@tanstack/table-core 9.0.0-beta.8 → 9.0.0-beta.80

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

@@ -0,0 +1,235 @@
+import { hasOwn, makeObjectMap } from "../../utils.js";
+
+//#region src/features/row-aggregation/rowAggregationFeature.utils.ts
+function isAggregationFnDef(value) {
+	return !!value && typeof value === "object" && "aggregate" in value;
+}
+function isAggregationFnDescriptor(value) {
+	return !!value && typeof value === "object" && "id" in value && "aggregationFn" in value;
+}
+function warn(message) {
+	if (process.env.NODE_ENV === "development") console.warn(message);
+}
+function resolveMaxAggregationDepth(maxDepth) {
+	return maxDepth === void 0 || Number.isNaN(maxDepth) ? 0 : Math.max(0, Math.floor(maxDepth));
+}
+function collectNormalizedAggregationRow(row, depth, maxDepth, seen, result) {
+	if (row.subRows.length && depth < maxDepth) {
+		for (let i = 0; i < row.subRows.length; i++) collectNormalizedAggregationRow(row.subRows[i], depth + 1, maxDepth, seen, result);
+		return;
+	}
+	if (!seen.has(row.id)) {
+		seen.add(row.id);
+		result.push(row);
+	}
+}
+function collectUniqueAggregationRow(row, depth, maxDepth, result) {
+	if (row.subRows.length && depth < maxDepth) {
+		for (let i = 0; i < row.subRows.length; i++) collectUniqueAggregationRow(row.subRows[i], depth + 1, maxDepth, result);
+		return;
+	}
+	result.push(row);
+}
+/**
+* Selects unique rows at a maximum relative depth in encounter order.
+* Branches that end before the requested depth contribute their deepest row.
+*/
+function normalizeAggregationRows(rows, maxDepth = 0) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	const normalizedMaxDepth = resolveMaxAggregationDepth(maxDepth);
+	for (let i = 0; i < rows.length; i++) collectNormalizedAggregationRow(rows[i], 0, normalizedMaxDepth, seen, result);
+	return result;
+}
+/**
+* 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.
+*/
+function normalizeUniqueAggregationRows(rows, maxDepth = 0) {
+	const normalizedMaxDepth = resolveMaxAggregationDepth(maxDepth);
+	let needsDescent = false;
+	if (normalizedMaxDepth > 0) {
+		for (let i = 0; i < rows.length; i++) if (rows[i].subRows.length) {
+			needsDescent = true;
+			break;
+		}
+	}
+	if (!needsDescent) return rows;
+	const result = [];
+	for (let i = 0; i < rows.length; i++) collectUniqueAggregationRow(rows[i], 0, normalizedMaxDepth, result);
+	return result;
+}
+function getAutoAggregationFnName(value) {
+	if (typeof value === "number") return "sum";
+	if (value instanceof Date && !Number.isNaN(value.getTime())) return "extent";
+}
+/** Resolves the `sum` or `extent` definition inferred from the first core row. */
+function column_getAutoAggregationFn(column) {
+	const value = column.table.getCoreRowModel().flatRows[0]?.getValue(column.id);
+	const name = getAutoAggregationFnName(value);
+	if (!name) return void 0;
+	const aggregationFn = column.table._rowModelFns.aggregationFns?.[name];
+	if (!aggregationFn) warn(`aggregationFn '${name}' (auto) for column '${column.id}' is not registered`);
+	return aggregationFn;
+}
+function resolveAggregationFn(column, ref) {
+	if (isAggregationFnDef(ref)) return ref;
+	if (ref === "auto") return column_getAutoAggregationFn(column);
+	const aggregationFn = column.table._rowModelFns.aggregationFns?.[ref];
+	if (!aggregationFn) warn(`aggregationFn '${String(ref)}' for column '${column.id}' is not registered`);
+	return aggregationFn;
+}
+/** Resolves and validates a column's scalar or multiple aggregation option. */
+function column_getAggregationFns(column) {
+	const option = column.columnDef.aggregationFn;
+	const registry = column.table._rowModelFns.aggregationFns;
+	const coreRowModel = column.table.getCoreRowModel();
+	const previous = column._resolvedAggregationFnsCache;
+	if (previous && previous.option === option && previous.registry === registry && previous.coreRowModel === coreRowModel) return previous.value;
+	const finish = (value) => {
+		column._resolvedAggregationFnsCache = {
+			coreRowModel,
+			option,
+			registry,
+			value
+		};
+		return value;
+	};
+	if (option == null) return finish([]);
+	if (!Array.isArray(option)) return finish([{
+		aggregationFn: resolveAggregationFn(column, option),
+		id: typeof option === "string" ? option : void 0
+	}]);
+	const ids = makeObjectMap();
+	for (let i = 0; i < option.length; i++) {
+		const item = option[i];
+		const id = typeof item === "string" ? item : isAggregationFnDescriptor(item) ? item.id : void 0;
+		if (id !== void 0) ids[id] = (ids[id] ?? 0) + 1;
+	}
+	const resolved = [];
+	for (let i = 0; i < option.length; i++) {
+		const item = option[i];
+		const id = typeof item === "string" ? item : isAggregationFnDescriptor(item) ? item.id : void 0;
+		if (id === void 0) {
+			warn(`aggregationFn at index ${i} for column '${column.id}' needs a stable id`);
+			resolved.push({
+				aggregationFn: void 0,
+				id: void 0
+			});
+			continue;
+		}
+		if (ids[id] > 1) {
+			warn(`aggregationFn id '${id}' for column '${column.id}' is duplicated`);
+			resolved.push({
+				aggregationFn: void 0,
+				id
+			});
+			continue;
+		}
+		const ref = isAggregationFnDescriptor(item) ? item.aggregationFn : item;
+		resolved.push({
+			aggregationFn: resolveAggregationFn(column, ref),
+			id
+		});
+	}
+	return finish(resolved);
+}
+function getSubRowResult(subRowValue, isMultiple, id) {
+	if (!isMultiple) return subRowValue;
+	if (!id || !subRowValue || typeof subRowValue !== "object") return void 0;
+	return hasOwn(subRowValue, id) ? subRowValue[id] : void 0;
+}
+/** Executes every configured aggregation over a depth-selected row frontier. */
+function aggregateColumnValue(args) {
+	const { subRows, column, groupingRow, rows, uniqueRows } = args;
+	const internalColumn = column;
+	const maxDepth = resolveMaxAggregationDepth(args.maxDepth ?? internalColumn.columnDef.maxAggregationDepth);
+	const aggregationRows = uniqueRows ? normalizeUniqueAggregationRows(rows, maxDepth) : normalizeAggregationRows(rows, maxDepth);
+	const entries = column_getAggregationFns(internalColumn);
+	const isMultiple = Array.isArray(internalColumn.columnDef.aggregationFn);
+	const canMerge = !!subRows?.length && subRows.every((row) => !!row.groupingColumnId && row.groupingColumnId !== column.id);
+	const getValue = (row) => row.getValue(column.id);
+	const execute = (entry) => {
+		const definition = entry.aggregationFn;
+		if (!definition) return void 0;
+		const context = {
+			...subRows ? { subRows } : {},
+			column,
+			columnId: column.id,
+			getValue,
+			...groupingRow ? { groupingRow } : {},
+			maxDepth,
+			rows: aggregationRows,
+			table: column.table
+		};
+		if (canMerge && definition.merge) return definition.merge({
+			...context,
+			subRowResults: subRows.map((row) => getSubRowResult(row.getValue(column.id), isMultiple, entry.id)),
+			subRows
+		});
+		return definition.aggregate(context);
+	};
+	if (!isMultiple) return entries[0] ? execute(entries[0]) : void 0;
+	const result = makeObjectMap();
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry.id !== void 0) result[entry.id] = execute(entry);
+	}
+	return result;
+}
+/** Implements `column.getAggregationValue(options?)` and its default cache. */
+function column_getAggregationValue(column, options) {
+	const rows = options?.rows;
+	const resolvedMaxDepth = resolveMaxAggregationDepth(options?.maxDepth ?? column.columnDef.maxAggregationDepth);
+	const providedResult = column.columnDef.getAggregationValue?.({
+		column,
+		maxDepth: resolvedMaxDepth,
+		rows,
+		table: column.table
+	});
+	if (providedResult) return providedResult.value;
+	if (column.table.options.manualAggregation) return void 0;
+	if (rows !== void 0) return aggregateColumnValue({
+		column,
+		maxDepth: resolvedMaxDepth,
+		rows
+	});
+	const model = column.table.getPreGroupedRowModel();
+	const previous = column._aggregationValueCache;
+	const registry = column.table._rowModelFns.aggregationFns;
+	const aggregationFnOption = column.columnDef.aggregationFn;
+	if (previous && previous.dependency === model && previous.maxDepth === resolvedMaxDepth && previous.registry === registry && previous.aggregationFnOption === aggregationFnOption) return previous.value;
+	const value = aggregateColumnValue({
+		column,
+		maxDepth: resolvedMaxDepth,
+		rows: model.rows,
+		uniqueRows: true
+	});
+	column._aggregationValueCache = {
+		aggregationFnOption,
+		dependency: model,
+		maxDepth: resolvedMaxDepth,
+		registry,
+		value
+	};
+	return value;
+}
+/** Implements `cell.getIsAggregated()` for synthetic grouped rows. */
+function cell_getIsAggregated(cell) {
+	const groupingColumnId = cell.row.groupingColumnId;
+	if (!groupingColumnId || groupingColumnId === cell.column.id) return false;
+	if ((cell.column.table.atoms.grouping?.get?.())?.includes(cell.column.id)) return false;
+	return column_getAggregationFns(cell.column).some((entry) => !!entry.aggregationFn);
+}
+/** Formats the default scalar or keyed aggregated-cell representation. */
+function formatAggregatedCellValue(value, option) {
+	if (value == null) return null;
+	if (Array.isArray(option) && typeof value === "object") return Object.keys(value).map((key) => `${key}: ${String(value[key])}`).join(", ");
+	return String(value);
+}
+
+//#endregion
+export { aggregateColumnValue, cell_getIsAggregated, column_getAggregationFns, column_getAggregationValue, column_getAutoAggregationFn, formatAggregatedCellValue, normalizeAggregationRows, normalizeUniqueAggregationRows };

