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

package/src/core/headers/coreHeadersFeature.utils.ts

@@ -1,10 +1,8 @@
+import { getDefaultColumnPinningState } from '../../features/column-pinning/columnPinningFeature.utils'
 import {
-  getDefaultColumnPinningState,
-  table_getCenterHeaderGroups,
-  table_getLeftHeaderGroups,
-  table_getRightHeaderGroups,
-} from '../../features/column-pinning/columnPinningFeature.utils'
-import { table_getVisibleLeafColumns } from '../../features/column-visibility/columnVisibilityFeature.utils'
+  column_getIsVisible,
+  table_getVisibleLeafColumns,
+} from '../../features/column-visibility/columnVisibilityFeature.utils'
 import { callMemoOrStaticFn } from '../../utils'
 import { buildHeaderGroups } from './buildHeaderGroups'
 import type { Table_Internal } from '../../types/Table'
@@ -14,6 +12,16 @@ import type { TableFeatures } from '../../types/TableFeatures'
 import type { Header_Header } from './coreHeadersFeature.types'
 import type { Column } from '../../types/Column'
 
+/**
+ * Returns leaf headers for a header.
+ *
+ * This is the static implementation behind the matching header instance API and can account for nested header groups.
+ *
+ * @example
+ * ```ts
+ * const value = header_getLeafHeaders(header)
+ * ```
+ */
 export function header_getLeafHeaders<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -33,6 +41,16 @@ export function header_getLeafHeaders<
   return leafHeaders
 }
 
+/**
+ * Returns context for a header.
+ *
+ * This is the static implementation behind the matching header instance API and can account for nested header groups.
+ *
+ * @example
+ * ```ts
+ * const value = header_getContext(header)
+ * ```
+ */
 export function header_getContext<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -45,6 +63,16 @@ export function header_getContext<
   }
 }
 
+/**
+ * Returns header groups for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getHeaderGroups(table)
+ * ```
+ */
 export function table_getHeaderGroups<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -56,29 +84,58 @@ export function table_getHeaderGroups<
     table,
     'getVisibleLeafColumns',
     table_getVisibleLeafColumns,
-  ) as unknown as Array<Column<TFeatures, TData, unknown>>
+  ) as Array<Column<TFeatures, TData, unknown>>
 
-  const leftColumns = left
-    .map((columnId) => leafColumns.find((d) => d.id === columnId)!)
-    .filter(Boolean)
+  // Fast path: no columns are pinned — skip per-side lookups, partition, and spread.
+  if (!left.length && !right.length) {
+    return buildHeaderGroups(allColumns, leafColumns, table)
+  }
+
+  const leafColumnsById = table.getAllLeafColumnsById()
+
+  const leftColumns: typeof leafColumns = []
+  for (let i = 0; i < left.length; i++) {
+    const column = leafColumnsById[left[i]!]
+    if (
+      column &&
+      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
+    ) {
+      leftColumns.push(column)
+    }
+  }
 
-  const rightColumns = right
-    .map((columnId) => leafColumns.find((d) => d.id === columnId)!)
-    .filter(Boolean)
+  const rightColumns: typeof leafColumns = []
+  for (let i = 0; i < right.length; i++) {
+    const column = leafColumnsById[right[i]!]
+    if (
+      column &&
+      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)
+    ) {
+      rightColumns.push(column)
+    }
+  }
 
   const centerColumns = leafColumns.filter(
     (column) => !left.includes(column.id) && !right.includes(column.id),
   )
 
-  const headerGroups = buildHeaderGroups(
+  return buildHeaderGroups(
     allColumns,
     [...leftColumns, ...centerColumns, ...rightColumns],
     table,
   )
-
-  return headerGroups
 }
 
+/**
+ * Returns footer groups for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getFooterGroups(table)
+ * ```
+ */
 export function table_getFooterGroups<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -87,45 +144,52 @@ export function table_getFooterGroups<
   return [...headerGroups].reverse()
 }
 
+/**
+ * Returns flat headers for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getFlatHeaders(table)
+ * ```
+ */
 export function table_getFlatHeaders<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
   const headerGroups = table.getHeaderGroups()
-  return headerGroups
-    .map((headerGroup) => {
-      return headerGroup.headers
-    })
-    .flat()
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < headerGroups.length; i++) {
+    const headers = headerGroups[i]!.headers
+    for (let j = 0; j < headers.length; j++) {
+      result.push(headers[j]!)
+    }
+  }
+  return result
 }
 
