@tanstack/table-core 9.0.0-beta.2 → 9.0.0-beta.20

package/src/core/row-models/coreRowModelsFeature.utils.ts

@@ -7,7 +7,7 @@ import type { RowModel } from './coreRowModelsFeature.types'
 /**
  * Resolves the table's unmodified core row model.
  *
- * The factory is created once per table, either from `options.rowModels.coreRowModel`
+ * The factory is created once per table, either from the `coreRowModel` slot on the `features` option
  * or the built-in `createCoreRowModel()`, then reused for later calls.
  *
  * @example
@@ -21,7 +21,7 @@ export function table_getCoreRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.coreRowModel) {
     table._rowModels.coreRowModel =
-      table.options.rowModels?.coreRowModel?.(table) ??
+      table.options.features.coreRowModel?.(table) ??
       createCoreRowModel<TFeatures, TData>()(table)
   }
 
@@ -64,7 +64,7 @@ export function table_getFilteredRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.filteredRowModel) {
     table._rowModels.filteredRowModel =
-      table.options.rowModels?.filteredRowModel?.(table)
+      table.options.features.filteredRowModel?.(table)
   }
 
   if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {
@@ -108,7 +108,7 @@ export function table_getGroupedRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.groupedRowModel) {
     table._rowModels.groupedRowModel =
-      table.options.rowModels?.groupedRowModel?.(table)
+      table.options.features.groupedRowModel?.(table)
   }
 
   if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {
@@ -153,7 +153,7 @@ export function table_getSortedRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.sortedRowModel) {
     table._rowModels.sortedRowModel =
-      table.options.rowModels?.sortedRowModel?.(table)
+      table.options.features.sortedRowModel?.(table)
   }
 
   if (table.options.manualSorting || !table._rowModels.sortedRowModel) {
@@ -197,7 +197,7 @@ export function table_getExpandedRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.expandedRowModel) {
     table._rowModels.expandedRowModel =
-      table.options.rowModels?.expandedRowModel?.(table)
+      table.options.features.expandedRowModel?.(table)
   }
 
   if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {
@@ -243,7 +243,7 @@ export function table_getPaginatedRowModel<
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   if (!table._rowModels.paginatedRowModel) {
     table._rowModels.paginatedRowModel =
-      table.options.rowModels?.paginatedRowModel?.(table)
+      table.options.features.paginatedRowModel?.(table)
   }
 
   if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {

package/src/core/row-models/createCoreRowModel.ts

@@ -1,7 +1,7 @@
 import { constructRow } from '../rows/constructRow'
-import { tableMemo } from '../../utils'
+import { makeObjectMap, tableMemo } from '../../utils'
 import { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'
-import type { Table, Table_Internal } from '../../types/Table'
+import type { Table_Internal } from '../../types/Table'
 import type { RowModel } from './coreRowModelsFeature.types'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
@@ -15,9 +15,10 @@ import type { RowData } from '../../types/type-utils'
 export function createCoreRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
->(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
-  return (_table) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+>(): (
+  table: Table_Internal<TFeatures, TData>,
+) => () => RowModel<TFeatures, TData> {
+  return (table) => {
     return tableMemo({
       feature: 'coreRowModelsFeature',
       table,
@@ -43,7 +44,7 @@ function _createCoreRowModel<
   const rowModel: RowModel<TFeatures, TData> = {
     rows: [],
     flatRows: [],
-    rowsById: {},
+    rowsById: makeObjectMap(),
   }
 
   const accessRows = (

package/src/core/rows/constructRow.ts

@@ -1,3 +1,4 @@
+import { makeObjectMap } from '../../utils'
 import type { Table_Internal } from '../../types/Table'
 import type { RowData } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -47,8 +48,8 @@ export const constructRow = <
   >
 
   // Only assign instance-specific properties
-  row._uniqueValuesCache = {}
-  row._valuesCache = {}
+  row._uniqueValuesCache = makeObjectMap()
+  row._valuesCache = makeObjectMap()
   row.depth = depth
   row.id = id
   row.index = rowIndex

package/src/core/rows/coreRowsFeature.ts

@@ -11,79 +11,52 @@ import {
   table_getRow,
   table_getRowId,
 } from './coreRowsFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   Row_Row,
-//   TableOptions_Rows,
-//   Table_Rows,
-// } from './coreRowsFeature.types'
-
-export interface CoreRowsFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Row: Row_Row<TFeatures, TData>
-  // TableOptions: TableOptions_Rows<TFeatures, TData>
-  // Table: Table_Rows<TFeatures, TData>
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock core rows feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Core feature that creates row APIs for values, cells, and tree traversal.
  */
