@tanstack/table-core 8.5.19 → 8.5.20

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.5.19",
+  "version": "8.5.20",
   "description": "Headless UI for building powerful tables & datagrids for TS/JS.",
   "license": "MIT",
   "homepage": "https://github.com/tanstack/table#readme",

package/src/columnHelper.ts

@@ -1,12 +1,12 @@
 import {
+  AccessorColumnDef,
   AccessorFn,
-  ColumnDef,
   DisplayColumnDef,
   GroupColumnDef,
   IdentifiedColumnDef,
   RowData,
 } from './types'
-import { DeepKeys, DeepValue, RequiredKeys } from './utils'
+import { DeepValue } from './utils'
 
 // type Person = {
 //   firstName: string
@@ -49,22 +49,29 @@ import { DeepKeys, DeepValue, RequiredKeys } from './utils'
 //   cell: info => info.getValue(),
 // })
 
-export type ColumnHelper<TData extends RowData> = {
-  accessor: <
-    TAccessor extends AccessorFn<TData> | DeepKeys<TData>,
-    TValue extends TAccessor extends AccessorFn<TData, infer TReturn>
-      ? TReturn
-      : TAccessor extends DeepKeys<TData>
-      ? DeepValue<TData, TAccessor>
-      : never
-  >(
-    accessor: TAccessor,
-    column: TAccessor extends AccessorFn<TData>
-      ? DisplayColumnDef<TData, TValue>
-      : IdentifiedColumnDef<TData, TValue>
-  ) => ColumnDef<TData, TValue>
-  display: (column: DisplayColumnDef<TData>) => ColumnDef<TData, unknown>
-  group: (column: GroupColumnDef<TData>) => ColumnDef<TData, unknown>
+type AccessorType<TData, TAccessor> = TAccessor extends AccessorFn<
+  TData,
+  infer TReturn
+>
+  ? TReturn
+  : DeepValue<TData, TAccessor>
+
+type Accessor<TData extends RowData> = <
+  TAccessor extends AccessorFn<TData> | string,
+  TValue extends AccessorType<TData, TAccessor>
+>(
+  accessor: TAccessor,
+  column: TAccessor extends AccessorFn<TData>
+    ? DisplayColumnDef<TData, TValue>
+    : IdentifiedColumnDef<TData, TValue>
+) => TValue extends never
+  ? never
+  : AccessorColumnDef<TData, AccessorType<TData, TAccessor>>
+
+export interface ColumnHelper<TData extends RowData> {
+  accessor: Accessor<TData>
+  display: (column: DisplayColumnDef<TData>) => DisplayColumnDef<TData>
+  group: (column: GroupColumnDef<TData>) => GroupColumnDef<TData>
 }
 
 export function createColumnHelper<
@@ -82,7 +89,7 @@ export function createColumnHelper<
             accessorKey: accessor,
           }
     },
-    display: column => column as ColumnDef<TData, unknown>,
-    group: column => column as ColumnDef<TData, unknown>,
+    display: column => column as DisplayColumnDef<TData>,
+    group: column => column as GroupColumnDef<TData>,
   }
 }

package/src/core/cell.ts

@@ -1,7 +1,7 @@
 import { RowData, Cell, Column, Row, Table } from '../types'
 import { Getter, memo } from '../utils'
 
