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

package/src/worker/initTableWorker.ts

@@ -0,0 +1,164 @@
+import { constructTable } from '../core/table/constructTable'
+import { storeReactivityBindings } from '../store-reactivity-bindings'
+import { makeObjectMap } from '../utils'
+import { serializeRowModel } from './serializeRowModel'
+import type { RowData } from '../types/type-utils'
+import type { TableFeatures } from '../types/TableFeatures'
+import type { TableOptions } from '../types/TableOptions'
+import type { Table_Internal } from '../types/Table'
+import type {
+  TableWorkerRequest,
+  TableWorkerResult,
+  TableWorkerStage,
+  TableWorkerStagePayload,
+} from './tableWorkerProtocol'
+
+export type TableWorkerConfig<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Omit<TableOptions<TFeatures, TData>, 'data'>
+
+function capitalize(stage: string) {
+  return stage.charAt(0).toUpperCase() + stage.slice(1)
+}
+
+/** Flatten column-group defs to leaf defs (mirrors core's id resolution). */
+function flattenColumnDefs(defs: Array<any>): Array<any> {
+  return defs.flatMap((def) =>
+    def.columns ? flattenColumnDefs(def.columns) : [def],
+  )
+}
+
+/**
+ * Runs a headless "shadow table" inside a dedicated Web Worker.
+ *
+ * Call this from a user-authored worker entry file, passing the same columns
+ * and processing features used on the main thread. The shadow table runs the
+ * real table-core row model pipeline (real fns, real Row objects) off the
+ * main thread and posts back one payload per stage the main thread requested:
+ * a transferable index permutation for flat results, a serialized row tree
+ * (with eagerly computed aggregates) when grouping produces synthetic rows.
+ *
+ * Everything passed here must be thread-portable: `accessorKey` columns or
+ * accessors defined in a shared module, and fns from registries or shared
+ * modules (no closures over app state).
+ *
+ * @example
+ * ```ts
+ * // table.worker.ts
+ * import { initTableWorker } from '@tanstack/table-core/experimental-worker-plugin'
+ * import { columns, sharedFeatures } from './tableConfig'
+ *
+ * initTableWorker({ features: sharedFeatures, columns })
+ * ```
+ */
+export function initTableWorker<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(config: TableWorkerConfig<TFeatures, TData>): void {
+  let table: Table_Internal<TFeatures, TData> | undefined
+  let dataVersion = 0
+  let coreIndexById: Record<string, number> = makeObjectMap()
+  let aggregateColumnIds: Array<string> = []
+  // Last-sent model identity per stage: the memoized getters return stable
+  // objects when their inputs did not change, so identity equality is exactly
+  // "this stage's result is unchanged".
+  let lastSentModels: { [K in TableWorkerStage]?: unknown } = {}
+
+  self.onmessage = (event: MessageEvent<TableWorkerRequest<TData>>) => {
+    const message = event.data
+
+    if (message.type === 'data') {
+      dataVersion = message.dataVersion
+      lastSentModels = {}
+      if (!table) {
+        table = constructTable<TFeatures, TData>({
+          ...(config as TableOptions<TFeatures, TData>),
+          features: {
+            coreReactivityFeature: storeReactivityBindings(),
+            ...config.features,
+          },
+          data: message.data,
+        })
+        // Only columns with an explicit aggregation get eagerly aggregated
+        // per group. Sync tables aggregate lazily (visible cells only), so
+        // auto-aggregating every column would explode on high-cardinality
+        // grouping for values nothing renders. Read the RAW column defs:
+        // rowAggregationFeature injects default aggregatedCell/aggregationFn
+        // into every resolved columnDef, so the resolved defs can't tell
+        // explicit from default.
+        aggregateColumnIds = flattenColumnDefs(config.columns as Array<any>)
+          .filter(
+            (def) => def.aggregationFn != null || def.aggregatedCell != null,
+          )
+          .map(
+            (def) =>
+              def.id ??
+              (typeof def.accessorKey === 'string'
+                ? def.accessorKey.replaceAll('.', '_')
+                : undefined),
+          )
+          .filter((id): id is string => id != null)
+      } else {
+        table.setOptions((prev) => ({ ...prev, data: message.data }))
+      }
+      // Map row ids to data positions once per dataset; serialization uses it
+      // to express every stage result in terms of core row positions.
+      const coreFlatRows = table.getCoreRowModel().flatRows
+      coreIndexById = makeObjectMap()
+      for (let i = 0; i < coreFlatRows.length; i++) {
+        coreIndexById[coreFlatRows[i]!.id] = i
+      }
+      return
+    }
+
+    if (!table) return
+
+    const start = performance.now()
+
+    // Apply the serializable state slices to the shadow table's base atoms.
+    table._reactivity.batch(() => {
+      for (const [key, value] of Object.entries(message.state)) {
+        const baseAtom = (table!.baseAtoms as Record<string, any>)[key]
+        if (baseAtom && value !== undefined) {
+          baseAtom.set(value)
+        }
+      }
+    })
+
+    // Compute exactly the stages the main thread requested, skipping any this
+    // shadow table has no row model factory for (the main thread warns).
+    const stages: { [K in TableWorkerStage]?: TableWorkerStagePayload } = {}
+    const transfer: Array<Transferable> = []
+
+    for (const stage of message.stages) {
+      if (!(config.features as Record<string, unknown>)[`${stage}RowModel`]) {
+        continue
+      }
+      const model = (table as any)[`get${capitalize(stage)}RowModel`]()
+      // Memoized getters return the same object when inputs are unchanged;
+      // skip re-serializing (and the main thread skips rebuilding). Safe under
+      // single-flight: results are never dropped within a dataVersion.
+      if (lastSentModels[stage] === model) {
+        stages[stage] = { kind: 'unchanged' }
+        continue
+      }
+      lastSentModels[stage] = model
+      stages[stage] = serializeRowModel(
+        model,
+        coreIndexById,
+        aggregateColumnIds,
+        transfer,
+      )
+    }
+
+    const response: TableWorkerResult = {
+      type: 'result',
+      requestId: message.requestId,
+      dataVersion,
+      stages,
+      computeMs: performance.now() - start,
+    }
+    postMessage(response, { transfer })
+  }
+}

