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

package/src/core/cells/constructCell.ts

@@ -16,13 +16,19 @@ function getCellPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._cellPrototype) {
     table._cellPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignCellPrototype?.(table._cellPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignCellPrototype?.(table._cellPrototype, table)
     }
   }
   return table._cellPrototype
 }
 
+/**
+ * Constructs a cell instance from normalized table internals.
+ *
+ * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
+ */
 export function constructCell<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/cells/coreCellsFeature.ts

@@ -16,6 +16,11 @@ export interface CoreCellsFeatureConstructors<
   // TableOptions: TableOptions_Cell
 }
 
+/**
+ * Creates the stock core cells feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
 export function constructCoreCellsFeature<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/cells/coreCellsFeature.utils.ts

@@ -2,6 +2,16 @@ import type { CellData, RowData } from '../../types/type-utils'
 import type { TableFeatures } from '../../types/TableFeatures'
 import type { Cell } from '../../types/Cell'
 
+/**
+ * Returns value for a cell.
+ *
+ * This is the static implementation behind the matching cell instance API and uses the owning row and column context.
+ *
+ * @example
+ * ```ts
+ * const value = cell_getValue(cell)
+ * ```
+ */
 export function cell_getValue<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -10,6 +20,16 @@ export function cell_getValue<
   return cell.row.getValue(cell.column.id)
 }
 
+/**
+ * Returns value for a cell.
+ *
+ * This is the static implementation behind the matching cell instance API and uses the owning row and column context.
+ *
+ * @example
+ * ```ts
+ * const value = cell_renderValue(cell)
+ * ```
+ */
 export function cell_renderValue<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -18,6 +38,16 @@ export function cell_renderValue<
   return cell.getValue() ?? cell.table.options.renderFallbackValue
 }
 
+/**
+ * Returns context for a cell.
+ *
+ * This is the static implementation behind the matching cell instance API and uses the owning row and column context.
+ *
+ * @example
+ * ```ts
+ * const value = cell_getContext(cell)
+ * ```
+ */
 export function cell_getContext<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/columns/constructColumn.ts

@@ -20,13 +20,19 @@ function getColumnPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._columnPrototype) {
     table._columnPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignColumnPrototype?.(table._columnPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignColumnPrototype?.(table._columnPrototype, table)
     }
   }
   return table._columnPrototype
 }
 
+/**
+ * Constructs a column instance from normalized table internals.
+ *
+ * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
+ */
 export function constructColumn<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -60,10 +66,12 @@ export function constructColumn<
   } else if (accessorKey) {
     // Support deep accessor keys
     if (accessorKey.includes('.')) {
+      const keys = accessorKey.split('.')
       accessorFn = (originalRow: TData) => {
         let result = originalRow as Record<string, any> | undefined
 
-        for (const key of accessorKey.split('.')) {
+        for (let i = 0; i < keys.length; i++) {
+          const key = keys[i]!
           result = result?.[key]
           if (process.env.NODE_ENV === 'development' && result === undefined) {
             console.warn(

package/src/core/columns/coreColumnsFeature.ts

@@ -6,6 +6,7 @@ import {
   table_getAllFlatColumns,
   table_getAllFlatColumnsById,
   table_getAllLeafColumns,
+  table_getAllLeafColumnsById,
   table_getColumn,
   table_getDefaultColumnDef,
 } from './coreColumnsFeature.utils'
@@ -26,6 +27,11 @@ export interface CoreColumnsFeatureConstructors<
   // TableOptions: TableOptions_Columns<TFeatures, TData>
 }
 
+/**
+ * Creates the stock core columns feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
 export function constructCoreColumnsFeature<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -76,6 +82,10 @@ export function constructCoreColumnsFeature<
             table.options.groupedColumnMode,
           ],
         },
+        table_getAllLeafColumnsById: {
+          fn: () => table_getAllLeafColumnsById(table),
+          memoDeps: () => [table.getAllLeafColumns()],
+        },
         table_getColumn: {
           fn: (columnId) => table_getColumn(table, columnId),
         },

package/src/core/columns/coreColumnsFeature.types.ts

@@ -96,6 +96,10 @@ export interface Table_Columns<
    * Returns all leaf-node columns in the table flattened to a single level. This does not include parent columns.
    */
   getAllLeafColumns: () => Array<Column<TFeatures, TData, unknown>>
+  /**
+   * Returns a map of all leaf-node columns by their ID. This does not include parent columns.
+   */
+  getAllLeafColumnsById: () => Record<string, Column<TFeatures, TData, unknown>>
   /**
    * Returns a single column by its ID.
    */

package/src/core/columns/coreColumnsFeature.utils.ts

@@ -11,6 +11,16 @@ import type {
 } from '../../types/ColumnDef'
 import type { Column } from '../../types/Column'
 
+/**
+ * Returns flat columns for a column.
+ *
+ * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ *
+ * @example
+ * ```ts
+ * const value = column_getFlatColumns(column)
+ * ```
+ */
 export function column_getFlatColumns<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -21,6 +31,16 @@ export function column_getFlatColumns<
   return [column, ...column.columns.flatMap((col) => col.getFlatColumns())]
 }
 
+/**
+ * Returns leaf columns for a column.
+ *
+ * This derives the value from the column definition, table options, and the feature state atoms registered on the table.
+ *
+ * @example
+ * ```ts
+ * const value = column_getLeafColumns(column)
+ * ```
+ */
 export function column_getLeafColumns<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -43,6 +63,16 @@ export function column_getLeafColumns<
   return [column]
 }
 
+/**
+ * Returns default column def 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_getDefaultColumnDef(table)
+ * ```
+ */
 export function table_getDefaultColumnDef<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -72,6 +102,16 @@ export function table_getDefaultColumnDef<
   } as Partial<ColumnDef<TFeatures, TData, unknown>>
 }
 
+/**
+ * Returns all columns 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_getAllColumns(table)
+ * ```
+ */
 export function table_getAllColumns<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -103,6 +143,16 @@ export function table_getAllColumns<
   return recurseColumns(table.options.columns)
 }
 
+/**
+ * Returns all flat columns 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_getAllFlatColumns(table)
+ * ```
+ */
 export function table_getAllFlatColumns<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -112,21 +162,41 @@ export function table_getAllFlatColumns<
   return table.getAllColumns().flatMap((column) => column.getFlatColumns())
 }
 
