@tanstack/table-core 9.0.0-beta.52 → 9.0.0-beta.53

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

@@ -1,44 +0,0 @@
-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>,
-): Store<T> | ReadonlyStore<T> {
-  const store: Store<T> = atom as Store<T>
-  Object.defineProperty(atom, 'state', {
-    get() {
-      return atom.get()
-    },
-  })
-  if ('set' in atom) {
-    store.setState = atom.set.bind(atom)
-  }
-  return store
-}

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

@@ -1,62 +0,0 @@
-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 { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Core feature that wires table row-model accessors and row-model caches.
- */
-export const coreRowModelsFeature: TableFeature = {
-  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),
-      },
-    })
-  },
-}

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

@@ -1,50 +0,0 @@
-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<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  rows: Array<Row<TFeatures, TData>>
-  flatRows: Array<Row<TFeatures, TData>>
-  rowsById: Record<string, Row<TFeatures, TData>>
-}
-
-export interface CachedRowModel_Core<
-  in out TFeatures extends TableFeatures,
-  in out TData extends RowData,
-> {
-  coreRowModel: () => RowModel<TFeatures, TData>
-}
-
-export interface Table_RowModels_Core<
-  in out TFeatures extends TableFeatures,
-  in out 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

@@ -1,272 +0,0 @@
-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'
-
-/**
- * Resolves the table's unmodified core row model.
- *
- * The factory is created once per table, either from the `coreRowModel` slot on the `features` option
- * or the built-in `createCoreRowModel()`, then reused for later calls.
- *
- * @example
- * ```ts
- * const coreRows = table_getCoreRowModel(table)
- * ```
- */
-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.features.coreRowModel?.(table) ??
-      createCoreRowModel<TFeatures, TData>()(table)
-  }
-
-  return table._rowModels.coreRowModel()
-}
-
-/**
- * Reads the row model immediately before column/global filtering.
- *
- * Filtering is the first derived row-model stage, so this currently aliases
- * `table.getCoreRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)
- * ```
- */
-export function table_getPreFilteredRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getCoreRowModel()
-}
-
-/**
- * Resolves the row model after column and global filtering.
- *
- * When `manualFiltering` is enabled, or no filtered row-model factory was
- * registered, this returns the pre-filtered row model because filtering is
- * expected to happen outside the table.
- *
- * @example
- * ```ts
- * const filteredRows = table_getFilteredRowModel(table)
- * ```
- */
-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.features.filteredRowModel?.(table)
-  }
-
-  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {
-    return table.getPreFilteredRowModel()
-  }
-
-  return table._rowModels.filteredRowModel()
-}
-
-/**
- * Reads the row model immediately before grouping.
- *
- * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)
- * ```
- */
-export function table_getPreGroupedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getFilteredRowModel()
-}
-
-/**
- * Resolves the row model after grouping has produced grouped rows.
- *
- * When `manualGrouping` is enabled, or no grouped row-model factory was
- * registered, this returns the pre-grouped row model unchanged.
- *
- * @example
- * ```ts
- * const groupedRows = table_getGroupedRowModel(table)
- * ```
- */
-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.features.groupedRowModel?.(table)
-  }
-
-  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {
-    return table.getPreGroupedRowModel()
-  }
-
-  return table._rowModels.groupedRowModel()
-}
-
-/**
- * Reads the row model immediately before sorting.
- *
- * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeSorting = table_getPreSortedRowModel(table)
- * ```
- */
-export function table_getPreSortedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getGroupedRowModel()
-}
-
-/**
- * Resolves the row model after sorting has been applied.
- *
- * When `manualSorting` is enabled, or no sorted row-model factory was
- * registered, this returns the pre-sorted row model because sorted data is
- * expected to be supplied by the caller.
- *
- * @example
- * ```ts
- * const sortedRows = table_getSortedRowModel(table)
- * ```
- */
-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.features.sortedRowModel?.(table)
-  }
-
-  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {
-    return table.getPreSortedRowModel()
-  }
-
-  return table._rowModels.sortedRowModel()
-}
-
-/**
- * Reads the row model immediately before row expansion.
- *
- * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)
- * ```
- */
-export function table_getPreExpandedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getSortedRowModel()
-}
-
-/**
- * Resolves the row model after expanded rows have been flattened into view.
- *
- * When `manualExpanding` is enabled, or no expanded row-model factory was
- * registered, this returns the pre-expanded row model unchanged.
- *
- * @example
- * ```ts
- * const expandedRows = table_getExpandedRowModel(table)
- * ```
- */
-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.features.expandedRowModel?.(table)
-  }
-
-  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {
-    return table.getPreExpandedRowModel()
-  }
-
-  return table._rowModels.expandedRowModel()
-}
-
-/**
- * Reads the row model immediately before pagination.
- *
- * Pagination is the final built-in row-model stage, so this aliases
- * `table.getExpandedRowModel()`.
- *
- * @example
- * ```ts
- * const rowsBeforePagination = table_getPrePaginatedRowModel(table)
- * ```
- */
-export function table_getPrePaginatedRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getExpandedRowModel()
-}
-
-/**
- * Resolves the row model after pagination has sliced rows for the current page.
- *
- * When `manualPagination` is enabled, or no paginated row-model factory was
- * registered, this returns the pre-paginated row model because pagination is
- * expected to happen before data reaches the table.
- *
- * @example
- * ```ts
- * const pageRows = table_getPaginatedRowModel(table)
- * ```
- */
-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.features.paginatedRowModel?.(table)
-  }
-
-  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {
-    return table.getPrePaginatedRowModel()
-  }
-
-  return table._rowModels.paginatedRowModel()
-}
-
-/**
- * Resolves the final row model consumed by renderers.
- *
- * This is the end of the built-in row-model pipeline: core -> filtering ->
- * grouping -> sorting -> expanding -> pagination.
- *
- * @example
- * ```ts
- * const visibleRows = table_getRowModel(table)
- * ```
- */
-export function table_getRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {
-  return table.getPaginatedRowModel()
-}

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

