@tanstack/table-core 8.0.13 → 8.1.1

package/src/types.ts

@@ -1,4 +1,4 @@
-import { CoreOptions, CoreTableState, CoreInstance } from './core/instance'
+import { CoreOptions, CoreTableState, CoreInstance } from './core/table'
 import { CoreColumn, CoreColumnDef } from './core/column'
 import {
   VisibilityInstance,
@@ -38,6 +38,7 @@ import {
   SortingTableState,
 } from './features/Sorting'
 import {
+  CustomAggregationFns,
   GroupingCell,
   GroupingColumn,
   GroupingColumnDef,
@@ -79,51 +80,45 @@ import { CoreCell } from './core/cell'
 export type Updater<T> = T | ((old: T) => T)
 export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void
 
+export type RowData = object | any[]
+
 export type TableGenerics = {
   Row?: any
   Value?: any
-  FilterFns?: any
-  SortingFns?: any
-  AggregationFns?: any
-  Renderer?: any
-  Rendered?: any
   ColumnMeta?: any
   TableMeta?: any
-  FilterMeta?: any
 }
 
 export type AnyRender = (Comp: any, props: any) => any
 
-export type TableInstance<TGenerics extends TableGenerics> =
-  CoreInstance<TGenerics> &
-    HeadersInstance<TGenerics> &
-    VisibilityInstance<TGenerics> &
-    ColumnOrderInstance<TGenerics> &
-    ColumnPinningInstance<TGenerics> &
-    FiltersInstance<TGenerics> &
-    SortingInstance<TGenerics> &
-    GroupingInstance<TGenerics> &
-    ColumnSizingInstance<TGenerics> &
-    ExpandedInstance<TGenerics> &
-    PaginationInstance<TGenerics> &
-    RowSelectionInstance<TGenerics>
-
-export type TableOptionsResolved<TGenerics extends TableGenerics> =
-  CoreOptions<TGenerics> &
-    VisibilityOptions &
-    ColumnOrderOptions &
-    ColumnPinningOptions &
-    FiltersOptions<TGenerics> &
-    SortingOptions<TGenerics> &
-    GroupingOptions<TGenerics> &
-    ExpandedOptions<TGenerics> &
-    ColumnSizingOptions &
-    PaginationOptions<TGenerics> &
-    RowSelectionOptions<TGenerics>
-
-export type TableOptions<TGenerics extends TableGenerics> = Omit<
-  PartialKeys<TableOptionsResolved<TGenerics>, 'state' | 'onStateChange'>,
-  'render' | 'renderFallbackValue'
+export type Table<TData extends RowData> = CoreInstance<TData> &
+  HeadersInstance<TData> &
+  VisibilityInstance<TData> &
+  ColumnOrderInstance<TData> &
+  ColumnPinningInstance<TData> &
+  FiltersInstance<TData> &
+  SortingInstance<TData> &
+  GroupingInstance<TData> &
+  ColumnSizingInstance &
+  ExpandedInstance<TData> &
+  PaginationInstance<TData> &
+  RowSelectionInstance<TData>
+
+export type TableOptionsResolved<TData extends RowData> = CoreOptions<TData> &
+  VisibilityOptions &
+  ColumnOrderOptions &
+  ColumnPinningOptions &
+  FiltersOptions<TData> &
+  SortingOptions<TData> &
+  GroupingOptions &
+  ExpandedOptions<TData> &
+  ColumnSizingOptions &
+  PaginationOptions &
+  RowSelectionOptions<TData>
+
+export type TableOptions<TData extends RowData> = PartialKeys<
+  TableOptionsResolved<TData>,
+  'state' | 'onStateChange' | 'renderFallbackValue'
 >
 
 export type TableState = CoreTableState &
@@ -152,10 +147,10 @@ export type InitialTableState = Partial<
     RowSelectionTableState
 >
 
-export type Row<TGenerics extends TableGenerics> = CoreRow<TGenerics> &
-  VisibilityRow<TGenerics> &
-  ColumnPinningRow<TGenerics> &
-  FiltersRow<TGenerics> &
+export type Row<TData extends RowData> = CoreRow<TData> &
+  VisibilityRow<TData> &
+  ColumnPinningRow<TData> &
+  FiltersRow<TData> &
   GroupingRow &
   RowSelectionRow &
   ExpandedRow
@@ -164,42 +159,42 @@ export type RowValues = {
   [key: string]: any
 }
 
-export type RowModel<TGenerics extends TableGenerics> = {
-  rows: Row<TGenerics>[]
-  flatRows: Row<TGenerics>[]
-  rowsById: Record<string, Row<TGenerics>>
+export type RowModel<TData extends RowData> = {
+  rows: Row<TData>[]
+  flatRows: Row<TData>[]
+  rowsById: Record<string, Row<TData>>
 }
 
-export type AccessorFn<TData> = (originalRow: TData, index: number) => any
+export type AccessorFn<TData extends RowData> = (
+  originalRow: TData,
+  index: number
+) => any
 
-export type Renderable<TGenerics extends TableGenerics, TProps> =
+export type ColumnDefTemplate<TProps extends object> =
   | string
-  | ((props: TProps) => TGenerics['Rendered'])
-
-export type ColumnDef<TGenerics extends TableGenerics> =
-  CoreColumnDef<TGenerics> &
-    VisibilityColumnDef &
-    ColumnPinningColumnDef &
-    FiltersColumnDef<TGenerics> &
-    SortingColumnDef<TGenerics> &
-    GroupingColumnDef<TGenerics> &
-    ColumnSizingColumnDef
-
-export type Column<TGenerics extends TableGenerics> = CoreColumn<TGenerics> &
+  | ((props: TProps) => unknown)
+
+export type ColumnDef<TData extends RowData> = CoreColumnDef<TData> &
+  VisibilityColumnDef &
+  ColumnPinningColumnDef &
+  FiltersColumnDef<TData> &
+  SortingColumnDef<TData> &
+  GroupingColumnDef<TData> &
+  ColumnSizingColumnDef
+
+export type Column<TData extends RowData> = CoreColumn<TData> &
   ColumnVisibilityColumn &
   ColumnPinningColumn &
-  FiltersColumn<TGenerics> &
-  SortingColumn<TGenerics> &
-  GroupingColumn<TGenerics> &
-  ColumnSizingColumn<TGenerics>
+  FiltersColumn<TData> &
+  SortingColumn<TData> &
+  GroupingColumn<TData> &
+  ColumnSizingColumn
 
-export type Cell<TGenerics extends TableGenerics> = CoreCell<TGenerics> &
-  GroupingCell<TGenerics>
+export type Cell<TData extends RowData> = CoreCell<TData> & GroupingCell
 
-export type Header<TGenerics extends TableGenerics> = CoreHeader<TGenerics> &
-  ColumnSizingHeader<TGenerics>
+export type Header<TData extends RowData> = CoreHeader<TData> &
+  ColumnSizingHeader
 
-export type HeaderGroup<TGenerics extends TableGenerics> =
-  CoreHeaderGroup<TGenerics>
+export type HeaderGroup<TData extends RowData> = CoreHeaderGroup<TData>
 
 export type NoInfer<A extends any> = [A][A extends any ? 0 : never]

package/src/utils/filterRowsUtils.ts

@@ -1,36 +1,41 @@
 import { createRow } from '../core/row'
-import { TableGenerics, Row, RowModel, TableInstance } from '../types'
+import { TableGenerics, Row, RowModel, Table, RowData } from '../types'
 
-export function filterRows<TGenerics extends TableGenerics>(
-  rows: Row<TGenerics>[],
-  filterRowImpl: (row: Row<TGenerics>) => any,
-  instance: TableInstance<TGenerics>
+export function filterRows<TData extends RowData>(
+  rows: Row<TData>[],
+  filterRowImpl: (row: Row<TData>) => any,
+  table: Table<TData>
 ) {
-  if (instance.options.filterFromLeafRows) {
-    return filterRowModelFromLeafs(rows, filterRowImpl, instance)
+  if (table.options.filterFromLeafRows) {
+    return filterRowModelFromLeafs(rows, filterRowImpl, table)
   }
 
-  return filterRowModelFromRoot(rows, filterRowImpl, instance)
+  return filterRowModelFromRoot(rows, filterRowImpl, table)
 }
 
-export function filterRowModelFromLeafs<TGenerics extends TableGenerics>(
-  rowsToFilter: Row<TGenerics>[],
-  filterRow: (row: Row<TGenerics>) => Row<TGenerics>[],
-  instance: TableInstance<TGenerics>
-): RowModel<TGenerics> {
-  const newFilteredFlatRows: Row<TGenerics>[] = []
-  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
+export 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 recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
-    const rows: Row<TGenerics>[] = []
+  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]!
 
       if (row.subRows?.length) {
-        const newRow = createRow(instance, row.id, row.original, row.index, row.depth)
+        const newRow = createRow(
+          table,
+          row.id,
+          row.original,
+          row.index,
+          row.depth
+        )
         newRow.columnFilters = row.columnFilters
         newRow.subRows = recurseFilterRows(row.subRows, depth + 1)
         if (!newRow.subRows.length) {
@@ -56,16 +61,16 @@ export function filterRowModelFromLeafs<TGenerics extends TableGenerics>(
   }
 }
 
-export function filterRowModelFromRoot<TGenerics extends TableGenerics>(
-  rowsToFilter: Row<TGenerics>[],
-  filterRow: (row: Row<TGenerics>) => any,
-  instance: TableInstance<TGenerics>
-): RowModel<TGenerics> {
-  const newFilteredFlatRows: Row<TGenerics>[] = []
-  const newFilteredRowsById: Record<string, Row<TGenerics>> = {}
+export 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>> = {}
 
   // Filters top level and nested rows
-  const recurseFilterRows = (rowsToFilter: Row<TGenerics>[], depth = 0) => {
+  const recurseFilterRows = (rowsToFilter: Row<TData>[], depth = 0) => {
     // Filter from parents downward first
 
     const rows = []
@@ -79,7 +84,7 @@ export function filterRowModelFromRoot<TGenerics extends TableGenerics>(
       if (pass) {
         if (row.subRows?.length) {
           const newRow = createRow(
-            instance,
+            table,
             row.id,
             row.original,
             row.index,

package/src/utils/getCoreRowModel.ts

@@ -1,32 +1,32 @@
 import { createRow } from '../core/row'
-import { TableInstance, Row, RowModel, TableGenerics } from '../types'
+import { Table, Row, RowModel, TableGenerics, RowData } from '../types'
 import { memo } from '../utils'
 
-export function getCoreRowModel<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>
-) => () => RowModel<TGenerics> {
-  return instance =>
+export function getCoreRowModel<TData extends RowData>(): (
+  table: Table<TData>
+) => () => RowModel<TData> {
+  return table =>
     memo(
-      () => [instance.options.data],
+      () => [table.options.data],
       (
         data
       ): {
-        rows: Row<TGenerics>[]
-        flatRows: Row<TGenerics>[]
-        rowsById: Record<string, Row<TGenerics>>
+        rows: Row<TData>[]
+        flatRows: Row<TData>[]
+        rowsById: Record<string, Row<TData>>
       } => {
-        const rowModel: RowModel<TGenerics> = {
+        const rowModel: RowModel<TData> = {
           rows: [],
           flatRows: [],
           rowsById: {},
         }
 
         const accessRows = (
-          originalRows: TGenerics['Row'][],
+          originalRows: TData[],
           depth = 0,
-          parent?: Row<TGenerics>
-        ): Row<TGenerics>[] => {
-          const rows = [] as Row<TGenerics>[]
+          parent?: 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?
@@ -38,8 +38,8 @@ export function getCoreRowModel<TGenerics extends TableGenerics>(): (
 
             // Make the row
             const row = createRow(
-              instance,
-              instance._getRowId(originalRows[i], i, parent),
+              table,
+              table._getRowId(originalRows[i]!, i, parent),
               originalRows[i],
               i,
               depth
@@ -49,13 +49,13 @@ export function getCoreRowModel<TGenerics extends TableGenerics>(): (
             rowModel.flatRows.push(row)
             // Also keep track of every row by its ID
             rowModel.rowsById[row.id] = row
-            // Push instance row into parent
+            // Push table row into parent
             rows.push(row)
 
             // Get the original subrows
-            if (instance.options.getSubRows) {
-              row.originalSubRows = instance.options.getSubRows(
-                originalRows[i],
+            if (table.options.getSubRows) {
+              row.originalSubRows = table.options.getSubRows(
+                originalRows[i]!,
                 i
               )
 
@@ -75,9 +75,9 @@ export function getCoreRowModel<TGenerics extends TableGenerics>(): (
       },
       {
         key: process.env.NODE_ENV === 'development' && 'getRowModel',
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
         onChange: () => {
-          instance._autoResetPageIndex()
+          table._autoResetPageIndex()
         },
       }
     )

package/src/utils/getExpandedRowModel.ts

@@ -1,15 +1,15 @@
-import { TableInstance, Row, RowModel, TableGenerics } from '../types'
+import { Table, Row, RowModel, TableGenerics, RowData } from '../types'
 import { memo } from '../utils'
 
-export function getExpandedRowModel<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>
-) => () => RowModel<TGenerics> {
-  return instance =>
+export function getExpandedRowModel<TData extends RowData>(): (
+  table: Table<TData>
+) => () => RowModel<TData> {
+  return table =>
     memo(
       () => [
-        instance.getState().expanded,
-        instance.getPreExpandedRowModel(),
-        instance.options.paginateExpandedRows,
+        table.getState().expanded,
+        table.getPreExpandedRowModel(),
+        table.options.paginateExpandedRows,
       ],
       (expanded, rowModel, paginateExpandedRows) => {
         if (
@@ -21,22 +21,22 @@ export function getExpandedRowModel<TGenerics extends TableGenerics>(): (
           return rowModel
         }
 
-        return expandRows(rowModel, instance)
+        return expandRows(rowModel, table)
       },
       {
         key: process.env.NODE_ENV === 'development' && 'getExpandedRowModel',
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
       }
     )
 }
 
-export function expandRows<TGenerics extends TableGenerics>(
-  rowModel: RowModel<TGenerics>,
-  instance: TableInstance<TGenerics>
+export function expandRows<TData extends RowData>(
+  rowModel: RowModel<TData>,
+  table: Table<TData>
 ) {
-  const expandedRows: Row<TGenerics>[] = []
+  const expandedRows: Row<TData>[] = []
 
-  const handleRow = (row: Row<TGenerics>) => {
+  const handleRow = (row: Row<TData>) => {
     expandedRows.push(row)
 
     if (row.subRows?.length && row.getIsExpanded()) {

package/src/utils/getFacetedMinMaxValues.ts

@@ -1,13 +1,13 @@
-import { TableInstance, TableGenerics } from '../types'
+import { Table, TableGenerics, RowData } from '../types'
 import { memo } from '../utils'
 
-export function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>,
+export function getFacetedMinMaxValues<TData extends RowData>(): (
+  table: Table<TData>,
   columnId: string
 ) => () => undefined | [number, number] {
-  return (instance, columnId) =>
+  return (table, columnId) =>
     memo(
-      () => [instance.getColumn(columnId).getFacetedRowModel()],
+      () => [table.getColumn(columnId).getFacetedRowModel()],
       facetedRowModel => {
         const firstValue = facetedRowModel.flatRows[0]?.getValue(columnId)
 
@@ -33,7 +33,7 @@ export function getFacetedMinMaxValues<TGenerics extends TableGenerics>(): (
         key:
           process.env.NODE_ENV === 'development' &&
           'getFacetedMinMaxValues_' + columnId,
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
         onChange: () => {},
       }
     )

package/src/utils/getFacetedRowModel.ts

@@ -1,18 +1,18 @@
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
+import { Table, RowModel, TableGenerics, Row, RowData } from '../types'
 import { memo } from '../utils'
 import { filterRows } from './filterRowsUtils'
 
-export function getFacetedRowModel<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>,
+export function getFacetedRowModel<TData extends RowData>(): (
+  table: Table<TData>,
   columnId: string
-) => () => RowModel<TGenerics> {
-  return (instance, columnId) =>
+) => () => RowModel<TData> {
+  return (table, columnId) =>
     memo(
       () => [
-        instance.getPreFilteredRowModel(),
-        instance.getState().columnFilters,
-        instance.getState().globalFilter,
-        instance.getFilteredRowModel(),
+        table.getPreFilteredRowModel(),
+        table.getState().columnFilters,
+        table.getState().globalFilter,
+        table.getFilteredRowModel(),
       ],
       (preRowModel, columnFilters, globalFilter) => {
         if (
@@ -27,7 +27,7 @@ export function getFacetedRowModel<TGenerics extends TableGenerics>(): (
           globalFilter ? '__global__' : undefined,
         ].filter(Boolean) as string[]
 
-        const filterRowsImpl = (row: Row<TGenerics>) => {
+        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) {
@@ -37,13 +37,13 @@ export function getFacetedRowModel<TGenerics extends TableGenerics>(): (
           return true
         }
 
-        return filterRows(preRowModel.rows, filterRowsImpl, instance)
+        return filterRows(preRowModel.rows, filterRowsImpl, table)
       },
       {
         key:
           process.env.NODE_ENV === 'development' &&
           'getFacetedRowModel_' + columnId,
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
         onChange: () => {},
       }
     )

package/src/utils/getFacetedUniqueValues.ts

@@ -1,13 +1,13 @@
-import { TableInstance, TableGenerics } from '../types'
+import { Table, TableGenerics, RowData } from '../types'
 import { memo } from '../utils'
 
-export function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>,
+export function getFacetedUniqueValues<TData extends RowData>(): (
+  table: Table<TData>,
   columnId: string
 ) => () => Map<any, number> {
-  return (instance, columnId) =>
+  return (table, columnId) =>
     memo(
-      () => [instance.getColumn(columnId).getFacetedRowModel()],
+      () => [table.getColumn(columnId).getFacetedRowModel()],
       facetedRowModel => {
         let facetedUniqueValues = new Map<any, number>()
 
@@ -30,7 +30,7 @@ export function getFacetedUniqueValues<TGenerics extends TableGenerics>(): (
         key:
           process.env.NODE_ENV === 'development' &&
           'getFacetedUniqueValues_' + columnId,
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
         onChange: () => {},
       }
     )

package/src/utils/getFilteredRowModel.ts

@@ -1,17 +1,17 @@
 import { ResolvedColumnFilter } from '../features/Filters'
-import { TableInstance, RowModel, TableGenerics, Row } from '../types'
+import { Table, RowModel, TableGenerics, Row, RowData } from '../types'
 import { memo } from '../utils'
 import { filterRows } from './filterRowsUtils'
 
-export function getFilteredRowModel<TGenerics extends TableGenerics>(): (
-  instance: TableInstance<TGenerics>
-) => () => RowModel<TGenerics> {
-  return instance =>
+export function getFilteredRowModel<TData extends RowData>(): (
+  table: Table<TData>
+) => () => RowModel<TData> {
+  return table =>
     memo(
       () => [
-        instance.getPreFilteredRowModel(),
-        instance.getState().columnFilters,
-        instance.getState().globalFilter,
+        table.getPreFilteredRowModel(),
+        table.getState().columnFilters,
+        table.getState().globalFilter,
       ],
       (rowModel, columnFilters, globalFilter) => {
         if (
@@ -25,11 +25,11 @@ export function getFilteredRowModel<TGenerics extends TableGenerics>(): (
           return rowModel
         }
 
-        const resolvedColumnFilters: ResolvedColumnFilter<TGenerics>[] = []
-        const resolvedGlobalFilters: ResolvedColumnFilter<TGenerics>[] = []
+        const resolvedColumnFilters: ResolvedColumnFilter<TData>[] = []
+        const resolvedGlobalFilters: ResolvedColumnFilter<TData>[] = []
 
         ;(columnFilters ?? []).forEach(d => {
-          const column = instance.getColumn(d.id)
+          const column = table.getColumn(d.id)
 
           if (!column) {
             if (process.env.NODE_ENV !== 'production') {
@@ -59,9 +59,9 @@ export function getFilteredRowModel<TGenerics extends TableGenerics>(): (
 
         const filterableIds = columnFilters.map(d => d.id)
 
-        const globalFilterFn = instance.getGlobalFilterFn()
+        const globalFilterFn = table.getGlobalFilterFn()
 
-        const globallyFilterableColumns = instance
+        const globallyFilterableColumns = table
           .getAllLeafColumns()
           .filter(column => column.getCanGlobalFilter())
 
@@ -135,7 +135,7 @@ export function getFilteredRowModel<TGenerics extends TableGenerics>(): (
           }
         }
 
-        const filterRowsImpl = (row: Row<TGenerics>) => {
+        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) {
@@ -146,13 +146,13 @@ export function getFilteredRowModel<TGenerics extends TableGenerics>(): (
         }
 
         // Filter final rows using all of the active filters
-        return filterRows(rowModel.rows, filterRowsImpl, instance)
+        return filterRows(rowModel.rows, filterRowsImpl, table)
       },
       {
         key: process.env.NODE_ENV === 'development' && 'getFilteredRowModel',
-        debug: () => instance.options.debugAll ?? instance.options.debugTable,
+        debug: () => table.options.debugAll ?? table.options.debugTable,
         onChange: () => {
-          instance._autoResetPageIndex()
+          table._autoResetPageIndex()
         },
       }
     )