package/src/worker/rebuildRowModel.ts

@@ -0,0 +1,120 @@
+import { constructRow } from '../core/rows/constructRow'
+import { hasOwn } from '../utils'
+import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'
+import type { Table_Internal } from '../types/Table'
+import type { TableFeatures } from '../types/TableFeatures'
+import type { RowData } from '../types/type-utils'
+import type {
+  TableWorkerRowNode,
+  TableWorkerStagePayload,
+} from './tableWorkerProtocol'
+
+/** Payloads that carry data; `unchanged` never reaches the rebuilder. */
+export type TableWorkerDataPayload = Exclude<
+  TableWorkerStagePayload,
+  { kind: 'unchanged' }
+>
+
+// Main-thread side: payload + this table's core rows -> RowModel. Mirrors how
+// the sync row models treat rows: data rows are reused (with depth/parentId
+// rewritten, exactly like createGroupedRowModel does), synthetic group rows
+// are reconstructed via constructRow with their worker-computed aggregates
+// pre-seeded so no aggregation ever runs on the main thread.
+
+function collectLeafRows(subRows: Array<any>, out: Array<any>) {
+  for (let i = 0; i < subRows.length; i++) {
+    const row = subRows[i]
+    if (row.groupingColumnId == null) {
+      out.push(row)
+    } else {
+      collectLeafRows(row.subRows, out)
+    }
+  }
+}
+
+export function rebuildRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  payload: TableWorkerDataPayload,
+  /**
+   * Whether a flat payload should rewrite row depth/parentId. Mirrors core:
+   * the grouped model's passthrough resets them, the filtered model never
+   * touches them. Without this distinction a filtered rebuild could zero the
+   * depths a grouped/sorted tree rebuild just assigned to shared row objects.
+   */
+  resetDepths: boolean,
+): RowModel<TFeatures, TData> {
+  const core = table.getCoreRowModel()
+
+  if (payload.kind === 'flat') {
+    const { indices } = payload
+    const rows = new Array(indices.length)
+    for (let i = 0; i < indices.length; i++) {
+      const row: any = core.flatRows[indices[i]!]!
+      if (resetDepths) {
+        row.depth = 0
+        row.parentId = undefined
+      }
+      rows[i] = row
+    }
+    return { rows, flatRows: rows, rowsById: core.rowsById }
+  }
+
+  const flatRows: Array<any> = []
+  // Data rows resolve through the prototype chain to the core map; only
+  // synthetic group rows are added on top.
+  const rowsById: Record<string, any> = Object.create(core.rowsById)
+
+  const rebuildRows = (
+    nodes: Array<TableWorkerRowNode>,
+    depth: number,
+    parentId: string | undefined,
+  ): Array<any> => {
+    const rows = new Array(nodes.length)
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i]!
+      if (typeof node === 'number') {
+        const row: any = core.flatRows[node]!
+        row.depth = depth
+        row.parentId = parentId
+        flatRows.push(row)
+        rows[i] = row
+        continue
+      }
+
+      const subRows = rebuildRows(node.children, depth + 1, node.id)
+      const leafRows: Array<any> = []
+      collectLeafRows(subRows, leafRows)
+
+      const row: any = constructRow(
+        table,
+        node.id,
+        leafRows[0]?.original,
+        node.index,
+        depth,
+        undefined,
+        parentId,
+      )
+      const aggregates = node.aggregates
+      Object.assign(row, {
+        groupingColumnId: node.groupingColumnId,
+        groupingValue: node.groupingValue,
+        subRows,
+        leafRows,
+        getValue: (columnId: string) =>
+          hasOwn(aggregates, columnId) ? aggregates[columnId] : undefined,
+      })
+
+      flatRows.push(row)
+      rowsById[node.id] = row
+      rows[i] = row
+    }
+    return rows
+  }
+
+  const rows = rebuildRows(payload.children, 0, undefined)
+
+  return { rows, flatRows, rowsById }
+}

