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

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>

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,
@@ -190,7 +190,7 @@ export const Filters: TableFeature = {
       getColumnCanGlobalFilter: column => {
         const value = instance
           .getCoreRowModel()
-          .flatRows[0]?.getAllCellsByColumnId()
+          .flatRows[0]?._getAllCellsByColumnId()
           [column.id]?.getValue()
 
         return typeof value === 'string'

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,7 +10,6 @@ import {
   Updater,
   Renderable,
   TableGenerics,
-  TableFeature,
 } from '../types'
 import { isFunction, makeStateUpdater, Overwrite } from '../utils'
 

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'
 

package/src/features/Pinning.ts

@@ -1,3 +1,4 @@
+import { TableFeature } from '../core/instance'
 import {
   OnChangeFn,
   Updater,
@@ -6,7 +7,6 @@ import {
   TableGenerics,
   Row,
   Cell,
-  TableFeature,
 } from '../types'
 import { makeStateUpdater, memo } from '../utils'
 
@@ -164,7 +164,7 @@ export const Pinning: TableFeature = {
         (allCells, left, right) => {
           const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]
 
-          return allCells.filter(d => !leftAndRight.includes(d.columnId))
+          return allCells.filter(d => !leftAndRight.includes(d.column.id))
         },
         {
           key:
@@ -181,7 +181,9 @@ export const Pinning: TableFeature = {
         ],
         (allCells, left) => {
           const cells = (left ?? [])
-            .map(columnId => allCells.find(cell => cell.columnId === columnId)!)
+            .map(
+              columnId => allCells.find(cell => cell.column.id === columnId)!
+            )
             .filter(Boolean)
             .map(d => ({ ...d, position: 'left' } as Cell<TGenerics>))
 
@@ -200,7 +202,9 @@ export const Pinning: TableFeature = {
         ],
         (allCells, right) => {
           const cells = (right ?? [])
-            .map(columnId => allCells.find(cell => cell.columnId === columnId)!)
+            .map(
+              columnId => allCells.find(cell => cell.column.id === columnId)!
+            )
             .filter(Boolean)
             .map(d => ({ ...d, position: 'left' } as Cell<TGenerics>))
 

package/src/features/RowSelection.ts

@@ -1,3 +1,4 @@
+import { TableFeature } from '../core/instance'
 import {
   OnChangeFn,
   TableGenerics,
@@ -5,7 +6,6 @@ import {
   Row,
   RowModel,
   Updater,
-  TableFeature,
 } from '../types'
 import { makeStateUpdater, memo } from '../utils'
 

package/src/features/Sorting.ts

@@ -1,4 +1,5 @@
 import { RowModel } from '..'
+import { TableFeature } from '../core/instance'
 import {
   BuiltInSortingFn,
   reSplitAlphaNumeric,
@@ -12,7 +13,6 @@ import {
   TableInstance,
   Row,
   Updater,
-  TableFeature,
 } from '../types'
 
 import { isFunction, makeStateUpdater, Overwrite } from '../utils'

package/src/features/Visibility.ts

@@ -1,3 +1,4 @@
+import { TableFeature } from '../core/instance'
 import {
   Cell,
   Column,
@@ -6,7 +7,6 @@ import {
   TableInstance,
   Updater,
   Row,
-  TableFeature,
 } from '../types'
 import { makeStateUpdater, memo } from '../utils'
 

package/src/index.ts

@@ -1,12 +1,14 @@
-export * from './core'
+export * from './core/instance'
 export * from './types'
 export * from './createTable'
+export * from './core/column'
+export * from './core/headers'
+export * from './core/row'
 export * from './features/ColumnSizing'
 export * from './features/ColumnSizing'
 export * from './features/Expanding'
 export * from './features/Filters'
 export * from './features/Grouping'
-export * from './features/Headers'
 export * from './features/Ordering'
 export * from './features/Pagination'
 export * from './features/Pinning'
@@ -27,9 +29,3 @@ export * from './utils/getSortedRowModel'
 export * from './utils/getGroupedRowModel'
 export * from './utils/getExpandedRowModel'
 export * from './utils/getPaginationRowModel'
-// Experimental Async
-// export * from './utils/getCoreRowModelAsync'
-// export * from './utils/getFilteredRowModelAsync'
-// export * from './utils/getFacetedRowModelAsync'
-// export * from './utils/getFacetedUniqueValuesAsync'
-// export * from './utils/getFacetedMinMaxValuesAsync'