package/dist/features/row-expanding/createExpandedRowModel.d.ts

@@ -1,8 +1,7 @@
 import { RowData } from "../../types/type-utils.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
-
+import { Table } from "../../types/Table.js";
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-expanding/createExpandedRowModel.d.ts
 /**
  * Creates a memoized expanded row model factory.
@@ -17,5 +16,4 @@ declare function createExpandedRowModel<TFeatures extends TableFeatures, TData e
  */
 declare function expandRows<TFeatures extends TableFeatures, TData extends RowData = any>(rowModel: RowModel<TFeatures, TData>): RowModel<TFeatures, TData>;
 //#endregion
-export { createExpandedRowModel, expandRows };
-//# sourceMappingURL=createExpandedRowModel.d.ts.map
+export { createExpandedRowModel, expandRows };

package/dist/features/row-expanding/createExpandedRowModel.js

@@ -14,24 +14,21 @@ function createExpandedRowModel() {
 			feature: "rowExpandingFeature",
 			table,
 			fnName: "table.getExpandedRowModel",
-			memoDeps: () => {
-				var _table$atoms$expanded;
-				return [
-					(_table$atoms$expanded = table.atoms.expanded) === null || _table$atoms$expanded === void 0 ? void 0 : _table$atoms$expanded.get(),
-					table.getPreExpandedRowModel(),
-					table.options.paginateExpandedRows
-				];
-			},
+			memoDeps: () => [
+				table.atoms.expanded?.get(),
+				table.getPreExpandedRowModel(),
+				table.options.paginateExpandedRows,
+				table.options.manualPagination
+			],
 			fn: () => _createExpandedRowModel(table)
 		});
 	};
 }
 function _createExpandedRowModel(table) {
-	var _table$atoms$expanded2;
 	const rowModel = table.getPreExpandedRowModel();
-	const expanded = (_table$atoms$expanded2 = table.atoms.expanded) === null || _table$atoms$expanded2 === void 0 ? void 0 : _table$atoms$expanded2.get();
+	const expanded = table.atoms.expanded?.get();
 	if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded ?? {}).length) return rowModel;
