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

package/src/features/column-grouping/columnGroupingFeature.types.ts

@@ -1,5 +1,4 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { Table } from '../../types/Table'
 import type { BuiltInAggregationFn } from '../../fns/aggregationFns'
 import type {
   CellData,
@@ -7,7 +6,7 @@ import type {
   RowData,
   Updater,
 } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
+import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
 import type { Cell } from '../../types/Cell'
 import type { ColumnDefTemplate } from '../../types/ColumnDef'
@@ -19,10 +18,10 @@ export interface TableState_ColumnGrouping {
 }
 
 export interface RowModelFns_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
-  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>
+  aggregationFns: Record<string, AggregationFn<TFeatures, TData>>
 }
 
 export interface AggregationFns {}
@@ -41,18 +40,34 @@ export type CustomAggregationFns<
   TData extends RowData,
 > = Record<string, AggregationFn<TFeatures, TData>>
 
+/**
+ * Resolves the valid string names for `columnDef.aggregationFn` for a feature
+ * set.
+ *
+ * When the features object declares an `aggregationFns` registry
+ * (`tableFeatures({ ..., aggregationFns })`), its keys are the only valid
+ * names; a name is only assignable if an aggregation function is actually
+ * registered for it. Otherwise this falls back to the global
+ * declaration-merged `AggregationFns` interface.
+ */
+export type ExtractAggregationFnKeys<TFeatures extends TableFeatures> =
+  IsAny<TFeatures> extends true
+    ? keyof AggregationFns | BuiltInAggregationFn
+    : TFeatures extends { aggregationFns: infer TAggregationFns extends object }
+      ? Extract<keyof TAggregationFns, string>
+      : keyof AggregationFns
+
 export type AggregationFnOption<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > =
   | 'auto'
-  | keyof AggregationFns
-  | BuiltInAggregationFn
+  | ExtractAggregationFnKeys<TFeatures>
   | AggregationFn<TFeatures, TData>
 
 export interface ColumnDef_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
   TValue extends CellData = CellData,
 > {
   /**
@@ -78,8 +93,8 @@ export interface ColumnDef_ColumnGrouping<
 }
 
 export interface Column_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Returns the aggregation function for the column.
@@ -175,8 +190,8 @@ export interface TableOptions_ColumnGrouping {
 export type GroupingColumnMode = false | 'reorder' | 'remove'
 
 export interface Table_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resets `grouping` to `initialState.grouping`.
@@ -191,8 +206,8 @@ export interface Table_ColumnGrouping<
 }
 
 export interface Table_RowModels_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resolves the row model after grouping and aggregation have been applied.
@@ -204,23 +219,9 @@ export interface Table_RowModels_Grouped<
   getPreGroupedRowModel: () => RowModel<TFeatures, TData>
 }
 
-export interface CreateRowModel_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve the grouped row model. If using server-side
-   * grouping, this is not required. To use client-side grouping, pass
-   * `createGroupedRowModel()` or implement your own factory.
-   */
-  groupedRowModel?: (
-    table: Table<TFeatures, TData>,
-  ) => () => RowModel<TFeatures, TData>
-}
-
 export interface CachedRowModel_Grouped<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   groupedRowModel: () => RowModel<TFeatures, TData>
 }

package/src/features/column-grouping/createGroupedRowModel.ts

@@ -8,11 +8,7 @@ import {
   row_getGroupingValue,
 } from './columnGroupingFeature.utils'
 import type { Column } from '../../types/Column'
