@tanstack/table-core 8.0.0-alpha.83 → 8.0.0-alpha.86

package/src/core/instance.ts

@@ -0,0 +1,361 @@
+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<TGenerics>
+  ) => () => RowModel<TGenerics>
+  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/features/ColumnSizing.ts

@@ -1,3 +1,4 @@
+import { TableFeature } from '../core/instance'
 import {
   Column,
   Header,
@@ -5,7 +6,6 @@ import {
   TableGenerics,
   TableInstance,
   Updater,
-  TableFeature,
 } from '../types'
 import { makeStateUpdater } from '../utils'
 import { ColumnPinningPosition } from './Pinning'

package/src/features/Expanding.ts

@@ -1,14 +1,13 @@
 import { RowModel } from '..'
+import { TableFeature } from '../core/instance'
 import {
   OnChangeFn,
   TableGenerics,
   TableInstance,
   Row,
   Updater,
-  TableFeature,
 } from '../types'
 import { makeStateUpdater } from '../utils'
-import { Rows } from './Rows'
 
 export type ExpandedStateList = Record<string, boolean>
 export type ExpandedState = true | Record<string, boolean>
@@ -31,7 +30,6 @@ export type ExpandedOptions<TGenerics extends TableGenerics> = {
   getExpandedRowModel?: (
     instance: TableInstance<TGenerics>
   ) => () => RowModel<TGenerics>
-  expandSubRows?: boolean
   getIsRowExpanded?: (row: Row<TGenerics>) => boolean
   getRowCanExpand?: (row: Row<TGenerics>) => boolean
   paginateExpandedRows?: boolean
@@ -68,7 +66,6 @@ export const Expanding: TableFeature = {
     return {
       onExpandedChange: makeStateUpdater('expanded', instance),
       autoResetExpanded: true,
-      expandSubRows: true,
       paginateExpandedRows: true,
     }
   },

package/src/features/Filters.ts

@@ -1,4 +1,5 @@
 import { RowModel } from '..'
+import { TableFeature } from '../core/instance'
 import { BuiltInFilterFn, filterFns } from '../filterFns'
 import {
   Column,
@@ -7,7 +8,6 @@ import {
   TableInstance,
   Row,
   Updater,
-  TableFeature,
 } from '../types'
 import {
   functionalUpdate,
@@ -20,8 +20,6 @@ import {
 export type FiltersTableState = {
   columnFilters: ColumnFiltersState
   globalFilter: any
-  // filtersProgress: number
-  // facetProgress: Record<string, number>
 }
 
 export type ColumnFiltersState = ColumnFilter[]
@@ -74,7 +72,6 @@ export type FiltersColumnDef<TGenerics extends TableGenerics> = {
   filterFn?: FilterFnOption<Overwrite<TGenerics, { Value: any }>>
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
-  enableFaceting?: boolean
 }
 
 export type FiltersColumn<TGenerics extends TableGenerics> = {
@@ -98,7 +95,6 @@ export type FiltersColumn<TGenerics extends TableGenerics> = {
 export type FiltersRow<TGenerics extends TableGenerics> = {
   columnFilters: Record<string, boolean>
   columnFiltersMeta: Record<string, TGenerics['FilterMeta']>
-  subRowsByFacetId: Record<string, Row<TGenerics>[]>
 }
 
 export type FiltersOptions<TGenerics extends TableGenerics> = {
@@ -190,7 +186,7 @@ export const Filters: TableFeature = {
       getColumnCanGlobalFilter: column => {
         const value = instance
           .getCoreRowModel()
-          .flatRows[0]?.getAllCellsByColumnId()
+          .flatRows[0]?._getAllCellsByColumnId()
           [column.id]?.getValue()
 
         return typeof value === 'string'
@@ -356,7 +352,6 @@ export const Filters: TableFeature = {
     return {
       columnFilters: {},
       columnFiltersMeta: {},
-      subRowsByFacetId: {},
     }
   },
 

package/src/features/Grouping.ts

@@ -1,5 +1,6 @@
 import { RowModel } from '..'
 import { BuiltInAggregationFn, aggregationFns } from '../aggregationFns'
+import { TableFeature } from '../core/instance'
 import {
   Cell,
   Column,
@@ -9,15 +10,19 @@ import {
   Updater,
   Renderable,
   TableGenerics,
-  TableFeature,
 } from '../types'
 import { isFunction, makeStateUpdater, Overwrite } from '../utils'
 
 export type GroupingState = string[]
 
+export type GroupingTableState = {
+  grouping: GroupingState
+}
+
 export type AggregationFn<TGenerics extends TableGenerics> = (
-  getLeafValues: () => TGenerics['Value'][],
-  getChildValues: () => TGenerics['Value'][]
+  columnId: string,
+  leafRows: Row<TGenerics>[],
+  childRows: Row<TGenerics>[]
 ) => any
 
 export type CustomAggregationFns<TGenerics extends TableGenerics> = Record<
@@ -31,13 +36,8 @@ export type AggregationFnOption<TGenerics extends TableGenerics> =
   | keyof TGenerics['AggregationFns']
   | AggregationFn<TGenerics>
 
-export type GroupingTableState = {
-  grouping: GroupingState
-}
-
 export type GroupingColumnDef<TGenerics extends TableGenerics> = {
   aggregationFn?: AggregationFnOption<Overwrite<TGenerics, { Value: any }>>
-  aggregateValue?: (columnValue: unknown) => any
   aggregatedCell?: Renderable<
     TGenerics,
     {
@@ -58,15 +58,15 @@ export type GroupingColumn<TGenerics extends TableGenerics> = {
   getGroupedIndex: () => number
   toggleGrouping: () => void
   getToggleGroupingHandler: () => () => void
-  getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
-  getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getAggregationFn: () => AggregationFn<TGenerics> | undefined
 }
 
 export type GroupingRow = {
   groupingColumnId?: string
   groupingValue?: any
   getIsGrouped: () => boolean
-  groupingValuesCache: Record<string, any>
+  _groupingValuesCache: Record<string, any>
 }
 
 export type GroupingCell<TGenerics extends TableGenerics> = {
@@ -87,11 +87,9 @@ export type GroupingOptions<TGenerics extends TableGenerics> = {
   aggregationFns?: TGenerics['AggregationFns']
   onGroupingChange?: OnChangeFn<GroupingState>
   enableGrouping?: boolean
-  enableGroupingRemoval?: boolean
   getGroupedRowModel?: (
     instance: TableInstance<TGenerics>
   ) => () => RowModel<TGenerics>
-
   groupedColumnMode?: false | 'reorder' | 'remove'
 }
 
@@ -172,7 +170,7 @@ export const Grouping: TableFeature = {
           column.toggleGrouping()
         }
       },
-      getColumnAutoAggregationFn: () => {
+      getAutoAggregationFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
         const value = firstRow?.getValue(column.id)
@@ -187,7 +185,7 @@ export const Grouping: TableFeature = {
 
         return aggregationFns.count
       },
-      getColumnAggregationFn: () => {
+      getAggregationFn: () => {
         const userAggregationFns = instance.options.aggregationFns
 
         if (!column) {
@@ -197,7 +195,7 @@ export const Grouping: TableFeature = {
         return isFunction(column.aggregationFn)
           ? column.aggregationFn
           : column.aggregationFn === 'auto'
-          ? column.getColumnAutoAggregationFn()
+          ? column.getAutoAggregationFn()
           : (userAggregationFns as Record<string, any>)?.[
               column.aggregationFn as string
             ] ??
@@ -240,12 +238,11 @@ export const Grouping: TableFeature = {
   },
 
   createRow: <TGenerics extends TableGenerics>(
-    row: Row<TGenerics>,
-    instance: TableInstance<TGenerics>
+    row: Row<TGenerics>
   ): GroupingRow => {
     return {
       getIsGrouped: () => !!row.groupingColumnId,
-      groupingValuesCache: {},
+      _groupingValuesCache: {},
     }
   },
 

package/src/features/Ordering.ts

@@ -6,10 +6,10 @@ import {
   Updater,
   Column,
   TableGenerics,
-  TableFeature,
 } from '../types'
 
 import { Grouping, orderColumns } from './Grouping'
+import { TableFeature } from '../core/instance'
 
 export type ColumnOrderTableState = {
   columnOrder: ColumnOrderState

package/src/features/Pagination.ts

@@ -1,10 +1,10 @@
+import { TableFeature } from '../core/instance'
 import {
   OnChangeFn,
   TableGenerics,
   TableInstance,
   RowModel,
   Updater,
-  TableFeature,
 } from '../types'
 import { functionalUpdate, makeStateUpdater, memo } from '../utils'