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

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()
-      )
-    )
-}

package/src/utils/getExpandedRowModel.ts

@@ -1,51 +0,0 @@
-import { Table, Row, RowModel, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-
-export function getExpandedRowModel<TData extends RowData>(): (
-  table: Table<TData>
-) => () => RowModel<TData> {
-  return table =>
-    memo(
-      () => [
-        table.getState().expanded,
-        table.getPreExpandedRowModel(),
-        table.options.paginateExpandedRows,
-      ],
-      (expanded, rowModel, paginateExpandedRows) => {
-        if (
-          !rowModel.rows.length ||
-          (expanded !== true && !Object.keys(expanded ?? {}).length)
-        ) {
-          return rowModel
-        }
-
-        if (!paginateExpandedRows) {
-          // Only expand rows at this point if they are being paginated
-          return rowModel
-        }
-
-        return expandRows(rowModel)
-      },
-      getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel')
-    )
-}
-
-export function expandRows<TData extends RowData>(rowModel: RowModel<TData>) {
-  const expandedRows: Row<TData>[] = []
-
-  const handleRow = (row: Row<TData>) => {
-    expandedRows.push(row)
-
-    if (row.subRows?.length && row.getIsExpanded()) {
-      row.subRows.forEach(handleRow)
-    }
-  }
-
-  rowModel.rows.forEach(handleRow)
-
-  return {
-    rows: expandedRows,
-    flatRows: rowModel.flatRows,
-    rowsById: rowModel.rowsById,
-  }
-}

package/src/utils/getFacetedMinMaxValues.ts

@@ -1,42 +0,0 @@
-import { Table, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-
-export function getFacetedMinMaxValues<TData extends RowData>(): (
-  table: Table<TData>,
-  columnId: string
-) => () => undefined | [number, number] {
-  return (table, columnId) =>
-    memo(
-      () => [table.getColumn(columnId)?.getFacetedRowModel()],
-      facetedRowModel => {
-        if (!facetedRowModel) return undefined
-
-        const firstValue =
-          facetedRowModel.flatRows[0]?.getUniqueValues(columnId)
-
-        if (typeof firstValue === 'undefined') {
-          return undefined
-        }
-
-        let facetedMinMaxValues: [any, any] = [firstValue, firstValue]
-
-        for (let i = 0; i < facetedRowModel.flatRows.length; i++) {
-          const values =
-            facetedRowModel.flatRows[i]!.getUniqueValues<number>(columnId)
-
-          for (let j = 0; j < values.length; j++) {
-            const value = values[j]!
-
-            if (value < facetedMinMaxValues[0]) {
-              facetedMinMaxValues[0] = value
-            } else if (value > facetedMinMaxValues[1]) {
-              facetedMinMaxValues[1] = value
-            }
-          }
-        }
-
-        return facetedMinMaxValues
-      },
-      getMemoOptions(table.options, 'debugTable', 'getFacetedMinMaxValues')
-    )
-}

package/src/utils/getFacetedRowModel.ts

@@ -1,44 +0,0 @@
-import { Table, RowModel, Row, RowData } from '../types'
-import { getMemoOptions, memo } from '../utils'
-import { filterRows } from './filterRowsUtils'
-
-export function getFacetedRowModel<TData extends RowData>(): (
-  table: Table<TData>,
-  columnId: string
-) => () => RowModel<TData> {
-  return (table, columnId) =>
-    memo(
-      () => [
-        table.getPreFilteredRowModel(),
-        table.getState().columnFilters,
-        table.getState().globalFilter,
-        table.getFilteredRowModel(),
-      ],
-      (preRowModel, columnFilters, globalFilter) => {
-        if (
-          !preRowModel.rows.length ||
-          (!columnFilters?.length && !globalFilter)
-        ) {
-          return preRowModel
-        }
-
-        const filterableIds = [
-          ...columnFilters.map(d => d.id).filter(d => d !== columnId),
-          globalFilter ? '__global__' : undefined,
-        ].filter(Boolean) as string[]
-
-        const filterRowsImpl = (row: Row<TData>) => {
-          // Horizontally filter rows through each column
-          for (let i = 0; i < filterableIds.length; i++) {
-            if (row.columnFilters[filterableIds[i]!] === false) {
-              return false
-            }
-          }
-          return true
-        }
-
-        return filterRows(preRowModel.rows, filterRowsImpl, table)
-      },
-      getMemoOptions(table.options, 'debugTable', 'getFacetedRowModel')
-    )
-}