package/src/worker/serializeRowModel.ts

@@ -0,0 +1,80 @@
+import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'
+import type {
+  TableWorkerRowNode,
+  TableWorkerStagePayload,
+} from './tableWorkerProtocol'
+
+// Worker-side: RowModel -> transferable payload. Stage-agnostic; the payload
+// kind is chosen from the model's shape (synthetic rows present or not).
+
+function isCloneSafe(value: unknown): boolean {
+  return typeof value !== 'function' && typeof value !== 'symbol'
+}
+
+function serializeRows(
+  rows: Array<any>,
+  coreIndexById: Record<string, number>,
+  aggregateColumnIds: Array<string>,
+): Array<TableWorkerRowNode> {
+  const nodes = new Array<TableWorkerRowNode>(rows.length)
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    if (row.groupingColumnId == null) {
+      // Data row: its position in `options.data` is all the main thread needs.
+      nodes[i] = coreIndexById[row.id]!
+      continue
+    }
+    // Synthetic group row: compute aggregates eagerly (the expensive per-group
+    // work we want off the main thread), but only for columns with an explicit
+    // aggregation; sync tables aggregate lazily, so eagerly auto-aggregating
+    // every column would explode on high-cardinality grouping.
+    const aggregates: Record<string, unknown> = {}
+    for (let c = 0; c < aggregateColumnIds.length; c++) {
+      const columnId = aggregateColumnIds[c]!
+      const value = row.getValue(columnId)
+      if (value !== undefined && isCloneSafe(value)) {
+        aggregates[columnId] = value
+      }
+    }
+    // The group's own column always serializes its display value (the first
+    // leaf's value) so grouped cells render.
+    if (!(row.groupingColumnId in aggregates)) {
+      const value = row.getValue(row.groupingColumnId)
+      if (value !== undefined && isCloneSafe(value)) {
+        aggregates[row.groupingColumnId] = value
+      }
+    }
+    nodes[i] = {
+      id: row.id,
+      groupingColumnId: row.groupingColumnId,
+      groupingValue: row.groupingValue,
+      index: row.index,
+      aggregates,
+      children: serializeRows(row.subRows, coreIndexById, aggregateColumnIds),
+    }
+  }
+  return nodes
+}
+
+export function serializeRowModel(
+  model: RowModel<any, any>,
+  coreIndexById: Record<string, number>,
+  aggregateColumnIds: Array<string>,
+  transfer: Array<Transferable>,
+): TableWorkerStagePayload {
+  // Flat fast path: no synthetic rows anywhere (flatRows === rows for flat
+  // data). A Uint32Array permutation transfers at zero-copy cost.
+  if (model.flatRows.length === model.rows.length) {
+    const indices = new Uint32Array(model.rows.length)
+    for (let i = 0; i < indices.length; i++) {
+      indices[i] = coreIndexById[model.rows[i]!.id]!
+    }
+    transfer.push(indices.buffer)
+    return { kind: 'flat', indices }
+  }
+
+  return {
+    kind: 'tree',
+    children: serializeRows(model.rows, coreIndexById, aggregateColumnIds),
+  }
+}

