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

package/dist/features/column-pinning/columnPinningFeature.utils.cjs

@@ -4,13 +4,14 @@ const require_buildHeaderGroups = require('../../core/headers/buildHeaderGroups.
 
 //#region src/features/column-pinning/columnPinningFeature.utils.ts
 /**
-* Returns the default column pinning state.
+* Creates the default column pinning state.
 *
-* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+* Both pinning regions start empty. Reset APIs use this value when
+* `defaultState` is `true`.
 *
 * @example
 * ```ts
-* const initialValue = getDefaultColumnPinningState()
+* const pinning = getDefaultColumnPinningState()
 * ```
 */
 function getDefaultColumnPinningState() {
@@ -20,9 +21,11 @@ function getDefaultColumnPinningState() {
 	};
 }
 /**
-* Pin. for a column.
+* Moves this column's leaf column ids into a pinning region.
 *
-* This is the static implementation behind the matching column instance API.
+* Pinning a group column pins all of its leaves. The leaf ids are first removed
+* from both regions, then appended to the requested `'left'` or `'right'`
+* region. Passing `false` unpins them back to the center.
 *
 * @example
 * ```ts
@@ -52,26 +55,28 @@ function column_pin(column, position) {
 	});
 }
 /**
-* Returns whether a column can use pin.
+* Checks whether this column or any of its leaf columns can be pinned.
 *
-* This combines column options, table options, and any required accessor or feature state for the capability.
+* Column-level `enablePinning` and table `enableColumnPinning` both default to
+* `true`; at least one leaf column must allow pinning.
 *
 * @example
 * ```ts
-* const value = column_getCanPin(column)
+* const canPin = column_getCanPin(column)
 * ```
 */
 function column_getCanPin(column) {
 	return column.getLeafColumns().some((leafColumn) => (leafColumn.columnDef.enablePinning ?? true) && (column.table.options.enableColumnPinning ?? true));
 }
 /**
-* Returns is pinned for a column.
+* Reads this column's current pinning region.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* Group columns report `'left'` or `'right'` when any leaf column is pinned in
+* that region. Unpinned columns return `false`.
 *
 * @example
 * ```ts
-* const value = column_getIsPinned(column)
+* const position = column_getIsPinned(column)
 * ```
 */
 function column_getIsPinned(column) {
@@ -83,13 +88,14 @@ function column_getIsPinned(column) {
 	return isLeft ? "left" : isRight ? "right" : false;
 }
 /**
-* Returns pinned index for a column.
+* Finds this column's index within its pinned region.
 *
-* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+* Unpinned columns return `0`; pinned columns return their position in
+* `state.columnPinning.left` or `state.columnPinning.right`.
 *
 * @example
 * ```ts
-* const value = column_getPinnedIndex(column)
+* const index = column_getPinnedIndex(column)
 * ```
 */
 function column_getPinnedIndex(column) {
@@ -98,13 +104,13 @@ function column_getPinnedIndex(column) {
 	return position ? ((_column$table$atoms$c2 = column.table.atoms.columnPinning) === null || _column$table$atoms$c2 === void 0 || (_column$table$atoms$c2 = _column$table$atoms$c2.get()) === null || _column$table$atoms$c2 === void 0 ? void 0 : _column$table$atoms$c2[position].indexOf(column.id)) ?? -1 : 0;
 }
 /**
-* Returns center visible cells for a row.
+* Collects visible cells whose columns are not pinned left or right.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* The result preserves the row's visible-cell order for center columns.
 *
 * @example
 * ```ts
-* const value = row_getCenterVisibleCells(row)
+* const centerCells = row_getCenterVisibleCells(row)
 * ```
 */
 function row_getCenterVisibleCells(row) {
@@ -115,13 +121,14 @@ function row_getCenterVisibleCells(row) {
 	return allCells.filter((d) => !leftAndRight.includes(d.column.id));
 }
 /**
-* Returns left visible cells for a row.
+* Collects visible cells for columns pinned to the left region.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* Cells are returned in `state.columnPinning.left` order and are marked with
+* `cell.position = 'left'`.
 *
 * @example
 * ```ts
-* const value = row_getLeftVisibleCells(row)
+* const leftCells = row_getLeftVisibleCells(row)
 * ```
 */
 function row_getLeftVisibleCells(row) {
@@ -140,13 +147,14 @@ function row_getLeftVisibleCells(row) {
 	return cells;
 }
 /**
-* Returns right visible cells for a row.
+* Collects visible cells for columns pinned to the right region.
 *
-* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+* Cells are returned in `state.columnPinning.right` order and are marked with
+* `cell.position = 'right'`.
 *
 * @example
 * ```ts
-* const value = row_getRightVisibleCells(row)
+* const rightCells = row_getRightVisibleCells(row)
 * ```
 */
 function row_getRightVisibleCells(row) {
@@ -165,13 +173,14 @@ function row_getRightVisibleCells(row) {
 	return cells;
 }
 /**
-* Updates the table's column pinning state slice.
+* Routes a column pinning updater through the table's pinning 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 a next `{ left, right }` state or a function of the
+* previous state, matching the instance `table.setColumnPinning` behavior.
 *
 * @example
 * ```ts
-* table_setColumnPinning(table, (old) => old)
+* table_setColumnPinning(table, (old) => ({ ...old, left: ['select'] }))
 * ```
 */
 function table_setColumnPinning(table, updater) {
@@ -179,9 +188,11 @@ function table_setColumnPinning(table, updater) {
 	(_table$options$onColu = (_table$options = table.options).onColumnPinningChange) === null || _table$options$onColu === void 0 || _table$options$onColu.call(_table$options, updater);
 }
 /**
-* Resets the table's column pinning state slice.
+* Resets `columnPinning` 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.columnPinning` when it
+* exists. Passing `true` ignores initial state and resets to empty left/right
+* arrays.
 *
 * @example
 * ```ts
@@ -193,13 +204,14 @@ function table_resetColumnPinning(table, defaultState) {
 	table_setColumnPinning(table, defaultState ? getDefaultColumnPinningState() : require_utils.cloneState(table.initialState.columnPinning ?? getDefaultColumnPinningState()));
 }
 /**
-* Returns is some columns pinned for the table.
+* Checks whether any columns are pinned.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Omit `position` to check both sides, or pass `'left'`/`'right'` to inspect a
+* single pinning region.
 *
 * @example
 * ```ts
-* const value = table_getIsSomeColumnsPinned(table)
+* const hasPinnedColumns = table_getIsSomeColumnsPinned(table)
 * ```
 */
 function table_getIsSomeColumnsPinned(table, position) {
@@ -209,13 +221,14 @@ function table_getIsSomeColumnsPinned(table, position) {
 	return Boolean(pinningState === null || pinningState === void 0 ? void 0 : pinningState[position].length);
 }
 /**
-* Returns left header groups for the table.
+* Builds header groups for visible columns pinned to the left region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The leaf columns are read in `state.columnPinning.left` order and then passed
+* through the same header-group builder as the unpinned table.
 *
 * @example
 * ```ts
-* const value = table_getLeftHeaderGroups(table)
+* const headerGroups = table_getLeftHeaderGroups(table)
 * ```
 */
 function table_getLeftHeaderGroups(table) {
@@ -231,13 +244,14 @@ function table_getLeftHeaderGroups(table) {
 	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "left");
 }
 /**
-* Returns right header groups for the table.
+* Builds header groups for visible columns pinned to the right region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The leaf columns are read in `state.columnPinning.right` order and then
+* passed through the same header-group builder as the unpinned table.
 *
 * @example
 * ```ts
-* const value = table_getRightHeaderGroups(table)
+* const headerGroups = table_getRightHeaderGroups(table)
 * ```
 */
 function table_getRightHeaderGroups(table) {
@@ -253,13 +267,14 @@ function table_getRightHeaderGroups(table) {
 	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "right");
 }
 /**
-* Returns center header groups for the table.
+* Builds header groups for visible columns that are not pinned.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Left- and right-pinned column ids are removed from the visible leaf column
+* list before header groups are built for the center region.
 *
 * @example
 * ```ts
-* const value = table_getCenterHeaderGroups(table)
+* const headerGroups = table_getCenterHeaderGroups(table)
 * ```
 */
 function table_getCenterHeaderGroups(table) {
@@ -272,52 +287,52 @@ function table_getCenterHeaderGroups(table) {
 	return require_buildHeaderGroups.buildHeaderGroups(allColumns, leafColumns, table, "center");
 }
 /**
-* Returns left footer groups for the table.
+* Builds footer groups for the left pinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Footer groups reuse the left header groups in reverse order.
 *
 * @example
 * ```ts
-* const value = table_getLeftFooterGroups(table)
+* const footerGroups = table_getLeftFooterGroups(table)
 * ```
 */
 function table_getLeftFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups)].reverse();
 }
 /**
-* Returns right footer groups for the table.
+* Builds footer groups for the right pinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Footer groups reuse the right header groups in reverse order.
 *
 * @example
 * ```ts
-* const value = table_getRightFooterGroups(table)
+* const footerGroups = table_getRightFooterGroups(table)
 * ```
 */
 function table_getRightFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups)].reverse();
 }
 /**
-* Returns center footer groups for the table.
+* Builds footer groups for the center, unpinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Footer groups reuse the center header groups in reverse order.
 *
 * @example
 * ```ts
-* const value = table_getCenterFooterGroups(table)
+* const footerGroups = table_getCenterFooterGroups(table)
 * ```
 */
 function table_getCenterFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups)].reverse();
 }
 /**
-* Returns left flat headers for the table.
+* Flattens every header from the left pinned header groups.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers and placeholder headers are included.
 *
 * @example
 * ```ts
-* const value = table_getLeftFlatHeaders(table)
+* const headers = table_getLeftFlatHeaders(table)
 * ```
 */
 function table_getLeftFlatHeaders(table) {
@@ -330,13 +345,13 @@ function table_getLeftFlatHeaders(table) {
 	return result;
 }
 /**
-* Returns right flat headers for the table.
+* Flattens every header from the right pinned header groups.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers and placeholder headers are included.
 *
 * @example
 * ```ts
-* const value = table_getRightFlatHeaders(table)
+* const headers = table_getRightFlatHeaders(table)
 * ```
 */
 function table_getRightFlatHeaders(table) {
@@ -349,13 +364,13 @@ function table_getRightFlatHeaders(table) {
 	return result;
 }
 /**
-* Returns center flat headers for the table.
+* Flattens every header from the center header groups.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers and placeholder headers are included.
 *
 * @example
 * ```ts
-* const value = table_getCenterFlatHeaders(table)
+* const headers = table_getCenterFlatHeaders(table)
 * ```
 */
 function table_getCenterFlatHeaders(table) {
@@ -368,52 +383,53 @@ function table_getCenterFlatHeaders(table) {
 	return result;
 }
 /**
-* Returns left leaf headers for the table.
+* Collects leaf headers for the left pinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers are filtered out from the left flat header list.
 *
 * @example
 * ```ts
-* const value = table_getLeftLeafHeaders(table)
+* const headers = table_getLeftLeafHeaders(table)
 * ```
 */
 function table_getLeftLeafHeaders(table) {
 	return require_utils.callMemoOrStaticFn(table, "getLeftFlatHeaders", table_getLeftFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
-* Returns right leaf headers for the table.
+* Collects leaf headers for the right pinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers are filtered out from the right flat header list.
 *
 * @example
 * ```ts
-* const value = table_getRightLeafHeaders(table)
+* const headers = table_getRightLeafHeaders(table)
 * ```
 */
 function table_getRightLeafHeaders(table) {
 	return require_utils.callMemoOrStaticFn(table, "getRightFlatHeaders", table_getRightFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
-* Returns center leaf headers for the table.
+* Collects leaf headers for the center, unpinned region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Parent headers are filtered out from the center flat header list.
 *
 * @example
 * ```ts
-* const value = table_getCenterLeafHeaders(table)
+* const headers = table_getCenterLeafHeaders(table)
 * ```
 */
 function table_getCenterLeafHeaders(table) {
 	return require_utils.callMemoOrStaticFn(table, "getCenterFlatHeaders", table_getCenterFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
-* Returns left leaf columns for the table.
+* Resolves leaf columns pinned to the left region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The result follows `state.columnPinning.left` order and skips stale ids that
+* no longer correspond to a leaf column.
 *
 * @example
 * ```ts
-* const value = table_getLeftLeafColumns(table)
+* const columns = table_getLeftLeafColumns(table)
 * ```
 */
 function table_getLeftLeafColumns(table) {
@@ -428,13 +444,14 @@ function table_getLeftLeafColumns(table) {
 	return result;
 }
 /**
-* Returns right leaf columns for the table.
+* Resolves leaf columns pinned to the right region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* The result follows `state.columnPinning.right` order and skips stale ids that
+* no longer correspond to a leaf column.
 *
 * @example
 * ```ts
-* const value = table_getRightLeafColumns(table)
+* const columns = table_getRightLeafColumns(table)
 * ```
 */
 function table_getRightLeafColumns(table) {
@@ -449,13 +466,13 @@ function table_getRightLeafColumns(table) {
 	return result;
 }
 /**
-* Returns center leaf columns for the table.
+* Resolves leaf columns that are not pinned to either side.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Left- and right-pinned ids are removed from `table.getAllLeafColumns()`.
 *
 * @example
 * ```ts
-* const value = table_getCenterLeafColumns(table)
+* const columns = table_getCenterLeafColumns(table)
 * ```
 */
 function table_getCenterLeafColumns(table) {
@@ -465,65 +482,68 @@ function table_getCenterLeafColumns(table) {
 	return table.getAllLeafColumns().filter((d) => !leftAndRight.includes(d.id));
 }
 /**
-* Returns pinned leaf columns for the table.
+* Resolves leaf columns for a requested pinning region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Pass `'left'`, `'center'`, or `'right'` for a partition, or pass `false` to
+* read all leaf columns without partitioning.
 *
 * @example
 * ```ts
-* const value = table_getPinnedLeafColumns(table)
+* const columns = table_getPinnedLeafColumns(table, 'center')
 * ```
 */
 function table_getPinnedLeafColumns(table, position) {
 	return !position ? table.getAllLeafColumns() : position === "left" ? require_utils.callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns) : position === "right" ? require_utils.callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns) : require_utils.callMemoOrStaticFn(table, "getCenterLeafColumns", table_getCenterLeafColumns);
 }
 /**
-* Returns left visible leaf columns for the table.
+* Resolves visible leaf columns pinned to the left region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Hidden pinned columns are filtered out after the left pin order is applied.
 *
 * @example
 * ```ts
-* const value = table_getLeftVisibleLeafColumns(table)
+* const columns = table_getLeftVisibleLeafColumns(table)
 * ```
 */
 function table_getLeftVisibleLeafColumns(table) {
 	return require_utils.callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
 }
 /**
-* Returns right visible leaf columns for the table.
+* Resolves visible leaf columns pinned to the right region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Hidden pinned columns are filtered out after the right pin order is applied.
 *
 * @example
 * ```ts
-* const value = table_getRightVisibleLeafColumns(table)
+* const columns = table_getRightVisibleLeafColumns(table)
 * ```
 */
 function table_getRightVisibleLeafColumns(table) {
 	return require_utils.callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
 }
 /**
-* Returns center visible leaf columns for the table.
+* Resolves visible leaf columns that are not pinned.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* This is the center partition used by layouts that render pinned columns
+* separately from the scrollable middle region.
 *
 * @example
 * ```ts
-* const value = table_getCenterVisibleLeafColumns(table)
+* const columns = table_getCenterVisibleLeafColumns(table)
 * ```
 */
 function table_getCenterVisibleLeafColumns(table) {
 	return require_utils.callMemoOrStaticFn(table, "getCenterLeafColumns", table_getCenterLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
 }
 /**
-* Returns pinned visible leaf columns for the table.
+* Resolves visible leaf columns for a requested pinning region.
 *
-* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+* Omit `position` to get all visible leaf columns, or pass `'left'`, `'center'`,
+* or `'right'` to get one partition.
 *
 * @example
 * ```ts
-* const value = table_getPinnedVisibleLeafColumns(table)
+* const columns = table_getPinnedVisibleLeafColumns(table, 'left')
 * ```
 */
 function table_getPinnedVisibleLeafColumns(table, position) {