@tanstack/table-core 9.0.0-beta.1 → 9.0.0-beta.10

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[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(

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,8 +3,12 @@ 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'
 
@@ -13,6 +17,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`.
@@ -69,14 +91,12 @@ export interface TableOptions_Table<
    * The feature modules registered on this table instance.
    *
    * Feature registration controls which state slices, options, and prototype
-   * APIs are available.
-   */
-  readonly features: TFeatures
-  /**
-   * Row model factories used by features such as filtering, grouping, sorting,
-   * expansion, and pagination.
+   * 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 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.
    *

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

@@ -59,7 +59,7 @@ export function table_reset<
     const keys = Object.keys(snap) as Array<keyof typeof snap>
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]!
-      ;(table.baseAtoms as any)[key].set(snap[key] as any)
+      ;(table.baseAtoms as any)[key].set(snap[key])
     }
   })
 }
@@ -112,11 +112,10 @@ export function table_setOptions<
 ): void {
   const newOptions = functionalUpdate(updater, table.options)
   // table static options that should never change after initialization
-  const { rowModels, features, atoms, initialState } = table.options
+  const { features, atoms, initialState } = table.options
   const mergedOptions = Object.assign(table_mergeOptions(table, newOptions), {
     // Once the table instance is created those properties should never change after initialization,
     // so we assign them back preserving the `table_mergeOptions` object reference
-    rowModels,
     features,
     atoms,
     initialState,

package/src/features/column-faceting/columnFacetingFeature.ts

@@ -11,110 +11,79 @@ import {
   table_getGlobalFacetedRowModel,
   table_getGlobalFacetedUniqueValues,
 } from './columnFacetingFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-import type { Column_Internal } from '../../types/Column'
-// import type {
-//   CachedRowModel_Faceted,
-//   Column_ColumnFaceting,
-//   CreateRowModel_Faceted,
-// } from './columnFacetingFeature.types'
-
-export interface ColumnFacetingFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // CachedRowModel: CachedRowModel_Faceted<TFeatures, TData>
-  // Column: Column_ColumnFaceting<TFeatures, TData>
-  // CreateRowModels: CreateRowModel_Faceted<TFeatures, TData>
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column faceting feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that derives faceted row models, unique values, and min/max values for filters.
  */
-export function constructColumnFacetingFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnFacetingFeatureConstructors<TFeatures, TData>> {
-  return {
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnFacetingFeature', prototype, table, {
-        column_getFacetedRowModel: {
-          memoDeps: () => [
-            table.getPreFilteredRowModel().rows,
-            table.atoms.columnFilters?.get(),
-            table.atoms.globalFilter?.get(),
-            table.getFilteredRowModel().rows,
-          ],
-          fn: (column) => column_getFacetedRowModel(column, column.table),
-        },
-        column_getFacetedMinMaxValues: {
-          memoDeps: (column: Column_Internal<TFeatures, TData>) => [
-            callMemoOrStaticFn(
-              column,
-              'getFacetedRowModel',
-              column_getFacetedRowModel,
-              column.table,
-            ).flatRows,
-          ],
-          fn: (column) => column_getFacetedMinMaxValues(column, column.table),
-        },
-        column_getFacetedUniqueValues: {
-          memoDeps: (column: Column_Internal<TFeatures, TData>) => [
-            callMemoOrStaticFn(
-              column,
-              'getFacetedRowModel',
-              column_getFacetedRowModel,
-              column.table,
-            ).flatRows,
-          ],
-          fn: (column) => column_getFacetedUniqueValues(column, column.table),
-        },
-      })
-    },
+export const columnFacetingFeature: TableFeature = {
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnFacetingFeature', prototype, table, {
+      column_getFacetedRowModel: {
+        memoDeps: () => [
+          table.getPreFilteredRowModel().rows,
+          table.atoms.columnFilters?.get(),
+          table.atoms.globalFilter?.get(),
+          table.getFilteredRowModel().rows,
+        ],
+        fn: (column) => column_getFacetedRowModel(column, column.table),
+      },
+      column_getFacetedMinMaxValues: {
+        memoDeps: (column) => [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            column.table,
+          ).flatRows,
+        ],
+        fn: (column) => column_getFacetedMinMaxValues(column, column.table),
+      },
+      column_getFacetedUniqueValues: {
+        memoDeps: (column) => [
+          callMemoOrStaticFn(
+            column,
+            'getFacetedRowModel',
+            column_getFacetedRowModel,
+            column.table,
+          ).flatRows,
+        ],
+        fn: (column) => column_getFacetedUniqueValues(column, column.table),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnFacetingFeature', table, {
-        table_getGlobalFacetedRowModel: {
-          memoDeps: () => [
-            table.getPreFilteredRowModel().rows,
-            table.atoms.columnFilters?.get(),
-            table.atoms.globalFilter?.get(),
-            table.getFilteredRowModel().rows,
-          ],
-          fn: () => table_getGlobalFacetedRowModel(table),
-        },
-        table_getGlobalFacetedMinMaxValues: {
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ],
-          fn: () => table_getGlobalFacetedMinMaxValues(table),
-        },
-        table_getGlobalFacetedUniqueValues: {
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getGlobalFacetedRowModel',
-              table_getGlobalFacetedRowModel,
-            ).flatRows,
-          ],
-          fn: () => table_getGlobalFacetedUniqueValues(table),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnFacetingFeature', table, {
+      table_getGlobalFacetedRowModel: {
+        memoDeps: () => [
+          table.getPreFilteredRowModel().rows,
+          table.atoms.columnFilters?.get(),
+          table.atoms.globalFilter?.get(),
+          table.getFilteredRowModel().rows,
+        ],
+        fn: () => table_getGlobalFacetedRowModel(table),
+      },
+      table_getGlobalFacetedMinMaxValues: {
+        memoDeps: () => [
+          callMemoOrStaticFn(
+            table,
+            'getGlobalFacetedRowModel',
+            table_getGlobalFacetedRowModel,
+          ).flatRows,
+        ],
+        fn: () => table_getGlobalFacetedMinMaxValues(table),
+      },
+      table_getGlobalFacetedUniqueValues: {
+        memoDeps: () => [
+          callMemoOrStaticFn(
+            table,
+            'getGlobalFacetedRowModel',
+            table_getGlobalFacetedRowModel,
+          ).flatRows,
+        ],
+        fn: () => table_getGlobalFacetedUniqueValues(table),
+      },
+    })
+  },
 }
-
-/**
- * The stock column faceting feature.
- *
- * Register this feature to add faceted row model, unique value, and min/max
- * helpers for column and global filter UIs.
- */
-export const columnFacetingFeature = constructColumnFacetingFeature()

package/src/features/column-faceting/columnFacetingFeature.types.ts

@@ -31,56 +31,23 @@ export interface Table_RowModels_Faceted<
   /**
    * Computes min/max numeric facet values for the active faceting context.
    *
-   * Requires a `facetedMinMaxValues` row-model factory in `rowModels`.
+   * Requires a `facetedMinMaxValues` row-model factory on the `features` option.
    */
   getFacetedMinMaxValues: () => undefined | [number, number]
   /**
    * Computes the row model used to derive facet values.
    *
-   * Requires a `facetedRowModel` row-model factory in `rowModels`.
+   * Requires a `facetedRowModel` row-model factory on the `features` option.
    */
   getFacetedRowModel: () => RowModel<TFeatures, TData>
   /**
    * Computes unique facet values and occurrence counts.
    *
-   * Requires a `facetedUniqueValues` row-model factory in `rowModels`.
+   * Requires a `facetedUniqueValues` row-model factory on the `features` option.
    */
   getFacetedUniqueValues: () => Map<any, number>
 }
 
-export interface CreateRowModel_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve faceted min/max values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedMinMaxValues()` or implement your own factory.
-   */
-  facetedMinMaxValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => [number, number] | undefined
-  /**
-   * Factory used to retrieve the faceted row model. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedRowModel()` or implement your own factory.
-   */
-  facetedRowModel?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => RowModel<TFeatures, TData>
-  /**
-   * Factory used to retrieve faceted unique values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedUniqueValues()` or implement your own factory.
-   */
-  facetedUniqueValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => Map<any, number>
-}
-
 export interface CachedRowModel_Faceted<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/features/column-faceting/columnFacetingFeature.utils.ts

@@ -24,7 +24,7 @@ export function column_getFacetedMinMaxValues<
   table: Table_Internal<TFeatures, TData>,
 ): [number, number] | undefined {
   const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, column.id) ??