-export function constructCoreRowsFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<CoreRowsFeatureConstructors<TFeatures, TData>> {
-  return {
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('coreRowsFeature', prototype, table, {
-        row_getAllCellsByColumnId: {
-          fn: (row) => row_getAllCellsByColumnId(row),
-          memoDeps: (row) => [row.getAllCells()],
-        },
-        row_getAllCells: {
-          fn: (row) => row_getAllCells(row),
-          memoDeps: (row) => [row.table.getAllLeafColumns()],
-        },
-        row_getLeafRows: {
-          fn: (row) => row_getLeafRows(row),
-        },
-        row_getParentRow: {
-          fn: (row) => row_getParentRow(row),
-        },
-        row_getParentRows: {
-          fn: (row) => row_getParentRows(row),
-        },
-        row_getUniqueValues: {
-          fn: (row, columnId) => row_getUniqueValues(row, columnId),
-        },
-        row_getValue: {
-          fn: (row, columnId) => row_getValue(row, columnId),
-        },
-        row_renderValue: {
-          fn: (row, columnId) => row_renderValue(row, columnId),
-        },
-      })
-    },
-    constructTableAPIs: (table) => {
-      assignTableAPIs('coreRowsFeature', table, {
-        table_getRowId: {
-          fn: (originalRow, index, parent) =>
-            table_getRowId(originalRow, table, index, parent),
-        },
-        table_getRow: {
-          fn: (id: string, searchAll?: boolean) =>
-            table_getRow(table, id, searchAll),
-        },
-      })
-    },
-  }
+export const coreRowsFeature: TableFeature = {
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('coreRowsFeature', prototype, table, {
+      row_getAllCellsByColumnId: {
+        fn: (row) => row_getAllCellsByColumnId(row),
+        memoDeps: (row) => [row.getAllCells()],
+      },
+      row_getAllCells: {
+        fn: (row) => row_getAllCells(row),
+        memoDeps: (row) => [row.table.getAllLeafColumns()],
+      },
+      row_getLeafRows: {
+        fn: (row) => row_getLeafRows(row),
+      },
+      row_getParentRow: {
+        fn: (row) => row_getParentRow(row),
+      },
+      row_getParentRows: {
+        fn: (row) => row_getParentRows(row),
+      },
+      row_getUniqueValues: {
+        fn: (row, columnId) => row_getUniqueValues(row, columnId),
+      },
+      row_getValue: {
+        fn: (row, columnId) => row_getValue(row, columnId),
+      },
+      row_renderValue: {
+        fn: (row, columnId) => row_renderValue(row, columnId),
+      },
+    })
+  },
+  constructTableAPIs: (table) => {
+    assignTableAPIs('coreRowsFeature', table, {
+      table_getRowId: {
+        fn: (originalRow, index, parent) =>
+          table_getRowId(originalRow, table, index, parent),
+      },
+      table_getRow: {
+        fn: (id: string, searchAll?: boolean) =>
+          table_getRow(table, id, searchAll),
+      },
+    })
+  },
 }
-
-/**
- * The Core Rows feature provides the core row functionality.
- */
-export const coreRowsFeature = constructCoreRowsFeature()

package/src/core/rows/coreRowsFeature.types.ts

@@ -5,8 +5,8 @@ import type { Row } from '../../types/Row'
 import type { Cell } from '../../types/Cell'
 
 export interface Row_CoreProperties<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   _uniqueValuesCache: Record<string, unknown>
   _valuesCache: Record<string, unknown>
