@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

package/src/features/column-ordering/columnOrderingFeature.utils.ts

@@ -1,292 +0,0 @@
-import { table_getPinnedVisibleLeafColumns } from '../column-pinning/columnPinningFeature.utils'
-import { callMemoOrStaticFn, cloneState, makeObjectMap } from '../../utils'
-import type { GroupingState } from '../column-grouping/columnGroupingFeature.types'
-import type { CellData, RowData, Updater } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Table_Internal } from '../../types/Table'
-import type { Column, Column_Internal } from '../../types/Column'
-import type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'
-import type {
-  ColumnIndexes,
-  ColumnOrderState,
-} from './columnOrderingFeature.types'
-
-/**
- * Creates the default column order state.
- *
- * The feature default is an empty array, meaning leaf columns keep their natural
- * definition order. Reset APIs use this value when `defaultState` is `true`.
- *
- * @example
- * ```ts
- * const order = getDefaultColumnOrderState()
- * ```
- */
-export function getDefaultColumnOrderState(): ColumnOrderState {
-  return []
-}
-
-/**
- * Builds column-id to index records for each visible pinning region.
- *
- * All four regions are built in one pass so a single memo entry serves every
- * `column_getIndex` lookup without per-column scans.
- *
- * @example
- * ```ts
- * const indexes = table_getColumnIndexes(table)
- * ```
- */
-export function table_getColumnIndexes<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): ColumnIndexes {
-  const buildIndexes = (
-    columns: ReadonlyArray<
-      | Column<TFeatures, TData, unknown>
-      | Column_Internal<TFeatures, TData, unknown>
-    >,
-  ): Record<string, number> => {
-    const indexes = makeObjectMap<number>()
-    for (let i = 0; i < columns.length; i++) {
-      indexes[columns[i]!.id] = i
-    }
-    return indexes
-  }
-
-  return {
-    all: buildIndexes(table_getPinnedVisibleLeafColumns(table)),
-    center: buildIndexes(table_getPinnedVisibleLeafColumns(table, 'center')),
-    start: buildIndexes(table_getPinnedVisibleLeafColumns(table, 'start')),
-    end: buildIndexes(table_getPinnedVisibleLeafColumns(table, 'end')),
-  }
-}
-
-/**
- * Finds this column's index within a visible pinning region.
- *
- * Pass `'start'`, `'center'`, or `'end'` to search that region; omit the
- * position to search the full visible leaf column list.
- *
- * @example
- * ```ts
- * const index = column_getIndex(column, 'center')
- * ```
- */
-export function column_getIndex<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(
-  column: Column_Internal<TFeatures, TData, TValue>,
-  position?: ColumnPinningPosition | 'center',
-) {
-  const indexes = callMemoOrStaticFn(
-    column.table,
-    'getColumnIndexes',
-    table_getColumnIndexes,
-  )
-  const key =
-    position === 'start'
-      ? 'start'
-      : position === 'end'
-        ? 'end'
-        : position === 'center'
-          ? 'center'
-          : 'all'
-  return indexes[key][column.id] ?? -1
-}
-
-/**
- * Checks whether this column is the first visible column in a pinning region.
- *
- * The same `position` semantics as `column_getIndex` apply.
- *
- * @example
- * ```ts
- * const isFirst = column_getIsFirstColumn(column, 'start')
- * ```
- */
-export function column_getIsFirstColumn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(
-  column: Column_Internal<TFeatures, TData, TValue>,
-  position?: ColumnPinningPosition | 'center',
-) {
-  const columns = table_getPinnedVisibleLeafColumns(column.table, position)
-  return columns[0]?.id === column.id
-}
-
-/**
- * Checks whether this column is the last visible column in a pinning region.
- *
- * The same `position` semantics as `column_getIndex` apply.
- *
- * @example
- * ```ts
- * const isLast = column_getIsLastColumn(column, 'end')
- * ```
- */
-export function column_getIsLastColumn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue extends CellData = CellData,
->(
-  column: Column_Internal<TFeatures, TData, TValue>,
-  position?: ColumnPinningPosition | 'center',
-) {
-  const columns = table_getPinnedVisibleLeafColumns(column.table, position)
-  return columns[columns.length - 1]?.id === column.id
-}
-
-/**
- * Routes a column order updater through the table's column-order change handler.
- *
- * The updater may be a next ordered id array or a function of the previous
- * array, matching the instance `table.setColumnOrder` behavior.
- *
- * @example
- * ```ts
- * table_setColumnOrder(table, ['firstName', 'lastName', 'age'])
- * ```
- */
-export function table_setColumnOrder<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>, updater: Updater<ColumnOrderState>) {
-  table.options.onColumnOrderChange?.(updater)
-}
-
-/**
- * Resets `columnOrder` to the configured initial state or feature default.
- *
- * With no argument, the reset clones `table.initialState.columnOrder` when it
- * exists. Passing `true` ignores initial state and resets to `[]`.
- *
- * @example
- * ```ts
- * table_resetColumnOrder(table)
- * table_resetColumnOrder(table, true)
- * ```
- */
-export function table_resetColumnOrder<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
-  table_setColumnOrder(
-    table,
-    defaultState ? [] : cloneState(table.initialState.columnOrder ?? []),
-  )
-}
-
-/**
- * Creates the ordering function used to arrange leaf columns.
- *
- * The returned function applies `state.columnOrder`, preserves unspecified
- * columns in their original order, then delegates to grouping rules.
- *
- * @example
- * ```ts
- * const orderColumnsForTable = table_getOrderColumnsFn(table)
- * ```
- */
-export function table_getOrderColumnsFn<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>) {
-  const columnOrder = table.atoms.columnOrder?.get()
-
-  return (columns: Array<Column_Internal<TFeatures, TData, unknown>>) => {
-    // Sort grouped columns to the start of the column list
-    // before the headers are built
-    let orderedColumns: Array<Column_Internal<TFeatures, TData, unknown>> = []
-
-    // If there is no order, return the normal columns
-    if (!columnOrder?.length) {
-      orderedColumns = columns
-    } else {
-      // Index columns by id for O(1) lookup
-      const remaining = new Map<
-        string,
-        Column_Internal<TFeatures, TData, unknown>
-      >()
-      for (let i = 0; i < columns.length; i++) {
-        const column = columns[i]!
-        remaining.set(column.id, column)
-      }
-
-      // Place columns in the requested order, removing each as it's used
-      // (handles duplicates and unknown ids in columnOrder)
-      for (let i = 0; i < columnOrder.length; i++) {
-        const id = columnOrder[i]!
-        const column = remaining.get(id)
-        if (column) {
-          orderedColumns.push(column)
-          remaining.delete(id)
-        }
-      }
-
-      // Append leftover columns in their original order
-      for (let i = 0; i < columns.length; i++) {
-        const column = columns[i]!
-        if (remaining.has(column.id)) orderedColumns.push(column)
-      }
-    }
-
-    return orderColumns(table, orderedColumns)
-  }
-}
-
-/**
- * Applies grouped-column placement rules to an already ordered leaf-column list.
- *
- * `groupedColumnMode: 'remove'` drops grouped columns from the list.
- * `groupedColumnMode: 'reorder'` moves grouped columns to the front in grouping
- * state order.
- *
- * @example
- * ```ts
- * const orderedColumns = orderColumns(table, leafColumns)
- * ```
- */
-export function orderColumns<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  table: Table_Internal<TFeatures, TData>,
-  leafColumns: Array<Column_Internal<TFeatures, TData, unknown>>,
-) {
-  const grouping = table.atoms.grouping?.get() ?? ([] as GroupingState)
-  const { groupedColumnMode } = table.options
-
-  if (!grouping.length || !groupedColumnMode) {
-    return leafColumns
-  }
-
-  const nonGroupingColumns = leafColumns.filter(
-    (col) => !grouping.includes(col.id),
-  )
-
-  if (groupedColumnMode === 'remove') {
-    return nonGroupingColumns
-  }
-
-  const leafColumnsById = new Map<
-    string,
-    Column_Internal<TFeatures, TData, unknown>
-  >()
-  for (let i = 0; i < leafColumns.length; i++) {
-    const col = leafColumns[i]!
-    leafColumnsById.set(col.id, col)
-  }
-
-  const groupingColumns: Array<Column_Internal<TFeatures, TData, unknown>> = []
-  for (let i = 0; i < grouping.length; i++) {
-    const col = leafColumnsById.get(grouping[i]!)
-    if (col) groupingColumns.push(col)
-  }
-
-  return [...groupingColumns, ...nonGroupingColumns]
-}

