@tanstack/table-core 9.0.0-beta.46 → 9.0.0-beta.48

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,69 +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
-  }
-
-  return undefined
-}
-
-/**
- * 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.
  *
@@ -333,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,9 +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 aggregation functions with the `aggregationFns` slot on the
- * `features` option:
- * `tableFeatures({ columnGroupingFeature, groupedRowModel: createGroupedRowModel(), aggregationFns })`.
+ * 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,
@@ -37,6 +36,7 @@ export function createGroupedRowModel<
       memoDeps: () => [
         table.atoms.grouping?.get(),
         table.getPreGroupedRowModel(),
+        table.options.columns,
       ],
       fn: () => _createGroupedRowModel(table),
       onAfterUpdate: () => {
@@ -118,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,
@@ -139,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]
               }
@@ -153,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'
@@ -74,6 +74,14 @@ export function table_getGlobalFilterFn<
       ? table_getGlobalAutoFilterFn()
       : filterFns?.[globalFilterFn as string]
 
+  if (
+    process.env.NODE_ENV === 'development' &&
+    !filterFn &&
+    globalFilterFn != null
+  ) {
+    console.warn(`globalFilterFn '${String(globalFilterFn)}' is not registered`)
+  }
+
   return filterFn
 }
 

package/src/features/row-sorting/createSortedRowModel.ts

@@ -14,8 +14,12 @@ 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 sorting functions with the `sortFns` slot on the `features` option:
- * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns })`.
+ * Register the sorting functions you use with the `sortFns` slot on the
+ * `features` option:
+ * `tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns: { alphanumeric: sortFn_alphanumeric } })`.
+ * Importing individual `sortFn_*` functions keeps unused built-ins out of
+ * your bundle; sorting functions passed directly to the `sortFn` column
+ * option need no registration at all.
  */
 export function createSortedRowModel<
   TFeatures extends TableFeatures,

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

@@ -1,6 +1,11 @@
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
-import type { BuiltInSortFn } from '../../fns/sortFns'
-import type { OnChangeFn, RowData, Updater } from '../../types/type-utils'
+import type { BuiltInSortFn } from './sortFns'
+import type {
+  OnChangeFn,
+  RowData,
+  TransformDataValueFn,
+  Updater,
+} from '../../types/type-utils'
 import type { IsAny, TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
 
@@ -35,6 +40,53 @@ export interface SortFn<
     rowB: Row<TFeatures, TData>,
     columnId: string,
   ): number
+  /**
+   * Normalizes each row's value before the two sides are compared. Only
+   * honored by sorting functions built with `constructSortFn` (including all
+   * built-in sorting functions).
+   */
+  resolveDataValue?: TransformDataValueFn
+}
+
+/**
+ * The definition object accepted by `constructSortFn`.
+ *
+ * `sort` is a value-level comparator: it receives both rows' (resolved) data
+ * values instead of the whole rows, so normalization concerns stay in
+ * `resolveDataValue`.
+ */
+export interface SortFnDef<
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
+> {
+  sort: (
+    dataValueA: any,
+    dataValueB: any,
+    rowA: Row<TFeatures, TData>,
+    rowB: Row<TFeatures, TData>,
+    columnId: string,
+  ) => number
+  resolveDataValue?: TransformDataValueFn
+}
+
+/**
+ * The shape returned by `constructSortFn`: a `SortFn` with its definition
+ * attached, so variants can be built by spreading it into another
+ * `constructSortFn` call.
+ *
+ * The call signature is generic so a created sorting function can be used
+ * with any table's rows, regardless of the feature set it was defined
+ * against.
+ */
+export interface CreatedSortFn<
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
+> extends SortFnDef<TFeatures, TData> {
+  <TRowFeatures extends TableFeatures, TRowData extends RowData>(
+    rowA: Row<TRowFeatures, TRowData>,
+    rowB: Row<TRowFeatures, TRowData>,
+    columnId: string,
+  ): number
 }
 
 export type CustomSortFns<

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'
@@ -91,30 +91,50 @@ export function column_getAutoSortFn<
 
   const firstRows = column.table.getFilteredRowModel().flatRows.slice(0, 10)
 
