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

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-faceting/createFacetedMinMaxValues.ts

@@ -1,5 +1,9 @@
 import { callMemoOrStaticFn, tableMemo } from '../../utils'
-import { column_getFacetedRowModel } from './columnFacetingFeature.utils'
+import { column_getCanGlobalFilter } from '../global-filtering/globalFilteringFeature.utils'
+import {
+  column_getFacetedRowModel,
+  table_getGlobalFacetedRowModel,
+} from './columnFacetingFeature.utils'
 import type { Row } from '../../types/Row'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -21,9 +25,18 @@ export function createFacetedMinMaxValues<
     const table = _table as unknown as Table_Internal<TFeatures, TData>
     return tableMemo({
       feature: 'columnFacetingFeature',
-      fn: (flatRows) => _createFacetedMinMaxValues(columnId, flatRows),
+      fn: (flatRows) => _createFacetedMinMaxValues(table, columnId, flatRows),
       fnName: 'table.getFacetedMinMaxValues',
       memoDeps: () => {
+        if (columnId === '__global__') {
+          return [
+            callMemoOrStaticFn(
+              table,
+              'getGlobalFacetedRowModel',
+              table_getGlobalFacetedRowModel,
+            ).flatRows,
+          ]
+        }
         const column = table.getColumn(columnId)
         if (!column) return [table.getPreFilteredRowModel().flatRows]
         return [
@@ -44,21 +57,34 @@ function _createFacetedMinMaxValues<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
 >(
+  table: Table_Internal<TFeatures, TData>,
   columnId: string,
   flatRows: Array<Row<TFeatures, TData>>,
 ): undefined | [number, number] {
   if (!flatRows.length) return undefined
 
+  // The global context aggregates values across every column that
+  // participates in global filtering
+  const columnIds =
+    columnId === '__global__'
+      ? table
+          .getAllLeafColumns()
+          .filter((column) => column_getCanGlobalFilter(column))
+          .map((column) => column.id)
+      : [columnId]
+
   let facetedMinValue = Number.POSITIVE_INFINITY
   let facetedMaxValue = Number.NEGATIVE_INFINITY
   let foundAny = false
 
   for (let i = 0; i < flatRows.length; i++) {
-    const value = Number(flatRows[i]!.getValue(columnId))
-    if (Number.isNaN(value)) continue
-    foundAny = true
-    if (value < facetedMinValue) facetedMinValue = value
-    if (value > facetedMaxValue) facetedMaxValue = value
+    for (let c = 0; c < columnIds.length; c++) {
+      const value = Number(flatRows[i]!.getValue(columnIds[c]!))
+      if (Number.isNaN(value)) continue
+      foundAny = true
+      if (value < facetedMinValue) facetedMinValue = value
+      if (value > facetedMaxValue) facetedMaxValue = value
+    }
   }
 
   if (!foundAny) return undefined

package/src/features/column-faceting/createFacetedRowModel.ts

@@ -67,7 +67,10 @@ function _createFacetedRowModel<
       if (id !== columnId) filterableIds.push(id)
     }
   }
-  if (globalFilter) filterableIds.push('__global__')
+  // The global context excludes the global filter itself, mirroring how a
+  // column's faceted model excludes that column's own filter
+  if (globalFilter && columnId !== '__global__')
+    filterableIds.push('__global__')
 
   if (!filterableIds.length) {
     return preRowModel

package/src/features/column-faceting/createFacetedUniqueValues.ts

@@ -1,5 +1,9 @@
 import { callMemoOrStaticFn, tableMemo } from '../../utils'
-import { column_getFacetedRowModel } from './columnFacetingFeature.utils'
+import { column_getCanGlobalFilter } from '../global-filtering/globalFilteringFeature.utils'
+import {
+  column_getFacetedRowModel,
+  table_getGlobalFacetedRowModel,
+} from './columnFacetingFeature.utils'
 import type { Row } from '../../types/Row'
 import type { Table, Table_Internal } from '../../types/Table'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -24,6 +28,15 @@ export function createFacetedUniqueValues<
       table,
       fnName: 'table.getFacetedUniqueValues',
       memoDeps: () => {
+        if (columnId === '__global__') {
+          return [
+            callMemoOrStaticFn(
+              table,
+              'getGlobalFacetedRowModel',
+              table_getGlobalFacetedRowModel,
+            ).flatRows,
+          ]
+        }
         const column = table.getColumn(columnId)
         if (!column) return [table.getPreFilteredRowModel().flatRows]
         return [
@@ -35,7 +48,7 @@ export function createFacetedUniqueValues<
           ).flatRows,
         ]
       },
-      fn: (flatRows) => _createFacetedUniqueValues(columnId, flatRows),
+      fn: (flatRows) => _createFacetedUniqueValues(table, columnId, flatRows),
     })
   }
 }
@@ -43,19 +56,40 @@ export function createFacetedUniqueValues<
 function _createFacetedUniqueValues<
   TFeatures extends TableFeatures,
   TData extends RowData = any,
->(columnId: string, flatRows: Array<Row<TFeatures, TData>>): Map<any, number> {
+>(
+  table: Table_Internal<TFeatures, TData>,
+  columnId: string,
+  flatRows: Array<Row<TFeatures, TData>>,
+): Map<any, number> {
+  // The global context aggregates unique values across every column that
+  // participates in global filtering
+  const columnIds =
+    columnId === '__global__'
+      ? table
+          .getAllLeafColumns()
+          .filter((column) => column_getCanGlobalFilter(column))
+          .map((column) => column.id)
+      : [columnId]
+
   const facetedUniqueValues = new Map<any, number>()
 
   for (let i = 0; i < flatRows.length; i++) {
-    const values = flatRows[i]!.getUniqueValues(columnId)
+    for (let c = 0; c < columnIds.length; c++) {
+      // the declared return type is Array, but rows return undefined for
+      // columns without an accessor (e.g. display columns)
+      const values = flatRows[i]!.getUniqueValues(columnIds[c]!) as
+        | Array<unknown>
+        | undefined
+      if (!values) continue
 
-    for (let j = 0; j < values.length; j++) {
-      const value = values[j]
-      const previousValue = facetedUniqueValues.get(value)
-      facetedUniqueValues.set(
-        value,
-        previousValue === undefined ? 1 : previousValue + 1,
-      )
+      for (let j = 0; j < values.length; j++) {
+        const value = values[j]
+        const previousValue = facetedUniqueValues.get(value)
+        facetedUniqueValues.set(
+          value,
+          previousValue === undefined ? 1 : previousValue + 1,
+        )
+      }
     }
   }
 

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),
-      },
     })
   },