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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/table-core",
   "author": "Tanner Linsley",
-  "version": "8.0.0-alpha.84",
+  "version": "8.0.0-alpha.87",
   "description": "Hooks for building lightweight, fast and extendable datagrids for React",
   "license": "MIT",
   "homepage": "https://github.com/tanstack/react-table#readme",

package/src/aggregationFns.ts

@@ -1,64 +1,53 @@
-export const aggregationFns = {
-  sum,
-  min,
-  max,
-  extent,
-  mean,
-  median,
-  unique,
-  uniqueCount,
-  count,
-}
+import { AggregationFn } from './features/Grouping'
 
-export type BuiltInAggregationFn = keyof typeof aggregationFns
-
-function sum(_getLeafValues: () => unknown[], getChildValues: () => unknown[]) {
+const sum: AggregationFn<any> = (columnId, _leafRows, childRows) => {
   // It's faster to just add the aggregations together instead of
   // process leaf nodes individually
-  return getChildValues().reduce(
+  return childRows.reduce(
     (sum: number, next: unknown) => sum + (typeof next === 'number' ? next : 0),
     0
   )
 }
 
-function min(_getLeafValues: () => unknown[], getChildValues: () => unknown[]) {
+const min: AggregationFn<any> = (columnId, _leafRows, childRows) => {
   let min: number | undefined
 
-  for (const value of getChildValues() as number[]) {
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
+
     if (
       value != null &&
       (min! > value || (min === undefined && value >= value))
     ) {
       min = value
     }
-  }
+  })
 
   return min
 }
 
-function max(_getLeafValues: () => unknown[], getChildValues: () => unknown[]) {
+const max: AggregationFn<any> = (columnId, _leafRows, childRows) => {
   let max: number | undefined
 
-  for (const value of getChildValues() as number[]) {
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
     if (
       value != null &&
       (max! < value || (max === undefined && value >= value))
     ) {
       max = value
     }
-  }
+  })
 
   return max
 }
 
