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

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

@@ -20,140 +20,96 @@ import {
   table_resetGrouping,
   table_setGrouping,
 } from './columnGroupingFeature.utils'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
-// import type {
-//   CachedRowModel_Grouped,
-//   Cell_ColumnGrouping,
-//   ColumnDef_ColumnGrouping,
-//   Column_ColumnGrouping,
-//   CreateRowModel_Grouped,
-//   RowModelFns_ColumnGrouping,
-//   Row_ColumnGrouping,
-//   TableOptions_ColumnGrouping,
-//   TableState_ColumnGrouping,
-//   Table_ColumnGrouping,
-// } from './columnGroupingFeature.types'
-
-export interface ColumnGroupingFeatureConstructors<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  // CachedRowModel: CachedRowModel_Grouped<TFeatures, TData>
-  // Cell: Cell_ColumnGrouping
-  // Column: Column_ColumnGrouping<TFeatures, TData>
-  // ColumnDef: ColumnDef_ColumnGrouping<TFeatures, TData>
-  // CreateRowModels: CreateRowModel_Grouped<TFeatures, TData>
-  // Row: Row_ColumnGrouping
-  // RowModelFns: RowModelFns_ColumnGrouping<TFeatures, TData>
-  // Table: Table_ColumnGrouping<TFeatures, TData>
-  // TableOptions: TableOptions_ColumnGrouping
-  // TableState: TableState_ColumnGrouping
-}
+import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Creates the stock column grouping 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 grouping state, aggregation defaults, and grouped row APIs.
  */
-export function constructColumnGroupingFeature<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(): TableFeature<ColumnGroupingFeatureConstructors<TFeatures, TData>> {
-  return {
-    getInitialState: (initialState) => {
-      return {
-        grouping: getDefaultGroupingState(),
-        ...initialState,
-      }
-    },
+export const columnGroupingFeature: TableFeature = {
+  getInitialState: (initialState) => {
+    return {
+      grouping: getDefaultGroupingState(),
+      ...initialState,
+    }
+  },
 
-    getDefaultColumnDef: () => {
-      return {
-        aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
-        aggregationFn: 'auto',
-      }
-    },
+  getDefaultColumnDef: () => {
+    return {
+      aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
+      aggregationFn: 'auto',
+    }
+  },
 
-    getDefaultTableOptions: (table) => {
-      return {
-        onGroupingChange: makeStateUpdater('grouping', table),
-        groupedColumnMode: 'reorder',
-      }
-    },
+  getDefaultTableOptions: (table) => {
+    return {
+      onGroupingChange: makeStateUpdater('grouping', table),
+      groupedColumnMode: 'reorder',
+    }
+  },
 
-    assignCellPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        cell_getIsGrouped: {
-          fn: (cell) => cell_getIsGrouped(cell),
-        },
-        cell_getIsPlaceholder: {
-          fn: (cell) => cell_getIsPlaceholder(cell),
-        },
-        cell_getIsAggregated: {
-          fn: (cell) => cell_getIsAggregated(cell),
-        },
-      })
-    },
+  assignCellPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      cell_getIsGrouped: {
+        fn: (cell) => cell_getIsGrouped(cell),
+      },
+      cell_getIsPlaceholder: {
+        fn: (cell) => cell_getIsPlaceholder(cell),
+      },
+      cell_getIsAggregated: {
+        fn: (cell) => cell_getIsAggregated(cell),
+      },
+    })
+  },
 
-    assignColumnPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        column_toggleGrouping: {
-          fn: (column) => column_toggleGrouping(column),
-        },
-        column_getCanGroup: {
-          fn: (column) => column_getCanGroup(column),
-        },
-        column_getIsGrouped: {
-          fn: (column) => column_getIsGrouped(column),
-        },
-        column_getGroupedIndex: {
-          fn: (column) => column_getGroupedIndex(column),
-        },
-        column_getToggleGroupingHandler: {
-          fn: (column) => column_getToggleGroupingHandler(column),
-        },
-        column_getAutoAggregationFn: {
-          fn: (column) => column_getAutoAggregationFn(column),
-        },
-        column_getAggregationFn: {
-          fn: (column) => column_getAggregationFn(column),
-        },
-      })
-    },
+  assignColumnPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      column_toggleGrouping: {
+        fn: (column) => column_toggleGrouping(column),
+      },
+      column_getCanGroup: {
+        fn: (column) => column_getCanGroup(column),
+      },
+      column_getIsGrouped: {
+        fn: (column) => column_getIsGrouped(column),
+      },
+      column_getGroupedIndex: {
+        fn: (column) => column_getGroupedIndex(column),
+      },
+      column_getToggleGroupingHandler: {
+        fn: (column) => column_getToggleGroupingHandler(column),
+      },
+      column_getAutoAggregationFn: {
+        fn: (column) => column_getAutoAggregationFn(column),
+      },
+      column_getAggregationFn: {
+        fn: (column) => column_getAggregationFn(column),
+      },
+    })
+  },
 
-    assignRowPrototype: (prototype, table) => {
-      assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
-        row_getIsGrouped: {
-          fn: (row) => row_getIsGrouped(row),
-        },
-        row_getGroupingValue: {
-          fn: (row, columnId) => row_getGroupingValue(row, columnId),
-        },
-      })
-    },
+  assignRowPrototype: (prototype, table) => {
+    assignPrototypeAPIs('columnGroupingFeature', prototype, table, {
+      row_getIsGrouped: {
+        fn: (row) => row_getIsGrouped(row),
+      },
+      row_getGroupingValue: {
+        fn: (row, columnId) => row_getGroupingValue(row, columnId),
+      },
+    })
+  },
 
-    initRowInstanceData: (row) => {
-      ;(row as any)._groupingValuesCache = {}
-    },
+  initRowInstanceData: (row) => {
+    ;(row as any)._groupingValuesCache = {}
+  },
 
-    constructTableAPIs: (table) => {
-      assignTableAPIs('columnGroupingFeature', table, {
-        table_setGrouping: {
-          fn: (updater) => table_setGrouping(table, updater),
-        },
-        table_resetGrouping: {
-          fn: (defaultState) => table_resetGrouping(table, defaultState),
-        },
-      })
-    },
-  }
+  constructTableAPIs: (table) => {
+    assignTableAPIs('columnGroupingFeature', table, {
+      table_setGrouping: {
+        fn: (updater) => table_setGrouping(table, updater),
+      },
+      table_resetGrouping: {
+        fn: (defaultState) => table_resetGrouping(table, defaultState),
+      },
+    })
+  },
 }
-
-/**
- * The stock column grouping feature.
- *
- * Register this feature to add grouping state, aggregation defaults, grouped
- * row-model support, and table/row/column/cell grouping APIs.
- */
-export const columnGroupingFeature = constructColumnGroupingFeature()

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

@@ -31,7 +31,7 @@ export function createGroupedRowModel<
   aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>,
 ): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {
   return (_table) => {
-    const table: Table_Internal<TFeatures, TData> = _table
+    const table = _table as unknown as Table_Internal<TFeatures, TData>
     if (!table._rowModelFns.aggregationFns)
       table._rowModelFns.aggregationFns = aggregationFns
     return tableMemo({

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