@tanstack/table-core 8.0.0-alpha.22 → 8.0.0-alpha.23

package/build/types/aggregationTypes.d.ts

@@ -10,13 +10,13 @@ export declare const aggregationTypes: {
     count: typeof count;
 };
 export declare type BuiltInAggregationType = keyof typeof aggregationTypes;
-declare function sum(_leafValues: unknown[], childValues: unknown[]): number;
-declare function min(_leafValues: unknown[], childValues: unknown[]): number | undefined;
-declare function max(_leafValues: unknown[], childValues: unknown[]): number | undefined;
-declare function extent(_leafValues: unknown[], childValues: unknown[]): (number | undefined)[];
-declare function mean(leafValues: unknown[]): number | undefined;
-declare function median(values: unknown[]): number | undefined;
-declare function unique<T>(values: T[]): T[];
-declare function uniqueCount(values: unknown[]): number;
-declare function count(values: unknown[]): number;
+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)[];
+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/core.d.ts

@@ -58,8 +58,8 @@ export declare type CoreRow<TGenerics extends PartialGenerics> = {
     original?: TGenerics['Row'];
     depth: number;
     values: RowValues;
-    leafRows: Row<TGenerics>[];
     subRows: Row<TGenerics>[];
+    getLeafRows: () => Row<TGenerics>[];
     getRowProps: PropGetter<RowProps>;
     originalSubRows?: TGenerics['Row'][];
     getAllCells: () => Cell<TGenerics>[];

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

@@ -44,7 +44,7 @@ export declare type FiltersColumn<TGenerics extends PartialGenerics> = {
     getPreFilteredMinMaxValues: () => [any, any];
 };
 export declare type FiltersOptions<TGenerics extends PartialGenerics> = {
-    filterFromChildrenUp?: boolean;
+    filterFromLeafRows?: boolean;
     filterTypes?: TGenerics['FilterFns'];
     enableFilters?: boolean;
     onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>;

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

@@ -3,7 +3,7 @@ import { BuiltInAggregationType } from '../aggregationTypes';
 import { Cell, Column, Getter, OnChangeFn, PropGetterValue, TableInstance, Row, Updater, PartialGenerics, Renderable, UseRenderer } from '../types';
 import { Overwrite } from '../utils';
 export declare type GroupingState = string[];
-export declare type AggregationFn<TGenerics extends PartialGenerics> = (leafValues: TGenerics['Row'][], childValues: TGenerics['Row'][]) => any;
+export declare type AggregationFn<TGenerics extends PartialGenerics> = (getLeafValues: () => TGenerics['Row'][], getChildValues: () => TGenerics['Row'][]) => any;
 export declare type CustomAggregationTypes<TGenerics extends PartialGenerics> = Record<string, AggregationFn<TGenerics>>;
 export declare type AggregationType<TGenerics extends PartialGenerics> = 'auto' | BuiltInAggregationType | keyof TGenerics['AggregationFns'] | AggregationFn<TGenerics>;
 export declare type GroupingTableState = {

package/build/types/utils/filterRowsUtils.d.ts

@@ -0,0 +1,3 @@
+import { AnyGenerics, Row, RowModel, TableInstance } from '../types';
+export declare function filterRowModelFromLeafs<TGenerics extends AnyGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;
+export declare function filterRowModelFromRoot<TGenerics extends AnyGenerics>(rowsToFilter: Row<TGenerics>[], filterRows: (rowsToFilter: Row<TGenerics>[], depth: number) => Row<TGenerics>[], instance: TableInstance<TGenerics>): RowModel<TGenerics>;

package/build/types/utils/sortRowsQuicksortFn.d.ts

@@ -0,0 +1,11 @@
+import { TableInstance, Row, RowModel, AnyGenerics } from '../types';
+export declare function sortRowsFn<TGenerics extends AnyGenerics>(instance: TableInstance<TGenerics>, rowModel: RowModel<TGenerics>): RowModel<TGenerics>;
+declare type Sorter<TGenerics extends AnyGenerics> = {
+    id: string;
+    compare: (a: Row<TGenerics>, b: Row<TGenerics>) => number;
+    desc?: boolean;
+    sortUndefined?: false | -1 | 1;
+    invertSorting?: boolean;
+};
+export declare function quicksort<TGenerics extends AnyGenerics>(rows: Row<TGenerics>[], sorters: Sorter<TGenerics>[]): Row<TGenerics>[];
+export {};

package/build/umd/index.development.js

@@ -388,18 +388,18 @@
     count: count
   };
 
-  function sum(_leafValues, childValues) {
+  function sum(_getLeafValues, getChildValues) {
     // It's faster to just add the aggregations together instead of
     // process leaf nodes individually
-    return childValues.reduce(function (sum, next) {
+    return getChildValues().reduce(function (sum, next) {
       return sum + (typeof next === 'number' ? next : 0);
     }, 0);
   }
 
-  function min(_leafValues, childValues) {
+  function min(_getLeafValues, getChildValues) {
     var min;
 
-    for (var _iterator = _createForOfIteratorHelperLoose(childValues), _step; !(_step = _iterator()).done;) {
+    for (var _iterator = _createForOfIteratorHelperLoose(getChildValues()), _step; !(_step = _iterator()).done;) {
       var value = _step.value;
 
       if (value != null && (min > value || min === undefined && value >= value)) {
@@ -410,10 +410,10 @@
     return min;
   }
 
-  function max(_leafValues, childValues) {
+  function max(_getLeafValues, getChildValues) {
     var max;
 
-    for (var _iterator2 = _createForOfIteratorHelperLoose(childValues), _step2; !(_step2 = _iterator2()).done;) {
+    for (var _iterator2 = _createForOfIteratorHelperLoose(getChildValues()), _step2; !(_step2 = _iterator2()).done;) {
       var value = _step2.value;
 
       if (value != null && (max < value || max === undefined && value >= value)) {
@@ -424,11 +424,11 @@
     return max;
   }
 
-  function extent(_leafValues, childValues) {
+  function extent(_getLeafValues, getChildValues) {
     var min;
     var max;
 
-    for (var _iterator3 = _createForOfIteratorHelperLoose(childValues), _step3; !(_step3 = _iterator3()).done;) {
+    for (var _iterator3 = _createForOfIteratorHelperLoose(getChildValues()), _step3; !(_step3 = _iterator3()).done;) {
       var value = _step3.value;
 
       if (value != null) {
@@ -444,11 +444,11 @@
     return [min, max];
   }
 
-  function mean(leafValues) {
+  function mean(getLeafValues) {
     var count = 0;
     var sum = 0;
 
-    for (var _iterator4 = _createForOfIteratorHelperLoose(leafValues), _step4; !(_step4 = _iterator4()).done;) {
+    for (var _iterator4 = _createForOfIteratorHelperLoose(getLeafValues()), _step4; !(_step4 = _iterator4()).done;) {
       var value = _step4.value;
 
       if (value != null && (value = +value) >= value) {
@@ -460,14 +460,16 @@
     return;
   }
 
-  function median(values) {
-    if (!values.length) {
+  function median(getLeafValues) {
+    var leafValues = getLeafValues();
+
+    if (!leafValues.length) {
       return;
     }
 
     var min = 0;
     var max = 0;
-    values.forEach(function (value) {
+    leafValues.forEach(function (value) {
       if (typeof value === 'number') {
         min = Math.min(min, value);
         max = Math.max(max, value);
@@ -476,16 +478,16 @@
     return (min + max) / 2;
   }
 
-  function unique(values) {
-    return Array.from(new Set(values).values());
+  function unique(getLeafValues) {
+    return Array.from(new Set(getLeafValues()).values());
   }
 
-  function uniqueCount(values) {
-    return new Set(values).size;
+  function uniqueCount(getLeafValues) {
+    return new Set(getLeafValues()).size;
   }
 
-  function count(values) {
-    return values.length;
+  function count(getLeafValues) {
+    return getLeafValues().length;
   }
 
   //
@@ -1989,7 +1991,7 @@
         onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
         onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
         autoResetColumnFilters: true,
-        filterFromChildrenUp: true,
+        filterFromLeafRows: true,
         autoResetGlobalFilter: true,
         globalFilterType: 'auto',
         getColumnCanGlobalFilterFn: function getColumnCanGlobalFilterFn(column) {
@@ -2976,14 +2978,7 @@
           return row.subRows && !!row.subRows.length;
         },
         getToggleExpandedProps: function getToggleExpandedProps(userProps) {
-          var initialProps = {
-            title: 'Toggle Row Expanded',
-            onClick: function onClick(e) {
-              e.stopPropagation();
-              instance.toggleRowExpanded(row.id);
-            }
-          };
-          return propGetter(initialProps, userProps);
+          return instance.getToggleExpandedProps(row.id, userProps);
         }
       };
     }
@@ -3210,10 +3205,10 @@
         },
         toggleAllRowsSelected: function toggleAllRowsSelected(value) {
           instance.setRowSelection(function (old) {
-            value = typeof value !== 'undefined' ? value : !instance.getIsAllRowsSelected(); // Only remove/add the rows that are visible on the screen
-            //  Leave all the other rows that are selected alone.
+            value = typeof value !== 'undefined' ? value : !instance.getIsAllRowsSelected();
+
+            var rowSelection = _extends({}, old);
 
-            var rowSelection = Object.assign({}, old);
             var preGroupedFlatRows = instance.getPreGroupedRowModel().flatRows; // We don't use `mutateRowIsSelected` here for performance reasons.
             // All of the rows are flat already, so it wouldn't be worth it
 
@@ -3955,7 +3950,11 @@
           depth: depth,
           values: values,
           subRows: [],
-          leafRows: [],
+          getLeafRows: function getLeafRows() {
+            return flattenBy(row.subRows, function (d) {
+              return d.subRows;
+            });
+          },
           getRowProps: function getRowProps(userProps) {
             return instance.getRowProps(row.id, userProps);
           },
@@ -4049,13 +4048,9 @@
 
               for (var _i = 0; _i < row.originalSubRows.length; _i++) {
                 accessRow(row.originalSubRows[_i], _i, depth + 1, subRows, row);
-              } // Keep the new subRows array on the row
-
+              }
 
               row.subRows = subRows;
-              row.leafRows = flattenBy(subRows, function (d) {
-                return d.leafRows;
-              });
             }
           }
         };
@@ -4077,9 +4072,9 @@
           return (_instance$options$deb10 = instance.options.debugAll) != null ? _instance$options$deb10 : instance.options.debugTable;
         },
         onChange: function onChange() {
-          instance._notifyRowSelectionReset();
-
           instance._notifyFiltersReset();
+
+          instance._notifyRowSelectionReset();
         }
       }),
       // The final calls start at the bottom of the model,
@@ -4241,126 +4236,147 @@
     };
   }
 
-  function columnFilterRowsFn(instance, rowModel) {
-    var columnFilters = instance.getState().columnFilters;
+  function filterRowModelFromLeafs(rowsToFilter, filterRows, instance) {
     var newFilteredFlatRows = [];
     var newFilteredRowsById = {};
-    var filterFromChildrenUp = instance.options.filterFromChildrenUp;
 
-    var filterRows = function filterRows(rowsToFilter, depth) {
-      columnFilters.forEach(function (_ref) {
-        var columnId = _ref.id,
-            filterValue = _ref.value;
-        // Find the columnFilters column
-        var column = instance.getColumn(columnId);
+    var recurseFilterRows = function recurseFilterRows(rowsToFilter, depth) {
+      if (depth === void 0) {
+        depth = 0;
+      }
 
-        if (!column) {
-          {
-            console.warn("Table: Could not find a column with id: " + columnId);
-          }
+      rowsToFilter = rowsToFilter.slice(); // Filter from children up first
 
-          throw new Error();
-        }
+      for (var i = 0; i < rowsToFilter.length; i++) {
+        var _row$subRows;
 
-        if (depth === 0) {
-          var preFilteredRows = [].concat(rowsToFilter);
+        var row = rowsToFilter[i];
 
-          column.getPreFilteredRows = function () {
-            return preFilteredRows;
-          };
+        if (!((_row$subRows = row.subRows) != null && _row$subRows.length)) {
+          continue;
         }
 
-        var filterFn = instance.getColumnFilterFn(column.id);
-
-        if (!filterFn) {
-          {
-            console.warn("Could not find a valid 'column.filterType' for column with the ID: " + column.id + ".");
-          }
+        rowsToFilter[i] = instance.createRow(row.id, row.original, row.index, row.depth, row.values);
+        rowsToFilter[i].subRows = recurseFilterRows(row.subRows, depth + 1);
 
-          return;
-        } // Pass the rows, id, filterValue and column to the filterFn
-        // to get the filtered rows back
+        if (!rowsToFilter[i].subRows.length) {
+          rowsToFilter.splice(i, 1);
+          i--;
+        }
+      }
 
+      rowsToFilter = filterRows(rowsToFilter, depth); // Apply the filter to any subRows
 
-        rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue);
+      rowsToFilter.forEach(function (row) {
+        newFilteredFlatRows.push(row);
+        newFilteredRowsById[row.id] = row;
       });
       return rowsToFilter;
     };
 
-    if (filterFromChildrenUp) {
-      var _recurseFilterRows = function _recurseFilterRows(rowsToFilter, depth) {
-        if (depth === void 0) {
-          depth = 0;
-        }
-
-        // Filter from children up
-        rowsToFilter = rowsToFilter.filter(function (row) {
-          var _row$subRows;
-
-          if (!((_row$subRows = row.subRows) != null && _row$subRows.length)) {
-            return true;
-          }
-
-          row.subRows = _recurseFilterRows(row.subRows, depth + 1);
-          return row.subRows.length;
-        });
-        rowsToFilter = filterRows(rowsToFilter, depth); // Apply the filter to any subRows
-
-        rowsToFilter.forEach(function (row) {
-          newFilteredFlatRows.push(row);
-          newFilteredRowsById[row.id] = row;
-        });
-        return rowsToFilter;
-      };
-
-      return {
-        rows: _recurseFilterRows(rowModel.rows),
-        flatRows: newFilteredFlatRows,
-        rowsById: newFilteredRowsById
-      };
-    } // Filters top level and nested rows
-
+    return {
+      rows: recurseFilterRows(rowsToFilter),
+      flatRows: newFilteredFlatRows,
+      rowsById: newFilteredRowsById
+    };
+  }
+  function filterRowModelFromRoot(rowsToFilter, filterRows, instance) {
+    var newFilteredFlatRows = [];
+    var newFilteredRowsById = {}; // Filters top level and nested rows
 
     var recurseFilterRows = function recurseFilterRows(rowsToFilter, depth) {
       if (depth === void 0) {
         depth = 0;
       }
 
-      // Filter from parents downward
+      // Filter from parents downward first
       rowsToFilter = filterRows(rowsToFilter, depth); // Apply the filter to any subRows
-      // We technically could do this recursively in the above loop,
-      // but that would severely hinder the API for the user, since they
-      // would be required to do that recursion in some scenarios
 
-      rowsToFilter.forEach(function (row) {
+      for (var i = 0; i < rowsToFilter.length; i++) {
+        var _row$subRows2;
+
+        var row = rowsToFilter[i];
         newFilteredFlatRows.push(row);
         newFilteredRowsById[row.id] = row;
 
-        if (!filterFromChildrenUp) {
-          var _row$subRows2;
+        if (!((_row$subRows2 = row.subRows) != null && _row$subRows2.length)) {
+          rowsToFilter.splice(i, 1);
+          i--;
+          continue;
+        }
 
-          if (!((_row$subRows2 = row.subRows) != null && _row$subRows2.length)) {
-            return;
-          }
+        rowsToFilter[i] = instance.createRow(row.id, row.original, row.index, row.depth, row.values);
+        rowsToFilter[i].subRows = recurseFilterRows(row.subRows, depth + 1);
+      }
 
-          row.subRows = recurseFilterRows(row.subRows, depth + 1);
-        }
-      });
       return rowsToFilter;
     };
 
     return {
-      rows: recurseFilterRows(rowModel.rows),
+      rows: recurseFilterRows(rowsToFilter),
       flatRows: newFilteredFlatRows,
       rowsById: newFilteredRowsById
     };
   }
 
+  function columnFilterRowsFn(instance, rowModel) {
+    var columnFilters = instance.getState().columnFilters;
+    var filterFromLeafRows = instance.options.filterFromLeafRows;
+
+    var filterRows = function filterRows(rowsToFilter, depth) {
+      for (var i = 0; i < columnFilters.length; i++) {
+        var _columnFilters$i = columnFilters[i],
+            columnId = _columnFilters$i.id,
+            filterValue = _columnFilters$i.value; // Find the columnFilters column
+
+        var column = instance.getColumn(columnId);
+
+        if (!column) {
+          {
+            console.warn("Table: Could not find a column with id: " + columnId);
+          }
+
+          throw new Error();
+        }
+
+        if (depth === 0) {
+          (function () {
+            var preFilteredRows = [].concat(rowsToFilter);
+
+            column.getPreFilteredRows = function () {
+              return preFilteredRows;
+            };
+          })();
+        }
+
+        var filterFn = instance.getColumnFilterFn(column.id);
+
+        if (!filterFn) {
+          {
+            console.warn("Could not find a valid 'column.filterType' for column with the ID: " + column.id + ".");
+          }
+
+          continue;
+        } // Pass the rows, id, filterValue and column to the filterFn
+        // to get the filtered rows back
+
+
+        rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue);
+      }
+
+      return rowsToFilter;
+    };
+
+    if (filterFromLeafRows) {
+      return filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
+    }
+
+    return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
+  }
+
   function globalFilterRowsFn(instance, rowModel) {
     var globalFilter = instance.getState().globalFilter;
-    var newFilteredFlatRows = [];
-    var newFilteredRowsById = {};
-    var filterFromChildrenUp = instance.options.filterFromChildrenUp;
+    var filterFromLeafRows = instance.options.filterFromLeafRows;
     var filterFn = instance.getGlobalFilterFn();
 
     if (!filterFn) {
@@ -4378,67 +4394,15 @@
       return d.id;
     });
 
-    if (filterFromChildrenUp) {
-      var _recurseFilterRows = function _recurseFilterRows(rowsToFilter, depth) {
-
-        // Filter from children up
-        rowsToFilter = rowsToFilter.filter(function (row) {
-          var _row$subRows;
-
-          if (!((_row$subRows = row.subRows) != null && _row$subRows.length)) {
-            return true;
-          }
-
-          row.subRows = _recurseFilterRows(row.subRows);
-          return row.subRows.length;
-        });
-        rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter); // Apply the filter to any subRows
-
-        rowsToFilter.forEach(function (row) {
-          newFilteredFlatRows.push(row);
-          newFilteredRowsById[row.id] = row;
-        });
-        return rowsToFilter;
-      };
-
-      return {
-        rows: _recurseFilterRows(rowModel.rows),
-        flatRows: newFilteredFlatRows,
-        rowsById: newFilteredRowsById
-      };
-    } // Filters top level and nested rows
-
-
-    var recurseFilterRows = function recurseFilterRows(rowsToFilter, depth) {
-
-      // Filter from parents downward
-      rowsToFilter = filterFn(rowsToFilter, filterableColumnIds, globalFilter); // Apply the filter to any subRows
-      // We technically could do this recursively in the above loop,
-      // but that would severely hinder the API for the user, since they
-      // would be required to do that recursion in some scenarios
-
-      rowsToFilter.forEach(function (row) {
-        newFilteredFlatRows.push(row);
-        newFilteredRowsById[row.id] = row;
-
-        if (!filterFromChildrenUp) {
-          var _row$subRows2;
-
-          if (!((_row$subRows2 = row.subRows) != null && _row$subRows2.length)) {
-            return;
-          }
-
-          row.subRows = recurseFilterRows(row.subRows);
-        }
-      });
-      return rowsToFilter;
+    var filterRows = function filterRows(rows) {
+      return filterFn(rows, filterableColumnIds, globalFilter);
     };
 
-    return {
-      rows: recurseFilterRows(rowModel.rows),
-      flatRows: newFilteredFlatRows,
-      rowsById: newFilteredRowsById
-    };
+    if (filterFromLeafRows) {
+      filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
+    }
+
+    return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
   }
 
   function sortRowsFn(instance, rowModel) {
@@ -4477,7 +4441,7 @@
             var bUndefined = typeof bValue === 'undefined';
 
             if (aUndefined || bUndefined) {
-              return aUndefined && bUndefined ? 0 : aUndefined ? 1 : -1;
+              return aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
             }
           } // This function should always return in ascending order
 
@@ -4540,21 +4504,21 @@
         var aggregateFn = instance.getColumnAggregationFn(column.id);
 
         if (aggregateFn) {
-          // Get the columnValues to aggregate
-          var groupedValues = groupedRows.map(function (row) {
-            return row.values[column.id];
-          }); // Get the columnValues to aggregate
-
-          var leafValues = leafRows.map(function (row) {
-            var columnValue = row.values[column.id];
+          values[column.id] = aggregateFn(function () {
+            return leafRows.map(function (row) {
+              var columnValue = row.values[column.id];
 
-            if (!depth && column.aggregateValue) {
-              columnValue = column.aggregateValue(columnValue);
-            }
+              if (!depth && column.aggregateValue) {
+                columnValue = column.aggregateValue(columnValue);
+              }
 
-            return columnValue;
+              return columnValue;
+            });
+          }, function () {
+            return groupedRows.map(function (row) {
+              return row.values[column.id];
+            });
           });
-          values[column.id] = aggregateFn(leafValues, groupedValues);
         } else if (column.aggregationType) {
           console.info({
             column: column
@@ -4597,7 +4561,7 @@
         var subRows = groupUpRecursively(groupedRows, depth + 1, id); // Flatten the leaf rows of the rows in this group
 
         var leafRows = depth ? flattenBy(groupedRows, function (row) {
-          return row.leafRows;
+          return row.subRows;
         }) : groupedRows;
         var values = aggregateRowsToValues(leafRows, groupedRows, depth);
         var row = instance.createRow(id, undefined, index, depth, values);