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

package/src/features/aggregation/aggregationFns.ts

@@ -0,0 +1,345 @@
+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 selected-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: ({ subRowResults }) => {
+    let sum = 0
+    for (let i = 0; i < subRowResults.length; i++) {
+      const value = subRowResults[i]
+      if (isNumber(value)) sum += value
+    }
+    return sum
+  },
+})
+
+/**
+ * Finds the minimum numeric or Date value from the selected rows. 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: ({ subRowResults }) => {
+    let result: RangeValue | undefined
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < subRowResults.length; i++) {
+      const value = subRowResults[i]
+      const valueKind = getRangeKind(value)
+      if (!valueKind) continue
+      if (value === undefined) 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 from the selected rows. 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: ({ subRowResults }) => {
+    let result: RangeValue | undefined
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < subRowResults.length; i++) {
+      const value = subRowResults[i]
+      const valueKind = getRangeKind(value)
+      if (!valueKind) continue
+      if (value === undefined) 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 from the selected rows.
+ * 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: ({ subRowResults }) => {
+    let result: [RangeValue | undefined, RangeValue | undefined] = [
+      undefined,
+      undefined,
+    ]
+    let kind: 'date' | 'number' | undefined
+    for (let i = 0; i < subRowResults.length; i++) {
+      const extent = subRowResults[i]!
+      const min = extent[0]
+      const max = extent[1]
+      const valueKind = getRangeKind(min)
+      if (!valueKind || min === undefined || max === undefined) continue
+      kind ??= valueKind
+      if (kind !== valueKind) continue
+      if (result[0] === undefined) {
+        result = [min, max]
+      } else {
+        if (compareRangeValues(min, result[0]) < 0) {
+          result[0] = min
+        }
+        const currentMax = result[1]
+        if (
+          currentMax === undefined ||
+          compareRangeValues(max, currentMax) > 0
+        ) {
+          result[1] = max
+        }
+      }
+    }
+    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: ({ subRowResults }) => {
+    let count = 0
+    for (let i = 0; i < subRowResults.length; i++) {
+      const value = subRowResults[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: ({ subRowResults }) => subRowResults[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: ({ subRowResults }) => subRowResults[subRowResults.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/columnFacetingFeature.types.ts

@@ -1,11 +1,10 @@
-import type { Table } from '../../types/Table'
 import type { RowData } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
 
 export interface Column_ColumnFaceting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Computes min/max numeric facet values for this column.
@@ -25,74 +24,44 @@ export interface Column_ColumnFaceting<
 }
 
 export interface Table_RowModels_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Computes min/max numeric facet values for the active faceting context.
    *
-   * Requires a `facetedMinMaxValues` row-model factory in `rowModels`.
+   * Requires a `facetedMinMaxValues` row-model factory on the `features` option.
    */
   getFacetedMinMaxValues: () => undefined | [number, number]
   /**
    * Computes the row model used to derive facet values.
    *
-   * Requires a `facetedRowModel` row-model factory in `rowModels`.
+   * Requires a `facetedRowModel` row-model factory on the `features` option.
    */
   getFacetedRowModel: () => RowModel<TFeatures, TData>
   /**
    * Computes unique facet values and occurrence counts.
    *
-   * Requires a `facetedUniqueValues` row-model factory in `rowModels`.
+   * Requires a `facetedUniqueValues` row-model factory on the `features` option.
    */
   getFacetedUniqueValues: () => Map<any, number>
 }
 
-export interface CreateRowModel_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-> {
-  /**
-   * Factory used to retrieve faceted min/max values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedMinMaxValues()` or implement your own factory.
-   */
-  facetedMinMaxValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => [number, number] | undefined
-  /**
-   * Factory used to retrieve the faceted row model. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedRowModel()` or implement your own factory.
-   */
-  facetedRowModel?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => RowModel<TFeatures, TData>
-  /**
-   * Factory used to retrieve faceted unique values. If using server-side
-   * faceting, this is not required. To use client-side faceting, pass
-   * `createFacetedUniqueValues()` or implement your own factory.
-   */
-  facetedUniqueValues?: (
-    table: Table<TFeatures, TData>,
-    columnId: string,
-  ) => () => Map<any, number>
-}
-
 export interface CachedRowModel_Faceted<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
-  facetedRowModel?: (columnId: string) => () => RowModel<TFeatures, TData>
-  facetedMinMaxValues?: (columnId: string) => [number, number]
-  facetedUniqueValues?: (columnId: string) => Map<any, number>
+  facetedRowModels?: Record<string, () => RowModel<TFeatures, TData>>
+  facetedMinMaxValues?: Record<string, () => undefined | [number, number]>
+  facetedUniqueValues?: Record<string, () => Map<any, number>>
+  globalFacetedRowModel?: () => RowModel<TFeatures, TData>
+  globalFacetedMinMaxValues?: () => undefined | [number, number]
+  globalFacetedUniqueValues?: () => Map<any, number>
 }
 
 export interface Table_ColumnFaceting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Returns the min and max values for the global filter.

