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

package/src/types/TableFeatures.ts

@@ -6,145 +6,290 @@ import type { Table_Internal } from './Table'
 import type { TableOptions_All } from './TableOptions'
 import type { TableState_All } from './TableState'
 import type { StockFeatures } from '../features/stockFeatures'
+import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'
+import type { FilterFn } from '../features/column-filtering/columnFilteringFeature.types'
+import type { SortFn } from '../features/row-sorting/rowSortingFeature.types'
+import type { AggregationFn } from '../features/column-grouping/columnGroupingFeature.types'
 
-export type ExtractFeatureTypes<
-  TKey extends keyof FeatureConstructors,
-  TFeatures extends TableFeatures,
-> = UnionToIntersection<
-  {
-    [K in keyof TFeatures]: K extends 'coreReativityFeature'
-      ? never
-      : TFeatures[K] extends TableFeature<infer FeatureConstructorOptions>
-        ? TKey extends keyof FeatureConstructorOptions
-          ? FeatureConstructorOptions[TKey]
-          : never
-        : any
-  }[keyof TFeatures]
->
-
-export interface FeatureConstructors {
-  CachedRowModel?: any
-  Cell?: any
-  Column?: any
-  ColumnDef?: any
-  CreateRowModels?: any
-  Header?: any
-  HeaderGroup?: any
-  Row?: any
-  RowModelFns?: any
-  Table?: any
-  TableOptions?: any
-  TableState?: any
-}
-
-export interface Plugins {}
-
-export interface TableFeatures
-  extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {}
-
-export type ConstructTableAPIs<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  table: Table_Internal<TFeatures, TData> &
-    Partial<TConstructors['Table']> & {
-      options: Partial<TConstructors['TableOptions']>
-    },
-) => void
+export type IsAny<T> = 0 extends 1 & T ? true : false
+type UnionToIntersectionOrEmpty<T> = [T] extends [never]
+  ? {}
+  : UnionToIntersection<T> & {}
 
-export type GetDefaultColumnDef<TConstructors extends FeatureConstructors> = <
+export type ExtractFeatureMapTypes<
   TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->() => ColumnDefBase_All<TFeatures, TData, TValue> &
-  Partial<TConstructors['ColumnDef']>
-
-export type GetDefaultTableOptions<TConstructors extends FeatureConstructors> =
-  <TFeatures extends TableFeatures, TData extends RowData>(
-    table: Table_Internal<TFeatures, TData> & Partial<TConstructors['Table']>,
-  ) => Partial<TableOptions_All<TFeatures, TData>> &
-    Partial<TConstructors['TableOptions']>
+  TFeatureMap extends object,
+> =
+  IsAny<TFeatures> extends true
+    ? UnionToIntersection<TFeatureMap[keyof TFeatureMap]>
+    : UnionToIntersectionOrEmpty<
+        TFeatureMap[Extract<keyof TFeatures, keyof TFeatureMap>]
+      >
 
-export type GetInitialState<TConstructors extends FeatureConstructors> = (
-  initialState: Partial<TableState_All> & Partial<TConstructors['TableState']>,
-) => TableState_All & Partial<TConstructors['TableState']>
-
-export type GetDefaultStateSelector<TConstructors extends FeatureConstructors> =
-  (
-    state: TableState_All,
-  ) => Partial<TableState_All> & Partial<TConstructors['TableState']>
-
-export type AssignCellPrototype<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  prototype: Record<string, any>,
-  table: Table_Internal<TFeatures, TData>,
-) => void
+/**
+ * This is an interface that you can delcaration-merge into to allow for custom plugins to be added to the table.
+ */
+export interface Plugins {}
 
-export type AssignColumnPrototype<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  prototype: Record<string, any>,
-  table: Table_Internal<TFeatures, TData>,
-) => void
+/**
+ * Keys of the `features` option that are not table features themselves.
+ *
+ * These slots carry per-table types (`tableMeta`, `columnMeta`), row model
+ * factories, and row model function registries. They are stripped from the
+ * table's registered `_features` at runtime and excluded from feature-derived
+ * options such as the generated `debug*` keys.
+ */
+export type NonFeatureKeys =
+  | 'aggregationFns'
+  | 'columnMeta'
+  | 'coreRowModel'
+  | 'expandedRowModel'
+  | 'facetedMinMaxValues'
+  | 'facetedRowModel'
+  | 'facetedUniqueValues'
+  | 'filterFns'
+  | 'filterMeta'
+  | 'filteredRowModel'
+  | 'groupedRowModel'
+  | 'paginatedRowModel'
+  | 'sortFns'
+  | 'sortedRowModel'
+  | 'tableMeta'
 