@@ -1,94 +0,0 @@
-import { constructRow } from '../rows/constructRow'
-import { makeObjectMap, tableMemo } from '../../utils'
-import { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'
-import type { Table_Internal } from '../../types/Table'
-import type { RowModel } from './coreRowModelsFeature.types'
-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,
->(): (
-  table: Table_Internal<TFeatures, TData>,
-) => () => RowModel<TFeatures, TData> {
-  return (table) => {
-    return tableMemo({
-      feature: 'coreRowModelsFeature',
-      table,
-      fnName: 'table.getCoreRowModel',
-      memoDeps: () => [table.options.data],
-      fn: () => _createCoreRowModel(table, table.options.data),
-      onAfterUpdate: () => table_autoResetPageIndex(table),
-    })
-  }
-}
-
-function _createCoreRowModel<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  table: Table_Internal<TFeatures, TData>,
-  data: ReadonlyArray<TData>,
-): {
-  rows: Array<Row<TFeatures, TData>>
-  flatRows: Array<Row<TFeatures, TData>>
-  rowsById: Record<string, Row<TFeatures, TData>>
-} {
-  const rowModel: RowModel<TFeatures, TData> = {
-    rows: [],
-    flatRows: [],
-    rowsById: makeObjectMap(),
-  }
-
-  const accessRows = (
-    originalRows: ReadonlyArray<TData>,
-    depth = 0,
-    parentRow?: Row<TFeatures, TData>,
-  ): Array<Row<TFeatures, TData>> => {
-    const rows = [] as Array<Row<TFeatures, TData>>
-
-    for (let i = 0; i < originalRows.length; i++) {
-      const originalRow = originalRows[i]!
-      // Make the row
-      const row = constructRow(
-        table,
-        table.getRowId(originalRow, i, parentRow),
-        originalRow,
-        i,
-        depth,
-        undefined,
-        parentRow?.id,
-      )
-
-      // Keep track of every row in a flat array
-      rowModel.flatRows.push(row)
-      // Also keep track of every row by its ID
-      rowModel.rowsById[row.id] = row
-      // Push table row into parent
-      rows.push(row)
-
-      // Get the original subrows
-      if (table.options.getSubRows) {
-        row.originalSubRows = table.options.getSubRows(originalRow, i)
-
-        // Then recursively access them
-        if (row.originalSubRows?.length) {
-          row.subRows = accessRows(row.originalSubRows, depth + 1, row)
-        }
-      }
-    }
-
-    return rows
-  }
-
-  rowModel.rows = accessRows(data)
-
-  return rowModel
-}

package/src/core/rows/constructRow.ts