package/src/features/column-faceting/columnFacetingFeature.utils.ts

@@ -1,3 +1,4 @@
+import { makeObjectMap } from '../../utils'
 import type { CellData, RowData } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowModel } from '../../core/row-models/coreRowModelsFeature.types'
@@ -23,9 +24,16 @@ export function column_getFacetedMinMaxValues<
   column: Column_Internal<TFeatures, TData, TValue>,
   table: Table_Internal<TFeatures, TData>,
 ): [number, number] | undefined {
-  const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, column.id) ??
-    (() => undefined)
+  const facetedMinMaxValues = (table._rowModels.facetedMinMaxValues ??=
+    makeObjectMap())
+  let facetedMinMaxValuesFn = facetedMinMaxValues[column.id]
+
+  if (!facetedMinMaxValuesFn) {
+    facetedMinMaxValuesFn = facetedMinMaxValues[column.id] =
+      table.options.features.facetedMinMaxValues?.(table, column.id) ??
+      (() => undefined)
+  }
+
   return facetedMinMaxValuesFn()
 }
 
@@ -49,9 +57,17 @@ export function column_getFacetedRowModel<
   column: Column_Internal<TFeatures, TData, TValue> | undefined,
   table: Table_Internal<TFeatures, TData>,
 ): RowModel<TFeatures, TData> {
-  const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, column?.id ?? '') ??
-    (() => table.getPreFilteredRowModel())
+  const columnId = column?.id ?? ''
+  const facetedRowModels = (table._rowModels.facetedRowModels ??=
+    makeObjectMap())
+  let facetedRowModelFn = facetedRowModels[columnId]
+
+  if (!facetedRowModelFn) {
+    facetedRowModelFn = facetedRowModels[columnId] =
+      table.options.features.facetedRowModel?.(table, columnId) ??
+      (() => table.getPreFilteredRowModel())
+  }
+
   return facetedRowModelFn()
 }
 
@@ -74,9 +90,16 @@ export function column_getFacetedUniqueValues<
   column: Column_Internal<TFeatures, TData, TValue>,
   table: Table_Internal<TFeatures, TData>,
 ): Map<any, number> {
-  const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, column.id) ??
-    (() => new Map<any, number>())
+  const facetedUniqueValues = (table._rowModels.facetedUniqueValues ??=
+    makeObjectMap())
+  let facetedUniqueValuesFn = facetedUniqueValues[column.id]
+
+  if (!facetedUniqueValuesFn) {
+    facetedUniqueValuesFn = facetedUniqueValues[column.id] =
+      table.options.features.facetedUniqueValues?.(table, column.id) ??
+      (() => new Map<any, number>())
+  }
+
   return facetedUniqueValuesFn()
 }
 
@@ -95,9 +118,13 @@ export function table_getGlobalFacetedMinMaxValues<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): undefined | [number, number] {
-  const facetedMinMaxValuesFn =
-    table.options.rowModels?.facetedMinMaxValues?.(table, '__global__') ??
-    (() => undefined)
+  if (!table._rowModels.globalFacetedMinMaxValues) {
+    table._rowModels.globalFacetedMinMaxValues =
+      table.options.features.facetedMinMaxValues?.(table, '__global__') ??
+      (() => undefined)
+  }
+
+  const facetedMinMaxValuesFn = table._rowModels.globalFacetedMinMaxValues
   return facetedMinMaxValuesFn()
 }
 
@@ -117,9 +144,13 @@ export function table_getGlobalFacetedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  const facetedRowModelFn =
-    table.options.rowModels?.facetedRowModel?.(table, '__global__') ??
-    (() => table.getPreFilteredRowModel())
+  if (!table._rowModels.globalFacetedRowModel) {
+    table._rowModels.globalFacetedRowModel =
+      table.options.features.facetedRowModel?.(table, '__global__') ??
+      (() => table.getPreFilteredRowModel())
+  }
+
+  const facetedRowModelFn = table._rowModels.globalFacetedRowModel
   return facetedRowModelFn()
 }
 
@@ -138,8 +169,12 @@ export function table_getGlobalFacetedUniqueValues<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>): Map<any, number> {
-  const facetedUniqueValuesFn =
-    table.options.rowModels?.facetedUniqueValues?.(table, '__global__') ??
-    (() => new Map())
+  if (!table._rowModels.globalFacetedUniqueValues) {
+    table._rowModels.globalFacetedUniqueValues =
+      table.options.features.facetedUniqueValues?.(table, '__global__') ??
+      (() => new Map())
+  }
+
+  const facetedUniqueValuesFn = table._rowModels.globalFacetedUniqueValues
   return facetedUniqueValuesFn()
 }

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,14 @@ 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
+  }
 
   const filterRowsImpl = (
     row: Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>,