@tanstack/table-core 9.0.0-alpha.46 → 9.0.0-alpha.48

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

@@ -6,20 +6,23 @@ import { Table_Internal } from "../../types/Table.js";
 
 //#region src/features/row-expanding/rowExpandingFeature.utils.d.ts
 /**
- * Returns the default expanded state.
+ * Creates the default expanded state.
  *
- * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+ * The feature default is an empty map, meaning no rows are expanded. Reset APIs
+ * use this value when `defaultState` is `true`.
  *
  * @example
  * ```ts
- * const initialValue = getDefaultExpandedState()
+ * const expanded = getDefaultExpandedState()
  * ```
  */
 declare function getDefaultExpandedState(): ExpandedState;
 /**
- * Schedules an automatic reset for expanded.
+ * Schedules an expanded-state reset after row-structure changes.
  *
- * The reset only runs when the related feature options allow automatic resets for the current table state change.
+ * The reset runs when `autoResetAll`, `autoResetExpanded`, or the default
+ * client-side expanding behavior allows it. Manual expanding opts out unless
+ * the reset options explicitly opt back in.
  *
  * @example
  * ```ts
@@ -28,20 +31,23 @@ declare function getDefaultExpandedState(): ExpandedState;
  */
 declare function table_autoResetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): void;
 /**
- * Updates the table's expanded state slice.
+ * Routes an expanded-state updater through the table's expanded change handler.
  *
- * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+ * The updater may be `true`, a row-id map, or a function of the previous
+ * expanded state, matching the instance `table.setExpanded` behavior.
  *
  * @example
  * ```ts
- * table_setExpanded(table, (old) => old)
+ * 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;
 /**
- * Toggles all rows expanded for the table.
+ * Expands or collapses every row.
  *
- * This is the table-level convenience API used by UI controls that affect many columns or rows at once.
+ * Passing `true` stores the special expanded-all state. Passing `false` stores
+ * an empty map. Omitting the value toggles based on whether all rows are
+ * currently expanded.
  *
  * @example
  * ```ts
@@ -50,9 +56,10 @@ declare function table_setExpanded<TFeatures extends TableFeatures, TData extend
  */
 declare function table_toggleAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, expanded?: boolean): void;
 /**
- * Resets the table's expanded state slice.
+ * Resets `expanded` to the configured initial state or feature default.
  *
- * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+ * With no argument, the reset clones `table.initialState.expanded` when it
+ * exists. Passing `true` ignores initial state and resets to `{}`.
  *
  * @example
  * ```ts
@@ -62,64 +69,70 @@ declare function table_toggleAllRowsExpanded<TFeatures extends TableFeatures, TD
  */
 declare function table_resetExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
 /**
- * Returns can some rows expand for the table.
+ * Checks whether at least one pre-paginated row can expand.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * Pagination is intentionally ignored so controls can reflect expandable rows
+ * that may not be on the current page.
  *
  * @example
  * ```ts
- * const value = table_getCanSomeRowsExpand(table)
+ * const canExpand = table_getCanSomeRowsExpand(table)
  * ```
  */
 declare function table_getCanSomeRowsExpand<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
 /**
- * Returns an event handler for all rows expanded handler.
+ * Creates an event handler that toggles all rows expanded.
  *
- * The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.
+ * React-style synthetic events are persisted when present before the table state
+ * is toggled.
  *
  * @example
  * ```ts
- * const value = table_getToggleAllRowsExpandedHandler(table)
+ * const onClick = table_getToggleAllRowsExpandedHandler(table)
  * ```
  */
 declare function table_getToggleAllRowsExpandedHandler<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): (e: unknown) => void;
 /**
- * Returns is some rows expanded for the table.
+ * Checks whether any row is expanded.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The special expanded-all value `true` counts as some rows expanded.
  *
  * @example
  * ```ts
- * const value = table_getIsSomeRowsExpanded(table)
+ * const someExpanded = table_getIsSomeRowsExpanded(table)
  * ```
  */
 declare function table_getIsSomeRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
 /**
- * Returns is all rows expanded for the table.
+ * Checks whether every row in the current row model is expanded.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * The special expanded-all value `true` returns true immediately. Empty
+ * expanded state returns false.
  *
  * @example
  * ```ts
- * const value = table_getIsAllRowsExpanded(table)
+ * const allExpanded = table_getIsAllRowsExpanded(table)
  * ```
  */
 declare function table_getIsAllRowsExpanded<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): boolean;
 /**
- * Returns expanded depth for the table.
+ * Computes the deepest expanded row id depth.
  *
- * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ * Row ids are split on `.`; expanded-all state scans the current row model,
+ * while explicit expanded state scans its expanded id keys.
  *
  * @example
  * ```ts
- * const value = table_getExpandedDepth(table)
+ * const depth = table_getExpandedDepth(table)
  * ```
  */
 declare function table_getExpandedDepth<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): number;
 /**
- * Toggles expanded for a row.
+ * Expands or collapses this row.
  *
- * The update is routed through the table state updater for the owning feature state slice.
+ * 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.
  *
  * @example
  * ```ts
@@ -128,46 +141,48 @@ declare function table_getExpandedDepth<TFeatures extends TableFeatures, TData e
  */
 declare function row_toggleExpanded<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, expanded?: boolean): void;
 /**
- * Returns is expanded for a row.
+ * Checks whether this row is expanded.
  *
- * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+ * `options.getIsRowExpanded` can override state-derived behavior. Otherwise
+ * the row is expanded when expanded state is `true` or contains this row id.
  *
  * @example
  * ```ts
- * const value = row_getIsExpanded(row)
+ * const expanded = row_getIsExpanded(row)
  * ```
  */
 declare function row_getIsExpanded<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): boolean;
 /**
- * Returns whether a row can use expand.
+ * Checks whether this row can be expanded.
  *
- * This evaluates row data, table options, and feature-specific enablement rules.
+ * `options.getRowCanExpand` wins when provided. Otherwise rows can expand when
+ * expanding is enabled and the row has subRows.
  *
  * @example
  * ```ts
- * const value = row_getCanExpand(row)
+ * const canExpand = row_getCanExpand(row)
  * ```
  */
 declare function row_getCanExpand<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): boolean;
 /**
- * Returns is all parents expanded for a row.
+ * Checks whether every ancestor of this row is expanded.
  *
- * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+ * The current row is not considered; only its parent chain is walked.
  *
  * @example
  * ```ts
- * const value = row_getIsAllParentsExpanded(row)
+ * const parentsExpanded = row_getIsAllParentsExpanded(row)
  * ```
  */
 declare function row_getIsAllParentsExpanded<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): boolean;
 /**
- * Returns an event handler for toggling expanded handler.
+ * Creates a row control handler that toggles this row's expanded state.
  *
- * The handler is intended for direct use in row-level controls such as expansion or selection buttons.
+ * The handler is a no-op when the row cannot expand.
  *
  * @example
  * ```ts
- * const value = row_getToggleExpandedHandler(row)
+ * const onClick = row_getToggleExpandedHandler(row)
  * ```
  */
 declare function row_getToggleExpandedHandler<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): () => void;

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

