@tanstack/table-core 8.0.11 → 8.0.14

package/src/features/Grouping.ts

@@ -1,15 +1,16 @@
 import { RowModel } from '..'
 import { BuiltInAggregationFn, aggregationFns } from '../aggregationFns'
-import { TableFeature } from '../core/instance'
+import { TableFeature } from '../core/table'
 import {
   Cell,
   Column,
   OnChangeFn,
-  TableInstance,
+  Table,
   Row,
   Updater,
-  Renderable,
+  ColumnDefTemplate,
   TableGenerics,
+  RowData,
 } from '../types'
 import { isFunction, makeStateUpdater, Overwrite } from '../utils'
 
@@ -19,46 +20,33 @@ export type GroupingTableState = {
   grouping: GroupingState
 }
 
-export type AggregationFn<TGenerics extends TableGenerics> = (
+export type AggregationFn<TData extends RowData> = (
   columnId: string,
-  leafRows: Row<TGenerics>[],
-  childRows: Row<TGenerics>[]
+  leafRows: Row<TData>[],
+  childRows: Row<TData>[]
 ) => any
 
-export type CustomAggregationFns<TGenerics extends TableGenerics> = Record<
-  string,
-  AggregationFn<TGenerics>
->
+export type CustomAggregationFns = Record<string, AggregationFn<any>>
 
-export type AggregationFnOption<TGenerics extends TableGenerics> =
+export type AggregationFnOption<TData extends RowData> =
   | 'auto'
   | BuiltInAggregationFn
-  | keyof TGenerics['AggregationFns']
-  | AggregationFn<TGenerics>
-
-export type GroupingColumnDef<TGenerics extends TableGenerics> = {
-  aggregationFn?: AggregationFnOption<Overwrite<TGenerics, { Value: any }>>
-  aggregatedCell?: Renderable<
-    TGenerics,
-    {
-      instance: TableInstance<TGenerics>
-      row: Row<TGenerics>
-      column: Column<TGenerics>
-      cell: Cell<TGenerics>
-      getValue: () => TGenerics['Value']
-    }
-  >
+  | AggregationFn<TData>
+
+export type GroupingColumnDef<TData extends RowData> = {
+  aggregationFn?: AggregationFnOption<TData>
+  aggregatedCell?: ColumnDefTemplate<ReturnType<Cell<TData>['getContext']>>
   enableGrouping?: boolean
 }
 
-export type GroupingColumn<TGenerics extends TableGenerics> = {
+export type GroupingColumn<TData extends RowData> = {
   getCanGroup: () => boolean
   getIsGrouped: () => boolean
   getGroupedIndex: () => number
   toggleGrouping: () => void
   getToggleGroupingHandler: () => () => void
-  getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
-  getAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getAutoAggregationFn: () => AggregationFn<TData> | undefined
+  getAggregationFn: () => AggregationFn<TData> | undefined
 }
 
 export type GroupingRow = {
@@ -68,11 +56,10 @@ export type GroupingRow = {
   _groupingValuesCache: Record<string, any>
 }
 
-export type GroupingCell<TGenerics extends TableGenerics> = {
+export type GroupingCell = {
   getIsGrouped: () => boolean
   getIsPlaceholder: () => boolean
   getIsAggregated: () => boolean
-  renderAggregatedCell: () => string | null | TGenerics['Rendered']
 }
 
 export type ColumnDefaultOptions = {
@@ -81,33 +68,30 @@ export type ColumnDefaultOptions = {
   enableGrouping: boolean
 }
 
-export type GroupingOptions<TGenerics extends TableGenerics> = {
+export type GroupingOptions = {
   manualGrouping?: boolean
-  aggregationFns?: TGenerics['AggregationFns']
   onGroupingChange?: OnChangeFn<GroupingState>
   enableGrouping?: boolean
-  getGroupedRowModel?: (instance: TableInstance<any>) => () => RowModel<any>
+  getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>
   groupedColumnMode?: false | 'reorder' | 'remove'
 }
 
 export type GroupingColumnMode = false | 'reorder' | 'remove'
 
-export type GroupingInstance<TGenerics extends TableGenerics> = {
+export type GroupingInstance<TData extends RowData> = {
   setGrouping: (updater: Updater<GroupingState>) => void
   resetGrouping: (defaultState?: boolean) => void
-  getPreGroupedRowModel: () => RowModel<TGenerics>
-  getGroupedRowModel: () => RowModel<TGenerics>
-  _getGroupedRowModel?: () => RowModel<TGenerics>
+  getPreGroupedRowModel: () => RowModel<TData>
+  getGroupedRowModel: () => RowModel<TData>
+  _getGroupedRowModel?: () => RowModel<TData>
 }
 
 //
 
 export const Grouping: TableFeature = {
-  getDefaultColumnDef: <
-    TGenerics extends TableGenerics
-  >(): GroupingColumnDef<TGenerics> => {
+  getDefaultColumnDef: <TData extends RowData>(): GroupingColumnDef<TData> => {
     return {
-      aggregatedCell: props => props.getValue()?.toString?.() ?? null,
+      aggregatedCell: props => (props.getValue() as any)?.toString?.() ?? null,
       aggregationFn: 'auto',
     }
   },
@@ -119,22 +103,22 @@ export const Grouping: TableFeature = {
     }
   },
 
-  getDefaultOptions: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): GroupingOptions<TGenerics> => {
+  getDefaultOptions: <TData extends RowData>(
+    table: Table<TData>
+  ): GroupingOptions => {
     return {
-      onGroupingChange: makeStateUpdater('grouping', instance),
+      onGroupingChange: makeStateUpdater('grouping', table),
       groupedColumnMode: 'reorder',
     }
   },
 
-  createColumn: <TGenerics extends TableGenerics>(
-    column: Column<TGenerics>,
-    instance: TableInstance<TGenerics>
-  ): GroupingColumn<TGenerics> => {
+  createColumn: <TData extends RowData>(
+    column: Column<TData>,
+    table: Table<TData>
+  ): GroupingColumn<TData> => {
     return {
       toggleGrouping: () => {
-        instance.setGrouping(old => {
+        table.setGrouping(old => {
           // Find any existing grouping for this column
           if (old?.includes(column.id)) {
             return old.filter(d => d !== column.id)
@@ -148,17 +132,17 @@ export const Grouping: TableFeature = {
         return (
           column.columnDef.enableGrouping ??
           true ??
-          instance.options.enableGrouping ??
+          table.options.enableGrouping ??
           true ??
           !!column.accessorFn
         )
       },
 
       getIsGrouped: () => {
-        return instance.getState().grouping?.includes(column.id)
+        return table.getState().grouping?.includes(column.id)
       },
 
-      getGroupedIndex: () => instance.getState().grouping?.indexOf(column.id),
+      getGroupedIndex: () => table.getState().grouping?.indexOf(column.id),
 
       getToggleGroupingHandler: () => {
         const canGroup = column.getCanGroup()
@@ -169,7 +153,7 @@ export const Grouping: TableFeature = {
         }
       },
       getAutoAggregationFn: () => {
-        const firstRow = instance.getCoreRowModel().flatRows[0]
+        const firstRow = table.getCoreRowModel().flatRows[0]
 
         const value = firstRow?.getValue(column.id)
 
@@ -182,8 +166,6 @@ export const Grouping: TableFeature = {
         }
       },
       getAggregationFn: () => {
-        const userAggregationFns = instance.options.aggregationFns
-
         if (!column) {
           throw new Error()
         }
@@ -192,64 +174,55 @@ export const Grouping: TableFeature = {
           ? column.columnDef.aggregationFn
           : column.columnDef.aggregationFn === 'auto'
           ? column.getAutoAggregationFn()
-          : (userAggregationFns as Record<string, any>)?.[
-              column.columnDef.aggregationFn as string
-            ] ??
-            (aggregationFns[
+          : (aggregationFns[
               column.columnDef.aggregationFn as BuiltInAggregationFn
-            ] as AggregationFn<TGenerics>)
+            ] as AggregationFn<TData>)
       },
     }
   },
 
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): GroupingInstance<TGenerics> => {
+  createTable: <TData extends RowData>(
+    table: Table<TData>
+  ): GroupingInstance<TData> => {
     return {
-      setGrouping: updater => instance.options.onGroupingChange?.(updater),
+      setGrouping: updater => table.options.onGroupingChange?.(updater),
 
       resetGrouping: defaultState => {
-        instance.setGrouping(
-          defaultState ? [] : instance.initialState?.grouping ?? []
+        table.setGrouping(
+          defaultState ? [] : table.initialState?.grouping ?? []
         )
       },
 
-      getPreGroupedRowModel: () => instance.getFilteredRowModel(),
+      getPreGroupedRowModel: () => table.getFilteredRowModel(),
       getGroupedRowModel: () => {
-        if (
-          !instance._getGroupedRowModel &&
-          instance.options.getGroupedRowModel
-        ) {
-          instance._getGroupedRowModel =
-            instance.options.getGroupedRowModel(instance)
+        if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {
+          table._getGroupedRowModel = table.options.getGroupedRowModel(table)
         }
 
-        if (instance.options.manualGrouping || !instance._getGroupedRowModel) {
-          return instance.getPreGroupedRowModel()
+        if (table.options.manualGrouping || !table._getGroupedRowModel) {
+          return table.getPreGroupedRowModel()
         }
 
-        return instance._getGroupedRowModel()
+        return table._getGroupedRowModel()
       },
     }
   },
 
-  createRow: <TGenerics extends TableGenerics>(
-    row: Row<TGenerics>
-  ): GroupingRow => {
+  createRow: <TData extends RowData>(row: Row<TData>): GroupingRow => {
     return {
       getIsGrouped: () => !!row.groupingColumnId,
       _groupingValuesCache: {},
     }
   },
 
-  createCell: <TGenerics extends TableGenerics>(
-    cell: Cell<TGenerics>,
-    column: Column<TGenerics>,
-    row: Row<TGenerics>,
-    instance: TableInstance<TGenerics>
-  ): GroupingCell<TGenerics> => {
+  createCell: <TData extends RowData>(
+    cell: Cell<TData>,
+    column: Column<TData>,
+    row: Row<TData>,
+    table: Table<TData>
+  ): GroupingCell => {
     const getRenderValue = () =>
-      cell.getValue() ?? instance.options.renderFallbackValue
+      cell.getValue() ?? table.options.renderFallbackValue
 
     return {
       getIsGrouped: () =>
@@ -259,34 +232,12 @@ export const Grouping: TableFeature = {
         !cell.getIsGrouped() &&
         !cell.getIsPlaceholder() &&
         !!row.subRows?.length,
-      renderAggregatedCell: () => {
-        if (process.env.NODE_ENV === 'development') {
-          if (!column.columnDef.aggregatedCell) {
-            console.warn(
-              'A columnDef.aggregatedCell template is recommended for displaying aggregated values.'
-            )
-          }
-        }
-
-        const template =
-          column.columnDef.aggregatedCell || column.columnDef.cell
-
-        return template
-          ? instance._render(template, {
-              instance,
-              column,
-              row,
-              cell,
-              getValue: getRenderValue,
-            })
-          : null
-      },
     }
   },
 }
 
-export function orderColumns<TGenerics extends TableGenerics>(
-  leafColumns: Column<TGenerics>[],
+export function orderColumns<TData extends RowData>(
+  leafColumns: Column<TData>[],
   grouping: string[],
   groupedColumnMode?: GroupingColumnMode
 ) {

package/src/features/Ordering.ts

@@ -1,15 +1,16 @@
 import { makeStateUpdater, memo } from '../utils'
 
 import {
-  TableInstance,
+  Table,
   OnChangeFn,
   Updater,
   Column,
   TableGenerics,
+  RowData,
 } from '../types'
 
 import { Grouping, orderColumns } from './Grouping'
-import { TableFeature } from '../core/instance'
+import { TableFeature } from '../core/table'
 
 export type ColumnOrderTableState = {
   columnOrder: ColumnOrderState
@@ -25,12 +26,10 @@ export type ColumnOrderDefaultOptions = {
   onColumnOrderChange: OnChangeFn<ColumnOrderState>
 }
 
-export type ColumnOrderInstance<TGenerics extends TableGenerics> = {
+export type ColumnOrderInstance<TData extends RowData> = {
   setColumnOrder: (updater: Updater<ColumnOrderState>) => void
   resetColumnOrder: (defaultState?: boolean) => void
-  _getOrderColumnsFn: () => (
-    columns: Column<TGenerics>[]
-  ) => Column<TGenerics>[]
+  _getOrderColumnsFn: () => (columns: Column<TData>[]) => Column<TData>[]
 }
 
 //
@@ -43,35 +42,34 @@ export const Ordering: TableFeature = {
     }
   },
 
-  getDefaultOptions: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
+  getDefaultOptions: <TData extends RowData>(
+    table: Table<TData>
   ): ColumnOrderDefaultOptions => {
     return {
-      onColumnOrderChange: makeStateUpdater('columnOrder', instance),
+      onColumnOrderChange: makeStateUpdater('columnOrder', table),
     }
   },
 
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): ColumnOrderInstance<TGenerics> => {
+  createTable: <TData extends RowData>(
+    table: Table<TData>
+  ): ColumnOrderInstance<TData> => {
     return {
-      setColumnOrder: updater =>
-        instance.options.onColumnOrderChange?.(updater),
+      setColumnOrder: updater => table.options.onColumnOrderChange?.(updater),
       resetColumnOrder: defaultState => {
-        instance.setColumnOrder(
-          defaultState ? [] : instance.initialState.columnOrder ?? []
+        table.setColumnOrder(
+          defaultState ? [] : table.initialState.columnOrder ?? []
         )
       },
       _getOrderColumnsFn: memo(
         () => [
-          instance.getState().columnOrder,
-          instance.getState().grouping,
-          instance.options.groupedColumnMode,
+          table.getState().columnOrder,
+          table.getState().grouping,
+          table.options.groupedColumnMode,
         ],
         (columnOrder, grouping, groupedColumnMode) => columns => {
           // Sort grouped columns to the start of the column list
           // before the headers are built
-          let orderedColumns: Column<TGenerics>[] = []
+          let orderedColumns: Column<TData>[] = []
 
           // If there is no order, return the normal columns
           if (!columnOrder?.length) {
@@ -103,7 +101,7 @@ export const Ordering: TableFeature = {
         },
         {
           key: process.env.NODE_ENV === 'development' && 'getOrderColumnsFn',
-          // debug: () => instance.options.debugAll ?? instance.options.debugTable,
+          // debug: () => table.options.debugAll ?? table.options.debugTable,
         }
       ),
     }

package/src/features/Pagination.ts

@@ -1,10 +1,11 @@
-import { TableFeature } from '../core/instance'
+import { TableFeature } from '../core/table'
 import {
   OnChangeFn,
   TableGenerics,
-  TableInstance,
+  Table,
   RowModel,
   Updater,
+  RowData,
 } from '../types'
 import { functionalUpdate, makeStateUpdater, memo } from '../utils'
 
@@ -21,19 +22,19 @@ export type PaginationInitialTableState = {
   pagination?: Partial<PaginationState>
 }
 
-export type PaginationOptions<TGenerics extends TableGenerics> = {
+export type PaginationOptions = {
   pageCount?: number
   manualPagination?: boolean
   onPaginationChange?: OnChangeFn<PaginationState>
   autoResetPageIndex?: boolean
-  getPaginationRowModel?: (instance: TableInstance<any>) => () => RowModel<any>
+  getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>
 }
 
 export type PaginationDefaultOptions = {
   onPaginationChange: OnChangeFn<PaginationState>
 }
 
-export type PaginationInstance<TGenerics extends TableGenerics> = {
+export type PaginationInstance<TData extends RowData> = {
   _autoResetPageIndex: () => void
   setPagination: (updater: Updater<PaginationState>) => void
   resetPagination: (defaultState?: boolean) => void
@@ -47,9 +48,9 @@ export type PaginationInstance<TGenerics extends TableGenerics> = {
   getCanNextPage: () => boolean
   previousPage: () => void
   nextPage: () => void
-  getPrePaginationRowModel: () => RowModel<TGenerics>
-  getPaginationRowModel: () => RowModel<TGenerics>
-  _getPaginationRowModel?: () => RowModel<TGenerics>
+  getPrePaginationRowModel: () => RowModel<TData>
+  getPaginationRowModel: () => RowModel<TData>
+  _getPaginationRowModel?: () => RowModel<TData>
   getPageCount: () => number
 }
 
@@ -74,38 +75,38 @@ export const Pagination: TableFeature = {
     }
   },
 
-  getDefaultOptions: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
+  getDefaultOptions: <TData extends RowData>(
+    table: Table<TData>
   ): PaginationDefaultOptions => {
     return {
-      onPaginationChange: makeStateUpdater('pagination', instance),
+      onPaginationChange: makeStateUpdater('pagination', table),
     }
   },
 
-  createInstance: <TGenerics extends TableGenerics>(
-    instance: TableInstance<TGenerics>
-  ): PaginationInstance<TGenerics> => {
+  createTable: <TData extends RowData>(
+    table: Table<TData>
+  ): PaginationInstance<TData> => {
     let registered = false
     let queued = false
 
     return {
       _autoResetPageIndex: () => {
         if (!registered) {
-          instance._queue(() => {
+          table._queue(() => {
             registered = true
           })
           return
         }
 
         if (
-          instance.options.autoResetAll ??
-          instance.options.autoResetPageIndex ??
-          !instance.options.manualPagination
+          table.options.autoResetAll ??
+          table.options.autoResetPageIndex ??
+          !table.options.manualPagination
         ) {
           if (queued) return
           queued = true
-          instance._queue(() => {
-            instance.resetPageIndex()
+          table._queue(() => {
+            table.resetPageIndex()
             queued = false
           })
         }
@@ -117,23 +118,24 @@ export const Pagination: TableFeature = {
           return newState
         }
 
-        return instance.options.onPaginationChange?.(safeUpdater)
+        return table.options.onPaginationChange?.(safeUpdater)
       },
       resetPagination: defaultState => {
-        instance.setPagination(
+        table.setPagination(
           defaultState
             ? getDefaultPaginationState()
-            : instance.initialState.pagination ?? getDefaultPaginationState()
+            : table.initialState.pagination ?? getDefaultPaginationState()
         )
       },
       setPageIndex: updater => {
-        instance.setPagination(old => {
+        table.setPagination(old => {
           let pageIndex = functionalUpdate(updater, old.pageIndex)
 
           const maxPageIndex =
-            (typeof instance.options.pageCount === 'undefined' || instance.options.pageCount === -1) ?
-              Number.MAX_SAFE_INTEGER
-              : instance.options.pageCount - 1
+            typeof table.options.pageCount === 'undefined' ||
+            table.options.pageCount === -1
+              ? Number.MAX_SAFE_INTEGER
+              : table.options.pageCount - 1
 
           pageIndex = Math.min(Math.max(0, pageIndex), maxPageIndex)
 
@@ -144,21 +146,21 @@ export const Pagination: TableFeature = {
         })
       },
       resetPageIndex: defaultState => {
-        instance.setPageIndex(
+        table.setPageIndex(
           defaultState
             ? defaultPageIndex
-            : instance.initialState?.pagination?.pageIndex ?? defaultPageIndex
+            : table.initialState?.pagination?.pageIndex ?? defaultPageIndex
         )
       },
       resetPageSize: defaultState => {
-        instance.setPageSize(
+        table.setPageSize(
           defaultState
             ? defaultPageSize
-            : instance.initialState?.pagination?.pageSize ?? defaultPageSize
+            : table.initialState?.pagination?.pageSize ?? defaultPageSize
         )
       },
       setPageSize: updater => {
-        instance.setPagination(old => {
+        table.setPagination(old => {
           const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))
           const topRowIndex = old.pageSize * old.pageIndex!
           const pageIndex = Math.floor(topRowIndex / pageSize)
@@ -171,10 +173,10 @@ export const Pagination: TableFeature = {
         })
       },
       setPageCount: updater =>
-        instance.setPagination(old => {
+        table.setPagination(old => {
           let newPageCount = functionalUpdate(
             updater,
-            instance.options.pageCount ?? -1
+            table.options.pageCount ?? -1
           )
 
           if (typeof newPageCount === 'number') {
@@ -188,7 +190,7 @@ export const Pagination: TableFeature = {
         }),
 
       getPageOptions: memo(
-        () => [instance.getPageCount()],
+        () => [table.getPageCount()],
         pageCount => {
           let pageOptions: number[] = []
           if (pageCount && pageCount > 0) {
@@ -198,16 +200,16 @@ export const Pagination: TableFeature = {
         },
         {
           key: process.env.NODE_ENV === 'development' && 'getPageOptions',
-          debug: () => instance.options.debugAll ?? instance.options.debugTable,
+          debug: () => table.options.debugAll ?? table.options.debugTable,
         }
       ),
 
-      getCanPreviousPage: () => instance.getState().pagination.pageIndex > 0,
+      getCanPreviousPage: () => table.getState().pagination.pageIndex > 0,
 
       getCanNextPage: () => {
-        const { pageIndex } = instance.getState().pagination
+        const { pageIndex } = table.getState().pagination
 
-        const pageCount = instance.getPageCount()
+        const pageCount = table.getPageCount()
 
         if (pageCount === -1) {
           return true
@@ -221,41 +223,38 @@ export const Pagination: TableFeature = {
       },
 
       previousPage: () => {
-        return instance.setPageIndex(old => old - 1)
+        return table.setPageIndex(old => old - 1)
       },
 
       nextPage: () => {
-        return instance.setPageIndex(old => {
+        return table.setPageIndex(old => {
           return old + 1
         })
       },
 
-      getPrePaginationRowModel: () => instance.getExpandedRowModel(),
+      getPrePaginationRowModel: () => table.getExpandedRowModel(),
       getPaginationRowModel: () => {
         if (
-          !instance._getPaginationRowModel &&
-          instance.options.getPaginationRowModel
+          !table._getPaginationRowModel &&
+          table.options.getPaginationRowModel
         ) {
-          instance._getPaginationRowModel =
-            instance.options.getPaginationRowModel(instance)
+          table._getPaginationRowModel =
+            table.options.getPaginationRowModel(table)
         }
 
-        if (
-          instance.options.manualPagination ||
-          !instance._getPaginationRowModel
-        ) {
-          return instance.getPrePaginationRowModel()
+        if (table.options.manualPagination || !table._getPaginationRowModel) {
+          return table.getPrePaginationRowModel()
         }
 
-        return instance._getPaginationRowModel()
+        return table._getPaginationRowModel()
       },
 
       getPageCount: () => {
         return (
-          instance.options.pageCount ??
+          table.options.pageCount ??
           Math.ceil(
-            instance.getPrePaginationRowModel().rows.length /
-            instance.getState().pagination.pageSize
+            table.getPrePaginationRowModel().rows.length /
+              table.getState().pagination.pageSize
           )
         )
       },