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

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.85",
   "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/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/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(