@tanstack/table-core 8.0.0-alpha.30 → 8.0.0-alpha.32

package/build/esm/index.js

@@ -103,6 +103,32 @@ function functionalUpdate(updater, input) {
 }
 function noop() {//
 }
+function getBatchGroups(arr, count) {
+  var groups = [{
+    start: 0,
+    end: count - 1,
+    items: []
+  }];
+  var groupIndex = 0;
+  var group = groups[groupIndex];
+
+  for (var i = 0; i < arr.length; i++) {
+    if (i > group.end) {
+      groupIndex++;
+      groups[groupIndex] = {
+        start: i,
+        end: i + count - 1,
+        items: []
+      };
+    }
+
+    group = groups[groupIndex];
+    var _item = arr[i];
+    group.items.push(_item);
+  }
+
+  return groups;
+}
 function makeStateUpdater(key, instance) {
   return function (updater) {
     instance.setState(function (old) {
@@ -200,22 +226,133 @@ function memo(getDeps, fn, opts) {
 
     return result;
   };
-} // export function hashString(str: string, seed = 0): string {
-//   let h1 = 0xdeadbeef ^ seed,
-//     h2 = 0x41c6ce57 ^ seed
-//   for (let i = 0, ch; i < str.length; i++) {
-//     ch = str.charCodeAt(i)
-//     h1 = Math.imul(h1 ^ ch, 2654435761)
-//     h2 = Math.imul(h2 ^ ch, 1597334677)
-//   }
-//   h1 =
-//     Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
-//     Math.imul(h2 ^ (h2 >>> 13), 3266489909)
-//   h2 =
-//     Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
-//     Math.imul(h1 ^ (h1 >>> 13), 3266489909)
-//   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString()
-// }
+}
+function incrementalMemo(getDeps, getInitialValue, schedule, opts) {
+  var _opts$timeout;
+
+  var oldDeps;
+  var deps;
+  var result;
+  var nextResultRef;
+  var tasks = [];
+  var totalTaskCount = 0;
+  var resultStartTime;
+  var batchIndex = 0;
+  var progress = 0;
+  var working = false;
+  var callback;
+  var timeout = (_opts$timeout = opts.timeout) != null ? _opts$timeout : 100;
+
+  var onProgress = function onProgress(latestResult, previousResult) {
+    progress = 1 - tasks.length / totalTaskCount;
+    opts.onProgress(progress, latestResult, previousResult);
+  };
+
+  return function () {
+    var scheduleFn = function scheduleFn(workFn) {
+      totalTaskCount++;
+      tasks.push(workFn);
+    };
+
+    var newDeps = getDeps();
+    var first = false;
+
+    if (!deps) {
+      first = true;
+      deps = [];
+      result = getInitialValue.apply(void 0, newDeps);
+    }
+
+    var depsChanged = newDeps.length !== deps.length || newDeps.some(function (dep, index) {
+      return deps[index] !== dep;
+    });
+
+    if (depsChanged) {
+      cancelIdleCallback(callback);
+      oldDeps = deps;
+      deps = newDeps;
+      totalTaskCount = 0;
+      tasks = [];
+      nextResultRef = {
+        current: getInitialValue.apply(void 0, newDeps)
+      };
+      resultStartTime = Date.now();
+      schedule.apply(void 0, newDeps)(nextResultRef)(scheduleFn);
+    }
+
+    var commitResult = function commitResult() {
+      cancelIdleCallback(callback);
+
+      if (opts.key && opts.debug) {
+        if (opts != null && opts.debug()) {
+          var resultEndTime = Math.round((Date.now() - resultStartTime) * 100) / 100;
+          var resultFpsPercentage = resultEndTime / batchIndex / 16;
+          console.info("%c\u23F1 " + resultEndTime + " ms / " + batchIndex + " tasks = " + Math.round(resultEndTime / batchIndex) + " ms/task", "\n      font-size: .6rem;\n      font-weight: bold;\n      color: hsl(" + Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120)) + "deg 100% 31%);", opts == null ? void 0 : opts.key, _extends({
+            length: oldDeps.length + " -> " + deps.length
+          }, deps.map(function (_, index) {
+            if (oldDeps[index] !== deps[index]) {
+              return [index, oldDeps[index], deps[index]];
+            }
+
+            return false;
+          }).filter(Boolean).reduce(function (accu, _ref2) {
+            var _extends4;
+
+            var a = _ref2[0],
+                b = _ref2[1];
+            return _extends({}, accu, (_extends4 = {}, _extends4[a] = b, _extends4));
+          }, {}), {
+            parent: parent
+          }));
+        }
+      }
+
+      working = false;
+      var previousResult = result;
+      result = nextResultRef.current;
+      onProgress(result, previousResult);
+      opts.onChange(result, previousResult);
+    };
+
+    if (opts.initialSync && first) {
+      batchIndex = 1;
+      first = false;
+
+      for (var i = 0; i < tasks.length; i++) {
+        tasks[i]();
+      }
+
+      tasks = [];
+      commitResult();
+    } else if (!working && tasks.length) {
+      cancelIdleCallback(callback);
+      working = true;
+      batchIndex = 0;
+
+      var workLoop = function workLoop(deadline) {
+        while (tasks.length && deadline.timeRemaining() > 0) {
+          tasks.shift()();
+        }
+
+        if (!tasks.length) {
+          commitResult();
+        } else {
+          ++batchIndex;
+          onProgress(nextResultRef.current, result);
+          callback = requestIdleCallback(workLoop, {
+            timeout: timeout
+          });
+        }
+      };
+
+      callback = requestIdleCallback(workLoop, {
+        timeout: timeout
+      });
+    }
+
+    return result;
+  };
+} // opts?.onChange?.(result, oldResult)
 
 //
 var defaultColumnSizing = {
@@ -546,6 +683,8 @@ var Expanding = {
     var registered = false;
     return {
       _notifyExpandedReset: function _notifyExpandedReset() {
+        instance._notifyPageIndexReset();
+
         if (!registered) {
           registered = true;
           return;
@@ -697,25 +836,19 @@ var Expanding = {
         });
         return maxDepth;
       },
-      getExpandedRowModel: memo(function () {
-        return [instance.getState().expanded, instance.getGroupedRowModel(), instance.options.expandRowsFn, instance.options.paginateExpandedRows];
-      }, function (expanded, rowModel, expandRowsFn, paginateExpandedRows) {
-        if (!expandRowsFn || // Do not expand if rows are not included in pagination
-        !paginateExpandedRows || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
-          return rowModel;
+      getPreExpandedRowModel: function getPreExpandedRowModel() {
+        return instance.getGroupedRowModel();
+      },
+      getExpandedRowModel: function getExpandedRowModel() {
+        if (!instance._getExpandedRowModel && instance.options.getExpandedRowModel) {
+          instance._getExpandedRowModel = instance.options.getExpandedRowModel(instance);
         }
 
-        return expandRowsFn(instance, rowModel);
-      }, {
-        key: 'getExpandedRowModel',
-        debug: function debug() {
-          var _instance$options$deb;
-
-          return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+        if (!instance._getExpandedRowModel) {
+          return instance.getPreExpandedRowModel();
         }
-      }),
-      getPreExpandedRowModel: function getPreExpandedRowModel() {
-        return instance.getGroupedRowModel();
+
+        return instance._getExpandedRowModel();
       }
     };
   },
@@ -903,7 +1036,9 @@ var Filters = {
   getInitialState: function getInitialState() {
     return {
       columnFilters: [],
-      globalFilter: undefined
+      globalFilter: undefined,
+      columnFiltersProgress: 1,
+      globalFilterProgress: 1
     };
   },
   getDefaultOptions: function getDefaultOptions(instance) {
@@ -1002,6 +1137,8 @@ var Filters = {
     var registered = false;
     return {
       _notifyFiltersReset: function _notifyFiltersReset() {
+        instance._notifySortingReset();
+
         if (!registered) {
           registered = true;
           return;
@@ -1011,16 +1148,12 @@ var Filters = {
           return;
         }
 
-        if (instance.options.autoResetAll === true) {
-          instance.resetSorting();
-        } else {
-          if (instance.options.autoResetColumnFilters) {
-            instance.resetColumnFilters();
-          }
+        if (instance.options.autoResetAll === true || instance.options.autoResetColumnFilters) {
+          instance.resetColumnFilters();
+        }
 
-          if (instance.options.autoResetGlobalFilter) {
-            instance.resetGlobalFilter();
-          }
+        if (instance.options.autoResetAll === true || instance.options.autoResetGlobalFilter) {
+          instance.resetGlobalFilter();
         }
       },
       getColumnAutoFilterFn: function getColumnAutoFilterFn(columnId) {
@@ -1200,84 +1333,31 @@ var Filters = {
       getPreColumnFilteredRowModel: function getPreColumnFilteredRowModel() {
         return instance.getCoreRowModel();
       },
-      getColumnFilteredRowModel: memo(function () {
-        return [instance.getState().columnFilters, instance.getCoreRowModel(), instance.options.columnFilterRowsFn];
-      }, function (columnFilters, rowModel, columnFiltersFn) {
-        var columnFilteredRowModel = function () {
-          if (!(columnFilters != null && columnFilters.length) || !columnFiltersFn) {
-            return rowModel;
-          }
-
-          return columnFiltersFn(instance, rowModel);
-        }(); // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
-
-
-        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
-          var _instance$getState$co5;
-
-          return !((_instance$getState$co5 = instance.getState().columnFilters) != null && _instance$getState$co5.find(function (d) {
-            return d.id === column.id;
-          }));
-        }); // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
-
-        nonFilteredColumns.forEach(function (column) {
-          column.getPreFilteredRows = function () {
-            return columnFilteredRowModel.rows;
-          };
-        });
-        return columnFilteredRowModel;
-      }, {
-        key: 'getColumnFilteredRowModel',
-        debug: function debug() {
-          var _instance$options$deb2;
+      getColumnFilteredRowModel: function getColumnFilteredRowModel() {
+        if (!instance._getColumnFilteredRowModel && instance.options.getColumnFilteredRowModel) {
+          instance._getColumnFilteredRowModel = instance.options.getColumnFilteredRowModel(instance);
+        }
 
-          return (_instance$options$deb2 = instance.options.debugAll) != null ? _instance$options$deb2 : instance.options.debugTable;
+        if (!instance._getColumnFilteredRowModel) {
+          return instance.getPreColumnFilteredRowModel();
         }
-      }),
+
+        return instance._getColumnFilteredRowModel();
+      },
       getPreGlobalFilteredRowModel: function getPreGlobalFilteredRowModel() {
         return instance.getColumnFilteredRowModel();
       },
-      getGlobalFilteredRowModel: memo(function () {
-        return [instance.getState().globalFilter, instance.getColumnFilteredRowModel(), instance.options.globalFilterRowsFn];
-      }, function (globalFilterValue, columnFilteredRowModel, globalFiltersFn) {
-        var globalFilteredRowModel = function () {
-          if (!globalFiltersFn || !globalFilterValue) {
-            return columnFilteredRowModel;
-          }
-
-          return globalFiltersFn(instance, columnFilteredRowModel);
-        }(); // Now that each filtered column has it's partially filtered rows,
-        // lets assign the final filtered rows to all of the other columns
-
-
-        var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
-          var _instance$getState$co6;
-
-          return !((_instance$getState$co6 = instance.getState().columnFilters) != null && _instance$getState$co6.find(function (d) {
-            return d.id === column.id;
-          }));
-        }); // This essentially enables faceted filter options to be built easily
-        // using every column's preFilteredRows value
-
-        nonFilteredColumns.forEach(function (column) {
-          column.getPreFilteredRows = function () {
-            return globalFilteredRowModel.rows;
-          };
-        });
-        return globalFilteredRowModel;
-      }, {
-        key: 'getGlobalFilteredRowModel',
-        debug: function debug() {
-          var _instance$options$deb3;
+      getGlobalFilteredRowModel: function getGlobalFilteredRowModel() {
+        if (!instance._getGlobalFilteredRowModel && instance.options.getGlobalFilteredRowModel) {
+          instance._getGlobalFilteredRowModel = instance.options.getGlobalFilteredRowModel(instance);
+        }
 
-          return (_instance$options$deb3 = instance.options.debugAll) != null ? _instance$options$deb3 : instance.options.debugTable;
-        },
-        onChange: function onChange() {
-          instance._notifySortingReset();
+        if (!instance._getGlobalFilteredRowModel) {
+          return instance.getPreGlobalFilteredRowModel();
         }
-      })
+
+        return instance._getGlobalFilteredRowModel();
+      }
     };
   }
 };
@@ -1442,6 +1522,8 @@ var Grouping = {
     var registered = false;
     return {
       _notifyGroupingReset: function _notifyGroupingReset() {
+        instance._notifyExpandedReset();
+
         if (!registered) {
           registered = true;
           return;
@@ -1541,25 +1623,17 @@ var Grouping = {
       getPreGroupedRowModel: function getPreGroupedRowModel() {
         return instance.getSortedRowModel();
       },
-      getGroupedRowModel: memo(function () {
-        return [instance.getState().grouping, instance.getSortedRowModel(), instance.options.groupRowsFn];
-      }, function (grouping, rowModel, groupRowsFn) {
-        if (!groupRowsFn || !grouping.length) {
-          return rowModel;
+      getGroupedRowModel: function getGroupedRowModel() {
+        if (!instance._getGroupedRowModel && instance.options.getGroupedRowModel) {
+          instance._getGroupedRowModel = instance.options.getGroupedRowModel(instance);
         }
 
-        return groupRowsFn(instance, rowModel);
-      }, {
-        key: 'getGroupedRowModel',
-        debug: function debug() {
-          var _instance$options$deb;
-
-          return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
-        },
-        onChange: function onChange() {
-          return instance._notifyExpandedReset();
+        if (!instance._getGroupedRowModel) {
+          return instance.getPreGroupedRowModel();
         }
-      })
+
+        return instance._getGroupedRowModel();
+      }
     };
   },
   createRow: function createRow(row, instance) {
@@ -1828,22 +1902,17 @@ var Pagination = {
       getPrePaginationRowModel: function getPrePaginationRowModel() {
         return instance.getExpandedRowModel();
       },
-      getPaginationRowModel: memo(function () {
-        return [instance.getState().pagination, instance.getExpandedRowModel(), instance.options.paginateRowsFn];
-      }, function (_pagination, rowModel, paginateRowsFn) {
-        if (!paginateRowsFn || !rowModel.rows.length) {
-          return rowModel;
+      getPaginationRowModel: function getPaginationRowModel() {
+        if (!instance._getPaginationRowModel && instance.options.getPaginationRowModel) {
+          instance._getPaginationRowModel = instance.options.getPaginationRowModel(instance);
         }
 
-        return paginateRowsFn(instance, rowModel);
-      }, {
-        key: 'getPaginationRowModel',
-        debug: function debug() {
-          var _instance$options$deb2;
-
-          return (_instance$options$deb2 = instance.options.debugAll) != null ? _instance$options$deb2 : instance.options.debugTable;
+        if (!instance._getPaginationRowModel) {
+          return instance.getPrePaginationRowModel();
         }
-      }),
+
+        return instance._getPaginationRowModel();
+      },
       getPageCount: function getPageCount() {
         var pageCount = instance.getState().pagination.pageCount;
 
@@ -2653,6 +2722,8 @@ var Sorting = {
     var registered = false;
     return {
       _notifySortingReset: function _notifySortingReset() {
+        instance._notifyGroupingReset();
+
         if (!registered) {
           registered = true;
           return;
@@ -2883,25 +2954,17 @@ var Sorting = {
       getPreSortedRowModel: function getPreSortedRowModel() {
         return instance.getGlobalFilteredRowModel();
       },
-      getSortedRowModel: memo(function () {
-        return [instance.getState().sorting, instance.getGlobalFilteredRowModel(), instance.options.sortRowsFn];
-      }, function (sorting, rowModel, sortingFn) {
-        if (!sortingFn || !(sorting != null && sorting.length)) {
-          return rowModel;
+      getSortedRowModel: function getSortedRowModel() {
+        if (!instance._getSortedRowModel && instance.options.getSortedRowModel) {
+          instance._getSortedRowModel = instance.options.getSortedRowModel(instance);
         }
 
-        return sortingFn(instance, rowModel);
-      }, {
-        key: 'getSortedRowModel',
-        debug: function debug() {
-          var _instance$options$deb;
-
-          return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
-        },
-        onChange: function onChange() {
-          instance._notifyGroupingReset();
+        if (!instance._getSortedRowModel) {
+          return instance.getPreSortedRowModel();
         }
-      })
+
+        return instance._getSortedRowModel();
+      }
     };
   }
 };
@@ -3687,8 +3750,11 @@ function createTableInstance(options) {
   };
 
   instance.options = buildOptions(options);
+  var coreInitialState = {
+    coreProgress: 1
+  };
 
-  var initialState = _extends({}, features.reduce(function (obj, feature) {
+  var initialState = _extends({}, coreInitialState, features.reduce(function (obj, feature) {
     return Object.assign(obj, feature.getInitialState == null ? void 0 : feature.getInitialState());
   }, {}), (_options$initialState = options.initialState) != null ? _options$initialState : {});
 
@@ -4002,85 +4068,13 @@ function createTableInstance(options) {
 
       return row;
     },
-    getCoreRowModel: memo(function () {
-      return [instance.options.data];
-    }, function (data) {
-      // Access the row model using initial columns
-      var rows = [];
-      var flatRows = [];
-      var rowsById = {};
-      var leafColumns = instance.getAllLeafColumns();
-
-      var accessRow = function accessRow(originalRow, rowIndex, depth, parentRows, parent) {
-        if (depth === void 0) {
-          depth = 0;
-        }
-
-        var id = instance.getRowId(originalRow, rowIndex, parent);
-
-        if (!id) {
-          if (process.env.NODE_ENV !== 'production') {
-            throw new Error("getRowId expected an ID, but got " + id);
-          }
-        }
-
-        var values = {};
-
-        for (var i = 0; i < leafColumns.length; i++) {
-          var _column = leafColumns[i];
-
-          if (_column && _column.accessorFn) {
-            values[_column.id] = _column.accessorFn(originalRow, rowIndex);
-          }
-        } // Make the row
-
-
-        var row = instance.createRow(id, originalRow, rowIndex, depth, values); // Push instance row into the parentRows array
-
-        parentRows.push(row); // Keep track of every row in a flat array
-
-        flatRows.push(row); // Also keep track of every row by its ID
-
-        rowsById[id] = row; // Get the original subrows
-
-        if (instance.options.getSubRows) {
-          var originalSubRows = instance.options.getSubRows(originalRow, rowIndex); // Then recursively access them
-
-          if (originalSubRows != null && originalSubRows.length) {
-            row.originalSubRows = originalSubRows;
-            var subRows = [];
-
-            for (var _i = 0; _i < row.originalSubRows.length; _i++) {
-              accessRow(row.originalSubRows[_i], _i, depth + 1, subRows, row);
-            }
-
-            row.subRows = subRows;
-          }
-        }
-      };
-
-      for (var i = 0; i < data.length; i++) {
-        accessRow(data[i], i, 0, rows);
+    getCoreRowModel: function getCoreRowModel() {
+      if (!instance._getCoreRowModel) {
+        instance._getCoreRowModel = instance.options.getCoreRowModel(instance);
       }
 
-      return {
-        rows: rows,
-        flatRows: flatRows,
-        rowsById: rowsById
-      };
-    }, {
-      key: 'getRowModel',
-      debug: function debug() {
-        var _instance$options$deb10;
-
-        return (_instance$options$deb10 = instance.options.debugAll) != null ? _instance$options$deb10 : instance.options.debugTable;
-      },
-      onChange: function onChange() {
-        instance._notifyFiltersReset();
-
-        instance._notifyRowSelectionReset();
-      }
-    }),
+      return instance._getCoreRowModel();
+    },
     // The final calls start at the bottom of the model,
     // expanded rows, which then work their way up
     getRowModel: function getRowModel() {
@@ -4183,6 +4177,18 @@ function createTableInstance(options) {
       return (_instance$getRightHea = (_instance$getRightHea2 = instance.getRightHeaderGroups()[0]) == null ? void 0 : _instance$getRightHea2.headers.reduce(function (sum, header) {
         return sum + header.getWidth();
       }, 0)) != null ? _instance$getRightHea : 0;
+    },
+    getOverallProgress: function getOverallProgress() {
+      var _instance$getState = instance.getState(),
+          coreProgress = _instance$getState.coreProgress,
+          columnFiltersProgress = _instance$getState.columnFiltersProgress,
+          globalFilterProgress = _instance$getState.globalFilterProgress;
+
+      return mean(function () {
+        return [coreProgress, columnFiltersProgress, globalFilterProgress].filter(function (d) {
+          return d < 1;
+        });
+      });
     }
   });
 
@@ -4251,25 +4257,215 @@ function _createTable(_, __, __options) {
   };
 }
 
-function filterRowModelFromLeafs(rowsToFilter, filterRows, instance) {
-  var newFilteredFlatRows = [];
-  var newFilteredRowsById = {};
+function getCoreRowModelSync() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.options.data];
+    }, function (data) {
+      // Access the row model using initial columns
+      var rows = [];
+      var flatRows = [];
+      var rowsById = {};
+      var leafColumns = instance.getAllLeafColumns();
 
-  var recurseFilterRows = function recurseFilterRows(rowsToFilter, depth) {
-    if (depth === void 0) {
-      depth = 0;
-    }
+      var accessRow = function accessRow(originalRow, rowIndex, depth, parentRows, parent) {
+        if (depth === void 0) {
+          depth = 0;
+        }
 
-    rowsToFilter = rowsToFilter.slice(); // Filter from children up first
+        var id = instance.getRowId(originalRow, rowIndex, parent);
 
-    for (var i = 0; i < rowsToFilter.length; i++) {
-      var _row$subRows;
+        if (!id) {
+          if (process.env.NODE_ENV !== 'production') {
+            throw new Error("getRowId expected an ID, but got " + id);
+          }
+        }
 
-      var row = rowsToFilter[i];
+        var values = {};
 
-      if (!((_row$subRows = row.subRows) != null && _row$subRows.length)) {
-        continue;
-      }
+        for (var i = 0; i < leafColumns.length; i++) {
+          var column = leafColumns[i];
+
+          if (column && column.accessorFn) {
+            values[column.id] = column.accessorFn(originalRow, rowIndex);
+          }
+        } // Make the row
+
+
+        var row = instance.createRow(id, originalRow, rowIndex, depth, values); // Push instance row into the parentRows array
+
+        parentRows.push(row); // Keep track of every row in a flat array
+
+        flatRows.push(row); // Also keep track of every row by its ID
+
+        rowsById[id] = row; // Get the original subrows
+
+        if (instance.options.getSubRows) {
+          var originalSubRows = instance.options.getSubRows(originalRow, rowIndex); // Then recursively access them
+
+          if (originalSubRows != null && originalSubRows.length) {
+            row.originalSubRows = originalSubRows;
+            var subRows = [];
+
+            for (var _i = 0; _i < row.originalSubRows.length; _i++) {
+              accessRow(row.originalSubRows[_i], _i, depth + 1, subRows, row);
+            }
+
+            row.subRows = subRows;
+          }
+        }
+      };
+
+      for (var i = 0; i < data.length; i++) {
+        accessRow(data[i], i, 0, rows);
+      }
+
+      return {
+        rows: rows,
+        flatRows: flatRows,
+        rowsById: rowsById
+      };
+    }, {
+      key: 'getRowModel',
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        instance._notifyFiltersReset();
+
+        instance._notifyRowSelectionReset();
+      }
+    });
+  };
+}
+
+function getCoreRowModelAsync(opts) {
+  return function (instance) {
+    return incrementalMemo(function () {
+      return [instance.options.data, instance.getAllLeafColumns()];
+    }, function () {
+      var rows = [];
+      var flatRows = [];
+      var rowsById = {};
+      return {
+        rows: rows,
+        flatRows: flatRows,
+        rowsById: rowsById
+      };
+    }, function (data, leafColumns) {
+      return function (rowModelRef) {
+        return function (scheduleTask) {
+          var accessRows = function accessRows(originalRows, depth, parent) {
+            if (depth === void 0) {
+              depth = 0;
+            }
+
+            var batchGroups = getBatchGroups(originalRows, 2000);
+
+            var _loop = function _loop(i) {
+              var batchGroup = batchGroups[i];
+              scheduleTask(function () {
+                for (var _i = 0; _i < batchGroup.items.length; _i++) {
+                  var originalRow = batchGroup.items[_i];
+                  var rowIndex = batchGroup.start + _i;
+                  var id = instance.getRowId(originalRow, rowIndex, parent);
+
+                  if (!id) {
+                    if (process.env.NODE_ENV !== 'production') {
+                      throw new Error("getRowId expected an ID, but got " + id);
+                    }
+                  }
+
+                  var values = {};
+
+                  for (var _i2 = 0; _i2 < leafColumns.length; _i2++) {
+                    var column = leafColumns[_i2];
+
+                    if (column && column.accessorFn) {
+                      values[column.id] = column.accessorFn(originalRow, rowIndex);
+                    }
+                  } // Make the row
+
+
+                  var row = instance.createRow(id, originalRow, rowIndex, depth, values); // Push instance row into the parentRows array
+
+                  if (parent) {
+                    parent.subRows.push(row);
+                  } else {
+                    rowModelRef.current.rows.push(row);
+                  } // Keep track of every row in a flat array
+
+
+                  rowModelRef.current.flatRows.push(row); // Also keep track of every row by its ID
+
+                  rowModelRef.current.rowsById[id] = row; // Get the original subrows
+
+                  if (instance.options.getSubRows) {
+                    var originalSubRows = instance.options.getSubRows(originalRow, rowIndex); // Then recursively access them
+
+                    if (originalSubRows != null && originalSubRows.length) {
+                      row.originalSubRows = originalSubRows;
+                      row.subRows = [];
+                      accessRows(row.originalSubRows, depth + 1, row);
+                    }
+                  }
+                }
+              });
+            };
+
+            for (var i = 0; i < batchGroups.length; i++) {
+              _loop(i);
+            }
+          };
+
+          accessRows(data);
+        };
+      };
+    }, {
+      key: 'getRowModel',
+      initialSync: opts == null ? void 0 : opts.initialSync,
+      onProgress: function onProgress(progress) {
+        instance.setState(function (old) {
+          return _extends({}, old, {
+            coreProgress: progress
+          });
+        });
+      },
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        instance._notifyFiltersReset();
+
+        instance._notifyRowSelectionReset();
+      }
+    });
+  };
+}
+
+function filterRowModelFromLeafs(rowsToFilter, filterRows, instance) {
+  var newFilteredFlatRows = [];
+  var newFilteredRowsById = {};
+
+  var recurseFilterRows = function recurseFilterRows(rowsToFilter, depth) {
+    if (depth === void 0) {
+      depth = 0;
+    }
+
+    rowsToFilter = rowsToFilter.slice(); // Filter from children up first
+
+    for (var i = 0; i < rowsToFilter.length; i++) {
+      var _row$subRows;
+
+      var row = rowsToFilter[i];
+
+      if (!((_row$subRows = row.subRows) != null && _row$subRows.length)) {
+        continue;
+      }
 
       rowsToFilter[i] = instance.createRow(row.id, row.original, row.index, row.depth, row.values);
       rowsToFilter[i].subRows = recurseFilterRows(row.subRows, depth + 1);
@@ -4334,259 +4530,380 @@ function filterRowModelFromRoot(rowsToFilter, filterRows, instance) {
   };
 }
 
-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
+function getColumnFilteredRowModelSync() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().columnFilters, instance.getCoreRowModel()];
+    }, function (columnFilters, rowModel) {
+      var columnFilteredRowModel = function () {
+        if (!rowModel.rows.length || !columnFilters) {
+          return rowModel;
+        }
 
-      var column = instance.getColumn(columnId);
+        var filterFromLeafRows = instance.options.filterFromLeafRows;
 
-      if (!column) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn("Table: Could not find a column with id: " + columnId);
-        }
+        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
 
-        throw new Error();
-      }
+            var column = instance.getColumn(columnId);
 
-      if (depth === 0) {
-        (function () {
-          var preFilteredRows = [].concat(rowsToFilter);
+            if (!column) {
+              if (process.env.NODE_ENV !== 'production') {
+                console.warn("Table: Could not find a column with id: " + columnId);
+              }
 
-          column.getPreFilteredRows = function () {
-            return preFilteredRows;
-          };
-        })();
-      }
+              throw new Error();
+            }
 
-      var filterFn = instance.getColumnFilterFn(column.id);
+            if (depth === 0) {
+              (function () {
+                var preFilteredRows = [].concat(rowsToFilter);
 
-      if (!filterFn) {
-        if (process.env.NODE_ENV !== 'production') {
-          console.warn("Could not find a valid 'column.filterType' for column with the ID: " + column.id + ".");
-        }
+                column.getPreFilteredRows = function () {
+                  return preFilteredRows;
+                };
+              })();
+            }
 
-        continue;
-      } // Pass the rows, id, filterValue and column to the filterFn
-      // to get the filtered rows back
+            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 = filterFn(rowsToFilter, [columnId], filterValue);
-    }
+              continue;
+            } // Pass the rows, id, filterValue and column to the filterFn
+            // to get the filtered rows back
 
-    return rowsToFilter;
-  };
 
-  if (filterFromLeafRows) {
-    return filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
-  }
+            rowsToFilter = filterFn(rowsToFilter, [columnId], filterValue);
+          }
 
-  return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
-}
+          return rowsToFilter;
+        };
 
-function globalFilterRowsFn(instance, rowModel) {
-  var globalFilter = instance.getState().globalFilter;
-  var filterFromLeafRows = instance.options.filterFromLeafRows;
-  var filterFn = instance.getGlobalFilterFn();
+        if (filterFromLeafRows) {
+          return filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
+        }
 
-  if (!filterFn) {
-    if (process.env.NODE_ENV !== 'production') {
-      console.warn("Could not find a valid 'globalFilterType'");
-    }
+        return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
+      }(); // Now that each filtered column has it's partially filtered rows,
+      // lets assign the final filtered rows to all of the other columns
 
-    return rowModel;
-  }
 
-  var filterableColumns = instance.getAllLeafColumns().filter(function (column) {
-    return column.getCanGlobalFilter();
-  });
-  var filterableColumnIds = filterableColumns.map(function (d) {
-    return d.id;
-  });
+      var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
+        var _instance$getState$co;
 
-  var filterRows = function filterRows(rows) {
-    return filterFn(rows, filterableColumnIds, globalFilter);
-  };
+        return !((_instance$getState$co = instance.getState().columnFilters) != null && _instance$getState$co.find(function (d) {
+          return d.id === column.id;
+        }));
+      }); // This essentially enables faceted filter options to be built easily
+      // using every column's preFilteredRows value
 
-  if (filterFromLeafRows) {
-    filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
-  }
+      nonFilteredColumns.forEach(function (column) {
+        column.getPreFilteredRows = function () {
+          return columnFilteredRowModel.rows;
+        };
+      });
+      return columnFilteredRowModel;
+    }, {
+      key: 'getColumnFilteredRowModelSync',
+      debug: function debug() {
+        var _instance$options$deb;
 
-  return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        instance._notifySortingReset();
+      }
+    });
+  };
 }
 
-function sortRowsFn(instance, rowModel) {
-  var sortingState = instance.getState().sorting;
-  var sortedFlatRows = []; // Filter out sortings that correspond to non existing columns
+function getGlobalFilteredRowModelSync() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().globalFilter, instance.getCoreRowModel()];
+    }, function (globalFilter, rowModel) {
+      var globalFilteredRowModel = function () {
+        if (!rowModel.rows.length || !globalFilter) {
+          return rowModel;
+        }
 
-  var availableSorting = sortingState.filter(function (sort) {
-    return instance.getColumnCanSort(sort.id);
-  });
-  var columnInfoById = {};
-  availableSorting.forEach(function (sortEntry) {
-    var column = instance.getColumn(sortEntry.id);
-    columnInfoById[sortEntry.id] = {
-      sortUndefined: column.sortUndefined,
-      invertSorting: column.invertSorting,
-      sortingFn: instance.getColumnSortingFn(sortEntry.id)
-    };
-  });
+        var filterFromLeafRows = instance.options.filterFromLeafRows;
+        var filterFn = instance.getGlobalFilterFn();
 
-  var sortData = function sortData(rows) {
-    // This will also perform a stable sorting using the row index
-    // if needed.
-    var sortedData = rows.slice();
-    sortedData.sort(function (rowA, rowB) {
-      for (var i = 0; i < availableSorting.length; i += 1) {
-        var _sortEntry$desc;
-
-        var sortEntry = availableSorting[i];
-        var columnInfo = columnInfoById[sortEntry.id];
-        var isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
-
-        if (columnInfo.sortUndefined) {
-          var aValue = rowA.values[sortEntry.id];
-          var bValue = rowB.values[sortEntry.id];
-          var aUndefined = typeof aValue === 'undefined';
-          var bUndefined = typeof bValue === 'undefined';
-
-          if (aUndefined || bUndefined) {
-            return aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
+        if (!filterFn) {
+          if (process.env.NODE_ENV !== 'production') {
+            console.warn("Could not find a valid 'globalFilterType'");
           }
-        } // This function should always return in ascending order
 
+          return rowModel;
+        }
 
-        var sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
-
-        if (sortInt !== 0) {
-          if (isDesc) {
-            sortInt *= -1;
-          }
+        var filterableColumns = instance.getAllLeafColumns().filter(function (column) {
+          return column.getCanGlobalFilter();
+        });
+        var filterableColumnIds = filterableColumns.map(function (d) {
+          return d.id;
+        });
 
-          if (columnInfo.invertSorting) {
-            sortInt *= -1;
-          }
+        var filterRows = function filterRows(rows) {
+          return filterFn(rows, filterableColumnIds, globalFilter);
+        };
 
-          return sortInt;
+        if (filterFromLeafRows) {
+          filterRowModelFromLeafs(rowModel.rows, filterRows, instance);
         }
-      }
 
-      return rowA.index - rowB.index;
-    }); // If there are sub-rows, sort them
+        return filterRowModelFromRoot(rowModel.rows, filterRows, instance);
+      }(); // Now that each filtered column has it's partially filtered rows,
+      // lets assign the final filtered rows to all of the other columns
 
-    sortedData.forEach(function (row) {
-      sortedFlatRows.push(row);
 
-      if (!row.subRows || row.subRows.length <= 1) {
-        return;
-      }
+      var nonFilteredColumns = instance.getAllLeafColumns().filter(function (column) {
+        var _instance$getState$co;
 
-      row.subRows = sortData(row.subRows);
-    });
-    return sortedData;
-  };
+        return !((_instance$getState$co = instance.getState().columnFilters) != null && _instance$getState$co.find(function (d) {
+          return d.id === column.id;
+        }));
+      }); // This essentially enables faceted filter options to be built easily
+      // using every column's preFilteredRows value
 
-  return {
-    rows: sortData(rowModel.rows),
-    flatRows: sortedFlatRows,
-    rowsById: rowModel.rowsById
+      nonFilteredColumns.forEach(function (column) {
+        column.getPreFilteredRows = function () {
+          return globalFilteredRowModel.rows;
+        };
+      });
+      return globalFilteredRowModel;
+    }, {
+      key: 'getGlobalFilteredRowModelSync',
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        instance._notifySortingReset();
+      }
+    });
   };
 }
 
-function groupRowsFn(instance, sortedRowModel) {
-  var groupingState = instance.getState().grouping; // Filter the grouping list down to columns that exist
+function getSortedRowModelSync() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().sorting, instance.getGlobalFilteredRowModel()];
+    }, function (sorting, rowModel) {
+      if (!rowModel.rows.length || !(sorting != null && sorting.length)) {
+        return rowModel;
+      }
 
-  var existingGrouping = groupingState.filter(function (columnId) {
-    return instance.getColumn(columnId);
-  }); // Find the columns that can or are aggregating
-  // Uses each column to aggregate rows into a single value
+      var sortingState = instance.getState().sorting;
+      var sortedFlatRows = []; // Filter out sortings that correspond to non existing columns
 
-  var aggregateRowsToValues = function aggregateRowsToValues(leafRows, groupedRows, depth) {
-    var values = {};
-    instance.getAllLeafColumns().forEach(function (column) {
-      // Don't aggregate columns that are in the grouping
-      if (existingGrouping.includes(column.id)) {
-        values[column.id] = groupedRows[0] ? groupedRows[0].values[column.id] : null;
-        return;
-      } // Aggregate the values
+      var availableSorting = sortingState.filter(function (sort) {
+        return instance.getColumnCanSort(sort.id);
+      });
+      var columnInfoById = {};
+      availableSorting.forEach(function (sortEntry) {
+        var column = instance.getColumn(sortEntry.id);
+        columnInfoById[sortEntry.id] = {
+          sortUndefined: column.sortUndefined,
+          invertSorting: column.invertSorting,
+          sortingFn: instance.getColumnSortingFn(sortEntry.id)
+        };
+      });
 
+      var sortData = function sortData(rows) {
+        // This will also perform a stable sorting using the row index
+        // if needed.
+        var sortedData = rows.slice();
+        sortedData.sort(function (rowA, rowB) {
+          for (var i = 0; i < availableSorting.length; i += 1) {
+            var _sortEntry$desc;
+
+            var sortEntry = availableSorting[i];
+            var columnInfo = columnInfoById[sortEntry.id];
+            var isDesc = (_sortEntry$desc = sortEntry == null ? void 0 : sortEntry.desc) != null ? _sortEntry$desc : false;
+
+            if (columnInfo.sortUndefined) {
+              var aValue = rowA.values[sortEntry.id];
+              var bValue = rowB.values[sortEntry.id];
+              var aUndefined = typeof aValue === 'undefined';
+              var bUndefined = typeof bValue === 'undefined';
+
+              if (aUndefined || bUndefined) {
+                return aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined;
+              }
+            } // This function should always return in ascending order
 
-      var aggregateFn = instance.getColumnAggregationFn(column.id);
 
-      if (aggregateFn) {
-        values[column.id] = aggregateFn(function () {
-          return leafRows.map(function (row) {
-            var columnValue = row.values[column.id];
+            var sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id);
+
+            if (sortInt !== 0) {
+              if (isDesc) {
+                sortInt *= -1;
+              }
 
-            if (!depth && column.aggregateValue) {
-              columnValue = column.aggregateValue(columnValue);
+              if (columnInfo.invertSorting) {
+                sortInt *= -1;
+              }
+
+              return sortInt;
             }
+          }
 
-            return columnValue;
-          });
-        }, function () {
-          return groupedRows.map(function (row) {
-            return row.values[column.id];
-          });
-        });
-      } else if (column.aggregationType) {
-        console.info({
-          column: column
+          return rowA.index - rowB.index;
+        }); // If there are sub-rows, sort them
+
+        sortedData.forEach(function (row) {
+          sortedFlatRows.push(row);
+
+          if (!row.subRows || row.subRows.length <= 1) {
+            return;
+          }
+
+          row.subRows = sortData(row.subRows);
         });
-        throw new Error(process.env.NODE_ENV !== 'production' ? "Table: Invalid column.aggregateType option for column listed above" : '');
-      } else {
-        values[column.id] = null;
+        return sortedData;
+      };
+
+      return {
+        rows: sortData(rowModel.rows),
+        flatRows: sortedFlatRows,
+        rowsById: rowModel.rowsById
+      };
+    }, {
+      key: 'getSortedRowModel',
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        instance._notifyGroupingReset();
       }
     });
-    return values;
   };
+}
 
-  var groupedFlatRows = [];
-  var groupedRowsById = {}; // const onlyGroupedFlatRows: Row[] = [];
-  // const onlyGroupedRowsById: Record<RowId, Row> = {};
-  // const nonGroupedFlatRows: Row[] = [];
-  // const nonGroupedRowsById: Record<RowId, Row> = {};
-  // Recursively group the data
+function getGroupedRowModelSync() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().grouping, instance.getSortedRowModel()];
+    }, function (grouping, rowModel) {
+      if (!rowModel.rows.length || !grouping.length) {
+        return rowModel;
+      } // Filter the grouping list down to columns that exist
 
-  var groupUpRecursively = function groupUpRecursively(rows, depth, parentId) {
-    if (depth === void 0) {
-      depth = 0;
-    }
 
-    // This is the last level, just return the rows
-    if (depth === existingGrouping.length) {
-      return rows;
-    }
+      var existingGrouping = grouping.filter(function (columnId) {
+        return instance.getColumn(columnId);
+      }); // Find the columns that can or are aggregating
+      // Uses each column to aggregate rows into a single value
+
+      var aggregateRowsToValues = function aggregateRowsToValues(leafRows, groupedRows, depth) {
+        var values = {};
+        instance.getAllLeafColumns().forEach(function (column) {
+          // Don't aggregate columns that are in the grouping
+          if (existingGrouping.includes(column.id)) {
+            values[column.id] = groupedRows[0] ? groupedRows[0].values[column.id] : null;
+            return;
+          } // Aggregate the values
 
-    var columnId = existingGrouping[depth]; // Group the rows together for this level
 
-    var rowGroupsMap = groupBy(rows, columnId); // Peform aggregations for each group
+          var aggregateFn = instance.getColumnAggregationFn(column.id);
 
-    var aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(function (_ref, index) {
-      var groupingValue = _ref[0],
-          groupedRows = _ref[1];
-      var id = columnId + ":" + groupingValue;
-      id = parentId ? parentId + ">" + id : id; // First, Recurse to group sub rows before aggregation
+          if (aggregateFn) {
+            values[column.id] = aggregateFn(function () {
+              return leafRows.map(function (row) {
+                var columnValue = row.values[column.id];
 
-      var subRows = groupUpRecursively(groupedRows, depth + 1, id); // Flatten the leaf rows of the rows in this group
+                if (!depth && column.aggregateValue) {
+                  columnValue = column.aggregateValue(columnValue);
+                }
 
-      var leafRows = depth ? flattenBy(groupedRows, function (row) {
-        return row.subRows;
-      }) : groupedRows;
-      var values = aggregateRowsToValues(leafRows, groupedRows, depth);
-      var row = instance.createRow(id, undefined, index, depth, values);
-      Object.assign(row, {
-        groupingColumnId: columnId,
-        groupingValue: groupingValue,
-        subRows: subRows,
-        leafRows: leafRows
-      });
-      subRows.forEach(function (subRow) {
+                return columnValue;
+              });
+            }, function () {
+              return groupedRows.map(function (row) {
+                return row.values[column.id];
+              });
+            });
+          } else if (column.aggregationType) {
+            console.info({
+              column: column
+            });
+            throw new Error(process.env.NODE_ENV !== 'production' ? "Table: Invalid column.aggregateType option for column listed above" : '');
+          } else {
+            values[column.id] = null;
+          }
+        });
+        return values;
+      };
+
+      var groupedFlatRows = [];
+      var groupedRowsById = {}; // const onlyGroupedFlatRows: Row[] = [];
+      // const onlyGroupedRowsById: Record<RowId, Row> = {};
+      // const nonGroupedFlatRows: Row[] = [];
+      // const nonGroupedRowsById: Record<RowId, Row> = {};
+      // Recursively group the data
+
+      var groupUpRecursively = function groupUpRecursively(rows, depth, parentId) {
+        if (depth === void 0) {
+          depth = 0;
+        }
+
+        // This is the last level, just return the rows
+        if (depth === existingGrouping.length) {
+          return rows;
+        }
+
+        var columnId = existingGrouping[depth]; // Group the rows together for this level
+
+        var rowGroupsMap = groupBy(rows, columnId); // Peform aggregations for each group
+
+        var aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(function (_ref, index) {
+          var groupingValue = _ref[0],
+              groupedRows = _ref[1];
+          var id = columnId + ":" + groupingValue;
+          id = parentId ? parentId + ">" + id : id; // First, Recurse to group sub rows before aggregation
+
+          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.subRows;
+          }) : groupedRows;
+          var values = aggregateRowsToValues(leafRows, groupedRows, depth);
+          var row = instance.createRow(id, undefined, index, depth, values);
+          Object.assign(row, {
+            groupingColumnId: columnId,
+            groupingValue: groupingValue,
+            subRows: subRows,
+            leafRows: leafRows
+          });
+          subRows.forEach(function (subRow) {
+            groupedFlatRows.push(subRow);
+            groupedRowsById[subRow.id] = subRow; // if (subRow.getIsGrouped?.()) {
+            //   onlyGroupedFlatRows.push(subRow);
+            //   onlyGroupedRowsById[subRow.id] = subRow;
+            // } else {
+            //   nonGroupedFlatRows.push(subRow);
+            //   nonGroupedRowsById[subRow.id] = subRow;
+            // }
+          });
+          return row;
+        });
+        return aggregatedGroupedRows;
+      };
+
+      var groupedRows = groupUpRecursively(rowModel.rows, 0, '');
+      groupedRows.forEach(function (subRow) {
         groupedFlatRows.push(subRow);
         groupedRowsById[subRow.id] = subRow; // if (subRow.getIsGrouped?.()) {
         //   onlyGroupedFlatRows.push(subRow);
@@ -4596,26 +4913,22 @@ function groupRowsFn(instance, sortedRowModel) {
         //   nonGroupedRowsById[subRow.id] = subRow;
         // }
       });
-      return row;
-    });
-    return aggregatedGroupedRows;
-  };
+      return {
+        rows: groupedRows,
+        flatRows: groupedFlatRows,
+        rowsById: groupedRowsById
+      };
+    }, {
+      key: 'getGroupedRowModel',
+      debug: function debug() {
+        var _instance$options$deb;
 
-  var groupedRows = groupUpRecursively(sortedRowModel.rows, 0, '');
-  groupedRows.forEach(function (subRow) {
-    groupedFlatRows.push(subRow);
-    groupedRowsById[subRow.id] = subRow; // if (subRow.getIsGrouped?.()) {
-    //   onlyGroupedFlatRows.push(subRow);
-    //   onlyGroupedRowsById[subRow.id] = subRow;
-    // } else {
-    //   nonGroupedFlatRows.push(subRow);
-    //   nonGroupedRowsById[subRow.id] = subRow;
-    // }
-  });
-  return {
-    rows: groupedRows,
-    flatRows: groupedFlatRows,
-    rowsById: groupedRowsById
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      },
+      onChange: function onChange() {
+        return instance._notifyExpandedReset();
+      }
+    });
   };
 }
 
@@ -4635,7 +4948,28 @@ function groupBy(rows, columnId) {
   }, groupMap);
 }
 
-function expandRowsFn(instance, sortedRowModel) {
+function getExpandedRowModel() {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().expanded, instance.getGroupedRowModel(), instance.options.paginateExpandedRows];
+    }, function (expanded, rowModel, paginateExpandedRows) {
+      if (!rowModel.rows.length || // Do not expand if rows are not included in pagination
+      !paginateExpandedRows || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) {
+        return rowModel;
+      }
+
+      return expandRows(rowModel, instance);
+    }, {
+      key: 'getExpandedRowModel',
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      }
+    });
+  };
+}
+function expandRows(rowModel, instance) {
   var expandedRows = [];
 
   var handleRow = function handleRow(row) {
@@ -4648,39 +4982,55 @@ function expandRowsFn(instance, sortedRowModel) {
     }
   };
 
-  sortedRowModel.rows.forEach(handleRow);
+  rowModel.rows.forEach(handleRow);
   return {
     rows: expandedRows,
-    flatRows: sortedRowModel.flatRows,
-    rowsById: sortedRowModel.rowsById
+    flatRows: rowModel.flatRows,
+    rowsById: rowModel.rowsById
   };
 }
 