+/**
+ * Returns all flat columns by id 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_getAllFlatColumnsById(table)
+ * ```
+ */
 export function table_getAllFlatColumnsById<
   TFeatures extends TableFeatures,
   TData extends RowData,
 >(
   table: Table_Internal<TFeatures, TData>,
 ): Record<string, Column<TFeatures, TData, unknown>> {
-  return table.getAllFlatColumns().reduce(
-    (acc, column) => {
-      acc[column.id] = column
-      return acc
-    },
-    {} as Record<string, Column<TFeatures, TData, unknown>>,
-  )
+  const result: Record<string, Column<TFeatures, TData, unknown>> = {}
+  const flatColumns = table.getAllFlatColumns()
+  for (let i = 0; i < flatColumns.length; i++) {
+    const column = flatColumns[i]!
+    result[column.id] = column
+  }
+  return result
 }
 
+/**
+ * Returns all leaf columns 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_getAllLeafColumns(table)
+ * ```
+ */
 export function table_getAllLeafColumns<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -140,9 +210,44 @@ export function table_getAllLeafColumns<
     table,
     'getOrderColumns',
     table_getOrderColumnsFn,
-  )(leafColumns as any) as any
+  )(leafColumns)
+}
+
+/**
+ * Returns all leaf columns by id 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_getAllLeafColumnsById(table)
+ * ```
+ */
+export function table_getAllLeafColumnsById<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+): Record<string, Column<TFeatures, TData, unknown>> {
+  const result: Record<string, Column<TFeatures, TData, unknown>> = {}
+  const leafColumns = table.getAllLeafColumns()
+  for (let i = 0; i < leafColumns.length; i++) {
+    const column = leafColumns[i]!
+    result[column.id] = column
+  }
+  return result
 }
 
+/**
+ * Returns column 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_getColumn(table)
+ * ```
+ */
 export function table_getColumn<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/coreFeatures.ts

@@ -16,6 +16,11 @@ export interface CoreFeatures {
   coreTablesFeature: typeof coreTablesFeature
 }
 
+/**
+ * The built-in core feature set required by every table.
+ *
+ * These features provide table, column, row, header, cell, and core row-model behavior before optional feature plugins are added.
+ */
 export const coreFeatures: CoreFeatures = {
   coreCellsFeature,
   coreColumnsFeature,

package/src/core/headers/buildHeaderGroups.ts

@@ -8,6 +8,11 @@ import type { Header } from '../../types/Header'
 import type { HeaderGroup } from '../../types/HeaderGroup'
 import type { Column } from '../../types/Column'
 
+/**
+ * Builds the nested header group structure for a table.
+ *
+ * The result accounts for visible leaf columns, pinned column groups, and placeholder headers needed to render multi-level headers.
+ */
 export function buildHeaderGroups<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -32,15 +37,14 @@ export function buildHeaderGroups<
   ) => {
     maxDepth = Math.max(maxDepth, depth)
 
-    columns
-      .filter((column) =>
-        callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible),
-      )
-      .forEach((column) => {
+    for (let i = 0; i < columns.length; i++) {
+      const column = columns[i]!
+      if (callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)) {
         if (column.columns.length) {
           findMaxDepth(column.columns, depth + 1)
         }
-      }, 0)
+      }
+    }
   }
 
   findMaxDepth(allColumns)
