@tanstack/table-core 9.0.0-beta.5 → 9.0.0-beta.51

package/src/features/column-sizing/columnSizingFeature.utils.ts

@@ -1,18 +1,26 @@
 import {
   table_getCenterHeaderGroups,
-  table_getLeftHeaderGroups,
+  table_getEndHeaderGroups,
   table_getPinnedVisibleLeafColumns,
-  table_getRightHeaderGroups,
+  table_getStartHeaderGroups,
 } from '../column-pinning/columnPinningFeature.utils'
-import { column_getIndex } from '../column-ordering/columnOrderingFeature.utils'
-import { callMemoOrStaticFn, cloneState } from '../../utils'
+import {
+  callMemoOrStaticFn,
+  cloneState,
+  hasOwn,
+  makeObjectMap,
+} from '../../utils'
 import type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.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 { Header } from '../../types/Header'
 import type { Column_Internal } from '../../types/Column'
-import type { ColumnSizingState } from './columnSizingFeature.types'
+import type {
+  ColumnOffsets,
+  ColumnOffsetsByPosition,
+  ColumnSizingState,
+} from './columnSizingFeature.types'
 
 /**
  * Creates the default committed column sizing state.
@@ -26,7 +34,7 @@ import type { ColumnSizingState } from './columnSizingFeature.types'
  * ```
  */
 export function getDefaultColumnSizingState(): ColumnSizingState {
-  return {}
+  return makeObjectMap()
 }
 
 /**
@@ -66,7 +74,11 @@ export function column_getSize<
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>): number {
   const defaultSizes = getDefaultColumnSizingColumnDef()
-  const columnSize = column.table.atoms.columnSizing?.get()?.[column.id]
+  const columnSizing = column.table.atoms.columnSizing?.get()
+  const columnSize =
+    columnSizing && hasOwn(columnSizing, column.id)
+      ? columnSizing[column.id]
+      : undefined
 
   return Math.min(
     Math.max(
@@ -77,15 +89,98 @@ export function column_getSize<
   )
 }
 
+function buildColumnOffsets<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(columns: Array<Column_Internal<TFeatures, TData, unknown>>): ColumnOffsets {
+  const starts = makeObjectMap<number>()
+  const afters = makeObjectMap<number>()
+  const sizes = new Array<number>(columns.length)
+
+  let start = 0
+  for (let i = 0; i < columns.length; i++) {
+    const column = columns[i]!
+    const size = callMemoOrStaticFn(column, 'getSize', column_getSize)
+    sizes[i] = size
+    starts[column.id] = start
+    start += size
+  }
+
+  let after = 0
+  for (let i = columns.length - 1; i >= 0; i--) {
+    afters[columns[i]!.id] = after
+    after += sizes[i]!
+  }
+
+  return { starts, afters }
+}
+
+/**
+ * Builds start and after offset maps for every visible leaf column, computed
+ * once per pinning region plus the full visible list.
+ *
+ * A single table-level memo of this result backs all `column.getStart()` and
+ * `column.getAfter()` calls with O(1) lookups.
+ *
+ * @example
+ * ```ts
+ * const offsets = table_getColumnOffsets(table)
+ * const startOffset = offsets.start.starts[column.id]
+ * ```
+ */
+export function table_getColumnOffsets<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): ColumnOffsetsByPosition {
+  return {
+    all: buildColumnOffsets(
+      table_getPinnedVisibleLeafColumns(table) as Array<
+        Column_Internal<TFeatures, TData, unknown>
+      >,
+    ),
+    center: buildColumnOffsets(
+      table_getPinnedVisibleLeafColumns(table, 'center') as Array<
+        Column_Internal<TFeatures, TData, unknown>
+      >,
+    ),
+    start: buildColumnOffsets(
+      table_getPinnedVisibleLeafColumns(table, 'start') as Array<
+        Column_Internal<TFeatures, TData, unknown>
+      >,
+    ),
+    end: buildColumnOffsets(
+      table_getPinnedVisibleLeafColumns(table, 'end') as Array<
+        Column_Internal<TFeatures, TData, unknown>
+      >,
+    ),
+  }
+}
+
+function toOffsetsKey(
+  position: ColumnPinningPosition | 'center' | undefined,
+): keyof ColumnOffsetsByPosition {
+  return position === 'start'
+    ? 'start'
+    : position === 'end'
+      ? 'end'
+      : position === 'center'
+        ? 'center'
+        : 'all' // undefined | false use the full visible list
+}
+
 /**
  * Computes the offset from the start edge of a pinning region to this column.
  *
  * The value is the sum of all previous visible leaf column sizes in the
- * requested `'left'`, `'center'`, or `'right'` region.
+ * requested `'start'`, `'center'`, or `'end'` region.
+ *
+ * `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 leftOffset = column_getStart(column, 'left')
+ * const startOffset = column_getStart(column, 'start')
  * ```
  */
 export function column_getStart<
