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

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

@@ -3,14 +3,39 @@ const require_columnVisibilityFeature_utils = require('../column-visibility/colu
 const require_buildHeaderGroups = require('../../core/headers/buildHeaderGroups.cjs');
 
 //#region src/features/column-pinning/columnPinningFeature.utils.ts
+/**
+* Returns the default column pinning state.
+*
+* Feature constructors use this value to initialize the table state or option defaults when no user value is provided.
+*
+* @example
+* ```ts
+* const initialValue = getDefaultColumnPinningState()
+* ```
+*/
 function getDefaultColumnPinningState() {
 	return {
 		left: [],
 		right: []
 	};
 }
+/**
+* Pin. for a column.
+*
+* This is the static implementation behind the matching column instance API.
+*
+* @example
+* ```ts
+* column_pin(column, 'left')
+* ```
+*/
 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)),
@@ -26,9 +51,29 @@ function column_pin(column, position) {
 		};
 	});
 }
+/**
+* Returns whether a column can use pin.
+*
+* This combines column options, table options, and any required accessor or feature state for the capability.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+*
+* @example
+* ```ts
+* const value = column_getIsPinned(column)
+* ```
+*/
 function column_getIsPinned(column) {
 	var _column$table$atoms$c;
 	const leafColumnIds = column.getLeafColumns().map((d) => d.id);
@@ -37,65 +82,186 @@ function column_getIsPinned(column) {
 	const isRight = leafColumnIds.some((d) => right.includes(d));
 	return isLeft ? "left" : isRight ? "right" : false;
 }
+/**
+* Returns pinned index for a column.
+*
+* This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+*
+* @example
+* ```ts
+* const value = column_getPinnedIndex(column)
+* ```
+*/
 function column_getPinnedIndex(column) {
 	var _column$table$atoms$c2;
 	const position = column_getIsPinned(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.
+*
+* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+*
+* @example
+* ```ts
+* const value = row_getCenterVisibleCells(row)
+* ```
+*/
 function row_getCenterVisibleCells(row) {
 	var _row$table$atoms$colu;
-	const allCells = require_utils.callMemoOrStaticFn(row, "getAllVisibleCells", require_columnVisibilityFeature_utils.row_getAllVisibleCells);
+	const allCells = require_utils.callMemoOrStaticFn(row, "getVisibleCells", require_columnVisibilityFeature_utils.row_getVisibleCells);
 	const { left, right } = ((_row$table$atoms$colu = row.table.atoms.columnPinning) === null || _row$table$atoms$colu === void 0 ? void 0 : _row$table$atoms$colu.get()) ?? getDefaultColumnPinningState();
 	const leftAndRight = [...left, ...right];
 	return allCells.filter((d) => !leftAndRight.includes(d.column.id));
 }
+/**
+* Returns left visible cells for a row.
+*
+* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+*
+* @example
+* ```ts
+* const value = row_getLeftVisibleCells(row)
+* ```
+*/
 function row_getLeftVisibleCells(row) {
 	var _row$table$atoms$colu2;
-	const allCells = require_utils.callMemoOrStaticFn(row, "getAllVisibleCells", require_columnVisibilityFeature_utils.row_getAllVisibleCells);
 	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();
-	const cells = left.map((columnId) => allCells.find((cell) => cell.column.id === columnId)).filter(Boolean);
-	cells.forEach((cell) => {
-		cell.position = "left";
-	});
+	if (!left.length) return [];
+	const allVisibleCells = require_utils.callMemoOrStaticFn(row, "getVisibleCellsByColumnId", require_columnVisibilityFeature_utils.row_getVisibleCellsByColumnId);
+	const cells = [];
+	for (let i = 0; i < left.length; i++) {
+		const cell = allVisibleCells[left[i]];
+		if (cell) {
+			cell.position = "left";
+			cells.push(cell);
+		}
+	}
 	return cells;
 }
+/**
+* Returns right visible cells for a row.
+*
+* This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+*
+* @example
+* ```ts
+* const value = row_getRightVisibleCells(row)
+* ```
+*/
 function row_getRightVisibleCells(row) {
 	var _row$table$atoms$colu3;
-	const allCells = require_utils.callMemoOrStaticFn(row, "getAllVisibleCells", require_columnVisibilityFeature_utils.row_getAllVisibleCells);
 	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();
-	const cells = right.map((columnId) => allCells.find((cell) => cell.column.id === columnId)).filter(Boolean);
-	cells.forEach((cell) => {
-		cell.position = "right";
-	});
+	if (!right.length) return [];
+	const allVisibleCells = require_utils.callMemoOrStaticFn(row, "getVisibleCellsByColumnId", require_columnVisibilityFeature_utils.row_getVisibleCellsByColumnId);
+	const cells = [];
+	for (let i = 0; i < right.length; i++) {
+		const cell = allVisibleCells[right[i]];
+		if (cell) {
+			cell.position = "right";
+			cells.push(cell);
+		}
+	}
 	return cells;
 }
+/**
+* Updates the table's column pinning state slice.
+*
+* The updater follows TanStack Table updater semantics and is routed through the corresponding `on*Change` option or backing atom.
+*
+* @example
+* ```ts
+* table_setColumnPinning(table, (old) => old)
+* ```
+*/
 function table_setColumnPinning(table, updater) {
 	var _table$options$onColu, _table$options;
 	(_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.
+*
+* By default the reset uses `table.initialState`; when supported, a blank/default reset bypasses the saved initial value.
+*
+* @example
+* ```ts
+* table_resetColumnPinning(table)
+* table_resetColumnPinning(table, true)
+* ```
+*/
 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getIsSomeColumnsPinned(table)
+* ```
+*/
 function table_getIsSomeColumnsPinned(table, position) {
 	var _table$atoms$columnPi;
 	const pinningState = (_table$atoms$columnPi = table.atoms.columnPinning) === null || _table$atoms$columnPi === void 0 ? void 0 : _table$atoms$columnPi.get();
 	if (!position) return Boolean((pinningState === null || pinningState === void 0 ? void 0 : pinningState.left.length) || (pinningState === null || pinningState === void 0 ? void 0 : pinningState.right.length));
 	return Boolean(pinningState === null || pinningState === void 0 ? void 0 : pinningState[position].length);
 }
+/**
+* Returns left header groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getLeftHeaderGroups(table)
+* ```
+*/
 function table_getLeftHeaderGroups(table) {
 	var _table$atoms$columnPi2;
 	const allColumns = table.getAllColumns();
-	const leafColumns = require_utils.callMemoOrStaticFn(table, "getVisibleLeafColumns", require_columnVisibilityFeature_utils.table_getVisibleLeafColumns);
+	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();
-	return require_buildHeaderGroups.buildHeaderGroups(allColumns, left.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean), table, "left");
+	const orderedLeafColumns = [];
+	for (let i = 0; i < left.length; i++) {
+		const column = leafColumnsById[left[i]];
+		if (column && require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible)) orderedLeafColumns.push(column);
+	}
+	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "left");
 }
+/**
+* Returns right header groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getRightHeaderGroups(table)
+* ```
+*/
 function table_getRightHeaderGroups(table) {
 	var _table$atoms$columnPi3;
 	const allColumns = table.getAllColumns();
-	const leafColumns = require_utils.callMemoOrStaticFn(table, "getVisibleLeafColumns", require_columnVisibilityFeature_utils.table_getVisibleLeafColumns);
+	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();
-	return require_buildHeaderGroups.buildHeaderGroups(allColumns, right.map((columnId) => leafColumns.find((d) => d.id === columnId)).filter(Boolean), table, "right");
+	const orderedLeafColumns = [];
+	for (let i = 0; i < right.length; i++) {
+		const column = leafColumnsById[right[i]];
+		if (column && require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible)) orderedLeafColumns.push(column);
+	}
+	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "right");
 }