+  let sortFnName: string | undefined
   let isString = false
 
   for (let i = 0; i < firstRows.length; i++) {
     const value = firstRows[i]!.getValue(column.id)
 
     if (Object.prototype.toString.call(value) === '[object Date]') {
-      if (sortFns?.datetime) {
-        return sortFns.datetime
-      }
+      sortFnName = 'datetime'
+      break
     }
 
     if (typeof value === 'string') {
       isString = true
 
       if (value.split(reSplitAlphaNumeric).length > 1) {
-        if (sortFns?.alphanumeric) {
-          return sortFns.alphanumeric
-        }
+        sortFnName = 'alphanumeric'
+        break
       }
     }
   }
 
-  if (isString) {
-    return sortFns?.text ?? sortFn_basic
+  if (!sortFnName && isString) {
+    sortFnName = 'text'
+  }
+
+  if (sortFnName) {
+    let sortFn = sortFns?.[sortFnName]
+
+    if (!sortFn) {
+      if (process.env.NODE_ENV === 'development') {
+        console.warn(
+          `sortFn '${sortFnName}' (auto) for column '${column.id}' is not registered`,
+        )
+      }
+
+      // String columns degrade to a registered text sort before basic
+      if (sortFnName === 'alphanumeric') {
+        sortFn = sortFns?.text
+      }
+    }
+
+    if (sortFn) {
+      return sortFn
+    }
   }
 
   return sortFn_basic
@@ -167,11 +187,23 @@ export function column_getSortFn<
   const sortFns: Record<string, SortFn<TFeatures, TData>> | undefined =
     column.table._rowModelFns.sortFns
 
-  return isFunction(column.columnDef.sortFn)
-    ? column.columnDef.sortFn
-    : column.columnDef.sortFn === 'auto'
-      ? column_getAutoSortFn(column)
-      : (sortFns?.[column.columnDef.sortFn as string] ?? sortFn_basic)
+  if (isFunction(column.columnDef.sortFn)) {
+    return column.columnDef.sortFn
+  }
+
+  if (column.columnDef.sortFn === 'auto') {
+    return column_getAutoSortFn(column)
+  }
+
+  const sortFn = sortFns?.[column.columnDef.sortFn as string]
+
+  if (process.env.NODE_ENV === 'development' && !sortFn) {
+    console.warn(
+      `sortFn '${String(column.columnDef.sortFn)}' for column '${column.id}' is not registered`,
+    )
+  }
+
+  return sortFn ?? sortFn_basic
 }
 
 /**

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

@@ -1,6 +1,7 @@
-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.
@@ -11,122 +12,127 @@ import type { Row } from '../types/Row'
 export const reSplitAlphaNumeric = /([0-9]+)/gm
 
 /**
- * Sorts rows with the built-in alphanumeric strategy.
+ * Builds a `SortFn` from a value-level comparator plus an optional
+ * `resolveDataValue` normalizer.
  *
- * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ * The `sort` comparator receives both rows' data values, each already passed
+ * through `resolveDataValue` when one is defined. Keeping normalization in the
+ * resolver means a variant of an existing sorting function only has to swap
+ * the resolver, not re-implement the comparison.
+ *
+ * The definition is attached to the returned function, so a variant can be
+ * created by spreading a built-in sorting function and overriding what
+ * differs:
+ *
+ * ```ts
+ * const stripDiacritics = (value: string) =>
+ *   value.normalize('NFD').replace(/\p{Diacritic}/gu, '')
+ *
+ * const alphanumericIgnoreDiacritics = constructSortFn({
+ *   ...sortFn_alphanumeric,
+ *   resolveDataValue: (value) =>
+ *     stripDiacritics(sortFn_alphanumeric.resolveDataValue!(value)),
+ * })
+ * ```
  */
