@tanstack/table-core 8.0.0-alpha.9 → 8.0.0-beta.2

package/src/core/instance.ts

@@ -0,0 +1,359 @@
+import { flattenBy, functionalUpdate, memo, RequiredKeys } from '../utils'
+
+import {
+  Updater,
+  TableOptionsResolved,
+  TableState,
+  TableInstance,
+  Renderable,
+  TableGenerics,
+  InitialTableState,
+  Row,
+  Column,
+  RowModel,
+  ColumnDef,
+} from '../types'
+
+//
+import { createColumn } from './column'
+import { Headers } from './headers'
+//
+
+import { ColumnSizing } from '../features/ColumnSizing'
+import { Expanding } from '../features/Expanding'
+import { Filters } from '../features/Filters'
+import { Grouping } from '../features/Grouping'
+import { Ordering } from '../features/Ordering'
+import { Pagination } from '../features/Pagination'
+import { Pinning } from '../features/Pinning'
+import { RowSelection } from '../features/RowSelection'
+import { Sorting } from '../features/Sorting'
+import { Visibility } from '../features/Visibility'
+
+export type TableFeature = {
+  getDefaultOptions?: (instance: any) => any
+  getInitialState?: (initialState?: InitialTableState) => any
+  createInstance?: (instance: any) => any
+  getDefaultColumnDef?: () => any
+  createColumn?: (column: any, instance: any) => any
+  createHeader?: (column: any, instance: any) => any
+  createCell?: (cell: any, column: any, row: any, instance: any) => any
+  createRow?: (row: any, instance: any) => any
+}
+
+const features = [
+  Headers,
+  Visibility,
+  Ordering,
+  Pinning,
+  Filters,
+  Sorting,
+  Grouping,
+  Expanding,
+  Pagination,
+  RowSelection,
+  ColumnSizing,
+] as const
+
+//
+
+export type CoreTableState = {}
+
+export type CoreOptions<TGenerics extends TableGenerics> = {
+  data: TGenerics['Row'][]
+  state: Partial<TableState>
+  onStateChange: (updater: Updater<TableState>) => void
+  render: TGenerics['Renderer']
+  debugAll?: boolean
+  debugTable?: boolean
+  debugHeaders?: boolean
+  debugColumns?: boolean
+  debugRows?: boolean
+  initialState?: InitialTableState
+  autoResetAll?: boolean
+  mergeOptions?: <T>(defaultOptions: T, options: Partial<T>) => T
+  meta?: TGenerics['TableMeta']
+  getCoreRowModel: (instance: TableInstance<any>) => () => RowModel<any>
+  getSubRows?: (
+    originalRow: TGenerics['Row'],
+    index: number
+  ) => undefined | TGenerics['Row'][]
+  getRowId?: (
+    originalRow: TGenerics['Row'],
+    index: number,
+    parent?: Row<TGenerics>
+  ) => string
+  columns: ColumnDef<TGenerics>[]
+  defaultColumn?: Partial<ColumnDef<TGenerics>>
+}
+
+export type CoreInstance<TGenerics extends TableGenerics> = {
+  initialState: TableState
+  reset: () => void
+  options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>
+  setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void
+  getState: () => TableState
+  setState: (updater: Updater<TableState>) => void
+  _features: readonly TableFeature[]
+  _queue: (cb: () => void) => void
+  _render: <TProps>(
+    template: Renderable<TGenerics, TProps>,
+    props: TProps
+  ) => string | null | TGenerics['Rendered']
+  _getRowId: (
+    _: TGenerics['Row'],
+    index: number,
+    parent?: Row<TGenerics>
+  ) => string
+  getCoreRowModel: () => RowModel<TGenerics>
+  _getCoreRowModel?: () => RowModel<TGenerics>
+  getRowModel: () => RowModel<TGenerics>
+  getRow: (id: string) => Row<TGenerics>
+  _getDefaultColumnDef: () => Partial<ColumnDef<TGenerics>>
+  _getColumnDefs: () => ColumnDef<TGenerics>[]
+  _getAllFlatColumnsById: () => Record<string, Column<TGenerics>>
+  getAllColumns: () => Column<TGenerics>[]
+  getAllFlatColumns: () => Column<TGenerics>[]
+  getAllLeafColumns: () => Column<TGenerics>[]
+  getColumn: (columnId: string) => Column<TGenerics>
+}
+
+export function createTableInstance<TGenerics extends TableGenerics>(
+  options: TableOptionsResolved<TGenerics>
+): TableInstance<TGenerics> {
+  if (options.debugAll || options.debugTable) {
+    console.info('Creating Table Instance...')
+  }
+
+  let instance = { _features: features } as unknown as TableInstance<TGenerics>
+
+  const defaultOptions = instance._features.reduce((obj, feature) => {
+    return Object.assign(obj, feature.getDefaultOptions?.(instance))
+  }, {}) as TableOptionsResolved<TGenerics>
+
+  const mergeOptions = (options: TableOptionsResolved<TGenerics>) => {
+    if (instance.options.mergeOptions) {
+      return instance.options.mergeOptions(defaultOptions, options)
+    }
+
+    return {
+      ...defaultOptions,
+      ...options,
+    }
+  }
+
+  const coreInitialState: CoreTableState = {}
+
+  let initialState = {
+    ...coreInitialState,
+    ...(options.initialState ?? {}),
+  } as TableState
+
+  instance._features.forEach(feature => {
+    initialState = feature.getInitialState?.(initialState) ?? initialState
+  })
+
+  const queued: (() => void)[] = []
+  let queuedTimeout = false
+
+  const coreInstance: CoreInstance<TGenerics> = {
+    _features: features,
+    options: {
+      ...defaultOptions,
+      ...options,
+    },
+    initialState,
+    _queue: cb => {
+      queued.push(cb)
+
+      if (!queuedTimeout) {
+        queuedTimeout = true
+
+        // Schedule a microtask to run the queued callbacks after
+        // the current call stack (render, etc) has finished.
+        Promise.resolve()
+          .then(() => {
+            while (queued.length) {
+              queued.shift()!()
+            }
+            queuedTimeout = false
+          })
+          .catch(error =>
+            setTimeout(() => {
+              throw error
+            })
+          )
+      }
+    },
+    reset: () => {
+      instance.setState(instance.initialState)
+    },
+    setOptions: updater => {
+      const newOptions = functionalUpdate(updater, instance.options)
+      instance.options = mergeOptions(newOptions)
+    },
+    _render: (template, props) => {
+      if (typeof instance.options.render === 'function') {
+        return instance.options.render(template, props)
+      }
+
+      if (typeof template === 'function') {
+        return (template as Function)(props)
+      }
+
+      return template
+    },
+
+    getState: () => {
+      return instance.options.state as TableState
+    },
+
+    setState: (updater: Updater<TableState>) => {
+      instance.options.onStateChange?.(updater)
+    },
+
+    _getRowId: (
+      row: TGenerics['Row'],
+      index: number,
+      parent?: Row<TGenerics>
+    ) =>
+      instance.options.getRowId?.(row, index, parent) ??
+      `${parent ? [parent.id, index].join('.') : index}`,
+
+    getCoreRowModel: () => {
+      if (!instance._getCoreRowModel) {
+        instance._getCoreRowModel = instance.options.getCoreRowModel(instance)
+      }
+
+      return instance._getCoreRowModel()
+    },
+
+    // The final calls start at the bottom of the model,
+    // expanded rows, which then work their way up
+
+    getRowModel: () => {
+      return instance.getPaginationRowModel()
+    },
+    getRow: (id: string) => {
+      const row = instance.getRowModel().rowsById[id]
+
+      if (!row) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error(`getRow expected an ID, but got ${id}`)
+        }
+        throw new Error()
+      }
+
+      return row
+    },
+    _getDefaultColumnDef: memo(
+      () => [instance.options.defaultColumn],
+      defaultColumn => {
+        defaultColumn = (defaultColumn ?? {}) as Partial<ColumnDef<TGenerics>>
+
+        return {
+          header: props => props.header.column.id,
+          footer: props => props.header.column.id,
+          cell: props => props.getValue().toString?.() ?? null,
+          ...instance._features.reduce((obj, feature) => {
+            return Object.assign(obj, feature.getDefaultColumnDef?.())
+          }, {}),
+          ...defaultColumn,
+        } as Partial<ColumnDef<TGenerics>>
+      },
+      {
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+        key: process.env.NODE_ENV === 'development' && 'getDefaultColumnDef',
+      }
+    ),
+
+    _getColumnDefs: () => instance.options.columns,
+
+    getAllColumns: memo(
+      () => [instance._getColumnDefs()],
+      columnDefs => {
+        const recurseColumns = (
+          columnDefs: ColumnDef<TGenerics>[],
+          parent?: Column<TGenerics>,
+          depth = 0
+        ): Column<TGenerics>[] => {
+          return columnDefs.map(columnDef => {
+            const column = createColumn(instance, columnDef, depth, parent)
+
+            column.columns = columnDef.columns
+              ? recurseColumns(columnDef.columns, column, depth + 1)
+              : []
+
+            return column
+          })
+        }
+
+        return recurseColumns(columnDefs)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getAllColumns',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+
+    getAllFlatColumns: memo(
+      () => [instance.getAllColumns()],
+      allColumns => {
+        return allColumns.flatMap(column => {
+          return column.getFlatColumns()
+        })
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getAllFlatColumns',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+
+    _getAllFlatColumnsById: memo(
+      () => [instance.getAllFlatColumns()],
+      flatColumns => {
+        return flatColumns.reduce((acc, column) => {
+          acc[column.id] = column
+          return acc
+        }, {} as Record<string, Column<TGenerics>>)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getAllFlatColumnsById',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+
+    getAllLeafColumns: memo(
+      () => [instance.getAllColumns(), instance._getOrderColumnsFn()],
+      (allColumns, orderColumns) => {
+        let leafColumns = allColumns.flatMap(column => column.getLeafColumns())
+        return orderColumns(leafColumns)
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'getAllLeafColumns',
+        debug: () => instance.options.debugAll ?? instance.options.debugColumns,
+      }
+    ),
+
+    getColumn: columnId => {
+      const column = instance._getAllFlatColumnsById()[columnId]
+
+      if (!column) {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn(`[Table] Column with id ${columnId} does not exist.`)
+        }
+        throw new Error()
+      }
+
+      return column
+    },
+  }
+
+  Object.assign(instance, coreInstance)
+
+  instance._features.forEach(feature => {
+    return Object.assign(instance, feature.createInstance?.(instance))
+  })
+
+  return instance
+}

package/src/core/row.ts

@@ -0,0 +1,85 @@
+import { Cell, Row, TableGenerics, TableInstance } from '../types'
+import { flattenBy, memo } from '../utils'
+import { createCell } from './cell'
+
+export type CoreRow<TGenerics extends TableGenerics> = {
+  id: string
+  index: number
+  original?: TGenerics['Row']
+  depth: number
+  _valuesCache: Record<string, any>
+  getValue: (columnId: string) => any
+  subRows: Row<TGenerics>[]
+  getLeafRows: () => Row<TGenerics>[]
+  originalSubRows?: TGenerics['Row'][]
+  getAllCells: () => Cell<TGenerics>[]
+  _getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>
+}
+
+export const createRow = <TGenerics extends TableGenerics>(
+  instance: TableInstance<TGenerics>,
+  id: string,
+  original: TGenerics['Row'] | undefined,
+  rowIndex: number,
+  depth: number,
+  subRows?: Row<TGenerics>[]
+): Row<TGenerics> => {
+  let row: CoreRow<TGenerics> = {
+    id,
+    index: rowIndex,
+    original,
+    depth,
+    _valuesCache: {},
+    getValue: columnId => {
+      if (row._valuesCache.hasOwnProperty(columnId)) {
+        return row._valuesCache[columnId]
+      }
+
+      const column = instance.getColumn(columnId)
+
+      if (!column.accessorFn) {
+        return undefined
+      }
+
+      row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex)
+
+      return row._valuesCache[columnId]
+    },
+    subRows: subRows ?? [],
+    getLeafRows: () => flattenBy(row.subRows, d => d.subRows),
+    getAllCells: memo(
+      () => [instance.getAllLeafColumns()],
+      leafColumns => {
+        return leafColumns.map(column => {
+          return createCell(instance, row as Row<TGenerics>, column, column.id)
+        })
+      },
+      {
+        key: process.env.NODE_ENV === 'development' && 'row.getAllCells',
+        debug: () => instance.options.debugAll ?? instance.options.debugRows,
+      }
+    ),
+
+    _getAllCellsByColumnId: memo(
+      () => [row.getAllCells()],
+      allCells => {
+        return allCells.reduce((acc, cell) => {
+          acc[cell.column.id] = cell
+          return acc
+        }, {} as Record<string, Cell<TGenerics>>)
+      },
+      {
+        key:
+          process.env.NODE_ENV === 'production' && 'row.getAllCellsByColumnId',
+        debug: () => instance.options.debugAll ?? instance.options.debugRows,
+      }
+    ),
+  }
+
+  for (let i = 0; i < instance._features.length; i++) {
+    const feature = instance._features[i]
+    Object.assign(row, feature?.createRow?.(row, instance))
+  }
+
+  return row as Row<TGenerics>
+}

package/src/createTable.ts

@@ -0,0 +1,188 @@
+import { CustomFilterFns, FilterFn } from './features/Filters'
+import { AggregationFn, CustomAggregationFns } from './features/Grouping'
+import { CustomSortingFns, SortingFn } from './features/Sorting'
+import {
+  ColumnDef,
+  AccessorFn,
+  AnyRender,
+  TableGenerics,
+  TableOptionsResolved,
+  TableOptions,
+} from './types'
+import { IfDefined, Overwrite } from './utils'
+
+export type TableFactory<TGenerics extends TableGenerics> =
+  () => Table<TGenerics>
+
+export type CreateTableOptions<
+  TRender extends AnyRender,
+  TFilterFns extends CustomFilterFns<any>,
+  TSortingFns extends CustomSortingFns<any>,
+  TAggregationFns extends CustomAggregationFns<any>,
+  TGenerics extends TableGenerics
+> = Partial<
+  {
+    render?: TRender
+    filterFns?: TFilterFns
+    sortingFns?: TSortingFns
+    aggregationFns?: TAggregationFns
+  } & Omit<
+    TableOptionsResolved<TGenerics>,
+    'filterFns' | 'sortingFns' | 'aggregationFns'
+  >
+>
+
+export type Table<TGenerics extends TableGenerics> = {
+  generics: TGenerics
+  options: Partial<TableOptionsResolved<TGenerics>>
+  // setGenerics: <T extends TableGenerics>() => Table<T>
+  setRowType: <TRow>() => Table<Overwrite<TGenerics, { Row: TRow }>>
+  setTableMetaType: <TTableMeta>() => Table<
+    Overwrite<TGenerics, { TableMeta: TTableMeta }>
+  >
+  setColumnMetaType: <TColumnMeta>() => Table<
+    Overwrite<TGenerics, { ColumnMeta: TColumnMeta }>
+  >
+  setFilterMetaType: <TFilterMeta>() => Table<
+    Overwrite<TGenerics, { FilterMeta: TFilterMeta }>
+  >
+  setOptions: <
+    TFilterFns extends Record<string, FilterFn<any>>,
+    TSortingFns extends Record<string, SortingFn<any>>,
+    TAggregationFns extends Record<string, AggregationFn<any>>
+  >(
+    options: CreateTableOptions<
+      any,
+      TFilterFns,
+      TSortingFns,
+      TAggregationFns,
+      TGenerics
+    >
+  ) => Table<
+    Overwrite<
+      TGenerics,
+      {
+        FilterFns: IfDefined<TFilterFns, TGenerics['FilterFns']>
+        SortingFns: IfDefined<TSortingFns, TGenerics['SortingFns']>
+        AggregationFns: IfDefined<TAggregationFns, TGenerics['AggregationFns']>
+      }
+    >
+  >
+  createGroup: (
+    column: Overwrite<
+      | Overwrite<
+          ColumnDef<any>,
+          {
+            header: string
+            id?: string
+          }
+        >
+      | Overwrite<
+          ColumnDef<any>,
+          {
+            id: string
+            header?: string | ((...any: any) => any)
+          }
+        >,
+      {
+        accessorFn?: never
+        accessorKey?: never
+        columns?: ColumnDef<any>[]
+      }
+    >
+  ) => ColumnDef<TGenerics>
+  createDisplayColumn: (
+    column: Omit<ColumnDef<TGenerics>, 'columns'>
+  ) => ColumnDef<TGenerics>
+  createDataColumn: <
+    TAccessor extends AccessorFn<TGenerics['Row']> | keyof TGenerics['Row']
+  >(
+    accessor: TAccessor,
+    column: Overwrite<
+      TAccessor extends (...args: any[]) => any
+        ? // Accessor Fn
+          ColumnDef<Overwrite<TGenerics, { Value: ReturnType<TAccessor> }>>
+        : TAccessor extends keyof TGenerics['Row']
+        ? // Accessor Key
+          Overwrite<
+            ColumnDef<
+              Overwrite<TGenerics, { Value: TGenerics['Row'][TAccessor] }>
+            >,
+            {
+              id?: string
+            }
+          >
+        : never,
+      {
+        accessorFn?: never
+        accessorKey?: never
+        columns?: ColumnDef<any>[]
+      }
+    >
+  ) => ColumnDef<TGenerics>
+  createOptions: (options: TableOptions<TGenerics>) => TableOptions<TGenerics>
+}
+
+//
+
+export function createTableFactory<TRenderer extends AnyRender>(opts: {
+  render: TRenderer
+}): () => Table<{ Renderer: TRenderer; Rendered: ReturnType<TRenderer> }> {
+  return () => createTable(undefined, undefined, opts)
+}
+
+// A lot of returns in here are `as any` for a reason. Unless you
+// can find a better way to do this, then don't worry about them
+function createTable<TGenerics extends TableGenerics>(
+  _?: undefined,
+  __?: undefined,
+  options?: CreateTableOptions<any, any, any, any, TGenerics>
+): Table<TGenerics> {
+  const table: Table<TGenerics> = {
+    generics: undefined!,
+    options: options ?? {
+      render: (() => {
+        throw new Error('')
+      })(),
+    },
+    // setGenerics: () => table as any,
+    setRowType: () => table as any,
+    setTableMetaType: () => table as any,
+    setColumnMetaType: () => table as any,
+    setFilterMetaType: () => table as any,
+    setOptions: newOptions =>
+      createTable(_, __, {
+        ...options,
+        ...newOptions,
+      } as any),
+    createDisplayColumn: column => ({ ...column, columnDefType: 'display' }),
+    createGroup: column => ({ ...column, columnDefType: 'group' } as any),
+    createDataColumn: (accessor, column): any => {
+      column = {
+        ...column,
+        columnDefType: 'data',
+        id: column.id,
+      }
+
+      if (typeof accessor === 'string') {
+        return {
+          ...column,
+          id: column.id ?? accessor,
+          accessorKey: accessor,
+        }
+      }
+
+      if (typeof accessor === 'function') {
+        return {
+          ...column,
+          accessorFn: accessor,
+        }
+      }
+
+      throw new Error('Invalid accessor')
+    },
+    createOptions: options => options,
+  }
+
+  return table
+}