-	if (!table.options.paginateExpandedRows) return rowModel;
+	if (!table.options.paginateExpandedRows && !table.options.manualPagination) return rowModel;
 	return expandRows(rowModel);
 }
 /**
@@ -54,5 +51,4 @@ function expandRows(rowModel) {
 }
 
 //#endregion
-export { createExpandedRowModel, expandRows };
-//# sourceMappingURL=createExpandedRowModel.js.map
+export { createExpandedRowModel, expandRows };

package/dist/features/row-expanding/rowExpandingFeature.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/features/row-expanding/rowExpandingFeature.d.ts
 /**
  * Feature that adds row expansion state and APIs for expandable row trees.
  */
 declare const rowExpandingFeature: TableFeature;
 //#endregion
-export { rowExpandingFeature };
-//# sourceMappingURL=rowExpandingFeature.d.ts.map
+export { rowExpandingFeature };

package/dist/features/row-expanding/rowExpandingFeature.js

@@ -43,5 +43,4 @@ const rowExpandingFeature = {
 };
 
 //#endregion
-export { rowExpandingFeature };
-//# sourceMappingURL=rowExpandingFeature.js.map
+export { rowExpandingFeature };

package/dist/features/row-expanding/rowExpandingFeature.types.d.ts

@@ -1,9 +1,7 @@
 import { OnChangeFn, RowData, Updater } from "../../types/type-utils.js";
 import { Row } from "../../types/Row.js";
