@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.2

package/dist/features/column-pinning/columnPinningFeature.utils.d.cts

@@ -0,0 +1,375 @@
+import { CellData, RowData, Updater } from "../../types/type-utils.cjs";
+import { HeaderGroup } from "../../types/HeaderGroup.cjs";
+import { Header } from "../../types/Header.cjs";
+import { ColumnPinningPosition, ColumnPinningState } from "./columnPinningFeature.types.cjs";
+import { Column, Column_Internal } from "../../types/Column.cjs";
+import { Row } from "../../types/Row.cjs";
+import { TableFeatures } from "../../types/TableFeatures.cjs";
+import { Table_Internal } from "../../types/Table.cjs";
+import { Cell } from "../../types/Cell.cjs";
+//#region src/features/column-pinning/columnPinningFeature.utils.d.ts
+/**
+ * Creates the default column pinning state.
+ *
+ * Both pinning regions start empty. Reset APIs use this value when
+ * `defaultState` is `true`.
+ *
+ * @example
+ * ```ts
+ * const pinning = getDefaultColumnPinningState()
+ * ```
+ */
+declare function getDefaultColumnPinningState(): ColumnPinningState;
+/**
+ * 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'`
+ * region. Passing `false` unpins them back to the center.
+ *
+ * @example
+ * ```ts
+ * column_pin(column, 'left')
+ * ```
+ */
+declare function column_pin<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>, position: ColumnPinningPosition): void;
+/**
+ * Checks whether this column or any of its leaf columns can be pinned.
+ *
+ * Column-level `enablePinning` and table `enableColumnPinning` both default to
+ * `true`; at least one leaf column must allow pinning.
+ *
+ * @example
+ * ```ts
+ * const canPin = column_getCanPin(column)
+ * ```
+ */
+declare function column_getCanPin<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): boolean;
+/**
+ * Reads this column's current pinning region.
+ *
+ * Group columns report `'left'` or `'right'` when any leaf column is pinned in
+ * that region. Unpinned columns return `false`.
+ *
+ * @example
+ * ```ts
+ * const position = column_getIsPinned(column)
+ * ```
+ */
+declare function column_getIsPinned<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): ColumnPinningPosition | 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`.
+ *
+ * @example
+ * ```ts
+ * const index = column_getPinnedIndex(column)
+ * ```
+ */
+declare function column_getPinnedIndex<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData>(column: Column_Internal<TFeatures, TData, TValue>): number;
+/**
+ * Collects visible cells whose columns are not pinned left or right.
+ *
+ * The result preserves the row's visible-cell order for center columns.
+ *
+ * @example
+ * ```ts
+ * const centerCells = row_getCenterVisibleCells(row)
+ * ```
+ */
+declare function row_getCenterVisibleCells<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): any[];
+/**
+ * Collects visible cells for columns pinned to the left region.
+ *
+ * Cells are returned in `state.columnPinning.left` order and are marked with
+ * `cell.position = 'left'`.
+ *
+ * @example
+ * ```ts
+ * const leftCells = row_getLeftVisibleCells(row)
+ * ```
+ */
+declare function row_getLeftVisibleCells<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>>;
+/**
+ * Collects visible cells for columns pinned to the right region.
+ *
+ * Cells are returned in `state.columnPinning.right` order and are marked with
+ * `cell.position = 'right'`.
+ *
+ * @example
+ * ```ts
+ * const rightCells = row_getRightVisibleCells(row)
+ * ```
+ */
+declare function row_getRightVisibleCells<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>): Cell<TFeatures, TData, unknown>[];
+/**
+ * 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
+ * previous state, matching the instance `table.setColumnPinning` behavior.
+ *
+ * @example
+ * ```ts
+ * table_setColumnPinning(table, (old) => ({ ...old, left: ['select'] }))
+ * ```
+ */
+declare function table_setColumnPinning<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, updater: Updater<ColumnPinningState>): void;
+/**
+ * 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
+ * arrays.
+ *
+ * @example
+ * ```ts
+ * table_resetColumnPinning(table)
+ * table_resetColumnPinning(table, true)
+ * ```
+ */
+declare function table_resetColumnPinning<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, defaultState?: boolean): void;
+/**
+ * Checks whether any columns are pinned.
+ *
+ * Omit `position` to check both sides, or pass `'left'`/`'right'` to inspect a
+ * single pinning region.
+ *
+ * @example
+ * ```ts
+ * const hasPinnedColumns = table_getIsSomeColumnsPinned(table)
+ * ```
+ */
+declare function table_getIsSomeColumnsPinned<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, position?: ColumnPinningPosition): boolean;
+/**
+ * Builds header groups for visible columns pinned to the left region.
+ *
+ * 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 headerGroups = table_getLeftHeaderGroups(table)
+ * ```
+ */
+declare function table_getLeftHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Builds header groups for visible columns pinned to the right region.
+ *
+ * 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 headerGroups = table_getRightHeaderGroups(table)
+ * ```
+ */
+declare function table_getRightHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): HeaderGroup<TFeatures, TData>[];
+/**
+ * Builds header groups for visible columns that are not pinned.
+ *
+ * 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 headerGroups = table_getCenterHeaderGroups(table)
+ * ```
+ */
+declare function table_getCenterHeaderGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Array<HeaderGroup<TFeatures, TData>>;
+/**
+ * Builds footer groups for the left pinned region.
+ *
+ * Footer groups reuse the left header groups in reverse order.
+ *
+ * @example
+ * ```ts
+ * const footerGroups = table_getLeftFooterGroups(table)
+ * ```
+ */
+declare function table_getLeftFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Builds footer groups for the right pinned region.
+ *
+ * Footer groups reuse the right header groups in reverse order.
+ *
+ * @example
+ * ```ts
+ * const footerGroups = table_getRightFooterGroups(table)
+ * ```
+ */
+declare function table_getRightFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Builds footer groups for the center, unpinned region.
+ *
+ * Footer groups reuse the center header groups in reverse order.
+ *
+ * @example
+ * ```ts
+ * const footerGroups = table_getCenterFooterGroups(table)
+ * ```
+ */
+declare function table_getCenterFooterGroups<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Flattens every header from the left pinned header groups.
+ *
+ * Parent headers and placeholder headers are included.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getLeftFlatHeaders(table)
+ * ```
+ */
+declare function table_getLeftFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+/**
+ * Flattens every header from the right pinned header groups.
+ *
+ * Parent headers and placeholder headers are included.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getRightFlatHeaders(table)
+ * ```
+ */
+declare function table_getRightFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+/**
+ * Flattens every header from the center header groups.
+ *
+ * Parent headers and placeholder headers are included.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getCenterFlatHeaders(table)
+ * ```
+ */
+declare function table_getCenterFlatHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Header<TFeatures, TData, unknown>[];
+/**
+ * Collects leaf headers for the left pinned region.
+ *
+ * Parent headers are filtered out from the left flat header list.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getLeftLeafHeaders(table)
+ * ```
+ */
+declare function table_getLeftLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Collects leaf headers for the right pinned region.
+ *
+ * Parent headers are filtered out from the right flat header list.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getRightLeafHeaders(table)
+ * ```
+ */
+declare function table_getRightLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Collects leaf headers for the center, unpinned region.
+ *
+ * Parent headers are filtered out from the center flat header list.
+ *
+ * @example
+ * ```ts
+ * const headers = table_getCenterLeafHeaders(table)
+ * ```
+ */
+declare function table_getCenterLeafHeaders<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Resolves leaf columns pinned to the left region.
+ *
+ * The result follows `state.columnPinning.left` order and skips stale ids that
+ * no longer correspond to a leaf column.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getLeftLeafColumns(table)
+ * ```
+ */
+declare function table_getLeftLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column_Internal<TFeatures, TData, unknown>[];
+/**
+ * Resolves leaf columns pinned to the right region.
+ *
+ * The result follows `state.columnPinning.right` order and skips stale ids that
+ * no longer correspond to a leaf column.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getRightLeafColumns(table)
+ * ```
+ */
+declare function table_getRightLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column_Internal<TFeatures, TData, unknown>[];
+/**
+ * Resolves leaf columns that are not pinned to either side.
+ *
+ * Left- and right-pinned ids are removed from `table.getAllLeafColumns()`.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getCenterLeafColumns(table)
+ * ```
+ */
+declare function table_getCenterLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): Column<TFeatures, TData, unknown>[];
+/**
+ * Resolves leaf columns for a requested pinning region.
+ *
+ * Pass `'left'`, `'center'`, or `'right'` for a partition, or pass `false` to
+ * read all leaf columns without partitioning.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getPinnedLeafColumns(table, 'center')
+ * ```
+ */
+declare function table_getPinnedLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, position: ColumnPinningPosition | 'center'): any[];
+/**
+ * Resolves visible leaf columns pinned to the left region.
+ *
+ * Hidden pinned columns are filtered out after the left pin order is applied.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getLeftVisibleLeafColumns(table)
+ * ```
+ */
+declare function table_getLeftVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Resolves visible leaf columns pinned to the right region.
+ *
+ * Hidden pinned columns are filtered out after the right pin order is applied.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getRightVisibleLeafColumns(table)
+ * ```
+ */
+declare function table_getRightVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * Resolves visible leaf columns that are not pinned.
+ *
+ * This is the center partition used by layouts that render pinned columns
+ * separately from the scrollable middle region.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getCenterVisibleLeafColumns(table)
+ * ```
+ */
+declare function table_getCenterVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>): any[];
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * const columns = table_getPinnedVisibleLeafColumns(table, 'left')
+ * ```
+ */
+declare function table_getPinnedVisibleLeafColumns<TFeatures extends TableFeatures, TData extends RowData>(table: Table_Internal<TFeatures, TData>, position?: ColumnPinningPosition | 'center'): any[];
+//#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.d.cts.map