-export type CellContext<TData extends RowData, TValue> = {
+export interface CellContext<TData extends RowData, TValue> {
   table: Table<TData>
   column: Column<TData, TValue>
   row: Row<TData>
@@ -10,7 +10,7 @@ export type CellContext<TData extends RowData, TValue> = {
   renderValue: Getter<TValue | null>
 }
 
-export type CoreCell<TData extends RowData, TValue> = {
+export interface CoreCell<TData extends RowData, TValue> {
   id: string
   getValue: CellContext<TData, TValue>['getValue']
   renderValue: CellContext<TData, TValue>['renderValue']
@@ -24,7 +24,7 @@ export function createCell<TData extends RowData, TValue>(
   row: Row<TData>,
   column: Column<TData, TValue>,
   columnId: string
-) {
+): Cell<TData, TValue> {
   const getRenderValue = () =>
     cell.getValue() ?? table.options.renderFallbackValue
 

package/src/core/column.ts

@@ -1,17 +1,14 @@
-import { TaggedTemplateExpression } from '@babel/types'
 import {
   Column,
   Table,
   AccessorFn,
   ColumnDef,
-  ColumnDefTemplate,
   RowData,
-  ColumnMeta,
   ColumnDefResolved,
 } from '../types'
 import { memo } from '../utils'
 
-export type CoreColumn<TData extends RowData, TValue> = {
+export interface CoreColumn<TData extends RowData, TValue> {
   id: string
   depth: number
   accessorFn?: AccessorFn<TData, TValue>
@@ -27,7 +24,7 @@ export function createColumn<TData extends RowData, TValue>(
   columnDef: ColumnDef<TData, TValue>,
   depth: number,
   parent?: Column<TData, TValue>
-) {
+): Column<TData, TValue> {
   const defaultColumn = table._getDefaultColumnDef()
 
   const resolvedColumnDef = {

package/src/core/headers.ts

@@ -2,19 +2,19 @@ import { RowData, Column, Header, HeaderGroup, Table } from '../types'
 import { memo } from '../utils'
 import { TableFeature } from './table'
 
-export type CoreHeaderGroup<TData extends RowData> = {
+export interface CoreHeaderGroup<TData extends RowData> {
   id: string
   depth: number
   headers: Header<TData, unknown>[]
 }
 
-export type HeaderContext<TData, TValue> = {
+export interface HeaderContext<TData, TValue> {
   table: Table<TData>
   header: Header<TData, TValue>
   column: Column<TData, TValue>
 }
 
-export type CoreHeader<TData extends RowData, TValue> = {
+export interface CoreHeader<TData extends RowData, TValue> {
   id: string
   index: number
   depth: number
@@ -29,7 +29,7 @@ export type CoreHeader<TData extends RowData, TValue> = {
   getContext: () => HeaderContext<TData, TValue>
 }
 
-export type HeadersInstance<TData extends RowData> = {
+export interface HeadersInstance<TData extends RowData> {
   getHeaderGroups: () => HeaderGroup<TData>[]
   getLeftHeaderGroups: () => HeaderGroup<TData>[]
   getCenterHeaderGroups: () => HeaderGroup<TData>[]
@@ -63,7 +63,7 @@ function createHeader<TData extends RowData, TValue>(
     index: number
     depth: number
   }
-) {
+): Header<TData, TValue> {
   const id = options.id ?? column.id
 
   let header: CoreHeader<TData, TValue> = {

package/src/core/row.ts

@@ -2,7 +2,7 @@ import { RowData, Cell, Row, Table } from '../types'
 import { flattenBy, memo } from '../utils'
 import { createCell } from './cell'
 
-export type CoreRow<TData extends RowData> = {
+export interface CoreRow<TData extends RowData> {
   id: string
   index: number
   original: TData

package/src/core/table.ts

@@ -1,11 +1,10 @@
-import { flattenBy, functionalUpdate, memo, RequiredKeys } from '../utils'
+import { functionalUpdate, memo, RequiredKeys } from '../utils'
 
 import {
   Updater,
   TableOptionsResolved,
   TableState,
   Table,
-  ColumnDefTemplate,
   InitialTableState,
   Row,
   Column,
@@ -26,7 +25,7 @@ import { Headers } from './headers'
 import { ColumnSizing } from '../features/ColumnSizing'
 import { Expanding } from '../features/Expanding'
 import { Filters } from '../features/Filters'
-import { Grouping, GroupingColumnDef } from '../features/Grouping'
+import { Grouping } from '../features/Grouping'
 import { Ordering } from '../features/Ordering'
 import { Pagination } from '../features/Pagination'
 import { Pinning } from '../features/Pinning'
@@ -34,7 +33,7 @@ import { RowSelection } from '../features/RowSelection'
 import { Sorting } from '../features/Sorting'
 import { Visibility } from '../features/Visibility'
 
-export type TableFeature = {
+export interface TableFeature {
   getDefaultOptions?: (table: any) => any
   getInitialState?: (initialState?: InitialTableState) => any
   createTable?: (table: any) => any
@@ -61,9 +60,9 @@ const features = [
 
 //
 
-export type CoreTableState = {}
+export interface CoreTableState {}
 
-export type CoreOptions<TData extends RowData> = {
+export interface CoreOptions<TData extends RowData> {
   data: TData[]
   state: Partial<TableState>
   onStateChange: (updater: Updater<TableState>) => void
@@ -87,7 +86,7 @@ export type CoreOptions<TData extends RowData> = {
   renderFallbackValue: any
 }
 
-export type CoreInstance<TData extends RowData> = {
+export interface CoreInstance<TData extends RowData> {
   initialState: TableState
   reset: () => void
   options: RequiredKeys<TableOptionsResolved<TData>, 'state'>

package/src/features/ColumnSizing.ts

@@ -5,14 +5,14 @@ import { ColumnPinningPosition } from './Pinning'
 
 //
 
-export type ColumnSizingTableState = {
+export interface ColumnSizingTableState {
   columnSizing: ColumnSizingState
   columnSizingInfo: ColumnSizingInfoState
 }
 
 export type ColumnSizingState = Record<string, number>
 
-export type ColumnSizingInfoState = {
+export interface ColumnSizingInfoState {
   startOffset: null | number
   startSize: null | number
   deltaOffset: null | number
@@ -23,20 +23,20 @@ export type ColumnSizingInfoState = {
 
 export type ColumnResizeMode = 'onChange' | 'onEnd'
 
-export type ColumnSizingOptions = {
+export interface ColumnSizingOptions {
   enableColumnResizing?: boolean
   columnResizeMode?: ColumnResizeMode
   onColumnSizingChange?: OnChangeFn<ColumnSizingState>
   onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>
 }
 
-export type ColumnSizingDefaultOptions = {
+export interface ColumnSizingDefaultOptions {
   columnResizeMode: ColumnResizeMode
   onColumnSizingChange: OnChangeFn<ColumnSizingState>
   onColumnSizingInfoChange: OnChangeFn<ColumnSizingInfoState>
 }
 
-export type ColumnSizingInstance = {
+export interface ColumnSizingInstance {
   setColumnSizing: (updater: Updater<ColumnSizingState>) => void
   setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void
   resetColumnSizing: (defaultState?: boolean) => void
@@ -47,14 +47,14 @@ export type ColumnSizingInstance = {
   getRightTotalSize: () => number
 }
 
-export type ColumnSizingColumnDef = {
+export interface ColumnSizingColumnDef {
   enableResizing?: boolean
   size?: number
   minSize?: number
   maxSize?: number
 }
 
-export type ColumnSizingColumn = {
+export interface ColumnSizingColumn {
   getSize: () => number
   getStart: (position?: ColumnPinningPosition) => number
   getCanResize: () => boolean
@@ -62,7 +62,7 @@ export type ColumnSizingColumn = {
   resetSize: () => void
 }
 
-export type ColumnSizingHeader = {
+export interface ColumnSizingHeader {
   getSize: () => number
   getStart: (position?: ColumnPinningPosition) => number
   getResizeHandler: () => (event: unknown) => void

package/src/features/Expanding.ts

@@ -5,18 +5,18 @@ import { makeStateUpdater } from '../utils'
 
 export type ExpandedStateList = Record<string, boolean>
 export type ExpandedState = true | Record<string, boolean>
-export type ExpandedTableState = {
+export interface ExpandedTableState {
   expanded: ExpandedState
 }
 
-export type ExpandedRow = {
+export interface ExpandedRow {
   toggleExpanded: (expanded?: boolean) => void
   getIsExpanded: () => boolean
   getCanExpand: () => boolean
   getToggleExpandedHandler: () => () => void
 }
 
-export type ExpandedOptions<TData extends RowData> = {
+export interface ExpandedOptions<TData extends RowData> {
   manualExpanding?: boolean
   onExpandedChange?: OnChangeFn<ExpandedState>
   autoResetExpanded?: boolean
@@ -27,7 +27,7 @@ export type ExpandedOptions<TData extends RowData> = {
   paginateExpandedRows?: boolean
 }
 
-export type ExpandedInstance<TData extends RowData> = {
+export interface ExpandedInstance<TData extends RowData> {
   _autoResetExpanded: () => void
   setExpanded: (updater: Updater<ExpandedState>) => void
   toggleAllRowsExpanded: (expanded?: boolean) => void

package/src/features/Filters.ts

@@ -13,25 +13,25 @@ import {
 } from '../types'
 import { functionalUpdate, isFunction, makeStateUpdater } from '../utils'
 
-export type FiltersTableState = {
+export interface FiltersTableState {
   columnFilters: ColumnFiltersState
   globalFilter: any
 }
 
 export type ColumnFiltersState = ColumnFilter[]
 
-export type ColumnFilter = {
+export interface ColumnFilter {
   id: string
   value: unknown
 }
 
-export type ResolvedColumnFilter<TData extends RowData> = {
+export interface ResolvedColumnFilter<TData extends RowData> {
   id: string
   resolvedValue: unknown
   filterFn: FilterFn<TData>
 }
 
-export type FilterFn<TData extends RowData> = {
+export interface FilterFn<TData extends RowData> {
   (
     row: Row<TData>,
     columnId: string,
@@ -64,13 +64,13 @@ export type FilterFnOption<TData extends RowData> =
   | keyof FilterFns
   | FilterFn<TData>
 
-export type FiltersColumnDef<TData extends RowData> = {
+export interface FiltersColumnDef<TData extends RowData> {
   filterFn?: FilterFnOption<TData>
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
 }
 
-export type FiltersColumn<TData extends RowData> = {
+export interface FiltersColumn<TData extends RowData> {
   getAutoFilterFn: () => FilterFn<TData> | undefined
   getFilterFn: () => FilterFn<TData> | undefined
   setFilterValue: (updater: Updater<any>) => void
@@ -87,12 +87,12 @@ export type FiltersColumn<TData extends RowData> = {
   _getFacetedMinMaxValues?: () => undefined | [number, number]
 }
 
-export type FiltersRow<TData extends RowData> = {
+export interface FiltersRow<TData extends RowData> {
   columnFilters: Record<string, boolean>
   columnFiltersMeta: Record<string, FilterMeta>
 }
 
-export type FiltersOptions<TData extends RowData> = {
+interface FiltersOptionsBase<TData extends RowData> {
   enableFilters?: boolean
   manualFiltering?: boolean
   filterFromLeafRows?: boolean
@@ -121,15 +121,21 @@ export type FiltersOptions<TData extends RowData> = {
     table: Table<TData>,
     columnId: string
   ) => () => undefined | [number, number]
-} & (keyof FilterFns extends never
+}
+
+type ResolvedFilterFns = keyof FilterFns extends never
   ? {
       filterFns?: Record<string, FilterFn<any>>
     }
   : {
       filterFns: Record<keyof FilterFns, FilterFn<any>>
-    })
+    }
+
+export interface FiltersOptions<TData extends RowData>
+  extends FiltersOptionsBase<TData>,
+    ResolvedFilterFns {}
 
-export type FiltersInstance<TData extends RowData> = {
+export interface FiltersInstance<TData extends RowData> {
   setColumnFilters: (updater: Updater<ColumnFiltersState>) => void
 
   resetColumnFilters: (defaultState?: boolean) => void

package/src/features/Grouping.ts

@@ -16,7 +16,7 @@ import { isFunction, makeStateUpdater } from '../utils'
 
 export type GroupingState = string[]
 
-export type GroupingTableState = {
+export interface GroupingTableState {
   grouping: GroupingState
 }
 
@@ -34,7 +34,7 @@ export type AggregationFnOption<TData extends RowData> =
   | BuiltInAggregationFn
   | AggregationFn<TData>
 
-export type GroupingColumnDef<TData extends RowData, TValue> = {
+export interface GroupingColumnDef<TData extends RowData, TValue> {
   aggregationFn?: AggregationFnOption<TData>
   aggregatedCell?: ColumnDefTemplate<
     ReturnType<Cell<TData, TValue>['getContext']>
@@ -42,7 +42,7 @@ export type GroupingColumnDef<TData extends RowData, TValue> = {
   enableGrouping?: boolean
 }
 
-export type GroupingColumn<TData extends RowData> = {
+export interface GroupingColumn<TData extends RowData> {
   getCanGroup: () => boolean
   getIsGrouped: () => boolean
   getGroupedIndex: () => number
@@ -52,42 +52,48 @@ export type GroupingColumn<TData extends RowData> = {
   getAggregationFn: () => AggregationFn<TData> | undefined
 }
 
-export type GroupingRow = {
+export interface GroupingRow {
   groupingColumnId?: string
   groupingValue?: unknown
   getIsGrouped: () => boolean
   _groupingValuesCache: Record<string, any>
 }
 
-export type GroupingCell = {
+export interface GroupingCell {
   getIsGrouped: () => boolean
   getIsPlaceholder: () => boolean
   getIsAggregated: () => boolean
 }
 
-export type ColumnDefaultOptions = {
+export interface ColumnDefaultOptions {
   // Column
   onGroupingChange: OnChangeFn<GroupingState>
   enableGrouping: boolean
 }
 
-export type GroupingOptions = {
+interface GroupingOptionsBase {
   manualGrouping?: boolean
   onGroupingChange?: OnChangeFn<GroupingState>
   enableGrouping?: boolean
   getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>
   groupedColumnMode?: false | 'reorder' | 'remove'
-} & (keyof AggregationFns extends never
+}
+
+type ResolvedAggregationFns = keyof AggregationFns extends never
   ? {
       aggregationFns?: Record<string, AggregationFn<any>>
     }
   : {
       aggregationFns: Record<keyof AggregationFns, AggregationFn<any>>
-    })
+    }
+
+export interface GroupingOptions
+  extends GroupingOptionsBase,
+    ResolvedAggregationFns {}
 
 export type GroupingColumnMode = false | 'reorder' | 'remove'
 
-export type GroupingInstance<TData extends RowData> = {
+export interface GroupingInstance<TData extends RowData> {
   setGrouping: (updater: Updater<GroupingState>) => void
   resetGrouping: (defaultState?: boolean) => void
   getPreGroupedRowModel: () => RowModel<TData>

package/src/features/Ordering.ts

@@ -2,24 +2,24 @@ import { makeStateUpdater, memo } from '../utils'
 
 import { Table, OnChangeFn, Updater, Column, RowData } from '../types'
 
-import { Grouping, orderColumns } from './Grouping'
+import { orderColumns } from './Grouping'
 import { TableFeature } from '../core/table'
 
-export type ColumnOrderTableState = {
+export interface ColumnOrderTableState {
   columnOrder: ColumnOrderState
 }
 
 export type ColumnOrderState = string[]
 
-export type ColumnOrderOptions = {
+export interface ColumnOrderOptions {
   onColumnOrderChange?: OnChangeFn<ColumnOrderState>
 }
 
-export type ColumnOrderDefaultOptions = {
+export interface ColumnOrderDefaultOptions {
   onColumnOrderChange: OnChangeFn<ColumnOrderState>
 }
 
-export type ColumnOrderInstance<TData extends RowData> = {
+export interface ColumnOrderInstance<TData extends RowData> {
   setColumnOrder: (updater: Updater<ColumnOrderState>) => void
   resetColumnOrder: (defaultState?: boolean) => void
   _getOrderColumnsFn: () => (

package/src/features/Pagination.ts

@@ -2,20 +2,20 @@ import { TableFeature } from '../core/table'
 import { OnChangeFn, Table, RowModel, Updater, RowData } from '../types'
 import { functionalUpdate, makeStateUpdater, memo } from '../utils'
 
-export type PaginationState = {
+export interface PaginationState {
   pageIndex: number
   pageSize: number
 }
 
-export type PaginationTableState = {
+export interface PaginationTableState {
   pagination: PaginationState
 }
 
-export type PaginationInitialTableState = {
+export interface PaginationInitialTableState {
   pagination?: Partial<PaginationState>
 }
 
-export type PaginationOptions = {
+export interface PaginationOptions {
   pageCount?: number
   manualPagination?: boolean
   onPaginationChange?: OnChangeFn<PaginationState>
@@ -23,11 +23,11 @@ export type PaginationOptions = {
   getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>
 }
 
-export type PaginationDefaultOptions = {
+export interface PaginationDefaultOptions {
   onPaginationChange: OnChangeFn<PaginationState>
 }
 
-export type PaginationInstance<TData extends RowData> = {
+export interface PaginationInstance<TData extends RowData> {
   _autoResetPageIndex: () => void
   setPagination: (updater: Updater<PaginationState>) => void
   resetPagination: (defaultState?: boolean) => void

package/src/features/Pinning.ts

@@ -12,42 +12,42 @@ import { makeStateUpdater, memo } from '../utils'
 
 export type ColumnPinningPosition = false | 'left' | 'right'
 
-export type ColumnPinningState = {
+export interface ColumnPinningState {
   left?: string[]
   right?: string[]
 }
 
-export type ColumnPinningTableState = {
+export interface ColumnPinningTableState {
   columnPinning: ColumnPinningState
 }
 
-export type ColumnPinningOptions = {
+export interface ColumnPinningOptions {
   onColumnPinningChange?: OnChangeFn<ColumnPinningState>
   enablePinning?: boolean
 }
 
-export type ColumnPinningDefaultOptions = {
+export interface ColumnPinningDefaultOptions {
   onColumnPinningChange: OnChangeFn<ColumnPinningState>
 }
 
-export type ColumnPinningColumnDef = {
+export interface ColumnPinningColumnDef {
   enablePinning?: boolean
 }
 
-export type ColumnPinningColumn = {
+export interface ColumnPinningColumn {
   getCanPin: () => boolean
   getPinnedIndex: () => number
   getIsPinned: () => ColumnPinningPosition
   pin: (position: ColumnPinningPosition) => void
 }
 
-export type ColumnPinningRow<TData extends RowData> = {
+export interface ColumnPinningRow<TData extends RowData> {
   getLeftVisibleCells: () => Cell<TData, unknown>[]
   getCenterVisibleCells: () => Cell<TData, unknown>[]
   getRightVisibleCells: () => Cell<TData, unknown>[]
 }
 
-export type ColumnPinningInstance<TData extends RowData> = {
+export interface ColumnPinningInstance<TData extends RowData> {
   setColumnPinning: (updater: Updater<ColumnPinningState>) => void
   resetColumnPinning: (defaultState?: boolean) => void
   getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean

package/src/features/RowSelection.ts

@@ -4,11 +4,11 @@ import { makeStateUpdater, memo } from '../utils'
 
 export type RowSelectionState = Record<string, boolean>
 
-export type RowSelectionTableState = {
+export interface RowSelectionTableState {
   rowSelection: RowSelectionState
 }
 
-export type RowSelectionOptions<TData extends RowData> = {
+export interface RowSelectionOptions<TData extends RowData> {
   enableRowSelection?: boolean | ((row: Row<TData>) => boolean)
   enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean)
   enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean)
@@ -26,7 +26,7 @@ export type RowSelectionOptions<TData extends RowData> = {
   // ) => RowModel<TData>
 }
 
-export type RowSelectionRow = {
+export interface RowSelectionRow {
   getIsSelected: () => boolean
   getIsSomeSelected: () => boolean
   getIsAllSubRowsSelected: () => boolean
@@ -37,7 +37,7 @@ export type RowSelectionRow = {
   getToggleSelectedHandler: () => (event: unknown) => void
 }
 
-export type RowSelectionInstance<TData extends RowData> = {
+export interface RowSelectionInstance<TData extends RowData> {
   getToggleAllRowsSelectedHandler: () => (event: unknown) => void
   getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void
   setRowSelection: (updater: Updater<RowSelectionState>) => void