@@ -2,22 +2,25 @@ import { cloneState } from "../../utils.js";
 
 //#region src/features/row-expanding/rowExpandingFeature.utils.ts
 /**
-* Returns the default expanded state.
+* Creates the default expanded state.
 *
-* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+* The feature default is an empty map, meaning no rows are expanded. Reset APIs
+* use this value when `defaultState` is `true`.
 *
 * @example
 * ```ts
-* const initialValue = getDefaultExpandedState()
+* const expanded = getDefaultExpandedState()
 * ```
 */
 function getDefaultExpandedState() {
 	return {};
 }
 /**
-* Schedules an automatic reset for expanded.
+* Schedules an expanded-state reset after row-structure changes.
 *
-* The reset only runs when the related feature options allow automatic resets for the current table state change.
+* The reset runs when `autoResetAll`, `autoResetExpanded`, or the default
+* client-side expanding behavior allows it. Manual expanding opts out unless
+* the reset options explicitly opt back in.
 *
 * @example
 * ```ts
@@ -25,16 +28,17 @@ function getDefaultExpandedState() {
 * ```
 */
 function table_autoResetExpanded(table) {
-	if (table.options.autoResetAll ?? table.options.autoResetExpanded ?? !table.options.manualExpanding) queueMicrotask(() => table_resetExpanded(table));
+	if (table.options.autoResetAll ?? table.options.autoResetExpanded ?? !table.options.manualExpanding) table._reactivity.schedule(() => table_resetExpanded(table));
 }
 /**
-* Updates the table's expanded state slice.
+* Routes an expanded-state updater through the table's expanded change handler.
 *
-* The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+* The updater may be `true`, a row-id map, or a function of the previous
+* expanded state, matching the instance `table.setExpanded` behavior.
 *
 * @example
 * ```ts
-* table_setExpanded(table, (old) => old)
+* table_setExpanded(table, (old) => ({ ...old, [rowId]: true }))
 * ```
 */
 function table_setExpanded(table, updater) {
@@ -42,9 +46,11 @@ function table_setExpanded(table, updater) {
 	(_table$options$onExpa = (_table$options = table.options).onExpandedChange) === null || _table$options$onExpa === void 0 || _table$options$onExpa.call(_table$options, updater);
 }
 /**
-* Toggles all rows expanded for the table.
+* Expands or collapses every row.
 *
-* This is the table-level convenience API used by UI controls that affect many columns or rows at once.
+* Passing `true` stores the special expanded-all state. Passing `false` stores
+* an empty map. Omitting the value toggles based on whether all rows are
+* currently expanded.
 *
 * @example
 * ```ts
@@ -56,9 +62,10 @@ function table_toggleAllRowsExpanded(table, expanded) {
 	else table_setExpanded(table, {});
 }
 /**
-* Resets the table's expanded state slice.
+* Resets `expanded` to the configured initial state or feature default.
 *
-* By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+* With no argument, the reset clones `table.initialState.expanded` when it
+* exists. Passing `true` ignores initial state and resets to `{}`.
 *
 * @example
 * ```ts
@@ -70,26 +77,28 @@ function table_resetExpanded(table, defaultState) {
 	table_setExpanded(table, defaultState ? {} : cloneState(table.initialState.expanded ?? {}));
 }
 /**
-* Returns can some rows expand for the table.
+* Checks whether at least one pre-paginated row can expand.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Pagination is intentionally ignored so controls can reflect expandable rows
+* that may not be on the current page.
 *
 * @example
 * ```ts
-* const value = table_getCanSomeRowsExpand(table)
+* const canExpand = table_getCanSomeRowsExpand(table)
 * ```
 */
 function table_getCanSomeRowsExpand(table) {
 	return table.getPrePaginatedRowModel().flatRows.some((row) => row_getCanExpand(row));
 }
 /**
-* Returns an event handler for all rows expanded handler.
+* Creates an event handler that toggles all rows expanded.
 *
-* The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.
+* React-style synthetic events are persisted when present before the table state
+* is toggled.
 *
 * @example
 * ```ts
-* const value = table_getToggleAllRowsExpandedHandler(table)
+* const onClick = table_getToggleAllRowsExpandedHandler(table)
 * ```
 */
 function table_getToggleAllRowsExpandedHandler(table) {
@@ -100,13 +109,13 @@ function table_getToggleAllRowsExpandedHandler(table) {
 	};
 }
 /**
-* Returns is some rows expanded for the table.
+* Checks whether any row is expanded.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The special expanded-all value `true` counts as some rows expanded.
 *
 * @example
 * ```ts
-* const value = table_getIsSomeRowsExpanded(table)
+* const someExpanded = table_getIsSomeRowsExpanded(table)
 * ```
 */
 function table_getIsSomeRowsExpanded(table) {
@@ -115,13 +124,14 @@ function table_getIsSomeRowsExpanded(table) {
 	return expanded === true || Object.values(expanded).some(Boolean);
 }
 /**
-* Returns is all rows expanded for the table.
+* Checks whether every row in the current row model is expanded.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The special expanded-all value `true` returns true immediately. Empty
+* expanded state returns false.
 *
 * @example
 * ```ts
-* const value = table_getIsAllRowsExpanded(table)
+* const allExpanded = table_getIsAllRowsExpanded(table)
 * ```
 */
 function table_getIsAllRowsExpanded(table) {
@@ -133,13 +143,14 @@ function table_getIsAllRowsExpanded(table) {
 	return true;
 }
 /**
-* Returns expanded depth for the table.
+* Computes the deepest expanded row id depth.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Row ids are split on `.`; expanded-all state scans the current row model,
+* while explicit expanded state scans its expanded id keys.
 *
 * @example
 * ```ts
-* const value = table_getExpandedDepth(table)
+* const depth = table_getExpandedDepth(table)
 * ```
 */
 function table_getExpandedDepth(table) {
@@ -152,9 +163,11 @@ function table_getExpandedDepth(table) {
 	return maxDepth;
 }
 /**
-* Toggles expanded for a row.
+* Expands or collapses this row.
 *
-* The update is routed through the table state updater for the owning feature state slice.
+* 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.
 *
 * @example
 * ```ts
@@ -182,13 +195,14 @@ function row_toggleExpanded(row, expanded) {
 	});
 }
 /**
-* Returns is expanded for a row.
+* Checks whether this row is expanded.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* `options.getIsRowExpanded` can override state-derived behavior. Otherwise
+* the row is expanded when expanded state is `true` or contains this row id.
 *
 * @example
 * ```ts
-* const value = row_getIsExpanded(row)
+* const expanded = row_getIsExpanded(row)
 * ```
 */
 function row_getIsExpanded(row) {
@@ -197,13 +211,14 @@ function row_getIsExpanded(row) {
 	return !!(((_row$table$options$ge = (_row$table$options = row.table.options).getIsRowExpanded) === null || _row$table$options$ge === void 0 ? void 0 : _row$table$options$ge.call(_row$table$options, row)) ?? (expanded === true || expanded[row.id]));
 }
 /**
-* Returns whether a row can use expand.
+* Checks whether this row can be expanded.
 *
-* This evaluates row data, table options, and feature-specific enablement rules.
+* `options.getRowCanExpand` wins when provided. Otherwise rows can expand when
+* expanding is enabled and the row has subRows.
 *
 * @example
 * ```ts
-* const value = row_getCanExpand(row)
+* const canExpand = row_getCanExpand(row)
 * ```
 */
 function row_getCanExpand(row) {
@@ -211,13 +226,13 @@ function row_getCanExpand(row) {
 	return ((_row$table$options$ge2 = (_row$table$options2 = row.table.options).getRowCanExpand) === null || _row$table$options$ge2 === void 0 ? void 0 : _row$table$options$ge2.call(_row$table$options2, row)) ?? ((row.table.options.enableExpanding ?? true) && !!row.subRows.length);
 }
 /**
-* Returns is all parents expanded for a row.
+* Checks whether every ancestor of this row is expanded.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* The current row is not considered; only its parent chain is walked.
 *
 * @example
 * ```ts
-* const value = row_getIsAllParentsExpanded(row)
+* const parentsExpanded = row_getIsAllParentsExpanded(row)
 * ```
 */
 function row_getIsAllParentsExpanded(row) {
@@ -225,18 +240,18 @@ function row_getIsAllParentsExpanded(row) {
 	let currentRow = row;
 	while (isFullyExpanded && currentRow.parentId) {
 		currentRow = row.table.getRow(currentRow.parentId, true);
-		isFullyExpanded = row_getIsExpanded(row);
+		isFullyExpanded = row_getIsExpanded(currentRow);
 	}
 	return isFullyExpanded;
 }
 /**
-* Returns an event handler for toggling expanded handler.
+* Creates a row control handler that toggles this row's expanded state.
 *
-* The handler is intended for direct use in row-level controls such as expansion or selection buttons.
+* The handler is a no-op when the row cannot expand.
 *
 * @example
 * ```ts
-* const value = row_getToggleExpandedHandler(row)
+* const onClick = row_getToggleExpandedHandler(row)
 * ```
 */
 function row_getToggleExpandedHandler(row) {

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

@@ -1 +1 @@
-{"version":3,"file":"rowExpandingFeature.utils.js","names":[],"sources":["../../../src/features/row-expanding/rowExpandingFeature.utils.ts"],"sourcesContent":["import { cloneState } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type {\n  ExpandedState,\n  ExpandedStateList,\n} from './rowExpandingFeature.types'\n\n/**\n * Returns the default expanded state.\n *\n * Feature constructors use this value to initialize the table state or option defaults when no user value is provided.\n *\n * @example\n * ```ts\n * const initialValue = getDefaultExpandedState()\n * ```\n */\nexport function getDefaultExpandedState(): ExpandedState {\n  return {}\n}\n\n/**\n * Schedules an automatic reset for expanded.\n *\n * The reset only runs when the related feature options allow automatic resets for the current table state change.\n *\n * @example\n * ```ts\n * table_autoResetExpanded(table)\n * ```\n */\nexport function table_autoResetExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  if (\n    table.options.autoResetAll ??\n    table.options.autoResetExpanded ??\n    !table.options.manualExpanding\n  ) {\n    queueMicrotask(() => table_resetExpanded(table))\n  }\n}\n\n/**\n * Updates the table's expanded state slice.\n *\n * The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.\n *\n * @example\n * ```ts\n * table_setExpanded(table, (old) => old)\n * ```\n */\nexport function table_setExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<ExpandedState>) {\n  table.options.onExpandedChange?.(updater)\n}\n\n/**\n * Toggles all rows expanded for the table.\n *\n * This is the table-level convenience API used by UI controls that affect many columns or rows at once.\n *\n * @example\n * ```ts\n * table_toggleAllRowsExpanded(table)\n * ```\n */\nexport function table_toggleAllRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, expanded?: boolean) {\n  if (expanded ?? !table_getIsAllRowsExpanded(table)) {\n    table_setExpanded(table, true)\n  } else {\n    table_setExpanded(table, {})\n  }\n}\n\n/**\n * Resets the table's expanded state slice.\n *\n * By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.\n *\n * @example\n * ```ts\n * table_resetExpanded(table)\n * table_resetExpanded(table, true)\n * ```\n */\nexport function table_resetExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setExpanded(\n    table,\n    defaultState ? {} : cloneState(table.initialState.expanded ?? {}),\n  )\n}\n\n/**\n * Returns can some rows expand for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getCanSomeRowsExpand(table)\n * ```\n */\nexport function table_getCanSomeRowsExpand<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getPrePaginatedRowModel()\n    .flatRows.some((row) => row_getCanExpand(row))\n}\n\n/**\n * Returns an event handler for all rows expanded handler.\n *\n * The handler calls the matching table toggle API and can be attached directly to checkbox or button UI.\n *\n * @example\n * ```ts\n * const value = table_getToggleAllRowsExpandedHandler(table)\n * ```\n */\nexport function table_getToggleAllRowsExpandedHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    ;(e as any).persist?.()\n    table_toggleAllRowsExpanded(table)\n  }\n}\n\n/**\n * Returns is some rows expanded for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getIsSomeRowsExpanded(table)\n * ```\n */\nexport function table_getIsSomeRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const expanded = table.atoms.expanded?.get() ?? {}\n  return expanded === true || Object.values(expanded).some(Boolean)\n}\n\n/**\n * Returns is all rows expanded for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getIsAllRowsExpanded(table)\n * ```\n */\nexport function table_getIsAllRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const expanded = table.atoms.expanded?.get() ?? {}\n\n  // If expanded is true, save some cycles and return true\n  if (expanded === true) {\n    return true\n  }\n\n  if (!Object.keys(expanded).length) {\n    return false\n  }\n\n  // If any row is not expanded, return false\n  if (table.getRowModel().flatRows.some((row) => !row_getIsExpanded(row))) {\n    return false\n  }\n\n  // They must all be expanded :shrug:\n  return true\n}\n\n/**\n * Returns expanded depth for the table.\n *\n * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.\n *\n * @example\n * ```ts\n * const value = table_getExpandedDepth(table)\n * ```\n */\nexport function table_getExpandedDepth<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  let maxDepth = 0\n\n  const rowIds =\n    table.atoms.expanded?.get() === true\n      ? Object.keys(table.getRowModel().rowsById)\n      : Object.keys(table.atoms.expanded?.get() ?? {})\n\n  rowIds.forEach((id) => {\n    const splitId = id.split('.')\n    maxDepth = Math.max(maxDepth, splitId.length)\n  })\n\n  return maxDepth\n}\n\n/**\n * Toggles expanded for a row.\n *\n * The update is routed through the table state updater for the owning feature state slice.\n *\n * @example\n * ```ts\n * row_toggleExpanded(row)\n * ```\n */\nexport function row_toggleExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, expanded?: boolean) {\n  table_setExpanded(row.table, (old) => {\n    const exists = old === true ? true : !!old[row.id]\n\n    let oldExpanded: ExpandedStateList = {}\n\n    if (old === true) {\n      Object.keys(row.table.getRowModel().rowsById).forEach((rowId) => {\n        oldExpanded[rowId] = true\n      })\n    } else {\n      oldExpanded = old\n    }\n\n    expanded = expanded ?? !exists\n\n    if (!exists && expanded) {\n      return {\n        ...oldExpanded,\n        [row.id]: true,\n      }\n    }\n\n    if (exists && !expanded) {\n      const { [row.id]: _, ...rest } = oldExpanded\n      return rest\n    }\n\n    return old\n  })\n}\n\n/**\n * Returns is expanded for a row.\n *\n * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.\n *\n * @example\n * ```ts\n * const value = row_getIsExpanded(row)\n * ```\n */\nexport function row_getIsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const expanded: ExpandedState = row.table.atoms.expanded?.get() ?? {}\n\n  return !!(\n    row.table.options.getIsRowExpanded?.(row) ??\n    (expanded === true || expanded[row.id])\n  )\n}\n\n/**\n * Returns whether a row can use expand.\n *\n * This evaluates row data, table options, and feature-specific enablement rules.\n *\n * @example\n * ```ts\n * const value = row_getCanExpand(row)\n * ```\n */\nexport function row_getCanExpand<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return (\n    row.table.options.getRowCanExpand?.(row) ??\n    ((row.table.options.enableExpanding ?? true) && !!row.subRows.length)\n  )\n}\n\n/**\n * Returns is all parents expanded for a row.\n *\n * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.\n *\n * @example\n * ```ts\n * const value = row_getIsAllParentsExpanded(row)\n * ```\n */\nexport function row_getIsAllParentsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  let isFullyExpanded = true\n  let currentRow = row\n\n  while (isFullyExpanded && currentRow.parentId) {\n    currentRow = row.table.getRow(currentRow.parentId, true)\n    isFullyExpanded = row_getIsExpanded(row)\n  }\n\n  return isFullyExpanded\n}\n\n/**\n * Returns an event handler for toggling expanded handler.\n *\n * The handler is intended for direct use in row-level controls such as expansion or selection buttons.\n *\n * @example\n * ```ts\n * const value = row_getToggleExpandedHandler(row)\n * ```\n */\nexport function row_getToggleExpandedHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const canExpand = row_getCanExpand(row)\n\n  return () => {\n    if (!canExpand) return\n    row_toggleExpanded(row)\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"rowExpandingFeature.utils.js","names":[],"sources":["../../../src/features/row-expanding/rowExpandingFeature.utils.ts"],"sourcesContent":["import { cloneState } from '../../utils'\nimport type { RowData, Updater } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Row } from '../../types/Row'\nimport type {\n  ExpandedState,\n  ExpandedStateList,\n} from './rowExpandingFeature.types'\n\n/**\n * Creates the default expanded state.\n *\n * The feature default is an empty map, meaning no rows are expanded. Reset APIs\n * use this value when `defaultState` is `true`.\n *\n * @example\n * ```ts\n * const expanded = getDefaultExpandedState()\n * ```\n */\nexport function getDefaultExpandedState(): ExpandedState {\n  return {}\n}\n\n/**\n * Schedules an expanded-state reset after row-structure changes.\n *\n * The reset runs when `autoResetAll`, `autoResetExpanded`, or the default\n * client-side expanding behavior allows it. Manual expanding opts out unless\n * the reset options explicitly opt back in.\n *\n * @example\n * ```ts\n * table_autoResetExpanded(table)\n * ```\n */\nexport function table_autoResetExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  if (\n    table.options.autoResetAll ??\n    table.options.autoResetExpanded ??\n    !table.options.manualExpanding\n  ) {\n    table._reactivity.schedule(() => table_resetExpanded(table))\n  }\n}\n\n/**\n * Routes an expanded-state updater through the table's expanded change handler.\n *\n * The updater may be `true`, a row-id map, or a function of the previous\n * expanded state, matching the instance `table.setExpanded` behavior.\n *\n * @example\n * ```ts\n * table_setExpanded(table, (old) => ({ ...old, [rowId]: true }))\n * ```\n */\nexport function table_setExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, updater: Updater<ExpandedState>) {\n  table.options.onExpandedChange?.(updater)\n}\n\n/**\n * Expands or collapses every row.\n *\n * Passing `true` stores the special expanded-all state. Passing `false` stores\n * an empty map. Omitting the value toggles based on whether all rows are\n * currently expanded.\n *\n * @example\n * ```ts\n * table_toggleAllRowsExpanded(table)\n * ```\n */\nexport function table_toggleAllRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, expanded?: boolean) {\n  if (expanded ?? !table_getIsAllRowsExpanded(table)) {\n    table_setExpanded(table, true)\n  } else {\n    table_setExpanded(table, {})\n  }\n}\n\n/**\n * Resets `expanded` to the configured initial state or feature default.\n *\n * With no argument, the reset clones `table.initialState.expanded` when it\n * exists. Passing `true` ignores initial state and resets to `{}`.\n *\n * @example\n * ```ts\n * table_resetExpanded(table)\n * table_resetExpanded(table, true)\n * ```\n */\nexport function table_resetExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {\n  table_setExpanded(\n    table,\n    defaultState ? {} : cloneState(table.initialState.expanded ?? {}),\n  )\n}\n\n/**\n * Checks whether at least one pre-paginated row can expand.\n *\n * Pagination is intentionally ignored so controls can reflect expandable rows\n * that may not be on the current page.\n *\n * @example\n * ```ts\n * const canExpand = table_getCanSomeRowsExpand(table)\n * ```\n */\nexport function table_getCanSomeRowsExpand<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return table\n    .getPrePaginatedRowModel()\n    .flatRows.some((row) => row_getCanExpand(row))\n}\n\n/**\n * Creates an event handler that toggles all rows expanded.\n *\n * React-style synthetic events are persisted when present before the table state\n * is toggled.\n *\n * @example\n * ```ts\n * const onClick = table_getToggleAllRowsExpandedHandler(table)\n * ```\n */\nexport function table_getToggleAllRowsExpandedHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  return (e: unknown) => {\n    ;(e as any).persist?.()\n    table_toggleAllRowsExpanded(table)\n  }\n}\n\n/**\n * Checks whether any row is expanded.\n *\n * The special expanded-all value `true` counts as some rows expanded.\n *\n * @example\n * ```ts\n * const someExpanded = table_getIsSomeRowsExpanded(table)\n * ```\n */\nexport function table_getIsSomeRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const expanded = table.atoms.expanded?.get() ?? {}\n  return expanded === true || Object.values(expanded).some(Boolean)\n}\n\n/**\n * Checks whether every row in the current row model is expanded.\n *\n * The special expanded-all value `true` returns true immediately. Empty\n * expanded state returns false.\n *\n * @example\n * ```ts\n * const allExpanded = table_getIsAllRowsExpanded(table)\n * ```\n */\nexport function table_getIsAllRowsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const expanded = table.atoms.expanded?.get() ?? {}\n\n  // If expanded is true, save some cycles and return true\n  if (expanded === true) {\n    return true\n  }\n\n  if (!Object.keys(expanded).length) {\n    return false\n  }\n\n  // If any row is not expanded, return false\n  if (table.getRowModel().flatRows.some((row) => !row_getIsExpanded(row))) {\n    return false\n  }\n\n  // They must all be expanded :shrug:\n  return true\n}\n\n/**\n * Computes the deepest expanded row id depth.\n *\n * Row ids are split on `.`; expanded-all state scans the current row model,\n * while explicit expanded state scans its expanded id keys.\n *\n * @example\n * ```ts\n * const depth = table_getExpandedDepth(table)\n * ```\n */\nexport function table_getExpandedDepth<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  let maxDepth = 0\n\n  const rowIds =\n    table.atoms.expanded?.get() === true\n      ? Object.keys(table.getRowModel().rowsById)\n      : Object.keys(table.atoms.expanded?.get() ?? {})\n\n  rowIds.forEach((id) => {\n    const splitId = id.split('.')\n    maxDepth = Math.max(maxDepth, splitId.length)\n  })\n\n  return maxDepth\n}\n\n/**\n * Expands or collapses this row.\n *\n * Omitting `expanded` toggles the row. If the current state is expanded-all,\n * the function first materializes that state into a row-id map before applying\n * the row-specific change.\n *\n * @example\n * ```ts\n * row_toggleExpanded(row)\n * ```\n */\nexport function row_toggleExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, expanded?: boolean) {\n  table_setExpanded(row.table, (old) => {\n    const exists = old === true ? true : !!old[row.id]\n\n    let oldExpanded: ExpandedStateList = {}\n\n    if (old === true) {\n      Object.keys(row.table.getRowModel().rowsById).forEach((rowId) => {\n        oldExpanded[rowId] = true\n      })\n    } else {\n      oldExpanded = old\n    }\n\n    expanded = expanded ?? !exists\n\n    if (!exists && expanded) {\n      return {\n        ...oldExpanded,\n        [row.id]: true,\n      }\n    }\n\n    if (exists && !expanded) {\n      const { [row.id]: _, ...rest } = oldExpanded\n      return rest\n    }\n\n    return old\n  })\n}\n\n/**\n * Checks whether this row is expanded.\n *\n * `options.getIsRowExpanded` can override state-derived behavior. Otherwise\n * the row is expanded when expanded state is `true` or contains this row id.\n *\n * @example\n * ```ts\n * const expanded = row_getIsExpanded(row)\n * ```\n */\nexport function row_getIsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const expanded: ExpandedState = row.table.atoms.expanded?.get() ?? {}\n\n  return !!(\n    row.table.options.getIsRowExpanded?.(row) ??\n    (expanded === true || expanded[row.id])\n  )\n}\n\n/**\n * Checks whether this row can be expanded.\n *\n * `options.getRowCanExpand` wins when provided. Otherwise rows can expand when\n * expanding is enabled and the row has subRows.\n *\n * @example\n * ```ts\n * const canExpand = row_getCanExpand(row)\n * ```\n */\nexport function row_getCanExpand<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return (\n    row.table.options.getRowCanExpand?.(row) ??\n    ((row.table.options.enableExpanding ?? true) && !!row.subRows.length)\n  )\n}\n\n/**\n * Checks whether every ancestor of this row is expanded.\n *\n * The current row is not considered; only its parent chain is walked.\n *\n * @example\n * ```ts\n * const parentsExpanded = row_getIsAllParentsExpanded(row)\n * ```\n */\nexport function row_getIsAllParentsExpanded<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  let isFullyExpanded = true\n  let currentRow = row\n\n  while (isFullyExpanded && currentRow.parentId) {\n    currentRow = row.table.getRow(currentRow.parentId, true)\n    isFullyExpanded = row_getIsExpanded(currentRow)\n  }\n\n  return isFullyExpanded\n}\n\n/**\n * Creates a row control handler that toggles this row's expanded state.\n *\n * The handler is a no-op when the row cannot expand.\n *\n * @example\n * ```ts\n * const onClick = row_getToggleExpandedHandler(row)\n * ```\n */\nexport function row_getToggleExpandedHandler<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const canExpand = row_getCanExpand(row)\n\n  return () => {\n    if (!canExpand) return\n    row_toggleExpanded(row)\n  }\n}\n"],"mappings":"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"}

package/dist/features/row-pagination/rowPaginationFeature.types.d.cts

@@ -41,23 +41,26 @@ interface PaginationDefaultOptions {
 interface Table_RowPagination<TFeatures extends TableFeatures, TData extends RowData> {
   _autoResetPageIndex: () => void;
   /**
-   * Returns whether the table can go to the next page.
+   * Checks whether the current page index can move forward.
    */
   getCanNextPage: () => boolean;
   /**
-   * Returns whether the table can go to the previous page.
+   * Checks whether the current page index can move backward.
    */
   getCanPreviousPage: () => boolean;
   /**
-   * Returns the page count. If manually paginating or controlling the pagination state, this will come directly from the `options.pageCount` table option, otherwise it will be calculated from the table data using the total row count and current page size.
+   * Resolves the current page count from `options.pageCount` or row count and
+   * page size.
    */
   getPageCount: () => number;
   /**
-   * Returns the row count. If manually paginating or controlling the pagination state, this will come directly from the `options.rowCount` table option, otherwise it will be calculated from the table data.
+   * Resolves the row count used for pagination math.
+   *
+   * `options.rowCount` wins; otherwise the pre-paginated row model is counted.
    */
   getRowCount: () => number;
   /**
-   * Returns an array of page options (zero-index-based) for the current page size.
+   * Builds zero-based page indexes for the current page count.
    */
   getPageOptions: () => Array<number>;
   /**
@@ -77,16 +80,20 @@ interface Table_RowPagination<TFeatures extends TableFeatures, TData extends Row
    */
   lastPage: () => void;
   /**
-   * Resets the page index to its initial state. If `defaultState` is `true`, the page index will be reset to `0` regardless of initial state.
+   * Resets `pagination.pageIndex` to initial state, or to `0` when
+   * `defaultState` is `true`.
    */
   resetPageIndex: (defaultState?: boolean) => void;
   /**
-   * Resets the page size to its initial state. If `defaultState` is `true`, the page size will be reset to `10` regardless of initial state.
+   * Resets `pagination.pageSize` to initial state, or to `10` when
+   * `defaultState` is `true`.
    */
   resetPageSize: (defaultState?: boolean) => void;
   /**
-   * Resets pagination state to `initialState.pagination`. Pass `true` to reset
-   * to the feature default of `{ pageIndex: 0, pageSize: 10 }`.
+   * Resets `pagination` to `initialState.pagination`.
+   *
+   * Pass `true` to ignore initial state and reset to
+   * `{ pageIndex: 0, pageSize: 10 }`.
    */
   resetPagination: (defaultState?: boolean) => void;
   /**
@@ -98,17 +105,17 @@ interface Table_RowPagination<TFeatures extends TableFeatures, TData extends Row
    */
   setPageSize: (updater: Updater<number>) => void;
   /**
-   * Sets pagination state using a value or updater.
+   * Updates pagination state with a next state or updater function.
    */
   setPagination: (updater: Updater<PaginationState>) => void;
 }
 interface Table_RowModels_Paginated<TFeatures extends TableFeatures, TData extends RowData> {
   /**
-   * Returns the row model for the table after pagination has been applied.
+   * Resolves the row model after pagination has sliced the current page.
    */
   getPaginatedRowModel: () => RowModel<TFeatures, TData>;
   /**
-   * Returns the row model for the table before any pagination has been applied.
+   * Reads the row model immediately before pagination.
    */
   getPrePaginatedRowModel: () => RowModel<TFeatures, TData>;
 }