@infinite-table/infinite-react 0.1.2 → 0.2.1

package/index.js

@@ -198,11 +198,11 @@ var require_common = __commonJS({
         let enableOverride = null;
         let namespacesCache;
         let enabledCache;
-        function debug7(...args) {
-          if (!debug7.enabled) {
+        function debug6(...args) {
+          if (!debug6.enabled) {
             return;
           }
-          const self = debug7;
+          const self = debug6;
           const curr = Number(new Date());
           const ms = curr - (prevTime || curr);
           self.diff = ms;
@@ -232,12 +232,12 @@ var require_common = __commonJS({
           const logFn = self.log || createDebug.log;
           logFn.apply(self, args);
         }
-        debug7.namespace = namespace;
-        debug7.useColors = createDebug.useColors();
-        debug7.color = createDebug.selectColor(namespace);
-        debug7.extend = extend;
-        debug7.destroy = createDebug.destroy;
-        Object.defineProperty(debug7, "enabled", {
+        debug6.namespace = namespace;
+        debug6.useColors = createDebug.useColors();
+        debug6.color = createDebug.selectColor(namespace);
+        debug6.extend = extend;
+        debug6.destroy = createDebug.destroy;
+        Object.defineProperty(debug6, "enabled", {
           enumerable: true,
           configurable: false,
           get: () => {
@@ -255,9 +255,9 @@ var require_common = __commonJS({
           }
         });
         if (typeof createDebug.init === "function") {
-          createDebug.init(debug7);
+          createDebug.init(debug6);
         }
-        return debug7;
+        return debug6;
       }
       function extend(namespace, delimiter) {
         const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
@@ -721,14 +721,21 @@ var ScrollListener = class {
 };
 
 // src/components/InfiniteTable/utils/toMap.ts
-function toMap(mapOrObject) {
+function toMap(mapOrObject, weakMapCache) {
   if (!mapOrObject) {
     return new Map();
   }
   if (mapOrObject instanceof Map) {
     return mapOrObject;
   }
-  return new Map(Object.entries(mapOrObject));
+  if (weakMapCache && weakMapCache.has(mapOrObject)) {
+    return weakMapCache.get(mapOrObject);
+  }
+  const result = new Map(Object.entries(mapOrObject));
+  if (weakMapCache) {
+    weakMapCache.set(mapOrObject, result);
+  }
+  return result;
 }
 
 // src/components/InfiniteTable/state/computeColumnGroupsDepths.ts
@@ -754,12 +761,10 @@ function computeColumnGroupsDepths(columnGroups) {
 }
 
 // src/components/InfiniteTable/state/getInitialState.ts
-function toColumnTypesMap(mapOrObject) {
-  return toMap(mapOrObject);
-}
 function initSetupState() {
   const columnsGeneratedForGrouping = new Map();
   return {
+    propsCache: new Map([]),
     columnShifts: null,
     domRef: (0, import_react2.createRef)(),
     scrollerDOMRef: (0, import_react2.createRef)(),
@@ -784,12 +789,8 @@ function initSetupState() {
     columnsWhenInlineGroupRenderStrategy: void 0
   };
 }
-var forwardProps = () => {
+var forwardProps = (setupState) => {
   return {
-    columns: (columns) => {
-      var _a;
-      return (_a = toMap(columns)) != null ? _a : new Map();
-    },
     scrollTopId: 1,
     components: 1,
     loadingText: 1,
@@ -807,6 +808,7 @@ var forwardProps = () => {
     onBlurWithin: 1,
     onScrollToTop: 1,
     onScrollToBottom: 1,
+    onScrollStop: 1,
     scrollToBottomOffset: 1,
     rowStyle: 1,
     rowProps: 1,
@@ -817,6 +819,7 @@ var forwardProps = () => {
     pivotRowLabelsColumn: 1,
     pivotColumnGroups: 1,
     onScrollbarsChange: 1,
+    scrollStopDelay: (scrollStopDelay) => scrollStopDelay != null ? scrollStopDelay : 100,
     viewportReservedWidth: (viewportReservedWidth) => viewportReservedWidth != null ? viewportReservedWidth : 0,
     activeIndex: (activeIndex) => activeIndex != null ? activeIndex : 0,
     columnMinWidth: (columnMinWidth) => columnMinWidth != null ? columnMinWidth : 30,
@@ -835,21 +838,13 @@ var forwardProps = () => {
     virtualizeColumns: (virtualizeColumns) => virtualizeColumns != null ? virtualizeColumns : true,
     rowHeight: (rowHeight) => typeof rowHeight === "number" ? rowHeight : 0,
     headerHeight: (headerHeight) => typeof headerHeight === "number" ? headerHeight : 0,
-    columnVisibility: (columnVisibility) => {
-      var _a;
-      return (_a = toMap(columnVisibility)) != null ? _a : new Map();
-    },
-    columnPinning: (columnPinning) => columnPinning != null ? columnPinning : new Map(),
-    columnSizing: (columnSizing) => {
-      var _a;
-      return (_a = toMap(columnSizing)) != null ? _a : new Map();
-    },
-    columnTypes: (columnTypes) => {
-      var _a;
-      return (_a = toColumnTypesMap(columnTypes)) != null ? _a : new Map();
-    },
+    columns: (columns) => toMap(columns, setupState.propsCache.get("columns")),
+    columnVisibility: (columnVisibility) => columnVisibility != null ? columnVisibility : {},
+    columnPinning: (columnPinning) => toMap(columnPinning, setupState.propsCache.get("columnPinning")),
+    columnSizing: (columnSizing) => toMap(columnSizing, setupState.propsCache.get("columnSizing")),
+    columnTypes: (columnTypes) => toMap(columnTypes, setupState.propsCache.get("columnTypes")),
     collapsedColumnGroups: (collapsedColumnGroups) => collapsedColumnGroups != null ? collapsedColumnGroups : new Map(),
-    columnGroups: (columnGroups) => columnGroups != null ? columnGroups : new Map()
+    columnGroups: (columnGroups) => toMap(columnGroups, setupState.propsCache.get("columnGroups"))
   };
 };
 function getGroupRenderStrategy(options) {
@@ -1224,11 +1219,11 @@ function getColumnComputedType(column, columnTypes) {
 // src/components/InfiniteTable/utils/getComputedVisibleColumns.ts
 var logError = err("getComputedVisibleColumns");
 var isColumnVisible = (columnVisibility, _columnVisibilityAssumeVisible, colId) => {
-  return !columnVisibility.has(colId) || columnVisibility.get(colId) !== false;
+  return columnVisibility[colId] !== false;
 };
 var getComputedPinned = (colId, columnPinning) => {
   const pinned = columnPinning.get(colId);
-  const computedPinned = pinned === "start" || pinned === true ? "start" : pinned === "end" ? "end" : false;
+  const computedPinned = pinned === "start" ? "start" : pinned === "end" ? "end" : false;
   return computedPinned;
 };
 var getComputedVisibleColumns = ({
@@ -1260,7 +1255,8 @@ var getComputedVisibleColumns = ({
       logError(`Column with id "${colId}" specified in columnOrder array cannot be found in the columns map.`);
       return false;
     }
-    return isColumnVisible(columnVisibility, columnVisibilityAssumeVisible, colId);
+    const result2 = isColumnVisible(columnVisibility, columnVisibilityAssumeVisible, colId);
+    return result2;
   });
   const columnsArray = visibleColumnOrder.map((columnId) => columns.get(columnId)).filter(Boolean);
   const sortedMap = (sortInfo != null ? sortInfo : []).reduce((acc, info, index) => {
@@ -1289,7 +1285,10 @@ var getComputedVisibleColumns = ({
         width: colType == null ? void 0 : colType.defaultWidth,
         flex: colType == null ? void 0 : colType.defaultFlex
       };
-      let colSizing = columnSizing.get(colId) || {};
+      let colSizing = columnSizing.get(colId) || {
+        width: column == null ? void 0 : column.defaultWidth,
+        flex: column == null ? void 0 : column.defaultFlex
+      };
       if (colSizing.width != null) {
         delete colTypeSizing.flex;
       }
@@ -1576,7 +1575,6 @@ var useComputedVisibleColumns = ({
   const columnsSizingRenderId = useRerenderOnKeyChange(columnSizing);
   const columnTypesRenderId = useRerenderOnKeyChange(columnTypes);
   const columnsRenderId = useRerenderOnKeyChange(columns);
-  const visibilityRenderId = useRerenderOnKeyChange(columnVisibility);
   const pinningRenderId = useRerenderOnKeyChange(columnPinning);
   const {
     computedRemainingSpace,
@@ -1632,7 +1630,6 @@ var useComputedVisibleColumns = ({
     pinnedStartMaxWidth,
     columnPinning,
     columnsRenderId,
-    visibilityRenderId,
     columnsSizingRenderId,
     pinningRenderId,
     columnTypesRenderId
@@ -1657,11 +1654,11 @@ var useComputedVisibleColumns = ({
   return result;
 };
 
-// src/utils/sortAscending.ts
+// src/utils/DeepMap/sortAscending.ts
 var sortAscending = (a, b) => a - b;
 
 // src/components/InfiniteTable/hooks/useComputed.ts
-var import_react19 = __toModule(require("react"));
+var import_react18 = __toModule(require("react"));
 
 // src/components/hooks/useComponentState.tsx
 var React2 = __toModule(require("react"));
@@ -1753,9 +1750,14 @@ function getReducerGeneratedActions(dispatch, getState, getProps, propsToForward
       if (currentValue === value) {
         return;
       }
-      notifyChange(props, stateKey, value);
+      let notifyTheChange = true;
       if (interceptedActions && typeof interceptedActions[key] === "function") {
-        interceptedActions[key](value, { actions, state: state2 });
+        if (interceptedActions[key](value, { actions, state: state2 }) === false) {
+          notifyTheChange = false;
+        }
+      }
+      if (notifyTheChange) {
+        notifyChange(props, stateKey, value);
       }
       const forwardFn = propsToForward[key];
       if (typeof forwardFn === "function") {
@@ -1833,9 +1835,12 @@ function getComponentStateRoot(config) {
     const getProps = useLatest(props);
     const theReducer = (previousState, action) => {
       var _a2;
+      if (action.type === "REPLACE_STATE") {
+        return action.payload;
+      }
       const parentState2 = (_a2 = getParentState == null ? void 0 : getParentState()) != null ? _a2 : null;
       const mappedState = action.payload.mappedState;
-      const updatedProps = action.payload.updatedProps;
+      const updatedProps = action.payload.updatedPropsToState;
       const newState = Object.assign({}, previousState);
       if (mappedState) {
         Object.assign(newState, mappedState);
@@ -1889,8 +1894,9 @@ function getComponentStateRoot(config) {
       const currentProps = props;
       const newMappedState = {};
       let newMappedStateCount = 0;
-      const updatedProps = {};
-      let updatedPropsCount = 0;
+      const updatedPropsToState = {};
+      let updatedPropsToStateCount = 0;
+      const rawUpdatedProps = {};
       for (var k in props) {
         const key = k;
         const oldValue = prevProps[key];
@@ -1901,6 +1907,7 @@ function getComponentStateRoot(config) {
         if (oldValue === newValue) {
           continue;
         }
+        rawUpdatedProps[key] = { newValue, oldValue };
         if (isControlled(key, props) || isControlled(key, prevProps)) {
           if (propsToForward.hasOwnProperty(k)) {
             let valueToSet = newValue;
@@ -1913,22 +1920,30 @@ function getComponentStateRoot(config) {
               newMappedStateCount++;
             }
           } else if (propsToStateSetRef.current.has(k)) {
-            updatedProps[key] = currentProps[key];
-            updatedPropsCount++;
+            updatedPropsToState[key] = currentProps[key];
+            updatedPropsToStateCount++;
           }
         }
       }
-      if (updatedPropsCount > 0 || newMappedStateCount > 0) {
+      if (updatedPropsToStateCount > 0 || newMappedStateCount > 0) {
         debug2("Triggered by new values for the following props", ...[
           ...Object.keys(newMappedState != null ? newMappedState : {}),
-          ...Object.keys(updatedProps != null ? updatedProps : {})
+          ...Object.keys(updatedPropsToState != null ? updatedPropsToState : {})
         ]);
-        dispatch({
+        const action = {
           payload: {
             mappedState: newMappedStateCount ? newMappedState : null,
-            updatedProps: updatedPropsCount ? updatedProps : null
+            updatedPropsToState: updatedPropsToStateCount ? updatedPropsToState : null
           }
-        });
+        };
+        dispatch(action);
+        if (config.onPropChange) {
+          for (var prop in rawUpdatedProps)
+            if (rawUpdatedProps.hasOwnProperty(prop)) {
+              const { newValue, oldValue } = rawUpdatedProps[prop];
+              config.onPropChange({ name: prop, newValue, oldValue }, props, actions);
+            }
+        }
       }
     });
     return /* @__PURE__ */ React2.createElement(Context.Provider, {
@@ -1996,35 +2011,38 @@ function useColumnGroups() {
     return interceptMap(collapsedColumnGroups, {
       set: (key, visibleCol) => {
         const colIds = key.slice(1);
-        const { columnVisibility } = getComponentState();
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
         colIds.forEach((colId) => {
-          columnVisibility.set(colId, false);
+          columnVisibility[colId] = false;
         });
-        columnVisibility.delete(visibleCol);
+        delete columnVisibility[visibleCol];
+        componentActions.columnVisibility = columnVisibility;
       },
       beforeClear: (currentCollapsedGroups) => {
-        const { columnVisibility } = getComponentState();
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
         const keys = [...currentCollapsedGroups.keys()];
         keys.forEach((key) => {
           const colIds = key.slice(1);
           colIds.forEach((colId) => {
-            columnVisibility.delete(colId);
+            delete columnVisibility[colId];
           });
         });
+        componentActions.columnVisibility = columnVisibility;
       },
       delete: (key) => {
-        const { columnVisibility } = getComponentState();
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
         const colIds = key.slice(1);
         colIds.forEach((colId) => {
-          columnVisibility.delete(colId);
+          delete columnVisibility[colId];
         });
+        componentActions.columnVisibility = columnVisibility;
       }
     });
   }, [collapsedColumnGroups]);
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
-var import_react18 = __toModule(require("react"));
+var import_react17 = __toModule(require("react"));
 
 // src/components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns.tsx
 var React6 = __toModule(require("react"));
@@ -2279,7 +2297,7 @@ function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
 }
 
 // src/components/InfiniteTable/hooks/useToggleGroupRow.ts
-var import_react17 = __toModule(require("react"));
+var import_react16 = __toModule(require("react"));
 
 // src/components/DataSource/index.tsx
 var React8 = __toModule(require("react"));
@@ -2361,188 +2379,7 @@ var getMultisortFunction = (sortInfo, get) => {
 // src/components/DataSource/privateHooks/useLoadData.ts
 var import_react15 = __toModule(require("react"));
 
-// src/components/hooks/useEffectWithChanges.ts
-var import_react14 = __toModule(require("react"));
-function useEffectWithChanges(fn, deps) {
-  const prevRef = (0, import_react14.useRef)({});
-  const oldValuesRef = (0, import_react14.useRef)({});
-  const oldValues = oldValuesRef.current;
-  const changesRef = (0, import_react14.useRef)({});
-  const changes = changesRef.current;
-  const useEffectDeps = [];
-  for (let k in deps) {
-    if (deps.hasOwnProperty(k)) {
-      if (deps[k] !== prevRef.current[k]) {
-        changes[k] = deps[k];
-        oldValues[k] = prevRef.current[k];
-      }
-      useEffectDeps.push(deps[k]);
-    }
-  }
-  prevRef.current = deps;
-  (0, import_react14.useEffect)(() => {
-    const changes2 = changesRef.current;
-    const result = fn(changes2, oldValues);
-    changesRef.current = {};
-    oldValuesRef.current = {};
-    return result;
-  }, useEffectDeps);
-}
-
-// src/components/DataSource/privateHooks/useLoadData.ts
-var debug3 = dbg("DataSource:useLoadData");
-function anonimizeValues(arg) {
-  const result = {};
-  for (var k in arg)
-    if (arg.hasOwnProperty(k)) {
-      result[k] = true;
-    }
-  return result;
-}
-function buildDataSourceDataParams(componentState, changes) {
-  var _a, _b;
-  const sortInfo = componentState.multiSort ? componentState.sortInfo : (_b = (_a = componentState.sortInfo) == null ? void 0 : _a[0]) != null ? _b : null;
-  const dataSourceParams = {
-    originalDataArray: componentState.originalDataArray,
-    sortInfo,
-    groupBy: componentState.groupBy,
-    pivotBy: componentState.pivotBy
-  };
-  if (componentState.livePagination !== void 0) {
-    dataSourceParams.livePaginationCursor = componentState.livePaginationCursor;
-  }
-  if (changes !== void 0) {
-    dataSourceParams.changes = changes;
-  }
-  return dataSourceParams;
-}
-function notifyDataParamsChanged(componentState, actions, changes) {
-  var _a;
-  if (typeof componentState.data === "function") {
-    loadData(componentState.data, componentState, actions);
-  }
-  const dataParams = buildDataSourceDataParams(componentState, changes);
-  (_a = componentState.onDataParamsChange) == null ? void 0 : _a.call(componentState, dataParams);
-}
-function loadData(data, componentState, actions) {
-  const dataParams = buildDataSourceDataParams(componentState);
-  if (typeof data === "function") {
-    data = data(dataParams);
-  }
-  const dataIsPromise = typeof data === "object" && typeof data.then === "function";
-  if (dataIsPromise) {
-    actions.loading = true;
-  }
-  Promise.resolve(data).then((dataParam) => {
-    let dataArray = [];
-    if (Array.isArray(dataParam.data)) {
-      const remoteData = dataParam;
-      dataArray = remoteData.data;
-      if (remoteData.livePaginationCursor !== void 0) {
-        actions.livePaginationCursor = remoteData.livePaginationCursor;
-      }
-    } else {
-      dataArray = dataParam;
-    }
-    actions.originalDataArray = dataArray;
-    if (dataIsPromise) {
-      actions.loading = false;
-    }
-  });
-}
-function useLoadData() {
-  const {
-    getComponentState,
-    componentActions: actions,
-    componentState: { data }
-  } = useComponentState();
-  (0, import_react15.useLayoutEffect)(() => {
-    loadData(data, getComponentState(), actions);
-  }, [data]);
-  useLivePagination();
-}
-function useLivePagination() {
-  const {
-    getComponentState,
-    componentActions: actions,
-    componentState
-  } = useComponentState();
-  const {
-    notifyScrollbarsChange,
-    sortInfo,
-    groupBy,
-    pivotBy,
-    livePaginationCursor,
-    scrollBottomId
-  } = componentState;
-  const [scrollbars, setScrollbars] = (0, import_react15.useState)({
-    vertical: false,
-    horizontal: false
-  });
-  const scrollbarsRef = (0, import_react15.useRef)(scrollbars);
-  (0, import_react15.useEffect)(() => {
-    notifyScrollbarsChange.onChange((scrollbars2) => {
-      if (!scrollbars2) {
-        return;
-      }
-      scrollbarsRef.current = scrollbars2;
-      setScrollbars(scrollbars2);
-    });
-    return () => notifyScrollbarsChange.destroy();
-  }, [notifyScrollbarsChange]);
-  const [cursorId, updateCursorId] = (0, import_react15.useState)(void 0);
-  (0, import_react15.useEffect)(() => {
-    const frameId = requestAnimationFrame(() => {
-      var _a;
-      if (!((_a = scrollbarsRef.current) == null ? void 0 : _a.vertical)) {
-        updateCursorId(livePaginationCursor);
-      }
-    });
-    return () => cancelAnimationFrame(frameId);
-  }, [livePaginationCursor]);
-  (0, import_react15.useEffect)(() => {
-    const { livePaginationCursor: livePaginationCursor2, livePagination } = getComponentState();
-    if (!scrollbars.vertical && livePagination) {
-      updateCursorId(livePaginationCursor2);
-    }
-  }, [scrollbars.vertical]);
-  (0, import_react15.useEffect)(() => {
-    updateCursorId(scrollBottomId);
-  }, [scrollBottomId]);
-  const depsObject = {
-    sortInfo,
-    groupBy,
-    pivotBy,
-    livePaginationCursor: cursorId
-  };
-  useEffectWithChanges((changes, prevValues) => {
-    if (cursorId === void 0) {
-      return;
-    }
-    debug3("onDataParamsChange triggered because the following values have changed", changes, "old values", prevValues);
-    notifyDataParamsChanged(getComponentState(), actions, anonimizeValues(changes));
-  }, depsObject);
-}
-
-// src/components/DataSource/state/normalizeSortInfo.ts
-var EMPTY_ARRAY = Object.freeze([]);
-var normalizeSortInfo = (initialSortInfo, weakMap) => {
-  const sortInfo = initialSortInfo != null ? initialSortInfo : EMPTY_ARRAY;
-  const result = Array.isArray(sortInfo) ? sortInfo : [sortInfo];
-  if (weakMap && weakMap.has(sortInfo)) {
-    const prevResult = weakMap.get(sortInfo);
-    if (prevResult && prevResult.length === result.length) {
-      return prevResult;
-    }
-  }
-  if (weakMap && sortInfo) {
-    weakMap.set(sortInfo, result);
-  }
-  return result;
-};
-
-// src/components/hooks/useOnce.ts
-var import_react16 = __toModule(require("react"));
+// src/utils/DeepMap/once.ts
 function once(fn) {
   let called = false;
   let result = null;
@@ -2556,14 +2393,8 @@ function once(fn) {
   };
   return onceFn;
 }
-function useOnce(fn) {
-  const onceFn = (0, import_react16.useMemo)(() => {
-    return once(fn);
-  }, []);
-  return onceFn();
-}
 
-// src/utils/DeepMap.ts
+// src/utils/DeepMap/index.ts
 var SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
 var DeepMap = class {
   constructor(initial) {
@@ -2815,70 +2646,776 @@ var DeepMap = class {
   }
 };
 
-// src/components/DataSource/GroupRowsState.ts
-var GroupRowsState = class {
-  constructor(state) {
-    this.update(state instanceof GroupRowsState ? state.getState() : state);
-  }
-  getState() {
-    var _a, _b, _c, _d;
-    return {
-      expandedRows: this.expandedAll ? true : (_b = (_a = this.expandedMap) == null ? void 0 : _a.topDownKeys()) != null ? _b : [],
-      collapsedRows: this.collapsedAll ? true : (_d = (_c = this.collapsedMap) == null ? void 0 : _c.topDownKeys()) != null ? _d : []
-    };
-  }
-  destroy() {
-    var _a, _b;
-    (_a = this.expandedMap) == null ? void 0 : _a.clear();
-    (_b = this.collapsedMap) == null ? void 0 : _b.clear();
-    delete this.expandedMap;
-    delete this.collapsedMap;
+// src/utils/groupAndPivot/index.ts
+var LAZY_ROOT_KEY_FOR_GROUPS = "____root____";
+function DEFAULT_TO_KEY(value) {
+  return value;
+}
+function initReducers(reducers) {
+  if (!reducers || !Object.keys(reducers).length) {
+    return {};
   }
-  update(state) {
-    var _a, _b, _c, _d;
-    this.initialState = state;
-    const { collapsedRows, expandedRows } = this.initialState;
-    this.collapsedAll = collapsedRows === true;
-    this.expandedAll = expandedRows === true;
-    if (this.collapsedAll && this.expandedAll) {
-      throw `Cannot have both collapsedRows and expandedRows be true!`;
-    }
-    if (collapsedRows !== true) {
-      (_a = this.collapsedMap) == null ? void 0 : _a.clear();
-      this.collapsedMap = (_b = this.collapsedMap) != null ? _b : new DeepMap(collapsedRows.map((keys) => [keys, true]));
-    }
-    if (expandedRows !== true) {
-      (_c = this.expandedMap) == null ? void 0 : _c.clear();
-      this.expandedMap = (_d = this.expandedMap) != null ? _d : new DeepMap(expandedRows.map((keys) => [keys, true]));
+  const result = {};
+  for (let key in reducers)
+    if (reducers.hasOwnProperty(key)) {
+      result[key] = reducers[key].initialValue;
     }
+  return result;
+}
+function computeReducersFor(data, reducers, reducerResults) {
+  var _a, _b;
+  if (!reducers || !Object.keys(reducers).length) {
+    return;
   }
-  areAllCollapsed() {
-    return this.collapsedAll && (this.expandedMap ? this.expandedMap.size === 0 : true);
-  }
-  areAllExpanded() {
-    return this.expandedAll && (this.collapsedMap ? this.collapsedMap.size === 0 : true);
-  }
-  collapseAll() {
-    this.update({
-      collapsedRows: true,
-      expandedRows: []
-    });
-  }
-  expandAll() {
-    this.update({
-      expandedRows: true,
-      collapsedRows: []
-    });
-  }
-  isGroupRowExpanded(keys) {
-    var _a, _b;
-    if (this.expandedAll === true) {
-      if (this.collapsedAll === true) {
-        throw 'Cannot have both expandedRows and collapsedRows be "true"';
+  for (let key in reducers)
+    if (reducers.hasOwnProperty(key)) {
+      const reducer = reducers[key];
+      if (typeof reducer.reducer !== "function") {
+        continue;
       }
-      return !((_a = this.collapsedMap) == null ? void 0 : _a.has(keys));
+      const currentValue = reducerResults[key];
+      const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) == null ? void 0 : _a.call(reducer, data)) != null ? _b : null;
+      reducerResults[key] = reducer.reducer(currentValue, value, data);
     }
-    return (_b = this.expandedMap) == null ? void 0 : _b.has(keys);
+}
+function lazyGroup(groupParams, rootData) {
+  const {
+    reducers = {},
+    pivot,
+    groupBy,
+    mappings
+  } = groupParams;
+  const deepMap = new DeepMap();
+  function traverseValues(pivotDeepMap, container, pivot2, pivotIndex = 0, currentPivotKeys2 = []) {
+    const last = pivotIndex === pivot2.length - 1;
+    const values = container[(mappings == null ? void 0 : mappings.values) || "values"] || {};
+    for (var k in values)
+      if (values.hasOwnProperty(k)) {
+        const pivotKey = k;
+        currentPivotKeys2.push(pivotKey);
+        topLevelPivotColumns.set(currentPivotKeys2, true);
+        pivotDeepMap.set(currentPivotKeys2, {
+          reducerResults: values[k][(mappings == null ? void 0 : mappings.totals) || "totals"] || {},
+          items: []
+        });
+        if (!last) {
+          traverseValues(pivotDeepMap, values[k], pivot2, pivotIndex + 1, currentPivotKeys2);
+        }
+        currentPivotKeys2.pop();
+      }
+  }
+  const topLevelPivotColumns = pivot ? new DeepMap() : void 0;
+  let currentPivotKeys = [];
+  const initialReducerValue = initReducers(reducers);
+  const globalReducerResults = __spreadValues({}, initialReducerValue);
+  rootData.visitDepthFirst((lazyGroupRowInfo, keys, _index, next) => {
+    const [_rootKey, ...currentGroupKeys] = keys;
+    const dataArray = lazyGroupRowInfo.items;
+    for (let i = 0, len = dataArray.length; i < len; i++) {
+      if (!dataArray[i]) {
+        const deepMapGroupValue2 = {
+          items: [],
+          reducerResults: {}
+        };
+        deepMap.set([...currentGroupKeys, `not-loaded-yet-${i}`], deepMapGroupValue2);
+        continue;
+      }
+      const dataObject = dataArray[i].data;
+      const dataKeys = dataArray[i].keys;
+      let item = dataObject;
+      const { field: groupByProperty } = groupBy[dataKeys.length - 1];
+      const key = item[groupByProperty];
+      currentGroupKeys.push(key);
+      const deepMapGroupValue = {
+        items: [],
+        reducerResults: dataArray[i].aggregations || {}
+      };
+      deepMap.set(currentGroupKeys, deepMapGroupValue);
+      if (pivot) {
+        const pivotDeepMap = deepMapGroupValue.pivotDeepMap = new DeepMap();
+        const pivotContainer = dataArray[i].pivot;
+        traverseValues(pivotDeepMap, pivotContainer, pivot, 0, currentPivotKeys);
+      }
+      currentGroupKeys.pop();
+    }
+    next == null ? void 0 : next();
+  });
+  const result = {
+    deepMap,
+    groupParams,
+    initialData: rootData,
+    reducerResults: globalReducerResults
+  };
+  if (pivot) {
+    result.topLevelPivotColumns = topLevelPivotColumns;
+    result.pivot = pivot;
+  }
+  return result;
+}
+function group(groupParams, data) {
+  const {
+    groupBy,
+    defaultToKey = DEFAULT_TO_KEY,
+    pivot,
+    reducers
+  } = groupParams;
+  const groupByLength = groupBy.length;
+  const topLevelPivotColumns = pivot ? new DeepMap() : void 0;
+  const deepMap = new DeepMap();
+  let currentGroupKeys = [];
+  let currentPivotKeys = [];
+  const initialReducerValue = initReducers(reducers);
+  const globalReducerResults = __spreadValues({}, initialReducerValue);
+  for (let i = 0, len = data.length; i < len; i++) {
+    let item = data[i];
+    for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
+      const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
+      const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+      currentGroupKeys.push(key);
+      if (!deepMap.has(currentGroupKeys)) {
+        const deepMapGroupValue = {
+          items: [],
+          reducerResults: __spreadValues({}, initialReducerValue)
+        };
+        if (pivot) {
+          deepMapGroupValue.pivotDeepMap = new DeepMap();
+        }
+        deepMap.set(currentGroupKeys, deepMapGroupValue);
+      }
+      const {
+        items: currentGroupItems,
+        reducerResults,
+        pivotDeepMap
+      } = deepMap.get(currentGroupKeys);
+      currentGroupItems.push(item);
+      if (reducers) {
+        computeReducersFor(item, reducers, reducerResults);
+      }
+      if (pivot) {
+        for (let pivotIndex = 0, pivotLength = pivot.length; pivotIndex < pivotLength; pivotIndex++) {
+          const { field: pivotField, toKey: pivotToKey } = pivot[pivotIndex];
+          const pivotKey = (pivotToKey || defaultToKey)(item[pivotField], item);
+          currentPivotKeys.push(pivotKey);
+          if (!pivotDeepMap.has(currentPivotKeys)) {
+            topLevelPivotColumns.set(currentPivotKeys, true);
+            pivotDeepMap == null ? void 0 : pivotDeepMap.set(currentPivotKeys, {
+              reducerResults: __spreadValues({}, initialReducerValue),
+              items: []
+            });
+          }
+          const {
+            reducerResults: pivotReducerResults,
+            items: pivotGroupItems
+          } = pivotDeepMap.get(currentPivotKeys);
+          pivotGroupItems.push(item);
+          if (reducers) {
+            computeReducersFor(item, reducers, pivotReducerResults);
+          }
+        }
+        currentPivotKeys.length = 0;
+      }
+    }
+    if (reducers) {
+      computeReducersFor(item, reducers, globalReducerResults);
+    }
+    currentGroupKeys.length = 0;
+  }
+  if (reducers) {
+    deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
+      completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
+      if (pivot) {
+        deepMapValue.pivotDeepMap.visitDepthFirst(({ items, reducerResults: pivotReducerResults }, _keys2, _indexInGroup2, next2) => {
+          completeReducers(reducers, pivotReducerResults, items);
+          next2 == null ? void 0 : next2();
+        });
+      }
+      next == null ? void 0 : next();
+    });
+  }
+  if (reducers) {
+    completeReducers(reducers, globalReducerResults, data);
+  }
+  const result = {
+    deepMap,
+    groupParams,
+    initialData: data,
+    reducerResults: globalReducerResults
+  };
+  if (pivot) {
+    result.topLevelPivotColumns = topLevelPivotColumns;
+    result.pivot = pivot;
+  }
+  return result;
+}
+function flatten(groupResult) {
+  const { groupParams, deepMap } = groupResult;
+  const groupByLength = groupParams.groupBy.length;
+  const result = [];
+  deepMap.topDownKeys().reduce((acc, key) => {
+    if (key.length === groupByLength) {
+      const items = deepMap.get(key).items;
+      acc.push(...items);
+    }
+    return acc;
+  }, result);
+  return result;
+}
+function getEnhancedGroupData(options, deepMapValue) {
+  const { groupBy, groupKeys, collapsed, parents, reducers } = options;
+  const groupNesting = groupKeys.length;
+  const { items: groupItems, reducerResults, pivotDeepMap } = deepMapValue;
+  let data = null;
+  if (Object.keys(reducerResults).length > 0) {
+    data = {};
+    for (let key in reducers)
+      if (reducers.hasOwnProperty(key)) {
+        const reducer = reducers[key];
+        const field = reducer.field;
+        if (field) {
+          data[field] = reducerResults[key];
+        }
+      }
+  }
+  const enhancedGroupData = {
+    data,
+    groupCount: groupItems.length,
+    groupData: groupItems,
+    groupKeys,
+    id: groupKeys,
+    collapsed,
+    parents,
+    collapsedChildrenCount: 0,
+    collapsedGroupsCount: 0,
+    indexInParentGroups: options.indexInParentGroups,
+    indexInGroup: options.indexInGroup,
+    indexInAll: options.indexInAll,
+    value: groupKeys[groupKeys.length - 1],
+    rootGroupBy: groupBy,
+    groupBy: groupNesting === groupBy.length ? groupBy : groupBy.slice(0, groupNesting),
+    isGroupRow: true,
+    pivotValuesMap: pivotDeepMap,
+    groupNesting,
+    reducerResults
+  };
+  return enhancedGroupData;
+}
+function completeReducers(reducers, reducerResults, items) {
+  if (reducers) {
+    for (let key in reducers)
+      if (reducers.hasOwnProperty(key)) {
+        const reducer = reducers[key];
+        if (reducer.done) {
+          reducerResults[key] = reducer.done(reducerResults[key], items);
+        }
+      }
+  }
+  return reducerResults;
+}
+function enhancedFlatten(param) {
+  const {
+    groupResult,
+    toPrimaryKey,
+    groupRowsState,
+    generateGroupRows,
+    reducers = {}
+  } = param;
+  const { groupParams, deepMap, pivot } = groupResult;
+  const { groupBy } = groupParams;
+  const groupByStrings = groupBy.map((g) => g.field);
+  const result = [];
+  const parents = [];
+  const indexInParentGroups = [];
+  deepMap.visitDepthFirst((deepMapValue, groupKeys, indexInGroup, next) => {
+    var _a;
+    const items = deepMapValue.items;
+    const groupNesting = groupKeys.length;
+    const collapsed = (_a = groupRowsState == null ? void 0 : groupRowsState.isGroupRowCollapsed(groupKeys)) != null ? _a : false;
+    const enhancedGroupData = getEnhancedGroupData({
+      groupBy: groupByStrings,
+      parents: Array.from(parents),
+      reducers,
+      indexInGroup,
+      indexInParentGroups: Array.from(indexInParentGroups),
+      indexInAll: result.length,
+      groupKeys,
+      collapsed
+    }, deepMapValue);
+    const include = generateGroupRows || collapsed;
+    if (include) {
+      result.push(enhancedGroupData);
+    }
+    if (collapsed) {
+      parents.forEach((parent) => {
+        parent.collapsedChildrenCount += enhancedGroupData.groupCount;
+        parent.collapsedGroupsCount += 1;
+      });
+    }
+    indexInParentGroups.push(indexInGroup);
+    parents.push(enhancedGroupData);
+    if (!collapsed) {
+      if (!next) {
+        if (!pivot) {
+          const startIndex = result.length;
+          result.push(...items.map((item, index) => {
+            return {
+              id: toPrimaryKey(item),
+              data: item,
+              isGroupRow: false,
+              collapsed: false,
+              groupKeys,
+              parents: Array.from(parents),
+              indexInParentGroups: [...indexInParentGroups, index],
+              indexInGroup: index,
+              indexInAll: startIndex + index,
+              groupBy: groupByStrings,
+              groupNesting,
+              groupCount: enhancedGroupData.groupCount
+            };
+          }));
+        }
+      } else {
+        next();
+      }
+    }
+    parents.pop();
+    indexInParentGroups.pop();
+  });
+  return {
+    data: result
+  };
+}
+
+// src/components/hooks/useEffectWithChanges.ts
+var import_react14 = __toModule(require("react"));
+function useEffectWithChanges(fn, deps) {
+  const prevRef = (0, import_react14.useRef)({});
+  const oldValuesRef = (0, import_react14.useRef)({});
+  const oldValues = oldValuesRef.current;
+  const changesRef = (0, import_react14.useRef)({});
+  const changes = changesRef.current;
+  const useEffectDeps = [];
+  for (let k in deps) {
+    if (deps.hasOwnProperty(k)) {
+      if (deps[k] !== prevRef.current[k]) {
+        changes[k] = deps[k];
+        oldValues[k] = prevRef.current[k];
+      }
+      useEffectDeps.push(deps[k]);
+    }
+  }
+  prevRef.current = deps;
+  (0, import_react14.useEffect)(() => {
+    const changes2 = changesRef.current;
+    const result = fn(changes2, oldValues);
+    changesRef.current = {};
+    oldValuesRef.current = {};
+    return result;
+  }, useEffectDeps);
+}
+
+// src/components/utils/debounce.ts
+function debounce(fn, { wait }) {
+  let timeout = null;
+  return function(...args) {
+    const context = this;
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      fn.apply(context, args);
+    }, wait);
+  };
+}
+
+// src/components/DataSource/privateHooks/useLoadData.ts
+var getRafPromise = () => new Promise((resolve) => {
+  requestAnimationFrame(resolve);
+});
+var SKIP_DATA_CHANGES_KEYS = {
+  originalDataArray: true,
+  changes: true
+};
+function getChangeDetect() {
+  var _a;
+  const perfNow = (_a = getGlobal().performance) == null ? void 0 : _a.now();
+  return `${Date.now()}:${perfNow}`;
+}
+function buildDataSourceDataParams(componentState, overrides) {
+  var _a, _b;
+  const sortInfo = componentState.multiSort ? componentState.sortInfo : (_b = (_a = componentState.sortInfo) == null ? void 0 : _a[0]) != null ? _b : null;
+  const dataSourceParams = {
+    originalDataArray: componentState.originalDataArray,
+    sortInfo,
+    groupBy: componentState.groupBy,
+    pivotBy: componentState.pivotBy,
+    aggregationReducers: componentState.aggregationReducers
+  };
+  if (componentState.livePagination !== void 0) {
+    dataSourceParams.livePaginationCursor = componentState.livePaginationCursor;
+    dataSourceParams.cursorId = componentState.cursorId;
+  }
+  if (componentState.fullLazyLoad) {
+    if (componentState.lazyLoadBatchSize != null && componentState.lazyLoadBatchSize > 0) {
+      dataSourceParams.lazyLoadBatchSize = componentState.lazyLoadBatchSize;
+      dataSourceParams.lazyLoadStartIndex = 0;
+    }
+    dataSourceParams.groupKeys = [];
+  }
+  if (overrides) {
+    Object.assign(dataSourceParams, overrides);
+  }
+  const changes = {};
+  const oldDataSourceParams = componentState.dataParams || {};
+  for (let k in dataSourceParams) {
+    if (dataSourceParams.hasOwnProperty(k) && !SKIP_DATA_CHANGES_KEYS[k]) {
+      const key = k;
+      if (dataSourceParams[key] !== oldDataSourceParams[key]) {
+        changes[key] = true;
+      }
+    }
+  }
+  dataSourceParams.changes = changes;
+  return dataSourceParams;
+}
+function loadData(data, componentState, actions, overrides) {
+  const dataParams = buildDataSourceDataParams(componentState, overrides);
+  if (typeof data === "function") {
+    data = data(dataParams);
+  }
+  const dataIsPromise = typeof data === "object" && typeof data.then === "function";
+  if (dataIsPromise && !componentState.fullLazyLoad) {
+    actions.loading = true;
+  }
+  return Promise.resolve(data).then((dataParam) => {
+    var _a, _b, _c;
+    let dataArray = [];
+    let skipAssign = false;
+    if (Array.isArray(dataParam.data)) {
+      const remoteData = dataParam;
+      dataArray = remoteData.data;
+      if (remoteData.livePaginationCursor !== void 0) {
+        actions.livePaginationCursor = remoteData.livePaginationCursor;
+      }
+      if (remoteData.mappings) {
+        actions.pivotMappings = remoteData.mappings;
+      }
+      if (componentState.fullLazyLoad && dataParams.groupKeys) {
+        const lazyGroupData = componentState.originalLazyGroupData;
+        const key = [LAZY_ROOT_KEY_FOR_GROUPS, ...dataParams.groupKeys];
+        const newGroupRowInfo = {
+          totalCount: (_a = remoteData.totalCount) != null ? _a : dataArray.length,
+          items: dataArray
+        };
+        if (dataParams.lazyLoadBatchSize) {
+          const existingGroupRowInfo = lazyGroupData.get(key);
+          const currentGroupRowInfo = existingGroupRowInfo != null ? existingGroupRowInfo : {
+            items: [],
+            totalCount: newGroupRowInfo.totalCount
+          };
+          currentGroupRowInfo.items.length = currentGroupRowInfo.totalCount;
+          const start = (_b = dataParams.lazyLoadStartIndex) != null ? _b : 0;
+          const end = Math.min((_c = remoteData.totalCount) != null ? _c : start + dataParams.lazyLoadBatchSize);
+          for (let i = start; i < end; i++) {
+            currentGroupRowInfo.items[i] = newGroupRowInfo.items[i - start];
+          }
+          if (!existingGroupRowInfo) {
+            lazyGroupData.set(key, currentGroupRowInfo);
+          }
+        } else {
+          lazyGroupData.set(key, newGroupRowInfo);
+        }
+        skipAssign = true;
+        actions.originalLazyGroupDataChangeDetect = getChangeDetect();
+      }
+    } else {
+      dataArray = dataParam;
+    }
+    if (!skipAssign) {
+      actions.originalDataArray = dataArray;
+    }
+    if (dataIsPromise && !componentState.fullLazyLoad) {
+      actions.loading = false;
+    }
+  });
+}
+function useLoadData() {
+  const {
+    getComponentState,
+    componentActions: actions,
+    componentState
+  } = useComponentState();
+  const {
+    data,
+    notifyScrollbarsChange,
+    sortInfo,
+    groupBy,
+    pivotBy,
+    livePagination,
+    livePaginationCursor,
+    cursorId: stateCursorId
+  } = componentState;
+  const [scrollbars, setScrollbars] = (0, import_react15.useState)({
+    vertical: false,
+    horizontal: false
+  });
+  const scrollbarsRef = (0, import_react15.useRef)(scrollbars);
+  (0, import_react15.useEffect)(() => {
+    notifyScrollbarsChange.onChange((scrollbars2) => {
+      if (!scrollbars2) {
+        return;
+      }
+      scrollbarsRef.current = scrollbars2;
+      setScrollbars(scrollbars2);
+    });
+    return () => notifyScrollbarsChange.destroy();
+  }, [notifyScrollbarsChange]);
+  (0, import_react15.useEffect)(() => {
+    const frameId = requestAnimationFrame(() => {
+      var _a;
+      if (!((_a = scrollbarsRef.current) == null ? void 0 : _a.vertical) && livePaginationCursor) {
+        actions.cursorId = livePaginationCursor;
+      }
+    });
+    return () => cancelAnimationFrame(frameId);
+  }, [livePaginationCursor]);
+  (0, import_react15.useEffect)(() => {
+    const { livePaginationCursor: livePaginationCursor2, livePagination: livePagination2 } = getComponentState();
+    if (!scrollbars.vertical && livePagination2) {
+      if (livePaginationCursor2) {
+        actions.cursorId = livePaginationCursor2;
+      }
+    }
+  }, [scrollbars.vertical]);
+  const depsObject = {
+    sortInfo,
+    groupBy,
+    pivotBy,
+    cursorId: livePagination ? stateCursorId : null
+  };
+  const initialRef = (0, import_react15.useRef)(true);
+  useLazyLoadRange();
+  useEffectWithChanges(() => {
+    const componentState2 = getComponentState();
+    if (typeof componentState2.data !== "function") {
+      loadData(componentState2.data, componentState2, actions);
+    }
+  }, { data });
+  useEffectWithChanges(() => {
+    const componentState2 = getComponentState();
+    if (typeof componentState2.data === "function") {
+      loadData(componentState2.data, componentState2, actions);
+    }
+  }, __spreadProps(__spreadValues({}, depsObject), { data }));
+  useEffectWithChanges((_changes, _prevValues) => {
+    const componentState2 = getComponentState();
+    if (initialRef.current) {
+      initialRef.current = false;
+      actions.dataParams = buildDataSourceDataParams(componentState2);
+    }
+  }, depsObject);
+}
+function useLazyLoadRange() {
+  const {
+    getComponentState,
+    componentActions: actions,
+    componentState
+  } = useComponentState();
+  const loadingCache = (0, import_react15.useMemo)(() => {
+    return new Map();
+  }, [componentState.data]);
+  globalThis.loadingCache = loadingCache;
+  const {
+    lazyLoadBatchSize,
+    notifyRenderRangeChange,
+    dataArray,
+    scrollStopDelayUpdatedByTable
+  } = componentState;
+  const latestRenderRangeRef = (0, import_react15.useRef)(null);
+  const loadRange = (param, cache = loadingCache) => {
+    const componentState2 = getComponentState();
+    param = param || latestRenderRangeRef.current;
+    if (!param) {
+      return;
+    }
+    const { renderStartIndex: startIndex, renderEndIndex: endIndex } = param;
+    if (!lazyLoadBatchSize || lazyLoadBatchSize <= 0) {
+      return;
+    }
+    lazyLoadRange({
+      startIndex,
+      endIndex,
+      lazyLoadBatchSize,
+      componentState: componentState2,
+      componentActions: actions
+    }, cache);
+  };
+  const debouncedLoadRange = (0, import_react15.useMemo)(() => debounce(loadRange, { wait: scrollStopDelayUpdatedByTable }), [scrollStopDelayUpdatedByTable]);
+  (0, import_react15.useEffect)(() => {
+    if (lazyLoadBatchSize && lazyLoadBatchSize > 0) {
+      return notifyRenderRangeChange.onChange((param) => {
+        latestRenderRangeRef.current = param;
+        loadRange(param, loadingCache);
+      });
+    }
+    return;
+  }, [lazyLoadBatchSize, loadingCache]);
+  (0, import_react15.useEffect)(() => {
+    if (lazyLoadBatchSize && lazyLoadBatchSize > 0) {
+      debouncedLoadRange();
+    }
+    return;
+  }, [dataArray]);
+}
+function lazyLoadRange(options, cache) {
+  const {
+    startIndex,
+    endIndex,
+    lazyLoadBatchSize,
+    componentState,
+    componentActions
+  } = options;
+  const { dataArray } = componentState;
+  const isRowLoaded = (index) => dataArray[index].data != null;
+  const perGroupFnCalls = new DeepMap();
+  const rootGroupKeys = ["_______xxx______"];
+  for (let i = startIndex; i <= endIndex; i++) {
+    const rowInfo = dataArray[i];
+    if (!rowInfo) {
+      continue;
+    }
+    const rowLoaded = rowInfo.data != null;
+    const parentGroupKeys = rowInfo.groupKeys ? [...rowInfo.groupKeys] : [];
+    if (rowInfo.groupKeys) {
+      parentGroupKeys.pop();
+    }
+    const cacheKeys = parentGroupKeys.length ? parentGroupKeys : rootGroupKeys;
+    const indexInGroup = rowInfo.indexInGroup;
+    if (!rowLoaded) {
+      let fnCalls = perGroupFnCalls.get(cacheKeys);
+      const batchStartIndexInGroup = Math.floor(indexInGroup / lazyLoadBatchSize) * lazyLoadBatchSize;
+      const offset = rowInfo.indexInGroup - batchStartIndexInGroup;
+      const absoluteIndexOfBatchStart = dataArray[rowInfo.indexInAll - offset].indexInAll;
+      const batchStartRowLoaded = isRowLoaded(absoluteIndexOfBatchStart);
+      const batchStartRowId = dataArray[absoluteIndexOfBatchStart].id;
+      if (batchStartRowLoaded || (fnCalls == null ? void 0 : fnCalls[batchStartRowId])) {
+        continue;
+      }
+      const shouldSetFnCalls = !fnCalls;
+      fnCalls = fnCalls || {};
+      const currentFnCall = {
+        lazyLoadStartIndex: batchStartIndexInGroup,
+        lazyLoadBatchSize,
+        groupKeys: parentGroupKeys
+      };
+      if (!fnCalls[batchStartRowId]) {
+        fnCalls[batchStartRowId] = currentFnCall;
+      }
+      if (shouldSetFnCalls) {
+        perGroupFnCalls.set(cacheKeys, fnCalls);
+      }
+    }
+  }
+  let initialPromise = Promise.resolve(true);
+  const allFnCalls = [];
+  perGroupFnCalls.topDownValues().forEach((record) => {
+    allFnCalls.push(...Object.values(record));
+  });
+  allFnCalls.reduce((promise, fnCall) => {
+    const cacheKey = `${fnCall.groupKeys.join("-")}:${fnCall.lazyLoadStartIndex}`;
+    if (cache && cache.has(cacheKey)) {
+      return promise;
+    }
+    cache == null ? void 0 : cache.set(cacheKey, true);
+    const args = [componentState.data, componentState, componentActions, fnCall];
+    return promise.then(() => getRafPromise()).then(() => loadData(...args)).then(() => {
+      requestAnimationFrame(() => {
+        cache == null ? void 0 : cache.delete(cacheKey);
+      });
+    });
+  }, initialPromise);
+}
+
+// src/components/DataSource/state/normalizeSortInfo.ts
+var EMPTY_ARRAY = Object.freeze([]);
+var normalizeSortInfo = (initialSortInfo, weakMap) => {
+  const sortInfo = initialSortInfo != null ? initialSortInfo : EMPTY_ARRAY;
+  const result = Array.isArray(sortInfo) ? sortInfo : [sortInfo];
+  if (weakMap && weakMap.has(sortInfo)) {
+    const prevResult = weakMap.get(sortInfo);
+    if (prevResult && prevResult.length === result.length) {
+      return prevResult;
+    }
+  }
+  if (weakMap && sortInfo) {
+    weakMap.set(sortInfo, result);
+  }
+  return result;
+};
+
+// src/components/DataSource/GroupRowsState.ts
+var GroupRowsState = class {
+  constructor(state) {
+    this.update(state instanceof GroupRowsState ? state.getState() : state);
+  }
+  getState() {
+    var _a, _b, _c, _d;
+    return {
+      expandedRows: this.expandedAll ? true : (_b = (_a = this.expandedMap) == null ? void 0 : _a.topDownKeys()) != null ? _b : [],
+      collapsedRows: this.collapsedAll ? true : (_d = (_c = this.collapsedMap) == null ? void 0 : _c.topDownKeys()) != null ? _d : []
+    };
+  }
+  destroy() {
+    var _a, _b;
+    (_a = this.expandedMap) == null ? void 0 : _a.clear();
+    (_b = this.collapsedMap) == null ? void 0 : _b.clear();
+    delete this.expandedMap;
+    delete this.collapsedMap;
+  }
+  update(state) {
+    var _a, _b, _c, _d;
+    this.initialState = state;
+    const { collapsedRows, expandedRows } = this.initialState;
+    this.collapsedAll = collapsedRows === true;
+    this.expandedAll = expandedRows === true;
+    if (this.collapsedAll && this.expandedAll) {
+      throw `Cannot have both collapsedRows and expandedRows be true!`;
+    }
+    if (collapsedRows !== true) {
+      (_a = this.collapsedMap) == null ? void 0 : _a.clear();
+      this.collapsedMap = (_b = this.collapsedMap) != null ? _b : new DeepMap(collapsedRows.map((keys) => [keys, true]));
+    }
+    if (expandedRows !== true) {
+      (_c = this.expandedMap) == null ? void 0 : _c.clear();
+      this.expandedMap = (_d = this.expandedMap) != null ? _d : new DeepMap(expandedRows.map((keys) => [keys, true]));
+    }
+  }
+  areAllCollapsed() {
+    return this.collapsedAll && (this.expandedMap ? this.expandedMap.size === 0 : true);
+  }
+  areAllExpanded() {
+    return this.expandedAll && (this.collapsedMap ? this.collapsedMap.size === 0 : true);
+  }
+  collapseAll() {
+    this.update({
+      collapsedRows: true,
+      expandedRows: []
+    });
+  }
+  expandAll() {
+    this.update({
+      expandedRows: true,
+      collapsedRows: []
+    });
+  }
+  isGroupRowExpanded(keys) {
+    var _a, _b;
+    if (this.expandedAll === true) {
+      if (this.collapsedAll === true) {
+        throw 'Cannot have both expandedRows and collapsedRows be "true"';
+      }
+      return !((_a = this.collapsedMap) == null ? void 0 : _a.has(keys));
+    }
+    return (_b = this.expandedMap) == null ? void 0 : _b.has(keys);
   }
   isGroupRowCollapsed(keys) {
     return !this.isGroupRowExpanded(keys);
@@ -2926,7 +3463,7 @@ var GroupRowsState = class {
 };
 
 // src/utils/shallowEqualObjects.ts
-function shallowEqualObjects(objA, objB) {
+function shallowEqualObjects(objA, objB, ignoreKeys) {
   if (objA === objB) {
     return true;
   }
@@ -2935,12 +3472,21 @@ function shallowEqualObjects(objA, objB) {
   }
   var aKeys = Object.keys(objA);
   var bKeys = Object.keys(objB);
+  if (ignoreKeys) {
+    aKeys = aKeys.filter((key2) => !ignoreKeys.has(key2));
+    bKeys = bKeys.filter((key2) => !ignoreKeys.has(key2));
+  }
   var len = aKeys.length;
   if (bKeys.length !== len) {
     return false;
   }
   for (var i = 0; i < len; i++) {
     var key = aKeys[i];
+    if (ignoreKeys) {
+      if (ignoreKeys.has(key)) {
+        continue;
+      }
+    }
     if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
       return false;
     }
@@ -2951,12 +3497,12 @@ function shallowEqualObjects(objA, objB) {
 // src/components/utils/discardCallsWithEqualArg.ts
 var map = new WeakMap();
 var getCompareDefault = (a) => a;
-function discardCallsWithEqualArg(fn, timeframe = 50, getCompareObject2) {
+function discardCallsWithEqualArg(fn, timeframe = 50, getCompareObject) {
   map.set(fn, {
     lastCallTime: 0,
     lastCallArg: null
   });
-  const getCompare = getCompareObject2 != null ? getCompareObject2 : getCompareDefault;
+  const getCompare = getCompareObject != null ? getCompareObject : getCompareDefault;
   return (arg) => {
     const { lastCallTime, lastCallArg } = map.get(fn) || {
       lastCallTime: 0,
@@ -2977,20 +3523,28 @@ function discardCallsWithEqualArg(fn, timeframe = 50, getCompareObject2) {
 }
 
 // src/components/DataSource/state/getInitialState.ts
+var defaultCursorId = Symbol("cursorId");
 function initSetupState2() {
   const now = Date.now();
   const originalDataArray = [];
   const dataArray = [];
+  const originalLazyGroupData = new DeepMap();
   return {
     dataParams: void 0,
     notifyScrollbarsChange: buildSubscriptionCallback(),
+    notifyScrollStop: buildSubscriptionCallback(),
+    notifyRenderRangeChange: buildSubscriptionCallback(),
     pivotTotalColumnPosition: "end",
+    scrollStopDelayUpdatedByTable: 100,
+    originalLazyGroupData,
+    originalLazyGroupDataChangeDetect: 0,
     originalDataArray,
-    scrollBottomId: Symbol("scrollBottomId"),
+    cursorId: defaultCursorId,
     showSeparatePivotColumnForSingleAggregation: false,
     propsCache: new Map([
       ["sortInfo", new WeakMap()]
     ]),
+    pivotMappings: void 0,
     pivotColumns: void 0,
     pivotColumnGroups: void 0,
     dataArray,
@@ -3006,19 +3560,22 @@ function initSetupState2() {
     lastGroupDataArray: void 0
   };
 }
-function getCompareObject(dataParams) {
+function getCompareObjectForDataParams(dataParams) {
   const obj = __spreadValues({}, dataParams);
   delete obj.originalDataArray;
   return obj;
 }
 var forwardProps3 = (setupState) => {
   return {
-    onDataParamsChange: (fn) => fn ? discardCallsWithEqualArg(fn, 100, getCompareObject) : void 0,
+    onDataParamsChange: (fn) => fn ? discardCallsWithEqualArg(fn, 100, getCompareObjectForDataParams) : void 0,
+    fullLazyLoad: 1,
     data: 1,
     pivotBy: 1,
     primaryKey: 1,
     livePagination: 1,
+    lazyLoadBatchSize: (lazyLoadBatchSize) => lazyLoadBatchSize != null ? lazyLoadBatchSize : -1,
     aggregationReducers: 1,
+    collapseGroupRowsOnDataFunctionChange: (collapseGroupRowsOnDataFunctionChange) => collapseGroupRowsOnDataFunctionChange != null ? collapseGroupRowsOnDataFunctionChange : true,
     loading: (loading) => loading != null ? loading : false,
     sortInfo: (sortInfo) => normalizeSortInfo(sortInfo, setupState.propsCache.get("sortInfo")),
     groupBy: (groupBy) => groupBy != null ? groupBy : [],
@@ -3030,297 +3587,111 @@ var forwardProps3 = (setupState) => {
     }
   };
 };
+function getLivePaginationCursorValue(livePaginationCursorProp, state) {
+  const livePaginationCursor = typeof livePaginationCursorProp === "function" ? livePaginationCursorProp({
+    array: state.originalDataArray,
+    length: state.originalDataArray.length,
+    lastItem: state.originalDataArray[state.originalDataArray.length - 1]
+  }) : livePaginationCursorProp;
+  return livePaginationCursor;
+}
 function mapPropsToState2(params) {
-  const { props, state } = params;
+  const { props, state, oldState } = params;
   const controlledSort = isControlledValue(props.sortInfo);
   const result = {
     controlledSort,
     multiSort: Array.isArray(controlledSort ? props.sortInfo : props.defaultSortInfo)
   };
-  if (props.livePagination) {
-    const livePaginationCursor = typeof props.livePaginationCursor === "function" ? props.livePaginationCursor({
-      array: state.originalDataArray,
-      length: state.originalDataArray.length,
-      lastItem: state.originalDataArray[state.originalDataArray.length - 1]
-    }) : props.livePaginationCursor;
-    result.livePaginationCursor = livePaginationCursor;
-  }
-  return result;
-}
-function getInterceptActions() {
-  return {
-    sortInfo: (sortInfo, { actions, state }) => {
-      const dataParams = buildDataSourceDataParams(state);
-      dataParams.sortInfo = sortInfo;
-      actions.dataParams = dataParams;
-    }
-  };
-}
-
-// src/utils/groupAndPivot/index.ts
-function DEFAULT_TO_KEY(value) {
-  return value;
-}
-function initReducers(reducers) {
-  if (!reducers || !Object.keys(reducers).length) {
-    return {};
-  }
-  const result = {};
-  for (let key in reducers)
-    if (reducers.hasOwnProperty(key)) {
-      result[key] = reducers[key].initialValue;
-    }
-  return result;
-}
-function computeReducersFor(data, reducers, reducerResults) {
-  var _a, _b;
-  if (!reducers || !Object.keys(reducers).length) {
-    return;
-  }
-  for (let key in reducers)
-    if (reducers.hasOwnProperty(key)) {
-      const reducer = reducers[key];
-      const currentValue = reducerResults[key];
-      const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) == null ? void 0 : _a.call(reducer, data)) != null ? _b : null;
-      reducerResults[key] = reducer.reducer(currentValue, value, data);
-    }
-}
-function group(groupParams, data) {
-  const {
-    groupBy,
-    defaultToKey = DEFAULT_TO_KEY,
-    pivot,
-    reducers
-  } = groupParams;
-  const groupByLength = groupBy.length;
-  const topLevelPivotColumns = pivot ? new DeepMap() : void 0;
-  const deepMap = new DeepMap();
-  let currentGroupKeys = [];
-  let currentPivotKeys = [];
-  const initialReducerValue = initReducers(reducers);
-  const globalReducerResults = __spreadValues({}, initialReducerValue);
-  for (let i = 0, len = data.length; i < len; i++) {
-    let item = data[i];
-    for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
-      const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
-      const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
-      currentGroupKeys.push(key);
-      if (!deepMap.has(currentGroupKeys)) {
-        const deepMapGroupValue = {
-          items: [],
-          reducerResults: __spreadValues({}, initialReducerValue)
-        };
-        if (pivot) {
-          deepMapGroupValue.pivotDeepMap = new DeepMap();
-        }
-        deepMap.set(currentGroupKeys, deepMapGroupValue);
-      }
-      const {
-        items: currentGroupItems,
-        reducerResults,
-        pivotDeepMap
-      } = deepMap.get(currentGroupKeys);
-      currentGroupItems.push(item);
-      if (reducers) {
-        computeReducersFor(item, reducers, reducerResults);
-      }
-      if (pivot) {
-        for (let pivotIndex = 0, pivotLength = pivot.length; pivotIndex < pivotLength; pivotIndex++) {
-          const { field: pivotField, toKey: pivotToKey } = pivot[pivotIndex];
-          const pivotKey = (pivotToKey || defaultToKey)(item[pivotField], item);
-          currentPivotKeys.push(pivotKey);
-          if (!pivotDeepMap.has(currentPivotKeys)) {
-            topLevelPivotColumns.set(currentPivotKeys, true);
-            pivotDeepMap == null ? void 0 : pivotDeepMap.set(currentPivotKeys, {
-              reducerResults: __spreadValues({}, initialReducerValue),
-              items: []
-            });
-          }
-          const {
-            reducerResults: pivotReducerResults,
-            items: pivotGroupItems
-          } = pivotDeepMap.get(currentPivotKeys);
-          pivotGroupItems.push(item);
-          if (reducers) {
-            computeReducersFor(item, reducers, pivotReducerResults);
-          }
-        }
-        currentPivotKeys.length = 0;
-      }
-    }
-    if (reducers) {
-      computeReducersFor(item, reducers, globalReducerResults);
-    }
-    currentGroupKeys.length = 0;
-  }
-  if (reducers) {
-    deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
-      completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
-      if (pivot) {
-        deepMapValue.pivotDeepMap.visitDepthFirst(({ items, reducerResults: pivotReducerResults }, _keys2, _indexInGroup2, next2) => {
-          completeReducers(reducers, pivotReducerResults, items);
-          next2 == null ? void 0 : next2();
-        });
-      }
-      next == null ? void 0 : next();
-    });
-  }
-  if (reducers) {
-    completeReducers(reducers, globalReducerResults, data);
-  }
-  const result = {
-    deepMap,
-    groupParams,
-    initialData: data,
-    reducerResults: globalReducerResults
-  };
-  if (pivot) {
-    result.topLevelPivotColumns = topLevelPivotColumns;
-    result.pivot = pivot;
+  if (props.livePagination) {
+    const dataArrayChanged = !oldState || oldState.originalDataArray !== state.originalDataArray;
+    const livePaginationCursor = typeof props.livePaginationCursor === "function" ? dataArrayChanged ? getLivePaginationCursorValue(props.livePaginationCursor, state) : state.livePaginationCursor : props.livePaginationCursor;
+    result.livePaginationCursor = livePaginationCursor;
   }
   return result;
 }
-function flatten(groupResult) {
-  const { groupParams, deepMap } = groupResult;
-  const groupByLength = groupParams.groupBy.length;
-  const result = [];
-  deepMap.topDownKeys().reduce((acc, key) => {
-    if (key.length === groupByLength) {
-      const items = deepMap.get(key).items;
-      acc.push(...items);
+var debugFullLazyLoad = dbg("DataSource:fullLazyLoad");
+function onPropChange(params, props, actions) {
+  const { name, newValue } = params;
+  if (name === "data" && typeof newValue === "function" && !props.groupRowsState) {
+    if (props.fullLazyLoad) {
+      debugFullLazyLoad(`"data" function prop has changed`);
+    }
+    if (props.collapseGroupRowsOnDataFunctionChange !== false) {
+      actions.groupRowsState = new GroupRowsState({
+        collapsedRows: true,
+        expandedRows: []
+      });
     }
-    return acc;
-  }, result);
-  return result;
-}
-function getEnhancedGroupData(options, deepMapValue) {
-  const { groupBy, groupKeys, collapsed, parents, reducers } = options;
-  const groupNesting = groupKeys.length;
-  const { items: groupItems, reducerResults, pivotDeepMap } = deepMapValue;
-  let data = null;
-  if (Object.keys(reducerResults).length > 0) {
-    data = {};
-    for (let key in reducers)
-      if (reducers.hasOwnProperty(key)) {
-        const reducer = reducers[key];
-        const field = reducer.field;
-        if (field) {
-          data[field] = reducerResults[key];
-        }
-      }
   }
-  const enhancedGroupData = {
-    data,
-    groupCount: groupItems.length,
-    groupData: groupItems,
-    groupKeys,
-    id: groupKeys,
-    collapsed,
-    parents,
-    collapsedChildrenCount: 0,
-    collapsedGroupsCount: 0,
-    indexInParentGroups: options.indexInParentGroups,
-    indexInGroup: options.indexInGroup,
-    indexInAll: options.indexInAll,
-    value: groupKeys[groupKeys.length - 1],
-    groupBy: groupBy.slice(0, groupNesting),
-    isGroupRow: true,
-    pivotValuesMap: pivotDeepMap,
-    groupNesting,
-    reducerResults
-  };
-  return enhancedGroupData;
 }
-function completeReducers(reducers, reducerResults, items) {
-  if (reducers) {
-    for (let key in reducers)
-      if (reducers.hasOwnProperty(key)) {
-        const reducer = reducers[key];
-        if (reducer.done) {
-          reducerResults[key] = reducer.done(reducerResults[key], items);
-        }
+var debugDataParams = dbg("DataSource:dataParams");
+function getInterceptActions() {
+  return {
+    sortInfo: (sortInfo, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state, {
+        sortInfo,
+        livePaginationCursor: null
+      });
+      actions.dataParams = dataParams;
+      if (state.livePagination) {
+        requestAnimationFrame(() => {
+          actions.livePaginationCursor = null;
+        });
       }
-  }
-  return reducerResults;
-}
-function enhancedFlatten(param) {
-  const {
-    groupResult,
-    toPrimaryKey,
-    groupRowsState,
-    generateGroupRows,
-    reducers = {}
-  } = param;
-  const { groupParams, deepMap, pivot } = groupResult;
-  const { groupBy } = groupParams;
-  const groupByStrings = groupBy.map((g) => g.field);
-  const result = [];
-  const parents = [];
-  const indexInParentGroups = [];
-  deepMap.visitDepthFirst((deepMapValue, groupKeys, indexInGroup, next) => {
-    var _a;
-    const items = deepMapValue.items;
-    const groupNesting = groupKeys.length;
-    const collapsed = (_a = groupRowsState == null ? void 0 : groupRowsState.isGroupRowCollapsed(groupKeys)) != null ? _a : false;
-    const enhancedGroupData = getEnhancedGroupData({
-      groupBy: groupByStrings,
-      parents: Array.from(parents),
-      reducers,
-      indexInGroup,
-      indexInParentGroups: Array.from(indexInParentGroups),
-      indexInAll: result.length,
-      groupKeys,
-      collapsed
-    }, deepMapValue);
-    const include = generateGroupRows || collapsed;
-    if (include) {
-      result.push(enhancedGroupData);
-    }
-    if (collapsed) {
-      parents.forEach((parent) => {
-        parent.collapsedChildrenCount += enhancedGroupData.groupCount;
-        parent.collapsedGroupsCount += 1;
+    },
+    groupBy: (groupBy, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state, {
+        groupBy,
+        livePaginationCursor: null
       });
-    }
-    indexInParentGroups.push(indexInGroup);
-    parents.push(enhancedGroupData);
-    if (!collapsed) {
-      if (!next) {
-        if (!pivot) {
-          const startIndex = result.length;
-          result.push(...items.map((item, index) => {
-            return {
-              id: toPrimaryKey(item),
-              data: item,
-              isGroupRow: false,
-              collapsed: false,
-              groupKeys,
-              parents: Array.from(parents),
-              indexInParentGroups: [...indexInParentGroups, index],
-              indexInGroup: index,
-              indexInAll: startIndex + index,
-              groupBy: groupByStrings,
-              groupNesting,
-              groupCount: enhancedGroupData.groupCount
-            };
-          }));
-        }
-      } else {
-        next();
+      actions.dataParams = dataParams;
+      if (state.livePagination) {
+        requestAnimationFrame(() => {
+          actions.livePaginationCursor = null;
+        });
+      }
+    },
+    pivotBy: (pivotBy, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state, {
+        pivotBy,
+        livePaginationCursor: null
+      });
+      actions.dataParams = dataParams;
+      if (state.livePagination) {
+        requestAnimationFrame(() => {
+          actions.livePaginationCursor = null;
+        });
+      }
+    },
+    cursorId: (cursorId, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state, {
+        cursorId
+      });
+      actions.dataParams = dataParams;
+    },
+    livePaginationCursor: (livePaginationCursor, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state, {
+        livePaginationCursor
+      });
+      actions.dataParams = dataParams;
+    },
+    dataParams: (dataParams, { state }) => {
+      if (shallowEqualObjects(dataParams, state.dataParams, new Set([
+        "changes",
+        "originalDataArray"
+      ]))) {
+        return false;
       }
+      debugDataParams("onDataParamsChange triggered because the following values have changed", dataParams == null ? void 0 : dataParams.changes);
+      return true;
     }
-    parents.pop();
-    indexInParentGroups.pop();
-  });
-  return {
-    data: result
   };
 }
 
 // src/utils/groupAndPivot/getPivotColumnsAndColumnGroups.ts
 function prepareColumn(column) {
   const { pivotByAtIndex: pivotByForColumn } = column;
-  if (pivotByForColumn.column) {
+  if (pivotByForColumn == null ? void 0 : pivotByForColumn.column) {
     if (typeof pivotByForColumn.column === "function") {
       Object.assign(column, pivotByForColumn.column({ column }));
     } else {
@@ -3331,7 +3702,7 @@ function prepareColumn(column) {
 }
 function prepareColumnGroup(columnGroup) {
   const { pivotByAtIndex: pivotByForColumnGroup } = columnGroup;
-  if (pivotByForColumnGroup.columnGroup) {
+  if (pivotByForColumnGroup == null ? void 0 : pivotByForColumnGroup.columnGroup) {
     if (typeof pivotByForColumnGroup.columnGroup === "function") {
       Object.assign(columnGroup, pivotByForColumnGroup.columnGroup({ columnGroup }));
     } else {
@@ -3360,6 +3731,9 @@ function getPivotColumnsAndColumnGroups({
         valueGetter: (params) => {
           var _a;
           const { rowInfo } = params;
+          if (!rowInfo.data) {
+            return "Loading ...";
+          }
           return rowInfo.groupKeys ? rowInfo.groupKeys[((_a = rowInfo.groupKeys) == null ? void 0 : _a.length) - 1] : null;
         }
       }
@@ -3391,7 +3765,7 @@ function getPivotColumnsAndColumnGroups({
         }));
       }
       aggregationReducers.forEach((reducer, index) => {
-        const header = isSingleAggregationColumn ? keys[keys.length - 1] : reducer.id;
+        const header = isSingleAggregationColumn ? keys[keys.length - 1] : reducer.name || reducer.id;
         const computedPivotColumn = prepareColumn({
           pivotBy,
           pivotColumn: true,
@@ -3410,7 +3784,7 @@ function getPivotColumnsAndColumnGroups({
             return (_b = (_a = rowInfo.pivotValuesMap) == null ? void 0 : _a.get(keys)) == null ? void 0 : _b.reducerResults[reducer.id];
           }
         });
-        const columnId = `${keys.join("/")}-${reducer.id}`;
+        const columnId = `${reducer.id}:${keys.join("/")}`;
         columns.set(columnId, computedPivotColumn);
       });
     } else {
@@ -3443,7 +3817,7 @@ function getPivotColumnsAndColumnGroups({
           }));
         }
         aggregationReducers.forEach((reducer, index) => {
-          const header = isSingleAggregationColumn ? `${keys[keys.length - 1]} total ` : `${reducer.id} total`;
+          const header = isSingleAggregationColumn ? `${keys[keys.length - 1]} total ` : `${reducer.name || reducer.id} total`;
           const computedPivotColumn = prepareColumn({
             columnGroup: columnGroupId,
             header,
@@ -3462,7 +3836,7 @@ function getPivotColumnsAndColumnGroups({
               return (_b = (_a = rowInfo.pivotValuesMap) == null ? void 0 : _a.get(keys)) == null ? void 0 : _b.reducerResults[reducer.id];
             }
           });
-          columns.set(`total:${keys.join("/")}-${reducer.id}`, computedPivotColumn);
+          columns.set(`total:${reducer.id}:${keys.join("/")}`, computedPivotColumn);
         });
       }
     }
@@ -3471,15 +3845,22 @@ function getPivotColumnsAndColumnGroups({
     }
   });
   if (columns.size === 1) {
-    columns.set("single", {
-      header: "Reduced",
-      pivotBy,
-      pivotColumn: true,
-      valueGetter: ({ rowInfo }) => {
-        var _a;
-        const key = Object.keys(rowInfo.reducerResults || {})[0];
-        return (_a = rowInfo.reducerResults) == null ? void 0 : _a[key];
-      }
+    aggregationReducers.forEach((reducer, index) => {
+      columns.set(`total:${reducer.id}`, prepareColumn({
+        header: `${reducer.name || reducer.id} total`,
+        pivotBy,
+        pivotColumn: true,
+        pivotTotalColumn: true,
+        pivotAggregator: reducer,
+        pivotAggregatorIndex: index,
+        pivotGroupKeys: [],
+        pivotGroupKey: "",
+        pivotIndex: -1,
+        valueGetter: ({ rowInfo }) => {
+          var _a;
+          return (_a = rowInfo.reducerResults) == null ? void 0 : _a[reducer.id];
+        }
+      }));
     });
   }
   const result = {
@@ -3516,10 +3897,11 @@ function concludeReducer(params) {
   const { state, previousState } = params;
   const sortInfo = state.sortInfo;
   const shouldSort = !!(sortInfo == null ? void 0 : sortInfo.length) && !state.controlledSort;
-  const sortDepsChanged = haveDepsChanged(previousState, state, [
-    "originalDataArray",
-    "sortInfo"
+  const originalDataArrayChanged = haveDepsChanged(previousState, state, [
+    "originalDataArray"
   ]);
+  const sortInfoChanged = haveDepsChanged(previousState, state, ["sortInfo"]);
+  const sortDepsChanged = originalDataArrayChanged || sortInfoChanged;
   const shouldSortAgain = shouldSort && (sortDepsChanged || !state.lastSortDataArray);
   const groupBy = state.groupBy;
   const pivotBy = state.pivotBy;
@@ -3527,6 +3909,8 @@ function concludeReducer(params) {
   const groupsDepsChanged = haveDepsChanged(previousState, state, [
     "generateGroupRows",
     "originalDataArray",
+    "originalLazyGroupData",
+    "originalLazyGroupDataChangeDetect",
     "groupBy",
     "groupRowsState",
     "pivotBy",
@@ -3551,7 +3935,12 @@ function concludeReducer(params) {
   };
   if (shouldGroup) {
     if (shouldGroupAgain) {
-      const groupResult = group({
+      const groupResult = state.fullLazyLoad ? lazyGroup({
+        groupBy,
+        pivot: pivotBy,
+        mappings: state.pivotMappings,
+        reducers: state.aggregationReducers
+      }, state.originalLazyGroupData) : group({
         groupBy,
         pivot: pivotBy,
         reducers: state.aggregationReducers
@@ -3619,6 +4008,7 @@ var DataSourceRoot = getComponentStateRoot({
   forwardProps: forwardProps3,
   concludeReducer,
   mapPropsToState: mapPropsToState2,
+  onPropChange,
   interceptActions: getInterceptActions()
 });
 function DataSourceCmp({ children }) {
@@ -3649,17 +4039,23 @@ function DataSource(props) {
 // src/components/InfiniteTable/hooks/useToggleGroupRow.ts
 function useToggleGroupRow() {
   const { getState: getDataSourceState, componentActions: dataSourceActions } = useDataSourceContextValue();
-  const toggleGroupRow = (0, import_react17.useCallback)((groupKeys) => {
-    const newState = new GroupRowsState(getDataSourceState().groupRowsState);
+  const toggleGroupRow = (0, import_react16.useCallback)((groupKeys) => {
+    const state = getDataSourceState();
+    const newState = new GroupRowsState(state.groupRowsState);
     newState.toggleGroupRow(groupKeys);
     dataSourceActions.groupRowsState = newState;
+    if (state.fullLazyLoad && newState.isGroupRowExpanded(groupKeys)) {
+      loadData(state.data, state, dataSourceActions, {
+        groupKeys
+      });
+    }
   }, []);
   return toggleGroupRow;
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
 function useGroupByMap(groupBy) {
-  const groupByMap = (0, import_react18.useMemo)(() => {
+  const groupByMap = (0, import_react17.useMemo)(() => {
     return groupBy.reduce((acc, groupBy2, index) => {
       acc.set(groupBy2.field, {
         groupBy: groupBy2,
@@ -3679,10 +4075,10 @@ function useColumnsWhen() {
     componentState: { groupRenderStrategy, pivotTotalColumnPosition }
   } = useComponentState();
   const groupByMap = useGroupByMap(groupBy);
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     dataSourceActions.generateGroupRows = groupRenderStrategy !== "inline";
   }, [groupRenderStrategy]);
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     dataSourceActions.pivotTotalColumnPosition = pivotTotalColumnPosition;
   }, [pivotTotalColumnPosition]);
   useColumnsWhenInlineGroupRenderStrategy(groupByMap);
@@ -3745,7 +4141,7 @@ function useColumnsWhenInlineGroupRenderStrategy(groupByMap) {
     });
     return computedColumns.size === 0 ? void 0 : computedColumns;
   }
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     const update = () => {
       componentActions.columnsWhenInlineGroupRenderStrategy = computeColumnsWhenInlineGroupRenderStrategy(columns, groupByMap, groupRenderStrategy, toggleGroupRow);
     };
@@ -3771,7 +4167,7 @@ function useColumnsWhenPivoting() {
     }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     const computedPivotColumns = getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, {
       pivotColumn,
       pivotRowLabelsColumn,
@@ -3792,7 +4188,7 @@ function useColumnsWhenGrouping() {
     componentState: { columns, groupColumn, groupRenderStrategy, pivotColumns }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     if (pivotColumns) {
       return;
     }
@@ -3829,7 +4225,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
       groupRenderStrategy
     }
   } = useComponentState();
-  (0, import_react18.useEffect)(() => {
+  (0, import_react17.useEffect)(() => {
     if (groupRenderStrategy !== "multi-column") {
       return;
     }
@@ -3847,7 +4243,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
     const currentState = getComponentState();
     const { computedColumns } = currentState;
     let updated = false;
-    const columnVisibility = new Map(currentState.columnVisibility);
+    const columnVisibility = __spreadValues({}, currentState.columnVisibility);
     const cols = computedColumns;
     groupBy.forEach(({ field, column: groupColumn }, index) => {
       const colId = (groupColumn == null ? void 0 : groupColumn.id) || `group-by-${field}`;
@@ -3858,9 +4254,9 @@ function useHideEmptyGroupColumns(groupRowsMap) {
       const shouldBeHidden = index > expandedGroupsLevel && hideEmptyGroupColumns;
       updated = true;
       if (shouldBeHidden) {
-        columnVisibility.set(colId, false);
+        columnVisibility[colId] = false;
       } else {
-        columnVisibility.delete(colId);
+        delete columnVisibility[colId];
       }
     });
     if (updated) {
@@ -3935,7 +4331,7 @@ function useComputed() {
     bodySize,
     showSeparatePivotColumnForSingleAggregation
   } = componentState;
-  (0, import_react19.useState)(() => {
+  (0, import_react18.useState)(() => {
     componentState.onRowHeightCSSVarChange.onChange((rowHeight) => {
       if (rowHeight) {
         componentActions.rowHeight = rowHeight;
@@ -3947,19 +4343,16 @@ function useComputed() {
       }
     });
   });
-  (0, import_react19.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     dataSourceActions.showSeparatePivotColumnForSingleAggregation = showSeparatePivotColumnForSingleAggregation;
   }, [showSeparatePivotColumnForSingleAggregation]);
   const { multiSort } = dataSourceState;
   useColumnGroups();
   useColumnsWhen();
-  const setSortInfo = (0, import_react19.useCallback)((sortInfo) => {
+  const setSortInfo = (0, import_react18.useCallback)((sortInfo) => {
     var _a2;
     const newSortInfo = multiSort ? sortInfo : (_a2 = sortInfo[0]) != null ? _a2 : null;
     dataSourceActions.sortInfo = newSortInfo;
-    if (getDataSourceState().livePagination) {
-      dataSourceActions.livePaginationCursor = null;
-    }
   }, [getDataSourceState]);
   const columns = componentState.computedColumns;
   const {
@@ -4116,20 +4509,20 @@ var HeaderWrapperCls = "_12zfob1v _16lm1iw16 _16lm1iw1 _16lm1iwj _16lm1iw10";
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeader.tsx
 var React17 = __toModule(require("react"));
-var import_react27 = __toModule(require("react"));
+var import_react26 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderCell.tsx
 var React13 = __toModule(require("react"));
-var import_react23 = __toModule(require("react"));
+var import_react22 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
 var React11 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useInfiniteTableState.ts
-var import_react20 = __toModule(require("react"));
+var import_react19 = __toModule(require("react"));
 var useInfiniteTableState = () => {
   const TableContext2 = getInfiniteTableContext();
-  const { componentState } = (0, import_react20.useContext)(TableContext2);
+  const { componentState } = (0, import_react19.useContext)(TableContext2);
   return componentState;
 };
 
@@ -4195,7 +4588,7 @@ var InfiniteTableCell = React11.memo(InfiniteTableCellFn);
 
 // src/components/InfiniteTable/hooks/useColumnPointerEvents.ts
 var import_binary_search = __toModule(require_binary_search());
-var import_react21 = __toModule(require("react"));
+var import_react20 = __toModule(require("react"));
 
 // src/components/InfiniteTable/utils/moveXatY.ts
 var moveXatY = (arr, dragIndex, dropIndex) => {
@@ -4229,18 +4622,18 @@ var useColumnPointerEvents = ({
   columns,
   computedRemainingSpace
 }) => {
-  const [draggingDiff, setDraggingDiff] = (0, import_react21.useState)(null);
-  const [proxyOffset, setProxyOffset] = (0, import_react21.useState)(null);
-  const breakpointsRef = (0, import_react21.useRef)([]);
-  const pointerMoveRef = (0, import_react21.useRef)(null);
-  const didDragRef = (0, import_react21.useRef)(false);
-  const initialClientPos = (0, import_react21.useRef)(null);
-  const currentDropIndexRef = (0, import_react21.useRef)(null);
+  const [draggingDiff, setDraggingDiff] = (0, import_react20.useState)(null);
+  const [proxyOffset, setProxyOffset] = (0, import_react20.useState)(null);
+  const breakpointsRef = (0, import_react20.useRef)([]);
+  const pointerMoveRef = (0, import_react20.useRef)(null);
+  const didDragRef = (0, import_react20.useRef)(false);
+  const initialClientPos = (0, import_react20.useRef)(null);
+  const currentDropIndexRef = (0, import_react20.useRef)(null);
   const dragging = draggingDiff != null;
   const { componentActions, computed } = useInfiniteTable();
   const { computedColumnOrder } = computed;
-  const column = (0, import_react21.useMemo)(() => columns.get(columnId), [columnId, columns]);
-  const { columnIndex, columnWidth, columnsArray } = (0, import_react21.useMemo)(() => {
+  const column = (0, import_react20.useMemo)(() => columns.get(columnId), [columnId, columns]);
+  const { columnIndex, columnWidth, columnsArray } = (0, import_react20.useMemo)(() => {
     const columnsArray2 = Array.from(columns.values());
     return {
       columnsArray: columnsArray2,
@@ -4248,8 +4641,8 @@ var useColumnPointerEvents = ({
       columnWidth: column.computedWidth
     };
   }, [columns, columnId, column]);
-  let cursorRef = (0, import_react21.useRef)("auto");
-  const onPointerDown = (0, import_react21.useCallback)((e) => {
+  let cursorRef = (0, import_react20.useRef)("auto");
+  const onPointerDown = (0, import_react20.useCallback)((e) => {
     const target = domRef.current;
     cursorRef.current = target.style.cursor;
     didDragRef.current = false;
@@ -4312,7 +4705,7 @@ var useColumnPointerEvents = ({
     target.addEventListener("pointermove", onPointerMove);
     target.setPointerCapture(e.pointerId);
   }, [columns, column, columnIndex, columnsArray, computedRemainingSpace]);
-  const onPointerUp = (0, import_react21.useCallback)((e) => {
+  const onPointerUp = (0, import_react20.useCallback)((e) => {
     const target = domRef.current;
     target.style.cursor = cursorRef.current;
     target.releasePointerCapture(e.pointerId);
@@ -4387,7 +4780,7 @@ var import_react_dom = __toModule(require("react-dom"));
 
 // src/components/InfiniteTable/components/icons/SortIcon.tsx
 var React12 = __toModule(require("react"));
-var import_react22 = __toModule(require("react"));
+var import_react21 = __toModule(require("react"));
 var defaultLineStyle = {
   marginTop: 2,
   marginBottom: 2,
@@ -4395,8 +4788,8 @@ var defaultLineStyle = {
 };
 function SortIcon(props) {
   var _a;
-  const [rendered, setRendered] = (0, import_react22.useState)(true);
-  const [opacity, setOpacity] = (0, import_react22.useState)(0);
+  const [rendered, setRendered] = (0, import_react21.useState)(true);
+  const [opacity, setOpacity] = (0, import_react21.useState)(0);
   const { direction, lineWidth = 1, style, className, index } = props;
   const showIndex = index != null && index > 0;
   const size = (_a = props.size) != null ? _a : 16;
@@ -4410,7 +4803,7 @@ function SortIcon(props) {
   }), props.lineStyle), {
     opacity
   });
-  (0, import_react22.useEffect)(() => {
+  (0, import_react21.useEffect)(() => {
     const newOpacity = direction != 0 ? 1 : 0;
     if (!rendered && newOpacity) {
       setRendered(true);
@@ -4487,8 +4880,8 @@ function InfiniteTableHeaderCell(props) {
     className: `${baseCls}__sort-icon ${HeaderSortIconCls}`,
     direction: column.computedSorted ? column.computedSortedAsc ? 1 : -1 : 0
   });
-  const domRef = (0, import_react23.useRef)(null);
-  const ref = (0, import_react23.useCallback)((node) => {
+  const domRef = (0, import_react22.useRef)(null);
+  const ref = (0, import_react22.useCallback)((node) => {
     var _a2;
     domRef.current = node;
     (_a2 = props.domRef) == null ? void 0 : _a2.call(props, node);
@@ -4497,7 +4890,7 @@ function InfiniteTableHeaderCell(props) {
     computed: { computedRemainingSpace },
     componentState: { portalDOMRef }
   } = useInfiniteTable();
-  (0, import_react23.useEffect)(() => {
+  (0, import_react22.useEffect)(() => {
     let clearOnResize = null;
     const node = domRef.current;
     if (onResize && node) {
@@ -4550,14 +4943,14 @@ function InfiniteTableHeaderCell(props) {
 
 // src/components/RawList/index.tsx
 var React16 = __toModule(require("react"));
-var import_react26 = __toModule(require("react"));
+var import_react25 = __toModule(require("react"));
 
 // src/components/RawList/AvoidReactDiff.tsx
 var React14 = __toModule(require("react"));
-var import_react24 = __toModule(require("react"));
+var import_react23 = __toModule(require("react"));
 function AvoidReactDiffFn(props) {
-  const [children, setChildren] = (0, import_react24.useState)(props.updater.get());
-  (0, import_react24.useLayoutEffect)(() => {
+  const [children, setChildren] = (0, import_react23.useState)(props.updater.get());
+  (0, import_react23.useLayoutEffect)(() => {
     const remove = props.updater.onChange((children2) => {
       setChildren(children2);
     });
@@ -4568,7 +4961,7 @@ function AvoidReactDiffFn(props) {
 var AvoidReactDiff = React14.memo(AvoidReactDiffFn);
 
 // src/components/RawList/useVirtualRenderer.ts
-var import_react25 = __toModule(require("react"));
+var import_react24 = __toModule(require("react"));
 
 // src/components/RawList/ReactVirtualRenderer.tsx
 var React15 = __toModule(require("react"));
@@ -4882,7 +5275,7 @@ function createRenderer(brain) {
 function useVirtualRenderer({
   brain
 }) {
-  return (0, import_react25.useMemo)(() => {
+  return (0, import_react24.useMemo)(() => {
     return createRenderer(brain);
   }, [brain]);
 }
@@ -4895,7 +5288,7 @@ function RawListFn(props) {
     debugChannel
   });
   const getRenderItem = useLatest(renderItem);
-  (0, import_react26.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     const renderRange = brain.getRenderRange();
     renderer.renderRange(renderRange, {
       renderItem,
@@ -4903,7 +5296,7 @@ function RawListFn(props) {
       onRender: onRenderUpdater
     });
   }, [brain, renderItem, onRenderUpdater]);
-  (0, import_react26.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     const remove = brain.onRenderRangeChange((renderRange) => {
       renderer.renderRange(renderRange, {
         force: false,
@@ -4920,7 +5313,7 @@ function RawListFn(props) {
 var RawList = React16.memo(RawListFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeader.tsx
-var debug4 = dbg("Header");
+var debug3 = dbg("Header");
 var { rootClassName: rootClassName4 } = internalProps;
 var TableHeaderClassName = `${rootClassName4}Header`;
 function InfiniteTableHeaderFn(props) {
@@ -4930,11 +5323,11 @@ function InfiniteTableHeaderFn(props) {
     componentState: { headerHeight }
   } = useInfiniteTable();
   const { computedVisibleColumnsMap } = computed;
-  const renderColumn = (0, import_react27.useCallback)(({ domRef: domRef2, itemIndex: columnIndex }) => {
+  const renderColumn = (0, import_react26.useCallback)(({ domRef: domRef2, itemIndex: columnIndex }) => {
     const column = columns[columnIndex];
     if (!column) {
       if (true) {
-        debug4("Cannot find column to render at ", columnIndex);
+        debug3("Cannot find column to render at ", columnIndex);
       }
       return null;
     }
@@ -4945,14 +5338,14 @@ function InfiniteTableHeaderFn(props) {
       columns: computedVisibleColumnsMap
     });
   }, [computedVisibleColumnsMap, columns, repaintId, headerHeight]);
-  (0, import_react27.useEffect)(() => {
+  (0, import_react26.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       domRef.current.style.transform = `translate3d(-${scrollPosition.scrollLeft}px, 0px, 0px)`;
     };
     const removeOnScroll = brain.onScroll(onScroll);
     return removeOnScroll;
   }, [brain]);
-  const domRef = (0, import_react27.useRef)(null);
+  const domRef = (0, import_react26.useRef)(null);
   const headerCls = HeaderClsRecipe({
     pinned: pinning,
     overflow: false,
@@ -5144,7 +5537,7 @@ function renderColumnHeaderGroups(config) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderUnvirtualized.tsx
-var import_react28 = __toModule(require("react"));
+var import_react27 = __toModule(require("react"));
 var { rootClassName: rootClassName5 } = internalProps;
 var TableHeaderClassName2 = `${rootClassName5}Header`;
 var UPDATE_SCROLL = (node, scrollPosition) => {
@@ -5210,7 +5603,7 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
   if (totalWidth != null) {
     style.width = availableWidth;
   }
-  (0, import_react28.useEffect)(() => {
+  (0, import_react27.useEffect)(() => {
     const scroller = brain || scrollListener;
     if (!scroller || !scrollable) {
       return;
@@ -5264,6 +5657,9 @@ function TableHeaderWrapper(props) {
   const hasPinnedStart = computedPinnedStartColumns.length > 0;
   const hasPinnedEnd = computedPinnedEndColumns.length > 0;
   const height = columnGroupsMaxDepth ? columnGroupsMaxDepth * headerHeight : headerHeight;
+  const unvirtualizedStyle = !virtualizeHeader && computedPinnedStartColumnsWidth ? {
+    left: computedPinnedStartWidth
+  } : void 0;
   const header = virtualizeHeader ? /* @__PURE__ */ React21.createElement(InfiniteTableHeader, {
     columns: computedUnpinnedColumns,
     repaintId: virtualizeHeader ? repaintId : void 0,
@@ -5278,6 +5674,7 @@ function TableHeaderWrapper(props) {
     availableWidth: computedUnpinnedColumnsWidth,
     totalWidth: computedUnpinnedColumnsWidth
   }) : /* @__PURE__ */ React21.createElement(InfiniteTableHeaderUnvirtualized, {
+    style: unvirtualizedStyle,
     brain,
     scrollable: true,
     pinning: false,
@@ -5324,12 +5721,12 @@ function TableHeaderWrapper(props) {
 
 // src/components/VirtualScrollContainer/index.tsx
 var React22 = __toModule(require("react"));
-var import_react30 = __toModule(require("react"));
+var import_react29 = __toModule(require("react"));
 
 // src/components/hooks/useOnScroll.ts
-var import_react29 = __toModule(require("react"));
+var import_react28 = __toModule(require("react"));
 var useOnScroll = (domRef, onScroll) => {
-  (0, import_react29.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     const domNode = domRef == null ? void 0 : domRef.current;
     const scrollFn = (event) => {
       const node = event.target;
@@ -5375,7 +5772,7 @@ var VirtualScrollContainer = React22.forwardRef(function VirtualScrollContainer2
     className,
     style
   } = props;
-  const domRef = ref != null ? ref : (0, import_react30.useRef)(null);
+  const domRef = ref != null ? ref : (0, import_react29.useRef)(null);
   useOnScroll(domRef, onContainerScroll);
   return /* @__PURE__ */ React22.createElement("div", {
     ref: domRef,
@@ -5410,14 +5807,14 @@ var import_react41 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useUnpinnedRendering.tsx
 var React29 = __toModule(require("react"));
-var import_react34 = __toModule(require("react"));
+var import_react33 = __toModule(require("react"));
 
 // src/components/VirtualList/VirtualRowList.tsx
 var React25 = __toModule(require("react"));
 
 // src/components/VirtualList/VirtualList.tsx
 var React24 = __toModule(require("react"));
-var import_react31 = __toModule(require("react"));
+var import_react30 = __toModule(require("react"));
 
 // src/components/VirtualList/VirtualList.css.ts
 var VirtualListCls = "_16lm1iw1 _16lm1iw8 _16lm1iw0";
@@ -5428,7 +5825,7 @@ var scrollTransformTargetCls = "mlx2t3";
 var UPDATE_SCROLL2 = (node, scrollPosition) => {
   node.style.transform = `translate3d(${-scrollPosition.scrollLeft}px, ${-scrollPosition.scrollTop}px, 0px)`;
 };
-var debug5 = dbg("VirtuaList");
+var debug4 = dbg("VirtuaList");
 var rootClassName7 = "InfiniteList";
 var VirtualList = (props) => {
   const _a = props, {
@@ -5460,15 +5857,15 @@ var VirtualList = (props) => {
     "onContainerScroll",
     "children"
   ]);
-  const domRef = (0, import_react31.useRef)(null);
+  const domRef = (0, import_react30.useRef)(null);
   const [, rerender] = useRerender();
-  const [totalSize, setTotalSize] = (0, import_react31.useState)(0);
-  const renderCountRef = (0, import_react31.useRef)(0);
-  (0, import_react31.useEffect)(() => {
+  const [totalSize, setTotalSize] = (0, import_react30.useState)(0);
+  const renderCountRef = (0, import_react30.useRef)(0);
+  (0, import_react30.useEffect)(() => {
     const removeOnRenderCount = virtualBrain.onRenderCountChange((renderCount) => {
       renderCountRef.current = renderCount;
       if (true) {
-        debug5.extend(mainAxis)(`Render count change ${renderCount}`);
+        debug4.extend(mainAxis)(`Render count change ${renderCount}`);
       }
       rerender();
     });
@@ -5483,7 +5880,7 @@ var VirtualList = (props) => {
       removeOnTotalSizeChange();
     };
   }, [virtualBrain]);
-  (0, import_react31.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       UPDATE_SCROLL2(domRef.current, scrollPosition);
     };
@@ -5537,7 +5934,7 @@ var VirtualRowList = (props) => {
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRow.tsx
 var React27 = __toModule(require("react"));
-var import_react33 = __toModule(require("react"));
+var import_react32 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableColumnCell.tsx
 var React26 = __toModule(require("react"));
@@ -5565,6 +5962,9 @@ function InfiniteTableColumnCellFn(props) {
   }
   const { data, isGroupRow, groupBy } = rowInfo;
   const groupRowInfo = null;
+  if (rowInfo.indexInAll === 0 && column.groupByField && column.groupByField === "stack") {
+    debugger;
+  }
   let value = isGroupRow && groupBy && column.groupByField ? rowInfo.value : isColumnWithField(column) ? data == null ? void 0 : data[column.field] : null;
   if (column.valueGetter) {
     value = column.valueGetter(isGroupRow ? {
@@ -5647,7 +6047,7 @@ function InfiniteTableColumnCellFn(props) {
 var InfiniteTableColumnCell = React26.memo(InfiniteTableColumnCellFn);
 
 // src/components/InfiniteTable/components/InfiniteTableRow/useRowDOMProps.ts
-var import_react32 = __toModule(require("react"));
+var import_react31 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRowClassName.ts
 var { rootClassName: rootClassName9 } = internalProps;
@@ -5672,8 +6072,8 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
     domRef: domRefFromProps,
     rowInfo
   } = props;
-  const domRef = (0, import_react32.useRef)(null);
-  const rowDOMRef = (0, import_react32.useCallback)((node) => {
+  const domRef = (0, import_react31.useRef)(null);
+  const rowDOMRef = (0, import_react31.useCallback)((node) => {
     domRefFromProps(node);
     domRef.current = node;
   }, []);
@@ -5704,7 +6104,7 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
   }), `${InfiniteTableRowClassName}--${rowInfo.isGroupRow ? "group" : "normal"}-row`, inlineGroupRoot ? `${InfiniteTableRowClassName}--inline-group-row` : "", showZebraRows ? `${InfiniteTableRowClassName}--${odd ? "odd" : "even"}` : null, showHoverRows ? `${InfiniteTableRowClassName}--show-hover` : null, domProps == null ? void 0 : domProps.className, rowProps == null ? void 0 : rowProps.className, rowComputedClassName);
   const initialMouseEnter = rowProps == null ? void 0 : rowProps.onMouseEnter;
   const initialMouseLeave = rowProps == null ? void 0 : rowProps.onMouseLeave;
-  const onMouseEnter = (0, import_react32.useCallback)((event) => {
+  const onMouseEnter = (0, import_react31.useCallback)((event) => {
     var _a;
     initialMouseEnter == null ? void 0 : initialMouseEnter(event);
     const rowIndex2 = ((_a = event.currentTarget) == null ? void 0 : _a.dataset.rowIndex) * 1;
@@ -5718,7 +6118,7 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
     const rows = parentNode.querySelectorAll(hoverSelector.join(","));
     rows.forEach((row) => row.classList.add(InfiniteTableRowClassName__hover, RowHoverCls));
   }, [initialMouseEnter, showHoverRows]);
-  const onMouseLeave = (0, import_react32.useCallback)((event) => {
+  const onMouseLeave = (0, import_react31.useCallback)((event) => {
     var _a;
     initialMouseLeave == null ? void 0 : initialMouseLeave(event);
     const rowIndex2 = (_a = event.currentTarget) == null ? void 0 : _a.dataset.rowIndex;
@@ -5774,7 +6174,7 @@ function InfiniteTableRowFn(props) {
     width: rowWidth,
     height: rowHeight
   }, domProps.style);
-  const renderCellRef = (0, import_react33.useRef)(null);
+  const renderCellRef = (0, import_react32.useRef)(null);
   const renderCell = React27.useCallback(({ domRef, itemIndex }) => {
     const column = columns[itemIndex];
     if (!column) {
@@ -5878,7 +6278,7 @@ function useUnpinnedRendering(params) {
   } = params;
   const { virtualizeColumns } = getState();
   const shouldVirtualizeColumns = typeof virtualizeColumns === "function" ? virtualizeColumns(computedUnpinnedColumns) : virtualizeColumns != null ? virtualizeColumns : true;
-  const renderRowUnpinned = (0, import_react34.useCallback)((rowParams) => {
+  const renderRowUnpinned = (0, import_react33.useCallback)((rowParams) => {
     const dataArray = getData();
     const rowInfo = dataArray[rowParams.rowIndex];
     const { showZebraRows, showHoverRows } = getState();
@@ -5944,7 +6344,7 @@ function useUnpinnedRendering(params) {
 }
 
 // src/components/InfiniteTable/hooks/useOnContainerScroll.ts
-var import_react35 = __toModule(require("react"));
+var import_react34 = __toModule(require("react"));
 
 // src/components/InfiniteTable/InfiniteCls.css.ts
 var import_createRuntimeFn5 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
@@ -5957,7 +6357,6 @@ var PinnedRowsClsVariants = { pinnedStart: "_1yeub2ve", pinnedEnd: "_1yeub2vf",
 var PinnedRowsContainerClsVariants = (0, import_createRuntimeFn5.createRuntimeFn)({ defaultClassName: "", variantClassNames: { pinned: { start: "_1yeub2vh", end: "_1yeub2vi", false: "_1yeub2vj" } }, defaultVariants: {}, compoundVariants: [] });
 
 // src/components/InfiniteTable/hooks/useOnContainerScroll.ts
-var DELAY = 200;
 var TableClassName = internalProps.rootClassName;
 var TableClassName__Scrolling = `${TableClassName}--scrolling`;
 var SCROLL_BOTTOM_OFFSET = 1;
@@ -5968,23 +6367,33 @@ var useOnContainerScroll = ({
 }) => {
   const {
     componentState: {
+      scrollStopDelay,
       scrollerDOMRef,
       domRef,
       scrollToBottomOffset,
       onScrollToBottom,
       onScrollToTop,
+      onScrollStop: onScrollStopFromProps,
       bodySize
     }
   } = useInfiniteTable();
-  const { componentActions: dataSourceActions, getState: getDataSourceState } = useDataSourceContextValue();
-  const timeoutIdRef = (0, import_react35.useRef)(0);
-  const scrollingRef = (0, import_react35.useRef)(false);
-  const scrollTopMaxRef = (0, import_react35.useRef)(0);
-  (0, import_react35.useEffect)(() => {
+  const {
+    componentActions: dataSourceActions,
+    getState: getDataSourceState,
+    componentState: { notifyScrollStop }
+  } = useDataSourceContextValue();
+  const onScrollStop = (0, import_react34.useCallback)((param) => {
+    onScrollStopFromProps == null ? void 0 : onScrollStopFromProps(param);
+    notifyScrollStop(param);
+  }, [onScrollStopFromProps, notifyScrollStop]);
+  const timeoutIdRef = (0, import_react34.useRef)(0);
+  const scrollingRef = (0, import_react34.useRef)(false);
+  const scrollTopMaxRef = (0, import_react34.useRef)(0);
+  (0, import_react34.useEffect)(() => {
     const { current: node } = scrollerDOMRef;
     scrollTopMaxRef.current = node.scrollHeight - node.clientHeight;
   }, [reservedContentHeight, bodySize.height]);
-  const setScrolling = (0, import_react35.useCallback)((scrolling) => {
+  const setScrolling = (0, import_react34.useCallback)((scrolling) => {
     var _a;
     const prevScrolling = scrollingRef.current;
     scrollingRef.current = scrolling;
@@ -5995,9 +6404,17 @@ var useOnContainerScroll = ({
       timeoutIdRef.current = setTimeout(() => {
         setScrolling(false);
         timeoutIdRef.current = 0;
-      }, DELAY);
+      }, scrollStopDelay);
     }
     if (prevScrolling !== scrolling) {
+      if (!scrolling) {
+        const range = verticalVirtualBrain.getRenderRange();
+        onScrollStop({
+          scrollTop: scrollPositionRef.current.scrollTop,
+          firstVisibleRowIndex: range.renderStartIndex,
+          lastVisibleRowIndex: range.renderEndIndex
+        });
+      }
       const classList = (_a = domRef.current) == null ? void 0 : _a.classList;
       if (!classList) {
         return;
@@ -6008,8 +6425,8 @@ var useOnContainerScroll = ({
         classList.remove(InfiniteClsScrolling, TableClassName__Scrolling);
       }
     }
-  }, []);
-  const onContainerScroll = (0, import_react35.useCallback)((scrollInfo) => {
+  }, [scrollStopDelay, onScrollStop]);
+  const onContainerScroll = (0, import_react34.useCallback)((scrollInfo) => {
     verticalVirtualBrain.setScrollPosition(scrollInfo);
     horizontalVirtualBrain.setScrollPosition(scrollInfo);
     setScrolling(true);
@@ -6019,15 +6436,15 @@ var useOnContainerScroll = ({
     domRef.current,
     setScrolling
   ]);
-  const scrollPositionRef = (0, import_react35.useRef)({
+  const scrollPositionRef = (0, import_react34.useRef)({
     scrollLeft: 0,
     scrollTop: 0
   });
-  const applyScrollHorizontal = (0, import_react35.useCallback)(({ scrollLeft }) => {
+  const applyScrollHorizontal = (0, import_react34.useCallback)(({ scrollLeft }) => {
     scrollPositionRef.current.scrollLeft = scrollLeft;
     onContainerScroll(scrollPositionRef.current);
   }, [onContainerScroll]);
-  const applyScrollVertical = (0, import_react35.useCallback)(({ scrollTop }) => {
+  const applyScrollVertical = (0, import_react34.useCallback)(({ scrollTop }) => {
     scrollPositionRef.current.scrollTop = scrollTop;
     onContainerScroll(scrollPositionRef.current);
     if (scrollTop === 0) {
@@ -6038,7 +6455,7 @@ var useOnContainerScroll = ({
     if (isScrollBottom) {
       onScrollToBottom == null ? void 0 : onScrollToBottom();
       if (getDataSourceState().livePagination) {
-        dataSourceActions.scrollBottomId = Date.now();
+        dataSourceActions.cursorId = Date.now();
       }
     }
   }, [onContainerScroll, scrollToBottomOffset, onScrollToBottom, onScrollToTop]);
@@ -6050,16 +6467,16 @@ var useOnContainerScroll = ({
 
 // src/components/InfiniteTable/hooks/usePinnedRendering.tsx
 var React31 = __toModule(require("react"));
-var import_react38 = __toModule(require("react"));
+var import_react37 = __toModule(require("react"));
 
 // src/components/VirtualList/RowListWithExternalScrolling.tsx
 var React30 = __toModule(require("react"));
-var import_react37 = __toModule(require("react"));
+var import_react36 = __toModule(require("react"));
 
 // src/components/hooks/useOnMount.ts
-var import_react36 = __toModule(require("react"));
+var import_react35 = __toModule(require("react"));
 function useOnMount(domRef, props) {
-  (0, import_react36.useEffect)(() => {
+  (0, import_react35.useEffect)(() => {
     const { onMount, onUnmount } = props;
     const node = domRef == null ? void 0 : domRef.current;
     onMount == null ? void 0 : onMount(node);
@@ -6090,8 +6507,8 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   } = props;
-  const domRef = (0, import_react37.useRef)(null);
-  const renderItem = (0, import_react37.useCallback)((renderProps) => renderRow({
+  const domRef = (0, import_react36.useRef)(null);
+  const renderItem = (0, import_react36.useCallback)((renderProps) => renderRow({
     domRef: renderProps.domRef,
     rowHeight: renderProps.itemSize,
     rowIndex: renderProps.itemIndex
@@ -6100,7 +6517,7 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   });
-  (0, import_react37.useEffect)(() => {
+  (0, import_react36.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       const node = domRef.current;
       if (node) {
@@ -6167,7 +6584,7 @@ function PinnedRowsContainer(props) {
     }
     return result;
   }, [height, rowWidth, pinning, hasOverflow]);
-  const updateScroll = (0, import_react38.useCallback)((node, scrollPosition) => {
+  const updateScroll = (0, import_react37.useCallback)((node, scrollPosition) => {
     UPDATE_SCROLL3(node, scrollPosition, hasOverflow ? pinnedScrollListener.getScrollPosition() : void 0);
   }, [hasOverflow, pinnedScrollListener]);
   const rowListProps = {
@@ -6209,7 +6626,7 @@ function PinnedRowsContainer(props) {
 }
 function useRenderPinnedRow(params) {
   const { getData, getState, columnsWidth, columns, verticalBrain } = params;
-  const renderPinnedRow = (0, import_react38.useCallback)((rowParams) => {
+  const renderPinnedRow = (0, import_react37.useCallback)((rowParams) => {
     const dataArray = getData();
     const rowInfo = dataArray[rowParams.rowIndex];
     const { showZebraRows, showHoverRows } = getState();
@@ -6325,6 +6742,15 @@ function usePinnedStartRendering(params) {
 // src/components/InfiniteTable/hooks/useYourBrain.ts
 var import_react40 = __toModule(require("react"));
 
+// src/components/hooks/useOnce.ts
+var import_react38 = __toModule(require("react"));
+function useOnce(fn) {
+  const onceFn = (0, import_react38.useMemo)(() => {
+    return once(fn);
+  }, []);
+  return onceFn();
+}
+
 // src/components/VirtualBrain/index.ts
 var import_binary_search2 = __toModule(require_binary_search());
 var initialScrollPosition2 = {
@@ -7215,7 +7641,7 @@ var useLicense = (licenseKey = "") => {
   const valid = (0, import_react43.useMemo)(() => {
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "0.1.2"
+      version: "0.2.1"
     });
     if (!licenseKey && !valid2 && isInsideSandbox) {
       return true;
@@ -7229,7 +7655,7 @@ var useLicense = (licenseKey = "") => {
 var React33 = __toModule(require("react"));
 var import_react44 = __toModule(require("react"));
 var error = err("CSSVariableWatch");
-var debug6 = dbg("CSSVariableWatch");
+var debug5 = dbg("CSSVariableWatch");
 var WRAPPER_STYLE = {
   position: "absolute",
   pointerEvents: "none",
@@ -7252,7 +7678,7 @@ var useCSSVariableWatch = (params) => {
     const value = params.ref.current.getBoundingClientRect().height;
     if (value) {
       lastValueRef.current = value;
-      debug6(`Variable ${params.varName} found and equals ${value}.`);
+      debug5(`Variable ${params.varName} found and equals ${value}.`);
       params.onChange(value);
     } else {
       error(`Specified variable ${params.varName} not found or does not have a numeric value.`);
@@ -7410,7 +7836,8 @@ var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
   } = useInfiniteTable();
   const {
     componentState: { dataArray, loading },
-    getState: getDataSourceState
+    getState: getDataSourceState,
+    componentActions: dataSourceActions
   } = useDataSourceContextValue();
   const {
     domRef,
@@ -7423,7 +7850,8 @@ var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
     onHeaderHeightCSSVarChange,
     rowHeightCSSVar,
     headerHeightCSSVar,
-    components
+    components,
+    scrollStopDelay
   } = componentState;
   const { columnShifts, bodySize } = componentState;
   const {
@@ -7436,6 +7864,7 @@ var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
     scrollbars,
     applyScrollVertical,
     horizontalVirtualBrain,
+    verticalVirtualBrain,
     reservedContentHeight
   } = useListRendering({
     getComputed,
@@ -7444,6 +7873,13 @@ var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
     bodySize,
     computed
   });
+  React35.useEffect(() => {
+    const dataSourceState = getDataSourceState();
+    const onChange = debounce((renderRange) => {
+      dataSourceState.notifyRenderRangeChange(renderRange);
+    }, { wait: scrollStopDelay });
+    return verticalVirtualBrain.onRenderRangeChange(onChange);
+  }, [verticalVirtualBrain, scrollStopDelay]);
   const licenseValid = useLicense(licenseKey);
   const domProps = useDOMProps(componentState.domProps);
   const LoadMaskCmp = (_a = components == null ? void 0 : components.LoadMask) != null ? _a : LoadMask;
@@ -7456,6 +7892,9 @@ var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
     }
     notifyScrollbarsChange(scrollbars);
   }, [scrollbars]);
+  React35.useEffect(() => {
+    dataSourceActions.scrollStopDelayUpdatedByTable = scrollStopDelay;
+  }, [scrollStopDelay]);
   return /* @__PURE__ */ React35.createElement("div", __spreadValues({
     ref: domRef
   }, domProps), header ? /* @__PURE__ */ React35.createElement(TableHeaderWrapper, {