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

package/src/core.ts

@@ -1,246 +0,0 @@
-import { functionalUpdate, RequiredKeys } from './utils'
-
-import {
-  Updater,
-  TableOptionsResolved,
-  TableState,
-  TableInstance,
-  Renderable,
-  TableFeature,
-  TableGenerics,
-  InitialTableState,
-} from './types'
-
-import { Columns } from './features/Columns'
-import { Rows } from './features/Rows'
-import { Cells } from './features/Cells'
-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'
-import { Headers } from './features/Headers'
-//
-
-export type CoreTableState = {
-  // coreProgress: number
-}
-
-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']
-  // keepPreviousData?: boolean
-}
-
-export type CoreInstance<TGenerics extends TableGenerics> = {
-  // generics: TGenerics
-  initialState: TableState
-  reset: () => void
-  options: RequiredKeys<TableOptionsResolved<TGenerics>, 'state'>
-  setOptions: (newOptions: Updater<TableOptionsResolved<TGenerics>>) => void
-  getState: () => TableState
-  setState: (updater: Updater<TableState>) => void
-  _queue: (cb: () => void) => void
-  _render: <TProps>(
-    template: Renderable<TGenerics, TProps>,
-    props: TProps
-  ) => string | null | TGenerics['Rendered']
-  _features: readonly TableFeature[]
-  // getOverallProgress: () => number
-  // getProgressStage: () =>
-  //   | undefined
-  //   | 'coreRowModel'
-  //   | 'filteredRowModel'
-  //   | 'facetedRowModel'
-  // createBatch: (priority: keyof CoreBatches) => Batch
-  // init: () => void
-  // willUpdate: () => void
-  // destroy: () => void
-  // batches: CoreBatches
-}
-
-// export type Batch = {
-//   id: number
-//   priority: keyof CoreBatches
-//   tasks: (() => void)[]
-//   schedule: (cb: () => void) => void
-//   cancel: () => void
-// }
-
-// type CoreBatches = {
-//   data: Batch[]
-//   facets: Batch[]
-// }
-
-export function createTableInstance<TGenerics extends TableGenerics>(
-  options: TableOptionsResolved<TGenerics>
-): TableInstance<TGenerics> {
-  if (options.debugAll || options.debugTable) {
-    console.info('Creating Table Instance...')
-  }
-
-  let instance = {
-    _features: [
-      Columns,
-      Rows,
-      Cells,
-      Headers,
-      Visibility,
-      Ordering,
-      Pinning,
-      Filters,
-      Sorting,
-      Grouping,
-      Expanding,
-      Pagination,
-      RowSelection,
-      ColumnSizing,
-    ] as const,
-  } as unknown as CoreInstance<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 = {
-    // coreProgress: 1,
-  }
-
-  let initialState = {
-    ...coreInitialState,
-    ...(options.initialState ?? {}),
-  } as TableState
-
-  instance._features.forEach(feature => {
-    initialState = feature.getInitialState?.(initialState) ?? initialState
-  })
-
-  const queued: (() => void)[] = []
-  let queuedTimeout = false
-
-  const midInstance: CoreInstance<TGenerics> = {
-    ...instance,
-    // init: () => {
-    //   startWork()
-    // },
-    // willUpdate: () => {
-    //   startWork()
-    // },
-    // destroy: () => {
-    //   stopWork()
-    // },
-    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)
-    },
-
-    // getOverallProgress: () => {
-    //   const { coreProgress, filtersProgress, facetProgress } =
-    //     instance.getState()
-
-    //   return mean(() =>
-    //     [coreProgress, filtersProgress].filter(d => d < 1)
-    //   ) as number
-    // },
-    // getProgressStage: () => {
-    //   const { coreProgress, filtersProgress, facetProgress } =
-    //     instance.getState()
-
-    //   if (coreProgress < 1) {
-    //     return 'coreRowModel'
-    //   }
-
-    //   if (filtersProgress < 1) {
-    //     return 'filteredRowModel'
-    //   }
-
-    //   if (Object.values(facetProgress).some(d => d < 1)) {
-    //     return 'facetedRowModel'
-    //   }
-    // },
-  }
-
-  instance = Object.assign(instance, midInstance)
-
-  instance._features.forEach(feature => {
-    return Object.assign(instance, feature.createInstance?.(instance))
-  })
-
-  return instance as TableInstance<TGenerics>
-}

package/src/features/Cells.ts