@@ -94,28 +189,14 @@ export function column_getStart<
   TValue extends CellData = CellData,
 >(
   column: Column_Internal<TFeatures, TData, TValue>,
-  position: ColumnPinningPosition | 'center',
+  position?: ColumnPinningPosition | 'center',
 ): number {
-  const index = callMemoOrStaticFn(
-    column,
-    'getIndex',
-    column_getIndex,
-    position,
-  )
-  if (index <= 0) return 0
-
-  const visibleLeafColumns = callMemoOrStaticFn(
+  const offsets = callMemoOrStaticFn(
     column.table,
-    'getPinnedVisibleLeafColumns',
-    table_getPinnedVisibleLeafColumns,
-    position,
-  )
-
-  const prevColumn = visibleLeafColumns[index - 1]!
-  return (
-    callMemoOrStaticFn(prevColumn, 'getStart', column_getStart, position) +
-    callMemoOrStaticFn(prevColumn, 'getSize', column_getSize)
+    'getColumnOffsets',
+    table_getColumnOffsets,
   )
+  return offsets[toOffsetsKey(position)].starts[column.id] ?? 0
 }
 
 /**
@@ -126,7 +207,7 @@ export function column_getStart<
  *
  * @example
  * ```ts
- * const rightOffset = column_getAfter(column, 'right')
+ * const endOffset = column_getAfter(column, 'end')
  * ```
  */
 export function column_getAfter<
@@ -135,27 +216,14 @@ export function column_getAfter<
   TValue extends CellData = CellData,
 >(
   column: Column_Internal<TFeatures, TData, TValue>,
-  position: ColumnPinningPosition | 'center',
+  position?: ColumnPinningPosition | 'center',
 ): number {
-  const visibleLeafColumns = callMemoOrStaticFn(
+  const offsets = callMemoOrStaticFn(
     column.table,
-    'getPinnedVisibleLeafColumns',
-    table_getPinnedVisibleLeafColumns,
-    position,
-  )
-  const index = callMemoOrStaticFn(
-    column,
-    'getIndex',
-    column_getIndex,
-    position,
-  )
-  if (index < 0 || index >= visibleLeafColumns.length - 1) return 0
-
-  const nextColumn = visibleLeafColumns[index + 1]!
-  return (
-    callMemoOrStaticFn(nextColumn, 'getSize', column_getSize) +
-    callMemoOrStaticFn(nextColumn, 'getAfter', column_getAfter, position)
+    'getColumnOffsets',
+    table_getColumnOffsets,
   )
+  return offsets[toOffsetsKey(position)].afters[column.id] ?? 0
 }
 
 /**
@@ -174,7 +242,15 @@ export function column_resetSize<
   TData extends RowData,
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>) {
-  table_setColumnSizing(column.table, ({ [column.id]: _, ...rest }) => {
+  table_setColumnSizing(column.table, (old) => {
+    const rest = makeObjectMap<number>()
+    const columnIds = Object.keys(old)
+    for (let i = 0; i < columnIds.length; i++) {
+      const columnId = columnIds[i]!
+      if (columnId !== column.id) {
+        rest[columnId] = old[columnId]!
+      }
+    }
     return rest
   })
 }
@@ -280,14 +356,19 @@ export function table_resetColumnSizing<
 >(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
   table_setColumnSizing(
     table,
-    defaultState ? {} : cloneState(table.initialState.columnSizing ?? {}),
+    defaultState
+      ? makeObjectMap()
+      : Object.assign(
+          makeObjectMap<number>(),
+          cloneState(table.initialState.columnSizing ?? {}),
+        ),
   )
 }
 
 /**
  * Sums the rendered size of the full table header row.
  *
- * This includes left, center, and right columns in the main header group.
+ * This includes start, center, and end columns in the main header group.
  *
  * @example
  * ```ts
@@ -306,24 +387,24 @@ export function table_getTotalSize<
 }
 
 /**
- * Sums the rendered size of the left pinned header region.
+ * Sums the rendered size of the logical start pinned header region.
  *
- * An empty left pinning region returns `0`.
+ * An empty start pinning region returns `0`.
  *
  * @example
  * ```ts
- * const width = table_getLeftTotalSize(table)
+ * const width = table_getStartTotalSize(table)
  * ```
  */
-export function table_getLeftTotalSize<
+export function table_getStartTotalSize<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
   return (
     callMemoOrStaticFn(
       table,
-      'getLeftHeaderGroups',
-      table_getLeftHeaderGroups,
+      'getStartHeaderGroups',
+      table_getStartHeaderGroups,
     )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {
       return sum + header_getSize(header)
     }, 0) ?? 0
@@ -356,24 +437,24 @@ export function table_getCenterTotalSize<
 }
 
 /**
- * Sums the rendered size of the right pinned header region.
+ * Sums the rendered size of the logical end pinned header region.
  *
- * An empty right pinning region returns `0`.
+ * An empty end pinning region returns `0`.
  *
  * @example
  * ```ts
- * const width = table_getRightTotalSize(table)
+ * const width = table_getEndTotalSize(table)
  * ```
  */
-export function table_getRightTotalSize<
+export function table_getEndTotalSize<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
   return (
     callMemoOrStaticFn(
       table,
-      'getRightHeaderGroups',
-      table_getRightHeaderGroups,
+      'getEndHeaderGroups',
+      table_getEndHeaderGroups,
     )[0]?.headers.reduce((sum: number, header: Header<TFeatures, TData>) => {
       return sum + header_getSize(header)
     }, 0) ?? 0

package/src/features/column-visibility/columnVisibilityFeature.ts

@@ -88,7 +88,9 @@ export const columnVisibilityFeature: TableFeature = {
         memoDeps: () => [
           table.atoms.columnVisibility?.get(),
           table.atoms.columnOrder?.get(),
+          table.atoms.grouping?.get(),
           table.options.columns,
+          table.options.groupedColumnMode,
         ],
       },
       table_getVisibleLeafColumns: {
@@ -96,7 +98,9 @@ export const columnVisibilityFeature: TableFeature = {
         memoDeps: () => [
           table.atoms.columnVisibility?.get(),
           table.atoms.columnOrder?.get(),
+          table.atoms.grouping?.get(),
           table.options.columns,
+          table.options.groupedColumnMode,
         ],
       },
       table_setColumnVisibility: {

package/src/features/column-visibility/columnVisibilityFeature.types.ts

@@ -28,8 +28,8 @@ export type VisibilityDefaultOptions = Pick<
 >
 
 export interface Table_ColumnVisibility<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Checks whether every leaf column is currently visible.
@@ -76,8 +76,8 @@ export interface ColumnDef_ColumnVisibility {
 }
 
 export interface Row_ColumnVisibility<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Gets this row's cells for currently visible columns.

package/src/features/column-visibility/columnVisibilityFeature.utils.ts

@@ -1,4 +1,9 @@
-import { callMemoOrStaticFn, cloneState } from '../../utils'
+import {
+  callMemoOrStaticFn,
+  cloneState,
+  hasOwn,
+  makeObjectMap,
+} from '../../utils'
 import { getDefaultColumnPinningState } from '../column-pinning/columnPinningFeature.utils'
 import type { CellData, RowData, Updater } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
@@ -20,14 +25,14 @@ import type { Row } from '../../types/Row'
  * ```
  */
 export function getDefaultColumnVisibilityState(): ColumnVisibilityState {
-  return {}
+  return makeObjectMap()
 }
 
 /**
  * Updates this column's visibility when hiding is allowed.
  *
  * Passing `visible` stores that value. Omitting it flips the column's current
- * visibility state. Columns that cannot hide are left unchanged.
+ * visibility state. Columns that cannot hide are start unchanged.
  *
  * @example
  * ```ts
@@ -40,12 +45,13 @@ export function column_toggleVisibility<
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>, visible?: boolean): void {
   if (column_getCanHide(column)) {
-    table_setColumnVisibility(column.table, (old) => ({
-      ...old,
-      [column.id]:
+    table_setColumnVisibility(column.table, (old) => {
+      const next = Object.assign(makeObjectMap<boolean>(), old)
+      next[column.id] =
         visible ??
-        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),
-    }))
+        !callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
+      return next
+    })
   }
 }
 
@@ -66,13 +72,20 @@ export function column_getIsVisible<
   TData extends RowData,
   TValue extends CellData = CellData,
 >(column: Column_Internal<TFeatures, TData, TValue>): boolean {
+  const columnVisibility = column.table.atoms.columnVisibility?.get()
+  if (!columnVisibility) return true
+
   const childColumns = column.columns
+  if (childColumns.length) {
+    return childColumns.some((childColumn) =>
+      callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),
+    )
+  }
+
   return (
-    (childColumns.length
-      ? childColumns.some((childColumn) =>
-          callMemoOrStaticFn(childColumn, 'getIsVisible', column_getIsVisible),
-        )
-      : column.table.atoms.columnVisibility?.get()?.[column.id]) ?? true
+    (hasOwn(columnVisibility, column.id)
+      ? columnVisibility[column.id]
+      : undefined) ?? true
   )
 }
 
@@ -124,8 +137,8 @@ export function column_getToggleVisibilityHandler<
 /**
  * Collects the cells from this row whose columns are visible.
  *
- * When column pinning is active, the result is ordered as left-pinned cells,
- * center cells, then right-pinned cells.
+ * When column pinning is active, the result is ordered as start-pinned cells,
+ * center cells, then end-pinned cells.
  *
  * @example
  * ```ts
@@ -145,9 +158,9 @@ export function row_getVisibleCells<
     }
   }
 
-  const { left, right } =
+  const { start, end } =
     row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
-  if (!left.length && !right.length) return visibleCells // no pinning, return early
+  if (!start.length && !end.length) return visibleCells // no pinning, return early
 
   const visibleCellsByColumnId = callMemoOrStaticFn(
     row,
@@ -155,16 +168,16 @@ export function row_getVisibleCells<
     row_getVisibleCellsByColumnId,
   )
 
-  const leftCells: Array<Cell<TFeatures, TData, unknown>> = []
-  for (let i = 0; i < left.length; i++) {
-    const cell = visibleCellsByColumnId[left[i]!]
-    if (cell) leftCells.push(cell)
+  const startCells: Array<Cell<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < start.length; i++) {
+    const cell = visibleCellsByColumnId[start[i]!]
+    if (cell) startCells.push(cell)
   }
 
-  const rightCells: Array<Cell<TFeatures, TData, unknown>> = []
-  for (let i = 0; i < right.length; i++) {
-    const cell = visibleCellsByColumnId[right[i]!]
-    if (cell) rightCells.push(cell)
+  const endCells: Array<Cell<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < end.length; i++) {
+    const cell = visibleCellsByColumnId[end[i]!]
+    if (cell) endCells.push(cell)
   }
 
   // Center cells: visible cells in natural column order, minus pinned ones.
@@ -172,10 +185,10 @@ export function row_getVisibleCells<
   for (let i = 0; i < visibleCells.length; i++) {
     const cell = visibleCells[i]!
     const id = cell.column.id
-    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)
+    if (!start.includes(id) && !end.includes(id)) centerCells.push(cell)
   }
 
-  return [...leftCells, ...centerCells, ...rightCells]
+  return [...startCells, ...centerCells, ...endCells]
 }
 
 /**
@@ -192,7 +205,7 @@ export function row_getVisibleCellsByColumnId<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>): Record<string, Cell<TFeatures, TData, unknown>> {
-  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}
+  const result = makeObjectMap<Cell<TFeatures, TData, unknown>>()
   const allCells = row.getAllCells()
   for (let i = 0; i < allCells.length; i++) {
     const cell = allCells[i]!
@@ -286,7 +299,12 @@ export function table_resetColumnVisibility<
 >(table: Table_Internal<TFeatures, TData>, defaultState?: boolean) {
   table_setColumnVisibility(
     table,
-    defaultState ? {} : cloneState(table.initialState.columnVisibility ?? {}),
+    defaultState
+      ? makeObjectMap()
+      : Object.assign(
+          makeObjectMap<boolean>(),
+          cloneState(table.initialState.columnVisibility ?? {}),
+        ),
   )
 }
 
@@ -306,7 +324,7 @@ export function table_toggleAllColumnsVisible<
 >(table: Table_Internal<TFeatures, TData>, value?: boolean) {
   value = value ?? !table_getIsAllColumnsVisible(table)
 
-  const visibility: Record<string, boolean> = {}
+  const visibility = makeObjectMap<boolean>()
   const leafColumns = table.getAllLeafColumns()
   for (let i = 0; i < leafColumns.length; i++) {
     const column = leafColumns[i]!

package/src/features/global-filtering/globalFilteringFeature.types.ts

@@ -33,8 +33,8 @@ export interface Column_GlobalFiltering {
 }
 
 export interface TableOptions_GlobalFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Enables global filtering across columns that allow it.
@@ -67,8 +67,8 @@ export interface TableOptions_GlobalFiltering<
 }
 
 export interface Table_GlobalFiltering<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
+  in out TFeatures extends TableFeatures,
+  in out TData extends RowData,
 > {
   /**
    * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.

package/src/features/global-filtering/globalFilteringFeature.utils.ts

@@ -1,4 +1,4 @@
-import { filterFn_includesString } from '../../fns/filterFns'
+import { filterFn_includesString } from '../column-filtering/filterFns'
 import { cloneState, isFunction } from '../../utils'
 import type { Column_Internal } from '../../types/Column'
 import type { FilterFn } from '../column-filtering/columnFilteringFeature.types'
@@ -26,7 +26,7 @@ export function column_getCanGlobalFilter<
     (column.columnDef.enableGlobalFilter ?? true) &&
     (column.table.options.enableGlobalFilter ?? true) &&
     (column.table.options.enableFilters ?? true) &&
-    (column.table.options.getColumnCanGlobalFilter?.(column) ?? true) &&
+    (column.table.options.getColumnCanGlobalFilter?.(column as any) ?? true) &&
     !!column.accessorFn
   )
 }
@@ -63,9 +63,9 @@ export function table_getGlobalFilterFn<
   TData extends RowData,
 >(
   table: Table_Internal<TFeatures, TData>,
-): FilterFn<TFeatures, TData> | FilterFn<TFeatures, TData> | undefined {
+): FilterFn<TFeatures, TData> | undefined {
   const { globalFilterFn: globalFilterFn } = table.options
-  const filterFns: Record<string, FilterFn<TFeatures, RowData>> | undefined =
+  const filterFns: Record<string, FilterFn<TFeatures, TData>> | undefined =
     table._rowModelFns.filterFns
 
   const filterFn = isFunction(globalFilterFn)
@@ -74,7 +74,15 @@ export function table_getGlobalFilterFn<
       ? table_getGlobalAutoFilterFn()
       : filterFns?.[globalFilterFn as string]
 
-  return filterFn as FilterFn<TFeatures, TData> | undefined
+  if (
+    process.env.NODE_ENV === 'development' &&
+    !filterFn &&
+    globalFilterFn != null
+  ) {
+    console.warn(`globalFilterFn '${String(globalFilterFn)}' is not registered`)
+  }
+
+  return filterFn
 }
 
 /**