@tanstack/table-core 9.0.0-beta.47 → 9.0.0-beta.49

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

@@ -1,16 +1,7 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { BuiltInAggregationFn } from '../../fns/aggregationFns'
-import type {
-  CellData,
-  OnChangeFn,
-  RowData,
-  TransformDataValueFn,
-  Updater,
-} from '../../types/type-utils'
-import type { IsAny, TableFeatures } from '../../types/TableFeatures'
+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,123 +9,10 @@ export interface TableState_ColumnGrouping {
   grouping: GroupingState
 }
 
-export interface RowModelFns_ColumnGrouping<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  aggregationFns: Record<string, AggregationFn<TFeatures, TData>>
-}
-
-export interface AggregationFns {}
-
-export interface AggregationFn<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  (
-    columnId: string,
-    leafRows: Array<Row<TFeatures, TData>>,
-    childRows: Array<Row<TFeatures, TData>>,
-  ): any
-  /**
-   * Normalizes each row's value before it is aggregated. Only honored by
-   * aggregation functions built with `constructAggregationFn` (including the
-   * value-based built-in aggregation functions).
-   */
-  resolveDataValue?: TransformDataValueFn
-}
-
-/**
- * The definition object accepted by `constructAggregationFn`.
- *
- * `aggregate` is a value-level reducer: it receives the rows' (resolved)
- * values instead of the rows themselves, so normalization concerns stay in
- * `resolveDataValue`.
- */
-export interface AggregationFnDef<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  aggregate: (
-    values: Array<any>,
-    rows: Array<Row<TFeatures, TData>>,
-    columnId: string,
-  ) => any
-  /**
-   * Which of the group's rows feed the aggregation: all of its `leafRows`
-   * (the default) or its immediate `childRows`. For nested groups, child rows
-   * expose already-aggregated values, which is faster for reaggregatable
-   * computations like sums and extents.
-   */
-  fromRows?: 'leafRows' | 'childRows'
-  resolveDataValue?: TransformDataValueFn
-}
-
-/**
- * The shape returned by `constructAggregationFn`: an `AggregationFn` with its
- * definition attached, so variants can be built by spreading it into another
- * `constructAggregationFn` call.
- *
- * The call signature is generic so a created aggregation function can be used
- * with any table's rows, regardless of the feature set it was defined
- * against.
- */
-export interface CreatedAggregationFn<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> extends AggregationFnDef<TFeatures, TData> {
-  <TRowFeatures extends TableFeatures, TRowData extends RowData>(
-    columnId: string,
-    leafRows: Array<Row<TRowFeatures, TRowData>>,
-    childRows: Array<Row<TRowFeatures, TRowData>>,
-  ): any
-}
-
-export type CustomAggregationFns<
-  TFeatures extends TableFeatures,
-  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'
-  | ExtractAggregationFnKeys<TFeatures>
-  | AggregationFn<TFeatures, TData>
-
 export interface ColumnDef_ColumnGrouping<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
