@tanstack/table-core 9.0.0-alpha.46 → 9.0.0-alpha.47

package/src/features/column-faceting/createFacetedMinMaxValues.ts

@@ -49,20 +49,18 @@ function _createFacetedMinMaxValues<
 ): undefined | [number, number] {
   if (!flatRows.length) return undefined
 
-  const numericValues = flatRows
-    .map((flatRow) => flatRow.getValue(columnId))
-    .map(Number)
-    .filter((value) => !Number.isNaN(value))
+  let facetedMinValue = Number.POSITIVE_INFINITY
+  let facetedMaxValue = Number.NEGATIVE_INFINITY
+  let foundAny = false
 
-  if (!numericValues.length) return undefined
-
-  let facetedMinValue = numericValues[0]!
-  let facetedMaxValue = numericValues[0]!
-
-  for (const value of numericValues) {
+  for (let i = 0; i < flatRows.length; i++) {
+    const value = Number(flatRows[i]!.getValue(columnId))
+    if (Number.isNaN(value)) continue
+    foundAny = true
     if (value < facetedMinValue) facetedMinValue = value
     if (value > facetedMaxValue) facetedMaxValue = value
   }
 
+  if (!foundAny) return undefined
   return [facetedMinValue, facetedMaxValue]
 }

package/src/features/column-faceting/createFacetedRowModel.ts

@@ -60,17 +60,21 @@ function _createFacetedRowModel<
     return preRowModel
   }
 