-import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table } from "../../types/Table.js";
 import { RowModel } from "../../core/row-models/coreRowModelsFeature.types.js";
-
+import { TableFeatures } from "../../types/TableFeatures.js";
 //#region src/features/row-expanding/rowExpandingFeature.types.d.ts
 type ExpandedStateList = Record<string, boolean>;
 type ExpandedState = true | Record<string, boolean>;
@@ -32,7 +30,7 @@ interface Row_RowExpanding {
    */
   toggleExpanded: (expanded?: boolean) => void;
 }
-interface TableOptions_RowExpanding<TFeatures extends TableFeatures, TData extends RowData> {
+interface TableOptions_RowExpanding<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Enables automatic expanded-state resets when page-altering table state changes.
    */
@@ -60,11 +58,11 @@ interface TableOptions_RowExpanding<TFeatures extends TableFeatures, TData exten
    */
   onExpandedChange?: OnChangeFn<ExpandedState>;
   /**
-   * If `true` expanded rows will be paginated along with the rest of the table (which means expanded rows may span multiple pages). If `false` expanded rows will not be considered for pagination (which means expanded rows will always render on their parents page. This also means more rows will be rendered than the set page size)
+   * If `true` expanded rows will be paginated along with the rest of the table (which means expanded rows may span multiple pages). If `false` expanded rows will not be considered for pagination (which means expanded rows will always render on their parent's page). This also means more rows will be rendered than the set page size.
    */
   paginateExpandedRows?: boolean;
 }
-interface Table_RowExpanding<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_RowExpanding<in out _TFeatures extends TableFeatures, in out _TData extends RowData> {
   autoResetExpanded: () => void;
   /**
    * Checks whether at least one row can be expanded.
@@ -101,7 +99,7 @@ interface Table_RowExpanding<TFeatures extends TableFeatures, TData extends RowD
    */
   toggleAllRowsExpanded: (expanded?: boolean) => void;
 }