-export type AssignHeaderPrototype<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  prototype: Record<string, any>,
-  table: Table_Internal<TFeatures, TData>,
-) => void
+/**
+ * Maps each row model and fn registry slot to the feature(s) that must be
+ * registered alongside it in the same features object.
+ *
+ * Custom features can declaration-merge their own slot prerequisites into this
+ * interface to get the same validation from `tableFeatures()`.
+ */
+export interface FeatureSlotPrereqs {
+  aggregationFns: 'columnGroupingFeature'
+  columnResizingFeature: 'columnSizingFeature' // columnSizingFeature is required for columnResizingFeature
+  expandedRowModel: 'rowExpandingFeature'
+  facetedMinMaxValues: 'columnFacetingFeature'
+  facetedRowModel: 'columnFacetingFeature'
+  facetedUniqueValues: 'columnFacetingFeature'
+  filteredRowModel: 'columnFilteringFeature'
+  filterFns: 'columnFilteringFeature'
+  filterMeta: 'columnFilteringFeature'
+  globalFilteringFeature: 'columnFilteringFeature' // columnFilteringFeature is required for globalFilteringFeature
+  groupedRowModel: 'columnGroupingFeature'
+  paginatedRowModel: 'rowPaginationFeature'
+  sortedRowModel: 'rowSortingFeature'
+  sortFns: 'rowSortingFeature'
+}
 
-export type AssignRowPrototype<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  prototype: Record<string, any>,
-  table: Table_Internal<TFeatures, TData>,
-) => void
+/**
+ * Validates that every row model and fn registry slot in a features object is
+ * accompanied by its prerequisite feature.
+ *
+ * Slots whose prerequisite is missing have their type replaced with a literal
+ * error message, so the offending property fails to type-check with a message
+ * naming the feature that needs to be added.
+ */
+export type ValidateFeatureSlots<TFeatures extends TableFeatures> =
+  IsAny<TFeatures> extends true
+    ? {}
+    : {
+        [K in keyof TFeatures as K extends keyof FeatureSlotPrereqs
+          ? K
+          : never]: K extends keyof FeatureSlotPrereqs
+          ? [Extract<FeatureSlotPrereqs[K], keyof TFeatures>] extends [never]
+            ? `Error: '${K & string}' requires '${FeatureSlotPrereqs[K] &
+                string}' to be included in this table's features.`
+            : TFeatures[K]
+          : never
+      }
 