@@ -45,8 +45,8 @@ export interface Row_CoreProperties<
 }
 
 export interface Row_Row<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > extends Row_CoreProperties<TFeatures, TData> {
   /**
    * Builds a lookup of this row's cells keyed by leaf column id.
@@ -83,8 +83,8 @@ export interface Row_Row<
 }
 
 export interface TableOptions_Rows<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * This optional function is used to derive a unique ID for any given row. If not provided the rows index is used (nested rows join together with `.` using their grandparents' index eg. `index.index.index`). If you need to identify individual rows that are originating from any server-side operations, it's suggested you use this function to return an ID that makes sense regardless of network IO/ambiguity eg. a userId, taskId, database ID field, etc.
@@ -106,8 +106,8 @@ export interface TableOptions_Rows<
 }
 
 export interface Table_Rows<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   getRowId: (_: TData, index: number, parent?: Row<TFeatures, TData>) => string
   /**

package/src/core/rows/coreRowsFeature.utils.ts

@@ -1,4 +1,4 @@
-import { flattenBy } from '../../utils'
+import { flattenBy, hasOwn, makeObjectMap } from '../../utils'
 import { constructCell } from '../cells/constructCell'
 import type { Table_Internal } from '../../types/Table'
 import type { RowData } from '../../types/type-utils'
@@ -21,7 +21,7 @@ export function row_getValue<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>, columnId: string) {
-  if (row._valuesCache.hasOwnProperty(columnId)) {
+  if (hasOwn(row._valuesCache, columnId)) {
     return row._valuesCache[columnId]
   }
 
@@ -51,7 +51,7 @@ export function row_getUniqueValues<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>, columnId: string) {
-  if (row._uniqueValuesCache.hasOwnProperty(columnId)) {
+  if (hasOwn(row._uniqueValuesCache, columnId)) {
     return row._uniqueValuesCache[columnId]
   }
 
@@ -192,7 +192,7 @@ export function row_getAllCellsByColumnId<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>) {
-  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}
+  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()
   const cells = row.getAllCells()
   for (let i = 0; i < cells.length; i++) {
     const cell = cells[i]!

package/src/core/table/constructTable.ts

@@ -7,7 +7,7 @@ import type { RowData } from '../../types/type-utils'
 import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { TableOptions } from '../../types/TableOptions'
-import type { TableState } from '../../types/TableState'
+import type { TableState, TableState_All } from '../../types/TableState'
 
 /**
  * Builds the initial table state from registered features and user initial state.
@@ -33,18 +33,40 @@ 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!
+
+  // Strip the non-feature slots: type-only meta slots, row model factories,
+  // and row model fn registries all live on the `features` option but are not
+  // table features themselves.
+  const {
+    aggregationFns,
+    columnMeta: _columnMeta,
+    coreRowModel,
+    expandedRowModel,
+    facetedMinMaxValues,
+    facetedRowModel,
+    facetedUniqueValues,
+    filterFns,
+    filterMeta: _filterMeta,
+    filteredRowModel,
+    groupedRowModel,
+    paginatedRowModel,
+    sortFns,
+    sortedRowModel,
+    tableMeta: _tableMeta,
+    ...features
+  } = tableOptions.features
 
   const table = {
     _reactivity,
-    _features: { ...coreFeatures, ...tableOptions.features },
+    _features: { ...coreFeatures, ...features },
     _rowModels: {},
-    _rowModelFns: {},
+    _rowModelFns: { aggregationFns, filterFns, sortFns },
     baseAtoms: {},
     atoms: {},
-  } as Table_Internal<TFeatures, TData>
+  } as unknown as Table_Internal<TFeatures, TData>
 
-  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)
+  const featuresList: Array<TableFeature> = Object.values(table._features)
 
   const defaultOptions = featuresList.reduce((obj, feature) => {
     return Object.assign(obj, feature.getDefaultTableOptions?.(table))
@@ -100,7 +122,7 @@ export function constructTable<
   )
 
   const stateKeys = Object.keys(table.initialState) as Array<
-    string & keyof TableState<TFeatures>
+    string & keyof TableState_All
   >
 
   for (let i = 0; i < stateKeys.length; i++) {
@@ -115,11 +137,14 @@ export function constructTable<
     // create readonly derived atom: on each get(), read either external atom or base atom
     ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(
       () => {
-        const externalAtom = table.options.atoms?.[key]
+        const externalAtoms = table.options.atoms as
+          | Partial<Record<keyof TableState_All, Atom<unknown>>>
+          | undefined
+        const externalAtom = externalAtoms?.[key]
         if (externalAtom) {
           return externalAtom.get()
         }
-        return table.baseAtoms[key].get()
+        return table.baseAtoms[key]!.get()
       },
       { debugName: `table/atoms/${key}` },
     )
@@ -130,10 +155,10 @@ export function constructTable<
   table.store = atomToStore(
     _reactivity.createReadonlyAtom(
       () => {
-        const snapshot = {} as TableState<TFeatures>
+        const snapshot = {} as TableState<TFeatures> & TableState_All
         for (let i = 0; i < stateKeys.length; i++) {
           const key = stateKeys[i]!
-          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key].get()
+          ;(snapshot as Record<string, unknown>)[key] = table.atoms[key]!.get()
         }
         return snapshot
       },
@@ -146,7 +171,19 @@ export function constructTable<
     (tableOptions.debugAll || tableOptions.debugTable)
   ) {
     const features = Object.keys(table._features)
-    const rowModels = Object.keys(table.options.rowModels || {})
+    const rowModels = Object.entries({
+      coreRowModel,
+      filteredRowModel,
+      groupedRowModel,
+      sortedRowModel,
+      expandedRowModel,
+      paginatedRowModel,
+      facetedRowModel,
+      facetedMinMaxValues,
+      facetedUniqueValues,
+    })
+      .filter(([, factory]) => factory)
+      .map(([key]) => key)
     const states = Object.keys(table.initialState)
 
     console.log(
@@ -165,5 +202,5 @@ export function constructTable<
     featuresList[i]!.constructTableAPIs?.(table)
   }
 
-  return table
+  return table as unknown as Table<TFeatures, TData>
 }

package/src/core/table/coreTablesFeature.ts

@@ -1,41 +1,19 @@
 import { assignTableAPIs } from '../../utils'
 import { table_reset, table_setOptions } from './coreTablesFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'
-
-export interface CoreTablesFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Table: Table_Table<TFeatures, TData>
-  // TableOptions: TableOptions_Table<TFeatures, TData>
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock core tables feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Core feature that adds base table instance APIs such as reset and setOptions.
  */
-export function constructCoreTablesFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {
-  return {
-    constructTableAPIs: (table) => {
-      assignTableAPIs('coreTablesFeature', table, {
-        table_reset: {
-          fn: () => table_reset(table),
-        },
-        table_setOptions: {
-          fn: (updater) => table_setOptions(table, updater),
-        },
-      })
-    },
-  }
+export const coreTablesFeature: TableFeature = {
+  constructTableAPIs: (table) => {
+    assignTableAPIs('coreTablesFeature', table, {
+      table_reset: {
+        fn: () => table_reset(table),
+      },
+      table_setOptions: {
+        fn: (updater) => table_setOptions(table, updater),
+      },
+    })
+  },
 }
-
-/**
- * The Core Tables feature provides the core table functionality for handling state and options.
- */
-export const coreTablesFeature = constructCoreTablesFeature()

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

@@ -3,15 +3,37 @@ 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 { CachedRowModels, CreateRowModels_All } from '../../types/RowModel'
+import type {
+  IsAny,
+  TableFeatures,
+  ValidateFeatureSlots,
+} from '../../types/TableFeatures'
+import type { CachedRowModels } from '../../types/RowModel'
 import type { TableOptions } from '../../types/TableOptions'
 import type { TableState, TableState_All } from '../../types/TableState'
 
 export interface TableMeta<
+  in out TFeatures extends TableFeatures,
+  in out 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
@@ -62,21 +84,19 @@ export type ExternalAtoms_All = Partial<{
 }>
 
 export interface TableOptions_Table<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * The feature modules registered on this table instance.
    *
    * Feature registration controls which state slices, options, and prototype
-   * APIs are available.
+   * APIs are available. This object also carries the table's row model
+   * factories (`sortedRowModel`, `filteredRowModel`, etc.), row model function
+   * registries (`sortFns`, `filterFns`, `aggregationFns`), and type-only meta
+   * slots (`tableMeta`, `columnMeta`).
    */
-  readonly features: TFeatures
-  /**
-   * Row model factories used by features such as filtering, grouping, sorting,
-   * expansion, and pagination.
-   */
-  readonly rowModels?: CreateRowModels_All<TFeatures, TData>
+  readonly features: TFeatures & ValidateFeatureSlots<TFeatures>
   /**
    * Optionally, provide your own external writable atoms for individual state slices.
    * When an atom is provided for a given slice, it takes precedence over `options.state[key]`
@@ -116,8 +136,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.
    *
@@ -129,8 +152,8 @@ export interface TableOptions_Table<
 }
 
 export interface Table_CoreProperties<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Table reactivity bindings for interacting with TanStack Store.
@@ -197,8 +220,8 @@ export interface Table_CoreProperties<
 }
 
 export interface Table_Table<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > extends Table_CoreProperties<TFeatures, TData> {
   /**
    * Resets the table's internal base atoms to `table.initialState`.