@tanstack/table-core 9.0.0-beta.34 → 9.0.0-beta.36

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

@@ -1,12 +1,15 @@
 import { table_getPinnedVisibleLeafColumns } from '../column-pinning/columnPinningFeature.utils'
-import { cloneState } from '../../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_Internal } from '../../types/Column'
+import type { Column, Column_Internal } from '../../types/Column'
 import type { ColumnPinningPosition } from '../column-pinning/columnPinningFeature.types'
-import type { ColumnOrderState } from './columnOrderingFeature.types'
+import type {
+  ColumnIndexes,
+  ColumnOrderState,
+} from './columnOrderingFeature.types'
 
 /**
  * Creates the default column order state.
@@ -23,6 +26,42 @@ 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')),
+    left: buildIndexes(table_getPinnedVisibleLeafColumns(table, 'left')),
+    right: buildIndexes(table_getPinnedVisibleLeafColumns(table, 'right')),
+  }
+}
+
 /**
  * Finds this column's index within a visible pinning region.
  *
@@ -42,8 +81,20 @@ export function column_getIndex<
   column: Column_Internal<TFeatures, TData, TValue>,
   position?: ColumnPinningPosition | 'center',
 ) {
-  const columns = table_getPinnedVisibleLeafColumns(column.table, position)
-  return columns.findIndex((d) => d.id === column.id)
+  const indexes = callMemoOrStaticFn(
+    column.table,
+    'getColumnIndexes',
+    table_getColumnIndexes,
+  )
+  const key =
+    position === 'left'
+      ? 'left'
+      : position === 'right'
+        ? 'right'
+        : position === 'center'
+          ? 'center'
+          : 'all'
+  return indexes[key][column.id] ?? -1
 }
 
 /**

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

@@ -139,15 +139,22 @@ export function column_getIsPinned<
 >(
   column: Column_Internal<TFeatures, TData, TValue>,
 ): ColumnPinningPosition | false {
-  const leafColumnIds = column.getLeafColumns().map((d) => d.id)
+  const leafColumns = column.getLeafColumns()
 
   const { left, right } =
     column.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
 
-  const isLeft = leafColumnIds.some((d) => left.includes(d))
-  const isRight = leafColumnIds.some((d) => right.includes(d))
-
-  return isLeft ? 'left' : isRight ? 'right' : false
+  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'
+    }
+  }
+  return false
 }
 
 /**
@@ -197,6 +204,9 @@ export function row_getCenterVisibleCells<
   )
   const { left, right } =
     row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
+  if (!left.length && !right.length) {
+    return allCells
+  }
   const leftAndRight: Array<string> = [...left, ...right]
   return allCells.filter((d) => !leftAndRight.includes(d.column.id))
 }
@@ -441,11 +451,12 @@ export function table_getCenterHeaderGroups<
   )
   const { left, right } =
     table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
-  const leftAndRight: Array<string> = [...left, ...right]
-
-  leafColumns = leafColumns.filter(
-    (column) => !leftAndRight.includes(column.id),
-  )
+  if (left.length || right.length) {
+    const leftAndRight: Array<string> = [...left, ...right]
+    leafColumns = leafColumns.filter(
+      (column) => !leftAndRight.includes(column.id),
+    )
+  }
   return buildHeaderGroups(allColumns, leafColumns, table, 'center')
 }
 
@@ -741,6 +752,9 @@ export function table_getCenterLeafColumns<
 >(table: Table_Internal<TFeatures, TData>) {
   const { left, right } =
     table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
+  if (!left.length && !right.length) {
+    return table.getAllLeafColumns()
+  }
   const leftAndRight: Array<string> = [...left, ...right]
   return table.getAllLeafColumns().filter((d) => !leftAndRight.includes(d.id))
 }

package/src/features/column-resizing/columnResizingFeature.utils.ts

@@ -263,17 +263,29 @@ export function header_getResizeHandler<
         return false
       },
       upHandler: (e: TouchEvent) => {
-        contextDocument?.removeEventListener(
-          'touchmove',
-          touchEvents.moveHandler,
-        )
-        contextDocument?.removeEventListener('touchend', touchEvents.upHandler)
+        removeTouchEvents()
         if (e.cancelable) {
           e.preventDefault()
           e.stopPropagation()
         }
         onEnd(e.touches[0]?.clientX)
       },
+      // the browser fires touchcancel instead of touchend when it takes over
+      // the gesture (system gesture, scroll takeover, tab switch); without
+      // this the non-passive touchmove listener stays on the document forever
+      cancelHandler: () => {
+        removeTouchEvents()
+        onEnd()
+      },
+    }
+
+    const removeTouchEvents = () => {
+      contextDocument?.removeEventListener('touchmove', touchEvents.moveHandler)
+      contextDocument?.removeEventListener('touchend', touchEvents.upHandler)
+      contextDocument?.removeEventListener(
+        'touchcancel',
+        touchEvents.cancelHandler,
+      )
     }
 
     const passiveIfSupported = passiveEventSupported()
@@ -291,6 +303,11 @@ export function header_getResizeHandler<
         touchEvents.upHandler,
         passiveIfSupported,
       )
+      contextDocument?.addEventListener(
+        'touchcancel',
+        touchEvents.cancelHandler,
+        passiveIfSupported,
+      )
     } else {
       contextDocument?.addEventListener(
         'mousemove',

package/src/types/RowModel.ts

@@ -1,10 +1,7 @@
 import type { CachedRowModel_Faceted } from '../features/column-faceting/columnFacetingFeature.types'
 import type { CachedRowModel_Grouped } from '../features/column-grouping/columnGroupingFeature.types'
 import type { CachedRowModel_Filtered } from '../features/column-filtering/columnFilteringFeature.types'
-import type {
-  CachedRowModel_Core,
-  RowModel,
-} from '../core/row-models/coreRowModelsFeature.types'
+import type { CachedRowModel_Core } from '../core/row-models/coreRowModelsFeature.types'
 import type { CachedRowModel_Expanded } from '../features/row-expanding/rowExpandingFeature.types'
 import type { CachedRowModel_Paginated } from '../features/row-pagination/rowPaginationFeature.types'
 import type { CachedRowModel_Sorted } from '../features/row-sorting/rowSortingFeature.types'
@@ -26,12 +23,11 @@ export interface CachedRowModels_FeatureMap<
 export type CachedRowModels<
   TFeatures extends TableFeatures,
   TData extends RowData,
-> = {
-  CachedRowModel_Core: () => RowModel<TFeatures, TData>
-} & ExtractFeatureMapTypes<
-  TFeatures,
-  CachedRowModels_FeatureMap<TFeatures, TData>
->
+> = Partial<CachedRowModel_Core<TFeatures, TData>> &
+  ExtractFeatureMapTypes<
+    TFeatures,
+    CachedRowModels_FeatureMap<TFeatures, TData>
+  >
 
 export interface CachedRowModel_All<
   in out TFeatures extends TableFeatures,

package/src/utils.ts

@@ -52,7 +52,8 @@ export function cloneState<T>(value: T): T {
 
 /**
  * Copies prototype-instance own properties without carrying over lazy memo
- * closures that were bound to the source instance.
+ * closures or the per-row cell cache, both of which are bound to the source
+ * instance (cached cells reference the source row).
  */
 export function copyInstancePropertiesWithoutMemos<
   TTarget extends Record<string, any>,