package/src/features/column-pinning/columnPinningFeature.ts

@@ -1,333 +0,0 @@
-import {
-  assignPrototypeAPIs,
-  assignTableAPIs,
-  callMemoOrStaticFn,
-  makeStateUpdater,
-} from '../../utils'
-import { table_getVisibleLeafColumns } from '../column-visibility/columnVisibilityFeature.utils'
-import {
-  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,
-} from './columnPinningFeature.utils'
-import type { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Feature that adds column pinning state and APIs for logical start, center,
- * and end regions.
- *
- * 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.
- */
-export const columnPinningFeature: TableFeature = {
-  getInitialState: (initialState) => {
-    return {
-      columnPinning: {
-        ...getDefaultColumnPinningState(),
-        ...initialState.columnPinning,
-      },
-      ...initialState,
-    }
-  },
-
-  getDefaultTableOptions: (table) => {
-    return {
-      onColumnPinningChange: makeStateUpdater('columnPinning', table),
-    }
-  },
-
-  assignColumnPrototype: (prototype, table) => {
-    assignPrototypeAPIs('columnPinningFeature', prototype, table, {
-      column_pin: {
-        fn: (column, position) => column_pin(column, position),
-      },
-      column_getCanPin: {
-        fn: (column) => column_getCanPin(column),
-      },
-      column_getPinnedIndex: {
-        fn: (column) => column_getPinnedIndex(column),
-      },
-      column_getIsPinned: {
-        fn: (column) => column_getIsPinned(column),
-      },
-    })
-  },
-
-  assignRowPrototype: (prototype, table) => {
-    assignPrototypeAPIs('columnPinningFeature', prototype, table, {
-      row_getCenterVisibleCells: {
-        fn: (row) => row_getCenterVisibleCells(row),
-        memoDeps: (row) => [
-          row.getAllCells(),
-          row.table.atoms.columnPinning?.get(),
-          row.table.atoms.columnVisibility?.get(),
-        ],
-      },
-      row_getStartVisibleCells: {
-        fn: (row) => row_getStartVisibleCells(row),
-        memoDeps: (row) => [
-          row.getAllCells(),
-          row.table.atoms.columnPinning?.get()?.start,
-          row.table.atoms.columnVisibility?.get(),
-        ],
-      },
-      row_getEndVisibleCells: {
-        fn: (row) => row_getEndVisibleCells(row),
-        memoDeps: (row) => [
-          row.getAllCells(),
-          row.table.atoms.columnPinning?.get()?.end,
-          row.table.atoms.columnVisibility?.get(),
-        ],
-      },
-    })
-  },
-
-  constructTableAPIs: (table) => {
-    assignTableAPIs('columnPinningFeature', table, {
-      table_setColumnPinning: {
-        fn: (updater) => table_setColumnPinning(table, updater),
-      },
-      table_resetColumnPinning: {
-        fn: (defaultState) => table_resetColumnPinning(table, defaultState),
-      },
-      table_getIsSomeColumnsPinned: {
-        fn: (position) => table_getIsSomeColumnsPinned(table, position),
-      },
-      // header groups
-      table_getStartHeaderGroups: {
-        fn: () => table_getStartHeaderGroups(table),
-        memoDeps: () => [
-          table.getAllColumns(),
-          callMemoOrStaticFn(
-            table,
-            'getVisibleLeafColumns',
-            table_getVisibleLeafColumns,
-          ),
-          table.atoms.columnPinning?.get()?.start,
-          table.atoms.columnOrder?.get(),
-        ],
-      },
-      table_getCenterHeaderGroups: {
-        fn: () => table_getCenterHeaderGroups(table),
-        memoDeps: () => [
-          table.getAllColumns(),
-          callMemoOrStaticFn(
-            table,
-            'getVisibleLeafColumns',
-            table_getVisibleLeafColumns,
-          ),
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnOrder?.get(),
-        ],
-      },
-      table_getEndHeaderGroups: {
-        fn: () => table_getEndHeaderGroups(table),
-        memoDeps: () => [
-          table.getAllColumns(),
-          callMemoOrStaticFn(
-            table,
-            'getVisibleLeafColumns',
-            table_getVisibleLeafColumns,
-          ),
-          table.atoms.columnPinning?.get()?.end,
-          table.atoms.columnOrder?.get(),
-        ],
-      },
-      // footer groups
-      table_getStartFooterGroups: {
-        fn: () => table_getStartFooterGroups(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getStartHeaderGroups',
-            table_getStartHeaderGroups,
-          ),
-        ],
-      },
-      table_getCenterFooterGroups: {
-        fn: () => table_getCenterFooterGroups(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getCenterHeaderGroups',
-            table_getCenterHeaderGroups,
-          ),
-        ],
-      },
-      table_getEndFooterGroups: {
-        fn: () => table_getEndFooterGroups(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getEndHeaderGroups',
-            table_getEndHeaderGroups,
-          ),
-        ],
-      },
-      // flat headers
-      table_getStartFlatHeaders: {
-        fn: () => table_getStartFlatHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getStartHeaderGroups',
-            table_getStartHeaderGroups,
-          ),
-        ],
-      },
-      table_getEndFlatHeaders: {
-        fn: () => table_getEndFlatHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getEndHeaderGroups',
-            table_getEndHeaderGroups,
-          ),
-        ],
-      },
-      table_getCenterFlatHeaders: {
-        fn: () => table_getCenterFlatHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getCenterHeaderGroups',
-            table_getCenterHeaderGroups,
-          ),
-        ],
-      },
-      // leaf headers
-      table_getStartLeafHeaders: {
-        fn: () => table_getStartLeafHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getStartHeaderGroups',
-            table_getStartHeaderGroups,
-          ),
-        ],
-      },
-      table_getEndLeafHeaders: {
-        fn: () => table_getEndLeafHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getEndHeaderGroups',
-            table_getEndHeaderGroups,
-          ),
-        ],
-      },
-      table_getCenterLeafHeaders: {
-        fn: () => table_getCenterLeafHeaders(table),
-        memoDeps: () => [
-          callMemoOrStaticFn(
-            table,
-            'getCenterHeaderGroups',
-            table_getCenterHeaderGroups,
-          ),
-        ],
-      },
-      // leaf columns
-      table_getStartLeafColumns: {
-        fn: () => table_getStartLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getEndLeafColumns: {
-        fn: () => table_getEndLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getCenterLeafColumns: {
-        fn: () => table_getCenterLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getPinnedLeafColumns: {
-        fn: (position) => table_getPinnedLeafColumns(table, position),
-        // must not memo here as it's just a shortcut function
-      },
-      // visible leaf columns
-      table_getStartVisibleLeafColumns: {
-        fn: () => table_getStartVisibleLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnVisibility?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getCenterVisibleLeafColumns: {
-        fn: () => table_getCenterVisibleLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnVisibility?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getEndVisibleLeafColumns: {
-        fn: () => table_getEndVisibleLeafColumns(table),
-        memoDeps: () => [
-          table.options.columns,
-          table.atoms.columnPinning?.get(),
-          table.atoms.columnVisibility?.get(),
-          table.atoms.columnOrder?.get(),
-          table.atoms.grouping?.get(),
-          table.options.groupedColumnMode,
-        ],
-      },
-      table_getPinnedVisibleLeafColumns: {
-        fn: (position) => table_getPinnedVisibleLeafColumns(table, position),
-        // must not memo here as it's just a shortcut function
-      },
-    })
-  },
-}