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

package/build/umd/index.development.js

@@ -109,6 +109,32 @@
   }
   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) {
@@ -206,22 +232,133 @@
 
       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 = {
@@ -552,6 +689,8 @@
       var registered = false;
       return {
         _notifyExpandedReset: function _notifyExpandedReset() {
+          instance._notifyPageIndexReset();
+
           if (!registered) {
             registered = true;
             return;
@@ -703,25 +842,19 @@
           });
           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();
         }
       };
     },
@@ -909,7 +1042,9 @@
     getInitialState: function getInitialState() {
       return {
         columnFilters: [],
-        globalFilter: undefined
+        globalFilter: undefined,
+        columnFiltersProgress: 1,
+        globalFilterProgress: 1
       };
     },
     getDefaultOptions: function getDefaultOptions(instance) {
@@ -1008,6 +1143,8 @@
       var registered = false;
       return {
         _notifyFiltersReset: function _notifyFiltersReset() {
+          instance._notifySortingReset();
+
           if (!registered) {
             registered = true;
             return;
@@ -1017,16 +1154,12 @@
             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) {
@@ -1206,84 +1339,31 @@
         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();
+        }
       };
     }
   };
@@ -1448,6 +1528,8 @@
       var registered = false;
       return {
         _notifyGroupingReset: function _notifyGroupingReset() {
+          instance._notifyExpandedReset();
+
           if (!registered) {
             registered = true;
             return;
@@ -1547,25 +1629,17 @@
         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) {
@@ -1834,22 +1908,17 @@
         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;
 
@@ -2167,7 +2236,9 @@
             return (_instance$options$deb = instance.options.debugAll) != null ? _instance$options$deb : instance.options.debugTable;
           },
           onChange: function onChange() {
-            return instance._notifyExpandedReset();
+            instance.queue(function () {
+              return instance._notifyExpandedReset();
+            });
           }
         }),
         getFilteredSelectedRowModel: memo(function () {
@@ -2190,7 +2261,9 @@
             return (_instance$options$deb2 = instance.options.debugAll) != null ? _instance$options$deb2 : instance.options.debugTable;
           },
           onChange: function onChange() {
-            return instance._notifyExpandedReset();
+            return instance.queue(function () {
+              return instance._notifyExpandedReset();
+            });
           }
         }),
         getGroupedSelectedRowModel: memo(function () {
@@ -2213,7 +2286,9 @@
             return (_instance$options$deb3 = instance.options.debugAll) != null ? _instance$options$deb3 : instance.options.debugTable;
           },
           onChange: function onChange() {
-            return instance._notifyExpandedReset();
+            return instance.queue(function () {
+              return instance._notifyExpandedReset();
+            });
           }
         }),
         ///
@@ -2659,6 +2734,8 @@
       var registered = false;
       return {
         _notifySortingReset: function _notifySortingReset() {
+          instance._notifyGroupingReset();
+
           if (!registered) {
             registered = true;
             return;
@@ -2889,25 +2966,17 @@
         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();
+        }
       };
     }
   };
@@ -3693,14 +3762,38 @@
     };
 
     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 : {});
 
+    var queued = [];
+    var queuedTimeout;
+
     var finalInstance = _extends({}, instance, features.reduce(function (obj, feature) {
       return Object.assign(obj, feature.getInstance == null ? void 0 : feature.getInstance(instance));
     }, {}), {
+      queue: function queue(cb) {
+        queued.push(cb);
+
+        if (!queuedTimeout) {
+          queuedTimeout = setTimeout(function () {
+            instance.setState(function (old) {
+              return _extends({}, old);
+            });
+          });
+        }
+      },
+      willUpdate: function willUpdate() {
+        clearTimeout(queuedTimeout);
+
+        while (queued.length) {
+          queued.shift()();
+        }
+      },
       initialState: initialState,
       reset: function reset() {
         instance.setState(instance.initialState);
@@ -4006,85 +4099,13 @@
 
         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) {
-            {
-              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() {
@@ -4181,6 +4202,18 @@
         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;
+          });
+        });
       }
     });
 