@@ -1,68 +0,0 @@
-import { makeObjectMap } from '../../utils'
-import type { Table_Internal } from '../../types/Table'
-import type { RowData } from '../../types/type-utils'
-import type { TableFeatures } from '../../types/TableFeatures'
-import type { Row } from '../../types/Row'
-import type { Row_CoreProperties } from './coreRowsFeature.types'
-
-/**
- * Creates or retrieves the row prototype for a table.
- * The prototype is cached on the table and shared by all row instances.
- */
-function getRowPrototype<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(table: Table_Internal<TFeatures, TData>): object {
-  if (!table._rowPrototype) {
-    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,
->(
-  table: Table_Internal<TFeatures, TData>,
-  id: string,
-  original: TData,
-  rowIndex: number,
-  depth: number,
-  subRows?: Array<Row<TFeatures, TData>>,
-  parentId?: string,
-): Row<TFeatures, TData> => {
-  // Create row with shared prototype for memory efficiency
-  const rowPrototype = getRowPrototype(table)
-  const row = Object.create(rowPrototype) as Row_CoreProperties<
-    TFeatures,
-    TData
-  >
-
-  // Only assign instance-specific properties
-  row._displayIndexCache = -1
-  row._uniqueValuesCache = makeObjectMap()
-  row._valuesCache = makeObjectMap()
-  row.depth = depth
-  row.id = id
-  row.index = rowIndex
-  row.original = original
-  row.parentId = parentId
-  row.subRows = subRows ?? []
-
-  // Initialize instance-specific data (e.g., caches) for features that need it
-  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

@@ -1,83 +0,0 @@
-import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'
-import {
-  row_getAllCells,
-  row_getAllCellsByColumnId,
-  row_getDisplayIndex,
-  row_getLeafRows,
-  row_getParentRow,
-  row_getParentRows,
-  row_getUniqueValues,
-  row_getValue,
-  row_renderValue,
-  table_getMaxSubRowDepth,
-  table_getRow,
-  table_getRowId,
-  table_getRowsInDisplayOrder,
-} from './coreRowsFeature.utils'
-import type { TableFeature } from '../../types/TableFeatures'
-
-/**
- * Core feature that creates row APIs for values, cells, and tree traversal.
- */
-export const coreRowsFeature: TableFeature = {
-  assignRowPrototype: (prototype, table) => {
-    assignPrototypeAPIs('coreRowsFeature', prototype, table, {
-      row_getDisplayIndex: {
-        fn: (row) => row_getDisplayIndex(row),
-      },
-      row_getAllCellsByColumnId: {
-        fn: (row) => row_getAllCellsByColumnId(row),
-        memoDeps: (row) => [row.getAllCells()],
-      },
-      row_getAllCells: {
-        fn: (row) => row_getAllCells(row),
-        memoDeps: (row) => [row.table.getAllLeafColumns()],
-      },
-      row_getLeafRows: {
-        fn: (row) => row_getLeafRows(row),
-        memoDeps: (row) => [row.subRows],
-      },
-      row_getParentRow: {
-        fn: (row) => row_getParentRow(row),
-      },
-      row_getParentRows: {
-        fn: (row) => row_getParentRows(row),
-      },
-      row_getUniqueValues: {
-        fn: (row, columnId) => row_getUniqueValues(row, columnId),
-      },
-      row_getValue: {
-        fn: (row, columnId) => row_getValue(row, columnId),
-      },
-      row_renderValue: {
-        fn: (row, columnId) => row_renderValue(row, columnId),
-      },
-    })
-  },
-  constructTableAPIs: (table) => {
-    assignTableAPIs('coreRowsFeature', table, {
-      table_getRowsInDisplayOrder: {
-        fn: () => table_getRowsInDisplayOrder(table),
-        memoDeps: () => [
-          table.getPrePaginatedRowModel().rows,
-          table.options.paginateExpandedRows,
-          table.options.paginateExpandedRows === false
-            ? table.atoms.expanded?.get()
-            : undefined,
-        ],
-      },
-      table_getRowId: {
-        fn: (originalRow, index, parent) =>
-          table_getRowId(originalRow, table, index, parent),
-      },
-      table_getRow: {
-        fn: (id: string, searchAll?: boolean) =>
-          table_getRow(table, id, searchAll),
-      },
-      table_getMaxSubRowDepth: {
-        fn: () => table_getMaxSubRowDepth(table),
-        memoDeps: () => [table.getCoreRowModel()],
-      },
-    })
-  },
-}