+/**
+ * Returns leaf headers for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getLeafHeaders(table)
+ * ```
+ */
 export function table_getLeafHeaders<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(table: Table_Internal<TFeatures, TData>) {
-  const left = callMemoOrStaticFn(
-    table,
-    'getLeftHeaderGroups',
-    table_getLeftHeaderGroups,
-  )
-  const center = callMemoOrStaticFn(
-    table,
-    'getCenterHeaderGroups',
-    table_getCenterHeaderGroups,
-  )
-  const right = callMemoOrStaticFn(
-    table,
-    'getRightHeaderGroups',
-    table_getRightHeaderGroups,
-  )
-
-  return [
-    ...(left[0]?.headers ?? []),
-    ...(center[0]?.headers ?? []),
-    ...(right[0]?.headers ?? []),
-  ]
-    .map((header) => {
-      return header.getLeafHeaders()
-    })
-    .flat()
+  const topHeaders = table.getHeaderGroups()[0]?.headers ?? []
+  const result: Array<Header<TFeatures, TData, unknown>> = []
+  for (let i = 0; i < topHeaders.length; i++) {
+    const leafHeaders = topHeaders[i]!.getLeafHeaders()
+    for (let j = 0; j < leafHeaders.length; j++) {
+      result.push(leafHeaders[j]!)
+    }
+  }
+  return result
 }

package/src/core/reactivity/coreReactivityFeature.types.ts

@@ -38,4 +38,8 @@ export interface TableReactivityBindings {
    * Batches reactive updates to avoid intermediate recomputation.
    */
   batch: (fn: () => void) => void
+  /**
+   * Schedules a function to run. This is used to defer updates after the current call stack (render, etc.) has finished
+   */
+  schedule: (fn: () => void) => void
 }

package/src/core/reactivity/coreReactivityFeature.utils.ts

@@ -2,16 +2,31 @@ import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'
 
 /**
  * Converts a writable atom to the store-compatible shape expected by core.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
  */
 export function atomToStore<T>(atom: Atom<T>): Store<T>
 /**
  * Converts a readonly atom to a readonly store-compatible shape.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
  */
 export function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>
 /**
  * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing
  * a `state` getter backed by `atom.get()`, and wiring `setState` for
  * writable atoms.
+ *
+ * @example
+ * ```ts
+ * const store = atomToStore(atom)
+ * ```
  */
 export function atomToStore<T>(
   atom: Atom<T> | ReadonlyAtom<T>,

package/src/core/row-models/coreRowModelsFeature.ts

@@ -24,6 +24,11 @@ export interface CoreRowModelsFeatureConstructors<
   // Table: Table_RowModels<TFeatures, TData>
 }
 
+/**
+ * Creates the stock core row models feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
 export function constructCoreRowModelsFeature<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/row-models/coreRowModelsFeature.types.ts

@@ -25,7 +25,8 @@ export interface CreateRowModel_Core<
   TData extends RowData,
 > extends CreateRowModel_Plugins {
   /**
-   * This required option is a factory for a function that computes and returns the core row model for the table.
+   * Optional factory for the core row model. When omitted, the built-in
+   * `createCoreRowModel()` factory is used.
    */
   coreRowModel?: (
     table: Table<TFeatures, TData>,

package/src/core/row-models/coreRowModelsFeature.utils.ts

@@ -4,6 +4,16 @@ import type { TableFeatures } from '../../types/TableFeatures'
 import type { RowData } from '../../types/type-utils'
 import type { RowModel } from './coreRowModelsFeature.types'
 
+/**
+ * Returns core row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getCoreRowModel(table)
+ * ```
+ */
 export function table_getCoreRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -17,6 +27,16 @@ export function table_getCoreRowModel<
   return table._rowModels.coreRowModel()
 }
 
+/**
+ * Returns pre filtered row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPreFilteredRowModel(table)
+ * ```
+ */
 export function table_getPreFilteredRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -24,6 +44,16 @@ export function table_getPreFilteredRowModel<
   return table.getCoreRowModel()
 }
 
+/**
+ * Returns filtered row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getFilteredRowModel(table)
+ * ```
+ */
 export function table_getFilteredRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -40,6 +70,16 @@ export function table_getFilteredRowModel<
   return table._rowModels.filteredRowModel()
 }
 
