@tanstack/table-core 9.0.0-alpha.10 → 9.0.0-alpha.11

package/src/core/headers/constructHeader.ts

@@ -0,0 +1,61 @@
+import type { Table_Internal } from '../../types/Table'
+import type { CellData, RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Header } from '../../types/Header'
+import type { Column } from '../../types/Column'
+import type { Header_CoreProperties } from './coreHeadersFeature.types'
+
+/**
+ * Creates or retrieves the header prototype for a table.
+ * The prototype is cached on the table and shared by all header instances.
+ */
+function getHeaderPrototype<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(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)
+    }
+  }
+  return table._headerPrototype
+}
+
+export function constructHeader<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>(
+  table: Table_Internal<TFeatures, TData>,
+  column: Column<TFeatures, TData, TValue>,
+  options: {
+    id?: string
+    isPlaceholder?: boolean
+    placeholderId?: string
+    index: number
+    depth: number
+  },
+): Header<TFeatures, TData, TValue> {
+  // Create header with shared prototype for memory efficiency
+  const headerPrototype = getHeaderPrototype(table)
+  const header = Object.create(headerPrototype) as Header_CoreProperties<
+    TFeatures,
+    TData,
+    TValue
+  >
+
+  // Only assign instance-specific properties
+  header.colSpan = 0
+  header.column = column
+  header.depth = options.depth
+  header.headerGroup = null
+  header.id = options.id ?? column.id
+  header.index = options.index
+  header.isPlaceholder = !!options.isPlaceholder
+  header.placeholderId = options.placeholderId
+  header.rowSpan = 0
+  header.subHeaders = []
+
+  return header as Header<TFeatures, TData, TValue>
+}

package/src/core/headers/coreHeadersFeature.ts

