@tanstack/table-core 9.0.0-beta.7 → 9.0.0-beta.70

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

@@ -16,20 +16,24 @@ import { buildHeaderGroups } from "../../core/headers/buildHeaderGroups.js";
 */
 function getDefaultColumnPinningState() {
 	return {
-		left: [],
-		right: []
+		start: [],
+		end: []
 	};
 }
 /**
 * Moves this column's leaf column ids into a pinning region.
 *
 * 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'`
+* from both regions, then appended to the requested `'start'` or `'end'`
 * region. Passing `false` unpins them back to the center.
 *
+* `start` and `end` are logical positions. In LTR languages/layouts, `start`
+* usually corresponds to left and `end` to right. In RTL languages/layouts,
+* `start` usually corresponds to right and `end` to left.
+*
 * @example
 * ```ts
-* column_pin(column, 'left')
+* column_pin(column, 'start')
 * ```
 */
 function column_pin(column, position) {
@@ -40,17 +44,17 @@ function column_pin(column, position) {
 		if (id) columnIds.push(id);
 	}
 	table_setColumnPinning(column.table, (old) => {
-		if (position === "right") return {
-			left: old.left.filter((d) => !columnIds.includes(d)),
-			right: [...old.right.filter((d) => !columnIds.includes(d)), ...columnIds]
+		if (position === "end") return {
+			start: old.start.filter((d) => !columnIds.includes(d)),
+			end: [...old.end.filter((d) => !columnIds.includes(d)), ...columnIds]
 		};
-		if (position === "left") return {
-			left: [...old.left.filter((d) => !columnIds.includes(d)), ...columnIds],
-			right: old.right.filter((d) => !columnIds.includes(d))
+		if (position === "start") return {
+			start: [...old.start.filter((d) => !columnIds.includes(d)), ...columnIds],
+			end: old.end.filter((d) => !columnIds.includes(d))
 		};
 		return {
-			left: old.left.filter((d) => !columnIds.includes(d)),
-			right: old.right.filter((d) => !columnIds.includes(d))
+			start: old.start.filter((d) => !columnIds.includes(d)),
+			end: old.end.filter((d) => !columnIds.includes(d))
 		};
 	});
 }
@@ -71,27 +75,30 @@ function column_getCanPin(column) {
 /**
 * Reads this column's current pinning region.
 *
-* Group columns report `'left'` or `'right'` when any leaf column is pinned in
+* Group columns report `'start'` or `'end'` when any leaf column is pinned in
 * that region. Unpinned columns return `false`.
 *
+* `start` and `end` are logical positions. In LTR languages/layouts, `start`
+* usually corresponds to left and `end` to right. In RTL languages/layouts,
+* `start` usually corresponds to right and `end` to left.
+*
 * @example
 * ```ts
 * const position = column_getIsPinned(column)
 * ```
 */
 function column_getIsPinned(column) {
-	var _column$table$atoms$c;
-	const leafColumnIds = column.getLeafColumns().map((d) => d.id);
-	const { left, right } = ((_column$table$atoms$c = column.table.atoms.columnPinning) === null || _column$table$atoms$c === void 0 ? void 0 : _column$table$atoms$c.get()) ?? getDefaultColumnPinningState();
-	const isLeft = leafColumnIds.some((d) => left.includes(d));
-	const isRight = leafColumnIds.some((d) => right.includes(d));
-	return isLeft ? "left" : isRight ? "right" : false;
+	const leafColumns = column.getLeafColumns();
+	const { start, end } = column.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	for (let i = 0; i < leafColumns.length; i++) if (start.includes(leafColumns[i].id)) return "start";
+	for (let i = 0; i < leafColumns.length; i++) if (end.includes(leafColumns[i].id)) return "end";
+	return false;
 }
 /**
 * Finds this column's index within its pinned region.
 *
 * Unpinned columns return `0`; pinned columns return their position in
-* `state.columnPinning.left` or `state.columnPinning.right`.
+* `state.columnPinning.start` or `state.columnPinning.end`.
 *
 * @example
 * ```ts
@@ -99,12 +106,11 @@ function column_getIsPinned(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;
+	return position ? column.table.atoms.columnPinning?.get()?.[position].indexOf(column.id) ?? -1 : 0;
 }
 /**
-* Collects visible cells whose columns are not pinned left or right.
+* Collects visible cells whose columns are not pinned start or end.
 *
 * The result preserves the row's visible-cell order for center columns.
 *
@@ -114,59 +120,57 @@ function column_getPinnedIndex(column) {
 * ```
 */
 function row_getCenterVisibleCells(row) {
-	var _row$table$atoms$colu;
 	const allCells = callMemoOrStaticFn(row, "getVisibleCells", 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));
+	const { start, end } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!start.length && !end.length) return allCells;
+	const startAndEnd = [...start, ...end];
+	return allCells.filter((d) => !startAndEnd.includes(d.column.id));
 }
 /**
-* Collects visible cells for columns pinned to the left region.
+* Collects visible cells for columns pinned to the start region.
 *
-* Cells are returned in `state.columnPinning.left` order and are marked with
-* `cell.position = 'left'`.
+* Cells are returned in `state.columnPinning.start` order and are marked with
+* `cell.position = 'start'`.
 *
 * @example
 * ```ts
-* const leftCells = row_getLeftVisibleCells(row)
+* const startCells = row_getStartVisibleCells(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 [];
+function row_getStartVisibleCells(row) {
+	const { start } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!start.length) return [];
 	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
 	const cells = [];
-	for (let i = 0; i < left.length; i++) {
-		const cell = allVisibleCells[left[i]];
+	for (let i = 0; i < start.length; i++) {
+		const cell = allVisibleCells[start[i]];
 		if (cell) {
-			cell.position = "left";
+			cell.position = "start";
 			cells.push(cell);
 		}
 	}
 	return cells;
 }
 /**
-* Collects visible cells for columns pinned to the right region.
+* Collects visible cells for columns pinned to the end region.
 *
-* Cells are returned in `state.columnPinning.right` order and are marked with
-* `cell.position = 'right'`.
+* Cells are returned in `state.columnPinning.end` order and are marked with
+* `cell.position = 'end'`.
 *
 * @example
 * ```ts
-* const rightCells = row_getRightVisibleCells(row)
+* const endCells = row_getEndVisibleCells(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 [];
+function row_getEndVisibleCells(row) {
+	const { end } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!end.length) return [];
 	const allVisibleCells = callMemoOrStaticFn(row, "getVisibleCellsByColumnId", row_getVisibleCellsByColumnId);
 	const cells = [];
-	for (let i = 0; i < right.length; i++) {
-		const cell = allVisibleCells[right[i]];
+	for (let i = 0; i < end.length; i++) {
+		const cell = allVisibleCells[end[i]];
 		if (cell) {
-			cell.position = "right";
+			cell.position = "end";
 			cells.push(cell);
 		}
 	}
@@ -175,23 +179,22 @@ function row_getRightVisibleCells(row) {
 /**
 * Routes a column pinning updater through the table's pinning change handler.
 *
-* The updater may be a next `{ left, right }` state or a function of the
+* The updater may be a next `{ start, end }` state or a function of the
 * previous state, matching the instance `table.setColumnPinning` behavior.
 *
 * @example
 * ```ts
-* table_setColumnPinning(table, (old) => ({ ...old, left: ['select'] }))
+* table_setColumnPinning(table, (old) => ({ ...old, start: ['select'] }))
 * ```
 */
 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);