-export type InitRowInstanceData<TConstructors extends FeatureConstructors> = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  row: Row<TFeatures, TData> & Partial<TConstructors['Row']>,
-) => void
+export interface TableFeatures
+  extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {
+  /**
+   * Registry of aggregation functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `aggregationFn` on
+   * column definitions, with full inference. Spread the exported
+   * `aggregationFns` to register the built-in aggregation functions:
+   * `aggregationFns: { ...aggregationFns, myCustomAggregationFn }`.
+   */
+  aggregationFns?: Record<string, AggregationFn<any, any>>
+  /**
+   * 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
+  /**
+   * Factory for the table's core (unmodified) row model. Defaults to the
+   * built-in `createCoreRowModel()` when omitted.
+   */
+  coreRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Factory for the client-side expanded row model. Pass the exported
+   * `createExpandedRowModel()` or implement your own. Not needed for
+   * server-side expansion.
+   */
+  expandedRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Factory for per-column faceted min/max values. Pass the exported
+   * `createFacetedMinMaxValues()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedMinMaxValues?: (
+    table: any,
+    columnId: string,
+  ) => () => [number, number] | undefined
+  /**
+   * Factory for the per-column faceted row model. Pass the exported
+   * `createFacetedRowModel()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedRowModel?: (table: any, columnId: string) => () => RowModel<any, any>
+  /**
+   * Factory for per-column faceted unique values. Pass the exported
+   * `createFacetedUniqueValues()` or implement your own. Not needed for
+   * server-side faceting.
+   */
+  facetedUniqueValues?: (table: any, columnId: string) => () => Map<any, number>
+  /**
+   * Factory for the client-side filtered row model. Pass the exported
+   * `createFilteredRowModel()` or implement your own. Not needed for
+   * server-side filtering.
+   */
+  filteredRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Registry of filter functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `filterFn` on
+   * column definitions and the `globalFilterFn` option, with full inference.
+   * Spread the exported `filterFns` to register the built-in filter functions:
+   * `filterFns: { ...filterFns, myCustomFilterFn }`.
+   */
+  filterFns?: Record<string, FilterFn<any, any>>
+  /**
+   * Type-only slot for declaring the type of the filter meta that filter
+   * functions attach to rows via `addMeta` and that is read back from
+   * `row.columnFiltersMeta`.
+   *
+   * Pass a phantom value: `filterMeta: {} as MyFilterMeta` (or
+   * `metaHelper<MyFilterMeta>()`). The value itself is ignored and stripped
+   * from the table's registered features at runtime; only its type is used.
+   *
+   * When omitted, the global declaration-merged `FilterMeta` interface applies.
+   */
+  filterMeta?: object
+  /**
+   * Factory for the client-side grouped row model. Pass the exported
+   * `createGroupedRowModel()` or implement your own. Not needed for
+   * server-side grouping.
+   */
+  groupedRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Factory for the client-side paginated row model. Pass the exported
+   * `createPaginatedRowModel()` or implement your own. Not needed for
+   * server-side pagination.
+   */
+  paginatedRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Factory for the client-side sorted row model. Pass the exported
+   * `createSortedRowModel()` or implement your own. Not needed for
+   * server-side sorting.
+   */
+  sortedRowModel?: (table: any) => () => RowModel<any, any>
+  /**
+   * Registry of sorting functions available to this table by name.
+   *
+   * Keys registered here become the valid string values for `sortFn` on column
+   * definitions, with full inference. Spread the exported `sortFns` to register
+   * the built-in sorting functions: `sortFns: { ...sortFns, myCustomSortFn }`.
+   */
+  sortFns?: Record<string, SortFn<any, any>>
+  /**
+   * 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
+}
 
-export interface TableFeature<TConstructors extends FeatureConstructors> {
+export interface TableFeature {
   /**
    * Assigns Cell APIs to the cell prototype for memory-efficient method sharing.
    * This is called once per table to build a shared prototype for all cells.
    */
-  assignCellPrototype?: AssignCellPrototype<TConstructors>
+  assignCellPrototype?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+  >(
+    prototype: Record<string, any>,
+    table: Table_Internal<TFeatures, TData>,
+  ) => void
   /**
    * Assigns Column APIs to the column prototype for memory-efficient method sharing.
    * This is called once per table to build a shared prototype for all columns.
    */
-  assignColumnPrototype?: AssignColumnPrototype<TConstructors>
+  assignColumnPrototype?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+  >(
+    prototype: Record<string, any>,
+    table: Table_Internal<TFeatures, TData>,
+  ) => void
   /**
    * Assigns Header APIs to the header prototype for memory-efficient method sharing.
    * This is called once per table to build a shared prototype for all headers.
    */
-  assignHeaderPrototype?: AssignHeaderPrototype<TConstructors>
+  assignHeaderPrototype?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+  >(
+    prototype: Record<string, any>,
+    table: Table_Internal<TFeatures, TData>,
+  ) => void
   /**
    * Assigns Row APIs to the row prototype for memory-efficient method sharing.
    * This is called once per table to build a shared prototype for all rows.
    */
-  assignRowPrototype?: AssignRowPrototype<TConstructors>
+  assignRowPrototype?: <TFeatures extends TableFeatures, TData extends RowData>(
+    prototype: Record<string, any>,
+    table: Table_Internal<TFeatures, TData>,
+  ) => void
   /**
    * Assigns Table APIs to the table instance.
    * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
    */
-  constructTableAPIs?: ConstructTableAPIs<TConstructors>
-  getDefaultColumnDef?: GetDefaultColumnDef<TConstructors>
-  getDefaultTableOptions?: GetDefaultTableOptions<TConstructors>
-  getInitialState?: GetInitialState<TConstructors>
+  constructTableAPIs?: <TFeatures extends TableFeatures, TData extends RowData>(
+    table: Table_Internal<TFeatures, TData>,
+  ) => void
+  getDefaultColumnDef?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+    TValue extends CellData = CellData,
+  >() => ColumnDefBase_All<TFeatures, TData, TValue>
+  getDefaultTableOptions?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+  >(
+    table: Table_Internal<TFeatures, TData>,
+  ) => Partial<TableOptions_All<TFeatures, TData>>
+  getInitialState?: (initialState: Partial<TableState_All>) => TableState_All
   /**
    * Initializes instance-specific data on each row (e.g., caches).
    * Methods should be assigned via assignRowPrototype instead.
    */
-  initRowInstanceData?: InitRowInstanceData<TConstructors>
+  initRowInstanceData?: <
+    TFeatures extends TableFeatures,
+    TData extends RowData,
+  >(
+    row: Row<TFeatures, TData>,
+  ) => void
 }