@@ -0,0 +1,98 @@
+import {
+  assignPrototypeAPIs,
+  assignTableAPIs,
+  callMemoOrStaticFn,
+} from '../../utils'
+import {
+  table_getCenterHeaderGroups,
+  table_getLeftHeaderGroups,
+  table_getRightHeaderGroups,
+} from '../../features/column-pinning/columnPinningFeature.utils'
+import {
+  header_getContext,
+  header_getLeafHeaders,
+  table_getFlatHeaders,
+  table_getFooterGroups,
+  table_getHeaderGroups,
+  table_getLeafHeaders,
+} from './coreHeadersFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+// import type { Header_Header, Table_Headers } from './coreHeadersFeature.types'
+
+interface CoreHeadersFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  // Header: Header_Header<TFeatures, TData>
+  // Table: Table_Headers<TFeatures, TData>
+}
+
+export function constructCoreHeadersFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<CoreHeadersFeatureConstructors<TFeatures, TData>> {
+  return {
+    assignHeaderPrototype: (prototype, table) => {
+      assignPrototypeAPIs('coreHeadersFeature', prototype, table, {
+        header_getLeafHeaders: {
+          fn: (header) => header_getLeafHeaders(header),
+          memoDeps: (header) => [header.column.table.options.columns],
+        },
+        header_getContext: {
+          fn: (header) => header_getContext(header),
+          memoDeps: (header) => [header.column.table.options.columns],
+        },
+      })
+    },
+
+    constructTableAPIs: (table) => {
+      assignTableAPIs('coreHeadersFeature', table, {
+        table_getHeaderGroups: {
+          fn: () => table_getHeaderGroups(table),
+          memoDeps: () => [
+            table.options.columns,
+            table.store.state.columnOrder,
+            table.store.state.grouping,
+            table.store.state.columnPinning,
+            table.store.state.columnVisibility,
+            table.options.groupedColumnMode,
+          ],
+        },
+        table_getFooterGroups: {
+          fn: () => table_getFooterGroups(table),
+          memoDeps: () => [table.getHeaderGroups()],
+        },
+        table_getFlatHeaders: {
+          fn: () => table_getFlatHeaders(table),
+          memoDeps: () => [table.getHeaderGroups()],
+        },
+        table_getLeafHeaders: {
+          fn: () => table_getLeafHeaders(table),
+          memoDeps: () => [
+            callMemoOrStaticFn(
+              table,
+              'getLeftHeaderGroups',
+              table_getLeftHeaderGroups,
+            ),
+            callMemoOrStaticFn(
+              table,
+              'getCenterHeaderGroups',
+              table_getCenterHeaderGroups,
+            ),
+            callMemoOrStaticFn(
+              table,
+              'getRightHeaderGroups',
+              table_getRightHeaderGroups,
+            ),
+          ],
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The Core Headers feature provides the core header functionality.
+ */
+export const coreHeadersFeature = constructCoreHeadersFeature()

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

@@ -0,0 +1,123 @@
+import type { CellData, RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Table } from '../../types/Table'
+import type { Header } from '../../types/Header'
+import type { HeaderGroup } from '../../types/HeaderGroup'
+import type { Column } from '../../types/Column'
+
+export interface Table_Headers<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns all header groups for the table.
+   */
+  getHeaderGroups: () => Array<HeaderGroup<TFeatures, TData>>
+  /**
+   * Returns the footer groups for the table.
+   */
+  getFooterGroups: () => Array<HeaderGroup<TFeatures, TData>>
+  /**
+   * Returns headers for all columns in the table, including parent headers.
+   */
+  getFlatHeaders: () => Array<Header<TFeatures, TData, unknown>>
+  /**
+   * Returns headers for all leaf columns in the table, (not including parent headers).
+   */
+  getLeafHeaders: () => Array<Header<TFeatures, TData, unknown>>
+}
+
+export interface HeaderContext<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> {
+  /**
+   * An instance of a column.
+   */
+  column: Column<TFeatures, TData, TValue>
+  /**
+   * An instance of a header.
+   */
+  header: Header<TFeatures, TData, TValue>
+  /**
+   * The table instance.
+   */
+  table: Table<TFeatures, TData>
+}
+
+export interface Header_CoreProperties<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> {
+  /**
+   * The col-span for the header.
+   */
+  colSpan: number
+  /**
+   * The header's associated column object.
+   */
+  column: Column<TFeatures, TData, TValue>
+  /**
+   * The depth of the header, zero-indexed based.
+   */
+  depth: number
+  /**
+   * The header's associated header group object.
+   */
+  headerGroup: HeaderGroup<TFeatures, TData> | null
+  /**
+   * The unique identifier for the header.
+   */
+  id: string
+  /**
+   * The index for the header within the header group.
+   */
+  index: number
+  /**
+   * A boolean denoting if the header is a placeholder header.
+   */
+  isPlaceholder: boolean
+  /**
+   * If the header is a placeholder header, this will be a unique header ID that does not conflict with any other headers across the table.
+   */
+  placeholderId?: string
+  /**
+   * The row-span for the header.
+   */
+  rowSpan: number
+  /**
+   * The header's hierarchical sub/child headers. Will be empty if the header's associated column is a leaf-column.
+   */
+  subHeaders: Array<Header<TFeatures, TData, TValue>>
+  /**
+   * Reference to the parent table instance.
+   */
+  table: Table<TFeatures, TData>
+}
+
+export interface Header_Header<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> extends Header_CoreProperties<TFeatures, TData, TValue> {
+  /**
+   * Returns the rendering context (or props) for column-based components like headers, footers and filters.
+   */
+  getContext: () => HeaderContext<TFeatures, TData, TValue>
+  /**
+   * Returns the leaf headers hierarchically nested under this header.
+   */
+  getLeafHeaders: () => Array<Header<TFeatures, TData, TValue>>
+}
+
+export interface HeaderGroup_Header<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+> {
+  depth: number
+  headers: Array<Header<TFeatures, TData, TValue>>
+  id: string
+}

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

@@ -0,0 +1,131 @@
+import {
+  getDefaultColumnPinningState,
+  table_getCenterHeaderGroups,
+  table_getLeftHeaderGroups,
+  table_getRightHeaderGroups,
+} from '../../features/column-pinning/columnPinningFeature.utils'
+import { table_getVisibleLeafColumns } from '../../features/column-visibility/columnVisibilityFeature.utils'
+import { callMemoOrStaticFn } from '../../utils'
+import { buildHeaderGroups } from './buildHeaderGroups'
+import type { Table_Internal } from '../../types/Table'
+import type { Header } from '../../types/Header'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { Header_Header } from './coreHeadersFeature.types'
+import type { Column } from '../../types/Column'
+
+export function header_getLeafHeaders<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue,
+>(header: Header<TFeatures, TData, TValue>) {
+  const leafHeaders: Array<Header<TFeatures, TData, TValue>> = []
+
+  const recurseHeader = (h: Header_Header<TFeatures, TData, TValue>) => {
+    if (h.subHeaders.length) {
+      h.subHeaders.map(recurseHeader)
+    }
+    leafHeaders.push(h as Header<TFeatures, TData, TValue>)
+  }
+
+  recurseHeader(header)
+
+  return leafHeaders
+}
+
+export function header_getContext<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue,
+>(header: Header<TFeatures, TData, TValue>) {
+  return {
+    column: header.column,
+    header,
+    table: header.column.table,
+  }
+}
+
+export function table_getHeaderGroups<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  const { left, right } =
+    table.store.state.columnPinning ?? getDefaultColumnPinningState()
+  const allColumns = table.getAllColumns()
+  const leafColumns = callMemoOrStaticFn(
+    table,
+    'getVisibleLeafColumns',
+    table_getVisibleLeafColumns,
+  ) as unknown as Array<Column<TFeatures, TData, unknown>>
+
+  const leftColumns = left
+    .map((columnId) => leafColumns.find((d) => d.id === columnId)!)
+    .filter(Boolean)
+
+  const rightColumns = right
+    .map((columnId) => leafColumns.find((d) => d.id === columnId)!)
+    .filter(Boolean)
+
+  const centerColumns = leafColumns.filter(
+    (column) => !left.includes(column.id) && !right.includes(column.id),
+  )
+
+  const headerGroups = buildHeaderGroups(
+    allColumns,
+    [...leftColumns, ...centerColumns, ...rightColumns],
+    table,
+  )
+
+  return headerGroups
+}
+
+export function table_getFooterGroups<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>) {
+  const headerGroups = table.getHeaderGroups()
+  return [...headerGroups].reverse()
+}
+
+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()
+}
+
+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()
+}

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

@@ -0,0 +1,78 @@
+import { assignTableAPIs } from '../../utils'
+import {
+  table_getCoreRowModel,
+  table_getExpandedRowModel,
+  table_getFilteredRowModel,
+  table_getGroupedRowModel,
+  table_getPaginatedRowModel,
+  table_getPreExpandedRowModel,
+  table_getPreFilteredRowModel,
+  table_getPreGroupedRowModel,
+  table_getPrePaginatedRowModel,
+  table_getPreSortedRowModel,
+  table_getRowModel,
+  table_getSortedRowModel,
+} from './coreRowModelsFeature.utils'
+import type { RowData } from '../../types/type-utils'
+import type { TableFeature, TableFeatures } from '../../types/TableFeatures'
+// import type { Table_RowModels } from './coreRowModelsFeature.types'
+
+interface CoreRowModelsFeatureConstructors<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  // Table: Table_RowModels<TFeatures, TData>
+}
+
+export function constructCoreRowModelsFeature<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {
+  return {
+    constructTableAPIs: (table) => {
+      assignTableAPIs('coreRowModelsFeature', table, {
+        table_getCoreRowModel: {
+          fn: () => table_getCoreRowModel(table),
+        },
+        table_getPreFilteredRowModel: {
+          fn: () => table_getPreFilteredRowModel(table),
+        },
+        table_getFilteredRowModel: {
+          fn: () => table_getFilteredRowModel(table),
+        },
+        table_getPreGroupedRowModel: {
+          fn: () => table_getPreGroupedRowModel(table),
+        },
+        table_getGroupedRowModel: {
+          fn: () => table_getGroupedRowModel(table),
+        },
+        table_getPreSortedRowModel: {
+          fn: () => table_getPreSortedRowModel(table),
+        },
+        table_getSortedRowModel: {
+          fn: () => table_getSortedRowModel(table),
+        },
+        table_getPreExpandedRowModel: {
+          fn: () => table_getPreExpandedRowModel(table),
+        },
+        table_getExpandedRowModel: {
+          fn: () => table_getExpandedRowModel(table),
+        },
+        table_getPrePaginatedRowModel: {
+          fn: () => table_getPrePaginatedRowModel(table),
+        },
+        table_getPaginatedRowModel: {
+          fn: () => table_getPaginatedRowModel(table),
+        },
+        table_getRowModel: {
+          fn: () => table_getRowModel(table),
+        },
+      })
+    },
+  }
+}
+
+/**
+ * The Core Row Models feature provides the core row model functionality.
+ */
+export const coreRowModelsFeature = constructCoreRowModelsFeature()

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

