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

package/src/features/aggregation/aggregationFns.ts

@@ -0,0 +1,336 @@
+import { constructAggregationFn } from './aggregationFeature.types'
+import type { AggregationContext } from './aggregationFeature.types'
+
+type RangeValue = Date | number
+
+function isNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}
+
+function isValidDate(value: unknown): value is Date {
+  return value instanceof Date && !Number.isNaN(value.getTime())
+}
+
+function getRangeKind(value: unknown): 'date' | 'number' | undefined {
+  if (isNumber(value)) return 'number'
+  if (isValidDate(value)) return 'date'
+  return undefined
+}
+
+function compareRangeValues(left: RangeValue, right: RangeValue) {
+  const leftValue = left instanceof Date ? left.getTime() : left
+  const rightValue = right instanceof Date ? right.getTime() : right
+  return leftValue - rightValue
+}
+
+function collectRangeValues(context: AggregationContext<any, any, unknown>) {
+  const values: Array<RangeValue> = []
+  let kind: 'date' | 'number' | undefined
+
+  for (let i = 0; i < context.rows.length; i++) {
+    const value = context.getValue(context.rows[i]!)
+    const valueKind = getRangeKind(value)
+    if (!valueKind) continue
+    kind ??= valueKind
+    if (valueKind === kind) values.push(value as RangeValue)
+  }
+
+  return values
+}
+
+/**
+ * Sums numeric row values. Non-number values contribute zero. As in the
+ * previous API, `NaN` is a number and therefore propagates through the sum.
+ */
+export const aggregationFn_sum = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  number
+>({
+  aggregate: (context) => {
+    let sum = 0
+    for (let i = 0; i < context.rows.length; i++) {
+      const value = context.getValue(context.rows[i]!)
+      sum += typeof value === 'number' ? value : 0
+    }
+    return sum
+  },
+  merge: ({ childResults }) => {
+    let sum = 0
+    for (let i = 0; i < childResults.length; i++) {
+      const value = childResults[i]
+      if (isNumber(value)) sum += value
+    }
+    return sum
+  },
+})
+
+/**
+ * Finds the minimum numeric or Date value. Invalid value types are ignored;
+ * `NaN` preserves the legacy numeric seeding behavior.
+ */
+export const aggregationFn_min = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  RangeValue | undefined
+>({
+  aggregate: (context) => {
+    const values = collectRangeValues(context)
+    let result = values[0]
+    for (let i = 1; i < values.length; i++) {
+      if (compareRangeValues(values[i]!, result!) < 0) result = values[i]
+    }
+    return result
+  },
+  merge: ({ childResults }) => {
+    let result: RangeValue | undefined
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < childResults.length; i++) {
+      const value = childResults[i]
+      const valueKind = getRangeKind(value)
+      if (!valueKind) continue
+      kind ??= valueKind
+      if (kind !== valueKind) continue
+      if (result === undefined || compareRangeValues(value!, result) < 0) {
+        result = value
+      }
+    }
+    return result
+  },
+})
+
+/**
+ * Finds the maximum numeric or Date value. Invalid value types are ignored;
+ * `NaN` preserves the legacy numeric seeding behavior.
+ */
+export const aggregationFn_max = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  RangeValue | undefined
+>({
+  aggregate: (context) => {
+    const values = collectRangeValues(context)
+    let result = values[0]
+    for (let i = 1; i < values.length; i++) {
+      if (compareRangeValues(values[i]!, result!) > 0) result = values[i]
+    }
+    return result
+  },
+  merge: ({ childResults }) => {
+    let result: RangeValue | undefined
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < childResults.length; i++) {
+      const value = childResults[i]
+      const valueKind = getRangeKind(value)
+      if (!valueKind) continue
+      kind ??= valueKind
+      if (kind !== valueKind) continue
+      if (result === undefined || compareRangeValues(value!, result) > 0) {
+        result = value
+      }
+    }
+    return result
+  },
+})
+
+/**
+ * Finds the minimum and maximum numeric or Date values. Empty inputs return
+ * `[undefined, undefined]`, preserving the previous built-in result shape.
+ */
+export const aggregationFn_extent = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  [RangeValue | undefined, RangeValue | undefined]
+>({
+  aggregate: (context) => {
+    const values = collectRangeValues(context)
+    if (!values.length) return [undefined, undefined]
+    let min = values[0]!
+    let max = values[0]!
+    for (let i = 1; i < values.length; i++) {
+      const value = values[i]!
+      if (compareRangeValues(value, min) < 0) min = value
+      if (compareRangeValues(value, max) > 0) max = value
+    }
+    return [min, max]
+  },
+  merge: ({ childResults }) => {
+    let result: [RangeValue | undefined, RangeValue | undefined] = [
+      undefined,
+      undefined,
+    ]
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < childResults.length; i++) {
+      const extent = childResults[i]!
+      const valueKind = getRangeKind(extent[0])
+      if (!valueKind) continue
+      kind ??= valueKind
+      if (kind !== valueKind) continue
+      if (result[0] === undefined) {
+        result = [extent[0], extent[1]]
+      } else {
+        if (compareRangeValues(extent[0]!, result[0]) < 0) {
+          result[0] = extent[0]
+        }
+        if (compareRangeValues(extent[1]!, result[1]!) > 0) {
+          result[1] = extent[1]
+        }
+      }
+    }
+    return result
+  },
+})
+
+/**
+ * Averages number and number-like row values. Nullish and non-numeric values
+ * are ignored; other values retain the legacy unary-plus coercion behavior.
+ */
+export const aggregationFn_mean = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  number | undefined
+>({
+  aggregate: (context) => {
+    let count = 0
+    let sum = 0
+    for (let i = 0; i < context.rows.length; i++) {
+      const value = context.getValue(context.rows[i]!)
+      if (value == null) continue
+      const numberValue = typeof value === 'number' ? value : +value
+      if (!Number.isNaN(numberValue)) {
+        count++
+        sum += numberValue
+      }
+    }
+    return count ? sum / count : undefined
+  },
+})
+
+/**
+ * Computes the median when every row value is a number. Returns `undefined`
+ * for empty inputs or when any value is non-numeric.
+ */
+export const aggregationFn_median = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  number | undefined
+>({
+  aggregate: (context) => {
+    if (!context.rows.length) return undefined
+    const values = new Array<number>(context.rows.length)
+    for (let i = 0; i < context.rows.length; i++) {
+      const value = context.getValue(context.rows[i]!)
+      if (typeof value !== 'number') return undefined
+      values[i] = value
+    }
+    values.sort((a, b) => a - b)
+    const mid = Math.floor(values.length / 2)
+    return values.length % 2
+      ? values[mid]
+      : (values[mid - 1]! + values[mid]!) / 2
+  },
+})
+
+/** Collects distinct row values using JavaScript `Set` semantics. */
+export const aggregationFn_unique = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  Array<unknown>
+>({
+  aggregate: (context) => {
+    const values = new Set<unknown>()
+    for (let i = 0; i < context.rows.length; i++) {
+      values.add(context.getValue(context.rows[i]!))
+    }
+    return Array.from(values)
+  },
+})
+
+/** Counts distinct row values using JavaScript `Set` semantics. */
+export const aggregationFn_uniqueCount = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  number
+>({
+  aggregate: (context) => {
+    const values = new Set<unknown>()
+    for (let i = 0; i < context.rows.length; i++) {
+      values.add(context.getValue(context.rows[i]!))
+    }
+    return values.size
+  },
+})
+
+/** Counts rows, independently of the column's values. */
+export const aggregationFn_count = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  number
+>({
+  aggregate: ({ rows }) => rows.length,
+  merge: ({ childResults }) => {
+    let count = 0
+    for (let i = 0; i < childResults.length; i++) {
+      const value = childResults[i]
+      if (isNumber(value)) count += value
+    }
+    return count
+  },
+})
+
+/** Returns the first row's value, including a nullish value. */
+export const aggregationFn_first = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  unknown
+>({
+  aggregate: (context) =>
+    context.rows[0] ? context.getValue(context.rows[0]) : undefined,
+  merge: ({ childResults }) => childResults[0],
+})
+
+/** Returns the last row's value, including a nullish value. */
+export const aggregationFn_last = constructAggregationFn<
+  any,
+  any,
+  unknown,
+  unknown
+>({
+  aggregate: (context) => {
+    const row = context.rows[context.rows.length - 1]
+    return row ? context.getValue(row) : undefined
+  },
+  merge: ({ childResults }) => childResults[childResults.length - 1],
+})
+
+/**
+ * Full built-in registry. Register individual definitions for tree-shaking.
+ *
+ * @deprecated Import individual `aggregationFn_*` definitions instead for a
+ * smaller bundle. This registry remains available for compatibility.
+ */
+export const aggregationFns = {
+  sum: aggregationFn_sum,
+  min: aggregationFn_min,
+  max: aggregationFn_max,
+  extent: aggregationFn_extent,
+  mean: aggregationFn_mean,
+  median: aggregationFn_median,
+  unique: aggregationFn_unique,
+  uniqueCount: aggregationFn_uniqueCount,
+  count: aggregationFn_count,
+  first: aggregationFn_first,
+  last: aggregationFn_last,
+}
+
+export type BuiltInAggregationFn = keyof typeof aggregationFns

