@infinite-table/infinite-react 0.0.8 → 0.1.1

package/index.esm.js

@@ -48,26 +48,6 @@ var __reExport = (target, module, desc) => {
 var __toModule = (module) => {
   return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
 };
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // node_modules/ms/index.js
 var require_ms = __commonJS({
@@ -636,44 +616,13 @@ var require_binary_search = __commonJS({
   }
 });
 
-// node_modules/decamelize/index.js
-var require_decamelize = __commonJS({
-  "node_modules/decamelize/index.js"(exports, module) {
-    "use strict";
-    var handlePreserveConsecutiveUppercase = (decamelized, separator) => {
-      decamelized = decamelized.replace(/((?<![\p{Uppercase_Letter}\d])[\p{Uppercase_Letter}\d](?![\p{Uppercase_Letter}\d]))/gu, ($0) => {
-        return $0.toLowerCase();
-      });
-      return decamelized.replace(/(\p{Uppercase_Letter}+)(\p{Uppercase_Letter}\p{Lowercase_Letter}+)/gu, (_, $1, $2) => {
-        return $1 + separator + $2.toLowerCase();
-      });
-    };
-    module.exports = (text, {
-      separator = "_",
-      preserveConsecutiveUppercase = false
-    } = {}) => {
-      if (!(typeof text === "string" && typeof separator === "string")) {
-        throw new TypeError("The `text` and `separator` arguments should be of type `string`");
-      }
-      if (text.length < 2) {
-        return preserveConsecutiveUppercase ? text : text.toLowerCase();
-      }
-      const replacement = `$1${separator}$2`;
-      const decamelized = text.replace(/([\p{Lowercase_Letter}\d])(\p{Uppercase_Letter})/gu, replacement);
-      if (preserveConsecutiveUppercase) {
-        return handlePreserveConsecutiveUppercase(decamelized, separator);
-      }
-      return decamelized.replace(/(\p{Uppercase_Letter})(\p{Uppercase_Letter}\p{Lowercase_Letter}+)/gu, replacement).toLowerCase();
-    };
-  }
-});
-
 // src/components/InfiniteTable/index.tsx
 import {
   StrictMode,
   createElement as createElement33,
   memo as memo13,
-  useEffect as useEffect22
+  useEffect as useEffect24,
+  useLayoutEffect as useLayoutEffect6
 } from "react";
 
 // src/components/InfiniteTable/internalProps.ts
@@ -754,9 +703,20 @@ var ScrollListener = class {
   }
 };
 
+// src/components/InfiniteTable/utils/toMap.ts
+function toMap(mapOrObject) {
+  if (!mapOrObject) {
+    return new Map();
+  }
+  if (mapOrObject instanceof Map) {
+    return mapOrObject;
+  }
+  return new Map(Object.entries(mapOrObject));
+}
+
 // src/components/InfiniteTable/state/computeColumnGroupsDepths.ts
 function computeColumnGroupsDepths(columnGroups) {
-  const map = new Map();
+  const map2 = new Map();
   columnGroups.forEach((colGroup, colGroupId) => {
     let parentGroupId = colGroup.columnGroup;
     let depth = 0;
@@ -771,20 +731,14 @@ function computeColumnGroupsDepths(columnGroups) {
       depth++;
       parentGroupId = parent.columnGroup;
     }
-    map.set(colGroupId, depth);
+    map2.set(colGroupId, depth);
   });
-  return map;
+  return map2;
 }
 
 // src/components/InfiniteTable/state/getInitialState.ts
-function toMap(mapOrObject) {
-  if (!mapOrObject) {
-    return new Map();
-  }
-  if (mapOrObject instanceof Map) {
-    return mapOrObject;
-  }
-  return new Map(Object.entries(mapOrObject));
+function toColumnTypesMap(mapOrObject) {
+  return toMap(mapOrObject);
 }
 function initSetupState() {
   const columnsGeneratedForGrouping = new Map();
@@ -819,6 +773,7 @@ var forwardProps = () => {
       var _a;
       return (_a = toMap(columns)) != null ? _a : new Map();
     },
+    scrollTopId: 1,
     components: 1,
     loadingText: 1,
     pivotColumns: 1,
@@ -844,12 +799,14 @@ var forwardProps = () => {
     pivotColumn: 1,
     pivotRowLabelsColumn: 1,
     pivotColumnGroups: 1,
+    onScrollbarsChange: 1,
     viewportReservedWidth: (viewportReservedWidth) => viewportReservedWidth != null ? viewportReservedWidth : 0,
     activeIndex: (activeIndex) => activeIndex != null ? activeIndex : 0,
     columnMinWidth: (columnMinWidth) => columnMinWidth != null ? columnMinWidth : 30,
     columnMaxWidth: (columnMaxWidth) => columnMaxWidth != null ? columnMaxWidth : 2e3,
     columnDefaultWidth: (columnDefaultWidth) => columnDefaultWidth != null ? columnDefaultWidth : 200,
     draggableColumns: (draggableColumns) => draggableColumns != null ? draggableColumns : true,
+    showSeparatePivotColumnForSingleAggregation: (showSeparatePivotColumnForSingleAggregation) => showSeparatePivotColumnForSingleAggregation != null ? showSeparatePivotColumnForSingleAggregation : false,
     sortable: (sortable) => sortable != null ? sortable : true,
     hideEmptyGroupColumns: (hideEmptyGroupColumns) => hideEmptyGroupColumns != null ? hideEmptyGroupColumns : false,
     pivotTotalColumnPosition: (pivotTotalColumnPosition) => pivotTotalColumnPosition != null ? pivotTotalColumnPosition : "end",
@@ -861,7 +818,10 @@ var forwardProps = () => {
     virtualizeColumns: (virtualizeColumns) => virtualizeColumns != null ? virtualizeColumns : true,
     rowHeight: (rowHeight) => typeof rowHeight === "number" ? rowHeight : 0,
     headerHeight: (headerHeight) => typeof headerHeight === "number" ? headerHeight : 0,
-    columnVisibility: (columnVisibility) => columnVisibility != null ? columnVisibility : new Map(),
+    columnVisibility: (columnVisibility) => {
+      var _a;
+      return (_a = toMap(columnVisibility)) != null ? _a : new Map();
+    },
     columnPinning: (columnPinning) => columnPinning != null ? columnPinning : new Map(),
     columnSizing: (columnSizing) => {
       var _a;
@@ -869,23 +829,22 @@ var forwardProps = () => {
     },
     columnTypes: (columnTypes) => {
       var _a;
-      return (_a = toMap(columnTypes)) != null ? _a : new Map();
+      return (_a = toColumnTypesMap(columnTypes)) != null ? _a : new Map();
     },
-    columnAggregations: (columnAggregations) => columnAggregations != null ? columnAggregations : new Map(),
     collapsedColumnGroups: (collapsedColumnGroups) => collapsedColumnGroups != null ? collapsedColumnGroups : new Map(),
     columnGroups: (columnGroups) => columnGroups != null ? columnGroups : new Map()
   };
 };
 function getGroupRenderStrategy(options) {
-  const { groupRowsBy, groupColumn, groupRenderStrategy } = options;
+  const { groupBy, groupColumn, groupRenderStrategy } = options;
   if (groupRenderStrategy) {
     return groupRenderStrategy;
   }
   if (groupColumn != null && typeof groupColumn === "object") {
     return "single-column";
   }
-  const columnsInGroupRowsBy = groupRowsBy.filter((g) => g.column);
-  if (columnsInGroupRowsBy.length) {
+  const columnsInGroupBy = groupBy.filter((g) => g.column);
+  if (columnsInGroupBy.length) {
     return "multi-column";
   }
   return "multi-column";
@@ -896,16 +855,17 @@ var mapPropsToState = (params) => {
   const computedColumnGroups = state.pivotColumnGroups || state.columnGroups;
   const virtualizeHeader = header && virtualizeColumns && (!computedColumnGroups || (computedColumnGroups == null ? void 0 : computedColumnGroups.size) === 0);
   const columnGroupsDepthsMap = state.columnGroups && state.columnGroups != (oldState == null ? void 0 : oldState.columnGroups) || state.pivotColumnGroups && state.pivotColumnGroups != (oldState == null ? void 0 : oldState.pivotColumnGroups) ? computeColumnGroupsDepths(computedColumnGroups) : state.columnGroupsDepthsMap;
-  const groupRowsBy = parentState == null ? void 0 : parentState.groupRowsBy;
+  const groupBy = parentState == null ? void 0 : parentState.groupBy;
   const groupRenderStrategy = getGroupRenderStrategy({
     groupRenderStrategy: props.groupRenderStrategy,
-    groupRowsBy,
+    groupBy,
     groupColumn: props.groupColumn
   });
+  const computedColumns = state.computedPivotColumns || state.columnsWhenGrouping || state.columnsWhenInlineGroupRenderStrategy || state.columns;
   return {
     groupRenderStrategy,
-    groupRowsBy,
-    computedColumns: state.computedPivotColumns || state.columnsWhenGrouping || state.columnsWhenInlineGroupRenderStrategy || state.columns,
+    groupBy,
+    computedColumns,
     virtualizeHeader,
     columnGroupsDepthsMap,
     columnGroupsMaxDepth: columnGroupsDepthsMap != state.columnGroupsDepthsMap ? Math.max(...columnGroupsDepthsMap.values(), 0) : state.columnGroupsMaxDepth,
@@ -1317,8 +1277,8 @@ var getComputedVisibleColumns = ({
       const colTypeSizing = {
         minWidth: colType == null ? void 0 : colType.minWidth,
         maxWidth: colType == null ? void 0 : colType.maxWidth,
-        width: colType == null ? void 0 : colType.width,
-        flex: colType == null ? void 0 : colType.flex
+        width: colType == null ? void 0 : colType.defaultWidth,
+        flex: colType == null ? void 0 : colType.defaultFlex
       };
       let colSizing = columnSizing.get(colId) || {};
       if (colSizing.width != null) {
@@ -1371,7 +1331,7 @@ var getComputedVisibleColumns = ({
   });
   const firstPinnedEndAbsoluteOffset = bodySize.width - totalPinnedEndWidth;
   columnsArray.forEach((c, i) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const id = visibleColumnOrder[i];
     const nextColumnId = visibleColumnOrder[i + 1];
     const colType = getColumnComputedType(c, columnTypes);
@@ -1432,6 +1392,7 @@ var getComputedVisibleColumns = ({
     const result2 = __spreadProps(__spreadValues({
       align: colType.align,
       verticalAlign: colType.verticalAlign,
+      valueGetter: colType.valueGetter,
       renderValue: colType.renderValue,
       render: colType.render
     }, c), {
@@ -1439,7 +1400,7 @@ var getComputedVisibleColumns = ({
       computedAbsoluteOffset,
       computedPinningOffset,
       computedOffset,
-      computedSortable: (_e = (_d = c.sortable) != null ? _d : sortable) != null ? _e : true,
+      computedSortable: (_f = (_e = (_d = c.sortable) != null ? _d : colType.sortable) != null ? _e : sortable) != null ? _f : true,
       computedSortInfo,
       computedSortIndex,
       computedMultiSort: multiSort,
@@ -1448,14 +1409,14 @@ var getComputedVisibleColumns = ({
       computedSortedDesc,
       computedVisibleIndex: i,
       computedPinned,
-      computedDraggable: (_g = (_f = c.draggable) != null ? _f : draggableColumns) != null ? _g : true,
+      computedDraggable: (_h = (_g = c.draggable) != null ? _g : draggableColumns) != null ? _h : true,
       computedFirstInCategory,
       computedLastInCategory,
       computedFirst: i === 0,
       computedLast,
       toggleSort,
       id,
-      header: (_i = (_h = c.header) != null ? _h : c.name) != null ? _i : c.field
+      header: (_k = (_j = (_i = c.header) != null ? _i : colType.header) != null ? _j : c.name) != null ? _k : c.field
     });
     computedOffset += computedWidth;
     computedVisibleColumnsMap.set(result2.id, result2);
@@ -1512,28 +1473,28 @@ var useRerender = () => {
 
 // src/components/hooks/useInterceptedMap.ts
 import { useEffect as useEffect2 } from "react";
-function interceptMap(map, fns) {
-  const { set, delete: deleteKey, clear } = map;
+function interceptMap(map2, fns) {
+  const { set, delete: deleteKey, clear } = map2;
   if (fns.set) {
-    map.set = (key, value) => {
-      set.call(map, key, value);
+    map2.set = (key, value) => {
+      set.call(map2, key, value);
       fns.set(key, value);
-      return map;
+      return map2;
     };
   }
   if (fns.delete) {
-    map.delete = (key) => {
-      const removed = deleteKey.call(map, key);
+    map2.delete = (key) => {
+      const removed = deleteKey.call(map2, key);
       fns.delete(key);
       return removed;
     };
   }
   if (fns.clear || fns.beforeClear) {
-    map.clear = () => {
+    map2.clear = () => {
       if (fns.beforeClear) {
-        fns.beforeClear(map);
+        fns.beforeClear(map2);
       }
-      const result = clear.call(map);
+      const result = clear.call(map2);
       if (fns.clear) {
         fns.clear();
       }
@@ -1542,13 +1503,13 @@ function interceptMap(map, fns) {
   }
   return () => {
     if (set) {
-      map.set = set;
+      map2.set = set;
     }
     if (deleteKey) {
-      map.delete = deleteKey;
+      map2.delete = deleteKey;
     }
     if (clear) {
-      map.clear = clear;
+      map2.clear = clear;
     }
   };
 }
@@ -1568,16 +1529,16 @@ var rafFn = (fn) => {
 };
 
 // src/components/InfiniteTable/hooks/useRerenderOnKeyChange.ts
-var useRerenderOnKeyChange = (map) => {
+var useRerenderOnKeyChange = (map2) => {
   const [renderId, rerender] = useRerender();
   useEffect3(() => {
     const update = rafFn(rerender);
-    return interceptMap(map, {
+    return interceptMap(map2, {
       set: update,
       clear: update,
       delete: update
     });
-  }, [map]);
+  }, [map2]);
   return renderId;
 };
 
@@ -1691,48 +1652,17 @@ var useComputedVisibleColumns = ({
 var sortAscending = (a, b) => a - b;
 
 // src/components/InfiniteTable/hooks/useComputed.ts
-import { useCallback as useCallback5, useState as useState4 } from "react";
-
-// src/components/InfiniteTable/hooks/useColumnAggregations.ts
-import { useEffect as useEffect5 } from "react";
-
-// src/components/DataSource/publicHooks/useDataSourceActions.ts
-import {
-  useContext as useContext2
-} from "react";
-
-// src/components/DataSource/DataSourceContext.ts
-import {
-  createContext as createContext2
-} from "react";
-var DSContext;
-function getDataSourceContext() {
-  if (DSContext) {
-    return DSContext;
-  }
-  return DSContext = createContext2({
-    getState: () => null,
-    componentState: null,
-    componentActions: null
-  });
-}
-
-// src/components/DataSource/publicHooks/useDataSourceActions.ts
-function useDataSourceActions() {
-  const DataSourceContext = getDataSourceContext();
-  const contextValue = useContext2(DataSourceContext);
-  return contextValue.componentActions;
-}
+import { useCallback as useCallback5, useEffect as useEffect10, useState as useState5 } from "react";
 
 // src/components/hooks/useComponentState.tsx
 import {
   createElement as createElement2,
   memo,
-  useContext as useContext3
+  useContext as useContext2
 } from "react";
 import {
   useReducer,
-  createContext as createContext3,
+  createContext as createContext2,
   useMemo as useMemo3,
   useEffect as useEffect4,
   useState as useState2,
@@ -1812,9 +1742,9 @@ function getComponentStateContext() {
   if (ComponentContext) {
     return ComponentContext;
   }
-  return ComponentContext = createContext3(null);
+  return ComponentContext = createContext2(null);
 }
-function getReducerActions(dispatch, getState, getProps, propsToForward, allowedControlledPropOverrides) {
+function getReducerGeneratedActions(dispatch, getState, getProps, propsToForward, allowedControlledPropOverrides, interceptedActions) {
   const state = getState();
   return Object.keys(state).reduce((actions, stateKey) => {
     const key = stateKey;
@@ -1826,6 +1756,9 @@ function getReducerActions(dispatch, getState, getProps, propsToForward, allowed
         return;
       }
       notifyChange(props, stateKey, value);
+      if (interceptedActions && typeof interceptedActions[key] === "function") {
+        interceptedActions[key](value, { actions, state: state2 });
+      }
       const forwardFn = propsToForward[key];
       if (typeof forwardFn === "function") {
         value = forwardFn(value);
@@ -1938,7 +1871,7 @@ function getComponentStateRoot(config) {
     const getComponentState = useLatest(state);
     const { allowedControlledPropOverrides } = config;
     const actions = useMemo3(() => {
-      const generatedActions = getReducerActions(dispatch, getComponentState, getProps, propsToForward, allowedControlledPropOverrides);
+      const generatedActions = getReducerGeneratedActions(dispatch, getComponentState, getProps, propsToForward, allowedControlledPropOverrides, config.interceptActions);
       return generatedActions;
     }, [
       dispatch,
@@ -1968,7 +1901,7 @@ function getComponentStateRoot(config) {
         if (oldValue === newValue) {
           continue;
         }
-        if (isControlled(key, props)) {
+        if (isControlled(key, props) || isControlled(key, prevProps)) {
           if (propsToForward.hasOwnProperty(k)) {
             let valueToSet = newValue;
             const forwardFn = propsToForward[k];
@@ -2005,56 +1938,44 @@ function getComponentStateRoot(config) {
 }
 function useComponentState() {
   const Context = getComponentStateContext();
-  return useContext3(Context);
-}
-
-// src/components/InfiniteTable/hooks/useColumnAggregations.ts
-function useColumnAggregations() {
-  const {
-    componentState: { columnAggregations },
-    getComponentState
-  } = useComponentState();
-  const dataSourceActions = useDataSourceActions();
-  useEffect5(() => {
-    function updateDataSourceAggregations() {
-      const reducers = [];
-      const componentState = getComponentState();
-      columnAggregations.forEach((aggregator, key) => {
-        var _a;
-        const colField = (_a = componentState.computedColumns.get(key)) == null ? void 0 : _a.field;
-        const newAggregator = __spreadValues({
-          getter: (data) => colField ? data[colField] : data
-        }, aggregator);
-        reducers.push(newAggregator);
-      });
-      dataSourceActions.aggregationReducers = reducers;
-    }
-    updateDataSourceAggregations();
-    return interceptMap(columnAggregations, {
-      clear: updateDataSourceAggregations,
-      delete: updateDataSourceAggregations,
-      set: updateDataSourceAggregations
-    });
-  }, [columnAggregations]);
+  return useContext2(Context);
 }
 
 // src/components/DataSource/publicHooks/useDataSource.ts
 import {
-  useContext as useContext4
+  useContext as useContext3
 } from "react";
+
+// src/components/DataSource/DataSourceContext.ts
+import {
+  createContext as createContext3
+} from "react";
+var DSContext;
+function getDataSourceContext() {
+  if (DSContext) {
+    return DSContext;
+  }
+  return DSContext = createContext3({
+    getState: () => null,
+    componentState: null,
+    componentActions: null
+  });
+}
+
+// src/components/DataSource/publicHooks/useDataSource.ts
 function useDataSource() {
   const DataSourceContext = getDataSourceContext();
-  const contextValue = useContext4(DataSourceContext);
+  const contextValue = useContext3(DataSourceContext);
   return contextValue.componentState;
 }
 function useDataSourceContextValue() {
   const DataSourceContext = getDataSourceContext();
-  const contextValue = useContext4(DataSourceContext);
+  const contextValue = useContext3(DataSourceContext);
   return contextValue;
 }
 
 // src/components/InfiniteTable/hooks/useColumnGroups.ts
-import { useEffect as useEffect6 } from "react";
+import { useEffect as useEffect5 } from "react";
 function useColumnGroups() {
   const {
     componentState: {
@@ -2064,7 +1985,7 @@ function useColumnGroups() {
     componentActions,
     getComponentState
   } = useComponentState();
-  useEffect6(() => {
+  useEffect5(() => {
     const recompute = () => {
       componentActions.columnGroupsDepthsMap = computeColumnGroupsDepths(computedColumnGroups);
     };
@@ -2075,7 +1996,7 @@ function useColumnGroups() {
       set: update
     });
   }, [computedColumnGroups]);
-  useEffect6(() => {
+  useEffect5(() => {
     return interceptMap(collapsedColumnGroups, {
       set: (key, visibleCol) => {
         const colIds = key.slice(1);
@@ -2107,7 +2028,7 @@ function useColumnGroups() {
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
-import { useEffect as useEffect8, useMemo as useMemo5 } from "react";
+import { useEffect as useEffect9, useMemo as useMemo5 } from "react";
 
 // src/components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns.tsx
 import {
@@ -2120,27 +2041,14 @@ var join = (...args) => args.filter((x) => !!`${x}`).join(" ");
 // src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
 import {
   createElement as createElement3,
-  useEffect as useEffect7
+  useEffect as useEffect6
 } from "react";
 import { useState as useState3 } from "react";
 
-// src/components/InfiniteTable/utilities.css.ts
-var alignItems = { center: "_16lm1iw11", stretch: "_16lm1iw12" };
-var cssEllipsisClassName = "_16lm1iw1a _16lm1iw1b _16lm1iw16";
-var cursor = { pointer: "_16lm1iwb" };
-var display = { flex: "_16lm1iwj", block: "_16lm1iwk", inlineBlock: "_16lm1iwl" };
-var fill = { currentColor: "_16lm1iw5", accentColor: "_16lm1iw6" };
-var flex = { "1": "_16lm1iwc", none: "_16lm1iwd" };
-var flexFlow = { column: "_16lm1iwz", row: "_16lm1iw10" };
-var justifyContent = { center: "_16lm1iw13", start: "_16lm1iw14", end: "_16lm1iw15" };
-var left = { "0": "_16lm1iwt", "100%": "_16lm1iwu" };
-var position = { relative: "_16lm1iw1", absolute: "_16lm1iw2", sticky: "_16lm1iw3", fixed: "_16lm1iw4" };
-var top = { "0": "_16lm1iwr", "100%": "_16lm1iws" };
-var transform = { translateZero: "_16lm1iw9", rotate90: "_16lm1iwa" };
-var transformTranslateZero = "_16lm1iw8";
-var userSelect = { none: "_16lm1iwm" };
-var willChange = { transform: "_16lm1iw19" };
-var zIndex = { "1": "_16lm1iwe", "10": "_16lm1iwf", "1000": "_16lm1iwg", "10000": "_16lm1iwh", "100000": "_16lm1iwi" };
+// src/components/InfiniteTable/components/icons/ExpanderIcon.css.ts
+var import_createRuntimeFn = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var ExpanderIconCls = "_16lm1iw6 _16lm1iwd _16lm1iwb";
+var ExpanderIconClsVariants = (0, import_createRuntimeFn.createRuntimeFn)({ defaultClassName: "", variantClassNames: { expanded: { true: "_16lm1iwa", false: "_198z9782" } }, defaultVariants: {}, compoundVariants: [] });
 
 // src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
 function ExpanderIcon(props) {
@@ -2154,7 +2062,7 @@ function ExpanderIcon(props) {
       setExpanded(!expanded);
     }
   };
-  useEffect7(() => {
+  useEffect6(() => {
     if (isControlled("expanded", props)) {
       setExpanded(props.expanded);
     }
@@ -2167,18 +2075,37 @@ function ExpanderIcon(props) {
     width: `${size}px`,
     style: props.style,
     onClick,
-    className: join(props.className, fill.accentColor, flex.none, cursor.pointer, expanded ? fill.accentColor : "", expanded ? transform.rotate90 : "", "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`)
+    className: join(props.className, ExpanderIconCls, ExpanderIconClsVariants({
+      expanded
+    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`)
   }, /* @__PURE__ */ createElement3("path", {
     d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z"
   }));
 }
 
 // src/components/InfiniteTable/components/InfiniteTableRow/row.css.ts
-var import_createRuntimeFn = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn2 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 var GroupRowExpanderCls = "_7pupv0b";
-var RowClsRecipe = (0, import_createRuntimeFn.createRuntimeFn)({ defaultClassName: "_7pupv00", variantClassNames: { zebra: { false: "_7pupv02", even: "_7pupv03", odd: "_7pupv04" }, groupRow: { true: "_7pupv05", false: "_7pupv06" }, inlineGroupRow: { true: "_7pupv07", false: "_7pupv08" }, showHoverRows: { true: "_7pupv09", false: "_7pupv0a" } }, defaultVariants: {}, compoundVariants: [] });
+var RowClsRecipe = (0, import_createRuntimeFn2.createRuntimeFn)({ defaultClassName: "_7pupv00", variantClassNames: { zebra: { false: "_7pupv02", even: "_7pupv03", odd: "_7pupv04" }, groupRow: { true: "_7pupv05", false: "_7pupv06" }, inlineGroupRow: { true: "_7pupv07", false: "_7pupv08" }, showHoverRows: { true: "_7pupv09", false: "_7pupv0a" } }, defaultVariants: {}, compoundVariants: [] });
 var RowHoverCls = "_7pupv01";
 
+// src/components/InfiniteTable/utilities.css.ts
+var alignItems = { center: "_16lm1iw11", stretch: "_16lm1iw12" };
+var cssEllipsisClassName = "_16lm1iw1a _16lm1iw1b _16lm1iw16";
+var cursor = { pointer: "_16lm1iwb" };
+var display = { flex: "_16lm1iwj", block: "_16lm1iwk", inlineBlock: "_16lm1iwl" };
+var flex = { "1": "_16lm1iwc", none: "_16lm1iwd" };
+var flexFlow = { column: "_16lm1iwz", row: "_16lm1iw10" };
+var justifyContent = { center: "_16lm1iw13", start: "_16lm1iw14", end: "_16lm1iw15" };
+var left = { "0": "_16lm1iwt", "100%": "_16lm1iwu" };
+var position = { relative: "_16lm1iw1", absolute: "_16lm1iw2", sticky: "_16lm1iw3", fixed: "_16lm1iw4" };
+var top = { "0": "_16lm1iwr", "100%": "_16lm1iws" };
+var transform = { translateZero: "_16lm1iw9", rotate90: "_16lm1iwa" };
+var transformTranslateZero = "_16lm1iw8";
+var userSelect = { none: "_16lm1iwm" };
+var willChange = { transform: "_16lm1iw19" };
+var zIndex = { "1": "_16lm1iwe", "10": "_16lm1iwf", "1000": "_16lm1iwg", "10000": "_16lm1iwh", "100000": "_16lm1iwi" };
+
 // src/components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns.tsx
 function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params) {
   if (!pivotColumns) {
@@ -2188,7 +2115,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
     pivotColumn,
     pivotRowLabelsColumn,
     pivotBy,
-    groupRowsBy,
+    groupBy,
     pivotTotalColumnPosition,
     toggleGroupRow
   } = params;
@@ -2205,7 +2132,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
           column = __spreadValues(__spreadValues({}, column), pivotColumn({
             column,
             pivotBy,
-            groupRowsBy
+            groupBy
           }));
         } else {
           column = __spreadValues(__spreadValues({}, column), pivotColumn);
@@ -2217,7 +2144,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
           column = __spreadValues(__spreadValues({}, column), pivotRowLabelsColumn({
             column,
             pivotBy,
-            groupRowsBy
+            groupBy
           }));
         } else {
           column = __spreadValues(__spreadValues({}, column), pivotRowLabelsColumn);
@@ -2226,11 +2153,11 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
       if (!column.render) {
         column.render = (renderOptions) => {
           var _a;
-          let { value, rowInfo, column: column2, groupRowsBy: groupRowsBy2 } = renderOptions;
+          let { value, rowInfo, column: column2, groupBy: groupBy2 } = renderOptions;
           if (column2.renderValue) {
             value = column2.renderValue(renderOptions);
           }
-          const showExpanderIcon = (((_a = rowInfo.groupKeys) == null ? void 0 : _a.length) || 0) < groupRowsBy2.length;
+          const showExpanderIcon = (((_a = rowInfo.groupKeys) == null ? void 0 : _a.length) || 0) < groupBy2.length;
           return /* @__PURE__ */ createElement4("div", {
             className: join(display.flex, alignItems.center, GroupRowExpanderCls)
           }, showExpanderIcon ? /* @__PURE__ */ createElement4(ExpanderIcon, {
@@ -2330,7 +2257,7 @@ function getColumnForGroupBy(options, toggleGroupRow, groupColumnFromProps) {
 function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
   let generatedGroupColumn = {
     header: `Group`,
-    groupByField: options.groupRowsBy.map((g) => g.field),
+    groupByField: options.groupBy.map((g) => g.field),
     sortable: false,
     render: (renderOptions) => {
       let { value, rowInfo, column } = renderOptions;
@@ -2371,62 +2298,231 @@ import {
   createElement as createElement6
 } from "react";
 
-// src/components/DataSource/privateHooks/useLoadData.ts
-import { useLayoutEffect as useLayoutEffect3 } from "react";
+// src/utils/multisort/sortTypes.ts
+var numberComparator = function(first, second) {
+  return first - second;
+};
+var stringComparator = function(first, second) {
+  first = `${first}`;
+  second = `${second}`;
+  return first.localeCompare(second);
+};
+var sortTypes = {
+  number: numberComparator,
+  string: stringComparator
+};
+var sortTypes_default = sortTypes;
 
-// src/components/DataSource/privateHooks/buildDataSourceDataInfo.ts
-function buildDataSourceDataInfo(dataParam) {
-  let dataArray = [];
-  if (Array.isArray(dataParam.data)) {
-    dataArray = dataParam.data;
-  } else {
-    dataArray = dataParam;
+// src/utils/multisort/index.ts
+var multisort = (sortInfo, array, get) => {
+  array.sort(getMultisortFunction(sortInfo, get));
+  return array;
+};
+multisort.knownTypes = sortTypes_default;
+var getSingleSortFunction = (info) => {
+  if (!info) {
+    return;
   }
-  return {
-    originalDataArray: dataArray
+  const field = info.field;
+  var dir = info.dir < 0 ? -1 : info.dir > 0 ? 1 : 0;
+  if (!dir) {
+    return;
+  }
+  let fn = info.fn;
+  if (!fn && info.type) {
+    fn = multisort.knownTypes[info.type];
+    if (!fn) {
+      console.warn(`Unknown sort type "${info.type}" - please pass one of ${Object.keys(multisort.knownTypes).join(", ")}`);
+    }
+  }
+  if (!fn) {
+    fn = sortTypes_default.string;
+  }
+  return (first, second) => {
+    const a = field ? first[field] : first;
+    const b = field ? second[field] : second;
+    return dir * fn(a, b);
   };
-}
-
-// src/components/DataSource/privateHooks/loadDataAsync.ts
-function loadDataAsync(data) {
-  return __async(this, null, function* () {
-    if (typeof data === "function") {
-      data = data();
+};
+var getSortFunctions = (sortInfo) => {
+  return sortInfo.map(getSingleSortFunction).filter((fn) => fn instanceof Function);
+};
+var getMultisortFunction = (sortInfo, get) => {
+  const fns = getSortFunctions(sortInfo);
+  return (first, second) => {
+    if (get) {
+      first = get(first);
+      second = get(second);
     }
-    return buildDataSourceDataInfo(yield data);
-  });
+    let result = 0;
+    let i = 0;
+    let fn;
+    const len = fns.length;
+    for (; i < len; i++) {
+      fn = fns[i];
+      if (!fn) {
+        continue;
+      }
+      result = fn(first, second);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return result;
+  };
+};
+
+// src/components/DataSource/privateHooks/useLoadData.ts
+import { useEffect as useEffect8, useLayoutEffect as useLayoutEffect3, useRef as useRef6, useState as useState4 } from "react";
+
+// src/components/hooks/useEffectWithChanges.ts
+import { useEffect as useEffect7, useRef as useRef5 } from "react";
+function useEffectWithChanges(fn, deps) {
+  const prevRef = useRef5({});
+  const oldValuesRef = useRef5({});
+  const oldValues = oldValuesRef.current;
+  const changesRef = useRef5({});
+  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;
+  useEffect7(() => {
+    const changes2 = changesRef.current;
+    const result = fn(changes2, oldValues);
+    changesRef.current = {};
+    oldValuesRef.current = {};
+    return result;
+  }, useEffectDeps);
 }
 
 // src/components/DataSource/privateHooks/useLoadData.ts
-function buildDataSourceInfo(data) {
-  return { originalDataArray: data };
+function buildDataSourceDataParams(componentState) {
+  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;
+  }
+  return dataSourceParams;
+}
+function notifyDataParamsChanged(componentState, actions) {
+  var _a;
+  if (typeof componentState.data === "function") {
+    loadData(componentState.data, componentState, actions);
+  }
+  const dataParams = buildDataSourceDataParams(componentState);
+  (_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();
-  const loadData = (data2) => {
-    let dataSourceInfo = {
-      originalDataArray: []
-    };
-    if (typeof data2 === "function") {
-      data2 = data2();
-    }
-    if (Array.isArray(data2)) {
-      dataSourceInfo = buildDataSourceInfo(data2);
-      actions.originalDataArray = dataSourceInfo.originalDataArray;
-    } else {
-      actions.loading = true;
-      loadDataAsync(data2).then((dataSourceInfo2) => {
-        actions.originalDataArray = dataSourceInfo2.originalDataArray;
-        actions.loading = false;
-      });
-    }
-  };
   useLayoutEffect3(() => {
-    loadData(data);
+    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] = useState4({
+    vertical: false,
+    horizontal: false
+  });
+  const scrollbarsRef = useRef6(scrollbars);
+  useEffect8(() => {
+    notifyScrollbarsChange.onChange((scrollbars2) => {
+      if (!scrollbars2) {
+        return;
+      }
+      scrollbarsRef.current = scrollbars2;
+      setScrollbars(scrollbars2);
+    });
+    return () => notifyScrollbarsChange.destroy();
+  }, [notifyScrollbarsChange]);
+  const [cursorId, updateCursorId] = useState4(void 0);
+  useEffect8(() => {
+    const frameId = requestAnimationFrame(() => {
+      var _a;
+      if (!((_a = scrollbarsRef.current) == null ? void 0 : _a.vertical)) {
+        updateCursorId(livePaginationCursor);
+      }
+    });
+    return () => cancelAnimationFrame(frameId);
+  }, [livePaginationCursor]);
+  useEffect8(() => {
+    const { livePaginationCursor: livePaginationCursor2, livePagination } = getComponentState();
+    if (!scrollbars.vertical && livePagination) {
+      updateCursorId(livePaginationCursor2);
+    }
+  }, [scrollbars.vertical]);
+  useEffect8(() => {
+    updateCursorId(scrollBottomId);
+  }, [scrollBottomId]);
+  const depsObject = {
+    sortInfo,
+    groupBy,
+    pivotBy,
+    cursorId
+  };
+  useEffectWithChanges(() => {
+    if (cursorId === void 0) {
+      return;
+    }
+    notifyDataParamsChanged(getComponentState(), actions);
+  }, depsObject);
 }
 
 // src/components/DataSource/state/normalizeSortInfo.ts
@@ -2480,9 +2576,9 @@ var DeepMap = class {
         if (!pair) {
           return;
         }
-        const { map } = pair;
+        const { map: map2 } = pair;
         const keys = [...parentKeys, key];
-        const next = map ? () => this.visitWithNext(keys, fn, map) : void 0;
+        const next = map2 ? () => this.visitWithNext(keys, fn, map2) : void 0;
         if (pair.hasOwnProperty("value")) {
           fn(pair.value, keys, i, next);
           i++;
@@ -2498,6 +2594,13 @@ var DeepMap = class {
       });
     }
   }
+  static clone(map2) {
+    const clone = new DeepMap();
+    map2.visit((pair, keys) => {
+      clone.set(keys, pair.value);
+    });
+    return clone;
+  }
   set(keys, value) {
     let currentMap = this.map;
     if (!keys.length) {
@@ -2548,14 +2651,14 @@ var DeepMap = class {
     return this.length;
   }
   clear() {
-    const clearMap = (map) => {
-      map.forEach((value, _key) => {
-        const { map: map2 } = value;
-        if (map2) {
-          clearMap(map2);
+    const clearMap = (map2) => {
+      map2.forEach((value, _key) => {
+        const { map: map3 } = value;
+        if (map3) {
+          clearMap(map3);
         }
       });
-      map.clear();
+      map2.clear();
     };
     clearMap(this.map);
     this.length = 0;
@@ -2600,9 +2703,9 @@ var DeepMap = class {
       }
     }
     while (maps.length) {
-      let map = maps.pop();
+      let map2 = maps.pop();
       let key = keys.pop();
-      if (key && (map == null ? void 0 : map.size) === 0) {
+      if (key && (map2 == null ? void 0 : map2.size) === 0) {
         let parentMap = maps[maps.length - 1];
         let pair = parentMap == null ? void 0 : parentMap.get(key);
         if (pair) {
@@ -2641,12 +2744,12 @@ var DeepMap = class {
     if (!pair) {
       return;
     }
-    const { map } = pair;
+    const { map: map2 } = pair;
     const keys = [...parentKeys, key];
     const next = once(() => {
-      if (map) {
-        map.forEach((_, k) => {
-          this.visitKey(k, map, keys, fn);
+      if (map2) {
+        map2.forEach((_, k) => {
+          this.visitKey(k, map2, keys, fn);
         });
       }
     });
@@ -2812,14 +2915,69 @@ var GroupRowsState = class {
   }
 };
 
+// src/utils/shallowEqualObjects.ts
+function shallowEqualObjects(objA, objB) {
+  if (objA === objB) {
+    return true;
+  }
+  if (!objA || !objB) {
+    return false;
+  }
+  var aKeys = Object.keys(objA);
+  var bKeys = Object.keys(objB);
+  var len = aKeys.length;
+  if (bKeys.length !== len) {
+    return false;
+  }
+  for (var i = 0; i < len; i++) {
+    var key = aKeys[i];
+    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/components/utils/discardCallsWithEqualArg.ts
+var map = new WeakMap();
+var getCompareDefault = (a) => a;
+function discardCallsWithEqualArg(fn, timeframe = 50, getCompareObject2) {
+  map.set(fn, {
+    lastCallTime: 0,
+    lastCallArg: null
+  });
+  const getCompare = getCompareObject2 != null ? getCompareObject2 : getCompareDefault;
+  return (arg) => {
+    const { lastCallTime, lastCallArg } = map.get(fn) || {
+      lastCallTime: 0,
+      lastCallArg: null
+    };
+    const now = Date.now();
+    const diff = now - lastCallTime;
+    const objectsEqual = shallowEqualObjects(getCompare(lastCallArg), getCompare(arg));
+    if (diff < timeframe && objectsEqual) {
+      return;
+    }
+    map.set(fn, {
+      lastCallTime: now,
+      lastCallArg: arg
+    });
+    fn(arg);
+  };
+}
+
 // src/components/DataSource/state/getInitialState.ts
 function initSetupState2() {
   const now = Date.now();
   const originalDataArray = [];
   const dataArray = [];
   return {
+    dataParams: void 0,
+    notifyScrollbarsChange: buildSubscriptionCallback(),
     pivotTotalColumnPosition: "end",
     originalDataArray,
+    scrollBottomId: Symbol("scrollBottomId"),
+    showSeparatePivotColumnForSingleAggregation: false,
     pivotColumns: void 0,
     pivotColumnGroups: void 0,
     dataArray,
@@ -2828,7 +2986,6 @@ function initSetupState2() {
     sortedAt: 0,
     reducedAt: now,
     generateGroupRows: true,
-    aggregationReducers: void 0,
     groupDeepMap: void 0,
     postSortDataArray: void 0,
     postGroupDataArray: void 0,
@@ -2836,15 +2993,23 @@ function initSetupState2() {
     lastGroupDataArray: void 0
   };
 }
+function getCompareObject(dataParams) {
+  const obj = __spreadValues({}, dataParams);
+  delete obj.originalDataArray;
+  return obj;
+}
 var forwardProps3 = () => {
   return {
-    remoteCount: 1,
+    onDataParamsChange: (fn) => fn ? discardCallsWithEqualArg(fn, 100, getCompareObject) : void 0,
     data: 1,
     pivotBy: 1,
     primaryKey: 1,
+    livePagination: 1,
+    livePaginationCursor: 1,
+    aggregationReducers: 1,
     loading: (loading) => loading != null ? loading : false,
     sortInfo: (sortInfo) => normalizeSortInfo(sortInfo),
-    groupRowsBy: (groupRowsBy) => groupRowsBy != null ? groupRowsBy : [],
+    groupBy: (groupBy) => groupBy != null ? groupBy : [],
     groupRowsState: (groupRowsState) => {
       return groupRowsState || new GroupRowsState({
         expandedRows: true,
@@ -2854,10 +3019,20 @@ var forwardProps3 = () => {
   };
 };
 function mapPropsToState2(params) {
-  var _a;
   const { props } = params;
+  const controlledSort = isControlledValue(props.sortInfo);
   return {
-    multiSort: Array.isArray((_a = props.sortInfo) != null ? _a : props.defaultSortInfo)
+    controlledSort,
+    multiSort: Array.isArray(controlledSort ? props.sortInfo : props.defaultSortInfo)
+  };
+}
+function getInterceptActions() {
+  return {
+    sortInfo: (sortInfo, { actions, state }) => {
+      const dataParams = buildDataSourceDataParams(state);
+      dataParams.sortInfo = sortInfo;
+      actions.dataParams = dataParams;
+    }
   };
 }
 
@@ -2866,19 +3041,28 @@ function DEFAULT_TO_KEY(value) {
   return value;
 }
 function initReducers(reducers) {
-  if (!reducers || !reducers.length) {
-    return [];
+  if (!reducers || !Object.keys(reducers).length) {
+    return {};
   }
-  return reducers.map((reducer) => reducer.initialValue);
+  const result = {};
+  for (let key in reducers)
+    if (reducers.hasOwnProperty(key)) {
+      result[key] = reducers[key].initialValue;
+    }
+  return result;
 }
 function computeReducersFor(data, reducers, reducerResults) {
-  if (!reducers || !reducers.length) {
+  var _a, _b;
+  if (!reducers || !Object.keys(reducers).length) {
     return;
   }
-  reducers.forEach((reducer, index) => {
-    const currentValue = reducerResults[index];
-    reducerResults[index] = reducer.reducer(currentValue, reducer.getter(data), data);
-  });
+  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 {
@@ -2893,7 +3077,7 @@ function group(groupParams, data) {
   let currentGroupKeys = [];
   let currentPivotKeys = [];
   const initialReducerValue = initReducers(reducers);
-  const globalReducerResults = [...initialReducerValue];
+  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++) {
@@ -2903,7 +3087,7 @@ function group(groupParams, data) {
       if (!deepMap.has(currentGroupKeys)) {
         const deepMapGroupValue = {
           items: [],
-          reducerResults: [...initialReducerValue]
+          reducerResults: __spreadValues({}, initialReducerValue)
         };
         if (pivot) {
           deepMapGroupValue.pivotDeepMap = new DeepMap();
@@ -2927,7 +3111,7 @@ function group(groupParams, data) {
           if (!pivotDeepMap.has(currentPivotKeys)) {
             topLevelPivotColumns.set(currentPivotKeys, true);
             pivotDeepMap == null ? void 0 : pivotDeepMap.set(currentPivotKeys, {
-              reducerResults: [...initialReducerValue],
+              reducerResults: __spreadValues({}, initialReducerValue),
               items: []
             });
           }
@@ -2989,11 +3173,23 @@ function flatten(groupResult) {
   return result;
 }
 function getEnhancedGroupData(options, deepMapValue) {
-  const { groupBy, groupKeys, collapsed, parents } = options;
+  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: null,
+    data,
     groupCount: groupItems.length,
     groupData: groupItems,
     groupKeys,
@@ -3015,17 +3211,25 @@ function getEnhancedGroupData(options, deepMapValue) {
   return enhancedGroupData;
 }
 function completeReducers(reducers, reducerResults, items) {
-  if (reducers && reducers.length) {
-    reducers == null ? void 0 : reducers.forEach((reducer, index) => {
-      if (reducer.done) {
-        reducerResults[index] = reducer.done(reducerResults[index], 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 } = param;
+  const {
+    groupResult,
+    toPrimaryKey,
+    groupRowsState,
+    generateGroupRows,
+    reducers = {}
+  } = param;
   const { groupParams, deepMap, pivot } = groupResult;
   const { groupBy } = groupParams;
   const groupByStrings = groupBy.map((g) => g.field);
@@ -3040,6 +3244,7 @@ function enhancedFlatten(param) {
     const enhancedGroupData = getEnhancedGroupData({
       groupBy: groupByStrings,
       parents: Array.from(parents),
+      reducers,
       indexInGroup,
       indexInParentGroups: Array.from(indexInParentGroups),
       indexInAll: result.length,
@@ -3091,88 +3296,46 @@ function enhancedFlatten(param) {
   };
 }
 
-// src/utils/multisort/sortTypes.ts
-var numberComparator = function(first, second) {
-  return first - second;
-};
-var stringComparator = function(first, second) {
-  first = `${first}`;
-  second = `${second}`;
-  return first.localeCompare(second);
-};
-var sortTypes = {
-  number: numberComparator,
-  string: stringComparator
-};
-var sortTypes_default = sortTypes;
-
-// src/utils/multisort/index.ts
-var multisort = (sortInfo, array, get) => {
-  array.sort(getMultisortFunction(sortInfo, get));
-  return array;
-};
-multisort.knownTypes = sortTypes_default;
-var getSingleSortFunction = (info) => {
-  if (!info) {
-    return;
-  }
-  const field = info.field;
-  var dir = info.dir < 0 ? -1 : info.dir > 0 ? 1 : 0;
-  if (!dir) {
-    return;
-  }
-  let fn = info.fn;
-  if (!fn && info.type) {
-    fn = multisort.knownTypes[info.type];
-    if (!fn) {
-      console.warn(`Unknown sort type "${info.type}" - please pass one of ${Object.keys(multisort.knownTypes).join(", ")}`);
+// src/utils/groupAndPivot/getPivotColumnsAndColumnGroups.ts
+function prepareColumn(column) {
+  const { pivotByAtIndex: pivotByForColumn } = column;
+  if (pivotByForColumn.column) {
+    if (typeof pivotByForColumn.column === "function") {
+      Object.assign(column, pivotByForColumn.column({ column }));
+    } else {
+      Object.assign(column, pivotByForColumn.column);
     }
   }
-  if (!fn) {
-    fn = sortTypes_default.string;
-  }
-  return (first, second) => {
-    const a = field ? first[field] : first;
-    const b = field ? second[field] : second;
-    return dir * fn(a, b);
-  };
-};
-var getSortFunctions = (sortInfo) => {
-  return sortInfo.map(getSingleSortFunction).filter((fn) => fn instanceof Function);
-};
-var getMultisortFunction = (sortInfo, get) => {
-  const fns = getSortFunctions(sortInfo);
-  return (first, second) => {
-    if (get) {
-      first = get(first);
-      second = get(second);
-    }
-    let result = 0;
-    let i = 0;
-    let fn;
-    const len = fns.length;
-    for (; i < len; i++) {
-      fn = fns[i];
-      if (!fn) {
-        continue;
-      }
-      result = fn(first, second);
-      if (result !== 0) {
-        return result;
-      }
+  return column;
+}
+function prepareColumnGroup(columnGroup) {
+  const { pivotByAtIndex: pivotByForColumnGroup } = columnGroup;
+  if (pivotByForColumnGroup.columnGroup) {
+    if (typeof pivotByForColumnGroup.columnGroup === "function") {
+      Object.assign(columnGroup, pivotByForColumnGroup.columnGroup({ columnGroup }));
+    } else {
+      Object.assign(columnGroup, pivotByForColumnGroup.columnGroup);
     }
-    return result;
-  };
-};
-
-// src/utils/groupAndPivot/getPivotColumnsAndColumnGroups.ts
-function getPivotColumnsAndColumnGroups(deepMap, pivotBy, pivotTotalColumnPosition) {
+  }
+  return columnGroup;
+}
+function getPivotColumnsAndColumnGroups({
+  deepMap,
+  pivotBy,
+  pivotTotalColumnPosition,
+  reducers = {},
+  showSeparatePivotColumnForSingleAggregation = false
+}) {
   const pivotLength = pivotBy.length;
+  const aggregationReducers = Object.keys(reducers).map((key) => {
+    return __spreadProps(__spreadValues({}, reducers[key]), { id: key });
+  });
   const columns = new Map([
     [
       "labels",
       {
         header: "Row labels",
+        pivotBy,
         valueGetter: (params) => {
           var _a;
           const { rowInfo } = params;
@@ -3182,72 +3345,104 @@ function getPivotColumnsAndColumnGroups(deepMap, pivotBy, pivotTotalColumnPositi
     ]
   ]);
   const columnGroups = new Map();
+  const isSingleAggregationColumn = !showSeparatePivotColumnForSingleAggregation && aggregationReducers.length === 1;
   deepMap.visitDepthFirst((_value, keys, _indexInGroup, next) => {
     keys = [...keys];
     if (pivotTotalColumnPosition === "end") {
       next == null ? void 0 : next();
     }
     if (keys.length === pivotLength) {
-      const parentKeys = keys.slice(0, -1);
-      let columnGroupId = parentKeys.join("/");
       const pivotByForColumn = pivotBy[keys.length - 1];
-      let computedPivotColumn = __spreadValues({
-        pivotBy,
-        pivotColumn: true,
-        pivotGroupKeys: keys,
-        pivotGroupKeyForColumn: keys[keys.length - 1],
-        pivotIndexForColumn: keys.length - 1,
-        pivotByForColumn,
-        sortable: false,
-        columnGroup: parentKeys.length ? `${columnGroupId}` : void 0,
-        header: keys[keys.length - 1],
-        valueGetter: ({ rowInfo }) => {
-          var _a, _b, _c;
-          const value = (_c = (_b = (_a = rowInfo.pivotValuesMap) == null ? void 0 : _a.get(keys)) == null ? void 0 : _b.reducerResults[0]) != null ? _c : null;
-          return value;
-        }
-      }, pivotByForColumn.column);
-      if (pivotByForColumn.column) {
-        if (typeof pivotByForColumn.column === "function") {
-          Object.assign(computedPivotColumn, pivotByForColumn.column({ column: computedPivotColumn }));
-        } else {
-          Object.assign(computedPivotColumn, pivotByForColumn.column);
-        }
-      }
-      columns.set(`${keys.join("/")}`, computedPivotColumn);
-    } else {
-      const colGroupId = keys.join("/");
       const parentKeys = keys.slice(0, -1);
-      columnGroups.set(colGroupId, {
-        columnGroup: parentKeys.length ? parentKeys.join("/") : void 0,
-        header: keys.join(" >> ")
-      });
-      if (pivotTotalColumnPosition !== false) {
-        const pivotByForColumn = pivotBy[keys.length - 1];
-        let computedPivotColumn = __spreadValues({
-          columnGroup: parentKeys.length ? parentKeys.join("/") : void 0,
-          header: `${keys.join("/")} total `,
-          pivotTotalColumn: true,
+      let parentColumnGroupId = parentKeys.join("/");
+      if (!isSingleAggregationColumn) {
+        const columnGroupId = parentColumnGroupId;
+        parentColumnGroupId = keys.join("/");
+        const pivotGroupKey = keys[keys.length - 1];
+        columnGroups.set(parentColumnGroupId, prepareColumnGroup({
+          header: pivotGroupKey,
+          columnGroup: columnGroupId,
+          pivotBy,
           pivotGroupKeys: keys,
-          pivotGroupKeyForColumn: keys[keys.length - 1],
-          pivotByForColumn,
-          pivotIndexForColumn: keys.length - 1,
+          pivotByAtIndex: pivotByForColumn,
+          pivotIndex: keys.length - 1,
+          pivotGroupKey
+        }));
+      }
+      aggregationReducers.forEach((reducer, index) => {
+        const header = isSingleAggregationColumn ? keys[keys.length - 1] : reducer.id;
+        const computedPivotColumn = prepareColumn({
           pivotBy,
+          pivotColumn: true,
+          pivotTotalColumn: false,
+          pivotAggregator: reducer,
+          pivotAggregatorIndex: index,
+          pivotGroupKeys: keys,
+          pivotGroupKey: keys[keys.length - 1],
+          pivotIndex: keys.length - 1,
+          pivotByAtIndex: pivotByForColumn,
           sortable: false,
+          columnGroup: parentColumnGroupId,
+          header,
           valueGetter: ({ rowInfo }) => {
-            var _a, _b, _c;
-            const value = (_c = (_b = (_a = rowInfo.pivotValuesMap) == null ? void 0 : _a.get(keys)) == null ? void 0 : _b.reducerResults[0]) != null ? _c : null;
-            return value;
-          }
-        }, pivotByForColumn.column);
-        if (pivotByForColumn.column) {
-          if (typeof pivotByForColumn.column === "function") {
-            Object.assign(computedPivotColumn, pivotByForColumn.column({ column: computedPivotColumn }));
-          } else {
-            Object.assign(computedPivotColumn, pivotByForColumn.column);
+            var _a, _b;
+            return (_b = (_a = rowInfo.pivotValuesMap) == null ? void 0 : _a.get(keys)) == null ? void 0 : _b.reducerResults[reducer.id];
           }
+        });
+        const columnId = `${keys.join("/")}-${reducer.id}`;
+        columns.set(columnId, computedPivotColumn);
+      });
+    } else {
+      const colGroupId = keys.join("/");
+      const parentKeys = keys.slice(0, -1);
+      columnGroups.set(colGroupId, prepareColumnGroup({
+        columnGroup: parentKeys.length ? parentKeys.join("/") : void 0,
+        header: keys[keys.length - 1],
+        pivotBy,
+        pivotGroupKeys: keys,
+        pivotIndex: keys.length - 1,
+        pivotByAtIndex: pivotBy[keys.length - 1],
+        pivotGroupKey: keys[keys.length - 1]
+      }));
+      if (pivotTotalColumnPosition !== false) {
+        const pivotByForColumn = pivotBy[keys.length - 1];
+        let columnGroupId = parentKeys.length ? parentKeys.join("/") : void 0;
+        if (!isSingleAggregationColumn) {
+          let parentGroupForTotalsGroup = columnGroupId;
+          columnGroupId = `total:${keys.join("/")}`;
+          columnGroups.set(columnGroupId, prepareColumnGroup({
+            header: `${keys[keys.length - 1]} total`,
+            columnGroup: parentGroupForTotalsGroup,
+            pivotBy,
+            pivotTotalColumnGroup: true,
+            pivotGroupKeys: keys,
+            pivotIndex: keys.length - 1,
+            pivotByAtIndex: pivotByForColumn,
+            pivotGroupKey: keys[keys.length - 1]
+          }));
         }
-        columns.set(`${keys.join("/")}-total`, computedPivotColumn);
+        aggregationReducers.forEach((reducer, index) => {
+          const header = isSingleAggregationColumn ? `${keys[keys.length - 1]} total ` : `${reducer.id} total`;
+          const computedPivotColumn = prepareColumn({
+            columnGroup: columnGroupId,
+            header,
+            pivotAggregator: reducer,
+            pivotAggregatorIndex: index,
+            pivotColumn: true,
+            pivotTotalColumn: true,
+            pivotGroupKeys: keys,
+            pivotGroupKey: keys[keys.length - 1],
+            pivotByAtIndex: pivotByForColumn,
+            pivotIndex: keys.length - 1,
+            pivotBy,
+            sortable: false,
+            valueGetter: ({ rowInfo }) => {
+              var _a, _b;
+              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);
+        });
       }
     }
     if (pivotTotalColumnPosition === "start" || pivotTotalColumnPosition === false) {
@@ -3257,9 +3452,12 @@ function getPivotColumnsAndColumnGroups(deepMap, pivotBy, pivotTotalColumnPositi
   if (columns.size === 1) {
     columns.set("single", {
       header: "Reduced",
+      pivotBy,
+      pivotColumn: true,
       valueGetter: ({ rowInfo }) => {
         var _a;
-        return (_a = rowInfo.reducerResults) == null ? void 0 : _a[0];
+        const key = Object.keys(rowInfo.reducerResults || {})[0];
+        return (_a = rowInfo.reducerResults) == null ? void 0 : _a[key];
       }
     });
   }
@@ -3283,29 +3481,37 @@ var haveDepsChanged = (state1, state2, deps) => {
   return false;
 };
 function toRowInfo(data, id, index) {
-  return { data, collapsed: true, id, indexInAll: index, indexInGroup: index };
+  return {
+    data,
+    collapsed: true,
+    id,
+    indexInAll: index,
+    indexInGroup: index,
+    isGroupRow: false
+  };
 }
 function concludeReducer(params) {
   var _a;
   const { state, previousState } = params;
   const sortInfo = state.sortInfo;
-  const shouldSort = !!(sortInfo == null ? void 0 : sortInfo.length);
+  const shouldSort = !!(sortInfo == null ? void 0 : sortInfo.length) && !state.controlledSort;
   const sortDepsChanged = haveDepsChanged(previousState, state, [
     "originalDataArray",
     "sortInfo"
   ]);
   const shouldSortAgain = shouldSort && (sortDepsChanged || !state.lastSortDataArray);
-  const groupBy = state.groupRowsBy;
+  const groupBy = state.groupBy;
   const pivotBy = state.pivotBy;
   const shouldGroup = groupBy.length || pivotBy;
   const groupsDepsChanged = haveDepsChanged(previousState, state, [
     "generateGroupRows",
     "originalDataArray",
-    "groupRowsBy",
+    "groupBy",
     "groupRowsState",
     "pivotBy",
     "aggregationReducers",
     "pivotTotalColumnPosition",
+    "showSeparatePivotColumnForSingleAggregation",
     "sortInfo"
   ]);
   const shouldGroupAgain = shouldGroup && (groupsDepsChanged || !state.lastGroupDataArray);
@@ -3331,13 +3537,20 @@ function concludeReducer(params) {
       }, dataArray);
       const flattenResult = enhancedFlatten({
         groupResult,
+        reducers: state.aggregationReducers,
         toPrimaryKey,
         groupRowsState: state.groupRowsState,
         generateGroupRows: state.generateGroupRows
       });
       rowInfoDataArray = flattenResult.data;
       state.groupDeepMap = groupResult.deepMap;
-      const pivotGroupsAndCols = pivotBy ? getPivotColumnsAndColumnGroups(groupResult.topLevelPivotColumns, pivotBy, (_a = state.pivotTotalColumnPosition) != null ? _a : "end") : void 0;
+      const pivotGroupsAndCols = pivotBy ? getPivotColumnsAndColumnGroups({
+        deepMap: groupResult.topLevelPivotColumns,
+        pivotBy,
+        pivotTotalColumnPosition: (_a = state.pivotTotalColumnPosition) != null ? _a : "end",
+        reducers: state.aggregationReducers,
+        showSeparatePivotColumnForSingleAggregation: state.showSeparatePivotColumnForSingleAggregation
+      }) : void 0;
       state.pivotColumns = pivotGroupsAndCols == null ? void 0 : pivotGroupsAndCols.columns;
       state.pivotColumnGroups = pivotGroupsAndCols == null ? void 0 : pivotGroupsAndCols.columnGroups;
     } else {
@@ -3359,7 +3572,9 @@ function concludeReducer(params) {
   }
   state.dataArray = rowInfoDataArray;
   state.reducedAt = now;
-  globalThis.state = state;
+  if (true) {
+    globalThis.state = state;
+  }
   return state;
 }
 
@@ -3382,7 +3597,8 @@ var DataSourceRoot = getComponentStateRoot({
   initSetupState: initSetupState2,
   forwardProps: forwardProps3,
   concludeReducer,
-  mapPropsToState: mapPropsToState2
+  mapPropsToState: mapPropsToState2,
+  interceptActions: getInterceptActions()
 });
 function DataSourceCmp({ children }) {
   const DataSourceContext = getDataSourceContext();
@@ -3421,49 +3637,49 @@ function useToggleGroupRow() {
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
-function useGroupRowsMap(groupRowsBy) {
-  const groupRowsMap = useMemo5(() => {
-    return groupRowsBy.reduce((acc, groupBy, index) => {
-      acc.set(groupBy.field, {
-        groupBy,
+function useGroupByMap(groupBy) {
+  const groupByMap = useMemo5(() => {
+    return groupBy.reduce((acc, groupBy2, index) => {
+      acc.set(groupBy2.field, {
+        groupBy: groupBy2,
         groupIndex: index
       });
       return acc;
     }, new Map());
-  }, [groupRowsBy]);
-  return groupRowsMap;
+  }, [groupBy]);
+  return groupByMap;
 }
 function useColumnsWhen() {
   const {
-    componentState: { groupRowsBy },
+    componentState: { groupBy },
     componentActions: dataSourceActions
   } = useDataSourceContextValue();
   const {
     componentState: { groupRenderStrategy, pivotTotalColumnPosition }
   } = useComponentState();
-  const groupRowsMap = useGroupRowsMap(groupRowsBy);
-  useEffect8(() => {
+  const groupByMap = useGroupByMap(groupBy);
+  useEffect9(() => {
     dataSourceActions.generateGroupRows = groupRenderStrategy !== "inline";
   }, [groupRenderStrategy]);
-  useEffect8(() => {
+  useEffect9(() => {
     dataSourceActions.pivotTotalColumnPosition = pivotTotalColumnPosition;
   }, [pivotTotalColumnPosition]);
-  useColumnsWhenInlineGroupRenderStrategy(groupRowsMap);
+  useColumnsWhenInlineGroupRenderStrategy(groupByMap);
   useColumnsWhenPivoting();
   useColumnsWhenGrouping();
-  useHideEmptyGroupColumns(groupRowsMap);
+  useHideEmptyGroupColumns(groupByMap);
 }
-function useColumnsWhenInlineGroupRenderStrategy(groupRowsMap) {
+function useColumnsWhenInlineGroupRenderStrategy(groupByMap) {
   const toggleGroupRow = useToggleGroupRow();
   const {
     componentActions,
     componentState: { columns, groupRenderStrategy }
   } = useComponentState();
-  function computeColumnsWhenInlineGroupRenderStrategy(columns2, groupRowsMap2, groupRenderStrategy2, toggleGroupRow2) {
+  function computeColumnsWhenInlineGroupRenderStrategy(columns2, groupByMap2, groupRenderStrategy2, toggleGroupRow2) {
     const computedColumns = new Map();
     columns2.forEach((column, id) => {
       let base = {};
-      const groupByForColumn = groupRowsMap2.get(column.field);
+      const groupByForColumn = groupByMap2.get(column.field);
       if (groupByForColumn && groupRenderStrategy2 === "inline") {
         const { groupIndex } = groupByForColumn;
         const field = groupByForColumn.groupBy.field;
@@ -3508,9 +3724,9 @@ function useColumnsWhenInlineGroupRenderStrategy(groupRowsMap) {
     });
     return computedColumns.size === 0 ? void 0 : computedColumns;
   }
-  useEffect8(() => {
+  useEffect9(() => {
     const update = () => {
-      componentActions.columnsWhenInlineGroupRenderStrategy = computeColumnsWhenInlineGroupRenderStrategy(columns, groupRowsMap, groupRenderStrategy, toggleGroupRow);
+      componentActions.columnsWhenInlineGroupRenderStrategy = computeColumnsWhenInlineGroupRenderStrategy(columns, groupByMap, groupRenderStrategy, toggleGroupRow);
     };
     update();
     return interceptMap(columns, {
@@ -3518,11 +3734,11 @@ function useColumnsWhenInlineGroupRenderStrategy(groupRowsMap) {
       delete: update,
       clear: update
     });
-  }, [columns, groupRowsMap, groupRenderStrategy, toggleGroupRow]);
+  }, [columns, groupByMap, groupRenderStrategy, toggleGroupRow]);
 }
 function useColumnsWhenPivoting() {
   const {
-    componentState: { groupRowsBy, pivotBy }
+    componentState: { groupBy, pivotBy }
   } = useDataSourceContextValue();
   const {
     componentActions,
@@ -3534,13 +3750,13 @@ function useColumnsWhenPivoting() {
     }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  useEffect8(() => {
+  useEffect9(() => {
     const computedPivotColumns = getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, {
       pivotColumn,
       pivotRowLabelsColumn,
       pivotTotalColumnPosition,
       pivotBy,
-      groupRowsBy,
+      groupBy,
       toggleGroupRow
     });
     componentActions.computedPivotColumns = computedPivotColumns;
@@ -3548,14 +3764,14 @@ function useColumnsWhenPivoting() {
 }
 function useColumnsWhenGrouping() {
   const {
-    componentState: { groupRowsBy }
+    componentState: { groupBy }
   } = useDataSourceContextValue();
   const {
     componentActions,
     componentState: { columns, groupColumn, groupRenderStrategy, pivotColumns }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  useEffect8(() => {
+  useEffect9(() => {
     if (pivotColumns) {
       return;
     }
@@ -3564,7 +3780,7 @@ function useColumnsWhenGrouping() {
         columns,
         groupColumn,
         groupRenderStrategy,
-        groupRowsBy,
+        groupBy,
         pivotColumns,
         toggleGroupRow
       });
@@ -3576,11 +3792,11 @@ function useColumnsWhenGrouping() {
       delete: update,
       clear: update
     });
-  }, [groupRowsBy, groupColumn, groupRenderStrategy, pivotColumns]);
+  }, [columns, groupBy, groupColumn, groupRenderStrategy, pivotColumns]);
 }
 function useHideEmptyGroupColumns(groupRowsMap) {
   const {
-    componentState: { groupRowsBy, groupRowsState },
+    componentState: { groupBy, groupRowsState },
     getState: getDataSourceState
   } = useDataSourceContextValue();
   const {
@@ -3592,11 +3808,11 @@ function useHideEmptyGroupColumns(groupRowsMap) {
       groupRenderStrategy
     }
   } = useComponentState();
-  useEffect8(() => {
-    if (groupRenderStrategy === "single-column") {
+  useEffect9(() => {
+    if (groupRenderStrategy !== "multi-column") {
       return;
     }
-    const groupsLength = groupRowsBy.length;
+    const groupsLength = groupBy.length;
     let expandedGroupsLevel = 0;
     const { dataArray } = getDataSourceState();
     const len = dataArray.length;
@@ -3612,15 +3828,15 @@ function useHideEmptyGroupColumns(groupRowsMap) {
     let updated = false;
     const columnVisibility = new Map(currentState.columnVisibility);
     const cols = computedColumns;
-    groupRowsBy.forEach(({ field }, index) => {
-      const colId = groupRenderStrategy === "multi-column" ? `group-by-${field}` : field;
-      const col = cols.get(colId);
+    groupBy.forEach(({ field, column: groupColumn }, index) => {
+      const colId = (groupColumn == null ? void 0 : groupColumn.id) || `group-by-${field}`;
+      let col = cols.get(colId);
       if (!col) {
         return;
       }
-      const shouldBeHidden = index > expandedGroupsLevel;
+      const shouldBeHidden = index > expandedGroupsLevel && hideEmptyGroupColumns;
       updated = true;
-      if (shouldBeHidden && hideEmptyGroupColumns) {
+      if (shouldBeHidden) {
         columnVisibility.set(colId, false);
       } else {
         columnVisibility.delete(colId);
@@ -3633,7 +3849,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
     getDataSourceState,
     groupRenderStrategy,
     generatedColumns,
-    groupRowsBy,
+    groupBy,
     groupRowsMap,
     hideEmptyGroupColumns ? groupRowsState : null,
     hideEmptyGroupColumns
@@ -3642,7 +3858,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
 function getColumnsWhenGrouping(params) {
   const {
     pivotColumns,
-    groupRowsBy,
+    groupBy,
     groupColumn,
     groupRenderStrategy,
     toggleGroupRow,
@@ -3656,10 +3872,10 @@ function getColumnsWhenGrouping(params) {
   }
   const computedColumns = new Map();
   if (groupRenderStrategy === "multi-column") {
-    groupRowsBy.forEach((groupByForColumn, groupIndexForColumn, arr) => {
+    groupBy.forEach((groupByForColumn, groupIndexForColumn, arr) => {
       const generatedGroupColumn = getColumnForGroupBy({
         groupByForColumn,
-        groupRowsBy,
+        groupBy,
         groupIndexForColumn,
         groupCount: arr.length,
         groupRenderStrategy
@@ -3668,8 +3884,8 @@ function getColumnsWhenGrouping(params) {
     });
   } else if (groupRenderStrategy === "single-column") {
     const singleGroupColumn = getSingleGroupColumn({
-      groupCount: groupRowsBy.length,
-      groupRowsBy,
+      groupCount: groupBy.length,
+      groupBy,
       groupRenderStrategy
     }, toggleGroupRow, groupColumn);
     computedColumns.set(singleGroupColumn.id || "group-by", singleGroupColumn);
@@ -3694,9 +3910,10 @@ function useComputed() {
     columnPinning,
     columnSizing,
     columnTypes,
-    bodySize
+    bodySize,
+    showSeparatePivotColumnForSingleAggregation
   } = componentState;
-  useState4(() => {
+  useState5(() => {
     componentState.onRowHeightCSSVarChange.onChange((rowHeight) => {
       if (rowHeight) {
         componentActions.rowHeight = rowHeight;
@@ -3708,13 +3925,16 @@ function useComputed() {
       }
     });
   });
-  useColumnAggregations();
+  useEffect10(() => {
+    dataSourceActions.showSeparatePivotColumnForSingleAggregation = showSeparatePivotColumnForSingleAggregation;
+  }, [showSeparatePivotColumnForSingleAggregation]);
   const { multiSort } = dataSourceState;
   useColumnGroups();
   useColumnsWhen();
   const setSortInfo = useCallback5((sortInfo) => {
     var _a2;
-    dataSourceActions.sortInfo = multiSort ? sortInfo : (_a2 = sortInfo[0]) != null ? _a2 : null;
+    const newSortInfo = multiSort ? sortInfo : (_a2 = sortInfo[0]) != null ? _a2 : null;
+    dataSourceActions.sortInfo = newSortInfo;
   }, []);
   const columns = componentState.computedColumns;
   const {
@@ -3866,11 +4086,11 @@ function VerticalScrollbarPlaceholderFn(props) {
 var VerticalScrollbarPlaceholder = memo2(VerticalScrollbarPlaceholderFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/header.css.ts
-var import_createRuntimeFn2 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn3 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 var CellCls = "_1eexc2a5 _16lm1iwj _16lm1iw10 _16lm1iw11 _16lm1iw2 _16lm1iw19 _16lm1iw1a";
 var HeaderCellProxy = "_12zfob10";
-var HeaderCellRecipe = (0, import_createRuntimeFn2.createRuntimeFn)({ defaultClassName: "_12zfob1c", variantClassNames: { dragging: { true: "_12zfob1d", false: "_12zfob1e" }, first: { true: "_12zfob1f", false: "_12zfob1g" }, last: { true: "_12zfob1h", false: "_12zfob1i" }, groupByField: { true: "_12zfob1j", false: "_12zfob1k" }, firstInCategory: { true: "_12zfob1l", false: "_12zfob1m" }, lastInCategory: { true: "_12zfob1n", false: "_12zfob1o" }, pinned: { start: "_12zfob1p", end: "_12zfob1q", false: "_12zfob1r" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_12zfob1s"], [{ pinned: "end", firstInCategory: true }, "_12zfob1t"], [{ pinned: false, lastInCategory: true }, "_12zfob1u"]] });
-var HeaderClsRecipe = (0, import_createRuntimeFn2.createRuntimeFn)({ defaultClassName: "_12zfob12 _16lm1iw10", variantClassNames: { pinned: { start: "_12zfob13", end: "_12zfob14", false: "_12zfob15" }, virtualized: { true: "_12zfob16", false: "_12zfob17" }, overflow: { true: "_12zfob18", false: "_12zfob19" } }, defaultVariants: {}, compoundVariants: [[{ overflow: true, pinned: "start" }, "_12zfob1a"], [{ overflow: true, pinned: "end" }, "_12zfob1b"]] });
+var HeaderCellRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob1c", variantClassNames: { dragging: { true: "_12zfob1d", false: "_12zfob1e" }, first: { true: "_12zfob1f", false: "_12zfob1g" }, last: { true: "_12zfob1h", false: "_12zfob1i" }, groupByField: { true: "_12zfob1j", false: "_12zfob1k" }, firstInCategory: { true: "_12zfob1l", false: "_12zfob1m" }, lastInCategory: { true: "_12zfob1n", false: "_12zfob1o" }, pinned: { start: "_12zfob1p", end: "_12zfob1q", false: "_12zfob1r" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_12zfob1s"], [{ pinned: "end", firstInCategory: true }, "_12zfob1t"], [{ pinned: false, lastInCategory: true }, "_12zfob1u"]] });
+var HeaderClsRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob12 _16lm1iw10", variantClassNames: { pinned: { start: "_12zfob13", end: "_12zfob14", false: "_12zfob15" }, virtualized: { true: "_12zfob16", false: "_12zfob17" }, overflow: { true: "_12zfob18", false: "_12zfob19" } }, defaultVariants: {}, compoundVariants: [[{ overflow: true, pinned: "start" }, "_12zfob1a"], [{ overflow: true, pinned: "end" }, "_12zfob1b"]] });
 var HeaderGroupCls = "_16lm1iwz _16lm1iwj";
 var HeaderGroup_Children = "_16lm1iwj _16lm1iw10 _16lm1iw12 _16lm1iwc";
 var HeaderGroup_Header = "_12zfob1x _16lm1iwj _16lm1iw10 _16lm1iw11";
@@ -3882,14 +4102,14 @@ import {
   createElement as createElement15,
   memo as memo6
 } from "react";
-import { useCallback as useCallback8, useEffect as useEffect12, useRef as useRef7 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect14, useRef as useRef9 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderCell.tsx
 import {
   Fragment as Fragment2,
   createElement as createElement11
 } from "react";
-import { useCallback as useCallback7, useEffect as useEffect10, useRef as useRef6 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect12, useRef as useRef8 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
 import {
@@ -3898,18 +4118,18 @@ import {
 } from "react";
 
 // src/components/InfiniteTable/hooks/useInfiniteTableState.ts
-import { useContext as useContext5 } from "react";
+import { useContext as useContext4 } from "react";
 var useInfiniteTableState = () => {
   const TableContext2 = getInfiniteTableContext();
-  const { componentState } = useContext5(TableContext2);
+  const { componentState } = useContext4(TableContext2);
   return componentState;
 };
 
 // src/components/InfiniteTable/components/cell.css.ts
-var import_createRuntimeFn3 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn4 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 var CellCls2 = "_1eexc2a5 _16lm1iwj _16lm1iw10 _16lm1iw11 _16lm1iw2 _16lm1iw19 _16lm1iw1a";
 var CellClsVariants = { shifting: "_1eexc2a3", dragging: "_1eexc2a4" };
-var ColumnCellRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_16lm1iw2 _16lm1iwo _16lm1iw7 _16lm1iwr", variantClassNames: { dragging: { false: "_1eexc2a7" }, first: { true: "_1eexc2a8", false: "_1eexc2a9" }, last: { true: "_1eexc2aa", false: "_1eexc2ab" }, groupByField: { true: "_1eexc2ac", false: "_1eexc2ad" }, firstInCategory: { true: "_1eexc2ae", false: "_1eexc2af" }, lastInCategory: { true: "_1eexc2ag", false: "_1eexc2ah" }, pinned: { start: "_1eexc2ai", end: "_1eexc2aj", false: "_1eexc2ak" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_1eexc2al"], [{ pinned: "end", firstInCategory: true }, "_1eexc2am"]] });
+var ColumnCellRecipe = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "_16lm1iw2 _16lm1iwo _16lm1iw7 _16lm1iwr", variantClassNames: { dragging: { false: "_1eexc2a7" }, first: { true: "_1eexc2a8", false: "_1eexc2a9" }, last: { true: "_1eexc2aa", false: "_1eexc2ab" }, groupByField: { true: "_1eexc2ac", false: "_1eexc2ad" }, firstInCategory: { true: "_1eexc2ae", false: "_1eexc2af" }, lastInCategory: { true: "_1eexc2ag", false: "_1eexc2ah" }, pinned: { start: "_1eexc2ai", end: "_1eexc2aj", false: "_1eexc2ak" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_1eexc2al"], [{ pinned: "end", firstInCategory: true }, "_1eexc2am"]] });
 var columnAlignCellStyle = { center: "_1eexc2a0", start: "_1eexc2a1", end: "_1eexc2a2" };
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
@@ -3970,8 +4190,8 @@ var import_binary_search = __toModule(require_binary_search());
 import {
   useCallback as useCallback6,
   useMemo as useMemo6,
-  useRef as useRef5,
-  useState as useState5
+  useRef as useRef7,
+  useState as useState6
 } from "react";
 
 // src/components/InfiniteTable/utils/moveXatY.ts
@@ -4006,13 +4226,13 @@ var useColumnPointerEvents = ({
   columns,
   computedRemainingSpace
 }) => {
-  const [draggingDiff, setDraggingDiff] = useState5(null);
-  const [proxyOffset, setProxyOffset] = useState5(null);
-  const breakpointsRef = useRef5([]);
-  const pointerMoveRef = useRef5(null);
-  const didDragRef = useRef5(false);
-  const initialClientPos = useRef5(null);
-  const currentDropIndexRef = useRef5(null);
+  const [draggingDiff, setDraggingDiff] = useState6(null);
+  const [proxyOffset, setProxyOffset] = useState6(null);
+  const breakpointsRef = useRef7([]);
+  const pointerMoveRef = useRef7(null);
+  const didDragRef = useRef7(false);
+  const initialClientPos = useRef7(null);
+  const currentDropIndexRef = useRef7(null);
   const dragging = draggingDiff != null;
   const { componentActions, computed } = useInfiniteTable();
   const { computedColumnOrder } = computed;
@@ -4025,7 +4245,7 @@ var useColumnPointerEvents = ({
       columnWidth: column.computedWidth
     };
   }, [columns, columnId, column]);
-  let cursorRef = useRef5("auto");
+  let cursorRef = useRef7("auto");
   const onPointerDown = useCallback6((e) => {
     const target = domRef.current;
     cursorRef.current = target.style.cursor;
@@ -4166,7 +4386,7 @@ import { createPortal } from "react-dom";
 import {
   createElement as createElement10
 } from "react";
-import { useEffect as useEffect9, useState as useState6 } from "react";
+import { useEffect as useEffect11, useState as useState7 } from "react";
 var defaultLineStyle = {
   marginTop: 2,
   marginBottom: 2,
@@ -4174,8 +4394,8 @@ var defaultLineStyle = {
 };
 function SortIcon(props) {
   var _a;
-  const [rendered, setRendered] = useState6(true);
-  const [opacity, setOpacity] = useState6(0);
+  const [rendered, setRendered] = useState7(true);
+  const [opacity, setOpacity] = useState7(0);
   const { direction, lineWidth = 1, style, className, index } = props;
   const showIndex = index != null && index > 0;
   const size = (_a = props.size) != null ? _a : 16;
@@ -4189,7 +4409,7 @@ function SortIcon(props) {
   }), props.lineStyle), {
     opacity
   });
-  useEffect9(() => {
+  useEffect11(() => {
     const newOpacity = direction != 0 ? 1 : 0;
     if (!rendered && newOpacity) {
       setRendered(true);
@@ -4266,7 +4486,7 @@ function InfiniteTableHeaderCell(props) {
     className: `${baseCls}__sort-icon ${HeaderSortIconCls}`,
     direction: column.computedSorted ? column.computedSortedAsc ? 1 : -1 : 0
   });
-  const domRef = useRef6(null);
+  const domRef = useRef8(null);
   const ref = useCallback7((node) => {
     var _a2;
     domRef.current = node;
@@ -4276,7 +4496,7 @@ function InfiniteTableHeaderCell(props) {
     computed: { computedRemainingSpace },
     componentState: { portalDOMRef }
   } = useInfiniteTable();
-  useEffect10(() => {
+  useEffect12(() => {
     let clearOnResize = null;
     const node = domRef.current;
     if (onResize && node) {
@@ -4332,7 +4552,7 @@ import {
   createElement as createElement14,
   memo as memo5
 } from "react";
-import { useEffect as useEffect11 } from "react";
+import { useEffect as useEffect13 } from "react";
 
 // src/components/RawList/AvoidReactDiff.tsx
 import {
@@ -4340,9 +4560,9 @@ import {
   createElement as createElement12,
   memo as memo4
 } from "react";
-import { useLayoutEffect as useLayoutEffect4, useState as useState7 } from "react";
+import { useLayoutEffect as useLayoutEffect4, useState as useState8 } from "react";
 function AvoidReactDiffFn(props) {
-  const [children, setChildren] = useState7(props.updater.get());
+  const [children, setChildren] = useState8(props.updater.get());
   useLayoutEffect4(() => {
     const remove = props.updater.onChange((children2) => {
       setChildren(children2);
@@ -4375,10 +4595,10 @@ var MappedItems = class extends Logger {
       return result;
     };
     this.getElementsOutsideItemRange = (startIndex, endIndex) => {
-      const map = this.elementIndexToItemIndex;
+      const map2 = this.elementIndexToItemIndex;
       const result = [];
-      for (const elementIndex in map) {
-        const itemIndex = map[elementIndex];
+      for (const elementIndex in map2) {
+        const itemIndex = map2[elementIndex];
         if (itemIndex < startIndex || itemIndex > endIndex) {
           result.push(elementIndex >> 0);
         }
@@ -4683,7 +4903,7 @@ function RawListFn(props) {
     debugChannel
   });
   const getRenderItem = useLatest(renderItem);
-  useEffect11(() => {
+  useEffect13(() => {
     const renderRange = brain.getRenderRange();
     renderer.renderRange(renderRange, {
       renderItem,
@@ -4691,7 +4911,7 @@ function RawListFn(props) {
       onRender: onRenderUpdater
     });
   }, [brain, renderItem, onRenderUpdater]);
-  useEffect11(() => {
+  useEffect13(() => {
     const remove = brain.onRenderRangeChange((renderRange) => {
       renderer.renderRange(renderRange, {
         force: false,
@@ -4733,14 +4953,14 @@ function InfiniteTableHeaderFn(props) {
       columns: computedVisibleColumnsMap
     });
   }, [computedVisibleColumnsMap, columns, repaintId, headerHeight]);
-  useEffect12(() => {
+  useEffect14(() => {
     const onScroll = (scrollPosition) => {
       domRef.current.style.transform = `translate3d(-${scrollPosition.scrollLeft}px, 0px, 0px)`;
     };
     const removeOnScroll = brain.onScroll(onScroll);
     return removeOnScroll;
   }, [brain]);
-  const domRef = useRef7(null);
+  const domRef = useRef9(null);
   const headerCls = HeaderClsRecipe({
     pinned: pinning,
     overflow: false,
@@ -4763,7 +4983,7 @@ import {
   createElement as createElement18,
   memo as memo7,
   useMemo as useMemo8,
-  useRef as useRef8
+  useRef as useRef10
 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/renderColumnHeaderGroups.tsx
@@ -4773,7 +4993,7 @@ import {
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/buildColumnAndGroupTree.ts
 function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
-  const map = new Map();
+  const map2 = new Map();
   const temporaryMap = new Map();
   const mapOfAllParentGroupsForColumns = new Map();
   columns.forEach((col, index) => {
@@ -4791,7 +5011,7 @@ function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
       computedWidth: col.computedWidth,
       depth: col.columnGroup ? ((_d = columnGroupsDepthsMap.get(col.columnGroup)) != null ? _d : 0) + 1 : 0
     };
-    map.set([colId], colItem);
+    map2.set([colId], colItem);
     let groupId = col.columnGroup;
     let colGroupItem;
     let prevGroupItem = colItem;
@@ -4813,7 +5033,7 @@ function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
             computedWidth: 0,
             depth: (_e = columnGroupsDepthsMap.get(groupId)) != null ? _e : 0
           };
-          map.set(groupAbsoluteId, colGroupItem);
+          map2.set(groupAbsoluteId, colGroupItem);
           temporaryMap.set(groupId, colGroupItem);
         }
         colGroupItem.columnItems.push(colItem);
@@ -4830,7 +5050,7 @@ function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
   });
   const result = [];
   let groupOffset = 0;
-  map.forEach((item) => {
+  map2.forEach((item) => {
     if (!item.ref.columnGroup) {
       const itemWidth = item.type === "column" ? item.ref.computedWidth : item.columnItems.reduce((sum, col) => sum + col.ref.computedWidth, 0);
       item.groupOffset = groupOffset;
@@ -4842,7 +5062,7 @@ function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
       groupOffset += itemWidth;
     }
   });
-  map.clear();
+  map2.clear();
   temporaryMap.clear();
   return result;
 }
@@ -4941,7 +5161,7 @@ function renderColumnHeaderGroups(config) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderUnvirtualized.tsx
-import { useEffect as useEffect13 } from "react";
+import { useEffect as useEffect15 } from "react";
 var { rootClassName: rootClassName5 } = internalProps;
 var TableHeaderClassName2 = `${rootClassName5}Header`;
 var UPDATE_SCROLL = (node, scrollPosition) => {
@@ -4974,7 +5194,7 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
     },
     computed: { computedVisibleColumnsMap: columnsMap }
   } = useInfiniteTable();
-  const domRef = useRef8(null);
+  const domRef = useRef10(null);
   const hasColumnGroups = computedColumnGroups.size > 0;
   const columnHeaderGroups = useMemo8(() => {
     return hasColumnGroups ? renderColumnHeaderGroups({
@@ -5007,7 +5227,7 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
   if (totalWidth != null) {
     style.width = availableWidth;
   }
-  useEffect13(() => {
+  useEffect15(() => {
     const scroller = brain || scrollListener;
     if (!scroller || !scrollable) {
       return;
@@ -5124,12 +5344,12 @@ import {
   createElement as createElement20,
   forwardRef as forwardRef2
 } from "react";
-import { useRef as useRef9 } from "react";
+import { useRef as useRef11 } from "react";
 
 // src/components/hooks/useOnScroll.ts
-import { useEffect as useEffect14 } from "react";
+import { useEffect as useEffect16 } from "react";
 var useOnScroll = (domRef, onScroll) => {
-  useEffect14(() => {
+  useEffect16(() => {
     const domNode = domRef == null ? void 0 : domRef.current;
     const scrollFn = (event) => {
       const node = event.target;
@@ -5175,7 +5395,7 @@ var VirtualScrollContainer = forwardRef2(function VirtualScrollContainer2(props,
     className,
     style
   } = props;
-  const domRef = ref != null ? ref : useRef9(null);
+  const domRef = ref != null ? ref : useRef11(null);
   useOnScroll(domRef, onContainerScroll);
   return /* @__PURE__ */ createElement20("div", {
     ref: domRef,
@@ -5209,7 +5429,7 @@ function SpacePlaceholderFn(props) {
 var SpacePlaceholder = memo8(SpacePlaceholderFn);
 
 // src/components/InfiniteTable/hooks/useListRendering.tsx
-import { useCallback as useCallback17, useEffect as useEffect20, useMemo as useMemo10, useRef as useRef15 } from "react";
+import { useCallback as useCallback17, useEffect as useEffect22, useMemo as useMemo10, useRef as useRef17 } from "react";
 
 // src/components/InfiniteTable/hooks/useUnpinnedRendering.tsx
 import {
@@ -5228,10 +5448,10 @@ import {
   Fragment as Fragment4,
   createElement as createElement22
 } from "react";
-import { useRef as useRef10, useEffect as useEffect15, useState as useState8 } from "react";
+import { useRef as useRef12, useEffect as useEffect17, useState as useState9 } from "react";
 
 // src/components/VirtualList/VirtualList.css.ts
-var VirtualListCls = "mlx2t0 _16lm1iw0";
+var VirtualListCls = "_16lm1iw1 _16lm1iw8 _16lm1iw0";
 var VirtualListClsOrientation = { horizontal: "mlx2t1", vertical: "mlx2t2" };
 var scrollTransformTargetCls = "mlx2t3";
 
@@ -5271,11 +5491,11 @@ var VirtualList = (props) => {
     "onContainerScroll",
     "children"
   ]);
-  const domRef = useRef10(null);
+  const domRef = useRef12(null);
   const [, rerender] = useRerender();
-  const [totalSize, setTotalSize] = useState8(0);
-  const renderCountRef = useRef10(0);
-  useEffect15(() => {
+  const [totalSize, setTotalSize] = useState9(0);
+  const renderCountRef = useRef12(0);
+  useEffect17(() => {
     const removeOnRenderCount = virtualBrain.onRenderCountChange((renderCount) => {
       renderCountRef.current = renderCount;
       if (true) {
@@ -5294,7 +5514,7 @@ var VirtualList = (props) => {
       removeOnTotalSizeChange();
     };
   }, [virtualBrain]);
-  useEffect15(() => {
+  useEffect17(() => {
     const onScroll = (scrollPosition) => {
       UPDATE_SCROLL2(domRef.current, scrollPosition);
     };
@@ -5352,7 +5572,7 @@ import {
   memo as memo10,
   useCallback as useCallback11
 } from "react";
-import { useRef as useRef12 } from "react";
+import { useRef as useRef14 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableColumnCell.tsx
 import {
@@ -5385,32 +5605,38 @@ function InfiniteTableColumnCellFn(props) {
   const groupRowInfo = null;
   let value = isGroupRow && groupBy && column.groupByField ? rowInfo.value : isColumnWithField(column) ? data == null ? void 0 : data[column.field] : null;
   if (column.valueGetter) {
-    value = column.valueGetter({
-      data,
-      rowInfo,
-      groupRowInfo
+    value = column.valueGetter(isGroupRow ? {
+      data: rowInfo.data,
+      rowInfo
+    } : {
+      data: rowInfo.data,
+      rowInfo
     });
   }
   const { componentState: computedDataSource } = useDataSourceContextValue();
-  const stylingRenderParam = {
-    value,
-    column,
+  const rest = rowInfo.isGroupRow ? {
+    rowInfo,
+    data: rowInfo.data
+  } : {
     rowInfo,
-    data
+    data: rowInfo.data
   };
+  const stylingRenderParam = __spreadValues({
+    value,
+    column
+  }, rest);
   let renderValue = value;
   if (column.render || column.renderValue) {
-    const renderParam = {
+    const renderParam = __spreadProps(__spreadValues({
       value,
       column,
-      rowInfo,
-      groupRowInfo,
-      data,
+      groupRowInfo
+    }, rest), {
       rowIndex,
       toggleGroupRow,
       toggleCurrentGroupRow: () => toggleGroupRow(rowInfo.groupKeys),
-      groupRowsBy: computedDataSource.groupRowsBy
-    };
+      groupBy: computedDataSource.groupBy
+    });
     if (column.render) {
       renderValue = column.render(renderParam);
     } else if (column.renderValue) {
@@ -5461,7 +5687,7 @@ var InfiniteTableColumnCell = memo9(InfiniteTableColumnCellFn);
 // src/components/InfiniteTable/components/InfiniteTableRow/useRowDOMProps.ts
 import {
   useCallback as useCallback10,
-  useRef as useRef11
+  useRef as useRef13
 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRowClassName.ts
@@ -5487,17 +5713,16 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
     domRef: domRefFromProps,
     rowInfo
   } = props;
-  const domRef = useRef11(null);
+  const domRef = useRef13(null);
   const rowDOMRef = useCallback10((node) => {
     domRefFromProps(node);
     domRef.current = node;
   }, []);
-  const rowPropsAndStyleArgs = {
-    data: rowInfo.data,
-    rowInfo,
+  const rest = rowInfo.isGroupRow ? { data: rowInfo.data, rowInfo } : { data: rowInfo.data, rowInfo };
+  const rowPropsAndStyleArgs = __spreadProps(__spreadValues({}, rest), {
     rowIndex,
-    groupRowsBy: rowInfo.groupBy
-  };
+    groupBy: rowInfo.groupBy
+  });
   if (typeof rowProps === "function") {
     rowProps = rowProps(rowPropsAndStyleArgs);
   }
@@ -5590,7 +5815,7 @@ function InfiniteTableRowFn(props) {
     width: rowWidth,
     height: rowHeight
   }, domProps.style);
-  const renderCellRef = useRef12(null);
+  const renderCellRef = useRef14(null);
   const renderCell = useCallback11(({ domRef, itemIndex }) => {
     const column = columns[itemIndex];
     if (!column) {
@@ -5763,23 +5988,23 @@ function useUnpinnedRendering(params) {
 }
 
 // src/components/InfiniteTable/hooks/useOnContainerScroll.ts
-import { useCallback as useCallback13, useEffect as useEffect16, useRef as useRef13 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect18, useRef as useRef15 } from "react";
 
 // src/components/InfiniteTable/InfiniteCls.css.ts
-var import_createRuntimeFn4 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn5 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 var FooterCls = "_16lm1iw1";
 var InfiniteCls = "_1yeub2v0 _16lm1iw1 _16lm1iwj _16lm1iwz _16lm1iw0";
-var InfiniteClsRecipe = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "", variantClassNames: { focused: { true: "_1yeub2v2", false: "_1yeub2v3" }, focusedWithin: { true: "_1yeub2v4", false: "_1yeub2v5" }, hasPinnedStart: { true: "_1yeub2v6", false: "_1yeub2v7" }, hasPinnedEnd: { true: "_1yeub2v8", false: "_1yeub2v9" }, hasPinnedStartOverflow: { true: "_1yeub2va", false: "_1yeub2vb" }, hasPinnedEndOverflow: { true: "_1yeub2vc", false: "_1yeub2vd" } }, defaultVariants: {}, compoundVariants: [] });
+var InfiniteClsRecipe = (0, import_createRuntimeFn5.createRuntimeFn)({ defaultClassName: "", variantClassNames: { focused: { true: "_1yeub2v2", false: "_1yeub2v3" }, focusedWithin: { true: "_1yeub2v4", false: "_1yeub2v5" }, hasPinnedStart: { true: "_1yeub2v6", false: "_1yeub2v7" }, hasPinnedEnd: { true: "_1yeub2v8", false: "_1yeub2v9" }, hasPinnedStartOverflow: { true: "_1yeub2va", false: "_1yeub2vb" }, hasPinnedEndOverflow: { true: "_1yeub2vc", false: "_1yeub2vd" } }, defaultVariants: {}, compoundVariants: [] });
 var InfiniteClsScrolling = "_1yeub2v1";
 var InfiniteClsShiftingColumns = "_16lm1iwm";
 var PinnedRowsClsVariants = { pinnedStart: "_1yeub2ve", pinnedEnd: "_1yeub2vf", overflow: "_1yeub2vg" };
-var PinnedRowsContainerClsVariants = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "", variantClassNames: { pinned: { start: "_1yeub2vh", end: "_1yeub2vi", false: "_1yeub2vj" } }, defaultVariants: {}, compoundVariants: [] });
+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 = 0;
+var SCROLL_BOTTOM_OFFSET = 1;
 var useOnContainerScroll = ({
   verticalVirtualBrain,
   horizontalVirtualBrain,
@@ -5795,10 +6020,11 @@ var useOnContainerScroll = ({
       bodySize
     }
   } = useInfiniteTable();
-  const timeoutIdRef = useRef13(0);
-  const scrollingRef = useRef13(false);
-  const scrollTopMaxRef = useRef13(0);
-  useEffect16(() => {
+  const { componentActions: dataSourceActions, getState: getDataSourceState } = useDataSourceContextValue();
+  const timeoutIdRef = useRef15(0);
+  const scrollingRef = useRef15(false);
+  const scrollTopMaxRef = useRef15(0);
+  useEffect18(() => {
     const { current: node } = scrollerDOMRef;
     scrollTopMaxRef.current = node.scrollHeight - node.clientHeight;
   }, [reservedContentHeight, bodySize.height]);
@@ -5837,7 +6063,7 @@ var useOnContainerScroll = ({
     domRef.current,
     setScrolling
   ]);
-  const scrollPositionRef = useRef13({
+  const scrollPositionRef = useRef15({
     scrollLeft: 0,
     scrollTop: 0
   });
@@ -5855,6 +6081,9 @@ var useOnContainerScroll = ({
     const isScrollBottom = scrollTop + offset >= scrollTopMaxRef.current;
     if (isScrollBottom) {
       onScrollToBottom == null ? void 0 : onScrollToBottom();
+      if (getDataSourceState().livePagination) {
+        dataSourceActions.scrollBottomId = Date.now();
+      }
     }
   }, [onContainerScroll, scrollToBottomOffset, onScrollToBottom, onScrollToTop]);
   return {
@@ -5874,12 +6103,12 @@ import { useCallback as useCallback15 } from "react";
 import {
   createElement as createElement28
 } from "react";
-import { useEffect as useEffect18, useCallback as useCallback14, useRef as useRef14 } from "react";
+import { useEffect as useEffect20, useCallback as useCallback14, useRef as useRef16 } from "react";
 
 // src/components/hooks/useOnMount.ts
-import { useEffect as useEffect17 } from "react";
+import { useEffect as useEffect19 } from "react";
 function useOnMount(domRef, props) {
-  useEffect17(() => {
+  useEffect19(() => {
     const { onMount, onUnmount } = props;
     const node = domRef == null ? void 0 : domRef.current;
     onMount == null ? void 0 : onMount(node);
@@ -5910,7 +6139,7 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   } = props;
-  const domRef = useRef14(null);
+  const domRef = useRef16(null);
   const renderItem = useCallback14((renderProps) => renderRow({
     domRef: renderProps.domRef,
     rowHeight: renderProps.itemSize,
@@ -5920,7 +6149,7 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   });
-  useEffect18(() => {
+  useEffect20(() => {
     const onScroll = (scrollPosition) => {
       const node = domRef.current;
       if (node) {
@@ -6143,7 +6372,7 @@ function usePinnedStartRendering(params) {
 }
 
 // src/components/InfiniteTable/hooks/useYourBrain.ts
-import { useEffect as useEffect19 } from "react";
+import { useEffect as useEffect21 } from "react";
 
 // src/components/VirtualBrain/index.ts
 var import_binary_search2 = __toModule(require_binary_search());
@@ -6622,7 +6851,7 @@ function useYourBrain(param) {
     });
     return brain;
   });
-  useEffect19(() => {
+  useEffect21(() => {
     return () => {
       horizontalVirtualBrain.destroy();
       verticalVirtualBrain.destroy();
@@ -6630,13 +6859,13 @@ function useYourBrain(param) {
   }, []);
   horizontalVirtualBrain.update(computedUnpinnedColumns.length, columnSize);
   verticalVirtualBrain.update(dataArray.length, rowHeight, rowSpan);
-  useEffect19(() => {
+  useEffect21(() => {
     verticalVirtualBrain.setAvailableSize({
       height: bodySize.height,
       width: 0
     });
   }, [bodySize, verticalVirtualBrain]);
-  useEffect19(() => {
+  useEffect21(() => {
     horizontalVirtualBrain.setAvailableSize({
       height: 0,
       width: Math.max(bodySize.width - computedPinnedStartWidth - computedPinnedEndWidth, 0)
@@ -6645,29 +6874,6 @@ function useYourBrain(param) {
   return { horizontalVirtualBrain, verticalVirtualBrain };
 }
 
-// src/utils/shallowEqualObjects.ts
-function shallowEqualObjects(objA, objB) {
-  if (objA === objB) {
-    return true;
-  }
-  if (!objA || !objB) {
-    return false;
-  }
-  var aKeys = Object.keys(objA);
-  var bKeys = Object.keys(objB);
-  var len = aKeys.length;
-  if (bKeys.length !== len) {
-    return false;
-  }
-  for (var i = 0; i < len; i++) {
-    var key = aKeys[i];
-    if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // src/components/InfiniteTable/hooks/useListRendering.tsx
 function useListRendering(param) {
   const { computed, bodySize, columnShifts } = param;
@@ -6697,7 +6903,7 @@ function useListRendering(param) {
     pinnedEndScrollListener
   } = componentState;
   const prevDataSourceTimestamp = usePrevious(dataSourceState.updatedAt);
-  const repaintIdRef = useRef15(0);
+  const repaintIdRef = useRef17(0);
   if (!shallowEqualObjects(prevComputed, computed) || prevDataSourceTimestamp !== dataSourceState.updatedAt) {
     repaintIdRef.current++;
   }
@@ -6739,12 +6945,12 @@ function useListRendering(param) {
   });
   const hasHorizontalScrollbar = computedUnpinnedColumnsWidth > bodySize.width - computedPinnedStartColumnsWidth - computedPinnedEndColumnsWidth;
   const reservedContentHeight = verticalVirtualBrain.getTotalSize() + (hasHorizontalScrollbar ? getScrollbarWidth() : 0);
-  const hasVerticalScrollbar = bodySize.height < reservedContentHeight;
+  const hasVerticalScrollbar = bodySize.height > 0 && bodySize.height < reservedContentHeight;
   const scrollbars = useMemo10(() => ({
     vertical: hasVerticalScrollbar,
     horizontal: hasHorizontalScrollbar
   }), [hasVerticalScrollbar, hasHorizontalScrollbar]);
-  useEffect20(() => {
+  useEffect22(() => {
     if (!bodySize.height) {
       return;
     }
@@ -6757,7 +6963,6 @@ function useListRendering(param) {
         setColumnVisibility: (columnVisibility) => {
           componentActions.columnVisibility = columnVisibility;
         },
-        setColumnAggregations: (columnAggregations) => componentActions.columnAggregations = columnAggregations,
         getState,
         getDataSourceState
       };
@@ -6805,7 +7010,7 @@ function useListRendering(param) {
     computedUnpinnedColumns
   });
   const [, rerender] = useRerender();
-  useEffect20(() => {
+  useEffect22(() => {
     rerender();
   }, [dataSourceState]);
   const { pinnedStartList, pinnedStartScrollbarPlaceholder } = usePinnedStartRendering(pinnedRenderingParams);
@@ -6832,16 +7037,15 @@ import {
   createElement as createElement30,
   forwardRef as forwardRef3,
   useCallback as useCallback18,
-  useRef as useRef16
+  useRef as useRef18
 } from "react";
-import { useEffect as useEffect21 } from "react";
+import { useEffect as useEffect23 } from "react";
 
 // src/components/utils/decamelize.ts
-var import_decamelize = __toModule(require_decamelize());
-var decamelize = (input, options) => {
-  var _a;
-  return (0, import_decamelize.default)(input, { separator: (_a = options == null ? void 0 : options.separator) != null ? _a : "-" });
-};
+function decamelize(str, options) {
+  const { separator } = options != null ? options : { separator: "-" };
+  return str.replace(/([a-z\d])([A-Z])/g, "$1" + separator + "$2").replace(new RegExp("(" + separator + "[A-Z])([A-Z])", "g"), "$1" + separator + "$2").toLowerCase();
+}
 
 // src/components/InfiniteTable/components/InfiniteTableLicenseFooter/index.tsx
 var defaultStyle2 = {
@@ -6872,7 +7076,7 @@ var enforceStyle = (node, style) => {
 };
 var InfiniteTableLicenseFooter = forwardRef3(function InfiniteTableLicenseFooter2(props, ref) {
   const { rootClassName: rootClassName12 } = useInternalProps();
-  const domRef = useRef16(null);
+  const domRef = useRef18(null);
   const domCallback = useCallback18((node) => {
     domRef.current = node;
     if (!ref) {
@@ -6884,7 +7088,7 @@ var InfiniteTableLicenseFooter = forwardRef3(function InfiniteTableLicenseFooter
       ref.current = node;
     }
   }, []);
-  useEffect21(() => {
+  useEffect23(() => {
     const forceStyle = () => {
       requestAnimationFrame(() => {
         var _a;
@@ -7065,7 +7269,7 @@ var useLicense = (licenseKey = "") => {
   const valid = useMemo11(() => {
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "0.0.8"
+      version: "0.1.1"
     });
     if (!licenseKey && !valid2 && isInsideSandbox) {
       return true;
@@ -7081,7 +7285,7 @@ import {
   useCallback as useCallback19,
   useLayoutEffect as useLayoutEffect5
 } from "react";
-import { useRef as useRef17 } from "react";
+import { useRef as useRef19 } from "react";
 var error = err("CSSVariableWatch");
 var debug5 = dbg("CSSVariableWatch");
 var WRAPPER_STYLE = {
@@ -7094,7 +7298,7 @@ var WRAPPER_STYLE = {
   overflow: "hidden"
 };
 var useCSSVariableWatch = (params) => {
-  const lastValueRef = useRef17(0);
+  const lastValueRef = useRef19(0);
   const onResize = useCallback19(({ height }) => {
     if (height && height !== lastValueRef.current) {
       lastValueRef.current = height;
@@ -7114,7 +7318,7 @@ var useCSSVariableWatch = (params) => {
   }, []);
 };
 var CSSVariableWatch = (props) => {
-  const domRef = useRef17(null);
+  const domRef = useRef19(null);
   useCSSVariableWatch(__spreadProps(__spreadValues({}, props), {
     ref: domRef
   }));
@@ -7259,9 +7463,15 @@ var InfiniteTableRoot = getComponentStateRoot({
 });
 var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
   var _a;
-  const { componentState, getComputed, computed } = useInfiniteTable();
   const {
-    componentState: { dataArray, loading }
+    componentState,
+    getComputed,
+    computed,
+    getState: getInfiniteTableState
+  } = useInfiniteTable();
+  const {
+    componentState: { dataArray, loading },
+    getState: getDataSourceState
   } = useDataSourceContextValue();
   const {
     domRef,
@@ -7298,6 +7508,15 @@ var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
   const licenseValid = useLicense(licenseKey);
   const domProps = useDOMProps(componentState.domProps);
   const LoadMaskCmp = (_a = components == null ? void 0 : components.LoadMask) != null ? _a : LoadMask;
+  useLayoutEffect6(() => {
+    const dataSourceState = getDataSourceState();
+    const { onScrollbarsChange } = getInfiniteTableState();
+    const { notifyScrollbarsChange } = dataSourceState;
+    if (onScrollbarsChange && dataSourceState.updatedAt && dataSourceState.dataArray.length) {
+      onScrollbarsChange(scrollbars);
+    }
+    notifyScrollbarsChange(scrollbars);
+  }, [scrollbars]);
   return /* @__PURE__ */ createElement33("div", __spreadValues({
     ref: domRef
   }, domProps), header ? /* @__PURE__ */ createElement33(TableHeaderWrapper, {
@@ -7329,7 +7548,7 @@ var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
 });
 function InfiniteTableContextProvider() {
   const { componentActions, componentState } = useComponentState();
-  const { scrollerDOMRef } = componentState;
+  const { scrollerDOMRef, scrollTopId } = componentState;
   const computed = useComputed();
   const getComputed = useLatest(computed);
   const getState = useLatest(componentState);
@@ -7358,12 +7577,17 @@ function InfiniteTableContextProvider() {
     }
     componentActions.bodySize = bodySize;
   }, { earlyAttach: true });
-  useEffect22(() => {
+  useEffect24(() => {
     return () => {
       componentState.onRowHeightCSSVarChange.destroy();
       componentState.onHeaderHeightCSSVarChange.destroy();
     };
   }, []);
+  useEffect24(() => {
+    if (scrollerDOMRef.current) {
+      scrollerDOMRef.current.scrollTop = 0;
+    }
+  }, [scrollTopId, scrollerDOMRef]);
   const TableContext2 = getInfiniteTableContext();
   return /* @__PURE__ */ createElement33(TableContext2.Provider, {
     value: contextValue
@@ -7388,6 +7612,7 @@ export {
   getComponentStateRoot,
   group,
   interceptMap,
+  multisort,
   useComponentState,
   useDataSource
 };