-export const sortFn_alphanumeric = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  return compareAlphanumeric(
-    toString(rowA.getValue(columnId)).toLowerCase(),
-    toString(rowB.getValue(columnId)).toLowerCase(),
+export function constructSortFn<
+  TFeatures extends TableFeatures = any,
+  TData extends RowData = any,
+>(def: SortFnDef<TFeatures, TData>): CreatedSortFn<TFeatures, TData> {
+  const sortFn: CreatedSortFn<TFeatures, TData> = Object.assign(
+    <TRowFeatures extends TableFeatures, TRowData extends RowData>(
+      rowA: Row<TRowFeatures, TRowData>,
+      rowB: Row<TRowFeatures, TRowData>,
+      columnId: string,
+    ): number => {
+      let dataValueA = rowA.getValue(columnId)
+      let dataValueB = rowB.getValue(columnId)
+      const resolveDataValue = sortFn.resolveDataValue
+      if (resolveDataValue) {
+        dataValueA = resolveDataValue(dataValueA)
+        dataValueB = resolveDataValue(dataValueB)
+      }
+      // The def's comparator is typed against the factory's TFeatures/TData;
+      // the caller's row generics are erased at this boundary.
+      return sortFn.sort(
+        dataValueA,
+        dataValueB,
+        rowA as any,
+        rowB as any,
+        columnId,
+      )
+    },
+    def,
   )
+  return sortFn
 }
 
+/**
+ * Sorts rows with the built-in alphanumeric strategy.
+ *
+ * This comparator returns ascending-order results; descending order is applied by the sorting row model.
+ */
+export const sortFn_alphanumeric = constructSortFn({
+  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),
+})
+
 /**
  * Sorts rows with the built-in alphanumeric case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-export const sortFn_alphanumericCaseSensitive = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  return compareAlphanumeric(
-    toString(rowA.getValue(columnId)),
-    toString(rowB.getValue(columnId)),
-  )
-}
+export const sortFn_alphanumericCaseSensitive = constructSortFn({
+  resolveDataValue: (dataValue) => toString(dataValue),
+  sort: (dataValueA, dataValueB) => compareAlphanumeric(dataValueA, dataValueB),
+})
 
-// The text filter is more basic (less numeric support)
+// The text sort is more basic (less numeric support)
 // but is much faster
 /**
  * Sorts rows with the built-in text strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-export const sortFn_text = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  return compareBasic(
-    toString(rowA.getValue(columnId)).toLowerCase(),
-    toString(rowB.getValue(columnId)).toLowerCase(),
-  )
-}
+export const sortFn_text = constructSortFn({
+  resolveDataValue: (dataValue) => toString(dataValue).toLowerCase(),
+  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),
+})
 
-// The text filter is more basic (less numeric support)
+// The text sort is more basic (less numeric support)
 // but is much faster
 /**
  * Sorts rows with the built-in text case sensitive strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-export const sortFn_textCaseSensitive = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  return compareBasic(
-    toString(rowA.getValue(columnId)),
-    toString(rowB.getValue(columnId)),
-  )
-}
+export const sortFn_textCaseSensitive = constructSortFn({
+  resolveDataValue: (dataValue) => toString(dataValue),
+  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),
+})
 
 /**
  * Sorts rows with the built-in datetime strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-export const sortFn_datetime = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  const a = toDateSortValue(rowA.getValue(columnId))
-  const b = toDateSortValue(rowB.getValue(columnId))
-
+export const sortFn_datetime = constructSortFn({
+  resolveDataValue: (dataValue) => toDateSortValue(dataValue),
   // Can handle nullish values
   // Use > and < because == (and ===) doesn't work with
   // Date objects (would require calling getTime()).
-  return a > b ? 1 : a < b ? -1 : 0
-}
+  sort: (dataValueA, dataValueB) =>
+    dataValueA > dataValueB ? 1 : dataValueA < dataValueB ? -1 : 0,
+})
 
 /**
  * Sorts rows with the built-in basic strategy.
  *
  * This comparator returns ascending-order results; descending order is applied by the sorting row model.
  */
-export const sortFn_basic = <
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  rowA: Row<TFeatures, TData>,
-  rowB: Row<TFeatures, TData>,
-  columnId: string,
-) => {
-  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))
-}
+export const sortFn_basic = constructSortFn({
+  sort: (dataValueA, dataValueB) => compareBasic(dataValueA, dataValueB),
+})
 
 // Utils
 
@@ -338,7 +344,15 @@ function countRemainingChunks(str: string, start: number) {
 /**
  * The built-in sorting function registry.
  *
- * Pass this object to sorted row model creation or extend it with custom sorting functions.
+ * Registering this full object opts out of tree-shaking: every built-in
+ * sorting function ends up in your bundle. Prefer importing the `sortFn_*`
+ * functions you actually use and registering just those in the `sortFns`
+ * slot, or passing them directly to the `sortFn` column option.
+ *
+ * @deprecated Import individual `sortFn_*` functions instead for a smaller
+ * bundle. This export still works and is not going away in v9, but built-in
+ * name resolution (including `sortFn: 'auto'`) only finds functions you
+ * register yourself.
  */
 export const sortFns = {
   alphanumeric: sortFn_alphanumeric,

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,