@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.9

package/dist/types/TableFeatures.d.ts

@@ -12,7 +12,29 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
 type UnionToIntersectionOrEmpty<T> = [T] extends [never] ? {} : UnionToIntersection<T> & {};
 type ExtractFeatureMapTypes<TFeatures extends TableFeatures, TFeatureMap extends object> = IsAny<TFeatures> extends true ? UnionToIntersection<TFeatureMap[keyof TFeatureMap]> : UnionToIntersectionOrEmpty<TFeatureMap[Extract<keyof TFeatures, keyof TFeatureMap>]>;
 interface Plugins {}
-interface TableFeatures extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {}
+interface TableFeatures extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {
+  /**
+   * Type-only slot for declaring the type of this table's `options.meta`.
+   *
+   * Pass a phantom value: `tableMeta: {} as MyTableMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `TableMeta` interface applies.
+   */
+  tableMeta?: object;
+  /**
+   * Type-only slot for declaring the type of `columnDef.meta` for all columns
+   * of this table.
+   *
+   * Pass a phantom value: `columnMeta: {} as MyColumnMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `ColumnMeta` interface applies.
+   */
+  columnMeta?: object;
+}
 interface TableFeature {
   /**
    * Assigns Cell APIs to the cell prototype for memory-efficient method sharing.
@@ -49,5 +71,5 @@ interface TableFeature {
   initRowInstanceData?: <TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>) => void;
 }
 //#endregion
-export { ExtractFeatureMapTypes, Plugins, TableFeature, TableFeatures };
+export { ExtractFeatureMapTypes, IsAny, Plugins, TableFeature, TableFeatures };
 //# sourceMappingURL=TableFeatures.d.ts.map

package/dist/types/TableOptions.d.cts

@@ -25,7 +25,7 @@ import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnG
  * options are mixed in.
  */
 interface TableOptions_Core<TFeatures extends TableFeatures, TData extends RowData> extends TableOptions_Table<TFeatures, TData>, TableOptions_Cell, TableOptions_Columns<TFeatures, TData>, TableOptions_Rows<TFeatures, TData> {}
-type DebugKeysFor<TFeatures extends TableFeatures> = { [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean };
+type DebugKeysFor<TFeatures extends TableFeatures> = { [K in Exclude<keyof TFeatures & string, 'tableMeta' | 'columnMeta'> as `debug${Capitalize<K>}`]?: boolean };
 type DebugOptions<TFeatures extends TableFeatures> = {
   debugAll?: boolean;
   debugCache?: boolean;

package/dist/types/TableOptions.d.ts

@@ -25,7 +25,7 @@ import { TableOptions_ColumnGrouping } from "../features/column-grouping/columnG
  * options are mixed in.
  */
 interface TableOptions_Core<TFeatures extends TableFeatures, TData extends RowData> extends TableOptions_Table<TFeatures, TData>, TableOptions_Cell, TableOptions_Columns<TFeatures, TData>, TableOptions_Rows<TFeatures, TData> {}
-type DebugKeysFor<TFeatures extends TableFeatures> = { [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean };
+type DebugKeysFor<TFeatures extends TableFeatures> = { [K in Exclude<keyof TFeatures & string, 'tableMeta' | 'columnMeta'> as `debug${Capitalize<K>}`]?: boolean };
 type DebugOptions<TFeatures extends TableFeatures> = {
   debugAll?: boolean;
   debugCache?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/table-core",
-  "version": "9.0.0-beta.7",
+  "version": "9.0.0-beta.9",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "author": "Tanner Linsley",
   "license": "MIT",

package/src/core/coreFeatures.ts

@@ -7,7 +7,7 @@ import { coreTablesFeature } from './table/coreTablesFeature'
 import type { TableReactivityBindings } from '../reactivity'
 
 export interface CoreFeatures {
-  coreReativityFeature?: TableReactivityBindings
+  coreReactivityFeature?: TableReactivityBindings
   coreCellsFeature: typeof coreCellsFeature
   coreColumnsFeature: typeof coreColumnsFeature
   coreHeadersFeature: typeof coreHeadersFeature

package/src/core/table/constructTable.ts

@@ -33,11 +33,18 @@ export function constructTable<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {
-  const _reactivity = tableOptions.features.coreReativityFeature!
+  const _reactivity = tableOptions.features.coreReactivityFeature!
+
+  // `tableMeta`/`columnMeta` are type-only slots, not real features
+  const {
+    columnMeta: _columnMeta,
+    tableMeta: _tableMeta,
+    ...features
+  } = tableOptions.features
 
   const table = {
     _reactivity,
-    _features: { ...coreFeatures, ...tableOptions.features },
+    _features: { ...coreFeatures, ...features },
     _rowModels: {},
     _rowModelFns: {},
     baseAtoms: {},

package/src/core/table/coreTablesFeature.types.ts

@@ -3,7 +3,7 @@ import type { Atom, ReadonlyAtom, ReadonlyStore } from '@tanstack/store'
 import type { CoreFeatures } from '../coreFeatures'
 import type { RowModelFns } from '../../types/RowModelFns'
 import type { RowData, Updater } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
+import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { CachedRowModels, CreateRowModels_All } from '../../types/RowModel'
 import type { TableOptions } from '../../types/TableOptions'
 import type { TableState, TableState_All } from '../../types/TableState'
@@ -13,6 +13,24 @@ export interface TableMeta<
   TData extends RowData,
 > {}
 
+/**
+ * Resolves the type of `options.meta` for a feature set.
+ *
+ * When the features object declares a `tableMeta` type-only slot
+ * (`tableFeatures({ ..., tableMeta: {} as MyTableMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `TableMeta`
+ * interface.
+ */
+export type ExtractTableMeta<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> =
+  IsAny<TFeatures> extends true
+    ? TableMeta<TFeatures, TData>
+    : TFeatures extends { tableMeta: infer TMeta extends object }
+      ? TMeta
+      : TableMeta<TFeatures, TData>
+
 /**
  * A map of writable atoms, one per `TableState` slice. These are the internal
  * writable atoms that the library always writes to via `makeStateUpdater`.
@@ -116,8 +134,11 @@ export interface TableOptions_Table<
   ) => TableOptions<TFeatures, TData>
   /**
    * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.
+   *
+   * Declare its type per-table via the `tableMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `TableMeta`.
    */
-  readonly meta?: TableMeta<TFeatures, TData>
+  readonly meta?: ExtractTableMeta<TFeatures, TData>
   /**
    * Optionally provide externally managed values for individual state slices.
    *

package/src/features/row-selection/rowSelectionFeature.utils.ts

@@ -649,7 +649,7 @@ export function selectRowsFn<
   ): Array<Row<TFeatures, TData>> => {
     const result: Array<Row<TFeatures, TData>> = []
     for (let i = 0; i < rows.length; i++) {
-      let row = rows[i]!
+      const row = rows[i]!
       const isSelected = isRowSelected(row)
 
       if (isSelected) {
@@ -658,13 +658,18 @@ export function selectRowsFn<
       }
 
       if (row.subRows.length) {
-        row = {
-          ...row,
-          subRows: recurseRows(row.subRows, depth + 1),
+        // Always recurse — selected descendants of unselected parents must
+        // still be collected into flatRows/rowsById.
+        const newSubRows = recurseRows(row.subRows, depth + 1)
+
+        if (isSelected) {
+          // Preserve prototype chain so methods like getValue() remain accessible
+          const cloned = Object.create(Object.getPrototypeOf(row))
+          Object.assign(cloned, row)
+          cloned.subRows = newSubRows
+          result.push(cloned)
         }
-      }
-
-      if (isSelected) {
+      } else if (isSelected) {
         result.push(row)
       }
     }

package/src/helpers/metaHelper.ts

@@ -0,0 +1,24 @@
+/**
+ * A helper for declaring the `tableMeta`/`columnMeta` type-only slots in the
+ * `features` option without a type assertion.
+ *
+ * Equivalent to `{} as TMeta`, but reads as type-only at the call site and
+ * avoids `@typescript-eslint/no-unnecessary-type-assertion` false positives
+ * when the meta type has only optional properties (where an auto-fix removing
+ * the assertion would silently degrade the inferred meta type to `{}`).
+ *
+ * The returned value is a phantom — it is ignored and stripped from the
+ * table's registered features at runtime; only its type is used.
+ * @example
+ * ```
+ * import { metaHelper, tableFeatures, rowSortingFeature } from '@tanstack/react-table'
+ * const features = tableFeatures({
+ *   rowSortingFeature,
+ *   tableMeta: metaHelper<MyTableMeta>(),
+ *   columnMeta: metaHelper<MyColumnMeta>(),
+ * });
+ * ```
+ */
+export function metaHelper<TMeta extends object>(): TMeta {
+  return {} as TMeta
+}

package/src/helpers/tableFeatures.ts

@@ -4,10 +4,20 @@ import type { TableFeatures } from '../types/TableFeatures'
  * A helper function to help define the features that are to be imported and applied to a table instance.
  * Use this utility to make it easier to have the correct type inference for the features that are being imported.
  * **Note:** It is recommended to use this utility statically outside of a component.
+ *
+ * You can also declare per-table `meta` types here with the `tableMeta` and
+ * `columnMeta` type-only slots instead of using global declaration merging.
+ * The values are phantom (ignored and stripped at runtime) — only their types
+ * are used.
  * @example
  * ```
  * import { tableFeatures, columnVisibilityFeature, rowPinningFeature } from '@tanstack/react-table'
- * const features = tableFeatures({ columnVisibilityFeature, rowPinningFeature });
+ * const features = tableFeatures({
+ *   columnVisibilityFeature,
+ *   rowPinningFeature,
+ *   tableMeta: {} as { updateData: (rowIndex: number, columnId: string, value: unknown) => void },
+ *   columnMeta: {} as { align?: 'left' | 'right' },
+ * });
  * const table = useTable({ features, rowModels: {}, columns, data });
  * ```
  */

package/src/index.ts

@@ -22,6 +22,7 @@ export * from './types/type-utils'
 
 export * from './core/coreFeatures'
 export * from './helpers/columnHelper'
+export * from './helpers/metaHelper'
 export * from './helpers/tableFeatures'
 export * from './helpers/tableOptions'
 export * from './utils'

package/src/store-reactivity-bindings.ts

@@ -11,7 +11,7 @@ import type { TableReactivityBindings } from './core/reactivity/coreReactivityFe
  * import { storeReactivityBindings } from '@tanstack/table-core/store-reactivity-bindings'
  *
  * const table = constructTable({
- *   features: tableFeatures({ coreReativityFeature: storeReactivityBindings() }),
+ *   features: tableFeatures({ coreReactivityFeature: storeReactivityBindings() }),
  *   // ...
  * })
  * ```

package/src/types/ColumnDef.ts

@@ -1,5 +1,9 @@
 import type { CellData, RowData, UnionToIntersection } from './type-utils'
-import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
+import type {
+  ExtractFeatureMapTypes,
+  IsAny,
+  TableFeatures,
+} from './TableFeatures'
 import type { CellContext } from '../core/cells/coreCellsFeature.types'
 import type { HeaderContext } from '../core/headers/coreHeadersFeature.types'
 import type { ColumnDef_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
@@ -17,6 +21,25 @@ export interface ColumnMeta<
   TValue extends CellData = CellData,
 > {}
 
+/**
+ * Resolves the type of `columnDef.meta` for a feature set.
+ *
+ * When the features object declares a `columnMeta` type-only slot
+ * (`tableFeatures({ ..., columnMeta: {} as MyColumnMeta })`), that type wins.
+ * Otherwise this falls back to the global declaration-merged `ColumnMeta`
+ * interface.
+ */
+export type ExtractColumnMeta<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> =
+  IsAny<TFeatures> extends true
+    ? ColumnMeta<TFeatures, TData, TValue>
+    : TFeatures extends { columnMeta: infer TMeta extends object }
+      ? TMeta
+      : ColumnMeta<TFeatures, TData, TValue>
+
 /**
  * Reads a cell value from an original row object.
  *
@@ -96,8 +119,11 @@ interface ColumnDefBase_Core<
   cell?: ColumnDefTemplate<CellContext<TFeatures, TData, TValue>>
   /**
    * User-defined metadata available on the resolved column definition.
+   *
+   * Declare its type per-table via the `columnMeta` type-only slot on the
+   * `features` option, or globally via declaration merging on `ColumnMeta`.
    */
-  meta?: ColumnMeta<TFeatures, TData, TValue>
+  meta?: ExtractColumnMeta<TFeatures, TData, TValue>
 }
 
 export interface ColumnDef_FeatureMap<

package/src/types/TableFeatures.ts

@@ -7,7 +7,7 @@ import type { TableOptions_All } from './TableOptions'
 import type { TableState_All } from './TableState'
 import type { StockFeatures } from '../features/stockFeatures'
 
-type IsAny<T> = 0 extends 1 & T ? true : false
+export type IsAny<T> = 0 extends 1 & T ? true : false
 type UnionToIntersectionOrEmpty<T> = [T] extends [never]
   ? {}
   : UnionToIntersection<T> & {}
@@ -25,7 +25,29 @@ export type ExtractFeatureMapTypes<
 export interface Plugins {}
 
 export interface TableFeatures
-  extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {}
+  extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {
+  /**
+   * Type-only slot for declaring the type of this table's `options.meta`.
+   *
+   * Pass a phantom value: `tableMeta: {} as MyTableMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `TableMeta` interface applies.
+   */
+  tableMeta?: object
+  /**
+   * Type-only slot for declaring the type of `columnDef.meta` for all columns
+   * of this table.
+   *
+   * Pass a phantom value: `columnMeta: {} as MyColumnMeta`. The value itself is
+   * ignored and stripped from the table's registered features at runtime — only
+   * its type is used, inferred wherever `TFeatures` flows.
+   *
+   * When omitted, the global declaration-merged `ColumnMeta` interface applies.
+   */
+  columnMeta?: object
+}
 
 export interface TableFeature {
   /**

package/src/types/TableOptions.ts

@@ -34,7 +34,10 @@ export interface TableOptions_Core<
     TableOptions_Rows<TFeatures, TData> {}
 
 type DebugKeysFor<TFeatures extends TableFeatures> = {
-  [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean
+  [K in Exclude<
+    keyof TFeatures & string,
+    'tableMeta' | 'columnMeta' // type-only slots, not real features
+  > as `debug${Capitalize<K>}`]?: boolean
 }
 
 export type DebugOptions<TFeatures extends TableFeatures> = {