@@ -1,128 +0,0 @@
-import {
-  Cell,
-  TableGenerics,
-  TableInstance,
-  Row,
-  Column,
-  CoreCell,
-} from '../types'
-import { memo } from '../utils'
-
-export type CellsRow<TGenerics extends TableGenerics> = {
-  getAllCells: () => Cell<TGenerics>[]
-  getAllCellsByColumnId: () => Record<string, Cell<TGenerics>>
-}
-
-export type CellsInstance<TGenerics extends TableGenerics> = {
-  createCell: (
-    row: Row<TGenerics>,
-    column: Column<TGenerics>,
-    columnId: string
-  ) => Cell<TGenerics>
-  getCell: (rowId: string, columnId: string) => Cell<TGenerics>
-}
-
-//
-
-export const Cells = {
-  createRow: <TGenerics extends TableGenerics>(
-    row: Row<TGenerics>,
-    instance: TableInstance<TGenerics>
-  ): CellsRow<TGenerics> => {
-    return {
-      getAllCells: memo(
-        () => [instance.getAllLeafColumns()],
-        leafColumns => {
-          return leafColumns.map(column => {
-            return instance.createCell(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.columnId] = cell
-            return acc
-          }, {} as Record<string, Cell<TGenerics>>)
-        },
-        {
-          key:
-            process.env.NODE_ENV === 'production' &&
-            'row.getAllCellsByColumnId',
-          debug: () => instance.options.debugAll ?? instance.options.debugRows,
-        }
-      ),
-    }
-  },
-
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): CellsInstance<TGenerics> => {
-    return {
-      createCell: (row, column, columnId) => {
-        const cell: CoreCell<TGenerics> = {
-          id: `${row.id}_${column.id}`,
-          rowId: row.id,
-          columnId,
-          row,
-          column,
-          getValue: () => row.getValue(columnId),
-          renderCell: () =>
-            column.columnDef.cell
-              ? instance._render(column.columnDef.cell, {
-                  instance,
-                  column,
-                  row,
-                  cell: cell as Cell<TGenerics>,
-                  getValue: cell.getValue,
-                })
-              : null,
-        }
-
-        instance._features.forEach(feature => {
-          Object.assign(
-            cell,
-            feature.createCell?.(
-              cell as Cell<TGenerics>,
-              column,
-              row as Row<TGenerics>,
-              instance
-            )
-          )
-        }, {})
-
-        return cell as Cell<TGenerics>
-      },
-
-      getCell: (rowId: string, columnId: string) => {
-        const row = instance.getRow(rowId)
-
-        if (!row) {
-          if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`[Table] could not find row with id ${rowId}`)
-          }
-          throw new Error()
-        }
-
-        const cell = row.getAllCellsByColumnId()[columnId]
-
-        if (!cell) {
-          if (process.env.NODE_ENV !== 'production') {
-            throw new Error(
-              `[Table] could not find cell ${columnId} in row ${rowId}`
-            )
-          }
-          throw new Error()
-        }
-
-        return cell
-      },
-    }
-  },
-}

package/src/features/Columns.ts