-interface Table_RowModels_Expanded<TFeatures extends TableFeatures, TData extends RowData> {
+interface Table_RowModels_Expanded<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   /**
    * Resolves the row model after expanded rows have been flattened into view.
    */
@@ -111,17 +109,8 @@ interface Table_RowModels_Expanded<TFeatures extends TableFeatures, TData extend
    */
   getPreExpandedRowModel: () => RowModel<TFeatures, TData>;
 }
-interface CreateRowModel_Expanded<TFeatures extends TableFeatures, TData extends RowData> {
-  /**
-   * Factory used to retrieve the expanded row model. If this function is not
-   * provided, the table will not expand rows. To use client-side expansion,
-   * pass `createExpandedRowModel()` or implement your own factory.
-   */
-  expandedRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
-}
-interface CachedRowModel_Expanded<TFeatures extends TableFeatures, TData extends RowData> {
+interface CachedRowModel_Expanded<in out TFeatures extends TableFeatures, in out TData extends RowData> {
   expandedRowModel: () => RowModel<TFeatures, TData>;
 }
 //#endregion
-export { CachedRowModel_Expanded, CreateRowModel_Expanded, ExpandedState, ExpandedStateList, Row_RowExpanding, TableOptions_RowExpanding, TableState_RowExpanding, Table_RowExpanding, Table_RowModels_Expanded };
-//# sourceMappingURL=rowExpandingFeature.types.d.ts.map
+export { CachedRowModel_Expanded, ExpandedState, ExpandedStateList, Row_RowExpanding, TableOptions_RowExpanding, TableState_RowExpanding, Table_RowExpanding, Table_RowModels_Expanded };

package/dist/features/row-expanding/rowExpandingFeature.utils.d.ts

@@ -1,9 +1,8 @@
 import { RowData, Updater } from "../../types/type-utils.js";
 import { ExpandedState } from "./rowExpandingFeature.types.js";
 import { Row } from "../../types/Row.js";
+import { Table } from "../../types/Table.js";
 import { TableFeatures } from "../../types/TableFeatures.js";
-import { Table_Internal } from "../../types/Table.js";
-
 //#region src/features/row-expanding/rowExpandingFeature.utils.d.ts
 /**
  * Creates the default expanded state.
@@ -29,7 +28,7 @@ declare function getDefaultExpandedState(): ExpandedState;
  * table_autoResetExpanded(table)
  * ```
  */
-declare function table_autoResetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
+declare function table_autoResetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): void;
 /**
  * Routes an expanded-state updater through the table's expanded change handler.
  *
@@ -41,7 +40,7 @@ declare function table_autoResetExpanded<TFeatures extends TableFeatures, TData
  * table_setExpanded(table, (old) => ({ ...old, [rowId]: true }))
  * ```
  */
-declare function table_setExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<ExpandedState>): void;
+declare function table_setExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, updater: Updater<ExpandedState>): void;
 /**
  * Expands or collapses every row.
  *
@@ -49,12 +48,15 @@ declare function table_setExpanded<TFeatures extends TableFeatures, TData extend
  * an empty map. Omitting the value toggles based on whether all rows are
  * currently expanded.
  *
+ * The call is a no-op (no `onExpandedChange`) when no row can expand or when
+ * the requested state matches the current state exactly.
+ *
  * @example
  * ```ts
  * table_toggleAllRowsExpanded(table)
  * ```
  */
-declare function table_toggleAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, expanded?: boolean): void;
+declare function table_toggleAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, expanded?: boolean): void;
 /**
  * Resets `expanded` to the configured initial state or feature default.
  *
@@ -67,7 +69,7 @@ declare function table_toggleAllRowsExpanded<TFeatures extends TableFeatures, TD
  * table_resetExpanded(table, true)
  * ```
  */
-declare function table_resetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+declare function table_resetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, defaultState?: boolean): void;
 /**
  * Checks whether at least one pre-paginated row can expand.
  *
@@ -79,19 +81,16 @@ declare function table_resetExpanded<TFeatures extends TableFeatures, TData exte
  * const canExpand = table_getCanSomeRowsExpand(table)
  * ```
  */