package/src/types/TableOptions.ts

@@ -17,12 +17,11 @@ import type { TableOptions_RowPinning } from '../features/row-pinning/rowPinning
 import type { TableOptions_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
 import type { TableOptions_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
 import type { RowData, UnionToIntersection } from './type-utils'
-import type { ExtractFeatureTypes, TableFeatures } from './TableFeatures'
-
-export interface TableOptions_Plugins<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {}
+import type {
+  ExtractFeatureMapTypes,
+  NonFeatureKeys,
+  TableFeatures,
+} from './TableFeatures'
 
 /**
  * Core options that are always available on a table, before optional feature
@@ -39,7 +38,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,
+    NonFeatureKeys // meta, row model, and fn registry slots, not real features
+  > as `debug${Capitalize<K>}`]?: boolean
 }
 
 export type DebugOptions<TFeatures extends TableFeatures> = {
@@ -52,6 +54,35 @@ export type DebugOptions<TFeatures extends TableFeatures> = {
   debugTable?: boolean
 } & DebugKeysFor<CoreFeatures & TFeatures>
 
+export interface TableOptions_FeatureMap<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>
+  columnGroupingFeature: TableOptions_ColumnGrouping
+  columnOrderingFeature: TableOptions_ColumnOrdering
+  columnPinningFeature: TableOptions_ColumnPinning
+  columnResizingFeature: TableOptions_ColumnResizing
+  columnSizingFeature: TableOptions_ColumnSizing
+  columnVisibilityFeature: TableOptions_ColumnVisibility
+  globalFilteringFeature: TableOptions_GlobalFiltering<TFeatures, TData>
+  rowExpandingFeature: TableOptions_RowExpanding<TFeatures, TData>
+  rowPaginationFeature: TableOptions_RowPagination
+  rowPinningFeature: TableOptions_RowPinning<TFeatures, TData>
+  rowSelectionFeature: TableOptions_RowSelection<TFeatures, TData>
+  rowSortingFeature: TableOptions_RowSorting
+}
+
+export type TableOptions_FeatureMap_All<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = UnionToIntersection<
+  TableOptions_FeatureMap<TFeatures, TData>[keyof TableOptions_FeatureMap<
+    TFeatures,
+    TData
+  >]
+>
+
 /**
  * Complete table options for a specific feature set.
  *
@@ -63,58 +94,9 @@ export type TableOptions<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > = TableOptions_Core<TFeatures, TData> &
-  UnionToIntersection<
-    | ('columnFilteringFeature' extends keyof TFeatures
-        ? TableOptions_ColumnFiltering<TFeatures, TData>
-        : never)
-    | ('columnGroupingFeature' extends keyof TFeatures
-        ? TableOptions_ColumnGrouping
-        : never)
-    | ('columnOrderingFeature' extends keyof TFeatures
-        ? TableOptions_ColumnOrdering
-        : never)
-    | ('columnPinningFeature' extends keyof TFeatures
-        ? TableOptions_ColumnPinning
-        : never)
-    | ('columnResizingFeature' extends keyof TFeatures
-        ? TableOptions_ColumnResizing
-        : never)
-    | ('columnSizingFeature' extends keyof TFeatures
-        ? TableOptions_ColumnSizing
-        : never)
-    | ('columnVisibilityFeature' extends keyof TFeatures
-        ? TableOptions_ColumnVisibility
-        : never)
-    | ('globalFilteringFeature' extends keyof TFeatures
-        ? TableOptions_GlobalFiltering<TFeatures, TData>
-        : never)
-    | ('rowExpandingFeature' extends keyof TFeatures
-        ? TableOptions_RowExpanding<TFeatures, TData>
-        : never)
-    | ('rowPaginationFeature' extends keyof TFeatures
-        ? TableOptions_RowPagination
-        : never)
-    | ('rowPinningFeature' extends keyof TFeatures
-        ? TableOptions_RowPinning<TFeatures, TData>
-        : never)
-    | ('rowSelectionFeature' extends keyof TFeatures
-        ? TableOptions_RowSelection<TFeatures, TData>
-        : never)
-    | ('rowSortingFeature' extends keyof TFeatures
-        ? TableOptions_RowSorting
-        : never)
-  > &
-  ExtractFeatureTypes<'TableOptions', TFeatures> &
-  TableOptions_Plugins<TFeatures, TData> &
+  ExtractFeatureMapTypes<TFeatures, TableOptions_FeatureMap<TFeatures, TData>> &
   DebugOptions<TFeatures>
 
-// export type TableOptions<
-//   TFeatures extends TableFeatures,
-//   TData extends RowData,
-// > = TableOptions_Core<TFeatures, TData> &
-//   ExtractFeatureTypes<'TableOptions', TFeatures> &
-//   TableOptions_Plugins<TFeatures, TData>
-
 /**
  * Internal broad option shape used where feature code may need to read options
  * from features that are not present in the current generic feature set.
@@ -123,18 +105,4 @@ export type TableOptions_All<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > = TableOptions_Core<TFeatures, TData> &
-  Partial<
-    TableOptions_ColumnFiltering<TFeatures, TData> &
-      TableOptions_ColumnGrouping &
-      TableOptions_ColumnOrdering &
-      TableOptions_ColumnPinning &
-      TableOptions_ColumnResizing &
-      TableOptions_ColumnSizing &
-      TableOptions_ColumnVisibility &
-      TableOptions_GlobalFiltering<TFeatures, TData> &
-      TableOptions_RowExpanding<TFeatures, TData> &
-      TableOptions_RowPagination &
-      TableOptions_RowPinning<TFeatures, TData> &
-      TableOptions_RowSelection<TFeatures, TData> &
-      TableOptions_RowSorting
-  >
+  Partial<TableOptions_FeatureMap_All<TFeatures, TData>>

package/src/types/TableState.ts

@@ -1,4 +1,3 @@
-import type { UnionToIntersection } from './type-utils'
 import type { TableState_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
 import type { TableState_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
 import type { TableState_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types'
@@ -12,13 +11,23 @@ import type { TableState_RowPagination } from '../features/row-pagination/rowPag
 import type { TableState_RowPinning } from '../features/row-pinning/rowPinningFeature.types'
 import type { TableState_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
 import type { TableState_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
-import type { ExtractFeatureTypes, TableFeatures } from './TableFeatures'
+import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
 
-/**
- * Use this interface as a target for declaration merging to add your own state properties.
- * Note: This will affect the types of all tables in your project.
- */
-export interface TableState_Plugins<TFeatures extends TableFeatures> {}
+export interface TableState_FeatureMap {
+  columnFilteringFeature: TableState_ColumnFiltering
+  columnGroupingFeature: TableState_ColumnGrouping
+  columnOrderingFeature: TableState_ColumnOrdering
+  columnPinningFeature: TableState_ColumnPinning
+  columnResizingFeature: TableState_ColumnResizing
+  columnSizingFeature: TableState_ColumnSizing
+  columnVisibilityFeature: TableState_ColumnVisibility
+  globalFilteringFeature: TableState_GlobalFiltering
+  rowExpandingFeature: TableState_RowExpanding
+  rowPaginationFeature: TableState_RowPagination
+  rowPinningFeature: TableState_RowPinning
+  rowSelectionFeature: TableState_RowSelection
+  rowSortingFeature: TableState_RowSorting
+}
 
 /**
  * Complete table state for a specific feature set.
@@ -26,75 +35,13 @@ export interface TableState_Plugins<TFeatures extends TableFeatures> {}
  * State slices are included only when their feature is present in `TFeatures`,
  * then custom feature/plugin state is mixed in.
  */
-export type TableState<TFeatures extends TableFeatures> = UnionToIntersection<
-  | ('columnFilteringFeature' extends keyof TFeatures
-      ? TableState_ColumnFiltering
-      : never)
-  | ('columnGroupingFeature' extends keyof TFeatures
-      ? TableState_ColumnGrouping
-      : never)
-  | ('columnOrderingFeature' extends keyof TFeatures
-      ? TableState_ColumnOrdering
-      : never)
-  | ('columnPinningFeature' extends keyof TFeatures
-      ? TableState_ColumnPinning
-      : never)
-  | ('columnResizingFeature' extends keyof TFeatures
-      ? TableState_ColumnResizing
-      : never)
-  | ('columnSizingFeature' extends keyof TFeatures
-      ? TableState_ColumnSizing
-      : never)
-  | ('columnVisibilityFeature' extends keyof TFeatures
-      ? TableState_ColumnVisibility
-      : never)
-  | ('globalFilteringFeature' extends keyof TFeatures
-      ? TableState_GlobalFiltering
-      : never)
-  | ('rowExpandingFeature' extends keyof TFeatures
-      ? TableState_RowExpanding
-      : never)
-  | ('rowPaginationFeature' extends keyof TFeatures
-      ? TableState_RowPagination
-      : never)
-  | ('rowPinningFeature' extends keyof TFeatures
-      ? TableState_RowPinning
-      : never)
-  | ('rowSelectionFeature' extends keyof TFeatures
-      ? TableState_RowSelection
-      : never)
-  | ('rowSortingFeature' extends keyof TFeatures
-      ? TableState_RowSorting
-      : never)
-> &
-  ExtractFeatureTypes<'TableState', TFeatures> &
-  TableState_Plugins<TFeatures>
-
-// export type TableState<TFeatures extends TableFeatures> = ExtractFeatureTypes<
-// export type TableState<TFeatures extends TableFeatures> = ExtractFeatureTypes<
-//   'TableState',
-//   TFeatures
-// > &
-//   TableState_Plugins<TFeatures>
+export type TableState<TFeatures extends TableFeatures> =
+  ExtractFeatureMapTypes<TFeatures, TableState_FeatureMap>
 
 /**
- * Internal broad state shape containing every stock feature state slice.
+ * Internal broad state shape containing every registered feature state slice.
  *
  * Feature internals use this when they may need to inspect optional slices owned
  * by other features.
  */
-export type TableState_All = Partial<
-  TableState_ColumnFiltering &
-    TableState_ColumnGrouping &
-    TableState_ColumnOrdering &
-    TableState_ColumnPinning &
-    TableState_ColumnResizing &
-    TableState_ColumnSizing &
-    TableState_ColumnVisibility &
-    TableState_GlobalFiltering &
-    TableState_RowExpanding &
-    TableState_RowPagination &
-    TableState_RowPinning &
-    TableState_RowSelection &
-    TableState_RowSorting
->
+export type TableState_All = Partial<TableState<TableFeatures>>

package/src/utils.ts

@@ -427,13 +427,14 @@ export function assignPrototypeAPIs<
  */
 export function callMemoOrStaticFn<
   TObject extends Record<string, any>,
-  TStaticFn extends AnyFunction,
+  TArgs extends Array<any>,
+  TReturn,
 >(
   obj: TObject,
   fnKey: string,
-  staticFn: TStaticFn,
-  ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never
-): ReturnType<TStaticFn> {
+  staticFn: (obj: TObject, ...args: TArgs) => TReturn,
+  ...args: TArgs
+): TReturn {
   return (
     (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)
   )