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

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

@@ -1,16 +1,17 @@
 import { callMemoOrStaticFn, cloneState } from "../../utils.js";
-import { column_getIsVisible, row_getVisibleCells, table_getVisibleLeafColumns } from "../column-visibility/columnVisibilityFeature.utils.js";
+import { column_getIsVisible, row_getVisibleCells, row_getVisibleCellsByColumnId, table_getVisibleLeafColumns } from "../column-visibility/columnVisibilityFeature.utils.js";
 import { buildHeaderGroups } from "../../core/headers/buildHeaderGroups.js";
 
 //#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
@@ -30,7 +33,12 @@ function getDefaultColumnPinningState() {
 * ```
 */
 function column_pin(column, position) {
-	const columnIds = column.getLeafColumns().map((d) => d.id).filter(Boolean);
+	const leafColumns = column.getLeafColumns();
+	const columnIds = [];
+	for (let i = 0; i < leafColumns.length; i++) {
+		const id = leafColumns[i].id;
+		if (id) columnIds.push(id);
+	}
 	table_setColumnPinning(column.table, (old) => {
 		if (position === "right") return {
 			left: old.left.filter((d) => !columnIds.includes(d)),
@@ -47,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) {
@@ -78,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) {
@@ -93,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) {
@@ -110,23 +121,24 @@ 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) {
 	var _row$table$atoms$colu2;
 	const { left } = ((_row$table$atoms$colu2 = row.table.atoms.columnPinning) === null || _row$table$atoms$colu2 === void 0 ? void 0 : _row$table$atoms$colu2.get()) ?? getDefaultColumnPinningState();
 	if (!left.length) return [];
-	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCells", row_getVisibleCells);
+	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
 	const cells = [];
-	for (const columnId of left) {
-		const cell = allVisibleCells.find((c) => c.column.id === columnId);
+	for (let i = 0; i < left.length; i++) {
+		const cell = allVisibleCells[left[i]];
 		if (cell) {
 			cell.position = "left";
 			cells.push(cell);
@@ -135,23 +147,24 @@ 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) {
 	var _row$table$atoms$colu3;
 	const { right } = ((_row$table$atoms$colu3 = row.table.atoms.columnPinning) === null || _row$table$atoms$colu3 === void 0 ? void 0 : _row$table$atoms$colu3.get()) ?? getDefaultColumnPinningState();
 	if (!right.length) return [];
-	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCells", row_getVisibleCells);
+	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
 	const cells = [];
-	for (const columnId of right) {
-		const cell = allVisibleCells.find((c) => c.column.id === columnId);
+	for (let i = 0; i < right.length; i++) {
+		const cell = allVisibleCells[right[i]];
 		if (cell) {
 			cell.position = "right";
 			cells.push(cell);
@@ -160,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) {
@@ -174,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
@@ -188,13 +204,14 @@ function table_resetColumnPinning(table, defaultState) {
 	table_setColumnPinning(table, defaultState ? getDefaultColumnPinningState() : 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) {
@@ -204,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) {
@@ -219,20 +237,21 @@ function table_getLeftHeaderGroups(table) {
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const { left } = ((_table$atoms$columnPi2 = table.atoms.columnPinning) === null || _table$atoms$columnPi2 === void 0 ? void 0 : _table$atoms$columnPi2.get()) ?? getDefaultColumnPinningState();
 	const orderedLeafColumns = [];
-	for (const columnId of left) {
-		const column = leafColumnsById[columnId];
+	for (let i = 0; i < left.length; i++) {
+		const column = leafColumnsById[left[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) orderedLeafColumns.push(column);
 	}
 	return 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) {
@@ -241,20 +260,21 @@ function table_getRightHeaderGroups(table) {
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const { right } = ((_table$atoms$columnPi3 = table.atoms.columnPinning) === null || _table$atoms$columnPi3 === void 0 ? void 0 : _table$atoms$columnPi3.get()) ?? getDefaultColumnPinningState();
 	const orderedLeafColumns = [];
-	for (const columnId of right) {
-		const column = leafColumnsById[columnId];
+	for (let i = 0; i < right.length; i++) {
+		const column = leafColumnsById[right[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) orderedLeafColumns.push(column);
 	}
 	return 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) {
@@ -267,136 +287,149 @@ function table_getCenterHeaderGroups(table) {
 	return 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 [...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 [...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 [...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) {
-	return callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const leftHeaderGroups = callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups);
+	const result = [];
+	for (let i = 0; i < leftHeaderGroups.length; i++) {
+		const headers = leftHeaderGroups[i].headers;
+		for (let j = 0; j < headers.length; j++) result.push(headers[j]);
+	}
+	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) {
-	return callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const rightHeaderGroups = callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups);
+	const result = [];
+	for (let i = 0; i < rightHeaderGroups.length; i++) {
+		const headers = rightHeaderGroups[i].headers;
+		for (let j = 0; j < headers.length; j++) result.push(headers[j]);
+	}
+	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) {
-	return callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const centerHeaderGroups = callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups);
+	const result = [];
+	for (let i = 0; i < centerHeaderGroups.length; i++) {
+		const headers = centerHeaderGroups[i].headers;
+		for (let j = 0; j < headers.length; j++) result.push(headers[j]);
+	}
+	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 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 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 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) {
@@ -404,20 +437,21 @@ function table_getLeftLeafColumns(table) {
 	const { left } = ((_table$atoms$columnPi5 = table.atoms.columnPinning) === null || _table$atoms$columnPi5 === void 0 ? void 0 : _table$atoms$columnPi5.get()) ?? getDefaultColumnPinningState();
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const result = [];
-	for (const columnId of left) {
-		const column = leafColumnsById[columnId];
+	for (let i = 0; i < left.length; i++) {
+		const column = leafColumnsById[left[i]];
 		if (column) result.push(column);
 	}
 	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) {
@@ -425,20 +459,20 @@ function table_getRightLeafColumns(table) {
 	const { right } = ((_table$atoms$columnPi6 = table.atoms.columnPinning) === null || _table$atoms$columnPi6 === void 0 ? void 0 : _table$atoms$columnPi6.get()) ?? getDefaultColumnPinningState();
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const result = [];
-	for (const columnId of right) {
-		const column = leafColumnsById[columnId];
+	for (let i = 0; i < right.length; i++) {
+		const column = leafColumnsById[right[i]];
 		if (column) result.push(column);
 	}
 	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) {
@@ -448,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" ? callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns) : position === "right" ? callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns) : 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 callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", 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 callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", 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 callMemoOrStaticFn(table, "getCenterLeafColumns", table_getCenterLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", 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) {