package/src/worker/tableWorkerProtocol.ts

@@ -0,0 +1,105 @@
+import type { RowData } from '../types/type-utils'
+
+/**
+ * Row model stages that can be offloaded to the worker, in pipeline order.
+ * Everything else in this module is derived from this list; adding a stage
+ * means adding an entry here and to `tableWorkerStageStateDeps`.
+ */
+export const tableWorkerPipeline = [
+  'filtered',
+  'grouped',
+  'sorted',
+  'expanded',
+] as const
+
+export type TableWorkerStage = (typeof tableWorkerPipeline)[number]
+
+/**
+ * The state slices each stage's computation depends on. The main thread sends
+ * the union of deps for its registered stages; a change to any of them
+ * triggers one worker round trip.
+ */
+export const tableWorkerStageStateDeps: Record<
+  TableWorkerStage,
+  Array<string>
+> = {
+  filtered: ['columnFilters', 'globalFilter'],
+  grouped: ['grouping'],
+  sorted: ['sorting'],
+  expanded: ['expanded'],
+}
+
+/**
+ * A serialized synthetic (group) row. Leaf rows serialize as their position in
+ * `options.data`; group rows carry what `constructRow` + the grouped row model
+ * need to rebuild them, plus eagerly computed aggregate values so no
+ * aggregation runs on the main thread.
+ */
+export interface TableWorkerGroupNode {
+  id: string
+  groupingColumnId: string
+  groupingValue: unknown
+  index: number
+  aggregates: Record<string, unknown>
+  children: Array<TableWorkerRowNode>
+}
+
+export type TableWorkerRowNode = number | TableWorkerGroupNode
+
+/**
+ * A stage result. Flat models (every row is a data row) travel as a
+ * transferable index permutation; models containing synthetic rows (grouping)
+ * travel as a tree. The kind is chosen from the model's actual shape at
+ * runtime, not from the stage name: a sorted model is flat without grouping
+ * and a tree with it.
+ *
+ * `unchanged` means the stage's model is identical to the last one sent for
+ * this dataset (its memoized inputs did not change); the main thread keeps
+ * its previous result and skips the rebuild entirely.
+ */
+export type TableWorkerStagePayload =
+  | { kind: 'flat'; indices: Uint32Array }
+  | { kind: 'tree'; children: Array<TableWorkerRowNode> }
+  | { kind: 'unchanged' }
+
+export type TableWorkerRequest<TData extends RowData = any> =
+  | {
+      type: 'data'
+      dataVersion: number
+      data: Array<TData>
+    }
+  | {
+      type: 'process'
+      requestId: number
+      dataVersion: number
+      /** The stages the main thread has worker-backed row models for. */
+      stages: Array<TableWorkerStage>
+      /** Serializable state slices (union of the stages' deps). */
+      state: Record<string, unknown>
+    }
+
+export interface TableWorkerResult {
+  type: 'result'
+  requestId: number
+  dataVersion: number
+  stages: { [K in TableWorkerStage]?: TableWorkerStagePayload }
+  computeMs: number
+}
+
+export type TableWorkerResponse = TableWorkerResult
+
+/**
+ * The state slice added by `workerRowModelsFeature`. `version` bumps when a
+ * worker result lands (driving re-renders through the normal state path);
+ * `isPending` is true while a request is in flight. The timing fields expose
+ * the last result's worker compute time and full round trip for devtools and
+ * debugging.
+ */
+export interface TableState_WorkerRowModels {
+  workerRowModels: {
+    version: number
+    isPending: boolean
+    lastComputeMs?: number
+    lastRoundTripMs?: number
+  }
+}

