@tanstack/table-core 9.0.0-beta.37 → 9.0.0-beta.42

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

@@ -16,20 +16,24 @@ const require_buildHeaderGroups = require('../../core/headers/buildHeaderGroups.
 */
 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,9 +75,13 @@ 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)
@@ -81,16 +89,16 @@ function column_getCanPin(column) {
 */
 function column_getIsPinned(column) {
 	const leafColumns = column.getLeafColumns();
-	const { left, right } = column.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	for (let i = 0; i < leafColumns.length; i++) if (left.includes(leafColumns[i].id)) return "left";
-	for (let i = 0; i < leafColumns.length; i++) if (right.includes(leafColumns[i].id)) return "right";
+	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
@@ -102,7 +110,7 @@ function column_getPinnedIndex(column) {
 	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.
 *
@@ -113,56 +121,56 @@ function column_getPinnedIndex(column) {
 */
 function row_getCenterVisibleCells(row) {
 	const allCells = require_utils.callMemoOrStaticFn(row, "getVisibleCells", require_columnVisibilityFeature_utils.row_getVisibleCells);
-	const { left, right } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	if (!left.length && !right.length) return allCells;
-	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) {
-	const { left } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	if (!left.length) return [];
+function row_getStartVisibleCells(row) {
+	const { start } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!start.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]];
+	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) {
-	const { right } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	if (!right.length) return [];
+function row_getEndVisibleCells(row) {
+	const { end } = row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
+	if (!end.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]];
+	for (let i = 0; i < end.length; i++) {
+		const cell = allVisibleCells[end[i]];
 		if (cell) {
-			cell.position = "right";
+			cell.position = "end";
 			cells.push(cell);
 		}
 	}
@@ -171,12 +179,12 @@ 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) {
@@ -186,7 +194,7 @@ function table_setColumnPinning(table, 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
@@ -201,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
@@ -211,57 +219,57 @@ function table_resetColumnPinning(table, defaultState) {
 */
 function table_getIsSomeColumnsPinned(table, position) {
 	const pinningState = table.atoms.columnPinning?.get();
-	if (!position) return Boolean(pinningState?.left.length || pinningState?.right.length);
+	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) {
+function table_getStartHeaderGroups(table) {
 	const allColumns = table.getAllColumns();
 	const leafColumnsById = table.getAllLeafColumnsById();
-	const { left } = table.atoms.columnPinning?.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 && require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible)) orderedLeafColumns.push(column);
 	}
-	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "left");
+	return require_buildHeaderGroups.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) {
+function table_getEndHeaderGroups(table) {
 	const allColumns = table.getAllColumns();
 	const leafColumnsById = table.getAllLeafColumnsById();
-	const { right } = table.atoms.columnPinning?.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 && require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible)) orderedLeafColumns.push(column);
 	}
-	return require_buildHeaderGroups.buildHeaderGroups(allColumns, orderedLeafColumns, table, "right");
+	return require_buildHeaderGroups.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
@@ -272,38 +280,38 @@ function table_getRightHeaderGroups(table) {
 function table_getCenterHeaderGroups(table) {
 	const allColumns = table.getAllColumns();
 	let leafColumns = require_utils.callMemoOrStaticFn(table, "getVisibleLeafColumns", require_columnVisibilityFeature_utils.table_getVisibleLeafColumns);
-	const { left, right } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	if (left.length || right.length) {
-		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 require_buildHeaderGroups.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 [...require_utils.callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups)].reverse();
+function table_getStartFooterGroups(table) {
+	return [...require_utils.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 [...require_utils.callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups)].reverse();
+function table_getEndFooterGroups(table) {
+	return [...require_utils.callMemoOrStaticFn(table, "getEndHeaderGroups", table_getEndHeaderGroups)].reverse();
 }
 /**
 * Builds footer groups for the center, unpinned region.
@@ -319,17 +327,17 @@ function table_getCenterFooterGroups(table) {
 	return [...require_utils.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 = require_utils.callMemoOrStaticFn(table, "getLeftHeaderGroups", table_getLeftHeaderGroups);
+function table_getStartFlatHeaders(table) {
+	const leftHeaderGroups = require_utils.callMemoOrStaticFn(table, "getStartHeaderGroups", table_getStartHeaderGroups);
 	const result = [];
 	for (let i = 0; i < leftHeaderGroups.length; i++) {
 		const headers = leftHeaderGroups[i].headers;
@@ -338,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 = require_utils.callMemoOrStaticFn(table, "getRightHeaderGroups", table_getRightHeaderGroups);
+function table_getEndFlatHeaders(table) {
+	const rightHeaderGroups = require_utils.callMemoOrStaticFn(table, "getEndHeaderGroups", table_getEndHeaderGroups);
 	const result = [];
 	for (let i = 0; i < rightHeaderGroups.length; i++) {
 		const headers = rightHeaderGroups[i].headers;
@@ -376,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 require_utils.callMemoOrStaticFn(table, "getLeftFlatHeaders", table_getLeftFlatHeaders).filter((header) => !header.subHeaders.length);
+function table_getStartLeafHeaders(table) {
+	return require_utils.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 require_utils.callMemoOrStaticFn(table, "getRightFlatHeaders", table_getRightFlatHeaders).filter((header) => !header.subHeaders.length);
+function table_getEndLeafHeaders(table) {
+	return require_utils.callMemoOrStaticFn(table, "getEndFlatHeaders", table_getEndFlatHeaders).filter((header) => !header.subHeaders.length);
 }
 /**
 * Collects leaf headers for the center, unpinned region.
@@ -415,51 +423,51 @@ function table_getCenterLeafHeaders(table) {
 	return require_utils.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) {
-	const { left } = table.atoms.columnPinning?.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) {
-	const { right } = table.atoms.columnPinning?.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
@@ -467,15 +475,15 @@ function table_getRightLeafColumns(table) {
 * ```
 */
 function table_getCenterLeafColumns(table) {
-	const { left, right } = table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState();
-	if (!left.length && !right.length) return table.getAllLeafColumns();
-	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
@@ -484,33 +492,33 @@ function table_getCenterLeafColumns(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);
+	return !position ? table.getAllLeafColumns() : position === "start" ? require_utils.callMemoOrStaticFn(table, "getStartLeafColumns", table_getStartLeafColumns) : position === "end" ? require_utils.callMemoOrStaticFn(table, "getEndLeafColumns", table_getEndLeafColumns) : require_utils.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 require_utils.callMemoOrStaticFn(table, "getLeftLeafColumns", table_getLeftLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
+function table_getStartVisibleLeafColumns(table) {
+	return require_utils.callMemoOrStaticFn(table, "getStartLeafColumns", table_getStartLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.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 require_utils.callMemoOrStaticFn(table, "getRightLeafColumns", table_getRightLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
+function table_getEndVisibleLeafColumns(table) {
+	return require_utils.callMemoOrStaticFn(table, "getEndLeafColumns", table_getEndLeafColumns).filter((column) => require_utils.callMemoOrStaticFn(column, "getIsVisible", require_columnVisibilityFeature_utils.column_getIsVisible));
 }
 /**
 * Resolves visible leaf columns that are not pinned.
@@ -529,16 +537,16 @@ 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 ? 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);
+	return !position ? require_utils.callMemoOrStaticFn(table, "getVisibleLeafColumns", require_columnVisibilityFeature_utils.table_getVisibleLeafColumns) : position === "start" ? require_utils.callMemoOrStaticFn(table, "getStartVisibleLeafColumns", table_getStartVisibleLeafColumns) : position === "end" ? require_utils.callMemoOrStaticFn(table, "getEndVisibleLeafColumns", table_getEndVisibleLeafColumns) : require_utils.callMemoOrStaticFn(table, "getCenterVisibleLeafColumns", table_getCenterVisibleLeafColumns);
 }
 
 //#endregion
@@ -548,29 +556,29 @@ exports.column_getPinnedIndex = column_getPinnedIndex;
 exports.column_pin = column_pin;
 exports.getDefaultColumnPinningState = getDefaultColumnPinningState;
 exports.row_getCenterVisibleCells = row_getCenterVisibleCells;
-exports.row_getLeftVisibleCells = row_getLeftVisibleCells;
-exports.row_getRightVisibleCells = row_getRightVisibleCells;
+exports.row_getEndVisibleCells = row_getEndVisibleCells;
+exports.row_getStartVisibleCells = row_getStartVisibleCells;
 exports.table_getCenterFlatHeaders = table_getCenterFlatHeaders;
 exports.table_getCenterFooterGroups = table_getCenterFooterGroups;
 exports.table_getCenterHeaderGroups = table_getCenterHeaderGroups;
 exports.table_getCenterLeafColumns = table_getCenterLeafColumns;
 exports.table_getCenterLeafHeaders = table_getCenterLeafHeaders;
 exports.table_getCenterVisibleLeafColumns = table_getCenterVisibleLeafColumns;
+exports.table_getEndFlatHeaders = table_getEndFlatHeaders;
+exports.table_getEndFooterGroups = table_getEndFooterGroups;
+exports.table_getEndHeaderGroups = table_getEndHeaderGroups;
+exports.table_getEndLeafColumns = table_getEndLeafColumns;
+exports.table_getEndLeafHeaders = table_getEndLeafHeaders;
+exports.table_getEndVisibleLeafColumns = table_getEndVisibleLeafColumns;
 exports.table_getIsSomeColumnsPinned = table_getIsSomeColumnsPinned;
-exports.table_getLeftFlatHeaders = table_getLeftFlatHeaders;
-exports.table_getLeftFooterGroups = table_getLeftFooterGroups;
-exports.table_getLeftHeaderGroups = table_getLeftHeaderGroups;
-exports.table_getLeftLeafColumns = table_getLeftLeafColumns;
-exports.table_getLeftLeafHeaders = table_getLeftLeafHeaders;
-exports.table_getLeftVisibleLeafColumns = table_getLeftVisibleLeafColumns;
 exports.table_getPinnedLeafColumns = table_getPinnedLeafColumns;
 exports.table_getPinnedVisibleLeafColumns = table_getPinnedVisibleLeafColumns;
-exports.table_getRightFlatHeaders = table_getRightFlatHeaders;
-exports.table_getRightFooterGroups = table_getRightFooterGroups;
-exports.table_getRightHeaderGroups = table_getRightHeaderGroups;
-exports.table_getRightLeafColumns = table_getRightLeafColumns;
-exports.table_getRightLeafHeaders = table_getRightLeafHeaders;
-exports.table_getRightVisibleLeafColumns = table_getRightVisibleLeafColumns;
+exports.table_getStartFlatHeaders = table_getStartFlatHeaders;
+exports.table_getStartFooterGroups = table_getStartFooterGroups;
+exports.table_getStartHeaderGroups = table_getStartHeaderGroups;
+exports.table_getStartLeafColumns = table_getStartLeafColumns;
+exports.table_getStartLeafHeaders = table_getStartLeafHeaders;
+exports.table_getStartVisibleLeafColumns = table_getStartVisibleLeafColumns;
 exports.table_resetColumnPinning = table_resetColumnPinning;
 exports.table_setColumnPinning = table_setColumnPinning;
 //# sourceMappingURL=columnPinningFeature.utils.cjs.map