@tanstack/table-core 9.0.0-alpha.6 → 9.0.0-beta.1

package/src/sortingFns.ts

@@ -1,128 +0,0 @@
-import { SortingFn } from './features/RowSorting'
-
-export const reSplitAlphaNumeric = /([0-9]+)/gm
-
-const alphanumeric: SortingFn<any> = (rowA, rowB, columnId) => {
-  return compareAlphanumeric(
-    toString(rowA.getValue(columnId)).toLowerCase(),
-    toString(rowB.getValue(columnId)).toLowerCase()
-  )
-}
-
-const alphanumericCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {
-  return compareAlphanumeric(
-    toString(rowA.getValue(columnId)),
-    toString(rowB.getValue(columnId))
-  )
-}
-
-// The text filter is more basic (less numeric support)
-// but is much faster
-const text: SortingFn<any> = (rowA, rowB, columnId) => {
-  return compareBasic(
-    toString(rowA.getValue(columnId)).toLowerCase(),
-    toString(rowB.getValue(columnId)).toLowerCase()
-  )
-}
-
-// The text filter is more basic (less numeric support)
-// but is much faster
-const textCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {
-  return compareBasic(
-    toString(rowA.getValue(columnId)),
-    toString(rowB.getValue(columnId))
-  )
-}
-
-const datetime: SortingFn<any> = (rowA, rowB, columnId) => {
-  const a = rowA.getValue<Date>(columnId)
-  const b = rowB.getValue<Date>(columnId)
-
-  // Can handle nullish values
-  // Use > and < because == (and ===) doesn't work with
-  // Date objects (would require calling getTime()).
-  return a > b ? 1 : a < b ? -1 : 0
-}
-
-const basic: SortingFn<any> = (rowA, rowB, columnId) => {
-  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))
-}
-
-// Utils
-
-function compareBasic(a: any, b: any) {
-  return a === b ? 0 : a > b ? 1 : -1
-}
-
-function toString(a: any) {
-  if (typeof a === 'number') {
-    if (isNaN(a) || a === Infinity || a === -Infinity) {
-      return ''
-    }
-    return String(a)
-  }
-  if (typeof a === 'string') {
-    return a
-  }
-  return ''
-}
-
-// Mixed sorting is slow, but very inclusive of many edge cases.
-// It handles numbers, mixed alphanumeric combinations, and even
-// null, undefined, and Infinity
-function compareAlphanumeric(aStr: string, bStr: string) {
-  // Split on number groups, but keep the delimiter
-  // Then remove falsey split values
-  const a = aStr.split(reSplitAlphaNumeric).filter(Boolean)
-  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean)
-
-  // While
-  while (a.length && b.length) {
-    const aa = a.shift()!
-    const bb = b.shift()!
-
-    const an = parseInt(aa, 10)
-    const bn = parseInt(bb, 10)
-
-    const combo = [an, bn].sort()
-
-    // Both are string
-    if (isNaN(combo[0]!)) {
-      if (aa > bb) {
-        return 1
-      }
-      if (bb > aa) {
-        return -1
-      }
-      continue
-    }
-
-    // One is a string, one is a number
-    if (isNaN(combo[1]!)) {
-      return isNaN(an) ? -1 : 1
-    }
-
-    // Both are numbers
-    if (an > bn) {
-      return 1
-    }
-    if (bn > an) {
-      return -1
-    }
-  }
-
-  return a.length - b.length
-}
-
-// Exports
-
-export const sortingFns = {
-  alphanumeric,
-  alphanumericCaseSensitive,
-  text,
-  textCaseSensitive,
-  datetime,
-  basic,
-}
-
-export type BuiltInSortingFn = keyof typeof sortingFns

package/src/types.ts