package/dist/fns/aggregationFns.cjs

@@ -1,161 +0,0 @@
-
-//#region src/fns/aggregationFns.ts
-/**
-* Sums numeric child-row values for a grouped column.
-*
-* Non-number values contribute `0`. Child rows are used so nested group totals
-* can reuse already aggregated values.
-*/
-function aggregationFn_sum(columnId, _leafRows, childRows) {
-	return childRows.reduce((sumValue, next) => {
-		const nextValue = next.getValue(columnId);
-		return sumValue + (typeof nextValue === "number" ? nextValue : 0);
-	}, 0);
-}
-/**
-* Finds the minimum numeric child-row value for a grouped column.
-*
-* Nullish and non-number values are ignored. Returns `undefined` when no
-* numeric value is found.
-*/
-function aggregationFn_min(columnId, _leafRows, childRows) {
-	let minValue;
-	childRows.forEach((row) => {
-		const value = row.getValue(columnId);
-		if (value != null && typeof value === "number" && (minValue === void 0 || value < minValue)) minValue = value;
-	});
-	return minValue;
-}
-/**
-* Finds the maximum numeric child-row value for a grouped column.
-*
-* Nullish and non-number values are ignored. Returns `undefined` when no
-* numeric value is found.
-*/
-function aggregationFn_max(columnId, _leafRows, childRows) {
-	let maxValue;
-	childRows.forEach((row) => {
-		const value = row.getValue(columnId);
-		if (value != null && typeof value === "number" && (maxValue === void 0 || value > maxValue)) maxValue = value;
-	});
-	return maxValue;
-}
-/**
-* Finds the numeric extent for a grouped column.
-*
-* Returns `[min, max]`, where each entry is `undefined` when no numeric value is
-* present.
-*/
-function aggregationFn_extent(columnId, _leafRows, childRows) {
-	let minValue;
-	let maxValue;
-	childRows.forEach((row) => {
-		const value = row.getValue(columnId);
-		if (value != null && typeof value === "number") if (minValue === void 0) minValue = maxValue = value;
-		else {
-			if (minValue > value) minValue = value;
-			if (maxValue < value) maxValue = value;
-		}
-	});
-	return [minValue, maxValue];
-}
-/**
-* Averages numeric leaf-row values for a grouped column.
-*
-* Number-like values are coerced with unary `+`; nullish and non-numeric values
-* are ignored.
-*/
-function aggregationFn_mean(columnId, leafRows) {
-	let count = 0;
-	let sumValue = 0;
-	leafRows.forEach((row) => {
-		const value = row.getValue(columnId);
-		if (value != null && typeof value === "number") {
-			++count;
-			sumValue += value;
-		} else if (value != null) {
-			const numValue = +value;
-			if (!Number.isNaN(numValue)) {
-				++count;
-				sumValue += numValue;
-			}
-		}
-	});
-	if (count) return sumValue / count;
-}
-/**
-* Computes the median of numeric leaf-row values for a grouped column.
-*
-* All values must be numbers. If any value is non-numeric, or no leaf rows are
-* present, the result is `undefined`.
-*/
-function aggregationFn_median(columnId, leafRows) {
-	if (!leafRows.length) return;
-	const values = new Array(leafRows.length);
-	for (let i = 0; i < leafRows.length; i++) {
-		const v = leafRows[i].getValue(columnId);
-		if (typeof v !== "number") return;
-		values[i] = v;
-	}
-	if (values.length === 1) return values[0];
-	const mid = Math.floor(values.length / 2);
-	values.sort((a, b) => a - b);
-	return values.length % 2 !== 0 ? values[mid] : (values[mid - 1] + values[mid]) / 2;
-}
-/**
-* Collects unique leaf-row values for a grouped column.
-*
-* Values are compared with JavaScript `Set` semantics.
-*/
-function aggregationFn_unique(columnId, leafRows) {
-	const set = /* @__PURE__ */ new Set();
-	for (let i = 0; i < leafRows.length; i++) set.add(leafRows[i].getValue(columnId));
-	return Array.from(set.values());
-}
-/**
-* Counts unique leaf-row values for a grouped column.
-*
-* Values are compared with JavaScript `Set` semantics.
-*/
-function aggregationFn_uniqueCount(columnId, leafRows) {
-	const set = /* @__PURE__ */ new Set();
-	for (let i = 0; i < leafRows.length; i++) set.add(leafRows[i].getValue(columnId));
-	return set.size;
-}
-/**
-* Counts the number of leaf rows in the group.
-*
-* The column id is ignored because the result is based only on group size.
-*/
-function aggregationFn_count(_columnId, leafRows) {
-	return leafRows.length;
-}
-/**
-* The built-in aggregation function registry.
-*
-* Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.
-*/
-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
-};
-
-//#endregion
-exports.aggregationFn_count = aggregationFn_count;
-exports.aggregationFn_extent = aggregationFn_extent;
-exports.aggregationFn_max = aggregationFn_max;
-exports.aggregationFn_mean = aggregationFn_mean;
-exports.aggregationFn_median = aggregationFn_median;
-exports.aggregationFn_min = aggregationFn_min;
-exports.aggregationFn_sum = aggregationFn_sum;
-exports.aggregationFn_unique = aggregationFn_unique;
-exports.aggregationFn_uniqueCount = aggregationFn_uniqueCount;
-exports.aggregationFns = aggregationFns;
-//# sourceMappingURL=aggregationFns.cjs.map

