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

package/build/types/aggregationFns.d.ts

@@ -1,22 +1,13 @@
+import { AggregationFn } from './features/Grouping';
 export declare const aggregationFns: {
-    sum: typeof sum;
-    min: typeof min;
-    max: typeof max;
-    extent: typeof extent;
-    mean: typeof mean;
-    median: typeof median;
-    unique: typeof unique;
-    uniqueCount: typeof uniqueCount;
-    count: typeof count;
+    sum: AggregationFn<any>;
+    min: AggregationFn<any>;
+    max: AggregationFn<any>;
+    extent: AggregationFn<any>;
+    mean: AggregationFn<any>;
+    median: AggregationFn<any>;
+    unique: AggregationFn<any>;
+    uniqueCount: AggregationFn<any>;
+    count: AggregationFn<any>;
 };
 export declare type BuiltInAggregationFn = keyof typeof aggregationFns;
-declare function sum(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number;
-declare function min(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
-declare function max(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): number | undefined;
-declare function extent(_getLeafValues: () => unknown[], getChildValues: () => unknown[]): (number | undefined)[];
-export declare function mean(getLeafValues: () => unknown[]): number | undefined;
-declare function median(getLeafValues: () => unknown[]): number | undefined;
-declare function unique<T>(getLeafValues: () => T[]): T[];
-declare function uniqueCount(getLeafValues: () => unknown[]): number;
-declare function count(getLeafValues: () => unknown[]): number;
-export {};

package/build/types/features/Filters.d.ts

@@ -32,7 +32,6 @@ export declare type FiltersColumnDef<TGenerics extends TableGenerics> = {
     }>>;
     enableColumnFilter?: boolean;
     enableGlobalFilter?: boolean;
-    enableFaceting?: boolean;
 };
 export declare type FiltersColumn<TGenerics extends TableGenerics> = {
     filterFn: FilterFnOption<Overwrite<TGenerics, {
@@ -56,7 +55,6 @@ export declare type FiltersColumn<TGenerics extends TableGenerics> = {
 export declare type FiltersRow<TGenerics extends TableGenerics> = {
     columnFilters: Record<string, boolean>;
     columnFiltersMeta: Record<string, TGenerics['FilterMeta']>;
-    subRowsByFacetId: Record<string, Row<TGenerics>[]>;
 };
 export declare type FiltersOptions<TGenerics extends TableGenerics> = {
     enableFilters?: boolean;

package/build/types/features/Grouping.d.ts

@@ -4,17 +4,16 @@ import { TableFeature } from '../core/instance';
 import { Cell, Column, OnChangeFn, TableInstance, Row, Updater, Renderable, TableGenerics } from '../types';
 import { Overwrite } from '../utils';
 export declare type GroupingState = string[];
-export declare type AggregationFn<TGenerics extends TableGenerics> = (getLeafValues: () => TGenerics['Value'][], getChildValues: () => TGenerics['Value'][]) => any;
-export declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
-export declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
 export declare type GroupingTableState = {
     grouping: GroupingState;
 };
+export declare type AggregationFn<TGenerics extends TableGenerics> = (columnId: string, leafRows: Row<TGenerics>[], childRows: Row<TGenerics>[]) => any;
+export declare type CustomAggregationFns<TGenerics extends TableGenerics> = Record<string, AggregationFn<TGenerics>>;
+export declare type AggregationFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInAggregationFn | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
 export declare type GroupingColumnDef<TGenerics extends TableGenerics> = {
     aggregationFn?: AggregationFnOption<Overwrite<TGenerics, {
         Value: any;
     }>>;
-    aggregateValue?: (columnValue: unknown) => any;
     aggregatedCell?: Renderable<TGenerics, {
         instance: TableInstance<TGenerics>;
         row: Row<TGenerics>;
@@ -33,14 +32,14 @@ export declare 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 declare type GroupingRow = {
     groupingColumnId?: string;
     groupingValue?: any;
     getIsGrouped: () => boolean;
-    groupingValuesCache: Record<string, any>;
+    _groupingValuesCache: Record<string, any>;
 };
 export declare type GroupingCell<TGenerics extends TableGenerics> = {
     getIsGrouped: () => boolean;
@@ -57,7 +56,6 @@ export declare 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';
 };

package/build/umd/index.development.js

@@ -1216,8 +1216,7 @@
     createRow: (row, instance) => {
       return {
         columnFilters: {},
-        columnFiltersMeta: {},
-        subRowsByFacetId: {}
+        columnFiltersMeta: {}
       };
     },
     createInstance: instance => {
@@ -1308,53 +1307,42 @@
     return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value;
   }
 
-  const aggregationFns = {
-    sum,
-    min,
-    max,
-    extent,
-    mean,
-    median,
-    unique,
-    uniqueCount,
-    count
-  };
-
-  function sum(_getLeafValues, getChildValues) {
+  const sum = (columnId, _leafRows, childRows) => {
     // It's faster to just add the aggregations together instead of
     // process leaf nodes individually
-    return getChildValues().reduce((sum, next) => sum + (typeof next === 'number' ? next : 0), 0);
-  }
+    return childRows.reduce((sum, next) => sum + (typeof next === 'number' ? next : 0), 0);
+  };
 
-  function min(_getLeafValues, getChildValues) {
+  const min = (columnId, _leafRows, childRows) => {
     let min;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
 
-    for (const value of getChildValues()) {
       if (value != null && (min > value || min === undefined && value >= value)) {
         min = value;
       }
-    }
-
+    });
     return min;
-  }
+  };
 
-  function max(_getLeafValues, getChildValues) {
+  const max = (columnId, _leafRows, childRows) => {
     let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
 
-    for (const value of getChildValues()) {
       if (value != null && (max < value || max === undefined && value >= value)) {
         max = value;
       }
-    }
-
+    });
     return max;
-  }
+  };
 
-  function extent(_getLeafValues, getChildValues) {
+  const extent = (columnId, _leafRows, childRows) => {
     let min;
     let max;
+    childRows.forEach(row => {
+      const value = row.getValue(columnId);
 
-    for (const value of getChildValues()) {
       if (value != null) {
         if (min === undefined) {
           if (value >= value) min = max = value;
@@ -1363,54 +1351,65 @@
           if (max < value) max = value;
         }
       }
-    }
-
+    });
     return [min, max];
-  }
+  };
 
-  function mean(getLeafValues) {
+  const mean = (columnId, leafRows) => {
     let count = 0;
     let sum = 0;
+    leafRows.forEach(row => {
+      let value = row.getValue(columnId);
 
-    for (let value of getLeafValues()) {
       if (value != null && (value = +value) >= value) {
         ++count, sum += value;
       }
-    }
-
+    });
     if (count) return sum / count;
     return;
-  }
-
-  function median(getLeafValues) {
-    const leafValues = getLeafValues();
+  };
 
-    if (!leafValues.length) {
+  const median = (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);
       }
     });
     return (min + max) / 2;
-  }
+  };
 