+	table.options.onColumnPinningChange?.(updater);
 }
 /**
 * Resets `columnPinning` to the configured initial state or feature default.
 *
 * With no argument, the reset clones `table.initialState.columnPinning` when it
-* exists. Passing `true` ignores initial state and resets to empty left/right
+* exists. Passing `true` ignores initial state and resets to empty start/end
 * arrays.
 *
 * @example
@@ -206,7 +209,7 @@ function table_resetColumnPinning(table, defaultState) {
 /**
 * Checks whether any columns are pinned.
 *
-* Omit `position` to check both sides, or pass `'left'`/`'right'` to inspect a
+* Omit `position` to check both sides, or pass `'start'`/`'end'` to inspect a
 * single pinning region.
 *
 * @example
@@ -215,61 +218,58 @@ function table_resetColumnPinning(table, defaultState) {
 * ```
 */
 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);
+	const pinningState = table.atoms.columnPinning?.get();
+	if (!position) return Boolean(pinningState?.start.length || pinningState?.end.length);
+	return Boolean(pinningState?.[position].length);
 }
 /**
-* Builds header groups for visible columns pinned to the left region.
+* Builds header groups for visible columns pinned to the start region.
 *
-* The leaf columns are read in `state.columnPinning.left` order and then passed
+* The leaf columns are read in `state.columnPinning.start` order and then passed
 * through the same header-group builder as the unpinned table.
 *
 * @example
 * ```ts
-* const headerGroups = table_getLeftHeaderGroups(table)
+* const headerGroups = table_getStartHeaderGroups(table)
 * ```
 */