+/**
+* Returns center header groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getCenterHeaderGroups(table)
+* ```
+*/
 function table_getCenterHeaderGroups(table) {
 	var _table$atoms$columnPi4;
 	const allColumns = table.getAllColumns();
@@ -105,67 +271,261 @@ function table_getCenterHeaderGroups(table) {
 	leafColumns = leafColumns.filter((column) => !leftAndRight.includes(column.id));
 	return require_buildHeaderGroups.buildHeaderGroups(allColumns, leafColumns, table, "center");
 }
+/**
+* Returns left footer groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getLeftFooterGroups(table)
+* ```
+*/
 function table_getLeftFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups)].reverse();
 }
+/**
+* Returns right footer groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getRightFooterGroups(table)
+* ```
+*/
 function table_getRightFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups)].reverse();
 }
+/**
+* Returns center footer groups for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getCenterFooterGroups(table)
+* ```
+*/
 function table_getCenterFooterGroups(table) {
 	return [...require_utils.callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups)].reverse();
 }
+/**
+* Returns left flat headers for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getLeftFlatHeaders(table)
+* ```
+*/
 function table_getLeftFlatHeaders(table) {
-	return require_utils.callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const leftHeaderGroups = require_utils.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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getRightFlatHeaders(table)
+* ```
+*/
 function table_getRightFlatHeaders(table) {
-	return require_utils.callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const rightHeaderGroups = require_utils.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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getCenterFlatHeaders(table)
+* ```
+*/
 function table_getCenterFlatHeaders(table) {
-	return require_utils.callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups).map((headerGroup) => {
-		return headerGroup.headers;
-	}).flat();
+	const centerHeaderGroups = require_utils.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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getLeftLeafColumns(table)
+* ```
+*/
 function table_getLeftLeafColumns(table) {
 	var _table$atoms$columnPi5;
 	const { left } = ((_table$atoms$columnPi5 = table.atoms.columnPinning) === null || _table$atoms$columnPi5 === void 0 ? void 0 : _table$atoms$columnPi5.get()) ?? getDefaultColumnPinningState();
-	return left.map((columnId) => table.getAllLeafColumns().find((column) => column.id === columnId)).filter(Boolean);
+	const leafColumnsById = table.getAllLeafColumnsById();
+	const result = [];
+	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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getRightLeafColumns(table)
+* ```
+*/
 function table_getRightLeafColumns(table) {
 	var _table$atoms$columnPi6;
 	const { right } = ((_table$atoms$columnPi6 = table.atoms.columnPinning) === null || _table$atoms$columnPi6 === void 0 ? void 0 : _table$atoms$columnPi6.get()) ?? getDefaultColumnPinningState();
-	return right.map((columnId) => table.getAllLeafColumns().find((column) => column.id === columnId)).filter(Boolean);
+	const leafColumnsById = table.getAllLeafColumnsById();
+	const result = [];
+	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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getCenterLeafColumns(table)
+* ```
+*/
 function table_getCenterLeafColumns(table) {
 	var _table$atoms$columnPi7;
 	const { left, right } = ((_table$atoms$columnPi7 = table.atoms.columnPinning) === null || _table$atoms$columnPi7 === void 0 ? void 0 : _table$atoms$columnPi7.get()) ?? getDefaultColumnPinningState();
 	const leftAndRight = [...left, ...right];
 	return table.getAllLeafColumns().filter((d) => !leftAndRight.includes(d.id));
 }
+/**
+* Returns pinned leaf columns for the table.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getPinnedLeafColumns(table)
+* ```
+*/
 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = 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.
+*
+* This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+*
+* @example
+* ```ts
+* const value = table_getPinnedVisibleLeafColumns(table)
+* ```
+*/
 function table_getPinnedVisibleLeafColumns(table, position) {
 	return !position ? require_utils.callMemoOrStaticFn(table, "getVisibleLeafColumns", require_columnVisibilityFeature_utils.table_getVisibleLeafColumns) : position === "left" ? require_utils.callMemoOrStaticFn(table, "getLeftVisibleLeafColumns", table_getLeftVisibleLeafColumns) : position === "right" ? require_utils.callMemoOrStaticFn(table, "getRightVisibleLeafColumns", table_getRightVisibleLeafColumns) : require_utils.callMemoOrStaticFn(table, "getCenterVisibleLeafColumns", table_getCenterVisibleLeafColumns);
 }