-  TValue extends CellData = CellData,
 > {
-  /**
-   * 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.
    *
@@ -154,18 +32,7 @@ export interface ColumnDef_ColumnGrouping<
   ) => any
 }
 
-export interface Column_ColumnGrouping<
-  in out TFeatures extends TableFeatures,
-  in out 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.
    */
@@ -209,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.
    */
@@ -272,7 +135,7 @@ export interface Table_RowModels_Grouped<
   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>
   /**

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

@@ -1,4 +1,4 @@
-import { cloneState, hasOwn, 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,103 +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.
- *
- * The chosen aggregation function is looked up in the table's
- * `aggregationFns` registry. When it is not registered there, this returns
- * `undefined` and warns in development instead of substituting a different
- * aggregation function.
- *
- * @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)
-
-  let aggregationFnName: string | undefined
-
-  if (typeof value === 'number') {
-    aggregationFnName = 'sum'
-  } else if (Object.prototype.toString.call(value) === '[object Date]') {
-    aggregationFnName = 'extent'
-  }
-
-  if (!aggregationFnName) {
-    return undefined
-  }
-
-  const aggregationFn = aggregationFns?.[aggregationFnName]
-
-  if (process.env.NODE_ENV === 'development' && !aggregationFn) {
-    console.warn(
-      `aggregationFn '${aggregationFnName}' (auto) for column '${column.id}' is not registered`,
-    )
-  }
-
-  return aggregationFn
-}
-
-/**
- * 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
-
-  if (isFunction(column.columnDef.aggregationFn)) {
-    return column.columnDef.aggregationFn
-  }
-
-  if (column.columnDef.aggregationFn === 'auto') {
-    return column_getAutoAggregationFn(column)
-  }
-
-  const aggregationFn =
-    aggregationFns?.[column.columnDef.aggregationFn as string]
-
-  if (
-    process.env.NODE_ENV === 'development' &&
-    !aggregationFn &&
-    column.columnDef.aggregationFn != null
-  ) {
-    console.warn(
-      `aggregationFn '${String(column.columnDef.aggregationFn)}' for column '${column.id}' is not registered`,
-    )
-  }
-
-  return aggregationFn
-}
-
 /**
  * Routes a grouping updater through the table's grouping change handler.
  *
@@ -367,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,13 +1,13 @@
-import { flattenBy, hasOwn, makeObjectMap, 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'
+  aggregateColumnValue,
+  normalizeAggregationRows,
+} from '../aggregation/aggregationFeature.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'
@@ -20,12 +20,8 @@ import type { RowData } from '../../types/type-utils'
  *
  * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
  *
- * Register the aggregation functions you use with the `aggregationFns` slot
- * on the `features` option:
- * `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel(), aggregationFns: { sum: aggregationFn_sum } })`.
- * Importing individual `aggregationFn_*` functions keeps unused built-ins out
- * of your bundle; aggregation functions passed directly to the
- * `aggregationFn` column option need no registration at all.
+ * When aggregationFeature is also registered, grouped rows use its shared
+ * executor for non-group values. Grouping remains useful without aggregation.
  */
 export function createGroupedRowModel<
   TFeatures extends TableFeatures,
@@ -40,6 +36,7 @@ export function createGroupedRowModel<
       memoDeps: () => [
         table.atoms.grouping?.get(),
         table.getPreGroupedRowModel(),
+        table.options.columns,
       ],
       fn: () => _createGroupedRowModel(table),
       onAfterUpdate: () => {
@@ -121,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)
 
         const row = constructRow(
           table,
@@ -142,8 +136,12 @@ function _createGroupedRowModel<
           subRows,
           leafRows,
           getValue: (colId: string) => {
-            // Don't aggregate columns that are in the grouping
-            if (existingGrouping.includes(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]
               }
@@ -156,32 +154,25 @@ function _createGroupedRowModel<
               return row._valuesCache[colId]
             }
 
-            if (
-              row._groupingValuesCache &&
-              hasOwn(row._groupingValuesCache, colId)
-            ) {
-              return row._groupingValuesCache[colId]
-            }
-
-            // Aggregate the values
-            const column = table.getColumn(colId)
-            const aggregateFn = column_getAggregationFn(
-              column as Column<TFeatures, TData, unknown>,
-            )
-
-            if (!row._groupingValuesCache) {
-              row._groupingValuesCache = makeObjectMap()
+            const aggregationCache = (row as any)._aggregationValuesCache as
+              | Record<string, unknown>
+              | undefined
+            if (aggregationCache && hasOwn(aggregationCache, colId)) {
+              return aggregationCache[colId]
             }
 
-            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({
+              childRows: subRows,
+              column,
+              groupingRow: row,
+              rows: leafRows,
+            })
+            return cache[colId]
           },
         })
 

package/src/features/global-filtering/globalFilteringFeature.utils.ts

@@ -1,4 +1,4 @@
-import { filterFn_includesString } from '../../fns/filterFns'
+import { filterFn_includesString } from '../column-filtering/filterFns'
 import { cloneState, isFunction } from '../../utils'
 import type { Column_Internal } from '../../types/Column'
 import type { FilterFn } from '../column-filtering/columnFilteringFeature.types'

package/src/features/row-sorting/rowSortingFeature.types.ts