-function paginateRowsFn(instance, rowModel) {
-  var _instance$getState$pa = instance.getState().pagination,
-      pageSize = _instance$getState$pa.pageSize,
-      pageIndex = _instance$getState$pa.pageIndex;
-  var rows = rowModel.rows,
-      flatRows = rowModel.flatRows,
-      rowsById = rowModel.rowsById;
-  var pageStart = pageSize * pageIndex;
-  var pageEnd = pageStart + pageSize;
-  rows = rows.slice(pageStart, pageEnd);
-
-  if (!instance.options.paginateExpandedRows) {
-    return expandRowsFn(instance, {
-      rows: rows,
-      flatRows: flatRows,
-      rowsById: rowsById
-    });
-  }
+function getPaginationRowModel(opts) {
+  return function (instance) {
+    return memo(function () {
+      return [instance.getState().pagination, instance.getExpandedRowModel()];
+    }, function (pagination, rowModel) {
+      if (!rowModel.rows.length) {
+        return rowModel;
+      }
 
-  return {
-    rows: rows,
-    flatRows: flatRows,
-    rowsById: rowsById
+      var pageSize = pagination.pageSize,
+          pageIndex = pagination.pageIndex;
+      var rows = rowModel.rows,
+          flatRows = rowModel.flatRows,
+          rowsById = rowModel.rowsById;
+      var pageStart = pageSize * pageIndex;
+      var pageEnd = pageStart + pageSize;
+      rows = rows.slice(pageStart, pageEnd);
+
+      if (!instance.options.paginateExpandedRows) {
+        return expandRows({
+          rows: rows,
+          flatRows: flatRows,
+          rowsById: rowsById
+        }, instance);
+      }
+
+      return {
+        rows: rows,
+        flatRows: flatRows,
+        rowsById: rowsById
+      };
+    }, {
+      key: 'getPaginationRowModel',
+      debug: function debug() {
+        var _instance$options$deb;
+
+        return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
+      }
+    });
   };
 }
 
-export { ColumnSizing, Expanding, Filters, Grouping, Headers, Ordering, Pagination, Pinning, RowSelection, Sorting, Visibility, buildHeaderGroups, columnFilterRowsFn, createTableInstance, defaultColumnSizing, expandRowsFn, flattenBy, functionalUpdate, globalFilterRowsFn, groupRowsFn, init, isFunction, isRowSelected, makeStateUpdater, memo, noop, paginateRowsFn, passiveEventSupported, propGetter, selectRowsFn, shouldAutoRemoveFilter, sortRowsFn };
+export { ColumnSizing, Expanding, Filters, Grouping, Headers, Ordering, Pagination, Pinning, RowSelection, Sorting, Visibility, buildHeaderGroups, createTableInstance, defaultColumnSizing, expandRows, flattenBy, functionalUpdate, getBatchGroups, getColumnFilteredRowModelSync, getCoreRowModelAsync, getCoreRowModelSync, getExpandedRowModel, getGlobalFilteredRowModelSync, getGroupedRowModelSync, getPaginationRowModel, getSortedRowModelSync, incrementalMemo, init, isFunction, isRowSelected, makeStateUpdater, memo, noop, passiveEventSupported, propGetter, selectRowsFn, shouldAutoRemoveFilter };
 //# sourceMappingURL=index.js.map