package/dist/fns/aggregationFns.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregationFns.cjs","names":[],"sources":["../../src/fns/aggregationFns.ts"],"sourcesContent":["import type { RowData } from '../types/type-utils'\nimport type { TableFeatures } from '../types/TableFeatures'\nimport type { Row } from '../types/Row'\n\n/**\n * Sums numeric child-row values for a grouped column.\n *\n * Non-number values contribute `0`. Child rows are used so nested group totals\n * can reuse already aggregated values.\n */\nexport function aggregationFn_sum<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  // It's faster to just add the aggregations together instead of\n  // process leaf nodes individually\n  return childRows.reduce((sumValue, next) => {\n    const nextValue = next.getValue(columnId)\n    return sumValue + (typeof nextValue === 'number' ? nextValue : 0)\n  }, 0)\n}\n\n/**\n * Finds the minimum numeric child-row value for a grouped column.\n *\n * Nullish and non-number values are ignored. Returns `undefined` when no\n * numeric value is found.\n */\nexport function aggregationFn_min<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let minValue: number | undefined\n\n  childRows.forEach((row) => {\n    const value = row.getValue(columnId)\n\n    if (\n      value != null &&\n      typeof value === 'number' &&\n      (minValue === undefined || value < minValue)\n    ) {\n      minValue = value\n    }\n  })\n\n  return minValue\n}\n\n/**\n * Finds the maximum numeric child-row value for a grouped column.\n *\n * Nullish and non-number values are ignored. Returns `undefined` when no\n * numeric value is found.\n */\nexport function aggregationFn_max<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let maxValue: number | undefined\n\n  childRows.forEach((row) => {\n    const value = row.getValue(columnId)\n    if (\n      value != null &&\n      typeof value === 'number' &&\n      (maxValue === undefined || value > maxValue)\n    ) {\n      maxValue = value\n    }\n  })\n\n  return maxValue\n}\n\n/**\n * Finds the numeric extent for a grouped column.\n *\n * Returns `[min, max]`, where each entry is `undefined` when no numeric value is\n * present.\n */\nexport function aggregationFn_extent<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  columnId: string,\n  _leafRows: Array<Row<TFeatures, TData>>,\n  childRows: Array<Row<TFeatures, TData>>,\n) {\n  let minValue: number | undefined\n  let maxValue: number | undefined\n\n  childRows.forEach((row) => {\n    const value = row.getValue(columnId)\n    if (value != null && typeof value === 'number') {\n      if (minValue === undefined) {\n        minValue = maxValue = value\n      } else {\n        if (minValue > value) minValue = value\n        if (maxValue! < value) maxValue = value\n      }\n    }\n  })\n\n  return [minValue, maxValue]\n}\n\n/**\n * Averages numeric leaf-row values for a grouped column.\n *\n * Number-like values are coerced with unary `+`; nullish and non-numeric values\n * are ignored.\n */\nexport function aggregationFn_mean<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  let count = 0\n  let sumValue = 0\n\n  leafRows.forEach((row) => {\n    const value = row.getValue(columnId)\n    if (value != null && typeof value === 'number') {\n      ++count\n      sumValue += value\n    } else if (value != null) {\n      const numValue = +value\n      if (!Number.isNaN(numValue)) {\n        ++count\n        sumValue += numValue\n      }\n    }\n  })\n\n  if (count) return sumValue / count\n\n  return\n}\n\n/**\n * Computes the median of numeric leaf-row values for a grouped column.\n *\n * All values must be numbers. If any value is non-numeric, or no leaf rows are\n * present, the result is `undefined`.\n */\nexport function aggregationFn_median<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  if (!leafRows.length) {\n    return\n  }\n\n  const values: Array<number> = new Array(leafRows.length)\n  for (let i = 0; i < leafRows.length; i++) {\n    const v = leafRows[i]!.getValue(columnId)\n    if (typeof v !== 'number') return\n    values[i] = v\n  }\n\n  if (values.length === 1) {\n    return values[0]\n  }\n\n  const mid = Math.floor(values.length / 2)\n  values.sort((a, b) => a - b)\n  return values.length % 2 !== 0\n    ? values[mid]\n    : (values[mid - 1]! + values[mid]!) / 2\n}\n\n/**\n * Collects unique leaf-row values for a grouped column.\n *\n * Values are compared with JavaScript `Set` semantics.\n */\nexport function aggregationFn_unique<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  const set = new Set<unknown>()\n  for (let i = 0; i < leafRows.length; i++) {\n    set.add(leafRows[i]!.getValue(columnId))\n  }\n  return Array.from(set.values())\n}\n\n/**\n * Counts unique leaf-row values for a grouped column.\n *\n * Values are compared with JavaScript `Set` semantics.\n */\nexport function aggregationFn_uniqueCount<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  const set = new Set<unknown>()\n  for (let i = 0; i < leafRows.length; i++) {\n    set.add(leafRows[i]!.getValue(columnId))\n  }\n  return set.size\n}\n\n/**\n * Counts the number of leaf rows in the group.\n *\n * The column id is ignored because the result is based only on group size.\n */\nexport function aggregationFn_count<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(_columnId: string, leafRows: Array<Row<TFeatures, TData>>) {\n  return leafRows.length\n}\n\n/**\n * The built-in aggregation function registry.\n *\n * Pass this object to grouped row model creation or extend it with custom aggregation functions for grouped columns.\n */\nexport const aggregationFns = {\n  sum: aggregationFn_sum,\n  min: aggregationFn_min,\n  max: aggregationFn_max,\n  extent: aggregationFn_extent,\n  mean: aggregationFn_mean,\n  median: aggregationFn_median,\n  unique: aggregationFn_unique,\n  uniqueCount: aggregationFn_uniqueCount,\n  count: aggregationFn_count,\n}\n\nexport type BuiltInAggregationFn = keyof typeof aggregationFns\n"],"mappings":"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"}