Infer the types of column meta and table meta

[NullVoxPopuli-ai-agent]

An alternative to #200 that uses inference: no types value, no tableTypes() helper, and no type arguments. A declared type can replace each inferred type.

const table = headlessTable(this, {
  columns: () => [
    { key: 'name', meta: { align: 'left' }, Cell: GroupedCell },
    { key: 'age', meta: { align: 'right' }, Cell: AgeCell },
  ],
  data: () => this.people,
  meta: { currency: 'EUR' },
});

table.columns[0].meta;        // { align?: 'left' | 'right' } | undefined
table.config.meta?.currency;  // string | undefined
table.rows[0].data;           // Person, inferred as before

// <column.Cell @row={{row}} @column={{column}} @groupBy={{@groupBy}} />
// Glint reports a missing or wrong @groupBy, taken from GroupedCell's signature.

What each need from #200 becomes:

#200	Here
columnMeta slot	Inferred from each column's meta, then merged. ColumnConfig<Person, Meta>[] declares it instead. satisfies checks one column in place.
tableMeta slot	Inferred from the config's meta, added to TableMeta.
cellArgs slot	Inferred from the Cells: every arg besides @row and @column that any Cell takes. ColumnConfig<Person, ColumnMeta, TableMeta, CellArgs>[] declares it instead. Works with template-only components, class components, and ComponentLike.
Typed Cells	A Cell asks for the metas it reads through CellContext<T, ColumnMeta, TableMeta>. Each Cell is checked against the meta of its own column. TypeScript reports a column or table whose meta does not match. @row.table and @column.table both have the table's types.
@options	column.getOptionsForRow has the @options that the Cells ask for, as in johanrd#5.
Helpers keep the types	columns.for, next, previous, before, after, orderedColumnsFor.
Old code keeps working	Column<Person>, Table<Person>, ColumnConfig<Person>[] accept typed tables and columns, also with cell args. So the plugin helpers take them unchanged. No existing test changed.

A new docs page, "Typing meta and cells", covers what is inferred, how to check it, how to declare it, how to write Cells, and the limits. The TypeScript page links to it.

Limits

• In value and options, column.meta is unknown. Typed with the column meta, it would be any: the callbacks take their type from the plain column list next to the mapped one (see below), where the column meta is any. The table meta is typed there.
• TypeScript does not check that a column's options returns the @options its Cell asks for. The return type of options is only known after the Cell types are fixed.
• An inline <template> Cell has no types for its args. This is the same on main.
• A function inside a meta literal needs annotated parameters.

Implementation notes

• headlessTable infers a tuple of the column metas through a homomorphic mapped type with a const type parameter. ColumnMetaOf merges the tuple into one object type.
• The cell args come from a second type parameter, the column list as written. Another mapped tuple for the Cells made callback columns lose their meta when the table had a meta. Inferring the args from Glint's ComponentLike directly keeps only the Cell with the fewest args. CellArgsOf reads each Cell's named args (from the TemplateOnlyComponent signature, from Glint's [Invoke], or from args) and intersects them.
• The mapped list lives only in HeadlessTableConfig, the parameter type of headlessTable, so that TableConfig and table.config stay a plain interface. Next to it is a plain readonly ColumnConfig<DataType, any, Meta, any>[]. TypeScript does not infer DataType through the mapped list, so without the plain list DataType would come from data only.
• ColumnConfig has a type-only [rowType]?: T property, as in Add per-table types: column meta, table meta, cell args #200. Without it, a list typed ColumnConfig[] gives a row type that depends on the order TypeScript checks the program in. TS 5.6 to 6.0 failed on this in test-app.
• Column and Table default their cell args to any, so a bare Column<Person> means a column with any Cell. A narrower default made every plugin helper reject a column whose Cell takes args. Tables from headlessTable always carry their inferred args.
• row.table is typed through an intersection on the rows and in CellContext. Adding the type parameters to the Row class made Table invariant in its meta.
• CellContext has out variance annotations. Without them, TypeScript measures CellContext as unrelated to its meta parameters, because Column, Table and CellContext refer to each other in cycles. A Cell that needs table meta would then pass on a table without it.

Needs TypeScript 5.4 (NoInfer). The oldest version in the CI matrix is 5.6.

Checked:

• The type tests in table/src/-private/-type-tests/ (inferred-meta, cell-args, column-controls-cell) pass with TS 5.6, TS 6, and the TS 7 nightly.
• test-app/tests/integration/cells-test.gts renders Cells with extra args and with @options, and checks the Glint errors for a missing or wrong arg.
• test-app type-checks with TS 5.6, 6.0, and the TS 7 nightly. CI runs the full matrix.
• pnpm lint: pass.
• test-app tests: 189 of 189 pass.
• docs-app production build: pass.

🤖 Generated with Claude Code

[johanrd]

@NullVoxPopuli yes, this approach also seems to work well! Column meta and table meta are inferred from annotated column lists, and compared to #200, the types: tableTypes<…>() lines can be deleted.

One gap on cell args though. Some of our tables give a Cell args from the template, in addition to @row and @column. Some are per row, so table meta can't carry them:

<column.Cell @row={{row}} @column={{column}} @groupBy={{@groupBy}} @onUpdate={{this.updateFor row}} />

This type test fails on #202: the column config does not accept the Cell.

type GroupedCellArgs = CellContext<Person> & {
  groupBy: 'day' | 'week';
  onUpdate: (value: string) => void;
};
declare const GroupedCell: ComponentLike<GroupedCellArgs>;

const table = headlessTable({}, {
  columns: () => [{ key: 'name', Cell: GroupedCell }],
  data: () => people,
});

expectTypeOf(table.columns[0]!.Cell).toEqualTypeOf<
  ComponentLike<GroupedCellArgs> | undefined
>();

Maybe, a ColumnConfig type parameter for cell args that is not inferred?

[johanrd]

cfbb714 closes the cell args gap, thanks🎉 I then tried to migrate our app to this head, and met two blockers:

1. The plugin helpers reject a column whose Cell takes args. CellArgs sits in the args of Column.Cell, so it is contravariant, and Column<Person, unknown, unknown, {groupBy}> does not fit Column<DataType>

declare const GroupedCell: ComponentLike<CellContext<Person> & { groupBy: 'day' | 'week' }>;

const table = headlessTable({}, {
  columns: () => [{ key: 'name', Cell: GroupedCell }],
  data: () => people,
});

isVisible(table.columns[0]!); // error TS2345
sort(table.columns[0]!);      // error TS2345

See johanrd#4 for a possible fix.

2. getOptionsForRow still returns { defaultValue: string }. So the pattern the options doc comment describes cannot be rendered when the Cell declares a shape:

<column.Cell @row={{row}} @column={{column}} @options={{column.getOptionsForRow row}} />

See johanrd#5 for a possible fix.

[johanrd]

also johanrd#6

[NullVoxPopuli]

huzzah!

[johanrd]

great! now only missing CellArgsOf array branch (johanrd#6) similar to ColumnMetaOf

also some public exports could be added (johanrd#5)