@@ -1,361 +0,0 @@
-import { CoreOptions, CoreTableState, CoreInstance } from './core/table'
-import {
-  VisibilityInstance,
-  VisibilityTableState,
-  VisibilityColumn as ColumnVisibilityColumn,
-  VisibilityOptions,
-  VisibilityColumnDef,
-  VisibilityRow,
-} from './features/ColumnVisibility'
-import {
-  ColumnOrderColumn,
-  ColumnOrderInstance,
-  ColumnOrderOptions,
-  ColumnOrderTableState,
-} from './features/ColumnOrdering'
-import {
-  ColumnPinningColumn,
-  ColumnPinningColumnDef,
-  ColumnPinningInstance,
-  ColumnPinningOptions,
-  ColumnPinningRow,
-  ColumnPinningTableState,
-} from './features/ColumnPinning'
-import {
-  RowPinningInstance,
-  RowPinningOptions,
-  RowPinningRow,
-  RowPinningTableState,
-} from './features/RowPinning'
-import {
-  CoreHeader,
-  CoreHeaderGroup,
-  HeaderContext,
-  HeadersInstance,
-} from './core/headers'
-import { FacetedColumn, FacetedOptions } from './features/ColumnFaceting'
-import { GlobalFacetingInstance } from './features/GlobalFaceting'
-import {
-  ColumnFiltersColumn,
-  ColumnFiltersColumnDef,
-  ColumnFiltersInstance,
-  ColumnFiltersOptions,
-  ColumnFiltersRow,
-  ColumnFiltersTableState,
-} from './features/ColumnFiltering'
-import {
-  GlobalFilterColumn,
-  GlobalFilterColumnDef,
-  GlobalFilterInstance,
-  GlobalFilterOptions,
-  GlobalFilterTableState,
-} from './features/GlobalFiltering'
-import {
-  SortingColumn,
-  SortingColumnDef,
-  SortingInstance,
-  SortingOptions,
-  SortingTableState,
-} from './features/RowSorting'
-import {
-  GroupingCell,
-  GroupingColumn,
-  GroupingColumnDef,
-  GroupingInstance,
-  GroupingOptions,
-  GroupingRow,
-  GroupingTableState,
-} from './features/ColumnGrouping'
-import {
-  ExpandedInstance,
-  ExpandedOptions,
-  ExpandedTableState,
-  ExpandedRow,
-} from './features/RowExpanding'
-import {
-  ColumnSizingColumn,
-  ColumnSizingColumnDef,
-  ColumnSizingHeader,
-  ColumnSizingInstance,
-  ColumnSizingOptions,
-  ColumnSizingTableState,
-} from './features/ColumnSizing'
-import {
-  PaginationInitialTableState,
-  PaginationInstance,
-  PaginationOptions,
-  PaginationTableState,
-} from './features/RowPagination'
-import {
-  RowSelectionInstance,
-  RowSelectionOptions,
-  RowSelectionRow,
-  RowSelectionTableState,
-} from './features/RowSelection'
-import { CoreRow } from './core/row'
-import { PartialKeys, UnionToIntersection } from './utils'
-import { CellContext, CoreCell } from './core/cell'
-import { CoreColumn } from './core/column'
-
-export interface TableFeature<TData extends RowData = any> {
-  _createCell?: (
-    cell: Cell<TData, unknown>,
-    column: Column<TData>,
-    row: Row<TData>,
-    table: Table<TData>
-  ) => void
-  _createColumn?: (column: Column<TData, unknown>, table: Table<TData>) => void
-  _createHeader?: (header: Header<TData, unknown>, table: Table<TData>) => void
-  _createRow?: (row: Row<TData>, table: Table<TData>) => void
-  _createTable?: (table: Table<TData>) => void
-  _getDefaultColumnDef?: () => Partial<ColumnDef<TData, unknown>>
-  _getDefaultOptions?: (
-    table: Table<TData>
-  ) => Partial<TableOptionsResolved<TData>>
-  _getInitialState?: (initialState?: InitialTableState) => Partial<TableState>
-}
-
-export interface TableMeta<TData extends RowData> {}
-
-export interface ColumnMeta<TData extends RowData, TValue> {}
-
-export interface FilterMeta {}
-
-export interface FilterFns {}
-
-export interface SortingFns {}
-
-export interface AggregationFns {}
-
-export type Updater<T> = T | ((old: T) => T)
-export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void
-
-export type RowData = unknown | object | any[]
-
-export type AnyRender = (Comp: any, props: any) => any
-
-export interface Table<TData extends RowData>
-  extends CoreInstance<TData>,
-    HeadersInstance<TData>,
-    VisibilityInstance<TData>,
-    ColumnOrderInstance<TData>,
-    ColumnPinningInstance<TData>,
-    RowPinningInstance<TData>,
-    ColumnFiltersInstance<TData>,
-    GlobalFilterInstance<TData>,
-    GlobalFacetingInstance<TData>,
-    SortingInstance<TData>,
-    GroupingInstance<TData>,
-    ColumnSizingInstance,
-    ExpandedInstance<TData>,
-    PaginationInstance<TData>,
-    RowSelectionInstance<TData> {}
-
-interface FeatureOptions<TData extends RowData>
-  extends VisibilityOptions,
-    ColumnOrderOptions,
-    ColumnPinningOptions,
-    RowPinningOptions<TData>,
-    FacetedOptions<TData>,
-    ColumnFiltersOptions<TData>,
-    GlobalFilterOptions<TData>,
-    SortingOptions<TData>,
-    GroupingOptions,
-    ExpandedOptions<TData>,
-    ColumnSizingOptions,
-    PaginationOptions,
-    RowSelectionOptions<TData> {}
-
-export interface TableOptionsResolved<TData extends RowData>
-  extends CoreOptions<TData>,
-    FeatureOptions<TData> {}
-
-export interface TableOptions<TData extends RowData>
-  extends PartialKeys<
-    TableOptionsResolved<TData>,
-    'state' | 'onStateChange' | 'renderFallbackValue'
-  > {}
-
-export interface TableState
-  extends CoreTableState,
-    VisibilityTableState,
-    ColumnOrderTableState,
-    ColumnPinningTableState,
-    RowPinningTableState,
-    ColumnFiltersTableState,
-    GlobalFilterTableState,
-    SortingTableState,
-    ExpandedTableState,
-    GroupingTableState,
-    ColumnSizingTableState,
-    PaginationTableState,
-    RowSelectionTableState {}
-
-interface CompleteInitialTableState
-  extends CoreTableState,
-    VisibilityTableState,
-    ColumnOrderTableState,
-    ColumnPinningTableState,
-    RowPinningTableState,
-    ColumnFiltersTableState,
-    GlobalFilterTableState,
-    SortingTableState,
-    ExpandedTableState,
-    GroupingTableState,
-    ColumnSizingTableState,
-    PaginationInitialTableState,
-    RowSelectionTableState {}
-
-export interface InitialTableState extends Partial<CompleteInitialTableState> {}
-
-export interface Row<TData extends RowData>
-  extends CoreRow<TData>,
-    VisibilityRow<TData>,
-    ColumnPinningRow<TData>,
-    RowPinningRow,
-    ColumnFiltersRow<TData>,
-    GroupingRow,
-    RowSelectionRow,
-    ExpandedRow {}
-
-export interface RowModel<TData extends RowData> {
-  rows: Row<TData>[]
-  flatRows: Row<TData>[]
-  rowsById: Record<string, Row<TData>>
-}
-
-export type AccessorFn<TData extends RowData, TValue = unknown> = (
-  originalRow: TData,
-  index: number
-) => TValue
-
-export type ColumnDefTemplate<TProps extends object> =
-  | string
-  | ((props: TProps) => any)
-
-export type StringOrTemplateHeader<TData, TValue> =
-  | string
-  | ColumnDefTemplate<HeaderContext<TData, TValue>>
-
-export interface StringHeaderIdentifier {
-  header: string
-  id?: string
-}
-
-export interface IdIdentifier<TData extends RowData, TValue> {
-  id: string
-  header?: StringOrTemplateHeader<TData, TValue>
-}
-
-type ColumnIdentifiers<TData extends RowData, TValue> =
-  | IdIdentifier<TData, TValue>
-  | StringHeaderIdentifier
-
-//
-
-interface ColumnDefExtensions<TData extends RowData, TValue = unknown>
-  extends VisibilityColumnDef,
-    ColumnPinningColumnDef,
-    ColumnFiltersColumnDef<TData>,
-    GlobalFilterColumnDef,
-    SortingColumnDef<TData>,
-    GroupingColumnDef<TData, TValue>,
-    ColumnSizingColumnDef {}
-
-export interface ColumnDefBase<TData extends RowData, TValue = unknown>
-  extends ColumnDefExtensions<TData, TValue> {
-  getUniqueValues?: AccessorFn<TData, unknown[]>
-  footer?: ColumnDefTemplate<HeaderContext<TData, TValue>>
-  cell?: ColumnDefTemplate<CellContext<TData, TValue>>
-  meta?: ColumnMeta<TData, TValue>
-}
-
-//
-
-export interface IdentifiedColumnDef<TData extends RowData, TValue = unknown>
-  extends ColumnDefBase<TData, TValue> {
-  id?: string
-  header?: StringOrTemplateHeader<TData, TValue>
-}
-
-export type DisplayColumnDef<
-  TData extends RowData,
-  TValue = unknown,
-> = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
-
-interface GroupColumnDefBase<TData extends RowData, TValue = unknown>
-  extends ColumnDefBase<TData, TValue> {
-  columns?: ColumnDef<TData, any>[]
-}
-
-export type GroupColumnDef<
-  TData extends RowData,
-  TValue = unknown,
-> = GroupColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
-
-export interface AccessorFnColumnDefBase<
-  TData extends RowData,
-  TValue = unknown,
-> extends ColumnDefBase<TData, TValue> {
-  accessorFn: AccessorFn<TData, TValue>
-}
-
-export type AccessorFnColumnDef<
-  TData extends RowData,
-  TValue = unknown,
-> = AccessorFnColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
-
-export interface AccessorKeyColumnDefBase<
-  TData extends RowData,
-  TValue = unknown,
-> extends ColumnDefBase<TData, TValue> {
-  id?: string
-  accessorKey: (string & {}) | keyof TData
-}
-
-export type AccessorKeyColumnDef<
-  TData extends RowData,
-  TValue = unknown,
-> = AccessorKeyColumnDefBase<TData, TValue> &
-  Partial<ColumnIdentifiers<TData, TValue>>
-
-export type AccessorColumnDef<TData extends RowData, TValue = unknown> =
-  | AccessorKeyColumnDef<TData, TValue>
-  | AccessorFnColumnDef<TData, TValue>
-
-//
-
-export type ColumnDef<TData extends RowData, TValue = unknown> =
-  | DisplayColumnDef<TData, TValue>
-  | GroupColumnDef<TData, TValue>
-  | AccessorColumnDef<TData, TValue>
-
-export type ColumnDefResolved<
-  TData extends RowData,
-  TValue = unknown,
-> = Partial<UnionToIntersection<ColumnDef<TData, TValue>>> & {
-  accessorKey?: string
-}
-
-export interface Column<TData extends RowData, TValue = unknown>
-  extends CoreColumn<TData, TValue>,
-    ColumnVisibilityColumn,
-    ColumnPinningColumn,
-    FacetedColumn<TData>,
-    ColumnFiltersColumn<TData>,
-    GlobalFilterColumn,
-    SortingColumn<TData>,
-    GroupingColumn<TData>,
-    ColumnSizingColumn,
-    ColumnOrderColumn {}
-
-export interface Cell<TData extends RowData, TValue>
-  extends CoreCell<TData, TValue>,
-    GroupingCell {}
-
-export interface Header<TData extends RowData, TValue>
-  extends CoreHeader<TData, TValue>,
-    ColumnSizingHeader {}
-
-export interface HeaderGroup<TData extends RowData>
-  extends CoreHeaderGroup<TData> {}