package/src/features/column-filtering/columnFilteringFeature.types.ts

@@ -1,4 +1,4 @@
-import type { BuiltInFilterFn } from '../../fns/filterFns'
+import type { BuiltInFilterFn } from './filterFns'
 import type {
   CellData,
   OnChangeFn,

package/src/{fns → features/column-filtering}/filterFns.ts

@@ -2,10 +2,10 @@ import type {
   CreatedFilterFn,
   ExtractFilterMeta,
   FilterFnDef,
-} from '../features/column-filtering/columnFilteringFeature.types'
-import type { RowData } from '../types/type-utils'
-import type { TableFeatures } from '../types/TableFeatures'
-import type { Row } from '../types/Row'
+} from './columnFilteringFeature.types'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Row } from '../../types/Row'
 
 /**
  * Builds a `FilterFn` from a value-level comparator plus optional resolvers.

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

@@ -5,11 +5,8 @@ import {
   makeStateUpdater,
 } from '../../utils'
 import {
-  cell_getIsAggregated,
   cell_getIsGrouped,
   cell_getIsPlaceholder,
-  column_getAggregationFn,
-  column_getAutoAggregationFn,
   column_getCanGroup,
   column_getGroupedIndex,
   column_getIsGrouped,
@@ -24,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) => {
@@ -34,13 +31,6 @@ export const columnGroupingFeature: TableFeature = {
     }
   },
 
-  getDefaultColumnDef: () => {
-    return {
-      aggregatedCell: ({ getValue }: any) => getValue()?.toString?.() ?? null,
-      aggregationFn: 'auto',
-    }
-  },
-
   getDefaultTableOptions: (table) => {
     return {
       onGroupingChange: makeStateUpdater('grouping', table),
@@ -56,9 +46,6 @@ export const columnGroupingFeature: TableFeature = {
       cell_getIsPlaceholder: {
         fn: (cell) => cell_getIsPlaceholder(cell),
       },
-      cell_getIsAggregated: {
-        fn: (cell) => cell_getIsAggregated(cell),
-      },
     })
   },
 
@@ -79,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),
-      },
     })
   },
 

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>
   /**