@@ -4249,18 +4282,212 @@
     };
   }
 
-  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++) {
+          if (!id) {
+            {
+              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);
+        }
+
+        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.queue(function () {
+            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) {
+                      {
+                        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.queue(function () {
+            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];
@@ -4332,259 +4559,386 @@
     };
   }
 
-  function columnFilterRowsFn(instance, rowModel) {
-    var columnFilters = instance.getState().columnFilters;
-    var filterFromLeafRows = instance.options.filterFromLeafRows;
+  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 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 filterFromLeafRows = instance.options.filterFromLeafRows;
 
-        var column = instance.getColumn(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
 
-        if (!column) {
-          {
-            console.warn("Table: Could not find a column with id: " + columnId);
-          }
-
-          throw new Error();
-        }
+              var column = instance.getColumn(columnId);
 
-        if (depth === 0) {
-          (function () {
-            var preFilteredRows = [].concat(rowsToFilter);
+              if (!column) {
+                {
+                  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) {
-          {
-            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) {
+                {
+                  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) {
-      {
-        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.queue(function () {
+            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) {
+            {
+              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) {
+            return 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.queue(function () {
+            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];
-            });
+            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);
           });
-        } else if (column.aggregationType) {
-          console.info({
-            column: column
+          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.queue(function () {
+            instance._notifyGroupingReset();
           });
-          throw new Error("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
+  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("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);
@@ -4594,26 +4948,24 @@
           //   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() {
+          instance.queue(function () {
+            instance._notifyExpandedReset();
+          });
+        }
+      });
     };
   }
 
@@ -4633,7 +4985,28 @@
     }, 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) {
@@ -4646,37 +5019,53 @@
       }
     };
 
-    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;
+        }
+      });
     };
   }
 
@@ -4692,26 +5081,31 @@
   exports.Sorting = Sorting;
   exports.Visibility = Visibility;
   exports.buildHeaderGroups = buildHeaderGroups;
-  exports.columnFilterRowsFn = columnFilterRowsFn;
   exports.createTableInstance = createTableInstance;
   exports.defaultColumnSizing = defaultColumnSizing;
-  exports.expandRowsFn = expandRowsFn;
+  exports.expandRows = expandRows;
   exports.flattenBy = flattenBy;
   exports.functionalUpdate = functionalUpdate;
-  exports.globalFilterRowsFn = globalFilterRowsFn;
-  exports.groupRowsFn = groupRowsFn;
+  exports.getBatchGroups = getBatchGroups;
+  exports.getColumnFilteredRowModelSync = getColumnFilteredRowModelSync;
+  exports.getCoreRowModelAsync = getCoreRowModelAsync;
+  exports.getCoreRowModelSync = getCoreRowModelSync;
+  exports.getExpandedRowModel = getExpandedRowModel;
+  exports.getGlobalFilteredRowModelSync = getGlobalFilteredRowModelSync;
+  exports.getGroupedRowModelSync = getGroupedRowModelSync;
+  exports.getPaginationRowModel = getPaginationRowModel;
+  exports.getSortedRowModelSync = getSortedRowModelSync;
+  exports.incrementalMemo = incrementalMemo;
   exports.init = init;
   exports.isFunction = isFunction;
   exports.isRowSelected = isRowSelected;
   exports.makeStateUpdater = makeStateUpdater;
   exports.memo = memo;
   exports.noop = noop;
-  exports.paginateRowsFn = paginateRowsFn;
   exports.passiveEventSupported = passiveEventSupported;
   exports.propGetter = propGetter;
   exports.selectRowsFn = selectRowsFn;
   exports.shouldAutoRemoveFilter = shouldAutoRemoveFilter;
-  exports.sortRowsFn = sortRowsFn;
 
   Object.defineProperty(exports, '__esModule', { value: true });