-function extent(
-  _getLeafValues: () => unknown[],
-  getChildValues: () => unknown[]
-) {
+const extent: AggregationFn<any> = (columnId, _leafRows, childRows) => {
   let min: number | undefined
   let max: number | undefined
 
-  for (const value of getChildValues() as number[]) {
+  childRows.forEach(row => {
+    const value = row.getValue(columnId)
     if (value != null) {
       if (min === undefined) {
         if (value >= value) min = max = value
@@ -67,36 +56,37 @@ function extent(
         if (max! < value) max = value
       }
     }
-  }
+  })
 
   return [min, max]
 }
 
-export function mean(getLeafValues: () => unknown[]) {
+const mean: AggregationFn<any> = (columnId, leafRows) => {
   let count = 0
   let sum = 0
 
-  for (let value of getLeafValues() as number[]) {
+  leafRows.forEach(row => {
+    let value = row.getValue(columnId)
     if (value != null && (value = +value) >= value) {
       ++count, (sum += value)
     }
-  }
+  })
 
   if (count) return sum / count
 
   return
 }
 
-function median(getLeafValues: () => unknown[]) {
-  const leafValues = getLeafValues()
-  if (!leafValues.length) {
+const median: AggregationFn<any> = (columnId, leafRows) => {
+  if (!leafRows.length) {
     return
   }
 
   let min = 0
   let max = 0
 
-  leafValues.forEach(value => {
+  leafRows.forEach(row => {
+    let value = row.getValue(columnId)
     if (typeof value === 'number') {
       min = Math.min(min, value)
       max = Math.max(max, value)
@@ -106,14 +96,28 @@ function median(getLeafValues: () => unknown[]) {
   return (min + max) / 2
 }
 
-function unique<T>(getLeafValues: () => T[]) {
-  return Array.from(new Set(getLeafValues()).values())
+const unique: AggregationFn<any> = (columnId, leafRows) => {
+  return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values())
 }
 
-function uniqueCount(getLeafValues: () => unknown[]) {
-  return new Set(getLeafValues()).size
+const uniqueCount: AggregationFn<any> = (columnId, leafRows) => {
+  return new Set(leafRows.map(d => d.getValue(columnId))).size
 }
 
-function count(getLeafValues: () => unknown[]) {
-  return getLeafValues().length
+const count: AggregationFn<any> = (_columnId, leafRows) => {
+  return leafRows.length
+}
+
+export const aggregationFns = {
+  sum,
+  min,
+  max,
+  extent,
+  mean,
+  median,
+  unique,
+  uniqueCount,
+  count,
 }
+
+export type BuiltInAggregationFn = keyof typeof aggregationFns

package/src/features/Expanding.ts

@@ -30,7 +30,6 @@ export type ExpandedOptions<TGenerics extends TableGenerics> = {
   getExpandedRowModel?: (
     instance: TableInstance<TGenerics>
   ) => () => RowModel<TGenerics>
-  expandSubRows?: boolean
   getIsRowExpanded?: (row: Row<TGenerics>) => boolean
   getRowCanExpand?: (row: Row<TGenerics>) => boolean
   paginateExpandedRows?: boolean
@@ -67,7 +66,6 @@ export const Expanding: TableFeature = {
     return {
       onExpandedChange: makeStateUpdater('expanded', instance),
       autoResetExpanded: true,
-      expandSubRows: true,
       paginateExpandedRows: true,
     }
   },

package/src/features/Filters.ts

@@ -20,8 +20,6 @@ import {
 export type FiltersTableState = {
   columnFilters: ColumnFiltersState
   globalFilter: any
-  // filtersProgress: number
-  // facetProgress: Record<string, number>
 }
 
 export type ColumnFiltersState = ColumnFilter[]
@@ -74,7 +72,6 @@ export type FiltersColumnDef<TGenerics extends TableGenerics> = {
   filterFn?: FilterFnOption<Overwrite<TGenerics, { Value: any }>>
   enableColumnFilter?: boolean
   enableGlobalFilter?: boolean
-  enableFaceting?: boolean
 }
 
 export type FiltersColumn<TGenerics extends TableGenerics> = {
@@ -98,7 +95,6 @@ export type FiltersColumn<TGenerics extends TableGenerics> = {
 export type FiltersRow<TGenerics extends TableGenerics> = {
   columnFilters: Record<string, boolean>
   columnFiltersMeta: Record<string, TGenerics['FilterMeta']>
-  subRowsByFacetId: Record<string, Row<TGenerics>[]>
 }
 
 export type FiltersOptions<TGenerics extends TableGenerics> = {
@@ -356,7 +352,6 @@ export const Filters: TableFeature = {
     return {
       columnFilters: {},
       columnFiltersMeta: {},
-      subRowsByFacetId: {},
     }
   },
 

package/src/features/Grouping.ts

@@ -15,9 +15,14 @@ import { isFunction, makeStateUpdater, Overwrite } from '../utils'
 
 export type GroupingState = string[]
 
+export type GroupingTableState = {
+  grouping: GroupingState
+}
+
 export type AggregationFn<TGenerics extends TableGenerics> = (
-  getLeafValues: () => TGenerics['Value'][],
-  getChildValues: () => TGenerics['Value'][]
+  columnId: string,
+  leafRows: Row<TGenerics>[],
+  childRows: Row<TGenerics>[]
 ) => any
 
 export type CustomAggregationFns<TGenerics extends TableGenerics> = Record<
@@ -31,13 +36,8 @@ export type AggregationFnOption<TGenerics extends TableGenerics> =
   | keyof TGenerics['AggregationFns']
   | AggregationFn<TGenerics>
 
-export type GroupingTableState = {
-  grouping: GroupingState
-}
-
 export type GroupingColumnDef<TGenerics extends TableGenerics> = {
   aggregationFn?: AggregationFnOption<Overwrite<TGenerics, { Value: any }>>
-  aggregateValue?: (columnValue: unknown) => any
   aggregatedCell?: Renderable<
     TGenerics,
     {
@@ -58,15 +58,15 @@ export type GroupingColumn<TGenerics extends TableGenerics> = {
   getGroupedIndex: () => number
   toggleGrouping: () => void
   getToggleGroupingHandler: () => () => void
-  getColumnAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
-  getColumnAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getAutoAggregationFn: () => AggregationFn<TGenerics> | undefined
+  getAggregationFn: () => AggregationFn<TGenerics> | undefined
 }
 
 export type GroupingRow = {
   groupingColumnId?: string
   groupingValue?: any
   getIsGrouped: () => boolean
-  groupingValuesCache: Record<string, any>
+  _groupingValuesCache: Record<string, any>
 }
 
 export type GroupingCell<TGenerics extends TableGenerics> = {
@@ -87,11 +87,9 @@ export type GroupingOptions<TGenerics extends TableGenerics> = {
   aggregationFns?: TGenerics['AggregationFns']
   onGroupingChange?: OnChangeFn<GroupingState>
   enableGrouping?: boolean
-  enableGroupingRemoval?: boolean
   getGroupedRowModel?: (
     instance: TableInstance<TGenerics>
   ) => () => RowModel<TGenerics>
-
   groupedColumnMode?: false | 'reorder' | 'remove'
 }
 
@@ -172,7 +170,7 @@ export const Grouping: TableFeature = {
           column.toggleGrouping()
         }
       },
-      getColumnAutoAggregationFn: () => {
+      getAutoAggregationFn: () => {
         const firstRow = instance.getCoreRowModel().flatRows[0]
 
         const value = firstRow?.getValue(column.id)
@@ -187,7 +185,7 @@ export const Grouping: TableFeature = {
 
         return aggregationFns.count
       },
-      getColumnAggregationFn: () => {
+      getAggregationFn: () => {
         const userAggregationFns = instance.options.aggregationFns
 
         if (!column) {
@@ -197,7 +195,7 @@ export const Grouping: TableFeature = {
         return isFunction(column.aggregationFn)
           ? column.aggregationFn
           : column.aggregationFn === 'auto'
-          ? column.getColumnAutoAggregationFn()
+          ? column.getAutoAggregationFn()
           : (userAggregationFns as Record<string, any>)?.[
               column.aggregationFn as string
             ] ??
@@ -240,12 +238,11 @@ export const Grouping: TableFeature = {
   },
 
   createRow: <TGenerics extends TableGenerics>(
-    row: Row<TGenerics>,
-    instance: TableInstance<TGenerics>
+    row: Row<TGenerics>
   ): GroupingRow => {
     return {
       getIsGrouped: () => !!row.groupingColumnId,
-      groupingValuesCache: {},
+      _groupingValuesCache: {},
     }
   },
 

package/src/features/Sorting.ts

@@ -26,6 +26,10 @@ export type ColumnSort = {
 
 export type SortingState = ColumnSort[]
 
+export type SortingTableState = {
+  sorting: SortingState
+}
+
 export type SortingFn<TGenerics extends TableGenerics> = {
   (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number
 }
@@ -35,10 +39,6 @@ export type CustomSortingFns<TGenerics extends TableGenerics> = Record<
   SortingFn<TGenerics>
 >
 
-export type SortingTableState = {
-  sorting: SortingState
-}
-
 export type SortingFnOption<TGenerics extends TableGenerics> =
   | 'auto'
   | BuiltInSortingFn

package/src/features/Visibility.ts

@@ -10,6 +10,12 @@ import {
 } from '../types'
 import { makeStateUpdater, memo } from '../utils'
 
+export type VisibilityState = Record<string, boolean>
+
+export type VisibilityTableState = {
+  columnVisibility: VisibilityState
+}
+
 export type VisibilityOptions = {
   onColumnVisibilityChange?: OnChangeFn<VisibilityState>
   enableHiding?: boolean
@@ -19,12 +25,6 @@ export type VisibilityDefaultOptions = {
   onColumnVisibilityChange: OnChangeFn<VisibilityState>
 }
 
-export type VisibilityState = Record<string, boolean>
-
-export type VisibilityTableState = {
-  columnVisibility: VisibilityState
-}
-
 export type VisibilityInstance<TGenerics extends TableGenerics> = {
   getVisibleFlatColumns: () => Column<TGenerics>[]
   getVisibleLeafColumns: () => Column<TGenerics>[]
@@ -36,14 +36,11 @@ export type VisibilityInstance<TGenerics extends TableGenerics> = {
   toggleAllColumnsVisible: (value?: boolean) => void
   getIsAllColumnsVisible: () => boolean
   getIsSomeColumnsVisible: () => boolean
-  getToggleAllColumnsVisibilityHandler: () =>
-    | undefined
-    | ((event: unknown) => void)
+  getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void
 }
 
 export type VisibilityColumnDef = {
   enableHiding?: boolean
-  defaultIsVisible?: boolean
 }
 
 export type VisibilityRow<TGenerics extends TableGenerics> = {
@@ -76,12 +73,6 @@ export const Visibility: TableFeature = {
     }
   },
 
-  getDefaultColumnDef: () => {
-    return {
-      defaultIsVisible: true,
-    }
-  },
-
   createColumn: <TGenerics extends TableGenerics>(
     column: Column<TGenerics>,
     instance: TableInstance<TGenerics>

package/src/sortingFns.ts

@@ -1,40 +1,69 @@
-import { TableGenerics, Row } from './types'
+import { SortingFn } from './features/Sorting'
 
 export const reSplitAlphaNumeric = /([0-9]+)/gm
 
-export const sortingFns = {
-  alphanumeric,
-  alphanumericCaseSensitive,
-  text,
-  textCaseSensitive,
-  datetime,
-  basic,
+const alphanumeric: SortingFn<any> = (rowA, rowB, columnId) => {
+  return compareAlphanumeric(
+    toString(rowA.getValue(columnId)).toLowerCase(),
+    toString(rowB.getValue(columnId)).toLowerCase()
+  )
 }
 
-export type BuiltInSortingFn = keyof typeof sortingFns
-
-function alphanumeric<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
+const alphanumericCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {
   return compareAlphanumeric(
+    toString(rowA.getValue(columnId)),
+    toString(rowB.getValue(columnId))
+  )
+}
+
+// The text filter is more basic (less numeric support)
+// but is much faster
+const text: SortingFn<any> = (rowA, rowB, columnId) => {
+  return compareBasic(
     toString(rowA.getValue(columnId)).toLowerCase(),
     toString(rowB.getValue(columnId)).toLowerCase()
   )
 }
 
-function alphanumericCaseSensitive<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
-  return compareAlphanumeric(
+// The text filter is more basic (less numeric support)
+// but is much faster
+const textCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {
+  return compareBasic(
     toString(rowA.getValue(columnId)),
     toString(rowB.getValue(columnId))
   )
 }
 
+const datetime: SortingFn<any> = (rowA, rowB, columnId) => {
+  return compareBasic(
+    (rowA.getValue(columnId) as Date).getTime(),
+    (rowB.getValue(columnId) as Date).getTime()
+  )
+}
+
+const basic: SortingFn<any> = (rowA, rowB, columnId) => {
+  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))
+}
+
+// Utils
+
+function compareBasic(a: any, b: any) {
+  return a === b ? 0 : a > b ? 1 : -1
+}
+
+function toString(a: any) {
+  if (typeof a === 'number') {
+    if (isNaN(a) || a === Infinity || a === -Infinity) {
+      return ''
+    }
+    return String(a)
+  }
+  if (typeof a === 'string') {
+    return a
+  }
+  return ''
+}
+
 // Mixed sorting is slow, but very inclusive of many edge cases.
 // It handles numbers, mixed alphanumeric combinations, and even
 // null, undefined, and Infinity
@@ -82,66 +111,15 @@ function compareAlphanumeric(aStr: string, bStr: string) {
   return a.length - b.length
 }
 
-// The text filter is more basic (less numeric support)
-// but is much faster
-function text<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
-  return compareBasic(
-    toString(rowA.getValue(columnId)).toLowerCase(),
-    toString(rowB.getValue(columnId)).toLowerCase()
-  )
-}
-
-// The text filter is more basic (less numeric support)
-// but is much faster
-function textCaseSensitive<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
-  return compareBasic(
-    toString(rowA.getValue(columnId)),
-    toString(rowB.getValue(columnId))
-  )
-}
-
-function datetime<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
-  return compareBasic(
-    (rowA.getValue(columnId) as Date).getTime(),
-    (rowB.getValue(columnId) as Date).getTime()
-  )
-}
-
-function basic<TGenerics extends TableGenerics>(
-  rowA: Row<TGenerics>,
-  rowB: Row<TGenerics>,
-  columnId: string
-) {
-  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))
-}
-
-// Utils
+// Exports
 
-function compareBasic(a: any, b: any) {
-  return a === b ? 0 : a > b ? 1 : -1
+export const sortingFns = {
+  alphanumeric,
+  alphanumericCaseSensitive,
+  text,
+  textCaseSensitive,
+  datetime,
+  basic,
 }
 
-function toString(a: any) {
-  if (typeof a === 'number') {
-    if (isNaN(a) || a === Infinity || a === -Infinity) {
-      return ''
-    }
-    return String(a)
-  }
-  if (typeof a === 'string') {
-    return a
-  }
-  return ''
-}
+export type BuiltInSortingFn = keyof typeof sortingFns

package/src/utils/getExpandedRowModel.ts

@@ -39,11 +39,7 @@ export function expandRows<TGenerics extends TableGenerics>(
   const handleRow = (row: Row<TGenerics>) => {
     expandedRows.push(row)
 
-    if (
-      instance.options.expandSubRows &&
-      row.subRows?.length &&
-      row.getIsExpanded()
-    ) {
+    if (row.subRows?.length && row.getIsExpanded()) {
       row.subRows.forEach(handleRow)
     }
   }

package/src/utils/getGroupedRowModel.ts

@@ -77,31 +77,22 @@ export function getGroupedRowModel<TGenerics extends TableGenerics>(): (
                     return row._valuesCache[columnId]
                   }
 
-                  if (row.groupingValuesCache.hasOwnProperty(columnId)) {
-                    return row.groupingValuesCache[columnId]
+                  if (row._groupingValuesCache.hasOwnProperty(columnId)) {
+                    return row._groupingValuesCache[columnId]
                   }
 
                   // Aggregate the values
                   const column = instance.getColumn(columnId)
-                  const aggregateFn = column.getColumnAggregationFn()
+                  const aggregateFn = column.getAggregationFn()
 
                   if (aggregateFn) {
-                    row.groupingValuesCache[columnId] = aggregateFn(
-                      () =>
-                        leafRows.map(row => {
-                          let columnValue = row.getValue(columnId)
-
-                          if (!depth && column.columnDef.aggregateValue) {
-                            columnValue =
-                              column.columnDef.aggregateValue(columnValue)
-                          }
-
-                          return columnValue
-                        }),
-                      () => groupedRows.map(row => row.getValue(columnId))
+                    row._groupingValuesCache[columnId] = aggregateFn(
+                      columnId,
+                      leafRows,
+                      groupedRows
                     )
 
-                    return row.groupingValuesCache[columnId]
+                    return row._groupingValuesCache[columnId]
                   } else if (column.aggregationFn) {
                     console.info({ column })
                     throw new Error(