-import type {
-  AggregationFn,
-  AggregationFns,
-  Row_ColumnGrouping,
-} from './columnGroupingFeature.types'
+import type { Row_ColumnGrouping } from './columnGroupingFeature.types'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 import type { Table, Table_Internal } from '../../types/Table'
@@ -23,17 +19,17 @@ import type { RowData } from '../../types/type-utils'
  * Creates a memoized grouped row model factory.
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+ *
+ * Register aggregation functions with the `aggregationFns` slot on the
+ * `features` option:
+ * `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel(), aggregationFns })`.
  */
 export function createGroupedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(
-  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>,
-): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
+>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
   return (_table) => {
-    const table: Table_Internal<TFeatures, TData> = _table
-    if (!table._rowModelFns.aggregationFns)
-      table._rowModelFns.aggregationFns = aggregationFns
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnGroupingFeature',
       table,

package/src/features/column-ordering/columnOrderingFeature.ts

@@ -12,94 +12,62 @@ import {
   table_resetColumnOrder,
   table_setColumnOrder,
 } from './columnOrderingFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   Column_ColumnOrdering,
-//   TableOptions_ColumnOrdering,
-//   TableState_ColumnOrdering,
-//   Table_ColumnOrdering,
-// } from './columnOrderingFeature.types'
-
-export interface ColumnOrderingFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // Column: Column_ColumnOrdering
-  // Table: Table_ColumnOrdering<TFeatures, TData>
-  // TableOptions: TableOptions_ColumnOrdering
-  // TableState: TableState_ColumnOrdering
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column ordering feature.
- *
- * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ * Feature that adds column ordering state and APIs for ordering leaf columns.
  */
-export function constructColumnOrderingFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnOrderingFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        columnOrder: getDefaultColumnOrderState(),
-        ...initialState,
-      }
-    },
+export const columnOrderingFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      columnOrder: getDefaultColumnOrderState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onColumnOrderChange: makeStateUpdater('columnOrder', table),
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onColumnOrderChange: makeStateUpdater('columnOrder', table),
+    }
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnOrderingFeature', prototype, table, {
-        column_getIndex: {
-          fn: (column, position) => column_getIndex(column, position),
-          memoDeps: (column, position) => [
-            position,
-            column.table.atoms.columnOrder?.get(),
-            column.table.atoms.columnPinning?.get(),
-            column.table.atoms.grouping?.get(),
-            column.table.atoms.columnVisibility?.get(),
-          ],
-        },
-        column_getIsFirstColumn: {
-          fn: (column, position) => column_getIsFirstColumn(column, position),
-        },
-        column_getIsLastColumn: {
-          fn: (column, position) => column_getIsLastColumn(column, position),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnOrderingFeature', prototype, table, {
+      column_getIndex: {
+        fn: (column, position) => column_getIndex(column, position),
+        memoDeps: (column, position) => [
+          position,
+          column.table.atoms.columnOrder?.get(),
+          column.table.atoms.columnPinning?.get(),
+          column.table.atoms.grouping?.get(),
+          column.table.atoms.columnVisibility?.get(),
+        ],
+      },
+      column_getIsFirstColumn: {
+        fn: (column, position) => column_getIsFirstColumn(column, position),
+      },
+      column_getIsLastColumn: {
+        fn: (column, position) => column_getIsLastColumn(column, position),
+      },
+    })
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnOrderingFeature', table, {
-        table_setColumnOrder: {
-          fn: (updater) => table_setColumnOrder(table, updater),
-        },
-        table_resetColumnOrder: {
-          fn: (defaultState) => table_resetColumnOrder(table, defaultState),
-        },
-        table_getOrderColumnsFn: {
-          fn: () => table_getOrderColumnsFn(table),
-          memoDeps: () => [
-            table.atoms.columnOrder?.get(),
-            table.atoms.grouping?.get(),
-            table.options.groupedColumnMode,
-          ],
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnOrderingFeature', table, {
+      table_setColumnOrder: {
+        fn: (updater) => table_setColumnOrder(table, updater),
+      },
+      table_resetColumnOrder: {
+        fn: (defaultState) => table_resetColumnOrder(table, defaultState),
+      },
+      table_getOrderColumnsFn: {
+        fn: () => table_getOrderColumnsFn(table),
+        memoDeps: () => [
+          table.atoms.columnOrder?.get(),
+          table.atoms.grouping?.get(),
+          table.options.groupedColumnMode,
+        ],
+      },
+    })
+  },
 }
-
-/**
- * The stock column ordering feature.
- *
- * Register this feature to add column order state and APIs for deriving the
- * ordered leaf column list alongside grouping and pinning.
- */
-export const columnOrderingFeature = constructColumnOrderingFeature()

package/src/features/column-ordering/columnOrderingFeature.types.ts

@@ -44,8 +44,8 @@ export interface ColumnOrderDefaultOptions {
 }
 
 export interface Table_ColumnOrdering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Resets `columnOrder` to `initialState.columnOrder`.