@@ -63,7 +64,7 @@ export function copyInstancePropertiesWithoutMemos<
 
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i]!
-    if (!key.startsWith('_memo_')) {
+    if (!key.startsWith('_memo_') && key !== '_cellsCache') {
       targetRecord[key] = source[key]
     }
   }

package/src/worker/initTableWorker.ts

@@ -79,7 +79,7 @@ export function initTableWorker<
             ...config.features,
           },
           data: message.data,
-        }) as unknown as Table_Internal<TFeatures, TData>
+        })
         // Only columns with an explicit aggregation get eagerly aggregated
         // per group. Sync tables aggregate lazily (visible cells only), so
         // auto-aggregating every column would explode on high-cardinality

package/src/worker/rebuildRowModel.ts

@@ -2,6 +2,8 @@ import { constructRow } from '../core/rows/constructRow'
 import { hasOwn } from '../utils'
 import type { RowModel } from '../core/row-models/coreRowModelsFeature.types'
 import type { Table_Internal } from '../types/Table'
+import type { TableFeatures } from '../types/TableFeatures'
+import type { RowData } from '../types/type-utils'
 import type {
   TableWorkerRowNode,
   TableWorkerStagePayload,
@@ -13,8 +15,6 @@ export type TableWorkerDataPayload = Exclude<
   { kind: 'unchanged' }
 >
 
-type AnyTable = Table_Internal<any, any>
-
 // Main-thread side: payload + this table's core rows -> RowModel. Mirrors how
 // the sync row models treat rows: data rows are reused (with depth/parentId
 // rewritten, exactly like createGroupedRowModel does), synthetic group rows
@@ -32,8 +32,11 @@ function collectLeafRows(subRows: Array<any>, out: Array<any>) {
   }
 }
 
-export function rebuildRowModel(
-  table: AnyTable,
+export function rebuildRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
   payload: TableWorkerDataPayload,
   /**
    * Whether a flat payload should rewrite row depth/parentId. Mirrors core:
@@ -42,7 +45,7 @@ export function rebuildRowModel(
    * depths a grouped/sorted tree rebuild just assigned to shared row objects.
    */
   resetDepths: boolean,
-): RowModel<any, any> {
+): RowModel<TFeatures, TData> {
   const core = table.getCoreRowModel()
 
   if (payload.kind === 'flat') {