+    table.options.features.facetedMinMaxValues?.(table, column.id) ??
     (() => undefined)
   return facetedMinMaxValuesFn()
 }
@@ -50,7 +50,7 @@ export function column_getFacetedRowModel<
   table: Table_Internal<TFeatures, TData>,
 ): RowModel<TFeatures, TData> {
   const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, column?.id ?? '') ??
+    table.options.features.facetedRowModel?.(table, column?.id ?? '') ??
     (() => table.getPreFilteredRowModel())
   return facetedRowModelFn()
 }
@@ -75,7 +75,7 @@ export function column_getFacetedUniqueValues<
   table: Table_Internal<TFeatures, TData>,
 ): Map<any, number> {
   const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, column.id) ??
+    table.options.features.facetedUniqueValues?.(table, column.id) ??
     (() => new Map<any, number>())
   return facetedUniqueValuesFn()
 }
@@ -96,7 +96,7 @@ export function table_getGlobalFacetedMinMaxValues<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): undefined | [number, number] {
   const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, '__global__') ??
+    table.options.features.facetedMinMaxValues?.(table, '__global__') ??
     (() => undefined)
   return facetedMinMaxValuesFn()
 }
@@ -118,7 +118,7 @@ export function table_getGlobalFacetedRowModel<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
   const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, '__global__') ??
+    table.options.features.facetedRowModel?.(table, '__global__') ??
     (() => table.getPreFilteredRowModel())
   return facetedRowModelFn()
 }
@@ -139,7 +139,7 @@ export function table_getGlobalFacetedUniqueValues<
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): Map<any, number> {
   const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, '__global__') ??
+    table.options.features.facetedUniqueValues?.(table, '__global__') ??
     (() => new Map())
   return facetedUniqueValuesFn()
 }

package/src/features/column-faceting/createFacetedMinMaxValues.ts

@@ -18,7 +18,7 @@ export function createFacetedMinMaxValues<
   columnId: string,
 ) => () => undefined | [number, number] {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),

package/src/features/column-faceting/createFacetedRowModel.ts

@@ -23,7 +23,7 @@ export function createFacetedRowModel<
   columnId: string,
 ) => () => RowModel<TFeatures, TData> {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       table,

package/src/features/column-faceting/createFacetedUniqueValues.ts

@@ -18,7 +18,7 @@ export function createFacetedUniqueValues<
   columnId: string,
 ) => () => Map<any, number> {
   return (_table, columnId) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
       table,