@@ -1,293 +0,0 @@
-import {
-  Cell,
-  Column,
-  Header,
-  TableGenerics,
-  TableInstance,
-  Row,
-  AccessorFn,
-  ColumnDef,
-  Renderable,
-} from '../types'
-import { memo } from '../utils'
-
-export type CoreColumnDefType = 'data' | 'display' | 'group'
-
-export type CoreColumnDef<TGenerics extends TableGenerics> = {
-  id: string
-  accessorKey?: string & keyof TGenerics['Row']
-  accessorFn?: AccessorFn<TGenerics['Row']>
-  columns?: ColumnDef<TGenerics>[]
-  header?: Renderable<
-    TGenerics,
-    {
-      instance: TableInstance<TGenerics>
-      header: Header<TGenerics>
-      column: Column<TGenerics>
-    }
-  >
-  footer?: Renderable<
-    TGenerics,
-    {
-      instance: TableInstance<TGenerics>
-      header: Header<TGenerics>
-      column: Column<TGenerics>
-    }
-  >
-  cell?: Renderable<
-    TGenerics,
-    {
-      instance: TableInstance<TGenerics>
-      row: Row<TGenerics>
-      column: Column<TGenerics>
-      cell: Cell<TGenerics>
-      getValue: () => TGenerics['Value']
-    }
-  >
-  meta?: TGenerics['ColumnMeta']
-}
-
-export type CoreColumn<TGenerics extends TableGenerics> = {
-  id: string
-  depth: number
-  accessorFn?: AccessorFn<TGenerics['Row']>
-  columnDef: ColumnDef<TGenerics>
-  columnDefType: CoreColumnDefType
-  columns: Column<TGenerics>[]
-  parent?: Column<TGenerics>
-  getFlatColumns: () => Column<TGenerics>[]
-  getLeafColumns: () => Column<TGenerics>[]
-}
-
-export type ColumnsOptions<TGenerics extends TableGenerics> = {
-  columns: ColumnDef<TGenerics>[]
-  defaultColumnDef?: Partial<ColumnDef<TGenerics>>
-}
-
-export type ColumnsInstance<TGenerics extends TableGenerics> = {
-  getDefaultColumnDef: () => Partial<ColumnDef<TGenerics>>
-  getColumnDefs: () => ColumnDef<TGenerics>[]
-  createColumn: (
-    columnDef: ColumnDef<TGenerics>,
-    depth: number,
-    parent?: Column<TGenerics>
-  ) => Column<TGenerics>
-  getAllColumns: () => Column<TGenerics>[]
-  getAllFlatColumns: () => Column<TGenerics>[]
-  getAllFlatColumnsById: () => Record<string, Column<TGenerics>>
-  getAllLeafColumns: () => Column<TGenerics>[]
-  getColumn: (columnId: string) => Column<TGenerics>
-}
-
-//
-
-export const Columns = {
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): ColumnsInstance<TGenerics> => {
-    return {
-      getDefaultColumnDef: memo(
-        () => [instance.options.defaultColumnDef],
-        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,
-
-      createColumn: (
-        columnDef: ColumnDef<TGenerics> & { columnDefType?: CoreColumnDefType },
-        depth: number,
-        parent
-      ) => {
-        const defaultColumnDef = instance.getDefaultColumnDef()
-
-        columnDef = {
-          ...defaultColumnDef,
-          ...columnDef,
-        }
-
-        let id =
-          columnDef.id ??
-          columnDef.accessorKey ??
-          (typeof columnDef.header === 'string' ? columnDef.header : undefined)
-
-        let accessorFn: AccessorFn<TGenerics['Row']> | undefined
-
-        if (columnDef.accessorFn) {
-          accessorFn = columnDef.accessorFn
-        } else if (columnDef.accessorKey) {
-          accessorFn = (originalRow?: TGenerics['Row']) =>
-            (originalRow as any)[columnDef.accessorKey]
-        }
-
-        if (!id) {
-          if (process.env.NODE_ENV !== 'production') {
-            throw new Error(
-              columnDef.accessorFn
-                ? `Columns require an id when using an accessorFn`
-                : `Columns require an id when using a non-string header`
-            )
-          }
-          throw new Error()
-        }
-
-        let column: CoreColumn<TGenerics> = {
-          ...columnDef,
-          id: `${id}`,
-          accessorFn,
-          parent: parent as any,
-          depth,
-          columnDef,
-          columnDefType: columnDef.columnDefType as CoreColumnDefType,
-          columns: [],
-          getFlatColumns: memo(
-            () => [true],
-            () => {
-              return [
-                column as Column<TGenerics>,
-                ...column.columns?.flatMap(d => d.getFlatColumns()),
-              ]
-            },
-            {
-              key:
-                process.env.NODE_ENV === 'production' &&
-                'column.getFlatColumns',
-              debug: () =>
-                instance.options.debugAll ?? instance.options.debugColumns,
-            }
-          ),
-          getLeafColumns: memo(
-            () => [instance._getOrderColumnsFn()],
-            orderColumns => {
-              if (column.columns?.length) {
-                let leafColumns = column.columns.flatMap(column =>
-                  column.getLeafColumns()
-                )
-
-                return orderColumns(leafColumns)
-              }
-
-              return [column as Column<TGenerics>]
-            },
-            {
-              key:
-                process.env.NODE_ENV === 'production' &&
-                'column.getLeafColumns',
-              debug: () =>
-                instance.options.debugAll ?? instance.options.debugColumns,
-            }
-          ),
-        }
-
-        column = instance._features.reduce((obj, feature) => {
-          return Object.assign(obj, feature.createColumn?.(column, instance))
-        }, column)
-
-        // Yes, we have to convert instance to uknown, because we know more than the compiler here.
-        return column as Column<TGenerics>
-      },
-
-      getAllColumns: memo(
-        () => [instance.getColumnDefs()],
-        columnDefs => {
-          const recurseColumns = (
-            columnDefs: ColumnDef<TGenerics>[],
-            parent?: Column<TGenerics>,
-            depth = 0
-          ): Column<TGenerics>[] => {
-            return columnDefs.map(columnDef => {
-              const column = instance.createColumn(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
-      },
-    }
-  },
-}