@@ -0,0 +1,67 @@
+import type { Table } from '../../types/Table'
+import type { Table_RowModels_Faceted } from '../../features/column-faceting/columnFacetingFeature.types'
+import type { Table_RowModels_Filtered } from '../../features/column-filtering/columnFilteringFeature.types'
+import type { Table_RowModels_Grouped } from '../../features/column-grouping/columnGroupingFeature.types'
+import type { Table_RowModels_Expanded } from '../../features/row-expanding/rowExpandingFeature.types'
+import type { Table_RowModels_Paginated } from '../../features/row-pagination/rowPaginationFeature.types'
+import type { Table_RowModels_Sorted } from '../../features/row-sorting/rowSortingFeature.types'
+import type { Row } from '../../types/Row'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+
+export interface RowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  rows: Array<Row<TFeatures, TData>>
+  flatRows: Array<Row<TFeatures, TData>>
+  rowsById: Record<string, Row<TFeatures, TData>>
+}
+
+export interface CreateRowModel_Plugins {}
+
+export interface CreateRowModel_Core<
+  TFeatures extends TableFeatures,
+  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.
+   */
+  coreRowModel?: (
+    table: Table<TFeatures, TData>,
+  ) => () => RowModel<TFeatures, TData>
+}
+
+export interface CachedRowModel_Plugins {}
+
+export interface CachedRowModel_Core<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> extends CachedRowModel_Plugins {
+  coreRowModel: () => RowModel<TFeatures, TData>
+}
+
+export interface Table_RowModels_Core<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  /**
+   * Returns the core row model before any processing has been applied.
+   */
+  getCoreRowModel: () => RowModel<TFeatures, TData>
+  /**
+   * Returns the final model after all processing from other used features has been applied. This is the row model that is most commonly used for rendering.
+   */
+  getRowModel: () => RowModel<TFeatures, TData>
+}
+
+export type Table_RowModels<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Table_RowModels_Core<TFeatures, TData> &
+  Table_RowModels_Faceted<TFeatures, TData> &
+  Table_RowModels_Filtered<TFeatures, TData> &
+  Table_RowModels_Grouped<TFeatures, TData> &
+  Table_RowModels_Expanded<TFeatures, TData> &
+  Table_RowModels_Paginated<TFeatures, TData> &
+  Table_RowModels_Sorted<TFeatures, TData>

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

