@tanstack/table-core 9.0.0-beta.9 → 9.0.1

package/dist/features/row-aggregation/aggregationFns.js

@@ -0,0 +1,279 @@
+import { constructAggregationFn } from "./rowAggregationFeature.types.js";
+
+//#region src/features/row-aggregation/aggregationFns.ts
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isValidDate(value) {
+	return value instanceof Date && !Number.isNaN(value.getTime());
+}
+function getRangeKind(value) {
+	if (isNumber(value)) return "number";
+	if (isValidDate(value)) return "date";
+}
+function compareRangeValues(left, right) {
+	return (left instanceof Date ? left.getTime() : left) - (right instanceof Date ? right.getTime() : right);
+}
+/** Comparable representation of a range value; `Date`s compare by time. */
+function toRangeNumber(value) {
+	return value instanceof Date ? value.getTime() : value;
+}
+/**
+* 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.
+*/
+const aggregationFn_sum = constructAggregationFn({
+	aggregate: (context) => {
+		const rows = context.rows;
+		let sum = 0;
+		for (let i = 0; i < rows.length; i++) {
+			const value = context.getValue(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.
+*/
+const aggregationFn_min = constructAggregationFn({
+	aggregate: (context) => {
+		const rows = context.rows;
+		let kind;
+		let result;
+		let resultNumber = 0;
+		for (let i = 0; i < rows.length; i++) {
+			const value = context.getValue(rows[i]);
+			const valueKind = getRangeKind(value);
+			if (!valueKind || kind !== void 0 && valueKind !== kind) continue;
+			const valueNumber = toRangeNumber(value);
+			if (kind === void 0) {
+				kind = valueKind;
+				result = value;
+				resultNumber = valueNumber;
+			} else if (valueNumber - resultNumber < 0) {
+				result = value;
+				resultNumber = valueNumber;
+			}
+		}
+		return result;
+	},
+	merge: ({ subRowResults }) => {
+		let result;
+		let kind;
+		for (let i = 0; i < subRowResults.length; i++) {
+			const value = subRowResults[i];
+			const valueKind = getRangeKind(value);
+			if (!valueKind) continue;
+			if (value === void 0) continue;
+			kind ??= valueKind;
+			if (kind !== valueKind) continue;
+			if (result === void 0 || 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.
+*/
+const aggregationFn_max = constructAggregationFn({
+	aggregate: (context) => {
+		const rows = context.rows;
+		let kind;
+		let result;
+		let resultNumber = 0;
+		for (let i = 0; i < rows.length; i++) {
+			const value = context.getValue(rows[i]);
+			const valueKind = getRangeKind(value);
+			if (!valueKind || kind !== void 0 && valueKind !== kind) continue;
+			const valueNumber = toRangeNumber(value);
+			if (kind === void 0) {
+				kind = valueKind;
+				result = value;
+				resultNumber = valueNumber;
+			} else if (valueNumber - resultNumber > 0) {
+				result = value;
+				resultNumber = valueNumber;
+			}
+		}
+		return result;
+	},
+	merge: ({ subRowResults }) => {
+		let result;
+		let kind;
+		for (let i = 0; i < subRowResults.length; i++) {
+			const value = subRowResults[i];
+			const valueKind = getRangeKind(value);
+			if (!valueKind) continue;
+			if (value === void 0) continue;
+			kind ??= valueKind;
+			if (kind !== valueKind) continue;
+			if (result === void 0 || 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.
+*/
+const aggregationFn_extent = constructAggregationFn({
+	aggregate: (context) => {
+		const rows = context.rows;
+		let kind;
+		let min;
+		let max;
+		let minNumber = 0;
+		let maxNumber = 0;
+		for (let i = 0; i < rows.length; i++) {
+			const value = context.getValue(rows[i]);
+			const valueKind = getRangeKind(value);
+			if (!valueKind || kind !== void 0 && valueKind !== kind) continue;
+			const valueNumber = toRangeNumber(value);
+			if (kind === void 0) {
+				kind = valueKind;
+				min = max = value;
+				minNumber = maxNumber = valueNumber;
+			} else {
+				if (valueNumber - minNumber < 0) {
+					min = value;
+					minNumber = valueNumber;
+				}
+				if (valueNumber - maxNumber > 0) {
+					max = value;
+					maxNumber = valueNumber;
+				}
+			}
+		}
+		if (kind === void 0) return [void 0, void 0];
+		return [min, max];
+	},
+	merge: ({ subRowResults }) => {
+		let result = [void 0, void 0];
+		let kind;
+		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 === void 0 || max === void 0) continue;
+			kind ??= valueKind;
+			if (kind !== valueKind) continue;
+			if (result[0] === void 0) result = [min, max];
+			else {
+				if (compareRangeValues(min, result[0]) < 0) result[0] = min;
+				const currentMax = result[1];
+				if (currentMax === void 0 || 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.
+*/
+const aggregationFn_mean = constructAggregationFn({ aggregate: (context) => {
+	const rows = context.rows;
+	let count = 0;
+	let sum = 0;
+	for (let i = 0; i < rows.length; i++) {
+		const value = context.getValue(rows[i]);
+		if (value == null) continue;
+		const numberValue = typeof value === "number" ? value : +value;
+		if (!Number.isNaN(numberValue)) {
+			count++;
+			sum += numberValue;
+		}
+	}
+	return count ? sum / count : void 0;
+} });
+/**
+* Computes the median of the numeric row values. Non-numeric values are
+* ignored, matching the `sum`/`min`/`max`/`mean` aggregations. Returns
+* `undefined` when no numeric values remain.
+*/
+const aggregationFn_median = constructAggregationFn({ aggregate: (context) => {
+	const rows = context.rows;
+	const values = [];
+	for (let i = 0; i < rows.length; i++) {
+		const value = context.getValue(rows[i]);
+		if (typeof value === "number") values.push(value);
+	}
+	if (!values.length) return void 0;
+	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. */
+const aggregationFn_unique = constructAggregationFn({ aggregate: (context) => {
+	const rows = context.rows;
+	const values = /* @__PURE__ */ new Set();
+	for (let i = 0; i < rows.length; i++) values.add(context.getValue(rows[i]));
+	return Array.from(values);
+} });
+/** Counts distinct row values using JavaScript `Set` semantics. */
+const aggregationFn_uniqueCount = constructAggregationFn({ aggregate: (context) => {
+	const rows = context.rows;
+	const values = /* @__PURE__ */ new Set();
+	for (let i = 0; i < rows.length; i++) values.add(context.getValue(rows[i]));
+	return values.size;
+} });
+/** Counts rows, independently of the column's values. */
+const aggregationFn_count = constructAggregationFn({
+	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. */
+const aggregationFn_first = constructAggregationFn({
+	aggregate: (context) => context.rows[0] ? context.getValue(context.rows[0]) : void 0,
+	merge: ({ subRowResults }) => subRowResults[0]
+});
+/** Returns the last row's value, including a nullish value. */
+const aggregationFn_last = constructAggregationFn({
+	aggregate: (context) => {
+		const row = context.rows[context.rows.length - 1];
+		return row ? context.getValue(row) : void 0;
+	},
+	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.
+*/
+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
+};
+
+//#endregion
+export { aggregationFn_count, aggregationFn_extent, aggregationFn_first, aggregationFn_last, aggregationFn_max, aggregationFn_mean, aggregationFn_median, aggregationFn_min, aggregationFn_sum, aggregationFn_unique, aggregationFn_uniqueCount, aggregationFns };

package/dist/features/row-aggregation/rowAggregationFeature.d.ts

@@ -0,0 +1,8 @@
+import { TableFeature } from "../../types/TableFeatures.js";
+//#region src/features/row-aggregation/rowAggregationFeature.d.ts
+/**
+ * Independent aggregation feature for grouped values and root/custom-row totals.
+ */
+declare const rowAggregationFeature: TableFeature;
+//#endregion
+export { rowAggregationFeature };

package/dist/features/row-aggregation/rowAggregationFeature.js

@@ -0,0 +1,35 @@
+import { assignPrototypeAPIs } from "../../utils.js";
+import { cell_getIsAggregated, column_getAggregationFns, column_getAggregationValue, column_getAutoAggregationFn, formatAggregatedCellValue } from "./rowAggregationFeature.utils.js";
+
+//#region src/features/row-aggregation/rowAggregationFeature.ts
+/**
+* Independent aggregation feature for grouped values and root/custom-row totals.
+*/
+const rowAggregationFeature = {
+	getDefaultColumnDef: () => ({
+		aggregatedCell: ({ column, getValue }) => formatAggregatedCellValue(getValue(), column.columnDef.aggregationFn),
+		aggregationFn: "auto",
+		maxAggregationDepth: 0
+	}),
+	getDefaultTableOptions: () => ({ manualAggregation: false }),
+	assignCellPrototype: (prototype, table) => {
+		assignPrototypeAPIs("rowAggregationFeature", prototype, table, { cell_getIsAggregated: { fn: (cell) => cell_getIsAggregated(cell) } });
+	},
+	assignColumnPrototype: (prototype, table) => {
+		assignPrototypeAPIs("rowAggregationFeature", prototype, table, {
+			column_getAggregationFns: { fn: (column) => column_getAggregationFns(column) },
+			column_getAggregationValue: { fn: (column, options) => column_getAggregationValue(column, options) },
+			column_getAutoAggregationFn: {
+				fn: (column) => column_getAutoAggregationFn(column),
+				memoDeps: (column) => [column.table.getCoreRowModel(), column.table._rowModelFns.aggregationFns]
+			}
+		});
+	},
+	initColumnInstanceData: (column) => {
+		column._aggregationValueCache = void 0;
+		column._resolvedAggregationFnsCache = void 0;
+	}
+};
+
+//#endregion
+export { rowAggregationFeature };

package/dist/features/row-aggregation/rowAggregationFeature.types.d.ts

@@ -0,0 +1,193 @@
+import { CellData, RowData } from "../../types/type-utils.js";
+import { BuiltInAggregationFn } from "./aggregationFns.js";
+import { ColumnDefTemplate } from "../../types/ColumnDef.js";
+import { Column } from "../../types/Column.js";
+import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
+import { Cell } from "../../types/Cell.js";
+import { IsAny, TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/row-aggregation/rowAggregationFeature.types.d.ts
+/** Declaration-merging fallback for named aggregation definitions. */
+interface AggregationFns {}
+/** Values and table objects available while one aggregation is evaluated. */
+interface AggregationContext<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> {
+  /** The column whose values are being aggregated. */
+  column: Column<TFeatures, TData, TValue>;
+  /** Convenience alias for `column.id`. */
+  columnId: string;
+  /** Maximum relative sub-row depth used to select `rows`. */
+  maxDepth: number;
+  /**
+   * Immediate sub-rows for grouped aggregation. This property is omitted
+   * for root or caller-supplied-row aggregation. At a terminal grouping level
+   * these are the direct data rows; at a nested level they are sub-row groups.
+   */
+  subRows?: ReadonlyArray<Row<TFeatures, TData>>;
+  /** Reads this column's value from one of `rows`. */
+  getValue: (row: Row<TFeatures, TData>) => TValue;
+  /**
+   * The synthetic grouped row receiving this result. This property is omitted
+   * for root or caller-supplied-row aggregation. Its `depth` identifies the
+   * grouping level when grouped aggregation needs that distinction.
+   */
+  groupingRow?: Row<TFeatures, TData>;
+  /**
+   * Unique rows selected at `maxDepth`. Branches that end before `maxDepth`
+   * contribute their deepest available row.
+   */
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column and rows. */
+  table: Table<TFeatures, TData>;
+}
+/** Additional values available when merging nested grouped results. */
+interface AggregationMergeContext<TFeatures extends TableFeatures, TData extends RowData, TValue, TResult> extends AggregationContext<TFeatures, TData, TValue> {
+  /** Results produced for each immediate sub-row group, in sub-row order. */
+  subRowResults: ReadonlyArray<TResult>;
+  /** Immediate sub-row groups corresponding to `subRowResults`. */
+  subRows: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/** A context-based aggregation definition and optional grouped-result merge. */
+interface AggregationFnDef<TFeatures extends TableFeatures = any, TData extends RowData = any, TValue = unknown, TResult = unknown> {
+  /** Computes a result directly from the selected `rows`. */
+  aggregate: (context: AggregationContext<TFeatures, TData, TValue>) => TResult;
+  /**
+   * Combines already-computed immediate sub-row results. When omitted,
+   * nested grouping falls back to `aggregate` over the group's selected rows.
+   */
+  merge?: (context: AggregationMergeContext<TFeatures, TData, TValue, TResult>) => TResult;
+}
+/**
+ * Creates a typed context-based aggregation definition for a column or
+ * aggregation-function registry.
+ */
+declare function constructAggregationFn<TFeatures extends TableFeatures = any, TData extends RowData = any, TValue = unknown, TResult = unknown>(definition: AggregationFnDef<TFeatures, TData, TValue, TResult>): AggregationFnDef<TFeatures, TData, TValue, TResult>;
+/** Aggregation-definition registry carried by a table feature set. */
+interface RowModelFns_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  aggregationFns: Record<string, AggregationFnDef<TFeatures, TData, any, any>>;
+}
+/** Named context-based aggregation definitions registered on a feature set. */
+type CustomAggregationFns<TFeatures extends TableFeatures, TData extends RowData> = Record<string, AggregationFnDef<TFeatures, TData, any, any>>;
+/** String names available from a feature set's aggregation registry. */
+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;
+/** A registered name, automatic inference, or inline aggregation definition. */
+type AggregationFnRef<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown, TResult = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDef<TFeatures, TData, TValue, TResult>;
+/** Gives an aggregation reference a stable key in a multiple result. */
+interface AggregationFnDescriptor<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown, TResult = unknown> {
+  /** The named, automatic, or inline definition to execute. */
+  aggregationFn: AggregationFnRef<TFeatures, TData, TValue, TResult>;
+  /** Stable key used in the object returned by a multiple aggregation. */
+  id: string;
+}
+/** One named or explicitly keyed entry in a multiple aggregation option. */
+type AggregationFnListItem<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> = 'auto' | ExtractAggregationFnKeys<TFeatures> | AggregationFnDescriptor<TFeatures, TData, TValue, any>;
+/** A scalar aggregation reference or a list that produces a keyed object. */
+type AggregationFnOption<TFeatures extends TableFeatures, TData extends RowData, TValue = unknown> = AggregationFnRef<TFeatures, TData, TValue, any> | ReadonlyArray<AggregationFnListItem<TFeatures, TData, TValue>>;
+/** Extracts the result type produced by an aggregation definition. */
+type AggregationResultOf<TDefinition> = TDefinition extends AggregationFnDef<any, any, any, infer TResult> ? TResult : unknown;
+type RegisteredAggregationDefinition<TFeatures extends TableFeatures, TKey extends PropertyKey> = TFeatures extends {
+  aggregationFns: infer TRegistry extends Record<PropertyKey, unknown>;
+} ? TKey extends keyof TRegistry ? TRegistry[TKey] : never : never;
+type AggregationResultOfRef<TRef, TFeatures extends TableFeatures> = TRef extends AggregationFnDef<any, any, any, any> ? AggregationResultOf<TRef> : TRef extends 'auto' ? RegisteredAggregationResult<TFeatures> : TRef extends PropertyKey ? AggregationResultOf<RegisteredAggregationDefinition<TFeatures, TRef>> : unknown;
+type AggregationEntryId<TEntry> = TEntry extends string ? TEntry : TEntry extends {
+  id: infer TId extends string;
+} ? TId : never;
+type AggregationEntryDefinition<TEntry> = TEntry extends {
+  aggregationFn: infer TDefinition;
+} ? TDefinition : TEntry;
+/** Infers the scalar or keyed result produced by an aggregation option. */
+type AggregationResult<TOption, TFeatures extends TableFeatures = any> = TOption extends ReadonlyArray<infer TEntry> ? { [TKey in AggregationEntryId<TEntry>]: AggregationResultOfRef<AggregationEntryDefinition<Extract<TEntry, TKey | {
+  id: TKey;
+}>>, TFeatures>; } : AggregationResultOfRef<TOption, TFeatures>;
+type RegisteredAggregationResult<TFeatures extends TableFeatures> = TFeatures extends {
+  aggregationFns: infer TRegistry extends Record<string, unknown>;
+} ? AggregationResultOf<TRegistry[keyof TRegistry]> : unknown;
+/** Default public result union when a column's precise option is not known. */
+type ColumnAggregationValue<TFeatures extends TableFeatures> = RegisteredAggregationResult<TFeatures> | Record<string, RegisteredAggregationResult<TFeatures> | undefined> | undefined;
+/** A validated aggregation entry returned by `column.getAggregationFns()`. */
+interface ResolvedAggregationFn<TFeatures extends TableFeatures, TData extends RowData> {
+  /** Resolved definition, or `undefined` when configuration is invalid. */
+  aggregationFn: AggregationFnDef<TFeatures, TData, any, any> | undefined;
+  /** Key used for a multiple result; scalar inline definitions have no id. */
+  id: string | undefined;
+}
+/** Column-definition options installed by `rowAggregationFeature`. */
+interface ColumnDef_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
+  /** Renderer used for a grouped row's aggregated cell. */
+  aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TFeatures, TData, TValue>['getContext']>>;
+  /**
+   * One aggregation reference for a scalar result, or an array for a keyed
+   * result object. Inline definitions in an array require an explicit `id`.
+   */
+  aggregationFn?: AggregationFnOption<TFeatures, TData, TValue>;
+  /**
+   * Maximum relative sub-row depth used for grouped aggregation and cached
+   * default totals. `0` selects the supplied root rows, `1` their direct
+   * sub-rows, and so on. Defaults to `0`.
+   */
+  maxAggregationDepth?: number;
+  /**
+   * Optionally supplies a precomputed aggregation value for this column.
+   * Return `{ value }` to handle the request, including `{ value: undefined }`;
+   * return `undefined` to use the local aggregation fallback.
+   */
+  getAggregationValue?: (context: AggregationValueContext<TFeatures, TData, TValue>) => AggregationValueResult | undefined;
+}
+/** Column instance APIs installed by `rowAggregationFeature`. */
+interface Column_RowAggregation<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /** Resolves the configured scalar or multiple aggregation definitions. */
+  getAggregationFns: () => ReadonlyArray<ResolvedAggregationFn<TFeatures, TData>>;
+  /**
+   * Aggregates this column over the default pre-grouped row model, or over a
+   * caller-provided array of rows. `options.maxDepth` overrides the column's
+   * `maxAggregationDepth`. Explicit-row calls are intentionally not cached.
+   */
+  getAggregationValue: <TResult = ColumnAggregationValue<TFeatures>>(options?: AggregationValueOptions<TFeatures, TData>) => TResult;
+  /** Infers `sum` for a numeric first row and `extent` for a Date first row. */
+  getAutoAggregationFn: () => AggregationFnDef<TFeatures, TData, any, any> | undefined;
+}
+/** Options for a caller-requested column aggregation value. */
+interface AggregationValueOptions<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+  /** Overrides the column's `maxAggregationDepth` for this request. */
+  maxDepth?: number;
+  /** Rows to aggregate instead of the default pre-grouped row model. */
+  rows?: ReadonlyArray<Row<TFeatures, TData>>;
+}
+/** Cell instance APIs installed by `rowAggregationFeature`. */
+interface Cell_RowAggregation {
+  /** Whether this cell displays an aggregate on a synthetic grouped row. */
+  getIsAggregated: () => boolean;
+}
+/** Internal per-row cache used while grouped aggregates are evaluated. */
+interface Row_RowAggregation {
+  /** Cached aggregate results keyed by column id; created lazily on grouped rows. */
+  _aggregationValuesCache?: Record<string, unknown>;
+}
+/** Values passed to a column-level aggregation-value provider. */
+interface AggregationValueContext<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+  /** The column whose value was requested. */
+  column: Column<TFeatures, TData, TValue>;
+  /** Maximum relative sub-row depth used for the request. */
+  maxDepth: number;
+  /** Caller-provided rows, or `undefined` for the default row model. */
+  rows?: ReadonlyArray<Row<TFeatures, TData>>;
+  /** The table that owns the column. */
+  table: Table<TFeatures, TData>;
+}
+/** Marks an aggregation-value override as handled. */
+interface AggregationValueResult<TResult = unknown> {
+  /** The supplied value. `undefined` is still a handled result. */
+  value: TResult;
+}
+/** Table options installed by `rowAggregationFeature`. */
+interface TableOptions_RowAggregation {
+  /**
+   * Disables local `column.getAggregationValue()` calculation when a column
+   * override does not handle the request. Group values supplied by manually
+   * grouped rows remain the responsibility of the data owner.
+   */
+  manualAggregation?: boolean;
+}
+//#endregion
+export { AggregationContext, AggregationFnDef, AggregationFnDescriptor, AggregationFnListItem, AggregationFnOption, AggregationFnRef, AggregationFns, AggregationMergeContext, AggregationResult, AggregationResultOf, AggregationValueContext, AggregationValueOptions, AggregationValueResult, Cell_RowAggregation, ColumnAggregationValue, ColumnDef_RowAggregation, Column_RowAggregation, CustomAggregationFns, ExtractAggregationFnKeys, ResolvedAggregationFn, RowModelFns_RowAggregation, Row_RowAggregation, TableOptions_RowAggregation, constructAggregationFn };

package/dist/features/row-aggregation/rowAggregationFeature.types.js

@@ -0,0 +1,11 @@
+//#region src/features/row-aggregation/rowAggregationFeature.types.ts
+/**
+* Creates a typed context-based aggregation definition for a column or
+* aggregation-function registry.
+*/
+function constructAggregationFn(definition) {
+	return definition;
+}
+
+//#endregion
+export { constructAggregationFn };

package/dist/features/row-aggregation/rowAggregationFeature.utils.d.ts

@@ -0,0 +1,46 @@
+import { CellData, RowData } from "../../types/type-utils.js";
+import { AggregationFnDef, AggregationValueOptions, ColumnAggregationValue, ResolvedAggregationFn } from "./rowAggregationFeature.types.js";
+import { Column } from "../../types/Column.js";
+import { Row } from "../../types/Row.js";
+import { Cell } from "../../types/Cell.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
+//#region src/features/row-aggregation/rowAggregationFeature.utils.d.ts
+/**
+ * Selects unique rows at a maximum relative depth in encounter order.
+ * Branches that end before the requested depth contribute their deepest row.
+ */
+declare function normalizeAggregationRows<TFeatures extends TableFeatures, TData extends RowData>(rows: ReadonlyArray<Row<TFeatures, TData>>, maxDepth?: number): Array<Row<TFeatures, TData>>;
+/**
+ * Frontier selection for rows that are distinct nodes of a single row tree —
+ * the row models the table builds itself. Skips `normalizeAggregationRows`'
+ * duplicate-id guard (disjoint subtrees cannot revisit a row) and returns
+ * `rows` unchanged when no row descends, so the default `maxDepth: 0` case
+ * costs nothing per aggregation.
+ */
+declare function normalizeUniqueAggregationRows<TFeatures extends TableFeatures, TData extends RowData>(rows: ReadonlyArray<Row<TFeatures, TData>>, maxDepth?: number): ReadonlyArray<Row<TFeatures, TData>>;
+/** Resolves the `sum` or `extent` definition inferred from the first core row. */
+declare function column_getAutoAggregationFn<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): AggregationFnDef<TFeatures, TData, any, any> | undefined;
+/** Resolves and validates a column's scalar or multiple aggregation option. */
+declare function column_getAggregationFns<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>): ReadonlyArray<ResolvedAggregationFn<TFeatures, TData>>;
+/** Executes every configured aggregation over a depth-selected row frontier. */
+declare function aggregateColumnValue<TFeatures extends TableFeatures, TData extends RowData>(args: {
+  maxDepth?: number;
+  subRows?: ReadonlyArray<Row<TFeatures, TData>>;
+  column: Column<TFeatures, TData, unknown>;
+  groupingRow?: Row<TFeatures, TData>;
+  rows: ReadonlyArray<Row<TFeatures, TData>>;
+  /**
+   * Marks `rows` as distinct nodes of a single row tree (rows the table's own
+   * row models produced), enabling frontier selection without the
+   * duplicate-id guard. Caller-supplied row arrays must omit this.
+   */
+  uniqueRows?: boolean;
+}): unknown;
+/** Implements `column.getAggregationValue(options?)` and its default cache. */
+declare function column_getAggregationValue<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column<TFeatures, TData, TValue>, options?: AggregationValueOptions<TFeatures, TData>): ColumnAggregationValue<TFeatures>;
+/** Implements `cell.getIsAggregated()` for synthetic grouped rows. */
+declare function cell_getIsAggregated<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(cell: Cell<TFeatures, TData, TValue>): boolean;
+/** Formats the default scalar or keyed aggregated-cell representation. */
+declare function formatAggregatedCellValue(value: unknown, option: unknown): string | null;
+//#endregion
+export { aggregateColumnValue, cell_getIsAggregated, column_getAggregationFns, column_getAggregationValue, column_getAutoAggregationFn, formatAggregatedCellValue, normalizeAggregationRows, normalizeUniqueAggregationRows };