@tanstack/table-core 9.0.0-beta.5 → 9.0.0-beta.51

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

@@ -1,14 +1,12 @@
 import {
   assignPrototypeAPIs,
   assignTableAPIs,
+  makeObjectMap,
   makeStateUpdater,
 } from '../../utils'
 import {
-  cell_getIsAggregated,
   cell_getIsGrouped,
   cell_getIsPlaceholder,
-  column_getAggregationFn,
-  column_getAutoAggregationFn,
   column_getCanGroup,
   column_getGroupedIndex,
   column_getIsGrouped,
@@ -23,7 +21,7 @@ import {
 import type { TableFeature } from '../../types/TableFeatures'
 
 /**
- * Feature that adds column grouping state, aggregation defaults, and grouped row APIs.
+ * Feature that adds column grouping state and grouped row APIs.
  */
 export const columnGroupingFeature: TableFeature = {
   getInitialState: (initialState) => {
@@ -33,13 +31,6 @@ export const columnGroupingFeature: TableFeature = {
     }
   },
 
-  getDefaultColumnDef: () => {
-    return {
-      aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
-      aggregationFn: 'auto',
-    }
-  },
-
   getDefaultTableOptions: (table) => {
     return {
       onGroupingChange: makeStateUpdater('grouping', table),
@@ -55,9 +46,6 @@ export const columnGroupingFeature: TableFeature = {
       cell_getIsPlaceholder: {
         fn: (cell) => cell_getIsPlaceholder(cell),
       },
-      cell_getIsAggregated: {
-        fn: (cell) => cell_getIsAggregated(cell),
-      },
     })
   },
 
@@ -78,12 +66,6 @@ export const columnGroupingFeature: TableFeature = {
       column_getToggleGroupingHandler: {
         fn: (column) => column_getToggleGroupingHandler(column),
       },
-      column_getAutoAggregationFn: {
-        fn: (column) => column_getAutoAggregationFn(column),
-      },
-      column_getAggregationFn: {
-        fn: (column) => column_getAggregationFn(column),
-      },
     })
   },
 
@@ -99,7 +81,7 @@ export const columnGroupingFeature: TableFeature = {
   },
 
   initRowInstanceData: (row) => {
-    ;(row as any)._groupingValuesCache = {}
+    ;(row as any)._groupingValuesCache = makeObjectMap()
   },
 
   constructTableAPIs: (table) => {

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

@@ -1,16 +1,7 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { Table } from '../../types/Table'
-import type { BuiltInAggregationFn } from '../../fns/aggregationFns'
-import type {
-  CellData,
-  OnChangeFn,
-  RowData,
-  Updater,
-} from '../../types/type-utils'
+import type { OnChangeFn, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
-import type { Cell } from '../../types/Cell'
-import type { ColumnDefTemplate } from '../../types/ColumnDef'
 
 export type GroupingState = Array<string>
 
@@ -18,53 +9,10 @@ export interface TableState_ColumnGrouping {
   grouping: GroupingState
 }
 
-export interface RowModelFns_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  aggregationFns: Record<keyof AggregationFns, AggregationFn<TFeatures, TData>>
-}
-
-export interface AggregationFns {}
-
-export type AggregationFn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> = (
-  columnId: string,
-  leafRows: Array<Row<TFeatures, TData>>,
-  childRows: Array<Row<TFeatures, TData>>,
-) => any
-
-export type CustomAggregationFns<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> = Record<string, AggregationFn<TFeatures, TData>>
-
-export type AggregationFnOption<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> =
-  | 'auto'
-  | keyof AggregationFns
-  | BuiltInAggregationFn
-  | AggregationFn<TFeatures, TData>
-
 export interface ColumnDef_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
-  /**
-   * The cell to display each row for the column if the cell is an aggregate. If a function is passed, it will be passed a props object with the context of the cell and should return the property type for your adapter (the exact type depends on the adapter being used).
-   */
-  aggregatedCell?: ColumnDefTemplate<
-    ReturnType<Cell<TFeatures, TData, TValue>['getContext']>
-  >
-  /**
-   * The resolved aggregation function for the column.
-   */
-  aggregationFn?: AggregationFnOption<TFeatures, TData>
   /**
    * Allows this column to be added to grouping state.
    *
@@ -72,23 +20,19 @@ export interface ColumnDef_ColumnGrouping<
    */
   enableGrouping?: boolean
   /**
-   * Specify a value to be used for grouping rows on this column. If this option is not specified, the value derived from `accessorKey` / `accessorFn` will be used instead.
-   */
-  getGroupingValue?: (row: TData) => any
+   * Returns the value used to group rows for this column.
+   *
+   * When omitted, grouping uses the value derived from this column's
+   * `accessorKey` or `accessorFn`.
+   */
+  getGroupingValue?: (
+    originalRow: TData,
+    index: number,
+    row: Row<TFeatures, TData>,
+  ) => any
 }
 
-export interface Column_ColumnGrouping<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Returns the aggregation function for the column.
-   */
-  getAggregationFn: () => AggregationFn<TFeatures, TData> | undefined
-  /**
-   * Returns the automatically inferred aggregation function for the column.
-   */
-  getAutoAggregationFn: () => AggregationFn<TFeatures, TData> | undefined
+export interface Column_ColumnGrouping {
   /**
    * Checks whether this column can currently be grouped.
    */
@@ -132,10 +76,6 @@ export interface Row_ColumnGrouping {
 }
 
 export interface Cell_ColumnGrouping {
-  /**
-   * Checks whether this cell should render an aggregated value.
-   */
-  getIsAggregated: () => boolean
   /**
    * Checks whether this cell represents the active grouping column.
    */
@@ -175,8 +115,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,11 +131,11 @@ 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.
+   * Resolves the row model after grouping has been applied.
    */
   getGroupedRowModel: () => RowModel<TFeatures, TData>
   /**
@@ -204,23 +144,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/columnGroupingFeature.utils.ts

@@ -1,4 +1,4 @@
-import { cloneState, isFunction } from '../../utils'
+import { cloneState, hasOwn } from '../../utils'
 import type { Column_Internal } from '../../types/Column'
 import type { CellData, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -6,7 +6,6 @@ import type { Table_Internal } from '../../types/Table'
 import type { Row } from '../../types/Row'
 import type { Cell } from '../../types/Cell'
 import type {
-  AggregationFn,
   GroupingState,
   Row_ColumnGrouping,
 } from './columnGroupingFeature.types'
@@ -135,67 +134,6 @@ export function column_getToggleGroupingHandler<
   }
 }
 
-/**
- * Chooses a built-in aggregation function from the first core row value.
- *
- * Numeric columns default to `sum`, date-like values default to `extent`, and
- * other value types leave aggregation unspecified.
- *
- * @example
- * ```ts
- * const aggregationFn = column_getAutoAggregationFn(column)
- * ```
- */
-export function column_getAutoAggregationFn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(column: Column_Internal<TFeatures, TData, TValue>) {
-  const aggregationFns:
-    | Record<string, AggregationFn<TFeatures, TData>>
-    | undefined = column.table._rowModelFns.aggregationFns
-
-  const firstRow = column.table.getCoreRowModel().flatRows[0]
-
-  const value = firstRow?.getValue(column.id)
-
-  if (typeof value === 'number') {
-    return aggregationFns?.sum
-  }
-
-  if (Object.prototype.toString.call(value) === '[object Date]') {
-    return aggregationFns?.extent
-  }
-}
-
-/**
- * Resolves the aggregation function configured for a column.
- *
- * Function-valued `columnDef.aggregationFn` is returned directly, `'auto'`
- * delegates to `column_getAutoAggregationFn`, and string values are looked up in
- * the table's aggregation function registry.
- *
- * @example
- * ```ts
- * const aggregationFn = column_getAggregationFn(column)
- * ```
- */
-export function column_getAggregationFn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(column: Column_Internal<TFeatures, TData, TValue>) {
-  const aggregationFns:
-    | Record<string, AggregationFn<TFeatures, TData>>
-    | undefined = column.table._rowModelFns.aggregationFns
-
-  return isFunction(column.columnDef.aggregationFn)
-    ? column.columnDef.aggregationFn
-    : column.columnDef.aggregationFn === 'auto'
-      ? column_getAutoAggregationFn(column)
-      : aggregationFns?.[column.columnDef.aggregationFn as string]
-}
-
 /**
  * Routes a grouping updater through the table's grouping change handler.
  *
@@ -268,7 +206,7 @@ export function row_getGroupingValue<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData> & Partial<Row_ColumnGrouping>, columnId: string) {
-  if (row._groupingValuesCache?.hasOwnProperty(columnId)) {
+  if (row._groupingValuesCache && hasOwn(row._groupingValuesCache, columnId)) {
     return row._groupingValuesCache[columnId]
   }
 
@@ -284,6 +222,8 @@ export function row_getGroupingValue<
   if (row._groupingValuesCache) {
     row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(
       row.original,
+      row.index,
+      row,
     )
   }
 
@@ -329,26 +269,3 @@ export function cell_getIsPlaceholder<
 >(cell: Cell<TFeatures, TData, TValue>) {
   return !cell_getIsGrouped(cell) && column_getIsGrouped(cell.column)
 }
-
-/**
- * Checks whether this cell should render an aggregated value.
- *
- * Aggregated cells are non-placeholder, non-grouped cells on rows that have
- * subRows.
- *
- * @example
- * ```ts
- * const isAggregated = cell_getIsAggregated(cell)
- * ```
- */
-export function cell_getIsAggregated<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(cell: Cell<TFeatures, TData, TValue>) {
-  return (
-    !cell_getIsGrouped(cell) &&
-    !cell_getIsPlaceholder(cell) &&
-    !!cell.row.subRows.length
-  )
-}

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

@@ -1,18 +1,14 @@
-import { flattenBy, tableMemo } from '../../utils'
+import { hasOwn, makeObjectMap, tableMemo } from '../../utils'
 import { constructRow } from '../../core/rows/constructRow'
 import { table_getColumn } from '../../core/columns/coreColumnsFeature.utils'
 import { table_autoResetExpanded } from '../row-expanding/rowExpandingFeature.utils'
 import { table_autoResetPageIndex } from '../row-pagination/rowPaginationFeature.utils'
 import {
-  column_getAggregationFn,
-  row_getGroupingValue,
-} from './columnGroupingFeature.utils'
-import type { Column } from '../../types/Column'
-import type {
-  AggregationFn,
-  AggregationFns,
-  Row_ColumnGrouping,
-} from './columnGroupingFeature.types'
+  aggregateColumnValue,
+  normalizeAggregationRows,
+} from '../row-aggregation/rowAggregationFeature.utils'
+import { row_getGroupingValue } from './columnGroupingFeature.utils'
+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,16 @@ 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.
+ *
+ * When rowAggregationFeature is also registered, grouped rows use its shared
+ * executor for non-group values. Grouping remains useful without aggregation.
  */
 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 as unknown as Table_Internal<TFeatures, TData>
-    if (!table._rowModelFns.aggregationFns)
-      table._rowModelFns.aggregationFns = aggregationFns
     return tableMemo({
       feature: 'columnGroupingFeature',
       table,
@@ -41,6 +36,7 @@ export function createGroupedRowModel<
       memoDeps: () => [
         table.atoms.grouping?.get(),
         table.getPreGroupedRowModel(),
+        table.options.columns,
       ],
       fn: () => _createGroupedRowModel(table),
       onAfterUpdate: () => {
@@ -73,7 +69,7 @@ function _createGroupedRowModel<
 
   const groupedFlatRows: Array<Row<TFeatures, TData>> &
     Partial<Row_ColumnGrouping> = []
-  const groupedRowsById: Record<string, Row<TFeatures, TData>> = {}
+  const groupedRowsById = makeObjectMap<Row<TFeatures, TData>>()
 
   // Recursively group the data
   const groupUpRecursively = (
@@ -87,11 +83,17 @@ function _createGroupedRowModel<
       return rows.map((row) => {
         row.depth = depth
 
-        groupedFlatRows.push(row)
-        groupedRowsById[row.id] = row
-
+        // Every row is pushed into flatRows/rowsById exactly once, by its
+        // parent frame: rows returned here are pushed by the caller (the
+        // parent group's loop or the root loop), so only descendants below
+        // the terminal depth are pushed here.
         if (row.subRows.length) {
           row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id)
+          for (let i = 0; i < row.subRows.length; i++) {
+            const subRow = row.subRows[i]!
+            groupedFlatRows.push(subRow)
+            groupedRowsById[subRow.id] = subRow
+          }
         }
 
         return row
@@ -116,10 +118,7 @@ function _createGroupedRowModel<
           subRow.parentId = id
         })
 
-        // Flatten the leaf rows of the rows in this group
-        const leafRows = depth
-          ? flattenBy(groupedRows, (row) => row.subRows)
-          : groupedRows
+        const leafRows = normalizeAggregationRows(groupedRows, Infinity)
 
         const row = constructRow(
           table,
@@ -137,9 +136,13 @@ function _createGroupedRowModel<
           subRows,
           leafRows,
           getValue: (colId: string) => {
-            // Don't aggregate columns that are in the grouping
-            if (existingGrouping.includes(colId)) {
-              if (row._valuesCache.hasOwnProperty(colId)) {
+            const groupingIndex = existingGrouping.indexOf(colId)
+
+            // The active grouping column and ancestor grouping columns expose
+            // their inherited grouping values. Columns grouped at deeper
+            // levels are still eligible for aggregation here.
+            if (groupingIndex !== -1 && groupingIndex <= depth) {
+              if (hasOwn(row._valuesCache, colId)) {
                 return row._valuesCache[colId]
               }
 
@@ -151,27 +154,25 @@ function _createGroupedRowModel<
               return row._valuesCache[colId]
             }
 
-            if (row._groupingValuesCache?.hasOwnProperty(colId)) {
-              return row._groupingValuesCache[colId]
+            const aggregationCache = (row as any)._aggregationValuesCache as
+              | Record<string, unknown>
+              | undefined
+            if (aggregationCache && hasOwn(aggregationCache, colId)) {
+              return aggregationCache[colId]
             }
 
-            // Aggregate the values
-            const column = table.getColumn(colId)
-            const aggregateFn = column_getAggregationFn(
-              column as Column<TFeatures, TData, unknown>,
-            )
-
-            if (!row._groupingValuesCache) row._groupingValuesCache = {}
-
-            if (aggregateFn) {
-              row._groupingValuesCache[colId] = aggregateFn(
-                colId,
-                leafRows,
-                groupedRows,
-              )
-
-              return row._groupingValuesCache[colId]
-            }
+            const column = table.getColumn(colId) as any
+            if (typeof column.getAggregationFns !== 'function') return undefined
+
+            const cache = ((row as any)._aggregationValuesCache ??=
+              makeObjectMap())
+            cache[colId] = aggregateColumnValue({
+              subRows,
+              column,
+              groupingRow: row,
+              rows: groupedRows,
+            })
+            return cache[colId]
           },
         })
 

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

@@ -8,6 +8,7 @@ import {
   column_getIsFirstColumn,
   column_getIsLastColumn,
   getDefaultColumnOrderState,
+  table_getColumnIndexes,
   table_getOrderColumnsFn,
   table_resetColumnOrder,
   table_setColumnOrder,
@@ -35,13 +36,6 @@ export const columnOrderingFeature: TableFeature = {
     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),
@@ -54,6 +48,17 @@ export const columnOrderingFeature: TableFeature = {
 
   constructTableAPIs: (table) => {
     assignTableAPIs('columnOrderingFeature', table, {
+      table_getColumnIndexes: {
+        fn: () => table_getColumnIndexes(table),
+        memoDeps: () => [
+          table.options.columns,
+          table.atoms.columnOrder?.get(),
+          table.atoms.columnPinning?.get(),
+          table.atoms.columnVisibility?.get(),
+          table.atoms.grouping?.get(),
+          table.options.groupedColumnMode,
+        ],
+      },
       table_setColumnOrder: {
         fn: (updater) => table_setColumnOrder(table, updater),
       },

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

@@ -4,6 +4,25 @@ import type { ColumnPinningPosition } from '../column-pinning/columnPinningFeatu
 
 export type ColumnOrderState = Array<string>
 
+export interface ColumnIndexes {
+  /**
+   * Maps each visible leaf column id to its index in the full visible column list.
+   */
+  all: Record<string, number>
+  /**
+   * Maps each unpinned visible leaf column id to its index within the center region.
+   */
+  center: Record<string, number>
+  /**
+   * Maps each start-pinned visible leaf column id to its index within the start region.
+   */
+  start: Record<string, number>
+  /**
+   * Maps each end-pinned visible leaf column id to its index within the end region.
+   */
+  end: Record<string, number>
+}
+
 export interface TableState_ColumnOrdering {
   columnOrder: ColumnOrderState
 }
@@ -21,7 +40,7 @@ export interface Column_ColumnOrdering {
   /**
    * Finds this column's zero-based index among visible columns.
    *
-   * Pass `'left'`, `'center'`, or `'right'` to measure within that pinned
+   * Pass `'start'`, `'center'`, or `'end'` to measure within that pinned
    * region instead of the full visible leaf order.
    */
   getIndex: (position?: ColumnPinningPosition | 'center') => number
@@ -44,9 +63,16 @@ export interface ColumnOrderDefaultOptions {
 }
 
 export interface Table_ColumnOrdering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out _TFeatures extends TableFeatures,
+  in out _TData extends RowData,
 > {
+  /**
+   * Builds column-id to index records for each visible pinning region.
+   *
+   * This is the memoized source that `column.getIndex` reads from; most apps
+   * will not need to call it directly.
+   */
+  getColumnIndexes: () => ColumnIndexes
   /**
    * Resets `columnOrder` to `initialState.columnOrder`.
    *