-declare function table_getCanSomeRowsExpand<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
+declare function table_getCanSomeRowsExpand<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): boolean;
 /**
  * Creates an event handler that toggles all rows expanded.
  *
- * React-style synthetic events are persisted when present before the table state
- * is toggled.
- *
  * @example
  * ```ts
  * const onClick = table_getToggleAllRowsExpandedHandler(table)
  * ```
  */
-declare function table_getToggleAllRowsExpandedHandler<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): (e: unknown) => void;
+declare function table_getToggleAllRowsExpandedHandler<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): (_e: unknown) => void;
 /**
  * Checks whether any row is expanded.
  *
@@ -102,37 +101,43 @@ declare function table_getToggleAllRowsExpandedHandler<TFeatures extends TableFe
  * const someExpanded = table_getIsSomeRowsExpanded(table)
  * ```
  */
-declare function table_getIsSomeRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
+declare function table_getIsSomeRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): boolean;
 /**
- * Checks whether every row in the current row model is expanded.
+ * Checks whether every expandable row in the current row model is expanded.
  *
  * The special expanded-all value `true` returns true immediately. Empty
- * expanded state returns false.
+ * expanded state returns false. Rows that cannot expand are ignored, so a
+ * materialized expanded-all map (which only contains expandable row ids)
+ * still counts as all rows expanded.
  *
  * @example
  * ```ts
  * const allExpanded = table_getIsAllRowsExpanded(table)
  * ```
  */
-declare function table_getIsAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
+declare function table_getIsAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): boolean;
 /**
  * Computes the deepest expanded row id depth.
  *
- * Row ids are split on `.`; expanded-all state scans the current row model,
- * while explicit expanded state scans its expanded id keys.
+ * Row ids are split on `.`; expanded-all state scans the current row model's
+ * expandable rows, while explicit expanded state scans its expanded id keys.
  *
  * @example
  * ```ts
  * const depth = table_getExpandedDepth(table)
  * ```
  */
-declare function table_getExpandedDepth<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number;
+declare function table_getExpandedDepth<TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>): number;
 /**
  * Expands or collapses this row.
  *
  * Omitting `expanded` toggles the row. If the current state is expanded-all,
- * the function first materializes that state into a row-id map before applying
- * the row-specific change.
+ * the function first materializes that state into a row-id map (containing
+ * only expandable row ids) before applying the row-specific change.
+ *
+ * The call is a no-op (no `onExpandedChange`) when the requested state matches
+ * the current state, or when expanding a row that cannot expand. Collapsing is
+ * always allowed so stale expanded ids can be cleaned up.
  *
  * @example
  * ```ts
@@ -187,5 +192,4 @@ declare function row_getIsAllParentsExpanded<TFeatures extends TableFeatures, TD
  */
 declare function row_getToggleExpandedHandler<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): () => void;
 //#endregion
-export { getDefaultExpandedState, row_getCanExpand, row_getIsAllParentsExpanded, row_getIsExpanded, row_getToggleExpandedHandler, row_toggleExpanded, table_autoResetExpanded, table_getCanSomeRowsExpand, table_getExpandedDepth, table_getIsAllRowsExpanded, table_getIsSomeRowsExpanded, table_getToggleAllRowsExpandedHandler, table_resetExpanded, table_setExpanded, table_toggleAllRowsExpanded };
-//# sourceMappingURL=rowExpandingFeature.utils.d.ts.map
+export { getDefaultExpandedState, row_getCanExpand, row_getIsAllParentsExpanded, row_getIsExpanded, row_getToggleExpandedHandler, row_toggleExpanded, table_autoResetExpanded, table_getCanSomeRowsExpand, table_getExpandedDepth, table_getIsAllRowsExpanded, table_getIsSomeRowsExpanded, table_getToggleAllRowsExpandedHandler, table_resetExpanded, table_setExpanded, table_toggleAllRowsExpanded };