@@ -0,0 +1,140 @@
+import { createCoreRowModel } from './createCoreRowModel'
+import type { Table_Internal } from '../../types/Table'
+import type { TableFeatures } from '../../types/TableFeatures'
+import type { RowData } from '../../types/type-utils'
+import type { RowModel } from './coreRowModelsFeature.types'
+
+export function table_getCoreRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.coreRowModel) {
+    table._rowModels.coreRowModel =
+      table.options._rowModels?.coreRowModel?.(table) ??
+      createCoreRowModel<TFeatures, TData>()(table)
+  }
+
+  return table._rowModels.coreRowModel()
+}
+
+export function table_getPreFilteredRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getCoreRowModel()
+}
+
+export function table_getFilteredRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.filteredRowModel) {
+    table._rowModels.filteredRowModel =
+      table.options._rowModels?.filteredRowModel?.(table)
+  }
+
+  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {
+    return table.getPreFilteredRowModel()
+  }
+
+  return table._rowModels.filteredRowModel()
+}
+
+export function table_getPreGroupedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getFilteredRowModel()
+}
+
+export function table_getGroupedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.groupedRowModel) {
+    table._rowModels.groupedRowModel =
+      table.options._rowModels?.groupedRowModel?.(table)
+  }
+
+  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {
+    return table.getPreGroupedRowModel()
+  }
+
+  return table._rowModels.groupedRowModel()
+}
+
+export function table_getPreSortedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getGroupedRowModel()
+}
+
+export function table_getSortedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.sortedRowModel) {
+    table._rowModels.sortedRowModel =
+      table.options._rowModels?.sortedRowModel?.(table)
+  }
+
+  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {
+    return table.getPreSortedRowModel()
+  }
+
+  return table._rowModels.sortedRowModel()
+}
+
+export function table_getPreExpandedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getSortedRowModel()
+}
+
+export function table_getExpandedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.expandedRowModel) {
+    table._rowModels.expandedRowModel =
+      table.options._rowModels?.expandedRowModel?.(table)
+  }
+
+  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {
+    return table.getPreExpandedRowModel()
+  }
+
+  return table._rowModels.expandedRowModel()
+}
+
+export function table_getPrePaginatedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getExpandedRowModel()
+}
+
+export function table_getPaginatedRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  if (!table._rowModels.paginatedRowModel) {
+    table._rowModels.paginatedRowModel =
+      table.options._rowModels?.paginatedRowModel?.(table)
+  }
+
+  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {
+    return table.getPrePaginatedRowModel()
+  }
+
+  return table._rowModels.paginatedRowModel()
+}
+
+export function table_getRowModel<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
+  return table.getPaginatedRowModel()
+}