+/**
+ * Returns pre grouped row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPreGroupedRowModel(table)
+ * ```
+ */
 export function table_getPreGroupedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -47,6 +87,16 @@ export function table_getPreGroupedRowModel<
   return table.getFilteredRowModel()
 }
 
+/**
+ * Returns grouped row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getGroupedRowModel(table)
+ * ```
+ */
 export function table_getGroupedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -63,6 +113,16 @@ export function table_getGroupedRowModel<
   return table._rowModels.groupedRowModel()
 }
 
+/**
+ * Returns pre sorted row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPreSortedRowModel(table)
+ * ```
+ */
 export function table_getPreSortedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -70,6 +130,16 @@ export function table_getPreSortedRowModel<
   return table.getGroupedRowModel()
 }
 
+/**
+ * Returns sorted row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getSortedRowModel(table)
+ * ```
+ */
 export function table_getSortedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -86,6 +156,16 @@ export function table_getSortedRowModel<
   return table._rowModels.sortedRowModel()
 }
 
+/**
+ * Returns pre expanded row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPreExpandedRowModel(table)
+ * ```
+ */
 export function table_getPreExpandedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -93,6 +173,16 @@ export function table_getPreExpandedRowModel<
   return table.getSortedRowModel()
 }
 
+/**
+ * Returns expanded row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getExpandedRowModel(table)
+ * ```
+ */
 export function table_getExpandedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -109,6 +199,16 @@ export function table_getExpandedRowModel<
   return table._rowModels.expandedRowModel()
 }
 
+/**
+ * Returns pre paginated row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPrePaginatedRowModel(table)
+ * ```
+ */
 export function table_getPrePaginatedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -116,6 +216,16 @@ export function table_getPrePaginatedRowModel<
   return table.getExpandedRowModel()
 }
 
+/**
+ * Returns paginated row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getPaginatedRowModel(table)
+ * ```
+ */
 export function table_getPaginatedRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -132,6 +242,16 @@ export function table_getPaginatedRowModel<
   return table._rowModels.paginatedRowModel()
 }
 
+/**
+ * Returns row model for the table.
+ *
+ * This reads the relevant table atoms, options, and row-model cache to derive the current table-level value.
+ *
+ * @example
+ * ```ts
+ * const value = table_getRowModel(table)
+ * ```
+ */
 export function table_getRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/row-models/createCoreRowModel.ts

@@ -7,6 +7,11 @@ import type { TableFeatures } from '../../types/TableFeatures'
 import type { Row } from '../../types/Row'
 import type { RowData } from '../../types/type-utils'
 
+/**
+ * Creates a memoized core row model factory.
+ *
+ * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.
+ */
 export function createCoreRowModel<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/rows/constructRow.ts

@@ -14,13 +14,19 @@ function getRowPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._rowPrototype) {
     table._rowPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignRowPrototype?.(table._rowPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignRowPrototype?.(table._rowPrototype, table)
     }
   }
   return table._rowPrototype
 }
 
+/**
+ * Constructs a row instance from normalized table internals.
+ *
+ * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
+ */
 export const constructRow = <
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -51,8 +57,9 @@ export const constructRow = <
   row.subRows = subRows ?? []
 
   // Initialize instance-specific data (e.g., caches) for features that need it
-  for (const feature of Object.values(table._features)) {
-    feature.initRowInstanceData?.(row)
+  const features = Object.values(table._features)
+  for (let i = 0; i < features.length; i++) {
+    features[i]!.initRowInstanceData?.(row)
   }
 
   return row as Row<TFeatures, TData>

package/src/core/rows/coreRowsFeature.ts

@@ -28,6 +28,11 @@ export interface CoreRowsFeatureConstructors<
   // Table: Table_Rows<TFeatures, TData>
 }
 
+/**
+ * Creates the stock core rows feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
 export function constructCoreRowsFeature<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/rows/coreRowsFeature.types.ts

@@ -48,6 +48,9 @@ export interface Row_Row<
   TFeatures extends TableFeatures,
   TData extends RowData,
 > extends Row_CoreProperties<TFeatures, TData> {
+  /**
+   * Returns all of the cells for the row by column id.
+   */
   getAllCellsByColumnId: () => Record<string, Cell<TFeatures, TData, unknown>>
   /**
    * Returns all of the cells for the row.