@tanstack/table-core 8.5.18 → 8.5.20

package/src/features/Sorting.ts

@@ -20,18 +20,18 @@ import { isFunction, makeStateUpdater } from '../utils'
 
 export type SortDirection = 'asc' | 'desc'
 
-export type ColumnSort = {
+export interface ColumnSort {
   id: string
   desc: boolean
 }
 
 export type SortingState = ColumnSort[]
 
-export type SortingTableState = {
+export interface SortingTableState {
   sorting: SortingState
 }
 
-export type SortingFn<TData extends RowData> = {
+export interface SortingFn<TData extends RowData> {
   (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number
 }
 
@@ -46,7 +46,7 @@ export type SortingFnOption<TData extends RowData> =
   | BuiltInSortingFn
   | SortingFn<TData>
 
-export type SortingColumnDef<TData extends RowData> = {
+export interface SortingColumnDef<TData extends RowData> {
   sortingFn?: SortingFnOption<TData>
   sortDescFirst?: boolean
   enableSorting?: boolean
@@ -55,7 +55,7 @@ export type SortingColumnDef<TData extends RowData> = {
   sortUndefined?: false | -1 | 1
 }
 
-export type SortingColumn<TData extends RowData> = {
+export interface SortingColumn<TData extends RowData> {
   getAutoSortingFn: () => SortingFn<TData>
   getAutoSortDir: () => SortDirection
   getSortingFn: () => SortingFn<TData>
@@ -70,7 +70,7 @@ export type SortingColumn<TData extends RowData> = {
   getToggleSortingHandler: () => undefined | ((event: unknown) => void)
 }
 
-export type SortingOptions<TData extends RowData> = {
+interface SortingOptionsBase {
   manualSorting?: boolean
   onSortingChange?: OnChangeFn<SortingState>
   enableSorting?: boolean
@@ -81,15 +81,21 @@ export type SortingOptions<TData extends RowData> = {
   getSortedRowModel?: (table: Table<any>) => () => RowModel<any>
   maxMultiSortColCount?: number
   isMultiSortEvent?: (e: unknown) => boolean
-} & (keyof SortingFns extends never
+}
+
+type ResolvedSortingFns = keyof SortingFns extends never
   ? {
       sortingFns?: Record<string, SortingFn<any>>
     }
   : {
       sortingFns: Record<keyof SortingFns, SortingFn<any>>
-    })
+    }
+
+export interface SortingOptions<TData extends RowData>
+  extends SortingOptionsBase,
+    ResolvedSortingFns {}
 
-export type SortingInstance<TData extends RowData> = {
+export interface SortingInstance<TData extends RowData> {
   setSorting: (updater: Updater<SortingState>) => void
   resetSorting: (defaultState?: boolean) => void
   getPreSortedRowModel: () => RowModel<TData>

package/src/features/Visibility.ts

@@ -12,20 +12,20 @@ import { makeStateUpdater, memo } from '../utils'
 
 export type VisibilityState = Record<string, boolean>
 
-export type VisibilityTableState = {
+export interface VisibilityTableState {
   columnVisibility: VisibilityState
 }
 
-export type VisibilityOptions = {
+export interface VisibilityOptions {
   onColumnVisibilityChange?: OnChangeFn<VisibilityState>
   enableHiding?: boolean
 }
 
-export type VisibilityDefaultOptions = {
+export interface VisibilityDefaultOptions {
   onColumnVisibilityChange: OnChangeFn<VisibilityState>
 }
 
-export type VisibilityInstance<TData extends RowData> = {
+export interface VisibilityInstance<TData extends RowData> {
   getVisibleFlatColumns: () => Column<TData, unknown>[]
   getVisibleLeafColumns: () => Column<TData, unknown>[]
   getLeftVisibleLeafColumns: () => Column<TData, unknown>[]
@@ -39,16 +39,16 @@ export type VisibilityInstance<TData extends RowData> = {
   getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void
 }
 
-export type VisibilityColumnDef = {
+export interface VisibilityColumnDef {
   enableHiding?: boolean
 }
 
-export type VisibilityRow<TData extends RowData> = {
+export interface VisibilityRow<TData extends RowData> {
   _getAllVisibleCells: () => Cell<TData, unknown>[]
   getVisibleCells: () => Cell<TData, unknown>[]
 }
 
-export type VisibilityColumn = {
+export interface VisibilityColumn {
   getCanHide: () => boolean
   getIsVisible: () => boolean
   toggleVisibility: (value?: boolean) => void

package/src/types.ts

@@ -27,7 +27,6 @@ import {
   HeadersInstance,
 } from './core/headers'
 import {
-  FilterFn,
   FiltersColumn,
   FiltersColumnDef,
   FiltersInstance,
@@ -43,7 +42,6 @@ import {
   SortingTableState,
 } from './features/Sorting'
 import {
-  CustomAggregationFns,
   GroupingCell,
   GroupingColumn,
   GroupingColumnDef,
@@ -79,15 +77,20 @@ import {
   RowSelectionTableState,
 } from './features/RowSelection'
 import { CoreRow } from './core/row'
-import { DeepKeys, PartialKeys, UnionToIntersection } from './utils'
+import { PartialKeys, UnionToIntersection } from './utils'
 import { CellContext, CoreCell } from './core/cell'
 import { CoreColumn } from './core/column'
 
 export interface TableMeta<TData extends RowData> {}
+
 export interface ColumnMeta<TData extends RowData, TValue> {}
+
 export interface FilterMeta {}
+
 export interface FilterFns {}
+
 export interface SortingFns {}
+
 export interface AggregationFns {}
 
 export type Updater<T> = T | ((old: T) => T)
@@ -97,71 +100,79 @@ export type RowData = unknown | object | any[]
 
 export type AnyRender = (Comp: any, props: any) => any
 
-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 interface Table<TData extends RowData>
+  extends CoreInstance<TData>,
+    HeadersInstance<TData>,
+    VisibilityInstance<TData>,
+    ColumnOrderInstance<TData>,
+    ColumnPinningInstance<TData>,
+    FiltersInstance<TData>,
+    SortingInstance<TData>,
+    GroupingInstance<TData>,
+    ColumnSizingInstance,
+    ExpandedInstance<TData>,
+    PaginationInstance<TData>,
+    RowSelectionInstance<TData> {}
+
+interface FeatureOptions<TData extends RowData>
+  extends VisibilityOptions,
+    ColumnOrderOptions,
+    ColumnPinningOptions,
+    FiltersOptions<TData>,
+    SortingOptions<TData>,
+    GroupingOptions,
+    ExpandedOptions<TData>,
+    ColumnSizingOptions,
+    PaginationOptions,
+    RowSelectionOptions<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 &
-  VisibilityTableState &
-  ColumnOrderTableState &
-  ColumnPinningTableState &
-  FiltersTableState &
-  SortingTableState &
-  ExpandedTableState &
-  GroupingTableState &
-  ColumnSizingTableState &
-  PaginationTableState &
-  RowSelectionTableState
-
-export type InitialTableState = Partial<
-  CoreTableState &
-    VisibilityTableState &
-    ColumnOrderTableState &
-    ColumnPinningTableState &
-    FiltersTableState &
-    SortingTableState &
-    ExpandedTableState &
-    GroupingTableState &
-    ColumnSizingTableState &
-    PaginationInitialTableState &
-    RowSelectionTableState
->
-
-export type Row<TData extends RowData> = CoreRow<TData> &
-  VisibilityRow<TData> &
-  ColumnPinningRow<TData> &
-  FiltersRow<TData> &
-  GroupingRow &
-  RowSelectionRow &
-  ExpandedRow
-
-export type RowModel<TData extends RowData> = {
+  FeatureOptions<TData>
+
+export interface TableOptions<TData extends RowData>
+  extends PartialKeys<
+    TableOptionsResolved<TData>,
+    'state' | 'onStateChange' | 'renderFallbackValue'
+  > {}
+
+export interface TableState
+  extends CoreTableState,
+    VisibilityTableState,
+    ColumnOrderTableState,
+    ColumnPinningTableState,
+    FiltersTableState,
+    SortingTableState,
+    ExpandedTableState,
+    GroupingTableState,
+    ColumnSizingTableState,
+    PaginationTableState,
+    RowSelectionTableState {}
+
+interface CompleteInitialTableState
+  extends CoreTableState,
+    VisibilityTableState,
+    ColumnOrderTableState,
+    ColumnPinningTableState,
+    FiltersTableState,
+    SortingTableState,
+    ExpandedTableState,
+    GroupingTableState,
+    ColumnSizingTableState,
+    PaginationInitialTableState,
+    RowSelectionTableState {}
+
+export interface InitialTableState extends Partial<CompleteInitialTableState> {}
+
+export interface Row<TData extends RowData>
+  extends CoreRow<TData>,
+    VisibilityRow<TData>,
+    ColumnPinningRow<TData>,
+    FiltersRow<TData>,
+    GroupingRow,
+    RowSelectionRow,
+    ExpandedRow {}
+
+export interface RowModel<TData extends RowData> {
   rows: Row<TData>[]
   flatRows: Row<TData>[]
   rowsById: Record<string, Row<TData>>
@@ -180,12 +191,12 @@ export type StringOrTemplateHeader<TData, TValue> =
   | string
   | ColumnDefTemplate<HeaderContext<TData, TValue>>
 
-type StringHeaderIdentifier = {
+interface StringHeaderIdentifier {
   header: string
   id?: string
 }
 
-type IdIdentifier<TData extends RowData, TValue> = {
+interface IdIdentifier<TData extends RowData, TValue> {
   id: string
   header?: StringOrTemplateHeader<TData, TValue>
 }
@@ -196,24 +207,26 @@ type ColumnIdentifiers<TData extends RowData, TValue> =
 
 //
 
-export type ColumnDefBase<TData extends RowData, TValue = unknown> = {
+interface ColumnDefExtensions<TData extends RowData, TValue = unknown>
+  extends VisibilityColumnDef,
+    ColumnPinningColumnDef,
+    FiltersColumnDef<TData>,
+    SortingColumnDef<TData>,
+    GroupingColumnDef<TData, TValue>,
+    ColumnSizingColumnDef {}
+
+export interface ColumnDefBase<TData extends RowData, TValue = unknown>
+  extends ColumnDefExtensions<TData, TValue> {
   getUniqueValues?: AccessorFn<TData, unknown[]>
   footer?: ColumnDefTemplate<HeaderContext<TData, TValue>>
   cell?: ColumnDefTemplate<CellContext<TData, TValue>>
   meta?: ColumnMeta<TData, TValue>
-} & VisibilityColumnDef &
-  ColumnPinningColumnDef &
-  FiltersColumnDef<TData> &
-  SortingColumnDef<TData> &
-  GroupingColumnDef<TData, TValue> &
-  ColumnSizingColumnDef
+}
 
 //
 
-export type IdentifiedColumnDef<
-  TData extends RowData,
-  TValue = unknown
-> = ColumnDefBase<TData, TValue> & {
+export interface IdentifiedColumnDef<TData extends RowData, TValue = unknown>
+  extends ColumnDefBase<TData, TValue> {
   id?: string
   header?: StringOrTemplateHeader<TData, TValue>
 }
@@ -223,28 +236,37 @@ export type DisplayColumnDef<
   TValue = unknown
 > = ColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
 
+interface GroupColumnDefBase<TData extends RowData, TValue = unknown>
+  extends ColumnDefBase<TData, TValue> {
+  columns?: ColumnDef<TData, any>[]
+}
+
 export type GroupColumnDef<
   TData extends RowData,
   TValue = unknown
-> = ColumnDefBase<TData, TValue> &
-  ColumnIdentifiers<TData, TValue> & {
-    columns?: ColumnDef<TData, any>[]
-  }
+> = GroupColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
+
+interface AccessorFnColumnDefBase<TData extends RowData, TValue = unknown>
+  extends ColumnDefBase<TData, TValue> {
+  accessorFn: AccessorFn<TData, TValue>
+}
 
 export type AccessorFnColumnDef<
   TData extends RowData,
   TValue = unknown
-> = ColumnDefBase<TData, TValue> &
-  ColumnIdentifiers<TData, TValue> & {
-    accessorFn: AccessorFn<TData, TValue>
-  }
+> = AccessorFnColumnDefBase<TData, TValue> & ColumnIdentifiers<TData, TValue>
 
-export type AccessorKeyColumnDef<TData extends RowData, TValue = unknown> = {
+interface AccessorKeyColumnDefBase<TData extends RowData, TValue = unknown>
+  extends ColumnDefBase<TData, TValue> {
   id?: string
-} & Partial<ColumnIdentifiers<TData, TValue>> &
-  ColumnDefBase<TData, TValue> & {
-    accessorKey: string | keyof TData
-  }
+  accessorKey: string | keyof TData
+}
+
+export type AccessorKeyColumnDef<
+  TData extends RowData,
+  TValue = unknown
+> = AccessorKeyColumnDefBase<TData, TValue> &
+  Partial<ColumnIdentifiers<TData, TValue>>
 
 export type AccessorColumnDef<TData extends RowData, TValue = unknown> =
   | AccessorKeyColumnDef<TData, TValue>
@@ -264,21 +286,22 @@ export type ColumnDefResolved<
   accessorKey?: string
 }
 
-export type Column<TData extends RowData, TValue = unknown> = CoreColumn<
-  TData,
-  TValue
-> &
-  ColumnVisibilityColumn &
-  ColumnPinningColumn &
-  FiltersColumn<TData> &
-  SortingColumn<TData> &
-  GroupingColumn<TData> &
-  ColumnSizingColumn
-
-export type Cell<TData extends RowData, TValue> = CoreCell<TData, TValue> &
-  GroupingCell
-
-export type Header<TData extends RowData, TValue> = CoreHeader<TData, TValue> &
-  ColumnSizingHeader
-
-export type HeaderGroup<TData extends RowData> = CoreHeaderGroup<TData>
+export interface Column<TData extends RowData, TValue = unknown>
+  extends CoreColumn<TData, TValue>,
+    ColumnVisibilityColumn,
+    ColumnPinningColumn,
+    FiltersColumn<TData>,
+    SortingColumn<TData>,
+    GroupingColumn<TData>,
+    ColumnSizingColumn {}
+
+export interface Cell<TData extends RowData, TValue>
+  extends CoreCell<TData, TValue>,
+    GroupingCell {}
+
+export interface Header<TData extends RowData, TValue>
+  extends CoreHeader<TData, TValue>,
+    ColumnSizingHeader {}
+
+export interface HeaderGroup<TData extends RowData>
+  extends CoreHeaderGroup<TData> {}

package/src/utils/getSortedRowModel.ts

@@ -44,7 +44,7 @@ export function getSortedRowModel<TData extends RowData>(): (
         const sortData = (rows: Row<TData>[]) => {
           // This will also perform a stable sorting using the row index
           // if needed.
-          const sortedData = rows.slice()
+          const sortedData = [...rows]
 
           sortedData.sort((rowA, rowB) => {
             for (let i = 0; i < availableSorting.length; i += 1) {

package/src/utils.ts

@@ -1,8 +1,7 @@
 import { TableState, Updater } from './types'
 
-export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
-export type RequiredKeys<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<T>
+export type RequiredKeys<T, K extends keyof T> = T & { [P in K]-?: T[P] }
 export type Overwrite<T, U extends { [TKey in keyof T]?: any }> = Omit<
   T,
   keyof U
@@ -18,54 +17,68 @@ export type UnionToIntersection<T> = (
 export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N
 export type IsKnown<T, Y, N> = unknown extends T ? N : Y
 
-type ComputeRange<
-  N extends number,
-  Result extends Array<unknown> = []
-> = Result['length'] extends N
-  ? Result
-  : ComputeRange<N, [...Result, Result['length']]>
-type Index40 = ComputeRange<40>[number]
-
-// Is this type a tuple?
-type IsTuple<T> = T extends readonly any[] & { length: infer Length }
-  ? Length extends Index40
-    ? T
+type IndexableData = Record<string | number, any>
+export type DeepValue<T, TProp> = T extends IndexableData
+  ? TProp extends `${infer TBranch}.${infer TDeepProp}`
+    ? DeepValue<T[TBranch], TDeepProp>
+    : TProp extends keyof T
+    ? T[TProp]
     : never
   : never
 
-// If this type is a tuple, what indices are allowed?
-type AllowedIndexes<
-  Tuple extends ReadonlyArray<any>,
-  Keys extends number = never
-> = Tuple extends readonly []
-  ? Keys
-  : Tuple extends readonly [infer _, ...infer Tail]
-  ? AllowedIndexes<Tail, Keys | Tail['length']>
-  : Keys
-
-export type DeepKeys<T> = unknown extends T
-  ? keyof T
-  : object extends T
-  ? string
-  : T extends readonly any[] & IsTuple<T>
-  ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>>
-  : T extends any[]
-  ? never & 'Dynamic length array indexing is not supported'
-  : T extends Date
-  ? never
-  : T extends object
-  ? (keyof T & string) | DeepKeysPrefix<T, keyof T>
-  : never
-
-type DeepKeysPrefix<T, TPrefix> = TPrefix extends keyof T & (number | string)
-  ? `${TPrefix}.${DeepKeys<T[TPrefix]> & string}`
+type Join<K, P> = K extends string | number
+  ? P extends string | number
+    ? `${K}${'' extends P ? '' : '.'}${P}`
+    : never
   : never
 
-export type DeepValue<T, TProp> = T extends Record<string | number, any>
-  ? TProp extends `${infer TBranch}.${infer TDeepProp}`
-    ? DeepValue<T[TBranch], TDeepProp>
-    : T[TProp & string]
-  : never
+type Prev = [
+  never,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  ...0[]
+]
+
+type ExplicitLeaves =
+  | Date
+  | Number
+  | BigInt
+  | String
+  | Set<unknown>
+  | Map<unknown, unknown>
+  | WeakSet<object>
+  | WeakMap<object, unknown>
+
+export type DeepKeys<T, D extends number = 10> = [D] extends [never]
+  ? never
+  : T extends ExplicitLeaves
+  ? never
+  : T extends object
+  ? {
+      [K in keyof T]-?: K extends string | number
+        ? `${K}` | Join<K, DeepKeys<T[K], Prev[D]>>
+        : never
+    }[keyof T]
+  : ''
 
 export type NoInfer<T> = [T][T extends any ? 0 : never]