-function table_getLeftHeaderGroups(table) {
-	var _table$atoms$columnPi2;
+function table_getStartHeaderGroups(table) {
 	const allColumns = table.getAllColumns();
 	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 { start } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
 	const orderedLeafColumns = [];
-	for (let i = 0; i < left.length; i++) {
-		const column = leafColumnsById[left[i]];
+	for (let i = 0; i < start.length; i++) {
+		const column = leafColumnsById[start[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) orderedLeafColumns.push(column);
 	}
-	return buildHeaderGroups(allColumns, orderedLeafColumns, table, "left");
+	return buildHeaderGroups(allColumns, orderedLeafColumns, table, "start");
 }
 /**
-* Builds header groups for visible columns pinned to the right region.
+* Builds header groups for visible columns pinned to the end region.
 *
-* The leaf columns are read in `state.columnPinning.right` order and then
+* The leaf columns are read in `state.columnPinning.end` order and then
 * passed through the same header-group builder as the unpinned table.
 *
 * @example
 * ```ts
-* const headerGroups = table_getRightHeaderGroups(table)
+* const headerGroups = table_getEndHeaderGroups(table)
 * ```
 */
-function table_getRightHeaderGroups(table) {
-	var _table$atoms$columnPi3;
+function table_getEndHeaderGroups(table) {
 	const allColumns = table.getAllColumns();
 	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 { end } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
 	const orderedLeafColumns = [];
-	for (let i = 0; i < right.length; i++) {
-		const column = leafColumnsById[right[i]];
+	for (let i = 0; i < end.length; i++) {
+		const column = leafColumnsById[end[i]];
 		if (column && callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible)) orderedLeafColumns.push(column);
 	}
-	return buildHeaderGroups(allColumns, orderedLeafColumns, table, "right");
+	return buildHeaderGroups(allColumns, orderedLeafColumns, table, "end");
 }
 /**
 * Builds header groups for visible columns that are not pinned.
 *
-* Left- and right-pinned column ids are removed from the visible leaf column
+* Start- and end-pinned column ids are removed from the visible leaf column
 * list before header groups are built for the center region.
 *
 * @example
@@ -278,39 +278,40 @@ function table_getRightHeaderGroups(table) {
 * ```
 */
 function table_getCenterHeaderGroups(table) {
-	var _table$atoms$columnPi4;
 	const allColumns = table.getAllColumns();
 	let leafColumns = callMemoOrStaticFn(table, "getVisibleLeafColumns", table_getVisibleLeafColumns);
-	const { left, right } = ((_table$atoms$columnPi4 = table.atoms.columnPinning) === null || _table$atoms$columnPi4 === void 0 ? void 0 : _table$atoms$columnPi4.get()) ?? getDefaultColumnPinningState();
-	const leftAndRight = [...left, ...right];
-	leafColumns = leafColumns.filter((column) => !leftAndRight.includes(column.id));
+	const { start, end } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (start.length || end.length) {
+		const startAndEnd = [...start, ...end];
+		leafColumns = leafColumns.filter((column) => !startAndEnd.includes(column.id));
+	}
 	return buildHeaderGroups(allColumns, leafColumns, table, "center");
 }
 /**
-* Builds footer groups for the left pinned region.
+* Builds footer groups for the start pinned region.
 *
-* Footer groups reuse the left header groups in reverse order.
+* Footer groups reuse the start header groups in reverse order.
 *
 * @example
 * ```ts
-* const footerGroups = table_getLeftFooterGroups(table)
+* const footerGroups = table_getStartFooterGroups(table)
 * ```
 */
-function table_getLeftFooterGroups(table) {
-	return [...callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups)].reverse();
+function table_getStartFooterGroups(table) {
+	return [...callMemoOrStaticFn(table, "getStartHeaderGroups", table_getStartHeaderGroups)].reverse();
 }
 /**
-* Builds footer groups for the right pinned region.
+* Builds footer groups for the end pinned region.
 *
-* Footer groups reuse the right header groups in reverse order.
+* Footer groups reuse the end header groups in reverse order.
 *
 * @example
 * ```ts
-* const footerGroups = table_getRightFooterGroups(table)
+* const footerGroups = table_getEndFooterGroups(table)
 * ```
 */
-function table_getRightFooterGroups(table) {
-	return [...callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups)].reverse();
+function table_getEndFooterGroups(table) {
+	return [...callMemoOrStaticFn(table, "getEndHeaderGroups", table_getEndHeaderGroups)].reverse();
 }
 /**
 * Builds footer groups for the center, unpinned region.
@@ -326,17 +327,17 @@ function table_getCenterFooterGroups(table) {
 	return [...callMemoOrStaticFn(table, "getCenterHeaderGroups", table_getCenterHeaderGroups)].reverse();
 }
 /**
-* Flattens every header from the left pinned header groups.
+* Flattens every header from the start pinned header groups.
 *
 * Parent headers and placeholder headers are included.
 *
 * @example
 * ```ts
-* const headers = table_getLeftFlatHeaders(table)
+* const headers = table_getStartFlatHeaders(table)
 * ```
 */
-function table_getLeftFlatHeaders(table) {
-	const leftHeaderGroups = callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups);
+function table_getStartFlatHeaders(table) {
+	const leftHeaderGroups = callMemoOrStaticFn(table, "getStartHeaderGroups", table_getStartHeaderGroups);
 	const result = [];
 	for (let i = 0; i < leftHeaderGroups.length; i++) {
 		const headers = leftHeaderGroups[i].headers;
@@ -345,17 +346,17 @@ function table_getLeftFlatHeaders(table) {
 	return result;
 }
 /**
-* Flattens every header from the right pinned header groups.
+* Flattens every header from the end pinned header groups.
 *
 * Parent headers and placeholder headers are included.
 *
 * @example
 * ```ts
-* const headers = table_getRightFlatHeaders(table)
+* const headers = table_getEndFlatHeaders(table)
 * ```
 */
-function table_getRightFlatHeaders(table) {
-	const rightHeaderGroups = callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups);
+function table_getEndFlatHeaders(table) {
+	const rightHeaderGroups = callMemoOrStaticFn(table, "getEndHeaderGroups", table_getEndHeaderGroups);
 	const result = [];
 	for (let i = 0; i < rightHeaderGroups.length; i++) {
 		const headers = rightHeaderGroups[i].headers;
@@ -383,30 +384,30 @@ function table_getCenterFlatHeaders(table) {
 	return result;
 }
 /**
-* Collects leaf headers for the left pinned region.
+* Collects leaf headers for the start pinned region.
 *
-* Parent headers are filtered out from the left flat header list.
+* Parent headers are filtered out from the start flat header list.
 *
 * @example
 * ```ts
-* const headers = table_getLeftLeafHeaders(table)
+* const headers = table_getStartLeafHeaders(table)
 * ```
 */
-function table_getLeftLeafHeaders(table) {
-	return callMemoOrStaticFn(table, "getLeftFlatHeaders", table_getLeftFlatHeaders).filter((header) => !header.subHeaders.length);
+function table_getStartLeafHeaders(table) {
+	return callMemoOrStaticFn(table, "getStartFlatHeaders", table_getStartFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
-* Collects leaf headers for the right pinned region.
+* Collects leaf headers for the end pinned region.
 *
-* Parent headers are filtered out from the right flat header list.
+* Parent headers are filtered out from the end flat header list.
 *
 * @example
 * ```ts
-* const headers = table_getRightLeafHeaders(table)
+* const headers = table_getEndLeafHeaders(table)
 * ```
 */
-function table_getRightLeafHeaders(table) {
-	return callMemoOrStaticFn(table, "getRightFlatHeaders", table_getRightFlatHeaders).filter((header) => !header.subHeaders.length);
+function table_getEndLeafHeaders(table) {
+	return callMemoOrStaticFn(table, "getEndFlatHeaders", table_getEndFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
 * Collects leaf headers for the center, unpinned region.
@@ -422,53 +423,51 @@ function table_getCenterLeafHeaders(table) {
 	return callMemoOrStaticFn(table, "getCenterFlatHeaders", table_getCenterFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
-* Resolves leaf columns pinned to the left region.
+* Resolves leaf columns pinned to the start region.
 *
-* The result follows `state.columnPinning.left` order and skips stale ids that
+* The result follows `state.columnPinning.start` order and skips stale ids that
 * no longer correspond to a leaf column.
 *
 * @example
 * ```ts
-* const columns = table_getLeftLeafColumns(table)
+* const columns = table_getStartLeafColumns(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();
+function table_getStartLeafColumns(table) {
+	const { start } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const result = [];
-	for (let i = 0; i < left.length; i++) {
-		const column = leafColumnsById[left[i]];
+	for (let i = 0; i < start.length; i++) {
+		const column = leafColumnsById[start[i]];
 		if (column) result.push(column);
 	}
 	return result;
 }
 /**
-* Resolves leaf columns pinned to the right region.
+* Resolves leaf columns pinned to the end region.
 *
-* The result follows `state.columnPinning.right` order and skips stale ids that
+* The result follows `state.columnPinning.end` order and skips stale ids that
 * no longer correspond to a leaf column.
 *
 * @example
 * ```ts
-* const columns = table_getRightLeafColumns(table)
+* const columns = table_getEndLeafColumns(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();
+function table_getEndLeafColumns(table) {
+	const { end } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
 	const leafColumnsById = table.getAllLeafColumnsById();
 	const result = [];
-	for (let i = 0; i < right.length; i++) {
-		const column = leafColumnsById[right[i]];
+	for (let i = 0; i < end.length; i++) {
+		const column = leafColumnsById[end[i]];
 		if (column) result.push(column);
 	}
 	return result;
 }
 /**
-* Resolves leaf columns that are not pinned to either side.
+* Resolves leaf columns that are not pinned to either logical side.
 *
-* Left- and right-pinned ids are removed from `table.getAllLeafColumns()`.
+* Start- and end-pinned ids are removed from `table.getAllLeafColumns()`.
 *
 * @example
 * ```ts
@@ -476,15 +475,15 @@ function table_getRightLeafColumns(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));
+	const { start, end } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!start.length && !end.length) return table.getAllLeafColumns();
+	const startAndEnd = [...start, ...end];
+	return table.getAllLeafColumns().filter((d) => !startAndEnd.includes(d.id));
 }
 /**
 * Resolves leaf columns for a requested pinning region.
 *
-* Pass `'left'`, `'center'`, or `'right'` for a partition, or pass `false` to
+* Pass `'start'`, `'center'`, or `'end'` for a partition, or pass `false` to
 * read all leaf columns without partitioning.
 *
 * @example
@@ -493,33 +492,33 @@ function table_getCenterLeafColumns(table) {
 * ```
 */
 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);
+	return !position ? table.getAllLeafColumns() : position === "start" ? callMemoOrStaticFn(table, "getStartLeafColumns", table_getStartLeafColumns) : position === "end" ? callMemoOrStaticFn(table, "getEndLeafColumns", table_getEndLeafColumns) : callMemoOrStaticFn(table, "getCenterLeafColumns", table_getCenterLeafColumns);
 }
 /**
-* Resolves visible leaf columns pinned to the left region.
+* Resolves visible leaf columns pinned to the start region.
 *
-* Hidden pinned columns are filtered out after the left pin order is applied.
+* Hidden pinned columns are filtered out after the start pin order is applied.
 *
 * @example
 * ```ts
-* const columns = table_getLeftVisibleLeafColumns(table)
+* const columns = table_getStartVisibleLeafColumns(table)
 * ```
 */
-function table_getLeftVisibleLeafColumns(table) {
-	return callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+function table_getStartVisibleLeafColumns(table) {
+	return callMemoOrStaticFn(table, "getStartLeafColumns", table_getStartLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
-* Resolves visible leaf columns pinned to the right region.
+* Resolves visible leaf columns pinned to the end region.
 *
-* Hidden pinned columns are filtered out after the right pin order is applied.
+* Hidden pinned columns are filtered out after the end pin order is applied.
 *
 * @example
 * ```ts
-* const columns = table_getRightVisibleLeafColumns(table)
+* const columns = table_getEndVisibleLeafColumns(table)
 * ```
 */
-function table_getRightVisibleLeafColumns(table) {
-	return callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
+function table_getEndVisibleLeafColumns(table) {
+	return callMemoOrStaticFn(table, "getEndLeafColumns", table_getEndLeafColumns).filter((column) => callMemoOrStaticFn(column, "getIsVisible", column_getIsVisible));
 }
 /**
 * Resolves visible leaf columns that are not pinned.
@@ -538,18 +537,17 @@ function table_getCenterVisibleLeafColumns(table) {
 /**
 * Resolves visible leaf columns for a requested pinning region.
 *
-* Omit `position` to get all visible leaf columns, or pass `'left'`, `'center'`,
-* or `'right'` to get one partition.
+* Omit `position` to get all visible leaf columns, or pass `'start'`, `'center'`,
+* or `'end'` to get one partition.
 *
 * @example
 * ```ts
-* const columns = table_getPinnedVisibleLeafColumns(table, 'left')
+* const columns = table_getPinnedVisibleLeafColumns(table, 'start')
 * ```
 */
 function table_getPinnedVisibleLeafColumns(table, position) {
-	return !position ? callMemoOrStaticFn(table, "getVisibleLeafColumns", table_getVisibleLeafColumns) : position === "left" ? callMemoOrStaticFn(table, "getLeftVisibleLeafColumns", table_getLeftVisibleLeafColumns) : position === "right" ? callMemoOrStaticFn(table, "getRightVisibleLeafColumns", table_getRightVisibleLeafColumns) : callMemoOrStaticFn(table, "getCenterVisibleLeafColumns", table_getCenterVisibleLeafColumns);
+	return !position ? callMemoOrStaticFn(table, "getVisibleLeafColumns", table_getVisibleLeafColumns) : position === "start" ? callMemoOrStaticFn(table, "getStartVisibleLeafColumns", table_getStartVisibleLeafColumns) : position === "end" ? callMemoOrStaticFn(table, "getEndVisibleLeafColumns", table_getEndVisibleLeafColumns) : callMemoOrStaticFn(table, "getCenterVisibleLeafColumns", table_getCenterVisibleLeafColumns);
 }
 
 //#endregion
-export { column_getCanPin, column_getIsPinned, column_getPinnedIndex, column_pin, getDefaultColumnPinningState, row_getCenterVisibleCells, row_getLeftVisibleCells, row_getRightVisibleCells, table_getCenterFlatHeaders, table_getCenterFooterGroups, table_getCenterHeaderGroups, table_getCenterLeafColumns, table_getCenterLeafHeaders, table_getCenterVisibleLeafColumns, table_getIsSomeColumnsPinned, table_getLeftFlatHeaders, table_getLeftFooterGroups, table_getLeftHeaderGroups, table_getLeftLeafColumns, table_getLeftLeafHeaders, table_getLeftVisibleLeafColumns, table_getPinnedLeafColumns, table_getPinnedVisibleLeafColumns, table_getRightFlatHeaders, table_getRightFooterGroups, table_getRightHeaderGroups, table_getRightLeafColumns, table_getRightLeafHeaders, table_getRightVisibleLeafColumns, table_resetColumnPinning, table_setColumnPinning };
-//# sourceMappingURL=columnPinningFeature.utils.js.map
+export { column_getCanPin, column_getIsPinned, column_getPinnedIndex, column_pin, getDefaultColumnPinningState, row_getCenterVisibleCells, row_getEndVisibleCells, row_getStartVisibleCells, table_getCenterFlatHeaders, table_getCenterFooterGroups, table_getCenterHeaderGroups, table_getCenterLeafColumns, table_getCenterLeafHeaders, table_getCenterVisibleLeafColumns, table_getEndFlatHeaders, table_getEndFooterGroups, table_getEndHeaderGroups, table_getEndLeafColumns, table_getEndLeafHeaders, table_getEndVisibleLeafColumns, table_getIsSomeColumnsPinned, table_getPinnedLeafColumns, table_getPinnedVisibleLeafColumns, table_getStartFlatHeaders, table_getStartFooterGroups, table_getStartHeaderGroups, table_getStartLeafColumns, table_getStartLeafHeaders, table_getStartVisibleLeafColumns, table_resetColumnPinning, table_setColumnPinning };

package/dist/features/column-resizing/columnResizingFeature.d.ts

@@ -1,10 +1,8 @@
 import { TableFeature } from "../../types/TableFeatures.js";
-
 //#region src/features/column-resizing/columnResizingFeature.d.ts
 /**
  * Feature that adds column resizing state, options, and resize handlers.
  */
 declare const columnResizingFeature: TableFeature;
 //#endregion
-export { columnResizingFeature };
-//# sourceMappingURL=columnResizingFeature.d.ts.map
+export { columnResizingFeature };

package/dist/features/column-resizing/columnResizingFeature.js

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