@@ -65,7 +69,8 @@ export function buildHeaderGroups<
     headersToGroup.forEach((headerToGroup) => {
       // What is the latest (last) parent column?
 
-      const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0]
+      const latestPendingParentHeader =
+        pendingParentHeaders[pendingParentHeaders.length - 1]
 
       const isLeafHeader = headerToGroup.column.depth === headerGroup.depth
 
@@ -130,43 +135,43 @@ export function buildHeaderGroups<
 
   headerGroups.reverse()
 
-  // headerGroups = headerGroups.filter(headerGroup => {
-  //   return !headerGroup.headers.every(header => header.isPlaceholder)
-  // })
-
   const recurseHeadersForSpans = (
     headers: Array<Header<TFeatures, TData, TValue>>,
   ): Array<{ colSpan: number; rowSpan: number }> => {
-    const filteredHeaders = headers.filter((header) =>
-      callMemoOrStaticFn(header.column, 'getIsVisible', column_getIsVisible),
-    )
+    const results: Array<{ colSpan: number; rowSpan: number }> = []
+
+    for (let i = 0; i < headers.length; i++) {
+      const header = headers[i]!
+      if (
+        !callMemoOrStaticFn(header.column, 'getIsVisible', column_getIsVisible)
+      ) {
+        continue
+      }
 
-    return filteredHeaders.map((header) => {
       let colSpan = 0
-      let rowSpan = 0
-      let childRowSpans = [0]
+      let minChildRowSpan = Infinity
 
       if (header.subHeaders.length) {
-        childRowSpans = []
-
-        recurseHeadersForSpans(header.subHeaders).forEach(
-          ({ colSpan: childColSpan, rowSpan: childRowSpan }) => {
-            colSpan += childColSpan
-            childRowSpans.push(childRowSpan)
-          },
-        )
+        const childSpans = recurseHeadersForSpans(header.subHeaders)
+        for (let j = 0; j < childSpans.length; j++) {
+          const child = childSpans[j]!
+          colSpan += child.colSpan
+          if (child.rowSpan < minChildRowSpan) {
+            minChildRowSpan = child.rowSpan
+          }
+        }
       } else {
         colSpan = 1
+        minChildRowSpan = 0
       }
 
-      const minChildRowSpan = Math.min(...childRowSpans)
-      rowSpan = rowSpan + minChildRowSpan
-
       header.colSpan = colSpan
-      header.rowSpan = rowSpan
+      header.rowSpan = minChildRowSpan
 
-      return { colSpan, rowSpan }
-    })
+      results.push({ colSpan, rowSpan: header.rowSpan })
+    }
+
+    return results
   }
 
   recurseHeadersForSpans(

package/src/core/headers/constructHeader.ts

@@ -15,13 +15,19 @@ function getHeaderPrototype<
 >(table: Table_Internal<TFeatures, TData>): object {
   if (!table._headerPrototype) {
     table._headerPrototype = { table }
-    for (const feature of Object.values(table._features)) {
-      feature.assignHeaderPrototype?.(table._headerPrototype, table)
+    const features = Object.values(table._features)
+    for (let i = 0; i < features.length; i++) {
+      features[i]!.assignHeaderPrototype?.(table._headerPrototype, table)
     }
   }
   return table._headerPrototype
 }
 
+/**
+ * Constructs a header instance from normalized table internals.
+ *
+ * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.
+ */
 export function constructHeader<
   TFeatures extends TableFeatures,
   TData extends RowData,

package/src/core/headers/coreHeadersFeature.ts

@@ -1,13 +1,4 @@
-import {
-  assignPrototypeAPIs,
-  assignTableAPIs,
-  callMemoOrStaticFn,
-} from '../../utils'
-import {
-  table_getCenterHeaderGroups,
-  table_getLeftHeaderGroups,
-  table_getRightHeaderGroups,
-} from '../../features/column-pinning/columnPinningFeature.utils'
+import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'
 import {
   header_getContext,
   header_getLeafHeaders,
@@ -28,6 +19,11 @@ export interface CoreHeadersFeatureConstructors<
   // Table: Table_Headers<TFeatures, TData>
 }
 
+/**
+ * Creates the stock core headers feature.
+ *
+ * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.
+ */
 export function constructCoreHeadersFeature<
   TFeatures extends TableFeatures,
   TData extends RowData,
@@ -69,23 +65,7 @@ export function constructCoreHeadersFeature<
         },
         table_getLeafHeaders: {
           fn: () => table_getLeafHeaders(table),
-          memoDeps: () => [
-            callMemoOrStaticFn(
-              table,
-              'getLeftHeaderGroups',
-              table_getLeftHeaderGroups,
-            ),
-            callMemoOrStaticFn(
-              table,
-              'getCenterHeaderGroups',
-              table_getCenterHeaderGroups,
-            ),
-            callMemoOrStaticFn(
-              table,
-              'getRightHeaderGroups',
-              table_getRightHeaderGroups,
-            ),
-          ],
+          memoDeps: () => [table.getHeaderGroups()],
         },
       })
     },