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

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/Expanding.d.ts

@@ -18,7 +18,6 @@ export declare type ExpandedOptions<TGenerics extends TableGenerics> = {
     autoResetExpanded?: boolean;
     enableExpanding?: boolean;
     getExpandedRowModel?: (instance: TableInstance<TGenerics>) => () => RowModel<TGenerics>;
-    expandSubRows?: boolean;
     getIsRowExpanded?: (row: Row<TGenerics>) => boolean;
     getRowCanExpand?: (row: Row<TGenerics>) => boolean;
     paginateExpandedRows?: boolean;

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/types/features/Sorting.d.ts

@@ -9,13 +9,13 @@ export declare type ColumnSort = {
     desc: boolean;
 };
 export declare type SortingState = ColumnSort[];
+export declare type SortingTableState = {
+    sorting: SortingState;
+};
 export declare type SortingFn<TGenerics extends TableGenerics> = {
     (rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
 };
 export declare type CustomSortingFns<TGenerics extends TableGenerics> = Record<string, SortingFn<TGenerics>>;
-export declare type SortingTableState = {
-    sorting: SortingState;
-};
 export declare type SortingFnOption<TGenerics extends TableGenerics> = 'auto' | BuiltInSortingFn | keyof TGenerics['SortingFns'] | SortingFn<TGenerics>;
 export declare type SortingColumnDef<TGenerics extends TableGenerics> = {
     sortingFn?: SortingFnOption<Overwrite<TGenerics, {

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

@@ -1,5 +1,9 @@
 import { TableFeature } from '../core/instance';
 import { Cell, Column, OnChangeFn, TableGenerics, Updater } from '../types';
+export declare type VisibilityState = Record<string, boolean>;
+export declare type VisibilityTableState = {
+    columnVisibility: VisibilityState;
+};
 export declare type VisibilityOptions = {
     onColumnVisibilityChange?: OnChangeFn<VisibilityState>;
     enableHiding?: boolean;
@@ -7,10 +11,6 @@ export declare type VisibilityOptions = {
 export declare type VisibilityDefaultOptions = {
     onColumnVisibilityChange: OnChangeFn<VisibilityState>;
 };
-export declare type VisibilityState = Record<string, boolean>;
-export declare type VisibilityTableState = {
-    columnVisibility: VisibilityState;
-};
 export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     getVisibleFlatColumns: () => Column<TGenerics>[];
     getVisibleLeafColumns: () => Column<TGenerics>[];
@@ -22,11 +22,10 @@ export declare type VisibilityInstance<TGenerics extends TableGenerics> = {
     toggleAllColumnsVisible: (value?: boolean) => void;
     getIsAllColumnsVisible: () => boolean;
     getIsSomeColumnsVisible: () => boolean;
-    getToggleAllColumnsVisibilityHandler: () => undefined | ((event: unknown) => void);
+    getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
 };
 export declare type VisibilityColumnDef = {
     enableHiding?: boolean;
-    defaultIsVisible?: boolean;
 };
 export declare type VisibilityRow<TGenerics extends TableGenerics> = {
     _getAllVisibleCells: () => Cell<TGenerics>[];

package/build/types/sortingFns.d.ts

@@ -1,18 +1,11 @@
-import { TableGenerics, Row } from './types';
+import { SortingFn } from './features/Sorting';
 export declare const reSplitAlphaNumeric: RegExp;
 export declare const sortingFns: {
-    alphanumeric: typeof alphanumeric;
-    alphanumericCaseSensitive: typeof alphanumericCaseSensitive;
-    text: typeof text;
-    textCaseSensitive: typeof textCaseSensitive;
-    datetime: typeof datetime;
-    basic: typeof basic;
+    alphanumeric: SortingFn<any>;
+    alphanumericCaseSensitive: SortingFn<any>;
+    text: SortingFn<any>;
+    textCaseSensitive: SortingFn<any>;
+    datetime: SortingFn<any>;
+    basic: SortingFn<any>;
 };
 export declare type BuiltInSortingFn = keyof typeof sortingFns;
-declare function alphanumeric<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
-declare function alphanumericCaseSensitive<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): number;
-declare function text<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
-declare function textCaseSensitive<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
-declare function datetime<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
-declare function basic<TGenerics extends TableGenerics>(rowA: Row<TGenerics>, rowB: Row<TGenerics>, columnId: string): 1 | -1 | 0;
-export {};

package/build/umd/index.development.js

@@ -819,7 +819,6 @@
       return {
         onExpandedChange: makeStateUpdater('expanded', instance),
         autoResetExpanded: true,
-        expandSubRows: true,
         paginateExpandedRows: true
       };
     },
@@ -1216,8 +1215,7 @@
     createRow: (row, instance) => {
       return {
         columnFilters: {},
-        columnFiltersMeta: {},
-        subRowsByFacetId: {}
+        columnFiltersMeta: {}
       };
     },
     createInstance: instance => {
@@ -1308,53 +1306,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 +1350,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 +1463,7 @@
             column.toggleGrouping();
           };
         },
-        getColumnAutoAggregationFn: () => {
+        getAutoAggregationFn: () => {
           const firstRow = instance.getCoreRowModel().flatRows[0];
           const value = firstRow == null ? void 0 : firstRow.getValue(column.id);
 
@@ -1479,7 +1477,7 @@
 
           return aggregationFns.count;
         },
-        getColumnAggregationFn: () => {
+        getAggregationFn: () => {
           var _ref4;
 
           const userAggregationFns = instance.options.aggregationFns;
@@ -1488,7 +1486,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 +1512,10 @@
         }
       };
     },
-    createRow: (row, instance) => {
+    createRow: row => {
       return {
         getIsGrouped: () => !!row.groupingColumnId,
-        groupingValuesCache: {}
+        _groupingValuesCache: {}
       };
     },
     createCell: (cell, column, row, instance) => {
@@ -2336,21 +2334,54 @@
   }
 
   const reSplitAlphaNumeric = /([0-9]+)/gm;
-  const sortingFns = {
-    alphanumeric,
-    alphanumericCaseSensitive,
-    text,
-    textCaseSensitive,
-    datetime,
-    basic
-  };
 
-  function alphanumeric(rowA, rowB, columnId) {
+  const alphanumeric = (rowA, rowB, columnId) => {
     return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase());
-  }
+  };
 
-  function alphanumericCaseSensitive(rowA, rowB, columnId) {
+  const alphanumericCaseSensitive = (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 = (rowA, rowB, columnId) => {
+    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
+
+
+  const textCaseSensitive = (rowA, rowB, columnId) => {
+    return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
+  };
+
+  const datetime = (rowA, rowB, columnId) => {
+    return compareBasic(rowA.getValue(columnId).getTime(), rowB.getValue(columnId).getTime());
+  };
+
+  const basic = (rowA, rowB, columnId) => {
+    return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
+  }; // Utils
+
+
+  function compareBasic(a, b) {
+    return a === b ? 0 : a > b ? 1 : -1;
+  }
+
+  function toString(a) {
+    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
@@ -2397,48 +2428,17 @@
     }
 
     return a.length - b.length;
-  } // The text filter is more basic (less numeric support)
-  // but is much faster
-
-
-  function text(rowA, rowB, columnId) {
-    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(rowA, rowB, columnId) {
-    return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId)));
-  }
-
-  function datetime(rowA, rowB, columnId) {
-    return compareBasic(rowA.getValue(columnId).getTime(), rowB.getValue(columnId).getTime());
-  }
-
-  function basic(rowA, rowB, columnId) {
-    return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId));
-  } // Utils
+  } // Exports
 
 
-  function compareBasic(a, b) {
-    return a === b ? 0 : a > b ? 1 : -1;
-  }
-
-  function toString(a) {
-    if (typeof a === 'number') {
-      if (isNaN(a) || a === Infinity || a === -Infinity) {
-        return '';
-      }
-
-      return String(a);
-    }
-
-    if (typeof a === 'string') {
-      return a;
-    }
-
-    return '';
-  }
+  const sortingFns = {
+    alphanumeric,
+    alphanumericCaseSensitive,
+    text,
+    textCaseSensitive,
+    datetime,
+    basic
+  };
 
   //
   const Sorting = {
@@ -2662,11 +2662,6 @@
         onColumnVisibilityChange: makeStateUpdater('columnVisibility', instance)
       };
     },
-    getDefaultColumnDef: () => {
-      return {
-        defaultIsVisible: true
-      };
-    },
     createColumn: (column, instance) => {
       return {
         toggleVisibility: value => {
@@ -3650,25 +3645,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
@@ -3748,7 +3735,7 @@
         return rowModel;
       }
 
-      return expandRows(rowModel, instance);
+      return expandRows(rowModel);
     }, {
       key: 'getExpandedRowModel',
       debug: () => {
@@ -3766,7 +3753,7 @@
 
       expandedRows.push(row);
 
-      if (instance.options.expandSubRows && (_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
+      if ((_row$subRows = row.subRows) != null && _row$subRows.length && row.getIsExpanded()) {
         row.subRows.forEach(handleRow);
       }
     };
@@ -3803,7 +3790,7 @@
           rows,
           flatRows,
           rowsById
-        }, instance);
+        });
       }
 
       return {
@@ -3855,7 +3842,6 @@
   exports.isFunction = isFunction;
   exports.isRowSelected = isRowSelected;
   exports.makeStateUpdater = makeStateUpdater;
-  exports.mean = mean;
   exports.memo = memo;
   exports.noop = noop;
   exports.orderColumns = orderColumns;