-  const filterableIds = [
-    ...(columnFilters?.map((d) => d.id).filter((d) => d !== columnId) ?? []),
-    globalFilter ? '__global__' : undefined,
-  ].filter(Boolean) as Array<string>
+  const filterableIds: Array<string> = []
+  if (columnFilters) {
+    for (let i = 0; i < columnFilters.length; i++) {
+      const id = columnFilters[i]!.id
+      if (id !== columnId) filterableIds.push(id)
+    }
+  }
+  if (globalFilter) filterableIds.push('__global__')
 
   const filterRowsImpl = (
     row: Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>,
   ) => {
     // Horizontally filter rows through each column
-    for (const colId of filterableIds) {
-      if (row.columnFilters?.[colId] === false) {
+    for (let i = 0; i < filterableIds.length; i++) {
+      if (row.columnFilters?.[filterableIds[i]!] === false) {
         return false
       }
     }

package/src/features/column-faceting/createFacetedUniqueValues.ts

@@ -46,10 +46,11 @@ function _createFacetedUniqueValues<
 >(columnId: string, flatRows: Array<Row<TFeatures, TData>>): Map<any, number> {
   const facetedUniqueValues = new Map<any, number>()
 
-  for (const row of flatRows) {
-    const values = row.getUniqueValues(columnId)
+  for (let i = 0; i < flatRows.length; i++) {
+    const values = flatRows[i]!.getUniqueValues(columnId)
 
-    for (const value of values) {
+    for (let j = 0; j < values.length; j++) {
+      const value = values[j]
       if (facetedUniqueValues.has(value)) {
         facetedUniqueValues.set(
           value,

package/src/features/column-filtering/createFilteredRowModel.ts

@@ -57,9 +57,11 @@ function _createFilteredRowModel<
   const globalFilter = table.atoms.globalFilter?.get()
 
   if (!rowModel.rows.length || (!columnFilters?.length && !globalFilter)) {
-    for (const row of rowModel.flatRows as Array<
+    const flatRows = rowModel.flatRows as Array<
       Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>
-    >) {
+    >
+    for (let i = 0; i < flatRows.length; i++) {
+      const row = flatRows[i]!
       row.columnFilters = {}
       row.columnFiltersMeta = {}
     }
@@ -110,13 +112,16 @@ function _createFilteredRowModel<
   }
 
   // Flag the pre-filtered row model with each filter state
-  for (const row of rowModel.flatRows as Array<
+  const flatRows = rowModel.flatRows as Array<
     Row<TFeatures, TData> & Partial<Row_ColumnFiltering<TFeatures, TData>>
-  >) {
+  >
+  for (let i = 0; i < flatRows.length; i++) {
+    const row = flatRows[i]!
     row.columnFilters = {}
 
     if (resolvedColumnFilters.length) {
-      for (const currentColumnFilter of resolvedColumnFilters) {
+      for (let j = 0; j < resolvedColumnFilters.length; j++) {
+        const currentColumnFilter = resolvedColumnFilters[j]!
         const id = currentColumnFilter.id
 
         // Tag the row with the column filter state
@@ -134,7 +139,8 @@ function _createFilteredRowModel<
     }
 
     if (resolvedGlobalFilters.length) {
-      for (const currentGlobalFilter of resolvedGlobalFilters) {
+      for (let j = 0; j < resolvedGlobalFilters.length; j++) {
+        const currentGlobalFilter = resolvedGlobalFilters[j]!
         const id = currentGlobalFilter.id
         // Tag the row with the first truthy global filter state
         if (
@@ -164,8 +170,8 @@ function _createFilteredRowModel<
     row: Row<TFeatures, TData> & Row_ColumnFiltering<TFeatures, TData>,
   ) => {
     // Horizontally filter rows through each column
-    for (const columnId of filterableIds) {
-      if (row.columnFilters[columnId] === false) {
+    for (let i = 0; i < filterableIds.length; i++) {
+      if (row.columnFilters[filterableIds[i]!] === false) {
         return false
       }
     }

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

@@ -156,11 +156,15 @@ export function table_getOrderColumnsFn<
         string,
         Column_Internal<TFeatures, TData, unknown>
       >()
-      for (const column of columns) remaining.set(column.id, column)
+      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 (const id of columnOrder) {
+      for (let i = 0; i < columnOrder.length; i++) {
+        const id = columnOrder[i]!
         const column = remaining.get(id)
         if (column) {
           orderedColumns.push(column)
@@ -169,7 +173,8 @@ export function table_getOrderColumnsFn<
       }
 
       // Append leftover columns in their original order
-      for (const column of columns) {
+      for (let i = 0; i < columns.length; i++) {
+        const column = columns[i]!
         if (remaining.has(column.id)) orderedColumns.push(column)
       }
     }
@@ -214,11 +219,14 @@ export function orderColumns<
     string,
     Column_Internal<TFeatures, TData, unknown>
   >()
-  for (const col of leafColumns) leafColumnsById.set(col.id, col)
+  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 (const g of grouping) {
-    const col = leafColumnsById.get(g)
+  for (let i = 0; i < grouping.length; i++) {
+    const col = leafColumnsById.get(grouping[i]!)
     if (col) groupingColumns.push(col)
   }
 

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

@@ -1,10 +1,12 @@
 import {
   column_getIsVisible,
   row_getVisibleCells,
+  row_getVisibleCellsByColumnId,
   table_getVisibleLeafColumns,
 } from '../column-visibility/columnVisibilityFeature.utils'
 import { buildHeaderGroups } from '../../core/headers/buildHeaderGroups'
 import { callMemoOrStaticFn, cloneState } from '../../utils'
+import type { Header } from '../../types/Header'
 import type { HeaderGroup } from '../../types/HeaderGroup'
 import type { Cell } from '../../types/Cell'
 import type { Row } from '../../types/Row'
@@ -56,10 +58,13 @@ export function column_pin<
   column: Column_Internal<TFeatures, TData, TValue>,
   position: ColumnPinningPosition,
 ) {
-  const columnIds = column
-    .getLeafColumns()
-    .map((d) => d.id)
-    .filter(Boolean)
+  // Single pass: collect non-empty leaf-column ids.
+  const leafColumns = column.getLeafColumns()
+  const columnIds: Array<string> = []
+  for (let i = 0; i < leafColumns.length; i++) {
+    const id = leafColumns[i]!.id
+    if (id) columnIds.push(id)
+  }
 
   table_setColumnPinning(column.table, (old) => {
     if (position === 'right') {
@@ -209,12 +214,13 @@ export function row_getLeftVisibleCells<
   if (!left.length) return []
   const allVisibleCells = callMemoOrStaticFn(
     row,
-    'getVisibleCells',
-    row_getVisibleCells,
+    'getVisibleCellsByColumnId',
+    row_getVisibleCellsByColumnId,
   )
-  const cells: typeof allVisibleCells = []
-  for (const columnId of left) {
-    const cell = allVisibleCells.find((c) => c.column.id === columnId)
+  const cells: Array<Cell<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < left.length; i++) {
+    const columnId = left[i]!
+    const cell = allVisibleCells[columnId]
     if (cell) {
       // Assign position property directly to preserve prototype chain
       cell.position = 'left'
@@ -243,12 +249,13 @@ export function row_getRightVisibleCells<
   if (!right.length) return [] as Array<Cell<TFeatures, TData, unknown>>
   const allVisibleCells = callMemoOrStaticFn(
     row,
-    'getVisibleCells',
-    row_getVisibleCells,
+    'getVisibleCellsByColumnId',
+    row_getVisibleCellsByColumnId,
   )
-  const cells: typeof allVisibleCells = []
-  for (const columnId of right) {
-    const cell = allVisibleCells.find((c) => c.column.id === columnId)
+  const cells: Array<Cell<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < right.length; i++) {
+    const columnId = right[i]!
+    const cell = allVisibleCells[columnId]
     if (cell) {
       // Assign position property directly to preserve prototype chain
       cell.position = 'right'
@@ -353,8 +360,8 @@ export function table_getLeftHeaderGroups<
 
   const orderedLeafColumns: Array<Column_Internal<TFeatures, TData, unknown>> =
     []
-  for (const columnId of left) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < left.length; i++) {
+    const column = leafColumnsById[left[i]!]
     if (
       column &&
       callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
@@ -390,8 +397,8 @@ export function table_getRightHeaderGroups<
 
   const orderedLeafColumns: Array<Column_Internal<TFeatures, TData, unknown>> =
     []
-  for (const columnId of right) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < right.length; i++) {
+    const column = leafColumnsById[right[i]!]
     if (
       column &&
       callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
@@ -524,11 +531,14 @@ export function table_getLeftFlatHeaders<
     'getLeftHeaderGroups',
     table_getLeftHeaderGroups,
   )
-  return leftHeaderGroups
-    .map((headerGroup) => {
-      return headerGroup.headers
-    })
-    .flat()
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < leftHeaderGroups.length; i++) {
+    const headers = leftHeaderGroups[i]!.headers
+    for (let j = 0; j < headers.length; j++) {
+      result.push(headers[j])
+    }
+  }
+  return result
 }
 
 /**
@@ -550,11 +560,14 @@ export function table_getRightFlatHeaders<
     'getRightHeaderGroups',
     table_getRightHeaderGroups,
   )
-  return rightHeaderGroups
-    .map((headerGroup) => {
-      return headerGroup.headers
-    })
-    .flat()
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < rightHeaderGroups.length; i++) {
+    const headers = rightHeaderGroups[i]!.headers
+    for (let j = 0; j < headers.length; j++) {
+      result.push(headers[j])
+    }
+  }
+  return result
 }
 
 /**
@@ -576,11 +589,14 @@ export function table_getCenterFlatHeaders<
     'getCenterHeaderGroups',
     table_getCenterHeaderGroups,
   )
-  return centerHeaderGroups
-    .map((headerGroup) => {
-      return headerGroup.headers
-    })
-    .flat()
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < centerHeaderGroups.length; i++) {
+    const headers = centerHeaderGroups[i]!.headers
+    for (let j = 0; j < headers.length; j++) {
+      result.push(headers[j])
+    }
+  }
+  return result
 }
 
 // leaf headers
@@ -668,8 +684,8 @@ export function table_getLeftLeafColumns<
     table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
   const leafColumnsById = table.getAllLeafColumnsById()
   const result: Array<Column_Internal<TFeatures, TData, unknown>> = []
-  for (const columnId of left) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < left.length; i++) {
+    const column = leafColumnsById[left[i]!]
     if (column) result.push(column)
   }
   return result
@@ -693,8 +709,8 @@ export function table_getRightLeafColumns<
     table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
   const leafColumnsById = table.getAllLeafColumnsById()
   const result: Array<Column_Internal<TFeatures, TData, unknown>> = []
-  for (const columnId of right) {
-    const column = leafColumnsById[columnId]
+  for (let i = 0; i < right.length; i++) {
+    const column = leafColumnsById[right[i]!]
     if (column) result.push(column)
   }
   return result

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

@@ -141,15 +141,31 @@ export function constructColumnSizingFeature<
         },
         table_getTotalSize: {
           fn: () => table_getTotalSize(table),
+          memoDeps: () => [
+            table.atoms.columnSizing?.get(),
+            table.getHeaderGroups(),
+          ],
         },
         table_getLeftTotalSize: {
           fn: () => table_getLeftTotalSize(table),
+          memoDeps: () => [
+            table.atoms.columnSizing?.get(),
+            table.getHeaderGroups(),
+          ],
         },
         table_getCenterTotalSize: {
           fn: () => table_getCenterTotalSize(table),
+          memoDeps: () => [
+            table.atoms.columnSizing?.get(),
+            table.getHeaderGroups(),
+          ],
         },
         table_getRightTotalSize: {
           fn: () => table_getRightTotalSize(table),
+          memoDeps: () => [
+            table.atoms.columnSizing?.get(),
+            table.getHeaderGroups(),
+          ],
         },
       })
     },

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

@@ -10,6 +10,7 @@ import {
   column_toggleVisibility,
   getDefaultColumnVisibilityState,
   row_getVisibleCells,
+  row_getVisibleCellsByColumnId,
   table_getIsAllColumnsVisible,
   table_getIsSomeColumnsVisible,
   table_getToggleAllColumnsVisibilityHandler,
@@ -97,6 +98,13 @@ export function constructColumnVisibilityFeature<
             table.atoms.columnVisibility?.get(),
           ],
         },
+        row_getVisibleCellsByColumnId: {
+          fn: (row) => row_getVisibleCellsByColumnId(row),
+          memoDeps: (row) => [
+            row.getAllCells(),
+            table.atoms.columnVisibility?.get(),
+          ],
+        },
       })
     },
 

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

@@ -80,6 +80,13 @@ export interface Row_ColumnVisibility<
    * Returns an array of cells that account for column visibility for the row.
    */
   getVisibleCells: () => Array<Cell<TFeatures, TData, unknown>>
+  /**
+   * Returns visible cells by column id for the row.
+   */
+  getVisibleCellsByColumnId: () => Record<
+    string,
+    Cell<TFeatures, TData, unknown>
+  >
 }
 
 export interface Column_ColumnVisibility {

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

@@ -130,42 +130,73 @@ export function row_getVisibleCells<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {
-  const cells = row
-    .getAllCells()
-    .filter((cell) =>
-      callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible),
-    )
+  const allCells = row.getAllCells()
+  const visibleCells: Array<Cell<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < allCells.length; i++) {
+    const cell = allCells[i]!
+    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {
+      visibleCells.push(cell)
+    }
+  }
+
   const { left, right } =
     row.table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()
-  if (!left.length && !right.length) return cells // no pinning, return early
+  if (!left.length && !right.length) return visibleCells // no pinning, return early
 
-  const cellsByColumnId = new Map<string, Cell<TFeatures, TData, unknown>>()
-  for (const cell of cells) cellsByColumnId.set(cell.column.id, cell)
+  const visibleCellsByColumnId = callMemoOrStaticFn(
+    row,
+    'getVisibleCellsByColumnId',
+    row_getVisibleCellsByColumnId,
+  )
 
   const leftCells: Array<Cell<TFeatures, TData, unknown>> = []
-  for (const columnId of left) {
-    const cell = cellsByColumnId.get(columnId)
+  for (let i = 0; i < left.length; i++) {
+    const cell = visibleCellsByColumnId[left[i]!]
     if (cell) leftCells.push(cell)
   }
 
   const rightCells: Array<Cell<TFeatures, TData, unknown>> = []
-  for (const columnId of right) {
-    const cell = cellsByColumnId.get(columnId)
+  for (let i = 0; i < right.length; i++) {
+    const cell = visibleCellsByColumnId[right[i]!]
     if (cell) rightCells.push(cell)
   }
 
   // Center cells: visible cells in natural column order, minus pinned ones.
-  const leftSet = new Set(left)
-  const rightSet = new Set(right)
   const centerCells: Array<Cell<TFeatures, TData, unknown>> = []
-  for (const cell of cells) {
+  for (let i = 0; i < visibleCells.length; i++) {
+    const cell = visibleCells[i]!
     const id = cell.column.id
-    if (!leftSet.has(id) && !rightSet.has(id)) centerCells.push(cell)
+    if (!left.includes(id) && !right.includes(id)) centerCells.push(cell)
   }
 
   return [...leftCells, ...centerCells, ...rightCells]
 }
 
+/**
+ * Returns visible cells by column id for a row.
+ *
+ * This is the static implementation behind the matching row instance API and may read row caches or table state atoms.
+ *
+ * @example
+ * ```ts
+ * const value = row_getVisibleCellsByColumnId(row)
+ * ```
+ */
+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 allCells = row.getAllCells()
+  for (let i = 0; i < allCells.length; i++) {
+    const cell = allCells[i]!
+    if (callMemoOrStaticFn(cell.column, 'getIsVisible', column_getIsVisible)) {
+      result[cell.column.id] = cell
+    }
+  }
+  return result
+}
+
 /**
  * Returns visible flat columns for the table.
  *
@@ -266,7 +297,9 @@ export function table_toggleAllColumnsVisible<
   value = value ?? !table_getIsAllColumnsVisible(table)
 
   const visibility: Record<string, boolean> = {}
-  for (const column of table.getAllLeafColumns()) {
+  const leafColumns = table.getAllLeafColumns()
+  for (let i = 0; i < leafColumns.length; i++) {
+    const column = leafColumns[i]!
     visibility[column.id] = !value ? !column_getCanHide(column) : value
   }
 

package/src/features/row-expanding/rowExpandingFeature.utils.ts

@@ -41,7 +41,7 @@ export function table_autoResetExpanded<
     table.options.autoResetExpanded ??
     !table.options.manualExpanding
   ) {
-    queueMicrotask(() => table_resetExpanded(table))
+    table._reactivity.schedule(() => table_resetExpanded(table))
   }
 }
 
@@ -330,7 +330,7 @@ export function row_getIsAllParentsExpanded<
 
   while (isFullyExpanded && currentRow.parentId) {
     currentRow = row.table.getRow(currentRow.parentId, true)
-    isFullyExpanded = row_getIsExpanded(row)
+    isFullyExpanded = row_getIsExpanded(currentRow)
   }
 
   return isFullyExpanded

package/src/features/row-pinning/rowPinningFeature.utils.ts

@@ -109,26 +109,28 @@ function table_getPinnedRows<
 ): Array<Row<TFeatures, TData>> {
   const visibleRows = table.getRowModel().rows
   const pinnedRowIds = table.atoms.rowPinning?.get()?.[position] ?? []
+  const keepPinnedRows = table.options.keepPinnedRows ?? true
 
-  const rows =
-    (table.options.keepPinnedRows ?? true)
-      ? // get all rows that are pinned even if they would not be otherwise visible
-        // account for expanded parent rows, but not pagination or filtering
-        pinnedRowIds.map((rowId) => {
-          const row = table.getRow(rowId, true)
-          return row_getIsAllParentsExpanded(row) ? row : null
-        })
-      : // else get only visible rows that are pinned
-        pinnedRowIds.map(
-          (rowId) => visibleRows.find((row) => row.id === rowId)!,
-        )
-
-  const filteredRows = rows.filter((r) => !!r)
-  // Assign position property directly to preserve prototype chain
-  filteredRows.forEach((row) => {
+  const result: Array<Row<TFeatures, TData>> = []
+  for (let i = 0; i < pinnedRowIds.length; i++) {
+    const rowId = pinnedRowIds[i]!
+    let row: Row<TFeatures, TData> | undefined
+    if (keepPinnedRows) {
+      // get all rows that are pinned even if they would not be otherwise
+      // visible; account for expanded parent rows, but not pagination/filtering
+      const fullRow = table.getRow(rowId, true)
+      if (row_getIsAllParentsExpanded(fullRow)) row = fullRow
+    } else {
+      // else get only visible rows that are pinned
+      row = visibleRows.find((r) => r.id === rowId)
+    }
+    if (!row)
+      continue
+      // Assign position property directly to preserve prototype chain
     ;(row as any).position = position
-  })
-  return filteredRows
+    result.push(row)
+  }
+  return result
 }
 
 /**

package/src/features/row-selection/rowSelectionFeature.utils.ts

@@ -622,32 +622,33 @@ export function selectRowsFn<
   const newSelectedFlatRows: Array<Row<TFeatures, TData>> = []
   const newSelectedRowsById: Record<string, Row<TFeatures, TData>> = {}
 
-  // Filters top level and nested rows
+  // Filters top level and nested rows.
   const recurseRows = (
     rows: Array<Row<TFeatures, TData>>,
     depth = 0,
   ): Array<Row<TFeatures, TData>> => {
-    return rows
-      .map((row) => {
-        const isSelected = isRowSelected(row)
-
-        if (isSelected) {
-          newSelectedFlatRows.push(row)
-          newSelectedRowsById[row.id] = row
-        }
+    const result: Array<Row<TFeatures, TData>> = []
+    for (let i = 0; i < rows.length; i++) {
+      let row = rows[i]!
+      const isSelected = isRowSelected(row)
+
+      if (isSelected) {
+        newSelectedFlatRows.push(row)
+        newSelectedRowsById[row.id] = row
+      }
 
-        if (row.subRows.length) {
-          row = {
-            ...row,
-            subRows: recurseRows(row.subRows, depth + 1),
-          }
+      if (row.subRows.length) {
+        row = {
+          ...row,
+          subRows: recurseRows(row.subRows, depth + 1),
         }
+      }
 
-        if (isSelected) {
-          return row
-        }
-      })
-      .filter((x) => !!x)
+      if (isSelected) {
+        result.push(row)
+      }
+    }
+    return result
   }
 
   return {