-  function unique(getLeafValues) {
-    return Array.from(new Set(getLeafValues()).values());
-  }
+  const unique = (columnId, leafRows) => {
+    return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values());
+  };
 
-  function uniqueCount(getLeafValues) {
-    return new Set(getLeafValues()).size;
-  }
+  const uniqueCount = (columnId, leafRows) => {
+    return new Set(leafRows.map(d => d.getValue(columnId))).size;
+  };
 
-  function count(getLeafValues) {
-    return getLeafValues().length;
-  }
+  const count = (_columnId, leafRows) => {
+    return leafRows.length;
+  };
+
+  const aggregationFns = {
+    sum,
+    min,
+    max,
+    extent,
+    mean,
+    median,
+    unique,
+    uniqueCount,
+    count
+  };
 
   //
   const Grouping = {
@@ -1465,7 +1464,7 @@
             column.toggleGrouping();
           };
         },
-        getColumnAutoAggregationFn: () => {
+        getAutoAggregationFn: () => {
           const firstRow = instance.getCoreRowModel().flatRows[0];
           const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
 
@@ -1479,7 +1478,7 @@
 
           return aggregationFns.count;
         },
-        getColumnAggregationFn: () => {
+        getAggregationFn: () => {
           var _ref4;
 
           const userAggregationFns = instance.options.aggregationFns;
@@ -1488,7 +1487,7 @@
             throw new Error();
           }
 
-          return isFunction(column.aggregationFn) ? column.aggregationFn : column.aggregationFn === 'auto' ? column.getColumnAutoAggregationFn() : (_ref4 = userAggregationFns == null ? void 0 : userAggregationFns[column.aggregationFn]) != null ? _ref4 : aggregationFns[column.aggregationFn];
+          return isFunction(column.aggregationFn) ? column.aggregationFn : column.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_ref4 = userAggregationFns == null ? void 0 : userAggregationFns[column.aggregationFn]) != null ? _ref4 : aggregationFns[column.aggregationFn];
         }
       };
     },
@@ -1514,10 +1513,10 @@
         }
       };
     },
-    createRow: (row, instance) => {
+    createRow: row => {
       return {
         getIsGrouped: () => !!row.groupingColumnId,
-        groupingValuesCache: {}
+        _groupingValuesCache: {}
       };
     },
     createCell: (cell, column, row, instance) => {
@@ -3650,25 +3649,17 @@
                 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)));
-                return row.groupingValuesCache[columnId];
+                row._groupingValuesCache[columnId] = aggregateFn(columnId, leafRows, groupedRows);
+                return row._groupingValuesCache[columnId];
               } else if (column.aggregationFn) {
                 console.info({
                   column
@@ -3855,7 +3846,6 @@
   exports.isFunction = isFunction;
   exports.isRowSelected = isRowSelected;
   exports.makeStateUpdater = makeStateUpdater;
-  exports.mean = mean;
   exports.memo = memo;
   exports.noop = noop;
   exports.orderColumns = orderColumns;