@infinite-table/infinite-react 0.0.10 → 0.1.0

package/index.js

@@ -639,7 +639,7 @@ __export(exports, {
 });
 
 // src/components/InfiniteTable/index.tsx
-var React36 = __toModule(require("react"));
+var React35 = __toModule(require("react"));
 
 // src/components/InfiniteTable/internalProps.ts
 var rootClassName = "Infinite";
@@ -719,6 +719,17 @@ 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 map2 = new Map();
@@ -742,15 +753,6 @@ function computeColumnGroupsDepths(columnGroups) {
 }
 
 // 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);
 }
@@ -820,6 +822,7 @@ var forwardProps = () => {
     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",
@@ -831,7 +834,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;
@@ -841,21 +847,20 @@ var forwardProps = () => {
       var _a;
       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";
@@ -866,16 +871,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,
@@ -1653,37 +1659,10 @@ var useComputedVisibleColumns = ({
 var sortAscending = (a, b) => a - b;
 
 // src/components/InfiniteTable/hooks/useComputed.ts
-var import_react20 = __toModule(require("react"));
-
-// src/components/InfiniteTable/hooks/useColumnAggregations.ts
-var import_react12 = __toModule(require("react"));
-
-// src/components/DataSource/publicHooks/useDataSourceActions.ts
-var React3 = __toModule(require("react"));
-
-// src/components/DataSource/DataSourceContext.ts
-var React2 = __toModule(require("react"));
-var DSContext;
-function getDataSourceContext() {
-  if (DSContext) {
-    return DSContext;
-  }
-  return DSContext = React2.createContext({
-    getState: () => null,
-    componentState: null,
-    componentActions: null
-  });
-}
-
-// src/components/DataSource/publicHooks/useDataSourceActions.ts
-function useDataSourceActions() {
-  const DataSourceContext = getDataSourceContext();
-  const contextValue = React3.useContext(DataSourceContext);
-  return contextValue.componentActions;
-}
+var import_react19 = __toModule(require("react"));
 
 // src/components/hooks/useComponentState.tsx
-var React4 = __toModule(require("react"));
+var React2 = __toModule(require("react"));
 var import_react11 = __toModule(require("react"));
 
 // src/utils/proxyFnCall.ts
@@ -1813,7 +1792,7 @@ function forwardProps2(propsToForward, props) {
   return mappedState;
 }
 function getComponentStateRoot(config) {
-  return React4.memo(function ComponentStateRoot(props) {
+  return React2.memo(function ComponentStateRoot(props) {
     var _a, _b;
     const propsToStateSetRef = (0, import_react11.useRef)(new Set());
     const propsToForward = (0, import_react11.useMemo)(() => config.forwardProps ? config.forwardProps() : {}, []);
@@ -1918,7 +1897,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];
@@ -1948,61 +1927,47 @@ function getComponentStateRoot(config) {
         });
       }
     });
-    return /* @__PURE__ */ React4.createElement(Context.Provider, {
+    return /* @__PURE__ */ React2.createElement(Context.Provider, {
       value: contextValue
     }, props.children);
   });
 }
 function useComponentState() {
   const Context = getComponentStateContext();
-  return React4.useContext(Context);
+  return React2.useContext(Context);
 }
 
-// src/components/InfiniteTable/hooks/useColumnAggregations.ts
-function useColumnAggregations() {
-  const {
-    componentState: { columnAggregations },
-    getComponentState
-  } = useComponentState();
-  const dataSourceActions = useDataSourceActions();
-  (0, import_react12.useEffect)(() => {
-    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]);
+// src/components/DataSource/publicHooks/useDataSource.ts
+var React4 = __toModule(require("react"));
+
+// src/components/DataSource/DataSourceContext.ts
+var React3 = __toModule(require("react"));
+var DSContext;
+function getDataSourceContext() {
+  if (DSContext) {
+    return DSContext;
+  }
+  return DSContext = React3.createContext({
+    getState: () => null,
+    componentState: null,
+    componentActions: null
+  });
 }
 
 // src/components/DataSource/publicHooks/useDataSource.ts
-var React5 = __toModule(require("react"));
 function useDataSource() {
   const DataSourceContext = getDataSourceContext();
-  const contextValue = React5.useContext(DataSourceContext);
+  const contextValue = React4.useContext(DataSourceContext);
   return contextValue.componentState;
 }
 function useDataSourceContextValue() {
   const DataSourceContext = getDataSourceContext();
-  const contextValue = React5.useContext(DataSourceContext);
+  const contextValue = React4.useContext(DataSourceContext);
   return contextValue;
 }
 
 // src/components/InfiniteTable/hooks/useColumnGroups.ts
-var import_react13 = __toModule(require("react"));
+var import_react12 = __toModule(require("react"));
 function useColumnGroups() {
   const {
     componentState: {
@@ -2012,7 +1977,7 @@ function useColumnGroups() {
     componentActions,
     getComponentState
   } = useComponentState();
-  (0, import_react13.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     const recompute = () => {
       componentActions.columnGroupsDepthsMap = computeColumnGroupsDepths(computedColumnGroups);
     };
@@ -2023,7 +1988,7 @@ function useColumnGroups() {
       set: update
     });
   }, [computedColumnGroups]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     return interceptMap(collapsedColumnGroups, {
       set: (key, visibleCol) => {
         const colIds = key.slice(1);
@@ -2055,41 +2020,28 @@ function useColumnGroups() {
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
-var import_react19 = __toModule(require("react"));
+var import_react18 = __toModule(require("react"));
 
 // src/components/InfiniteTable/state/getComputedPivotColumnsFromDataSourcePivotColumns.tsx
-var React7 = __toModule(require("react"));
+var React6 = __toModule(require("react"));
 
 // src/utils/join.ts
 var join = (...args) => args.filter((x) => !!`${x}`).join(" ");
 
 // src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
-var React6 = __toModule(require("react"));
-var import_react14 = __toModule(require("react"));
+var React5 = __toModule(require("react"));
+var import_react13 = __toModule(require("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) {
   var _a;
   const { size = 24 } = props;
-  const [expanded, setExpanded] = (0, import_react14.useState)((_a = props.expanded) != null ? _a : props.defaultExpanded);
+  const [expanded, setExpanded] = (0, import_react13.useState)((_a = props.expanded) != null ? _a : props.defaultExpanded);
   const onClick = () => {
     var _a2;
     (_a2 = props.onChange) == null ? void 0 : _a2.call(props, !expanded);
@@ -2097,12 +2049,12 @@ function ExpanderIcon(props) {
       setExpanded(!expanded);
     }
   };
-  React6.useEffect(() => {
+  React5.useEffect(() => {
     if (isControlled("expanded", props)) {
       setExpanded(props.expanded);
     }
   }, [props.expanded]);
-  return /* @__PURE__ */ React6.createElement("svg", {
+  return /* @__PURE__ */ React5.createElement("svg", {
     "data-name": "expander-icon",
     xmlns: "http://www.w3.org/2000/svg",
     height: `${size}px`,
@@ -2110,18 +2062,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"}`)
-  }, /* @__PURE__ */ React6.createElement("path", {
+    className: join(props.className, ExpanderIconCls, ExpanderIconClsVariants({
+      expanded
+    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`)
+  }, /* @__PURE__ */ React5.createElement("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) {
@@ -2131,7 +2102,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
     pivotColumn,
     pivotRowLabelsColumn,
     pivotBy,
-    groupRowsBy,
+    groupBy,
     pivotTotalColumnPosition,
     toggleGroupRow
   } = params;
@@ -2148,7 +2119,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
           column = __spreadValues(__spreadValues({}, column), pivotColumn({
             column,
             pivotBy,
-            groupRowsBy
+            groupBy
           }));
         } else {
           column = __spreadValues(__spreadValues({}, column), pivotColumn);
@@ -2160,7 +2131,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
           column = __spreadValues(__spreadValues({}, column), pivotRowLabelsColumn({
             column,
             pivotBy,
-            groupRowsBy
+            groupBy
           }));
         } else {
           column = __spreadValues(__spreadValues({}, column), pivotRowLabelsColumn);
@@ -2169,19 +2140,19 @@ 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;
-          return /* @__PURE__ */ React7.createElement("div", {
+          const showExpanderIcon = (((_a = rowInfo.groupKeys) == null ? void 0 : _a.length) || 0) < groupBy2.length;
+          return /* @__PURE__ */ React6.createElement("div", {
             className: join(display.flex, alignItems.center, GroupRowExpanderCls)
-          }, showExpanderIcon ? /* @__PURE__ */ React7.createElement(ExpanderIcon, {
+          }, showExpanderIcon ? /* @__PURE__ */ React6.createElement(ExpanderIcon, {
             expanded: !rowInfo.collapsed,
             onChange: () => {
               toggleGroupRow(rowInfo.groupKeys);
             }
-          }) : null, /* @__PURE__ */ React7.createElement("div", {
+          }) : null, /* @__PURE__ */ React6.createElement("div", {
             className: cssEllipsisClassName
           }, value != null ? value : null));
         };
@@ -2198,7 +2169,7 @@ function getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, params)
 }
 
 // src/components/InfiniteTable/utils/getColumnForGroupBy.tsx
-var React8 = __toModule(require("react"));
+var React7 = __toModule(require("react"));
 function getGroupColumnRender({
   groupIndexForColumn,
   groupRenderStrategy,
@@ -2231,14 +2202,14 @@ function getGroupColumnRender({
         return null;
       }
     }
-    return /* @__PURE__ */ React8.createElement("div", {
+    return /* @__PURE__ */ React7.createElement("div", {
       className: join(display.flex, alignItems.center)
-    }, /* @__PURE__ */ React8.createElement(ExpanderIcon, {
+    }, /* @__PURE__ */ React7.createElement(ExpanderIcon, {
       expanded: !collapsed,
       onChange: () => {
         toggleGroupRow(groupKeys);
       }
-    }), /* @__PURE__ */ React8.createElement("div", {
+    }), /* @__PURE__ */ React7.createElement("div", {
       className: cssEllipsisClassName
     }, value != null ? value : null));
   };
@@ -2271,7 +2242,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;
@@ -2281,14 +2252,14 @@ function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
       if (column.renderValue) {
         value = column.renderValue(renderOptions);
       }
-      return /* @__PURE__ */ React8.createElement("div", {
+      return /* @__PURE__ */ React7.createElement("div", {
         className: join(display.flex, alignItems.center, GroupRowExpanderCls)
-      }, /* @__PURE__ */ React8.createElement(ExpanderIcon, {
+      }, /* @__PURE__ */ React7.createElement(ExpanderIcon, {
         expanded: !rowInfo.collapsed,
         onChange: () => {
           toggleGroupRow(rowInfo.groupKeys);
         }
-      }), /* @__PURE__ */ React8.createElement("div", {
+      }), /* @__PURE__ */ React7.createElement("div", {
         className: cssEllipsisClassName
       }, value != null ? value : null));
     }
@@ -2304,10 +2275,10 @@ function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
 }
 
 // src/components/InfiniteTable/hooks/useToggleGroupRow.ts
-var import_react18 = __toModule(require("react"));
+var import_react17 = __toModule(require("react"));
 
 // src/components/DataSource/index.tsx
-var React9 = __toModule(require("react"));
+var React8 = __toModule(require("react"));
 
 // src/utils/multisort/sortTypes.ts
 var numberComparator = function(first, second) {
@@ -2384,15 +2355,15 @@ var getMultisortFunction = (sortInfo, get) => {
 };
 
 // src/components/DataSource/privateHooks/useLoadData.ts
-var import_react16 = __toModule(require("react"));
+var import_react15 = __toModule(require("react"));
 
 // src/components/hooks/useEffectWithChanges.ts
-var import_react15 = __toModule(require("react"));
+var import_react14 = __toModule(require("react"));
 function useEffectWithChanges(fn, deps) {
-  const prevRef = (0, import_react15.useRef)({});
-  const oldValuesRef = (0, import_react15.useRef)({});
+  const prevRef = (0, import_react14.useRef)({});
+  const oldValuesRef = (0, import_react14.useRef)({});
   const oldValues = oldValuesRef.current;
-  const changesRef = (0, import_react15.useRef)({});
+  const changesRef = (0, import_react14.useRef)({});
   const changes = changesRef.current;
   const useEffectDeps = [];
   for (let k in deps) {
@@ -2405,7 +2376,7 @@ function useEffectWithChanges(fn, deps) {
     }
   }
   prevRef.current = deps;
-  (0, import_react15.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     const changes2 = changesRef.current;
     const result = fn(changes2, oldValues);
     changesRef.current = {};
@@ -2421,7 +2392,7 @@ function buildDataSourceDataParams(componentState) {
   const dataSourceParams = {
     originalDataArray: componentState.originalDataArray,
     sortInfo,
-    groupRowsBy: componentState.groupRowsBy,
+    groupBy: componentState.groupBy,
     pivotBy: componentState.pivotBy
   };
   if (componentState.livePagination !== void 0) {
@@ -2469,7 +2440,7 @@ function useLoadData() {
     componentActions: actions,
     componentState: { data }
   } = useComponentState();
-  (0, import_react16.useLayoutEffect)(() => {
+  (0, import_react15.useLayoutEffect)(() => {
     loadData(data, getComponentState(), actions);
   }, [data]);
   useLivePagination();
@@ -2483,17 +2454,17 @@ function useLivePagination() {
   const {
     notifyScrollbarsChange,
     sortInfo,
-    groupRowsBy,
+    groupBy,
     pivotBy,
     livePaginationCursor,
     scrollBottomId
   } = componentState;
-  const [scrollbars, setScrollbars] = (0, import_react16.useState)({
+  const [scrollbars, setScrollbars] = (0, import_react15.useState)({
     vertical: false,
     horizontal: false
   });
-  const scrollbarsRef = (0, import_react16.useRef)(scrollbars);
-  (0, import_react16.useEffect)(() => {
+  const scrollbarsRef = (0, import_react15.useRef)(scrollbars);
+  (0, import_react15.useEffect)(() => {
     notifyScrollbarsChange.onChange((scrollbars2) => {
       if (!scrollbars2) {
         return;
@@ -2503,8 +2474,8 @@ function useLivePagination() {
     });
     return () => notifyScrollbarsChange.destroy();
   }, [notifyScrollbarsChange]);
-  const [cursorId, updateCursorId] = (0, import_react16.useState)(void 0);
-  (0, import_react16.useEffect)(() => {
+  const [cursorId, updateCursorId] = (0, import_react15.useState)(void 0);
+  (0, import_react15.useEffect)(() => {
     const frameId = requestAnimationFrame(() => {
       var _a;
       if (!((_a = scrollbarsRef.current) == null ? void 0 : _a.vertical)) {
@@ -2513,18 +2484,18 @@ function useLivePagination() {
     });
     return () => cancelAnimationFrame(frameId);
   }, [livePaginationCursor]);
-  (0, import_react16.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     const { livePaginationCursor: livePaginationCursor2, livePagination } = getComponentState();
     if (!scrollbars.vertical && livePagination) {
       updateCursorId(livePaginationCursor2);
     }
   }, [scrollbars.vertical]);
-  (0, import_react16.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     updateCursorId(scrollBottomId);
   }, [scrollBottomId]);
   const depsObject = {
     sortInfo,
-    groupRowsBy,
+    groupBy,
     pivotBy,
     cursorId
   };
@@ -2543,7 +2514,7 @@ var normalizeSortInfo = (sortInfo) => {
 };
 
 // src/components/hooks/useOnce.ts
-var import_react17 = __toModule(require("react"));
+var import_react16 = __toModule(require("react"));
 function once(fn) {
   let called = false;
   let result = null;
@@ -2558,7 +2529,7 @@ function once(fn) {
   return onceFn;
 }
 function useOnce(fn) {
-  const onceFn = (0, import_react17.useMemo)(() => {
+  const onceFn = (0, import_react16.useMemo)(() => {
     return once(fn);
   }, []);
   return onceFn();
@@ -2605,6 +2576,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) {
@@ -2981,6 +2959,7 @@ function initSetupState2() {
     pivotTotalColumnPosition: "end",
     originalDataArray,
     scrollBottomId: Symbol("scrollBottomId"),
+    showSeparatePivotColumnForSingleAggregation: false,
     pivotColumns: void 0,
     pivotColumnGroups: void 0,
     dataArray,
@@ -2989,7 +2968,6 @@ function initSetupState2() {
     sortedAt: 0,
     reducedAt: now,
     generateGroupRows: true,
-    aggregationReducers: void 0,
     groupDeepMap: void 0,
     postSortDataArray: void 0,
     postGroupDataArray: void 0,
@@ -3005,15 +2983,15 @@ function getCompareObject(dataParams) {
 var forwardProps3 = () => {
   return {
     onDataParamsChange: (fn) => fn ? discardCallsWithEqualArg(fn, 100, getCompareObject) : void 0,
-    remoteCount: 1,
     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,
@@ -3045,19 +3023,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 {
@@ -3072,7 +3059,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++) {
@@ -3082,7 +3069,7 @@ function group(groupParams, data) {
       if (!deepMap.has(currentGroupKeys)) {
         const deepMapGroupValue = {
           items: [],
-          reducerResults: [...initialReducerValue]
+          reducerResults: __spreadValues({}, initialReducerValue)
         };
         if (pivot) {
           deepMapGroupValue.pivotDeepMap = new DeepMap();
@@ -3106,7 +3093,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: []
             });
           }
@@ -3168,11 +3155,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,
@@ -3194,17 +3193,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);
@@ -3219,6 +3226,7 @@ function enhancedFlatten(param) {
     const enhancedGroupData = getEnhancedGroupData({
       groupBy: groupByStrings,
       parents: Array.from(parents),
+      reducers,
       indexInGroup,
       indexInParentGroups: Array.from(indexInParentGroups),
       indexInAll: result.length,
@@ -3271,13 +3279,45 @@ function enhancedFlatten(param) {
 }
 
 // src/utils/groupAndPivot/getPivotColumnsAndColumnGroups.ts
-function getPivotColumnsAndColumnGroups(deepMap, pivotBy, pivotTotalColumnPosition) {
+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);
+    }
+  }
+  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 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;
@@ -3287,72 +3327,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) {
@@ -3362,9 +3434,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];
       }
     });
   }
@@ -3388,7 +3463,14 @@ 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;
@@ -3400,17 +3482,18 @@ function concludeReducer(params) {
     "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);
@@ -3436,13 +3519,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 {
@@ -3483,7 +3573,7 @@ function DataSourceWithContext(props) {
   if (typeof children === "function") {
     children = children(computedValues);
   }
-  return /* @__PURE__ */ React9.createElement(React9.Fragment, null, children);
+  return /* @__PURE__ */ React8.createElement(React8.Fragment, null, children);
 }
 var DataSourceRoot = getComponentStateRoot({
   initSetupState: initSetupState2,
@@ -3505,14 +3595,14 @@ function DataSourceCmp({ children }) {
     globalThis.getDataSourceState = getState;
   }
   useLoadData();
-  return /* @__PURE__ */ React9.createElement(DataSourceContext.Provider, {
+  return /* @__PURE__ */ React8.createElement(DataSourceContext.Provider, {
     value: contextValue
-  }, /* @__PURE__ */ React9.createElement(DataSourceWithContext, {
+  }, /* @__PURE__ */ React8.createElement(DataSourceWithContext, {
     children
   }));
 }
 function DataSource(props) {
-  return /* @__PURE__ */ React9.createElement(DataSourceRoot, __spreadValues({}, props), /* @__PURE__ */ React9.createElement(DataSourceCmp, {
+  return /* @__PURE__ */ React8.createElement(DataSourceRoot, __spreadValues({}, props), /* @__PURE__ */ React8.createElement(DataSourceCmp, {
     children: props.children
   }));
 }
@@ -3520,7 +3610,7 @@ function DataSource(props) {
 // src/components/InfiniteTable/hooks/useToggleGroupRow.ts
 function useToggleGroupRow() {
   const { getState: getDataSourceState, componentActions: dataSourceActions } = useDataSourceContextValue();
-  const toggleGroupRow = (0, import_react18.useCallback)((groupKeys) => {
+  const toggleGroupRow = (0, import_react17.useCallback)((groupKeys) => {
     const newState = new GroupRowsState(getDataSourceState().groupRowsState);
     newState.toggleGroupRow(groupKeys);
     dataSourceActions.groupRowsState = newState;
@@ -3529,49 +3619,49 @@ function useToggleGroupRow() {
 }
 
 // src/components/InfiniteTable/hooks/useColumnsWhen.ts
-function useGroupRowsMap(groupRowsBy) {
-  const groupRowsMap = (0, import_react19.useMemo)(() => {
-    return groupRowsBy.reduce((acc, groupBy, index) => {
-      acc.set(groupBy.field, {
-        groupBy,
+function useGroupByMap(groupBy) {
+  const groupByMap = (0, import_react18.useMemo)(() => {
+    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);
-  (0, import_react19.useEffect)(() => {
+  const groupByMap = useGroupByMap(groupBy);
+  (0, import_react18.useEffect)(() => {
     dataSourceActions.generateGroupRows = groupRenderStrategy !== "inline";
   }, [groupRenderStrategy]);
-  (0, import_react19.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     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;
@@ -3616,9 +3706,9 @@ function useColumnsWhenInlineGroupRenderStrategy(groupRowsMap) {
     });
     return computedColumns.size === 0 ? void 0 : computedColumns;
   }
-  (0, import_react19.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     const update = () => {
-      componentActions.columnsWhenInlineGroupRenderStrategy = computeColumnsWhenInlineGroupRenderStrategy(columns, groupRowsMap, groupRenderStrategy, toggleGroupRow);
+      componentActions.columnsWhenInlineGroupRenderStrategy = computeColumnsWhenInlineGroupRenderStrategy(columns, groupByMap, groupRenderStrategy, toggleGroupRow);
     };
     update();
     return interceptMap(columns, {
@@ -3626,11 +3716,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,
@@ -3642,13 +3732,13 @@ function useColumnsWhenPivoting() {
     }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  (0, import_react19.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     const computedPivotColumns = getComputedPivotColumnsFromDataSourcePivotColumns(pivotColumns, {
       pivotColumn,
       pivotRowLabelsColumn,
       pivotTotalColumnPosition,
       pivotBy,
-      groupRowsBy,
+      groupBy,
       toggleGroupRow
     });
     componentActions.computedPivotColumns = computedPivotColumns;
@@ -3656,14 +3746,14 @@ function useColumnsWhenPivoting() {
 }
 function useColumnsWhenGrouping() {
   const {
-    componentState: { groupRowsBy }
+    componentState: { groupBy }
   } = useDataSourceContextValue();
   const {
     componentActions,
     componentState: { columns, groupColumn, groupRenderStrategy, pivotColumns }
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
-  (0, import_react19.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     if (pivotColumns) {
       return;
     }
@@ -3672,7 +3762,7 @@ function useColumnsWhenGrouping() {
         columns,
         groupColumn,
         groupRenderStrategy,
-        groupRowsBy,
+        groupBy,
         pivotColumns,
         toggleGroupRow
       });
@@ -3684,11 +3774,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 {
@@ -3700,11 +3790,11 @@ function useHideEmptyGroupColumns(groupRowsMap) {
       groupRenderStrategy
     }
   } = useComponentState();
-  (0, import_react19.useEffect)(() => {
-    if (groupRenderStrategy === "single-column") {
+  (0, import_react18.useEffect)(() => {
+    if (groupRenderStrategy !== "multi-column") {
       return;
     }
-    const groupsLength = groupRowsBy.length;
+    const groupsLength = groupBy.length;
     let expandedGroupsLevel = 0;
     const { dataArray } = getDataSourceState();
     const len = dataArray.length;
@@ -3720,15 +3810,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);
@@ -3741,7 +3831,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
     getDataSourceState,
     groupRenderStrategy,
     generatedColumns,
-    groupRowsBy,
+    groupBy,
     groupRowsMap,
     hideEmptyGroupColumns ? groupRowsState : null,
     hideEmptyGroupColumns
@@ -3750,7 +3840,7 @@ function useHideEmptyGroupColumns(groupRowsMap) {
 function getColumnsWhenGrouping(params) {
   const {
     pivotColumns,
-    groupRowsBy,
+    groupBy,
     groupColumn,
     groupRenderStrategy,
     toggleGroupRow,
@@ -3764,10 +3854,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
@@ -3776,8 +3866,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);
@@ -3802,9 +3892,10 @@ function useComputed() {
     columnPinning,
     columnSizing,
     columnTypes,
-    bodySize
+    bodySize,
+    showSeparatePivotColumnForSingleAggregation
   } = componentState;
-  (0, import_react20.useState)(() => {
+  (0, import_react19.useState)(() => {
     componentState.onRowHeightCSSVarChange.onChange((rowHeight) => {
       if (rowHeight) {
         componentActions.rowHeight = rowHeight;
@@ -3816,11 +3907,13 @@ function useComputed() {
       }
     });
   });
-  useColumnAggregations();
+  (0, import_react19.useEffect)(() => {
+    dataSourceActions.showSeparatePivotColumnForSingleAggregation = showSeparatePivotColumnForSingleAggregation;
+  }, [showSeparatePivotColumnForSingleAggregation]);
   const { multiSort } = dataSourceState;
   useColumnGroups();
   useColumnsWhen();
-  const setSortInfo = (0, import_react20.useCallback)((sortInfo) => {
+  const setSortInfo = (0, import_react19.useCallback)((sortInfo) => {
     var _a2;
     const newSortInfo = multiSort ? sortInfo : (_a2 = sortInfo[0]) != null ? _a2 : null;
     dataSourceActions.sortInfo = newSortInfo;
@@ -3911,7 +4004,7 @@ function useComputed() {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableBody/InfiniteTableBody.tsx
-var React10 = __toModule(require("react"));
+var React9 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useInternalProps.ts
 var useInternalProps = () => {
@@ -3919,9 +4012,9 @@ var useInternalProps = () => {
 };
 
 // src/components/InfiniteTable/components/InfiniteTableBody/InfiniteTableBody.tsx
-var InfiniteTableBody = React10.forwardRef(function InfiniteTableBody2(props, ref) {
+var InfiniteTableBody = React9.forwardRef(function InfiniteTableBody2(props, ref) {
   const { rootClassName: rootClassName12 } = useInternalProps();
-  return /* @__PURE__ */ React10.createElement("div", __spreadProps(__spreadValues({
+  return /* @__PURE__ */ React9.createElement("div", __spreadProps(__spreadValues({
     ref
   }, props), {
     className: join(`${rootClassName12}Body`, position.relative, flex["1"], transformTranslateZero, props.className)
@@ -3929,16 +4022,16 @@ var InfiniteTableBody = React10.forwardRef(function InfiniteTableBody2(props, re
 });
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderWrapper.tsx
-var React22 = __toModule(require("react"));
+var React21 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/ScrollbarPlaceholder.tsx
-var React11 = __toModule(require("react"));
+var React10 = __toModule(require("react"));
 function HorizontalScrollbarPlaceholderFn(props) {
   const scrollbarWidth2 = getScrollbarWidth();
   if (!scrollbarWidth2) {
     return null;
   }
-  return /* @__PURE__ */ React11.createElement("div", {
+  return /* @__PURE__ */ React10.createElement("div", {
     "data-name": "horizontal-scrollbar-placeholder",
     style: __spreadValues({
       position: "absolute",
@@ -3948,13 +4041,13 @@ function HorizontalScrollbarPlaceholderFn(props) {
     }, props.style)
   });
 }
-var HorizontalScrollbarPlaceholder = React11.memo(HorizontalScrollbarPlaceholderFn);
+var HorizontalScrollbarPlaceholder = React10.memo(HorizontalScrollbarPlaceholderFn);
 function VerticalScrollbarPlaceholderFn(props) {
   const scrollbarWidth2 = getScrollbarWidth();
   if (!scrollbarWidth2) {
     return null;
   }
-  return /* @__PURE__ */ React11.createElement("div", {
+  return /* @__PURE__ */ React10.createElement("div", {
     "data-name": "vertical-scrollbar-placeholder",
     style: __spreadValues({
       position: "absolute",
@@ -3964,14 +4057,14 @@ function VerticalScrollbarPlaceholderFn(props) {
     }, props.style)
   });
 }
-var VerticalScrollbarPlaceholder = React11.memo(VerticalScrollbarPlaceholderFn);
+var VerticalScrollbarPlaceholder = React10.memo(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";
@@ -3979,29 +4072,29 @@ var HeaderSortIconCls = "_12zfob11 _16lm1iw1";
 var HeaderWrapperCls = "_12zfob1v _16lm1iw16 _16lm1iw1 _16lm1iwj _16lm1iw10";
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeader.tsx
-var React18 = __toModule(require("react"));
-var import_react28 = __toModule(require("react"));
+var React17 = __toModule(require("react"));
+var import_react27 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderCell.tsx
-var React14 = __toModule(require("react"));
-var import_react24 = __toModule(require("react"));
+var React13 = __toModule(require("react"));
+var import_react23 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
-var React12 = __toModule(require("react"));
+var React11 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useInfiniteTableState.ts
-var import_react21 = __toModule(require("react"));
+var import_react20 = __toModule(require("react"));
 var useInfiniteTableState = () => {
   const TableContext2 = getInfiniteTableContext();
-  const { componentState } = (0, import_react21.useContext)(TableContext2);
+  const { componentState } = (0, import_react20.useContext)(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
@@ -4046,20 +4139,20 @@ function InfiniteTableCellFn(props) {
       style.transform = `translate3d(${shiftLeft}px, 0px, 0px)`;
     }
   }
-  return /* @__PURE__ */ React12.createElement("div", __spreadProps(__spreadValues({}, domProps), {
+  return /* @__PURE__ */ React11.createElement("div", __spreadProps(__spreadValues({}, domProps), {
     ref: domRef,
     style,
     "data-name": `Cell`,
     className: join(domProps.className, columnAlignCellStyle[(_b = column.align) != null ? _b : "start"], justifyContent[(_c = column.align) != null ? _c : "start"], InfiniteTableCellClassName, CellCls2, shifting ? `${InfiniteTableCellClassName}--shifting ${CellClsVariants.shifting}` : "")
-  }), beforeChildren, cssEllipsis ? /* @__PURE__ */ React12.createElement("div", {
+  }), beforeChildren, cssEllipsis ? /* @__PURE__ */ React11.createElement("div", {
     className: `${rootClassName2}Cell_content ${cssEllipsisClassName}`
   }, children) : children, afterChildren);
 }
-var InfiniteTableCell = React12.memo(InfiniteTableCellFn);
+var InfiniteTableCell = React11.memo(InfiniteTableCellFn);
 
 // src/components/InfiniteTable/hooks/useColumnPointerEvents.ts
 var import_binary_search = __toModule(require_binary_search());
-var import_react22 = __toModule(require("react"));
+var import_react21 = __toModule(require("react"));
 
 // src/components/InfiniteTable/utils/moveXatY.ts
 var moveXatY = (arr, dragIndex, dropIndex) => {
@@ -4093,18 +4186,18 @@ var useColumnPointerEvents = ({
   columns,
   computedRemainingSpace
 }) => {
-  const [draggingDiff, setDraggingDiff] = (0, import_react22.useState)(null);
-  const [proxyOffset, setProxyOffset] = (0, import_react22.useState)(null);
-  const breakpointsRef = (0, import_react22.useRef)([]);
-  const pointerMoveRef = (0, import_react22.useRef)(null);
-  const didDragRef = (0, import_react22.useRef)(false);
-  const initialClientPos = (0, import_react22.useRef)(null);
-  const currentDropIndexRef = (0, import_react22.useRef)(null);
+  const [draggingDiff, setDraggingDiff] = (0, import_react21.useState)(null);
+  const [proxyOffset, setProxyOffset] = (0, import_react21.useState)(null);
+  const breakpointsRef = (0, import_react21.useRef)([]);
+  const pointerMoveRef = (0, import_react21.useRef)(null);
+  const didDragRef = (0, import_react21.useRef)(false);
+  const initialClientPos = (0, import_react21.useRef)(null);
+  const currentDropIndexRef = (0, import_react21.useRef)(null);
   const dragging = draggingDiff != null;
   const { componentActions, computed } = useInfiniteTable();
   const { computedColumnOrder } = computed;
-  const column = (0, import_react22.useMemo)(() => columns.get(columnId), [columnId, columns]);
-  const { columnIndex, columnWidth, columnsArray } = (0, import_react22.useMemo)(() => {
+  const column = (0, import_react21.useMemo)(() => columns.get(columnId), [columnId, columns]);
+  const { columnIndex, columnWidth, columnsArray } = (0, import_react21.useMemo)(() => {
     const columnsArray2 = Array.from(columns.values());
     return {
       columnsArray: columnsArray2,
@@ -4112,8 +4205,8 @@ var useColumnPointerEvents = ({
       columnWidth: column.computedWidth
     };
   }, [columns, columnId, column]);
-  let cursorRef = (0, import_react22.useRef)("auto");
-  const onPointerDown = (0, import_react22.useCallback)((e) => {
+  let cursorRef = (0, import_react21.useRef)("auto");
+  const onPointerDown = (0, import_react21.useCallback)((e) => {
     const target = domRef.current;
     cursorRef.current = target.style.cursor;
     didDragRef.current = false;
@@ -4176,7 +4269,7 @@ var useColumnPointerEvents = ({
     target.addEventListener("pointermove", onPointerMove);
     target.setPointerCapture(e.pointerId);
   }, [columns, column, columnIndex, columnsArray, computedRemainingSpace]);
-  const onPointerUp = (0, import_react22.useCallback)((e) => {
+  const onPointerUp = (0, import_react21.useCallback)((e) => {
     const target = domRef.current;
     target.style.cursor = cursorRef.current;
     target.releasePointerCapture(e.pointerId);
@@ -4250,8 +4343,8 @@ function useCellClassName(column, baseClasses, variants, extraFlags) {
 var import_react_dom = __toModule(require("react-dom"));
 
 // src/components/InfiniteTable/components/icons/SortIcon.tsx
-var React13 = __toModule(require("react"));
-var import_react23 = __toModule(require("react"));
+var React12 = __toModule(require("react"));
+var import_react22 = __toModule(require("react"));
 var defaultLineStyle = {
   marginTop: 2,
   marginBottom: 2,
@@ -4259,8 +4352,8 @@ var defaultLineStyle = {
 };
 function SortIcon(props) {
   var _a;
-  const [rendered, setRendered] = (0, import_react23.useState)(true);
-  const [opacity, setOpacity] = (0, import_react23.useState)(0);
+  const [rendered, setRendered] = (0, import_react22.useState)(true);
+  const [opacity, setOpacity] = (0, import_react22.useState)(0);
   const { direction, lineWidth = 1, style, className, index } = props;
   const showIndex = index != null && index > 0;
   const size = (_a = props.size) != null ? _a : 16;
@@ -4274,7 +4367,7 @@ function SortIcon(props) {
   }), props.lineStyle), {
     opacity
   });
-  (0, import_react23.useEffect)(() => {
+  (0, import_react22.useEffect)(() => {
     const newOpacity = direction != 0 ? 1 : 0;
     if (!rendered && newOpacity) {
       setRendered(true);
@@ -4304,18 +4397,18 @@ function SortIcon(props) {
   if (direction === -1) {
     indexStyle.top = "100%";
   }
-  return /* @__PURE__ */ React13.createElement("div", {
+  return /* @__PURE__ */ React12.createElement("div", {
     style: __spreadProps(__spreadValues({}, style), { width: size }),
     className: join(className, "ITableIcon", "ITableIcon-sort")
-  }, showIndex ? /* @__PURE__ */ React13.createElement("div", {
+  }, showIndex ? /* @__PURE__ */ React12.createElement("div", {
     "data-name": "index",
     style: indexStyle
-  }, index) : null, /* @__PURE__ */ React13.createElement("div", {
+  }, index) : null, /* @__PURE__ */ React12.createElement("div", {
     style: __spreadValues({ width: sizes[0] }, lineStyle),
     onTransitionEnd
-  }), /* @__PURE__ */ React13.createElement("div", {
+  }), /* @__PURE__ */ React12.createElement("div", {
     style: __spreadValues({ width: sizes[1] }, lineStyle)
-  }), /* @__PURE__ */ React13.createElement("div", {
+  }), /* @__PURE__ */ React12.createElement("div", {
     style: __spreadValues({ width: sizes[2] }, lineStyle)
   }));
 }
@@ -4346,13 +4439,13 @@ function InfiniteTableHeaderCell(props) {
     });
   }
   header = header != null ? header : column.name;
-  const sortTool = /* @__PURE__ */ React14.createElement(SortIcon, {
+  const sortTool = /* @__PURE__ */ React13.createElement(SortIcon, {
     index: column.computedMultiSort ? column.computedSortIndex + 1 : void 0,
     className: `${baseCls}__sort-icon ${HeaderSortIconCls}`,
     direction: column.computedSorted ? column.computedSortedAsc ? 1 : -1 : 0
   });
-  const domRef = (0, import_react24.useRef)(null);
-  const ref = (0, import_react24.useCallback)((node) => {
+  const domRef = (0, import_react23.useRef)(null);
+  const ref = (0, import_react23.useCallback)((node) => {
     var _a2;
     domRef.current = node;
     (_a2 = props.domRef) == null ? void 0 : _a2.call(props, node);
@@ -4361,7 +4454,7 @@ function InfiniteTableHeaderCell(props) {
     computed: { computedRemainingSpace },
     componentState: { portalDOMRef }
   } = useInfiniteTable();
-  (0, import_react24.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     let clearOnResize = null;
     const node = domRef.current;
     if (onResize && node) {
@@ -4384,7 +4477,7 @@ function InfiniteTableHeaderCell(props) {
   let offset = offsetFromProps != null ? offsetFromProps : virtualized ? 0 : column.computedPinningOffset;
   let draggingProxy = null;
   if (dragging) {
-    draggingProxy = /* @__PURE__ */ React14.createElement("div", {
+    draggingProxy = /* @__PURE__ */ React13.createElement("div", {
       className: `${baseCls}Proxy ${HeaderCellProxy}`,
       style: {
         position: "absolute",
@@ -4397,7 +4490,7 @@ function InfiniteTableHeaderCell(props) {
     }, header);
     draggingProxy = (0, import_react_dom.createPortal)(draggingProxy, portalDOMRef.current);
   }
-  return /* @__PURE__ */ React14.createElement(React14.Fragment, null, /* @__PURE__ */ React14.createElement(InfiniteTableCell, {
+  return /* @__PURE__ */ React13.createElement(React13.Fragment, null, /* @__PURE__ */ React13.createElement(InfiniteTableCell, {
     domRef: ref,
     column,
     "data-name": `HeaderCell`,
@@ -4413,29 +4506,29 @@ function InfiniteTableHeaderCell(props) {
 }
 
 // src/components/RawList/index.tsx
-var React17 = __toModule(require("react"));
-var import_react27 = __toModule(require("react"));
+var React16 = __toModule(require("react"));
+var import_react26 = __toModule(require("react"));
 
 // src/components/RawList/AvoidReactDiff.tsx
-var React15 = __toModule(require("react"));
-var import_react25 = __toModule(require("react"));
+var React14 = __toModule(require("react"));
+var import_react24 = __toModule(require("react"));
 function AvoidReactDiffFn(props) {
-  const [children, setChildren] = (0, import_react25.useState)(props.updater.get());
-  (0, import_react25.useLayoutEffect)(() => {
+  const [children, setChildren] = (0, import_react24.useState)(props.updater.get());
+  (0, import_react24.useLayoutEffect)(() => {
     const remove = props.updater.onChange((children2) => {
       setChildren(children2);
     });
     return remove;
   }, [props.updater]);
-  return /* @__PURE__ */ React15.createElement(React15.Fragment, null, children);
+  return /* @__PURE__ */ React14.createElement(React14.Fragment, null, children);
 }
-var AvoidReactDiff = React15.memo(AvoidReactDiffFn);
+var AvoidReactDiff = React14.memo(AvoidReactDiffFn);
 
 // src/components/RawList/useVirtualRenderer.ts
-var import_react26 = __toModule(require("react"));
+var import_react25 = __toModule(require("react"));
 
 // src/components/RawList/ReactVirtualRenderer.tsx
-var React16 = __toModule(require("react"));
+var React15 = __toModule(require("react"));
 
 // src/components/RawList/MappedItems.ts
 var MappedItems = class extends Logger {
@@ -4680,7 +4773,7 @@ var ReactVirtualRenderer = class extends Logger {
     };
     this.itemDOMRefs[elementIndex] = domRef;
     this.updaters[elementIndex] = buildSubscriptionCallback();
-    const item = /* @__PURE__ */ React16.createElement(AvoidReactDiff, {
+    const item = /* @__PURE__ */ React15.createElement(AvoidReactDiff, {
       key: elementIndex,
       name: `${elementIndex}`,
       updater: this.updaters[elementIndex]
@@ -4746,7 +4839,7 @@ function createRenderer(brain) {
 function useVirtualRenderer({
   brain
 }) {
-  return (0, import_react26.useMemo)(() => {
+  return (0, import_react25.useMemo)(() => {
     return createRenderer(brain);
   }, [brain]);
 }
@@ -4759,7 +4852,7 @@ function RawListFn(props) {
     debugChannel
   });
   const getRenderItem = useLatest(renderItem);
-  (0, import_react27.useEffect)(() => {
+  (0, import_react26.useEffect)(() => {
     const renderRange = brain.getRenderRange();
     renderer.renderRange(renderRange, {
       renderItem,
@@ -4767,7 +4860,7 @@ function RawListFn(props) {
       onRender: onRenderUpdater
     });
   }, [brain, renderItem, onRenderUpdater]);
-  (0, import_react27.useEffect)(() => {
+  (0, import_react26.useEffect)(() => {
     const remove = brain.onRenderRangeChange((renderRange) => {
       renderer.renderRange(renderRange, {
         force: false,
@@ -4777,11 +4870,11 @@ function RawListFn(props) {
     });
     return remove;
   }, [brain, onRenderUpdater]);
-  return /* @__PURE__ */ React17.createElement(AvoidReactDiff, {
+  return /* @__PURE__ */ React16.createElement(AvoidReactDiff, {
     updater: onRenderUpdater
   });
 }
-var RawList = React17.memo(RawListFn);
+var RawList = React16.memo(RawListFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeader.tsx
 var debug3 = dbg("Header");
@@ -4794,7 +4887,7 @@ function InfiniteTableHeaderFn(props) {
     componentState: { headerHeight }
   } = useInfiniteTable();
   const { computedVisibleColumnsMap } = computed;
-  const renderColumn = (0, import_react28.useCallback)(({ domRef: domRef2, itemIndex: columnIndex }) => {
+  const renderColumn = (0, import_react27.useCallback)(({ domRef: domRef2, itemIndex: columnIndex }) => {
     const column = columns[columnIndex];
     if (!column) {
       if (true) {
@@ -4802,21 +4895,21 @@ function InfiniteTableHeaderFn(props) {
       }
       return null;
     }
-    return /* @__PURE__ */ React18.createElement(InfiniteTableHeaderCell, {
+    return /* @__PURE__ */ React17.createElement(InfiniteTableHeaderCell, {
       domRef: domRef2,
       column,
       headerHeight,
       columns: computedVisibleColumnsMap
     });
   }, [computedVisibleColumnsMap, columns, repaintId, headerHeight]);
-  (0, import_react28.useEffect)(() => {
+  (0, import_react27.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       domRef.current.style.transform = `translate3d(-${scrollPosition.scrollLeft}px, 0px, 0px)`;
     };
     const removeOnScroll = brain.onScroll(onScroll);
     return removeOnScroll;
   }, [brain]);
-  const domRef = (0, import_react28.useRef)(null);
+  const domRef = (0, import_react27.useRef)(null);
   const headerCls = HeaderClsRecipe({
     pinned: pinning,
     overflow: false,
@@ -4827,18 +4920,18 @@ function InfiniteTableHeaderFn(props) {
     className: join(TableHeaderClassName, `${TableHeaderClassName}--virtualized`, className, headerCls),
     style
   };
-  return /* @__PURE__ */ React18.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React18.createElement(RawList, {
+  return /* @__PURE__ */ React17.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React17.createElement(RawList, {
     brain,
     renderItem: renderColumn
   }));
 }
-var InfiniteTableHeader = React18.memo(InfiniteTableHeaderFn);
+var InfiniteTableHeader = React17.memo(InfiniteTableHeaderFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderUnvirtualized.tsx
-var React21 = __toModule(require("react"));
+var React20 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/renderColumnHeaderGroups.tsx
-var React20 = __toModule(require("react"));
+var React19 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/buildColumnAndGroupTree.ts
 function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap) {
@@ -4928,7 +5021,7 @@ function assignGroupOffsetsAndComputedWidths(items, groupOffset = 0) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderGroup.tsx
-var React19 = __toModule(require("react"));
+var React18 = __toModule(require("react"));
 var TableHeaderGroupClassName = `${rootClassName}HeaderGroup`;
 function InfiniteTableHeaderGroup(props) {
   const { columnGroup, height, headerHeight } = props;
@@ -4942,16 +5035,16 @@ function InfiniteTableHeaderGroup(props) {
     width: columnGroup.computedWidth,
     height
   };
-  return /* @__PURE__ */ React19.createElement("div", {
+  return /* @__PURE__ */ React18.createElement("div", {
     "data-group-id": columnGroup.id,
     className: join(HeaderGroupCls, TableHeaderGroupClassName, `${TableHeaderGroupClassName}--unvirtualized`),
     style
-  }, /* @__PURE__ */ React19.createElement("div", {
+  }, /* @__PURE__ */ React18.createElement("div", {
     className: join(`${TableHeaderGroupClassName}__header`, HeaderGroup_Header),
     style: { height: headerHeight }
-  }, /* @__PURE__ */ React19.createElement("div", {
+  }, /* @__PURE__ */ React18.createElement("div", {
     className: join(`${TableHeaderGroupClassName}__header-content`, cssEllipsisClassName)
-  }, header)), /* @__PURE__ */ React19.createElement("div", {
+  }, header)), /* @__PURE__ */ React18.createElement("div", {
     className: join(`${TableHeaderGroupClassName}__children`, HeaderGroup_Children)
   }, props.children));
 }
@@ -4974,7 +5067,7 @@ function renderColumnHeaderGroups(config) {
     return items2.map((colGroupItem) => {
       if (colGroupItem.type === "column") {
         const col = colGroupItem.ref;
-        return /* @__PURE__ */ React20.createElement(InfiniteTableHeaderCell, {
+        return /* @__PURE__ */ React19.createElement(InfiniteTableHeaderCell, {
           key: col.id,
           headerHeight: (columnGroupsMaxDepth - colGroupItem.depth + 2) * headerHeight,
           column: col,
@@ -4988,7 +5081,7 @@ function renderColumnHeaderGroups(config) {
         colIds.push(col.id);
         return col;
       });
-      return /* @__PURE__ */ React20.createElement(InfiniteTableHeaderGroup, {
+      return /* @__PURE__ */ React19.createElement(InfiniteTableHeaderGroup, {
         key: `${colGroupItem.uniqueGroupId.join("/")}`,
         columns: columns2,
         height: (columnGroupsMaxDepth - colGroupItem.depth + 2) * headerHeight,
@@ -5008,7 +5101,7 @@ function renderColumnHeaderGroups(config) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderUnvirtualized.tsx
-var import_react29 = __toModule(require("react"));
+var import_react28 = __toModule(require("react"));
 var { rootClassName: rootClassName5 } = internalProps;
 var TableHeaderClassName2 = `${rootClassName5}Header`;
 var UPDATE_SCROLL = (node, scrollPosition) => {
@@ -5041,9 +5134,9 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
     },
     computed: { computedVisibleColumnsMap: columnsMap }
   } = useInfiniteTable();
-  const domRef = React21.useRef(null);
+  const domRef = React20.useRef(null);
   const hasColumnGroups = computedColumnGroups.size > 0;
-  const columnHeaderGroups = React21.useMemo(() => {
+  const columnHeaderGroups = React20.useMemo(() => {
     return hasColumnGroups ? renderColumnHeaderGroups({
       columnGroups: computedColumnGroups,
       columnGroupsDepthsMap,
@@ -5062,7 +5155,7 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
     columnGroupsMaxDepth
   ]);
   const children = hasColumnGroups ? columnHeaderGroups : columns.map((c) => {
-    return /* @__PURE__ */ React21.createElement(InfiniteTableHeaderCell, {
+    return /* @__PURE__ */ React20.createElement(InfiniteTableHeaderCell, {
       key: c.id,
       headerHeight,
       column: c,
@@ -5074,7 +5167,7 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
   if (totalWidth != null) {
     style.width = availableWidth;
   }
-  (0, import_react29.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     const scroller = brain || scrollListener;
     if (!scroller || !scrollable) {
       return;
@@ -5085,20 +5178,20 @@ function InfiniteTableHeaderUnvirtualizedFn(props) {
     const removeOnScroll = scroller.onScroll(onScroll);
     return removeOnScroll;
   }, [brain, scrollListener]);
-  return /* @__PURE__ */ React21.createElement("div", __spreadProps(__spreadValues({}, domProps), {
+  return /* @__PURE__ */ React20.createElement("div", __spreadProps(__spreadValues({}, domProps), {
     className: join(TableHeaderClassName2, `${TableHeaderClassName2}--unvirtualized`, pinning ? `${TableHeaderClassName2}--pinned ${TableHeaderClassName2}-${pinning}` : "", scrollable ? `${TableHeaderClassName2}--overflow` : "", domProps.className, HeaderClsRecipe({
       pinned: pinning,
       virtualized: false,
       overflow: scrollable
     })),
     style
-  }), /* @__PURE__ */ React21.createElement("div", {
+  }), /* @__PURE__ */ React20.createElement("div", {
     style: { width: totalWidth },
     className: join(flexFlow.row, display.flex),
     ref: domRef
   }, children));
 }
-var InfiniteTableHeaderUnvirtualized = React21.memo(InfiniteTableHeaderUnvirtualizedFn);
+var InfiniteTableHeaderUnvirtualized = React20.memo(InfiniteTableHeaderUnvirtualizedFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderWrapper.tsx
 function TableHeaderWrapper(props) {
@@ -5128,7 +5221,7 @@ function TableHeaderWrapper(props) {
   const hasPinnedStart = computedPinnedStartColumns.length > 0;
   const hasPinnedEnd = computedPinnedEndColumns.length > 0;
   const height = columnGroupsMaxDepth ? columnGroupsMaxDepth * headerHeight : headerHeight;
-  const header = virtualizeHeader ? /* @__PURE__ */ React22.createElement(InfiniteTableHeader, {
+  const header = virtualizeHeader ? /* @__PURE__ */ React21.createElement(InfiniteTableHeader, {
     columns: computedUnpinnedColumns,
     repaintId: virtualizeHeader ? repaintId : void 0,
     brain,
@@ -5141,7 +5234,7 @@ function TableHeaderWrapper(props) {
     },
     availableWidth: computedUnpinnedColumnsWidth,
     totalWidth: computedUnpinnedColumnsWidth
-  }) : /* @__PURE__ */ React22.createElement(InfiniteTableHeaderUnvirtualized, {
+  }) : /* @__PURE__ */ React21.createElement(InfiniteTableHeaderUnvirtualized, {
     brain,
     scrollable: true,
     pinning: false,
@@ -5149,12 +5242,12 @@ function TableHeaderWrapper(props) {
     availableWidth: computedUnpinnedColumnsWidth,
     totalWidth: computedUnpinnedColumnsWidth
   });
-  return /* @__PURE__ */ React22.createElement("div", {
+  return /* @__PURE__ */ React21.createElement("div", {
     className: HeaderWrapperCls,
     style: {
       height: virtualizeHeader ? height : void 0
     }
-  }, hasPinnedStart ? /* @__PURE__ */ React22.createElement(InfiniteTableHeaderUnvirtualized, {
+  }, hasPinnedStart ? /* @__PURE__ */ React21.createElement(InfiniteTableHeaderUnvirtualized, {
     style: {
       left: 0,
       position: "absolute",
@@ -5166,7 +5259,7 @@ function TableHeaderWrapper(props) {
     scrollable: computedPinnedStartOverflow,
     pinning: "start",
     scrollListener: computedPinnedStartOverflow ? pinnedStartScrollListener : void 0
-  }) : null, header, hasPinnedEnd ? /* @__PURE__ */ React22.createElement(InfiniteTableHeaderUnvirtualized, {
+  }) : null, header, hasPinnedEnd ? /* @__PURE__ */ React21.createElement(InfiniteTableHeaderUnvirtualized, {
     style: {
       right: scrollbars.vertical ? getScrollbarWidth() : 0,
       position: "absolute",
@@ -5178,7 +5271,7 @@ function TableHeaderWrapper(props) {
     scrollable: computedPinnedEndOverflow,
     pinning: "end",
     scrollListener: computedPinnedEndOverflow ? pinnedEndScrollListener : void 0
-  }) : null, scrollbars.vertical ? /* @__PURE__ */ React22.createElement(VerticalScrollbarPlaceholder, {
+  }) : null, scrollbars.vertical ? /* @__PURE__ */ React21.createElement(VerticalScrollbarPlaceholder, {
     style: {
       height: "100%",
       right: 0
@@ -5187,13 +5280,13 @@ function TableHeaderWrapper(props) {
 }
 
 // src/components/VirtualScrollContainer/index.tsx
-var React23 = __toModule(require("react"));
-var import_react31 = __toModule(require("react"));
+var React22 = __toModule(require("react"));
+var import_react30 = __toModule(require("react"));
 
 // src/components/hooks/useOnScroll.ts
-var import_react30 = __toModule(require("react"));
+var import_react29 = __toModule(require("react"));
 var useOnScroll = (domRef, onScroll) => {
-  (0, import_react30.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     const domNode = domRef == null ? void 0 : domRef.current;
     const scrollFn = (event) => {
       const node = event.target;
@@ -5231,7 +5324,7 @@ var getScrollableClassName = (scrollable) => {
 
 // src/components/VirtualScrollContainer/index.tsx
 var rootClassName6 = "InfiniteVirtualScrollContainer";
-var VirtualScrollContainer = React23.forwardRef(function VirtualScrollContainer2(props, ref) {
+var VirtualScrollContainer = React22.forwardRef(function VirtualScrollContainer2(props, ref) {
   const {
     children,
     scrollable = true,
@@ -5239,9 +5332,9 @@ var VirtualScrollContainer = React23.forwardRef(function VirtualScrollContainer2
     className,
     style
   } = props;
-  const domRef = ref != null ? ref : (0, import_react31.useRef)(null);
+  const domRef = ref != null ? ref : (0, import_react30.useRef)(null);
   useOnScroll(domRef, onContainerScroll);
-  return /* @__PURE__ */ React23.createElement("div", {
+  return /* @__PURE__ */ React22.createElement("div", {
     ref: domRef,
     style,
     className: join(className, rootClassName6, VirtualScrollContainerCls, getScrollableClassName(scrollable))
@@ -5249,7 +5342,7 @@ var VirtualScrollContainer = React23.forwardRef(function VirtualScrollContainer2
 });
 
 // src/components/VirtualList/SpacePlaceholder.tsx
-var React24 = __toModule(require("react"));
+var React23 = __toModule(require("react"));
 function SpacePlaceholderFn(props) {
   const { height, width, count } = props;
   const style = {
@@ -5259,7 +5352,7 @@ function SpacePlaceholderFn(props) {
     opacity: 0,
     pointerEvents: "none"
   };
-  return /* @__PURE__ */ React24.createElement("div", {
+  return /* @__PURE__ */ React23.createElement("div", {
     "data-count": count,
     "data-placeholder-width": true ? width : void 0,
     "data-placeholder-height": true ? height : void 0,
@@ -5267,24 +5360,24 @@ function SpacePlaceholderFn(props) {
     style
   });
 }
-var SpacePlaceholder = React24.memo(SpacePlaceholderFn);
+var SpacePlaceholder = React23.memo(SpacePlaceholderFn);
 
 // src/components/InfiniteTable/hooks/useListRendering.tsx
-var import_react42 = __toModule(require("react"));
+var import_react41 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useUnpinnedRendering.tsx
-var React30 = __toModule(require("react"));
-var import_react35 = __toModule(require("react"));
+var React29 = __toModule(require("react"));
+var import_react34 = __toModule(require("react"));
 
 // src/components/VirtualList/VirtualRowList.tsx
-var React26 = __toModule(require("react"));
+var React25 = __toModule(require("react"));
 
 // src/components/VirtualList/VirtualList.tsx
-var React25 = __toModule(require("react"));
-var import_react32 = __toModule(require("react"));
+var React24 = __toModule(require("react"));
+var import_react31 = __toModule(require("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";
 
@@ -5324,11 +5417,11 @@ var VirtualList = (props) => {
     "onContainerScroll",
     "children"
   ]);
-  const domRef = (0, import_react32.useRef)(null);
+  const domRef = (0, import_react31.useRef)(null);
   const [, rerender] = useRerender();
-  const [totalSize, setTotalSize] = (0, import_react32.useState)(0);
-  const renderCountRef = (0, import_react32.useRef)(0);
-  (0, import_react32.useEffect)(() => {
+  const [totalSize, setTotalSize] = (0, import_react31.useState)(0);
+  const renderCountRef = (0, import_react31.useRef)(0);
+  (0, import_react31.useEffect)(() => {
     const removeOnRenderCount = virtualBrain.onRenderCountChange((renderCount) => {
       renderCountRef.current = renderCount;
       if (true) {
@@ -5347,7 +5440,7 @@ var VirtualList = (props) => {
       removeOnTotalSizeChange();
     };
   }, [virtualBrain]);
-  (0, import_react32.useEffect)(() => {
+  (0, import_react31.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       UPDATE_SCROLL2(domRef.current, scrollPosition);
     };
@@ -5362,19 +5455,19 @@ var VirtualList = (props) => {
   if (true) {
     domProps["data-cmp-name"] = `VirtualList`;
   }
-  return /* @__PURE__ */ React25.createElement(React25.Fragment, null, /* @__PURE__ */ React25.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React25.createElement(VirtualScrollContainer, {
+  return /* @__PURE__ */ React24.createElement(React24.Fragment, null, /* @__PURE__ */ React24.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React24.createElement(VirtualScrollContainer, {
     scrollable,
     onContainerScroll
-  }, /* @__PURE__ */ React25.createElement("div", {
+  }, /* @__PURE__ */ React24.createElement("div", {
     ref: domRef,
     className: scrollTransformTargetCls,
     "data-name": "scroll-transform-target"
-  }, /* @__PURE__ */ React25.createElement(RawList, {
+  }, /* @__PURE__ */ React24.createElement(RawList, {
     brain: virtualBrain,
     renderItem,
     repaintId,
     debugChannel: "VirtualList-" + mainAxis
-  })), children, /* @__PURE__ */ React25.createElement(SpacePlaceholder, {
+  })), children, /* @__PURE__ */ React24.createElement(SpacePlaceholder, {
     count,
     width,
     height
@@ -5384,14 +5477,14 @@ var VirtualList = (props) => {
 // src/components/VirtualList/VirtualRowList.tsx
 var VirtualRowList = (props) => {
   const _a = props, { rowWidth, rowHeight, renderRow } = _a, listProps = __objRest(_a, ["rowWidth", "rowHeight", "renderRow"]);
-  const renderItem = React26.useCallback((renderProps) => {
+  const renderItem = React25.useCallback((renderProps) => {
     return renderRow({
       domRef: renderProps.domRef,
       rowHeight: renderProps.itemSize,
       rowIndex: renderProps.itemIndex
     });
   }, [renderRow]);
-  return /* @__PURE__ */ React26.createElement(VirtualList, __spreadProps(__spreadValues({}, listProps), {
+  return /* @__PURE__ */ React25.createElement(VirtualList, __spreadProps(__spreadValues({}, listProps), {
     renderItem,
     mainAxis: "vertical",
     itemMainAxisSize: rowHeight,
@@ -5400,11 +5493,11 @@ var VirtualRowList = (props) => {
 };
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRow.tsx
-var React28 = __toModule(require("react"));
-var import_react34 = __toModule(require("react"));
+var React27 = __toModule(require("react"));
+var import_react33 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableColumnCell.tsx
-var React27 = __toModule(require("react"));
+var React26 = __toModule(require("react"));
 var { rootClassName: rootClassName8 } = internalProps;
 var InfiniteTableColumnCellClassName = `${rootClassName8}ColumnCell`;
 function isColumnWithField(c) {
@@ -5431,32 +5524,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) {
@@ -5491,7 +5590,7 @@ function InfiniteTableColumnCellFn(props) {
       }
     }
   }
-  return /* @__PURE__ */ React27.createElement(InfiniteTableCell, __spreadProps(__spreadValues({
+  return /* @__PURE__ */ React26.createElement(InfiniteTableCell, __spreadProps(__spreadValues({
     domRef,
     offsetProperty
   }, dataset), {
@@ -5502,10 +5601,10 @@ function InfiniteTableColumnCellFn(props) {
     className: join(useCellClassName(column, [InfiniteTableColumnCellClassName, InfiniteTableCellClassName], ColumnCellRecipe, { dragging: false }), colClassName)
   }), hidden ? null : renderValue);
 }
-var InfiniteTableColumnCell = React27.memo(InfiniteTableColumnCellFn);
+var InfiniteTableColumnCell = React26.memo(InfiniteTableColumnCellFn);
 
 // src/components/InfiniteTable/components/InfiniteTableRow/useRowDOMProps.ts
-var import_react33 = __toModule(require("react"));
+var import_react32 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRowClassName.ts
 var { rootClassName: rootClassName9 } = internalProps;
@@ -5530,17 +5629,16 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
     domRef: domRefFromProps,
     rowInfo
   } = props;
-  const domRef = (0, import_react33.useRef)(null);
-  const rowDOMRef = (0, import_react33.useCallback)((node) => {
+  const domRef = (0, import_react32.useRef)(null);
+  const rowDOMRef = (0, import_react32.useCallback)((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);
   }
@@ -5563,7 +5661,7 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
   }), `${InfiniteTableRowClassName}--${rowInfo.isGroupRow ? "group" : "normal"}-row`, inlineGroupRoot ? `${InfiniteTableRowClassName}--inline-group-row` : "", showZebraRows ? `${InfiniteTableRowClassName}--${odd ? "odd" : "even"}` : null, showHoverRows ? `${InfiniteTableRowClassName}--show-hover` : null, domProps == null ? void 0 : domProps.className, rowProps == null ? void 0 : rowProps.className, rowComputedClassName);
   const initialMouseEnter = rowProps == null ? void 0 : rowProps.onMouseEnter;
   const initialMouseLeave = rowProps == null ? void 0 : rowProps.onMouseLeave;
-  const onMouseEnter = (0, import_react33.useCallback)((event) => {
+  const onMouseEnter = (0, import_react32.useCallback)((event) => {
     var _a;
     initialMouseEnter == null ? void 0 : initialMouseEnter(event);
     const rowIndex2 = ((_a = event.currentTarget) == null ? void 0 : _a.dataset.rowIndex) * 1;
@@ -5577,7 +5675,7 @@ function useRowDOMProps(props, rowProps, rowStyle, rowClassName, groupRenderStra
     const rows = parentNode.querySelectorAll(hoverSelector.join(","));
     rows.forEach((row) => row.classList.add(InfiniteTableRowClassName__hover, RowHoverCls));
   }, [initialMouseEnter, showHoverRows]);
-  const onMouseLeave = (0, import_react33.useCallback)((event) => {
+  const onMouseLeave = (0, import_react32.useCallback)((event) => {
     var _a;
     initialMouseLeave == null ? void 0 : initialMouseLeave(event);
     const rowIndex2 = (_a = event.currentTarget) == null ? void 0 : _a.dataset.rowIndex;
@@ -5633,13 +5731,13 @@ function InfiniteTableRowFn(props) {
     width: rowWidth,
     height: rowHeight
   }, domProps.style);
-  const renderCellRef = (0, import_react34.useRef)(null);
-  const renderCell = React28.useCallback(({ domRef, itemIndex }) => {
+  const renderCellRef = (0, import_react33.useRef)(null);
+  const renderCell = React27.useCallback(({ domRef, itemIndex }) => {
     const column = columns[itemIndex];
     if (!column) {
     }
     const hidden = false;
-    return /* @__PURE__ */ React28.createElement(InfiniteTableColumnCell, {
+    return /* @__PURE__ */ React27.createElement(InfiniteTableColumnCell, {
       getData,
       rowInfo,
       groupRenderStrategy,
@@ -5666,18 +5764,18 @@ function InfiniteTableRowFn(props) {
   if (true) {
     domProps["data-cmp-name"] = "ITableRow";
   }
-  return /* @__PURE__ */ React28.createElement("div", __spreadProps(__spreadValues({}, domProps), {
+  return /* @__PURE__ */ React27.createElement("div", __spreadProps(__spreadValues({}, domProps), {
     style
-  }), /* @__PURE__ */ React28.createElement(RawList, {
+  }), /* @__PURE__ */ React27.createElement(RawList, {
     brain,
     renderItem: renderCell,
     debugChannel: `${rowIndex}`
   }));
 }
-var InfiniteTableRow = React28.memo(InfiniteTableRowFn);
+var InfiniteTableRow = React27.memo(InfiniteTableRowFn);
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableRowUnvirtualized.tsx
-var React29 = __toModule(require("react"));
+var React28 = __toModule(require("react"));
 function TableRowUnvirtualizedFn(props) {
   const {
     rowHeight,
@@ -5698,7 +5796,7 @@ function TableRowUnvirtualizedFn(props) {
   }, domProps.style);
   const children = columns.map((col) => {
     const hidden = false;
-    return /* @__PURE__ */ React29.createElement(InfiniteTableColumnCell, {
+    return /* @__PURE__ */ React28.createElement(InfiniteTableColumnCell, {
       key: col.id,
       virtualized: false,
       rowHeight,
@@ -5711,11 +5809,11 @@ function TableRowUnvirtualizedFn(props) {
       column: col
     });
   });
-  return /* @__PURE__ */ React29.createElement("div", __spreadProps(__spreadValues({}, domProps), {
+  return /* @__PURE__ */ React28.createElement("div", __spreadProps(__spreadValues({}, domProps), {
     style
   }), children);
 }
-var TableRowUnvirtualized = React29.memo(TableRowUnvirtualizedFn);
+var TableRowUnvirtualized = React28.memo(TableRowUnvirtualizedFn);
 
 // src/components/InfiniteTable/hooks/useUnpinnedRendering.tsx
 function useUnpinnedRendering(params) {
@@ -5737,7 +5835,7 @@ function useUnpinnedRendering(params) {
   } = params;
   const { virtualizeColumns } = getState();
   const shouldVirtualizeColumns = typeof virtualizeColumns === "function" ? virtualizeColumns(computedUnpinnedColumns) : virtualizeColumns != null ? virtualizeColumns : true;
-  const renderRowUnpinned = (0, import_react35.useCallback)((rowParams) => {
+  const renderRowUnpinned = (0, import_react34.useCallback)((rowParams) => {
     const dataArray = getData();
     const rowInfo = dataArray[rowParams.rowIndex];
     const { showZebraRows, showHoverRows } = getState();
@@ -5758,7 +5856,7 @@ function useUnpinnedRendering(params) {
       rowProps.repaintId = repaintId;
     }
     const TableRowComponent = shouldVirtualizeColumns ? InfiniteTableRow : TableRowUnvirtualized;
-    return /* @__PURE__ */ React30.createElement(TableRowComponent, __spreadValues({}, rowProps));
+    return /* @__PURE__ */ React29.createElement(TableRowComponent, __spreadValues({}, rowProps));
   }, [
     repaintId,
     rowHeight,
@@ -5768,7 +5866,7 @@ function useUnpinnedRendering(params) {
     horizontalVirtualBrain,
     verticalVirtualBrain
   ]);
-  const fakeScrollbar = getScrollbarWidth() ? /* @__PURE__ */ React30.createElement("div", {
+  const fakeScrollbar = getScrollbarWidth() ? /* @__PURE__ */ React29.createElement("div", {
     "data-name": "horizontal-scrollbar-placeholder--fake",
     style: {
       position: "absolute",
@@ -5779,10 +5877,10 @@ function useUnpinnedRendering(params) {
       overflow: "auto",
       visibility: columnShifts ? "visible" : "hidden"
     }
-  }, /* @__PURE__ */ React30.createElement("div", {
+  }, /* @__PURE__ */ React29.createElement("div", {
     style: { height: "100%", width: computedUnpinnedColumnsWidth }
   })) : null;
-  return rowHeight != 0 ? /* @__PURE__ */ React30.createElement(VirtualRowList, {
+  return rowHeight != 0 ? /* @__PURE__ */ React29.createElement(VirtualRowList, {
     repaintId: `${repaintId}-unpinned-`,
     brain: verticalVirtualBrain,
     onContainerScroll: applyScrollHorizontal,
@@ -5803,17 +5901,17 @@ function useUnpinnedRendering(params) {
 }
 
 // src/components/InfiniteTable/hooks/useOnContainerScroll.ts
-var import_react36 = __toModule(require("react"));
+var import_react35 = __toModule(require("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;
@@ -5836,14 +5934,14 @@ var useOnContainerScroll = ({
     }
   } = useInfiniteTable();
   const { componentActions: dataSourceActions, getState: getDataSourceState } = useDataSourceContextValue();
-  const timeoutIdRef = (0, import_react36.useRef)(0);
-  const scrollingRef = (0, import_react36.useRef)(false);
-  const scrollTopMaxRef = (0, import_react36.useRef)(0);
-  (0, import_react36.useEffect)(() => {
+  const timeoutIdRef = (0, import_react35.useRef)(0);
+  const scrollingRef = (0, import_react35.useRef)(false);
+  const scrollTopMaxRef = (0, import_react35.useRef)(0);
+  (0, import_react35.useEffect)(() => {
     const { current: node } = scrollerDOMRef;
     scrollTopMaxRef.current = node.scrollHeight - node.clientHeight;
   }, [reservedContentHeight, bodySize.height]);
-  const setScrolling = (0, import_react36.useCallback)((scrolling) => {
+  const setScrolling = (0, import_react35.useCallback)((scrolling) => {
     var _a;
     const prevScrolling = scrollingRef.current;
     scrollingRef.current = scrolling;
@@ -5868,7 +5966,7 @@ var useOnContainerScroll = ({
       }
     }
   }, []);
-  const onContainerScroll = (0, import_react36.useCallback)((scrollInfo) => {
+  const onContainerScroll = (0, import_react35.useCallback)((scrollInfo) => {
     verticalVirtualBrain.setScrollPosition(scrollInfo);
     horizontalVirtualBrain.setScrollPosition(scrollInfo);
     setScrolling(true);
@@ -5878,15 +5976,15 @@ var useOnContainerScroll = ({
     domRef.current,
     setScrolling
   ]);
-  const scrollPositionRef = (0, import_react36.useRef)({
+  const scrollPositionRef = (0, import_react35.useRef)({
     scrollLeft: 0,
     scrollTop: 0
   });
-  const applyScrollHorizontal = (0, import_react36.useCallback)(({ scrollLeft }) => {
+  const applyScrollHorizontal = (0, import_react35.useCallback)(({ scrollLeft }) => {
     scrollPositionRef.current.scrollLeft = scrollLeft;
     onContainerScroll(scrollPositionRef.current);
   }, [onContainerScroll]);
-  const applyScrollVertical = (0, import_react36.useCallback)(({ scrollTop }) => {
+  const applyScrollVertical = (0, import_react35.useCallback)(({ scrollTop }) => {
     scrollPositionRef.current.scrollTop = scrollTop;
     onContainerScroll(scrollPositionRef.current);
     if (scrollTop === 0) {
@@ -5908,17 +6006,17 @@ var useOnContainerScroll = ({
 };
 
 // src/components/InfiniteTable/hooks/usePinnedRendering.tsx
-var React32 = __toModule(require("react"));
-var import_react39 = __toModule(require("react"));
-
-// src/components/VirtualList/RowListWithExternalScrolling.tsx
 var React31 = __toModule(require("react"));
 var import_react38 = __toModule(require("react"));
 
-// src/components/hooks/useOnMount.ts
+// src/components/VirtualList/RowListWithExternalScrolling.tsx
+var React30 = __toModule(require("react"));
 var import_react37 = __toModule(require("react"));
+
+// src/components/hooks/useOnMount.ts
+var import_react36 = __toModule(require("react"));
 function useOnMount(domRef, props) {
-  (0, import_react37.useEffect)(() => {
+  (0, import_react36.useEffect)(() => {
     const { onMount, onUnmount } = props;
     const node = domRef == null ? void 0 : domRef.current;
     onMount == null ? void 0 : onMount(node);
@@ -5949,8 +6047,8 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   } = props;
-  const domRef = (0, import_react38.useRef)(null);
-  const renderItem = (0, import_react38.useCallback)((renderProps) => renderRow({
+  const domRef = (0, import_react37.useRef)(null);
+  const renderItem = (0, import_react37.useCallback)((renderProps) => renderRow({
     domRef: renderProps.domRef,
     rowHeight: renderProps.itemSize,
     rowIndex: renderProps.itemIndex
@@ -5959,7 +6057,7 @@ var RowListWithExternalScrolling = (props) => {
     onMount,
     onUnmount
   });
-  (0, import_react38.useEffect)(() => {
+  (0, import_react37.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       const node = domRef.current;
       if (node) {
@@ -5988,7 +6086,7 @@ var RowListWithExternalScrolling = (props) => {
   if (true) {
     domProps["data-cmp-name"] = "RowListWithExternalScrolling";
   }
-  return /* @__PURE__ */ React31.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React31.createElement(RawList, {
+  return /* @__PURE__ */ React30.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React30.createElement(RawList, {
     brain,
     renderItem,
     repaintId
@@ -6011,7 +6109,7 @@ function PinnedRowsContainer(props) {
     brain,
     renderRow
   } = props;
-  const style = React32.useMemo(() => {
+  const style = React31.useMemo(() => {
     const result = pinning === "end" ? {
       width: rowWidth,
       height,
@@ -6026,7 +6124,7 @@ function PinnedRowsContainer(props) {
     }
     return result;
   }, [height, rowWidth, pinning, hasOverflow]);
-  const updateScroll = (0, import_react39.useCallback)((node, scrollPosition) => {
+  const updateScroll = (0, import_react38.useCallback)((node, scrollPosition) => {
     UPDATE_SCROLL3(node, scrollPosition, hasOverflow ? pinnedScrollListener.getScrollPosition() : void 0);
   }, [hasOverflow, pinnedScrollListener]);
   const rowListProps = {
@@ -6037,7 +6135,7 @@ function PinnedRowsContainer(props) {
     className: join(`${PinnedRowsContainerClassName}`, PinnedRowsClsVariants[pinning === "start" ? "pinnedStart" : "pinnedEnd"], `${PinnedRowsContainerClassName}--pinned-${pinning}`, `${PinnedRowsContainerClassName}--overflow`, PinnedRowsClsVariants.overflow)
   };
   if (hasOverflow) {
-    return /* @__PURE__ */ React32.createElement(VirtualScrollContainer, {
+    return /* @__PURE__ */ React31.createElement(VirtualScrollContainer, {
       scrollable: {
         horizontal: true,
         vertical: false
@@ -6053,22 +6151,22 @@ function PinnedRowsContainer(props) {
       className: join(PinnedRowsContainerClsVariants({
         pinned: pinning
       }), `${PinnedRowsContainerClassName}Container`, `${PinnedRowsContainerClassName}Container--pinned-${pinning}`)
-    }, /* @__PURE__ */ React32.createElement(RowListWithExternalScrolling, __spreadProps(__spreadValues({}, rowListProps), {
+    }, /* @__PURE__ */ React31.createElement(RowListWithExternalScrolling, __spreadProps(__spreadValues({}, rowListProps), {
       onMount: (node) => {
         pinnedScrollListener == null ? void 0 : pinnedScrollListener.onScroll((scrollPosition) => {
           updateScroll(node, brain.getScrollPosition(), scrollPosition);
         });
       }
-    })), /* @__PURE__ */ React32.createElement(SpacePlaceholder, {
+    })), /* @__PURE__ */ React31.createElement(SpacePlaceholder, {
       width: rowWidth,
       height: 1
     }));
   }
-  return /* @__PURE__ */ React32.createElement(RowListWithExternalScrolling, __spreadValues({}, rowListProps));
+  return /* @__PURE__ */ React31.createElement(RowListWithExternalScrolling, __spreadValues({}, rowListProps));
 }
 function useRenderPinnedRow(params) {
   const { getData, getState, columnsWidth, columns, verticalBrain } = params;
-  const renderPinnedRow = (0, import_react39.useCallback)((rowParams) => {
+  const renderPinnedRow = (0, import_react38.useCallback)((rowParams) => {
     const dataArray = getData();
     const rowInfo = dataArray[rowParams.rowIndex];
     const { showZebraRows, showHoverRows } = getState();
@@ -6084,7 +6182,7 @@ function useRenderPinnedRow(params) {
       rowWidth: columnsWidth,
       columns
     }, rowParams);
-    return /* @__PURE__ */ React32.createElement(TableRowUnvirtualized, __spreadValues({}, rowProps));
+    return /* @__PURE__ */ React31.createElement(TableRowUnvirtualized, __spreadValues({}, rowProps));
   }, [columnsWidth, columns, verticalBrain]);
   return renderPinnedRow;
 }
@@ -6127,7 +6225,7 @@ function usePinnedRenderingForSide(side, params) {
     columns,
     columnsWidth
   });
-  const pinnedList = columns.length && rowHeight !== 0 ? /* @__PURE__ */ React32.createElement(PinnedRowsContainer, {
+  const pinnedList = columns.length && rowHeight !== 0 ? /* @__PURE__ */ React31.createElement(PinnedRowsContainer, {
     pinning: side,
     pinnedScrollListener,
     hasOverflow,
@@ -6140,7 +6238,7 @@ function usePinnedRenderingForSide(side, params) {
     brain: verticalVirtualBrain,
     renderRow: renderRowPinned
   }) : null;
-  const pinnedScrollbarPlaceholder = pinnedList && hasHorizontalScrollbar && !hasOverflow ? /* @__PURE__ */ React32.createElement(HorizontalScrollbarPlaceholder, {
+  const pinnedScrollbarPlaceholder = pinnedList && hasHorizontalScrollbar && !hasOverflow ? /* @__PURE__ */ React31.createElement(HorizontalScrollbarPlaceholder, {
     style: side === "end" ? {
       width: columnsWidth,
       right: hasVerticalScrollbar ? getScrollbarWidth() : 0
@@ -6182,7 +6280,7 @@ function usePinnedStartRendering(params) {
 }
 
 // src/components/InfiniteTable/hooks/useYourBrain.ts
-var import_react41 = __toModule(require("react"));
+var import_react40 = __toModule(require("react"));
 
 // src/components/VirtualBrain/index.ts
 var import_binary_search2 = __toModule(require_binary_search());
@@ -6620,9 +6718,9 @@ var VirtualBrain = class extends Logger {
 };
 
 // src/components/InfiniteTable/hooks/useColumnSizeFn.ts
-var import_react40 = __toModule(require("react"));
+var import_react39 = __toModule(require("react"));
 function useColumnSizeFn(computedUnpinnedColumns) {
-  const columnSize = (0, import_react40.useCallback)((index) => {
+  const columnSize = (0, import_react39.useCallback)((index) => {
     const column = computedUnpinnedColumns[index];
     if (!column) {
       console.log("cannot find column at index", index, computedUnpinnedColumns);
@@ -6661,7 +6759,7 @@ function useYourBrain(param) {
     });
     return brain;
   });
-  (0, import_react41.useEffect)(() => {
+  (0, import_react40.useEffect)(() => {
     return () => {
       horizontalVirtualBrain.destroy();
       verticalVirtualBrain.destroy();
@@ -6669,13 +6767,13 @@ function useYourBrain(param) {
   }, []);
   horizontalVirtualBrain.update(computedUnpinnedColumns.length, columnSize);
   verticalVirtualBrain.update(dataArray.length, rowHeight, rowSpan);
-  (0, import_react41.useEffect)(() => {
+  (0, import_react40.useEffect)(() => {
     verticalVirtualBrain.setAvailableSize({
       height: bodySize.height,
       width: 0
     });
   }, [bodySize, verticalVirtualBrain]);
-  (0, import_react41.useEffect)(() => {
+  (0, import_react40.useEffect)(() => {
     horizontalVirtualBrain.setAvailableSize({
       height: 0,
       width: Math.max(bodySize.width - computedPinnedStartWidth - computedPinnedEndWidth, 0)
@@ -6713,12 +6811,12 @@ function useListRendering(param) {
     pinnedEndScrollListener
   } = componentState;
   const prevDataSourceTimestamp = usePrevious(dataSourceState.updatedAt);
-  const repaintIdRef = (0, import_react42.useRef)(0);
+  const repaintIdRef = (0, import_react41.useRef)(0);
   if (!shallowEqualObjects(prevComputed, computed) || prevDataSourceTimestamp !== dataSourceState.updatedAt) {
     repaintIdRef.current++;
   }
   const repaintId = repaintIdRef.current;
-  const rowSpan = (0, import_react42.useMemo)(() => {
+  const rowSpan = (0, import_react41.useMemo)(() => {
     const colsWithRowspan = computedVisibleColumns.filter((col) => typeof col.rowspan === "function");
     return colsWithRowspan.length ? ({ itemIndex }) => {
       let maxSpan = 1;
@@ -6756,11 +6854,11 @@ function useListRendering(param) {
   const hasHorizontalScrollbar = computedUnpinnedColumnsWidth > bodySize.width - computedPinnedStartColumnsWidth - computedPinnedEndColumnsWidth;
   const reservedContentHeight = verticalVirtualBrain.getTotalSize() + (hasHorizontalScrollbar ? getScrollbarWidth() : 0);
   const hasVerticalScrollbar = bodySize.height > 0 && bodySize.height < reservedContentHeight;
-  const scrollbars = (0, import_react42.useMemo)(() => ({
+  const scrollbars = (0, import_react41.useMemo)(() => ({
     vertical: hasVerticalScrollbar,
     horizontal: hasHorizontalScrollbar
   }), [hasVerticalScrollbar, hasHorizontalScrollbar]);
-  (0, import_react42.useEffect)(() => {
+  (0, import_react41.useEffect)(() => {
     if (!bodySize.height) {
       return;
     }
@@ -6773,7 +6871,6 @@ function useListRendering(param) {
         setColumnVisibility: (columnVisibility) => {
           componentActions.columnVisibility = columnVisibility;
         },
-        setColumnAggregations: (columnAggregations) => componentActions.columnAggregations = columnAggregations,
         getState,
         getDataSourceState
       };
@@ -6786,7 +6883,7 @@ function useListRendering(param) {
     reservedContentHeight
   });
   const { componentActions: dataSourceActions } = useDataSourceContextValue();
-  const toggleGroupRow = (0, import_react42.useCallback)((groupKeys) => {
+  const toggleGroupRow = (0, import_react41.useCallback)((groupKeys) => {
     const newState = new GroupRowsState(getDataSourceState().groupRowsState);
     newState.toggleGroupRow(groupKeys);
     dataSourceActions.groupRowsState = newState;
@@ -6821,7 +6918,7 @@ function useListRendering(param) {
     computedUnpinnedColumns
   });
   const [, rerender] = useRerender();
-  (0, import_react42.useEffect)(() => {
+  (0, import_react41.useEffect)(() => {
     rerender();
   }, [dataSourceState]);
   const { pinnedStartList, pinnedStartScrollbarPlaceholder } = usePinnedStartRendering(pinnedRenderingParams);
@@ -6844,8 +6941,8 @@ function useListRendering(param) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableLicenseFooter/index.tsx
-var React33 = __toModule(require("react"));
-var import_react43 = __toModule(require("react"));
+var React32 = __toModule(require("react"));
+var import_react42 = __toModule(require("react"));
 
 // src/components/utils/decamelize.ts
 function decamelize(str, options) {
@@ -6880,10 +6977,10 @@ var enforceStyle = (node, style) => {
     node.style.setProperty(decamelize(propertyName), propertyValue, "important");
   }
 };
-var InfiniteTableLicenseFooter = React33.forwardRef(function InfiniteTableLicenseFooter2(props, ref) {
+var InfiniteTableLicenseFooter = React32.forwardRef(function InfiniteTableLicenseFooter2(props, ref) {
   const { rootClassName: rootClassName12 } = useInternalProps();
-  const domRef = React33.useRef(null);
-  const domCallback = React33.useCallback((node) => {
+  const domRef = React32.useRef(null);
+  const domCallback = React32.useCallback((node) => {
     domRef.current = node;
     if (!ref) {
       return;
@@ -6894,7 +6991,7 @@ var InfiniteTableLicenseFooter = React33.forwardRef(function InfiniteTableLicens
       ref.current = node;
     }
   }, []);
-  (0, import_react43.useEffect)(() => {
+  (0, import_react42.useEffect)(() => {
     const forceStyle = () => {
       requestAnimationFrame(() => {
         var _a;
@@ -6908,12 +7005,12 @@ var InfiniteTableLicenseFooter = React33.forwardRef(function InfiniteTableLicens
       clearInterval(intervalId);
     };
   }, []);
-  return /* @__PURE__ */ React33.createElement("div", __spreadProps(__spreadValues({
+  return /* @__PURE__ */ React32.createElement("div", __spreadProps(__spreadValues({
     ref: domCallback
   }, props), {
     className: join(`${rootClassName12}-Footer`, FooterCls, props.className),
     style: defaultStyle2
-  }), "Powered by", " ", /* @__PURE__ */ React33.createElement("a", {
+  }), "Powered by", " ", /* @__PURE__ */ React32.createElement("a", {
     href: "https://infinite-table.com",
     rel: "noopener noreferrer",
     role: "link",
@@ -6922,7 +7019,7 @@ var InfiniteTableLicenseFooter = React33.forwardRef(function InfiniteTableLicens
 });
 
 // src/components/InfiniteTable/hooks/useLicense/useLicense.ts
-var import_react44 = __toModule(require("react"));
+var import_react43 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useLicense/crc32.ts
 var DEFAULT_ReversedPolynomial = 3988292384;
@@ -7072,10 +7169,10 @@ var origin = typeof window !== "undefined" ? window.location.origin : "";
 var [_fullUrl, protocol, sandboxUrl] = Array.from(SANDBOX_REGEX.exec(origin) || []);
 var isInsideSandbox = protocol === "https" && sandboxUrl === "sandpack.codesandbox.io";
 var useLicense = (licenseKey = "") => {
-  const valid = (0, import_react44.useMemo)(() => {
+  const valid = (0, import_react43.useMemo)(() => {
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "0.0.10"
+      version: "0.1.0"
     });
     if (!licenseKey && !valid2 && isInsideSandbox) {
       return true;
@@ -7086,8 +7183,8 @@ var useLicense = (licenseKey = "") => {
 };
 
 // src/components/CSSVariableWatch.tsx
-var React34 = __toModule(require("react"));
-var import_react45 = __toModule(require("react"));
+var React33 = __toModule(require("react"));
+var import_react44 = __toModule(require("react"));
 var error = err("CSSVariableWatch");
 var debug5 = dbg("CSSVariableWatch");
 var WRAPPER_STYLE = {
@@ -7100,15 +7197,15 @@ var WRAPPER_STYLE = {
   overflow: "hidden"
 };
 var useCSSVariableWatch = (params) => {
-  const lastValueRef = (0, import_react45.useRef)(0);
-  const onResize = React34.useCallback(({ height }) => {
+  const lastValueRef = (0, import_react44.useRef)(0);
+  const onResize = React33.useCallback(({ height }) => {
     if (height && height !== lastValueRef.current) {
       lastValueRef.current = height;
       params.onChange(height);
     }
   }, [params.onChange]);
   useResizeObserver(params.ref, onResize, { earlyAttach: true });
-  React34.useLayoutEffect(() => {
+  React33.useLayoutEffect(() => {
     const value = params.ref.current.getBoundingClientRect().height;
     if (value) {
       lastValueRef.current = value;
@@ -7120,15 +7217,15 @@ var useCSSVariableWatch = (params) => {
   }, []);
 };
 var CSSVariableWatch = (props) => {
-  const domRef = (0, import_react45.useRef)(null);
+  const domRef = (0, import_react44.useRef)(null);
   useCSSVariableWatch(__spreadProps(__spreadValues({}, props), {
     ref: domRef
   }));
-  return /* @__PURE__ */ React34.createElement("div", {
+  return /* @__PURE__ */ React33.createElement("div", {
     "data-name": "css-variable-watcher",
     "data-var": props.varName,
     style: WRAPPER_STYLE
-  }, /* @__PURE__ */ React34.createElement("div", {
+  }, /* @__PURE__ */ React33.createElement("div", {
     ref: domRef,
     style: {
       height: props.varName.startsWith("var(") ? props.varName : `var(${props.varName})`
@@ -7221,7 +7318,7 @@ function useDOMProps(initialDOMProps) {
 }
 
 // src/components/InfiniteTable/components/LoadMask.tsx
-var React35 = __toModule(require("react"));
+var React34 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/LoadMask.css.ts
 var LoadMaskCls = { visible: "qy58ya1 qy58ya0 _16lm1iw2 _16lm1iwr _16lm1iwt _16lm1iwx _16lm1iwv", hidden: "qy58ya2 qy58ya0 _16lm1iw2 _16lm1iwr _16lm1iwt _16lm1iwx _16lm1iwv" };
@@ -7233,15 +7330,15 @@ var { rootClassName: rootClassName11 } = internalProps;
 var baseCls2 = `${rootClassName11}-LoadMask`;
 function LoadMaskFn(props) {
   const { visible, children = "Loading" } = props;
-  return /* @__PURE__ */ React35.createElement("div", {
+  return /* @__PURE__ */ React34.createElement("div", {
     className: `${LoadMaskCls[visible ? "visible" : "hidden"]} ${baseCls2}`
-  }, /* @__PURE__ */ React35.createElement("div", {
+  }, /* @__PURE__ */ React34.createElement("div", {
     className: `${LoadMaskOverlayCls} ${baseCls2}-Overlay`
-  }), /* @__PURE__ */ React35.createElement("div", {
+  }), /* @__PURE__ */ React34.createElement("div", {
     className: `${LoadMaskTextCls} ${baseCls2}-Text`
   }, children));
 }
-var LoadMask = React35.memo(LoadMaskFn);
+var LoadMask = React34.memo(LoadMaskFn);
 
 // src/components/InfiniteTable/index.tsx
 var InfiniteTableClassName = internalProps.rootClassName;
@@ -7260,7 +7357,7 @@ var InfiniteTableRoot = getComponentStateRoot({
   getParentState: () => useDataSource(),
   debugName: "InfiniteTable"
 });
-var InfiniteTableComponent = React36.memo(function InfiniteTableComponent2() {
+var InfiniteTableComponent = React35.memo(function InfiniteTableComponent2() {
   var _a;
   const {
     componentState,
@@ -7307,7 +7404,7 @@ var InfiniteTableComponent = React36.memo(function InfiniteTableComponent2() {
   const licenseValid = useLicense(licenseKey);
   const domProps = useDOMProps(componentState.domProps);
   const LoadMaskCmp = (_a = components == null ? void 0 : components.LoadMask) != null ? _a : LoadMask;
-  React36.useLayoutEffect(() => {
+  React35.useLayoutEffect(() => {
     const dataSourceState = getDataSourceState();
     const { onScrollbarsChange } = getInfiniteTableState();
     const { notifyScrollbarsChange } = dataSourceState;
@@ -7316,31 +7413,31 @@ var InfiniteTableComponent = React36.memo(function InfiniteTableComponent2() {
     }
     notifyScrollbarsChange(scrollbars);
   }, [scrollbars]);
-  return /* @__PURE__ */ React36.createElement("div", __spreadValues({
+  return /* @__PURE__ */ React35.createElement("div", __spreadValues({
     ref: domRef
-  }, domProps), header ? /* @__PURE__ */ React36.createElement(TableHeaderWrapper, {
+  }, domProps), header ? /* @__PURE__ */ React35.createElement(TableHeaderWrapper, {
     brain: horizontalVirtualBrain,
     repaintId,
     scrollbars
-  }) : null, /* @__PURE__ */ React36.createElement(InfiniteTableBody, null, /* @__PURE__ */ React36.createElement(VirtualScrollContainer, {
+  }) : null, /* @__PURE__ */ React35.createElement(InfiniteTableBody, null, /* @__PURE__ */ React35.createElement(VirtualScrollContainer, {
     ref: scrollerDOMRef,
     onContainerScroll: applyScrollVertical,
     scrollable: ONLY_VERTICAL_SCROLLBAR
-  }, /* @__PURE__ */ React36.createElement("div", {
+  }, /* @__PURE__ */ React35.createElement("div", {
     className: display.flex
-  }, pinnedStartList, centerList, pinnedEndList), /* @__PURE__ */ React36.createElement(SpacePlaceholder, {
+  }, pinnedStartList, centerList, pinnedEndList), /* @__PURE__ */ React35.createElement(SpacePlaceholder, {
     count: dataArray.length,
     width: 0,
     height: reservedContentHeight
-  })), pinnedStartScrollbarPlaceholder, pinnedEndScrollbarPlaceholder, /* @__PURE__ */ React36.createElement(LoadMaskCmp, {
+  })), pinnedStartScrollbarPlaceholder, pinnedEndScrollbarPlaceholder, /* @__PURE__ */ React35.createElement(LoadMaskCmp, {
     visible: loading
-  }, loadingText)), licenseValid ? null : /* @__PURE__ */ React36.createElement(InfiniteTableLicenseFooter, null), /* @__PURE__ */ React36.createElement("div", {
+  }, loadingText)), licenseValid ? null : /* @__PURE__ */ React35.createElement(InfiniteTableLicenseFooter, null), /* @__PURE__ */ React35.createElement("div", {
     ref: portalDOMRef,
     className: join(`${rootClassName}Portal`, zIndex[1e3], position.absolute, top[0], left[0])
-  }), rowHeightCSSVar ? /* @__PURE__ */ React36.createElement(CSSVariableWatch, {
+  }), rowHeightCSSVar ? /* @__PURE__ */ React35.createElement(CSSVariableWatch, {
     varName: rowHeightCSSVar,
     onChange: onRowHeightCSSVarChange
-  }) : null, headerHeightCSSVar ? /* @__PURE__ */ React36.createElement(CSSVariableWatch, {
+  }) : null, headerHeightCSSVar ? /* @__PURE__ */ React35.createElement(CSSVariableWatch, {
     varName: headerHeightCSSVar,
     onChange: onHeaderHeightCSSVarChange
   }) : null);
@@ -7376,25 +7473,25 @@ function InfiniteTableContextProvider() {
     }
     componentActions.bodySize = bodySize;
   }, { earlyAttach: true });
-  React36.useEffect(() => {
+  React35.useEffect(() => {
     return () => {
       componentState.onRowHeightCSSVarChange.destroy();
       componentState.onHeaderHeightCSSVarChange.destroy();
     };
   }, []);
-  React36.useEffect(() => {
+  React35.useEffect(() => {
     if (scrollerDOMRef.current) {
       scrollerDOMRef.current.scrollTop = 0;
     }
   }, [scrollTopId, scrollerDOMRef]);
   const TableContext2 = getInfiniteTableContext();
-  return /* @__PURE__ */ React36.createElement(TableContext2.Provider, {
+  return /* @__PURE__ */ React35.createElement(TableContext2.Provider, {
     value: contextValue
-  }, /* @__PURE__ */ React36.createElement(InfiniteTableComponent, null));
+  }, /* @__PURE__ */ React35.createElement(InfiniteTableComponent, null));
 }
 function InfiniteTable(props) {
-  const table = /* @__PURE__ */ React36.createElement(InfiniteTableRoot, __spreadValues({}, props), /* @__PURE__ */ React36.createElement(InfiniteTableContextProvider, null));
-  return /* @__PURE__ */ React36.createElement(React36.StrictMode, null, table);
+  const table = /* @__PURE__ */ React35.createElement(InfiniteTableRoot, __spreadValues({}, props), /* @__PURE__ */ React35.createElement(InfiniteTableContextProvider, null));
+  return /* @__PURE__ */ React35.createElement(React35.StrictMode, null, table);
 }
 InfiniteTable.defaultProps = {
   rowHeight: 40,