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

package/build/esm/index.js

@@ -382,18 +382,18 @@ var aggregationTypes = {
   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)) {
@@ -404,10 +404,10 @@ function min(_leafValues, childValues) {
   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)) {
@@ -418,11 +418,11 @@ function max(_leafValues, childValues) {
   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) {
@@ -438,11 +438,11 @@ function extent(_leafValues, childValues) {
   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) {
@@ -454,14 +454,16 @@ function mean(leafValues) {
   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);
@@ -470,16 +472,16 @@ function median(values) {
   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;
 }
 
 //
@@ -1983,7 +1985,7 @@ var Filters = {
       onColumnFiltersChange: makeStateUpdater('columnFilters', instance),
       onGlobalFilterChange: makeStateUpdater('globalFilter', instance),
       autoResetColumnFilters: true,
-      filterFromChildrenUp: true,
+      filterFromLeafRows: true,
       autoResetGlobalFilter: true,
       globalFilterType: 'auto',
       getColumnCanGlobalFilterFn: function getColumnCanGlobalFilterFn(column) {
@@ -2970,14 +2972,7 @@ var Expanding = {
         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);
       }
     };
   }
@@ -3204,10 +3199,10 @@ var RowSelection = {
       },
       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
 
@@ -3951,7 +3946,11 @@ function createTableInstance(options) {
         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);
         },
@@ -4045,13 +4044,9 @@ function createTableInstance(options) {
 
             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;
-            });
           }
         }
       };
@@ -4073,9 +4068,9 @@ function createTableInstance(options) {
         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,
@@ -4243,126 +4238,147 @@ function _createTable(_, __, __options) {
   };
 }
 
-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) {
-        if (process.env.NODE_ENV !== 'production') {
-          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) {
-        if (process.env.NODE_ENV !== 'production') {
-          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) {
+        if (process.env.NODE_ENV !== 'production') {
+          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) {
+        if (process.env.NODE_ENV !== 'production') {
+          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) {
@@ -4380,67 +4396,15 @@ function globalFilterRowsFn(instance, rowModel) {
     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) {
@@ -4479,7 +4443,7 @@ function sortRowsFn(instance, rowModel) {
           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
 
@@ -4542,21 +4506,21 @@ function groupRowsFn(instance, sortedRowModel) {
       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
@@ -4599,7 +4563,7 @@ function groupRowsFn(instance, sortedRowModel) {
       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);