@@ -1,5 +1,5 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { BuiltInSortFn } from '../../fns/sortFns'
+import type { BuiltInSortFn } from './sortFns'
 import type {
   OnChangeFn,
   RowData,

package/src/features/row-sorting/rowSortingFeature.utils.ts

@@ -1,5 +1,5 @@
-import { reSplitAlphaNumeric, sortFn_basic } from '../../fns/sortFns'
 import { cloneState, isFunction } from '../../utils'
+import { reSplitAlphaNumeric, sortFn_basic } from './sortFns'
 import type { CellData, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { Table_Internal } from '../../types/Table'

package/src/{fns → features/row-sorting}/sortFns.ts

@@ -1,10 +1,7 @@
-import type {
-  CreatedSortFn,
-  SortFnDef,
-} from '../features/row-sorting/rowSortingFeature.types'
-import type { RowData } from '../types/type-utils'
-import type { TableFeatures } from '../types/TableFeatures'
-import type { Row } from '../types/Row'
+import type { CreatedSortFn, SortFnDef } from './rowSortingFeature.types'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Row } from '../../types/Row'
 
 /**
  * Regular expression used to split mixed text and numeric chunks.

package/src/features/stockFeatures.ts

@@ -1,4 +1,5 @@
 import { columnFacetingFeature } from './column-faceting/columnFacetingFeature'
+import { aggregationFeature } from './aggregation/aggregationFeature'
 import { columnFilteringFeature } from './column-filtering/columnFilteringFeature'
 import { columnGroupingFeature } from './column-grouping/columnGroupingFeature'
 import { columnOrderingFeature } from './column-ordering/columnOrderingFeature'
@@ -14,6 +15,7 @@ import { rowSelectionFeature } from './row-selection/rowSelectionFeature'
 import { rowSortingFeature } from './row-sorting/rowSortingFeature'
 
 export interface StockFeatures {
+  aggregationFeature: typeof aggregationFeature
   columnFacetingFeature: typeof columnFacetingFeature
   columnFilteringFeature: typeof columnFilteringFeature
   columnGroupingFeature: typeof columnGroupingFeature
@@ -36,6 +38,7 @@ export interface StockFeatures {
  * Use individual feature exports for tree-shaking, or this aggregate when a table should include every built-in feature.
  */
 export const stockFeatures: StockFeatures = {
+  aggregationFeature,
   columnFacetingFeature,
   columnFilteringFeature,
   columnGroupingFeature,

package/src/index.ts

@@ -58,20 +58,17 @@ export * from './core/table/constructTable'
 export * from './core/table/coreTablesFeature'
 export * from './core/table/coreTablesFeature.types'
 
-/**
- * RowModelFns
- */
-
-export * from './fns/aggregationFns'
-export * from './fns/filterFns'
-export * from './fns/sortFns'
-
 /**
  * Features
  */
 
 export * from './features/stockFeatures'
 
+// aggregationFeature
+export * from './features/aggregation/aggregationFeature'
+export * from './features/aggregation/aggregationFeature.types'
+export * from './features/aggregation/aggregationFns'
+
 // columnFacetingFeature
 export * from './features/column-faceting/columnFacetingFeature'
 export * from './features/column-faceting/columnFacetingFeature.types'
@@ -83,6 +80,7 @@ export * from './features/column-faceting/createFacetedUniqueValues'
 export * from './features/column-filtering/columnFilteringFeature'
 export * from './features/column-filtering/columnFilteringFeature.types'
 export * from './features/column-filtering/createFilteredRowModel'
+export * from './features/column-filtering/filterFns'
 
 // columnGroupingFeature
 export * from './features/column-grouping/columnGroupingFeature'
@@ -135,5 +133,6 @@ export * from './features/row-selection/rowSelectionFeature.types'
 export * from './features/row-sorting/rowSortingFeature'
 export * from './features/row-sorting/rowSortingFeature.types'
 export * from './features/row-sorting/createSortedRowModel'
+export * from './features/row-sorting/sortFns'
 
 // force

package/src/static-functions.ts

@@ -15,6 +15,7 @@ export * from './core/row-models/coreRowModelsFeature.utils'
 export * from './core/table/coreTablesFeature.utils'
 
 // Features
+export * from './features/aggregation/aggregationFeature.utils'
 export * from './features/column-faceting/columnFacetingFeature.utils'
 export * from './features/column-filtering/columnFilteringFeature.utils'
 export * from './features/column-grouping/columnGroupingFeature.utils'

package/src/types/Cell.ts

@@ -1,4 +1,5 @@
 import type { Cell_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { Cell_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { CellData, RowData } from './type-utils'
 import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
 import type { Cell_Cell } from '../core/cells/coreCellsFeature.types'
@@ -10,6 +11,7 @@ export interface Cell_Core<
 > extends Cell_Cell<TFeatures, TData, TValue> {}
 
 export interface Cell_FeatureMap {
+  aggregationFeature: Cell_Aggregation
   columnGroupingFeature: Cell_ColumnGrouping
 }
 

package/src/types/Column.ts

@@ -1,5 +1,6 @@
 import type { Table_Internal } from './Table'
 import type { Column_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
+import type { Column_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { Column_ColumnFaceting } from '../features/column-faceting/columnFacetingFeature.types'
 import type { Column_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
 import type { Column_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
@@ -24,9 +25,10 @@ export interface Column_FeatureMap<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
 > {
+  aggregationFeature: Column_Aggregation<TFeatures, TData>
   columnFacetingFeature: Column_ColumnFaceting<TFeatures, TData>
   columnFilteringFeature: Column_ColumnFiltering<TFeatures, TData>
-  columnGroupingFeature: Column_ColumnGrouping<TFeatures, TData>
+  columnGroupingFeature: Column_ColumnGrouping
   columnOrderingFeature: Column_ColumnOrdering
   columnPinningFeature: Column_ColumnPinning
   columnResizingFeature: Column_ColumnResizing

package/src/types/ColumnDef.ts

@@ -7,6 +7,7 @@ import type {
 import type { CellContext } from '../core/cells/coreCellsFeature.types'
 import type { HeaderContext } from '../core/headers/coreHeadersFeature.types'
 import type { ColumnDef_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type { ColumnDef_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { ColumnDef_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
 import type { ColumnDef_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
 import type { ColumnDef_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
@@ -132,12 +133,13 @@ export interface ColumnDef_FeatureMap<
   in out TData extends RowData,
   TValue extends CellData,
 > {
+  aggregationFeature: ColumnDef_Aggregation<TFeatures, TData, TValue>
   columnVisibilityFeature: ColumnDef_ColumnVisibility
   columnPinningFeature: ColumnDef_ColumnPinning
   columnFilteringFeature: ColumnDef_ColumnFiltering<TFeatures, TData>
   globalFilteringFeature: ColumnDef_GlobalFiltering
   rowSortingFeature: ColumnDef_RowSorting<TFeatures, TData>
-  columnGroupingFeature: ColumnDef_ColumnGrouping<TFeatures, TData, TValue>
+  columnGroupingFeature: ColumnDef_ColumnGrouping<TFeatures, TData>
   columnSizingFeature: ColumnDef_ColumnSizing
   columnResizingFeature: ColumnDef_ColumnResizing
 }
@@ -158,12 +160,13 @@ export type ColumnDefBase_All<
   TValue extends CellData = CellData,
 > = ColumnDefBase_Core<TFeatures, TData, TValue> &
   Partial<
-    ColumnDef_ColumnVisibility &
+    ColumnDef_Aggregation<TFeatures, TData, TValue> &
+      ColumnDef_ColumnVisibility &
       ColumnDef_ColumnPinning &
       ColumnDef_ColumnFiltering<TFeatures, TData> &
       ColumnDef_GlobalFiltering &
       ColumnDef_RowSorting<TFeatures, TData> &
-      ColumnDef_ColumnGrouping<TFeatures, TData, TValue> &
+      ColumnDef_ColumnGrouping<TFeatures, TData> &
       ColumnDef_ColumnSizing &
       ColumnDef_ColumnResizing
   >

package/src/types/Row.ts

@@ -1,4 +1,5 @@
 import type { Row_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types'
+import type { Row_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { Row_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
 import type { Row_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
 import type { Row_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
@@ -18,6 +19,7 @@ export interface Row_FeatureMap<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
 > {
+  aggregationFeature: Row_Aggregation
   columnFilteringFeature: Row_ColumnFiltering<TFeatures, TData>
   columnGroupingFeature: Row_ColumnGrouping
   columnPinningFeature: Row_ColumnPinning<TFeatures, TData>

package/src/types/RowModelFns.ts

@@ -1,5 +1,5 @@
 import type { RowModelFns_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
-import type { RowModelFns_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { RowModelFns_Aggregation } from '../features/aggregation/aggregationFeature.types'
 import type { RowData } from './type-utils'
 import type { RowModelFns_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
 import type { ExtractFeatureMapTypes, TableFeatures } from './TableFeatures'
@@ -10,8 +10,8 @@ export interface RowModelFns_FeatureMap<
   in out TFeatures extends TableFeatures,
   in out TData extends RowData,
 > {
+  aggregationFeature: RowModelFns_Aggregation<TFeatures, TData>
   columnFilteringFeature: RowModelFns_ColumnFiltering<TFeatures, TData>
-  columnGroupingFeature: RowModelFns_ColumnGrouping<TFeatures, TData>
   rowSortingFeature: RowModelFns_RowSorting<TFeatures, TData>
 }
 
@@ -27,6 +27,6 @@ export interface RowModelFns_All<
   in out TData extends RowData,
 > extends Partial<
   RowModelFns_ColumnFiltering<TFeatures, TData> &
-    RowModelFns_ColumnGrouping<TFeatures, TData> &
+    RowModelFns_Aggregation<TFeatures, TData> &
     RowModelFns_RowSorting<TFeatures, TData>
 > {}