package/src/utils/filterRowsUtils.ts

@@ -1,130 +0,0 @@
-import { _createRow } from '../core/row'
-import { Row, RowModel, Table, RowData } from '../types'
-
-export function filterRows<TData extends RowData>(
-  rows: Row<TData>[],
-  filterRowImpl: (row: Row<TData>) => any,
-  table: Table<TData>
-) {
-  if (table.options.filterFromLeafRows) {
-    return filterRowModelFromLeafs(rows, filterRowImpl, table)
-  }
-
-  return filterRowModelFromRoot(rows, filterRowImpl, table)
-}
-
-function filterRowModelFromLeafs<TData extends RowData>(
-  rowsToFilter: Row<TData>[],
-  filterRow: (row: Row<TData>) => Row<TData>[],
-  table: Table<TData>
-): RowModel<TData> {
-  const newFilteredFlatRows: Row<TData>[] = []
-  const newFilteredRowsById: Record<string, Row<TData>> = {}
-  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
-
-  const recurseFilterRows = (rowsToFilter: Row<TData>[], depth = 0) => {
-    const rows: Row<TData>[] = []
-
-    // Filter from children up first
-    for (let i = 0; i < rowsToFilter.length; i++) {
-      let row = rowsToFilter[i]!
-
-      const newRow = _createRow(
-        table,
-        row.id,
-        row.original,
-        row.index,
-        row.depth,
-        undefined,
-        row.parentId
-      )
-      newRow.columnFilters = row.columnFilters
-
-      if (row.subRows?.length && depth < maxDepth) {
-        newRow.subRows = recurseFilterRows(row.subRows, depth + 1)
-        row = newRow
-
-        if (filterRow(row) && !newRow.subRows.length) {
-          rows.push(row)
-          newFilteredRowsById[row.id] = row
-          newFilteredFlatRows.push(row)
-          continue
-        }
-
-        if (filterRow(row) || newRow.subRows.length) {
-          rows.push(row)
-          newFilteredRowsById[row.id] = row
-          newFilteredFlatRows.push(row)
-          continue
-        }
-      } else {
-        row = newRow
-        if (filterRow(row)) {
-          rows.push(row)
-          newFilteredRowsById[row.id] = row
-          newFilteredFlatRows.push(row)
-        }
-      }
-    }
-
-    return rows
-  }
-
-  return {
-    rows: recurseFilterRows(rowsToFilter),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}
-
-function filterRowModelFromRoot<TData extends RowData>(
-  rowsToFilter: Row<TData>[],
-  filterRow: (row: Row<TData>) => any,
-  table: Table<TData>
-): RowModel<TData> {
-  const newFilteredFlatRows: Row<TData>[] = []
-  const newFilteredRowsById: Record<string, Row<TData>> = {}
-  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100
-
-  // Filters top level and nested rows
-  const recurseFilterRows = (rowsToFilter: Row<TData>[], depth = 0) => {
-    // Filter from parents downward first
-
-    const rows: Row<TData>[] = []
-
-    // Apply the filter to any subRows
-    for (let i = 0; i < rowsToFilter.length; i++) {
-      let row = rowsToFilter[i]!
-
-      const pass = filterRow(row)
-
-      if (pass) {
-        if (row.subRows?.length && depth < maxDepth) {
-          const newRow = _createRow(
-            table,
-            row.id,
-            row.original,
-            row.index,
-            row.depth,
-            undefined,
-            row.parentId
-          )
-          newRow.subRows = recurseFilterRows(row.subRows, depth + 1)
-          row = newRow
-        }
-
-        rows.push(row)
-        newFilteredFlatRows.push(row)
-        newFilteredRowsById[row.id] = row
-      }
-    }
-
-    return rows
-  }
-
-  return {
-    rows: recurseFilterRows(rowsToFilter),
-    flatRows: newFilteredFlatRows,
-    rowsById: newFilteredRowsById,
-  }
-}

package/src/utils/getCoreRowModel.ts

@@ -1,82 +0,0 @@
-import { _createRow } from '../core/row'
-import { Table, Row, RowModel, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-
-export function getCoreRowModel<TData extends RowData>(): (
-  table: Table<TData>
-) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [table.options.data],
-      (
-        data
-      ): {
-        rows: Row<TData>[]
-        flatRows: Row<TData>[]
-        rowsById: Record<string, Row<TData>>
-      } => {
-        const rowModel: RowModel<TData> = {
-          rows: [],
-          flatRows: [],
-          rowsById: {},
-        }
-
-        const accessRows = (
-          originalRows: TData[],
-          depth = 0,
-          parentRow?: Row<TData>
-        ): Row<TData>[] => {
-          const rows = [] as Row<TData>[]
-
-          for (let i = 0; i < originalRows.length; i++) {
-            // This could be an expensive check at scale, so we should move it somewhere else, but where?
-            // if (!id) {
-            //   if (process.env.NODE_ENV !== 'production') {
-            //     throw new Error(`getRowId expected an ID, but got ${id}`)
-            //   }
-            // }
-
-            // Make the row
-            const row = _createRow(
-              table,
-              table._getRowId(originalRows[i]!, i, parentRow),
-              originalRows[i]!,
-              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(
-                originalRows[i]!,
-                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
-      },
-      getMemoOptions(table.options, 'debugTable', 'getRowModel', () =>
-        table._autoResetPageIndex()
-      )
-    )
-}