@infinite-table/infinite-react 0.4.0 → 0.4.3

package/index.esm.js

@@ -638,9 +638,9 @@ import {
   StrictMode,
   createElement as createElement35,
   memo as memo13,
-  useEffect as useEffect30
+  useEffect as useEffect30,
+  useState as useState15
 } from "react";
-import { useCallback as useCallback18, useState as useState16 } from "react";
 
 // src/utils/join.ts
 var join = (...args) => args.filter((x) => !!`${x}`).join(" ");
@@ -1018,32 +1018,33 @@ var AvoidReactDiff = memo2(AvoidReactDiffFn);
 
 // src/components/utils/buildSubscriptionCallback.tsx
 function buildSubscriptionCallback(withRaf = false) {
-  let result = null;
+  let lastCallValue = null;
   let fns = [];
   let rafId = null;
   const updater = (items, callback) => {
+    const results = [];
     if (withRaf) {
       if (rafId != null) {
         cancelAnimationFrame(rafId);
         rafId = null;
       }
       requestAnimationFrame(() => {
-        result = items;
+        lastCallValue = items;
         rafId = null;
         for (let i = 0, len = fns.length; i < len; i++) {
-          fns[i](items);
+          results.push(fns[i](items));
         }
-        callback == null ? void 0 : callback();
+        callback == null ? void 0 : callback(results);
       });
     } else {
-      result = items;
+      lastCallValue = items;
       for (let i = 0, len = fns.length; i < len; i++) {
-        fns[i](items);
+        results.push(fns[i](items));
       }
-      callback == null ? void 0 : callback();
+      callback == null ? void 0 : callback(results);
     }
   };
-  updater.get = () => result;
+  updater.get = () => lastCallValue;
   updater.onChange = (fn) => {
     fns.push(fn);
     return () => {
@@ -1054,6 +1055,7 @@ function buildSubscriptionCallback(withRaf = false) {
     updater(null);
     fns.length = 0;
   };
+  updater.getListenersCount = () => fns.length;
   return updater;
 }
 
@@ -2247,13 +2249,19 @@ var DeepMap = class {
     this.visitDepthFirst = (fn) => {
       this.visitWithNext([], fn);
     };
-    this.visitWithNext = (parentKeys, fn, currentMap = this.map) => {
+    this.visitWithNext = (parentKeys, fn, currentMap = this.map, depthLimit, skipSelfValue) => {
       if (!currentMap) {
         return;
       }
       let i = 0;
       const hasEmptyKey = currentMap.has(this.emptyKey);
-      let allowEmptyKey = true;
+      let allowEmptyKey = skipSelfValue ? false : true;
+      if (depthLimit !== void 0) {
+        if (depthLimit < 0) {
+          return;
+        }
+        depthLimit--;
+      }
       const iterator = (_, key) => {
         const pair = currentMap.get(key);
         if (!pair) {
@@ -2265,7 +2273,7 @@ var DeepMap = class {
           return;
         }
         const keys = isEmptyKey ? [] : [...parentKeys, key];
-        const next = map2 ? () => this.visitWithNext(keys, fn, map2) : void 0;
+        let next = map2 ? () => this.visitWithNext(keys, fn, map2, depthLimit !== void 0 ? depthLimit - 1 : void 0) : void 0;
         if (pair.hasOwnProperty("value")) {
           fn(pair.value, keys, i, next);
           i++;
@@ -2297,41 +2305,84 @@ var DeepMap = class {
       });
     }
   }
-  getValuesStartingWith(keys) {
+  getValuesStartingWith(keys, excludeSelf, depthLimit) {
     const result = [];
     this.getStartingWith(keys, (_keys, value) => {
       result.push(value);
-    });
+    }, excludeSelf, depthLimit);
     return result;
   }
-  getKeysStartingWith(keys) {
+  getKeysStartingWith(keys, excludeSelf, depthLimit) {
     const result = [];
     this.getStartingWith(keys, (keys2) => {
       result.push(keys2);
-    });
+    }, excludeSelf, depthLimit);
     return result;
   }
-  getStartingWith(keys, fn) {
+  getStartingWith(keys, fn, excludeSelf, depthLimit) {
+    let currentMap = this.map;
+    let pair;
+    let stop = false;
+    if (keys.length) {
+      for (let i = 0, len = keys.length; i < len; i++) {
+        const key = keys[i];
+        pair = currentMap.get(key);
+        if (!pair || !pair.map) {
+          stop = true;
+          if (i === len - 1) {
+            stop = true;
+            break;
+          } else {
+            return;
+          }
+        }
+        currentMap = pair.map;
+      }
+    }
+    if (pair && pair.value !== void 0) {
+      if (!excludeSelf) {
+        fn(keys, pair.value);
+      }
+    }
+    if (stop) {
+      return;
+    }
+    this.visitWithNext(keys, (value, keys2, _i, next) => {
+      fn(keys2, value);
+      next == null ? void 0 : next();
+    }, currentMap, depthLimit, excludeSelf);
+  }
+  getMapAt(keys) {
     let currentMap = this.map;
     let pair;
     if (!keys.length) {
-      keys = [this.emptyKey];
+      return this.map;
     }
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       pair = currentMap.get(key);
       if (!pair || !pair.map) {
-        return;
+        return void 0;
       }
       currentMap = pair.map;
     }
-    if (pair && pair.value !== void 0) {
-      fn(keys, pair.value);
+    return currentMap;
+  }
+  getAllChildrenSizeFor(keys) {
+    let currentMap = this.map;
+    let pair;
+    if (!keys.length) {
+      return this.length;
     }
-    this.visitWithNext(keys, (value, keys2, _i, next) => {
-      fn(keys2, value);
-      next == null ? void 0 : next();
-    }, currentMap);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      pair = currentMap.get(key);
+      if (!pair || !pair.map) {
+        return 0;
+      }
+      currentMap = pair.map;
+    }
+    return pair.length;
   }
   getDirectChildrenSizeFor(keys) {
     var _a;
@@ -2361,7 +2412,9 @@ var DeepMap = class {
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const last = i === len - 1;
-      const pair = currentMap.get(key) || {};
+      const pair = currentMap.get(key) || {
+        length: 0
+      };
       if (last) {
         pair.revision = this.revision++;
         pair.value = value;
@@ -2372,6 +2425,7 @@ var DeepMap = class {
           pair.map = new Map();
           currentMap.set(key, pair);
         }
+        pair.length++;
         currentMap = pair.map;
       }
     }
@@ -2422,6 +2476,7 @@ var DeepMap = class {
       keys = [...keys];
     }
     const maps = [currentMap];
+    const pairs = [];
     let result = false;
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
@@ -2433,6 +2488,9 @@ var DeepMap = class {
             delete pair.value;
             delete pair.revision;
             result = true;
+            pairs.forEach((pair2) => {
+              pair2.length--;
+            });
             this.length--;
           }
           if (pair.map && pair.map.size === 0) {
@@ -2448,6 +2506,7 @@ var DeepMap = class {
           result = false;
           break;
         }
+        pairs.push(pair);
         currentMap = pair.map;
         maps.push(currentMap);
       }
@@ -2521,6 +2580,19 @@ var DeepMap = class {
     });
     return result;
   }
+  valuesAt(keys) {
+    const map2 = this.getMapAt(keys);
+    if (!map2) {
+      return [];
+    }
+    const result = [];
+    map2.forEach((bag) => {
+      if (bag.value !== void 0) {
+        result.push(bag.value);
+      }
+    });
+    return result;
+  }
   values() {
     return this.sortedIterator((pair) => pair.value);
   }
@@ -3592,11 +3664,11 @@ var useRerender = () => {
 };
 
 // src/components/InfiniteTable/components/ActiveCellIndicator.css.ts
-var ActiveCellIndicatorCls = { visible: "nxbq1c2 nxbq1c1 _16lm1iwf _16lm1iw3 _16lm1iw14 _16lm1iw12", hidden: "nxbq1c3 nxbq1c1 _16lm1iwf _16lm1iw3 _16lm1iw14 _16lm1iw12" };
-var ActiveIndicatorWrapperCls = "_16lm1iwf _16lm1iw3 _16lm1iw14 _16lm1iw12 _16lm1iwy _16lm1iwo";
+var ActiveCellIndicatorCls = { visible: "nxbq1c2 nxbq1c1 _16lm1iwg _16lm1iw3 _16lm1iw15 _16lm1iw13", hidden: "nxbq1c3 nxbq1c1 _16lm1iwg _16lm1iw3 _16lm1iw15 _16lm1iw13" };
+var ActiveIndicatorWrapperCls = "_16lm1iwg _16lm1iw3 _16lm1iw15 _16lm1iw13 _16lm1iwz _16lm1iwp";
 
 // src/components/InfiniteTable/components/ActiveRowIndicator.css.ts
-var ActiveRowIndicatorCls = { visible: "j26lrx1 j26lrx0 _16lm1iwf _16lm1iw3 _16lm1iw11 _16lm1iw12 _16lm1iw14", hidden: "j26lrx2 j26lrx0 _16lm1iwf _16lm1iw3 _16lm1iw11 _16lm1iw12 _16lm1iw14" };
+var ActiveRowIndicatorCls = { visible: "j26lrx1 j26lrx0 _16lm1iwg _16lm1iw3 _16lm1iw12 _16lm1iw13 _16lm1iw15", hidden: "j26lrx2 j26lrx0 _16lm1iwg _16lm1iw3 _16lm1iw12 _16lm1iw13 _16lm1iw15" };
 
 // src/components/InfiniteTable/components/ActiveRowIndicator.tsx
 var { rootClassName: rootClassName3 } = internalProps;
@@ -3887,10 +3959,10 @@ var usePrevious = (value, initialValue) => {
 };
 
 // src/components/hooks/useComponentState/index.tsx
-var notifyChange = (props, callbackPropName, newValue) => {
+var notifyChange = (props, callbackPropName, values) => {
   const callbackProp = props[callbackPropName];
   if (typeof callbackProp === "function") {
-    callbackProp(newValue);
+    callbackProp(...values);
   }
 };
 var debug3 = dbg("rerender");
@@ -3919,14 +3991,14 @@ function getReducerGeneratedActions(dispatch, getState, getProps, propsToForward
         }
       }
       if (notifyTheChange) {
-        let callbackParam = value;
+        let callbackParams = [value];
         let callbackName = `on${toUpperFirst(stateKey)}Change`;
         if (mappedCallbacks && mappedCallbacks[key]) {
           const res = mappedCallbacks[key](value, state2);
           callbackName = res.callbackName || callbackName;
-          callbackParam = res.callbackParam;
+          callbackParams = res.callbackParams;
         }
-        notifyChange(props, callbackName, callbackParam);
+        notifyChange(props, callbackName, callbackParams);
       }
       const forwardFn = propsToForward[key];
       if (typeof forwardFn === "function") {
@@ -4143,20 +4215,20 @@ var useInternalProps = () => {
 };
 
 // src/components/InfiniteTable/utilities.css.ts
-var alignItems = { center: "_16lm1iw1e", stretch: "_16lm1iw1f" };
-var cssEllipsisClassName = "_16lm1iw1p _16lm1iw1q _16lm1iw1j";
-var cursor = { pointer: "_16lm1iwd", colResize: "_16lm1iwe" };
-var display = { flex: "_16lm1iwt", none: "_16lm1iwu", block: "_16lm1iwv", inlineBlock: "_16lm1iww" };
-var flex = { "1": "_16lm1iwg", none: "_16lm1iwh" };
-var flexFlow = { column: "_16lm1iw1c", row: "_16lm1iw1d" };
-var justifyContent = { center: "_16lm1iw1g", start: "_16lm1iw1h", end: "_16lm1iw1i" };
-var left = { "0": "_16lm1iw14", "100%": "_16lm1iw15", auto: "_16lm1iw16" };
-var overflow = { hidden: "_16lm1iw1j", auto: "_16lm1iw1k", visible: "_16lm1iw1l" };
+var alignItems = { center: "_16lm1iw1h", stretch: "_16lm1iw1i" };
+var cssEllipsisClassName = "_16lm1iw1s _16lm1iw1t _16lm1iw1m";
+var cursor = { pointer: "_16lm1iwe", colResize: "_16lm1iwf" };
+var display = { flex: "_16lm1iwu", none: "_16lm1iwv", block: "_16lm1iww", inlineBlock: "_16lm1iwx" };
+var flex = { "1": "_16lm1iwh", none: "_16lm1iwi" };
+var flexFlow = { column: "_16lm1iw1d", columnReverse: "_16lm1iw1e", row: "_16lm1iw1f", rowReverse: "_16lm1iw1g" };
+var justifyContent = { center: "_16lm1iw1j", start: "_16lm1iw1k", end: "_16lm1iw1l" };
+var left = { "0": "_16lm1iw15", "100%": "_16lm1iw16", auto: "_16lm1iw17" };
+var overflow = { hidden: "_16lm1iw1m", auto: "_16lm1iw1n", visible: "_16lm1iw1o" };
 var position = { relative: "_16lm1iw1", absolute: "_16lm1iw2", sticky: "_16lm1iw3", fixed: "_16lm1iw4" };
-var top = { "0": "_16lm1iw12", "100%": "_16lm1iw13" };
+var top = { "0": "_16lm1iw13", "100%": "_16lm1iw14" };
 var transformTranslateZero = "_16lm1iwa";
-var userSelect = { none: "_16lm1iwx" };
-var zIndex = { "1": "_16lm1iwi", "10": "_16lm1iwj", "100": "_16lm1iwk", "1000": "_16lm1iwl", "10000": "_16lm1iwm", "100000": "_16lm1iwn", "1000000": "_16lm1iwo", "10000000": "_16lm1iwp", "1k": "_16lm1iwq", "10k": "_16lm1iwr", "100k": "_16lm1iws" };
+var userSelect = { none: "_16lm1iwy" };
+var zIndex = { "1": "_16lm1iwj", "10": "_16lm1iwk", "100": "_16lm1iwl", "1000": "_16lm1iwm", "10000": "_16lm1iwn", "100000": "_16lm1iwo", "1000000": "_16lm1iwp", "10000000": "_16lm1iwq", "1k": "_16lm1iwr", "10k": "_16lm1iws", "100k": "_16lm1iwt" };
 
 // src/components/InfiniteTable/components/InfiniteTableBody/InfiniteTableBody.tsx
 var InfiniteTableBody = forwardRef2(function InfiniteTableBody2(props, ref) {
@@ -4253,6 +4325,7 @@ var defaultFilterTypes = getFilterTypes();
 
 // src/components/InfiniteTable/hooks/useCellClassName.ts
 function useCellClassName(column, baseClasses, variants, extraFlags) {
+  var _a;
   const result = [...baseClasses];
   const variantObject = {
     filtered: column.computedFiltered,
@@ -4262,7 +4335,7 @@ function useCellClassName(column, baseClasses, variants, extraFlags) {
     firstInCategory: column.computedFirstInCategory,
     lastInCategory: column.computedLastInCategory,
     pinned: column.computedPinned || false,
-    rowSelected: extraFlags.rowSelected,
+    rowSelected: (_a = extraFlags.rowSelected) != null ? _a : "null",
     rowActive: extraFlags.rowActive,
     dragging: extraFlags.dragging,
     zebra: extraFlags.zebra
@@ -4317,14 +4390,14 @@ var useInfiniteTable = () => {
 // src/components/InfiniteTable/InfiniteCls.css.ts
 var import_createRuntimeFn = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 var FooterCls = "_16lm1iw1";
-var InfiniteCls = "_1yeub2v0 _16lm1iw1 _16lm1iwt _16lm1iw1c _16lm1iw0";
+var InfiniteCls = "_1yeub2v0 _16lm1iw1 _16lm1iwu _16lm1iw1d _16lm1iw0";
 var InfiniteClsHasPinnedEnd = "_1yeub2vo";
 var InfiniteClsHasPinnedStart = "_1yeub2vn";
 var InfiniteClsRecipe = (0, import_createRuntimeFn.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: [[{ focused: false, focusedWithin: false }, "_1yeub2ve"]] });
 var InfiniteClsShiftingColumns = "_1yeub2vl";
-var PinnedEndIndicatorBorder = "_1yeub2vr _1yeub2vp _16lm1iw2 _16lm1iw12 _16lm1iwe _16lm1iwx _16lm1iw10 _16lm1iw1n _16lm1iwf _16lm1iwp";
+var PinnedEndIndicatorBorder = "_1yeub2vr _1yeub2vp _16lm1iw2 _16lm1iw13 _16lm1iwf _16lm1iwy _16lm1iw11 _16lm1iw1q _16lm1iwg _16lm1iwq";
 var PinnedRowsContainerClsVariants = (0, import_createRuntimeFn.createRuntimeFn)({ defaultClassName: "", variantClassNames: { pinned: { start: "_1yeub2vi", end: "_1yeub2vj", false: "_1yeub2vk" } }, defaultVariants: {}, compoundVariants: [] });
-var PinnedStartIndicatorBorder = "_1yeub2vq _1yeub2vp _16lm1iw2 _16lm1iw12 _16lm1iwe _16lm1iwx _16lm1iw10 _16lm1iw1n _16lm1iwf _16lm1iwp";
+var PinnedStartIndicatorBorder = "_1yeub2vq _1yeub2vp _16lm1iw2 _16lm1iw13 _16lm1iwf _16lm1iwy _16lm1iw11 _16lm1iw1q _16lm1iwg _16lm1iwq";
 
 // src/components/utils/getScrollbarWidth.ts
 var scrollbarWidth;
@@ -4902,6 +4975,9 @@ var useColumnPointerEvents = ({
   } = useInfiniteTable();
   const onPointerDown = useCallback6((e) => {
     var _a2;
+    if (e.target.tagName === "INPUT") {
+      return;
+    }
     const {
       computedVisibleColumns,
       computedVisibleColumnsMap,
@@ -4910,6 +4986,9 @@ var useColumnPointerEvents = ({
       computedPinnedEndColumns
     } = getComputed();
     const dragColumn = computedVisibleColumnsMap.get(columnId);
+    if (!dragColumn.computedDraggable) {
+      return;
+    }
     const target = domRef.current;
     const targetRect = target.getBoundingClientRect();
     const tableRect = rootRef.current.getBoundingClientRect();
@@ -5034,8 +5113,8 @@ function objectValuesExcept(obj, exceptList) {
 
 // src/components/InfiniteTable/components/cell.css.ts
 var import_createRuntimeFn2 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-var ColumnCellCls = "_1eexc2a6 _1eexc2a5 _16lm1iwt _16lm1iw1d _16lm1iw1e _16lm1iw2 _16lm1iw1o _16lm1iw1p _16lm1iwx";
-var ColumnCellRecipe = (0, import_createRuntimeFn2.createRuntimeFn)({ defaultClassName: "_1eexc2a8", variantClassNames: { dragging: { false: "_1eexc2a9", true: "_1eexc2aa" }, rowActive: { false: "_1eexc2ab", true: "_1eexc2ac" }, zebra: { false: "_1eexc2ad", even: "_1eexc2ae", odd: "_1eexc2af" }, rowSelected: { true: "_1eexc2ag", false: "_1eexc2ah" }, first: { true: "_1eexc2ai", false: "_1eexc2aj" }, last: { true: "_1eexc2ak", false: "_1eexc2al" }, groupByField: { true: "_1eexc2am", false: "_1eexc2an" }, firstInCategory: { true: "_1eexc2ao", false: "_1eexc2ap" }, lastInCategory: { true: "_1eexc2aq", false: "_1eexc2ar" }, pinned: { start: "_1eexc2as", end: "_1eexc2at", false: "_1eexc2au" }, filtered: { true: "_1eexc2av", false: "_1eexc2aw" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_1eexc2ax"], [{ pinned: "start", firstInCategory: true }, "_1eexc2ay"], [{ pinned: "end", firstInCategory: true }, "_1eexc2az"], [{ pinned: "end", lastInCategory: true }, "_1eexc2a10"]] });
+var ColumnCellCls = "_1eexc2a6 _1eexc2a5 _16lm1iwu _16lm1iw1f _16lm1iw1h _16lm1iw2 _16lm1iw1r _16lm1iw1s _16lm1iwy";
+var ColumnCellRecipe = (0, import_createRuntimeFn2.createRuntimeFn)({ defaultClassName: "_1eexc2a8", variantClassNames: { dragging: { false: "_1eexc2a9", true: "_1eexc2aa" }, rowActive: { false: "_1eexc2ab", true: "_1eexc2ac" }, zebra: { false: "_1eexc2ad", even: "_1eexc2ae", odd: "_1eexc2af" }, rowSelected: { true: "_1eexc2ag", false: "_1eexc2ah", null: "_1eexc2ai" }, first: { true: "_1eexc2aj", false: "_1eexc2ak" }, last: { true: "_1eexc2al", false: "_1eexc2am" }, groupByField: { true: "_1eexc2an", false: "_1eexc2ao" }, firstInCategory: { true: "_1eexc2ap", false: "_1eexc2aq" }, lastInCategory: { true: "_1eexc2ar", false: "_1eexc2as" }, pinned: { start: "_1eexc2at", end: "_1eexc2au", false: "_1eexc2av" }, filtered: { true: "_1eexc2aw", false: "_1eexc2ax" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_1eexc2ay"], [{ pinned: "start", firstInCategory: true }, "_1eexc2az"], [{ pinned: "end", firstInCategory: true }, "_1eexc2a10"], [{ pinned: "end", lastInCategory: true }, "_1eexc2a11"]] });
 var SelectionCheckboxCls = "_1eexc2a7";
 
 // src/components/InfiniteTable/components/CheckBox.tsx
@@ -5045,7 +5124,7 @@ import {
 import { useEffect as useEffect9, useRef as useRef11 } from "react";
 
 // src/components/InfiniteTable/components/CheckBox.css.ts
-var CheckBoxCls = "_16lm1iwd";
+var CheckBoxCls = "_16lm1iwe";
 
 // src/components/InfiniteTable/components/CheckBox.tsx
 function forwardProps2() {
@@ -5060,7 +5139,7 @@ var InfiniteCheckBoxRoot = getComponentStateRoot({
     checked: (checked) => {
       return {
         callbackName: "onChange",
-        callbackParam: checked
+        callbackParams: [checked]
       };
     }
   },
@@ -5185,7 +5264,7 @@ var defaultRenderSelectionCheckBox = (params) => {
         deselectCurrentRow();
       }
     },
-    checked: rowInfo.isGroupRow ? !rowInfo.rowSelected ? rowInfo.childrenSelectedCount > 0 ? null : false : true : rowInfo.rowSelected
+    checked: rowInfo.rowSelected
   });
 };
 function isColumnWithField(c) {
@@ -5204,6 +5283,7 @@ function InfiniteTableColumnCellFn(props) {
     toggleGroupRow,
     rowIndex,
     rowHeight,
+    columnsMap,
     domRef,
     hidden,
     showZebraRows
@@ -5279,23 +5359,24 @@ function InfiniteTableColumnCellFn(props) {
   }, rest);
   const renderParam = __spreadProps(__spreadValues({
     column,
+    columnsMap,
     domRef,
     groupRowInfo
   }, rest), {
     selectionMode,
-    selectRow: imperativeApi.selectRow,
-    deselectRow: imperativeApi.deselectRow,
-    toggleRowSelection: imperativeApi.toggleRowSelection,
+    selectRow: imperativeApi.selectionApi.selectRow,
+    deselectRow: imperativeApi.selectionApi.deselectRow,
+    toggleRowSelection: imperativeApi.selectionApi.toggleRowSelection,
     renderBag: {
       value,
       selectionCheckBox: null,
       groupIcon: null
     },
     selectCurrentRow: useCallback7(() => {
-      return imperativeApi.selectRow(rowInfo.id);
+      return imperativeApi.selectionApi.selectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
     }, [rowInfo]),
     deselectCurrentRow: useCallback7(() => {
-      return imperativeApi.deselectRow(rowInfo.id);
+      return imperativeApi.selectionApi.deselectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
     }, [rowInfo]),
     rowIndex,
     toggleGroupRow,
@@ -5306,7 +5387,10 @@ function InfiniteTableColumnCellFn(props) {
       toggleGroupRow(rowInfo.groupKeys);
     }, [rowInfo]),
     toggleCurrentGroupRowSelection: useCallback7(() => {
-      return imperativeApi.toggleGroupRowSelection(rowInfo.isGroupRow ? rowInfo.groupKeys : []);
+      if (!rowInfo.isGroupRow) {
+        return;
+      }
+      return imperativeApi.selectionApi.toggleGroupRowSelection(rowInfo.isGroupRow ? rowInfo.groupKeys : []);
     }, [rowInfo]),
     groupBy: computedDataSource.groupBy,
     pivotBy: computedDataSource.pivotBy
@@ -5323,7 +5407,7 @@ function InfiniteTableColumnCellFn(props) {
         })
       });
     }
-    if (column.renderSelectionCheckBox) {
+    if (column.renderSelectionCheckBox && selectionMode == "multi-row") {
       renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ createElement15(RenderCellHookComponent, {
         render: defaultRenderSelectionCheckBox,
         renderParam
@@ -5367,7 +5451,7 @@ function InfiniteTableColumnCellFn(props) {
         renderParam
       });
     }
-    return /* @__PURE__ */ createElement15(Fragment2, null, renderParam.renderBag.groupIcon, renderParam.renderBag.selectionCheckBox, renderParam.renderBag.value);
+    return /* @__PURE__ */ createElement15(Fragment2, null, column.align !== "end" ? renderParam.renderBag.groupIcon : null, column.align !== "end" ? renderParam.renderBag.selectionCheckBox : null, renderParam.renderBag.value, column.align === "end" ? renderParam.renderBag.selectionCheckBox : null, column.align === "end" ? renderParam.renderBag.groupIcon : null);
   }, [
     column,
     hidden,
@@ -5425,6 +5509,15 @@ function RenderCellHookComponent(props) {
     renderParam: props.renderParam
   }));
 }
+function RenderHeaderCellHookComponent(props) {
+  const ContextProvider = InfiniteTableHeaderCellContext.Provider;
+  return /* @__PURE__ */ createElement16(ContextProvider, {
+    value: props.renderParam
+  }, /* @__PURE__ */ createElement16(RenderHookComponent, {
+    render: props.render,
+    renderParam: props.renderParam
+  }));
+}
 
 // src/components/InfiniteTable/components/FilterEditors.tsx
 import {
@@ -5472,19 +5565,19 @@ import { useEffect as useEffect10, useState as useState6 } from "react";
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/header.css.ts
 var import_createRuntimeFn3 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-var CellCls = "_1eexc2a5 _16lm1iwt _16lm1iw1d _16lm1iw1e _16lm1iw2 _16lm1iw1o _16lm1iw1p _16lm1iwx";
-var HeaderCellContentRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob11d _16lm1iwz _16lm1iw11 _16lm1iwt _16lm1iw1d _16lm1iw1e", variantClassNames: { filtered: { false: "_12zfob11e", true: "_12zfob11f" } }, defaultVariants: {}, compoundVariants: [] });
-var HeaderCellProxy = "_12zfob1k _16lm1iw1p _16lm1iw1q _16lm1iw1j";
-var HeaderCellRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob1l _16lm1iwv", variantClassNames: { rowActive: { false: "_12zfob1m", true: "_12zfob1n" }, rowSelected: { false: "_12zfob1o", true: "_12zfob1p" }, zebra: { false: "_12zfob1q", even: "_12zfob1r", odd: "_12zfob1s" }, dragging: { true: "_12zfob1t", false: "_12zfob1u" }, first: { true: "_12zfob1v", false: "_12zfob1w" }, last: { true: "_12zfob1x", false: "_12zfob1y" }, groupByField: { true: "_12zfob1z", false: "_12zfob110" }, firstInCategory: { true: "_12zfob111", false: "_12zfob112" }, lastInCategory: { true: "_12zfob113", false: "_12zfob114" }, pinned: { start: "_12zfob115", end: "_12zfob116", false: "_12zfob117" }, filtered: { true: "_12zfob118", false: "_12zfob119" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_12zfob11a"], [{ pinned: "end", firstInCategory: true }, "_12zfob11b"], [{ pinned: false, lastInCategory: true }, "_12zfob11c"]] });
-var HeaderClsRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob16 _16lm1iwv _16lm1iw2", variantClassNames: { pinned: { start: "_12zfob17", end: "_12zfob18", false: "_12zfob19" }, firstInCategory: { true: "_12zfob1a", false: "_12zfob1b" }, lastInCategory: { true: "_12zfob1c", false: "_12zfob1d" }, overflow: { true: "_12zfob1e", false: "_12zfob1f" } }, defaultVariants: {}, compoundVariants: [[{ overflow: true, pinned: "start" }, "_12zfob1g"], [{ pinned: "start", firstInCategory: true }, "_12zfob1h"], [{ overflow: true, pinned: "end" }, "_12zfob1i"], [{ pinned: "end", lastInCategory: true }, "_12zfob1j"]] });
-var HeaderFilterCls = "_12zfob11i _16lm1iwt _16lm1iw1d _16lm1iw1e _16lm1iw1";
-var HeaderFilterEditorCls = "_16lm1iw11 _16lm1iwz";
-var HeaderGroupCls = "_12zfob11h _16lm1iwt _16lm1iw1d _16lm1iw1e";
+var CellCls = "_1eexc2a5 _16lm1iwu _16lm1iw1f _16lm1iw1h _16lm1iw2 _16lm1iw1r _16lm1iw1s _16lm1iwy";
+var HeaderCellContentRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob11e _16lm1iw10 _16lm1iw12 _16lm1iwu _16lm1iw1f _16lm1iw1h", variantClassNames: { filtered: { false: "_12zfob11f", true: "_12zfob11g" } }, defaultVariants: {}, compoundVariants: [] });
+var HeaderCellProxy = "_12zfob1k _16lm1iw1s _16lm1iw1t _16lm1iw1m";
+var HeaderCellRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob1l _16lm1iww", variantClassNames: { rowActive: { false: "_12zfob1m", true: "_12zfob1n" }, rowSelected: { false: "_12zfob1o", true: "_12zfob1p", null: "_12zfob1q" }, zebra: { false: "_12zfob1r", even: "_12zfob1s", odd: "_12zfob1t" }, dragging: { true: "_12zfob1u", false: "_12zfob1v" }, first: { true: "_12zfob1w", false: "_12zfob1x" }, last: { true: "_12zfob1y", false: "_12zfob1z" }, groupByField: { true: "_12zfob110", false: "_12zfob111" }, firstInCategory: { true: "_12zfob112", false: "_12zfob113" }, lastInCategory: { true: "_12zfob114", false: "_12zfob115" }, pinned: { start: "_12zfob116", end: "_12zfob117", false: "_12zfob118" }, filtered: { true: "_12zfob119", false: "_12zfob11a" } }, defaultVariants: {}, compoundVariants: [[{ pinned: "start", lastInCategory: true }, "_12zfob11b"], [{ pinned: "end", firstInCategory: true }, "_12zfob11c"], [{ pinned: false, lastInCategory: true }, "_12zfob11d"]] });
+var HeaderClsRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_12zfob16 _16lm1iww _16lm1iw2", variantClassNames: { pinned: { start: "_12zfob17", end: "_12zfob18", false: "_12zfob19" }, firstInCategory: { true: "_12zfob1a", false: "_12zfob1b" }, lastInCategory: { true: "_12zfob1c", false: "_12zfob1d" }, overflow: { true: "_12zfob1e", false: "_12zfob1f" } }, defaultVariants: {}, compoundVariants: [[{ overflow: true, pinned: "start" }, "_12zfob1g"], [{ pinned: "start", firstInCategory: true }, "_12zfob1h"], [{ overflow: true, pinned: "end" }, "_12zfob1i"], [{ pinned: "end", lastInCategory: true }, "_12zfob1j"]] });
+var HeaderFilterCls = "_12zfob11j _16lm1iwu _16lm1iw1f _16lm1iw1h _16lm1iw1";
+var HeaderFilterEditorCls = "_16lm1iw12 _16lm1iw10";
+var HeaderGroupCls = "_12zfob11i _16lm1iwu _16lm1iw1f _16lm1iw1h";
 var HeaderScrollbarPlaceholderCls = "_12zfob15 _16lm1iw2";
 var HeaderSortIconCls = "_16lm1iw1";
 var HeaderSortIconIndexCls = "_12zfob14";
 var HeaderSortIconRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "", variantClassNames: { align: { start: "_12zfob11", center: "_12zfob12", end: "_12zfob13" } }, defaultVariants: {}, compoundVariants: [] });
-var HeaderWrapperCls = "_12zfob11g _16lm1iw1j _16lm1iw1 _16lm1iwt _16lm1iw1d";
+var HeaderWrapperCls = "_12zfob11h _16lm1iw1m _16lm1iw1 _16lm1iwu _16lm1iw1f";
 
 // src/components/InfiniteTable/components/icons/SortIcon.tsx
 var defaultLineStyle = {
@@ -6054,9 +6147,9 @@ function getColumnGroupResizer(colIndexes, config) {
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/ResizeHandle.css.ts
 var import_createRuntimeFn4 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-var ResizeHandleCls = "zneyzh0 _16lm1iw2 _16lm1iw12 _16lm1iw19 _16lm1iw17 _16lm1iwe _16lm1iw1j";
-var ResizeHandleDraggerClsRecipe = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "zneyzhb _16lm1iw2 _16lm1iw12 _16lm1iw17", variantClassNames: { constrained: { false: "zneyzhc", true: "zneyzhd" } }, defaultVariants: {}, compoundVariants: [] });
-var ResizeHandleRecipeCls = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "", variantClassNames: { computedPinned: { start: "zneyzh1", end: "zneyzh2 _16lm1iw14 _16lm1iw1b", false: "zneyzh3" }, computedFirstInCategory: { true: "zneyzh4", false: "zneyzh5" }, computedLastInCategory: { true: "zneyzh6", false: "zneyzh7" } }, defaultVariants: {}, compoundVariants: [[{ computedPinned: "end", computedLastInCategory: false, computedFirstInCategory: true }, "zneyzh8"], [{ computedPinned: false, computedFirstInCategory: false, computedLastInCategory: true }, "zneyzh9"], [{ computedPinned: "start", computedFirstInCategory: false, computedLastInCategory: true }, "zneyzha"]] });
+var ResizeHandleCls = "zneyzh0 _16lm1iw2 _16lm1iw13 _16lm1iw1a _16lm1iw18 _16lm1iwf _16lm1iw1m";
+var ResizeHandleDraggerClsRecipe = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "zneyzhb _16lm1iw2 _16lm1iw13 _16lm1iw18", variantClassNames: { constrained: { false: "zneyzhc", true: "zneyzhd" } }, defaultVariants: {}, compoundVariants: [] });
+var ResizeHandleRecipeCls = (0, import_createRuntimeFn4.createRuntimeFn)({ defaultClassName: "", variantClassNames: { computedPinned: { start: "zneyzh1", end: "zneyzh2 _16lm1iw15 _16lm1iw1c", false: "zneyzh3" }, computedFirstInCategory: { true: "zneyzh4", false: "zneyzh5" }, computedLastInCategory: { true: "zneyzh6", false: "zneyzh7" } }, defaultVariants: {}, compoundVariants: [[{ computedPinned: "end", computedLastInCategory: false, computedFirstInCategory: true }, "zneyzh8"], [{ computedPinned: false, computedFirstInCategory: false, computedLastInCategory: true }, "zneyzh9"], [{ computedPinned: "start", computedFirstInCategory: false, computedLastInCategory: true }, "zneyzha"]] });
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/index.tsx
 var { rootClassName: rootClassName8 } = internalProps;
@@ -6199,6 +6292,23 @@ function useColumnResizeHandle(column) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderCell.tsx
+var defaultRenderSelectionCheckBox2 = (params) => {
+  const { allRowsSelected, someRowsSelected, api } = params;
+  const selected = allRowsSelected ? true : someRowsSelected ? null : false;
+  return /* @__PURE__ */ createElement22(InfiniteCheckBox, {
+    domProps: {
+      className: SelectionCheckboxCls
+    },
+    onChange: (selected2) => {
+      if (selected2) {
+        api.selectionApi.selectAll();
+      } else {
+        api.selectionApi.deselectAll();
+      }
+    },
+    checked: selected
+  });
+};
 var InfiniteTableHeaderCellContext = createContext5(null);
 var { rootClassName: rootClassName9 } = internalProps;
 var InfiniteTableHeaderCellClassName = `${rootClassName9}HeaderCell`;
@@ -6208,6 +6318,7 @@ function InfiniteTableHeaderCell(props) {
   const column = props.column;
   const {
     computed: { showColumnFilters },
+    imperativeApi: api,
     componentState: {
       portalDOMRef,
       columnHeaderHeight,
@@ -6215,8 +6326,9 @@ function InfiniteTableHeaderCell(props) {
       columnReorderDragColumnId
     }
   } = useInfiniteTable();
+  const { allRowsSelected, someRowsSelected, selectionMode } = useDataSource();
   const dragging = columnReorderDragColumnId === column.id;
-  const { onResize, height, width, headerOptions } = props;
+  const { onResize, height, width, headerOptions, columnsMap } = props;
   const sortInfo = column.computedSortInfo;
   let header = column.header;
   const ref = useCallback9((node) => {
@@ -6225,7 +6337,7 @@ function InfiniteTableHeaderCell(props) {
     (_a2 = props.domRef) == null ? void 0 : _a2.call(props, node);
   }, [props.domRef]);
   const alwaysShow = headerOptions.alwaysReserveSpaceForSortIcon;
-  const sortTool = column.computedSortable && (column.computedSorted || alwaysShow) ? /* @__PURE__ */ createElement22(SortIcon, {
+  const sortIcon = column.computedSortable && (column.computedSorted || alwaysShow) ? /* @__PURE__ */ createElement22(SortIcon, {
     index: column.computedMultiSort ? column.computedSortIndex + 1 : void 0,
     className: `${InfiniteTableHeaderCellClassName}__sort-icon ${HeaderSortIconCls} ${HeaderSortIconRecipe({
       align: column.align || "start"
@@ -6236,20 +6348,58 @@ function InfiniteTableHeaderCell(props) {
     dragging,
     domRef: ref,
     column,
+    columnsMap,
     columnSortInfo: sortInfo,
     columnFilterValue: column.computedFilterValue,
-    sortTool
+    someRowsSelected,
+    allRowsSelected,
+    selectionMode,
+    api,
+    renderBag: {
+      sortIcon,
+      selectionCheckBox: null,
+      header: column.header && typeof column.header !== "function" ? column.header : column.name
+    }
   };
   const align = column.align || "start";
   const renderChildren = () => {
+    if (column.renderSortIcon) {
+      renderParam.renderBag.sortIcon = /* @__PURE__ */ createElement22(RenderHeaderCellHookComponent, {
+        render: column.renderSortIcon,
+        renderParam: __spreadProps(__spreadValues({}, renderParam), {
+          renderBag: __spreadValues({}, renderParam.renderBag)
+        })
+      });
+    }
+    if (column.renderSelectionCheckBox && selectionMode === "multi-row") {
+      renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ createElement22(RenderHeaderCellHookComponent, {
+        render: defaultRenderSelectionCheckBox2,
+        renderParam
+      });
+      if (column.renderHeaderSelectionCheckBox && column.renderHeaderSelectionCheckBox !== true) {
+        renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ createElement22(RenderHeaderCellHookComponent, {
+          render: column.renderHeaderSelectionCheckBox,
+          renderParam: __spreadProps(__spreadValues({}, renderParam), {
+            renderBag: __spreadValues({}, renderParam.renderBag)
+          })
+        });
+      }
+    }
     if (header instanceof Function) {
-      header = /* @__PURE__ */ createElement22(RenderHookComponent, {
+      renderParam.renderBag.header = /* @__PURE__ */ createElement22(RenderHookComponent, {
         render: header,
+        renderParam: __spreadProps(__spreadValues({}, renderParam), {
+          renderBag: __spreadValues({}, renderParam.renderBag)
+        })
+      });
+    }
+    if (column.renderHeader) {
+      return /* @__PURE__ */ createElement22(RenderHeaderCellHookComponent, {
+        render: column.renderHeader,
         renderParam
       });
     }
-    header = header != null ? header : column.name;
-    return /* @__PURE__ */ createElement22(Fragment3, null, align === "end" ? sortTool : null, header, align !== "end" ? sortTool : null);
+    return /* @__PURE__ */ createElement22(Fragment3, null, align !== "end" ? renderParam.renderBag.selectionCheckBox : null, align === "end" ? renderParam.renderBag.sortIcon : null, renderParam.renderBag.header, align !== "end" ? renderParam.renderBag.sortIcon : null, align === "end" ? renderParam.renderBag.selectionCheckBox : null);
   };
   const domRef = useRef13(null);
   const {
@@ -6785,7 +6935,7 @@ function InfiniteTableHeaderFn(props) {
       headerOptions,
       width: widthWithColspan,
       height: heightWithRowspan,
-      columns: computedVisibleColumnsMap
+      columnsMap: computedVisibleColumnsMap
     });
   }, [
     headerOptions,
@@ -6989,7 +7139,7 @@ var InfiniteTableLicenseFooter = forwardRef4(function InfiniteTableLicenseFooter
 
 // src/components/InfiniteTable/components/InfiniteTableRow/row.css.ts
 var import_createRuntimeFn5 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-var GroupRowExpanderCls = "_7pupv0b";
+var GroupRowExpanderCls = (0, import_createRuntimeFn5.createRuntimeFn)({ defaultClassName: "", variantClassNames: { align: { start: "_7pupv0b", center: "_7pupv0c", end: "_7pupv0d" } }, defaultVariants: {}, compoundVariants: [] });
 var RowClsRecipe = (0, import_createRuntimeFn5.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";
 
@@ -7000,8 +7150,8 @@ import {
 } from "react";
 
 // src/components/InfiniteTable/components/LoadMask.css.ts
-var LoadMaskCls = { visible: "qy58ya1 qy58ya0 _16lm1iw2 _16lm1iw12 _16lm1iw14 _16lm1iw19 _16lm1iw17", hidden: "qy58ya2 qy58ya0 _16lm1iw2 _16lm1iw12 _16lm1iw14 _16lm1iw19 _16lm1iw17" };
-var LoadMaskOverlayCls = "qy58ya3 _16lm1iw2 _16lm1iw12 _16lm1iw14 _16lm1iw19 _16lm1iw17";
+var LoadMaskCls = { visible: "qy58ya1 qy58ya0 _16lm1iw2 _16lm1iw13 _16lm1iw15 _16lm1iw1a _16lm1iw18", hidden: "qy58ya2 qy58ya0 _16lm1iw2 _16lm1iw13 _16lm1iw15 _16lm1iw1a _16lm1iw18" };
+var LoadMaskOverlayCls = "qy58ya3 _16lm1iw2 _16lm1iw13 _16lm1iw15 _16lm1iw1a _16lm1iw18";
 var LoadMaskTextCls = "qy58ya4";
 
 // src/components/InfiniteTable/components/LoadMask.tsx
@@ -7019,9 +7169,38 @@ function LoadMaskFn(props) {
 }
 var LoadMask = memo12(LoadMaskFn);
 
+// src/utils/deepClone.ts
+function cloneArray(arr) {
+  return arr.map(deepClone);
+}
+function deepClone(source) {
+  if (getGlobal().structuredClone) {
+    return getGlobal().structuredClone(source);
+  }
+  if (source === null || typeof source !== "object") {
+    return source;
+  }
+  if (Array.isArray(source)) {
+    return cloneArray(source);
+  }
+  if (source instanceof Date) {
+    return new Date(source);
+  }
+  if (source instanceof Set) {
+    return new Set(cloneArray(Array.from(source)));
+  }
+  if (source instanceof Map) {
+    return new Map(cloneArray(Array.from(source)));
+  }
+  let target = {};
+  for (let key in source)
+    if (source.hasOwnProperty(key)) {
+      target[key] = deepClone(source[key]);
+    }
+  return target;
+}
+
 // src/utils/groupAndPivot/index.ts
-var GROUP_SELECTED_REDUCER_KEY = "__groupFullySelected";
-var GROUP_CHILDREN_SELECTED_COUNT_KEY = "__groupChildrenSelectedCount";
 var LAZY_ROOT_KEY_FOR_GROUPS = "____root____";
 var NOT_LOADED_YET_KEY_PREFIX = "____not_loaded_yet____";
 function DEFAULT_TO_KEY(value) {
@@ -7038,7 +7217,7 @@ function initReducers(reducers) {
     }
   return result;
 }
-function computeReducersFor(data, index, reducers, reducerResults) {
+function computeReducersFor(data, index, reducers, reducerResults, groupKeys) {
   var _a, _b;
   if (!reducers || !Object.keys(reducers).length) {
     return;
@@ -7051,7 +7230,7 @@ function computeReducersFor(data, index, reducers, reducerResults) {
       }
       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, index);
+      reducerResults[key] = reducer.reducer(currentValue, value, data, index, groupKeys);
     }
 }
 function lazyGroup(groupParams, rootData) {
@@ -7059,6 +7238,8 @@ function lazyGroup(groupParams, rootData) {
     reducers = {},
     pivot,
     groupBy,
+    indexer,
+    toPrimaryKey,
     mappings
   } = groupParams;
   const deepMap = new DeepMap();
@@ -7083,7 +7264,7 @@ function lazyGroup(groupParams, rootData) {
   const topLevelPivotColumns = pivot ? new DeepMap() : void 0;
   const currentPivotKeys = [];
   const initialReducerValue = initReducers(reducers);
-  const globalReducerResults = __spreadValues({}, initialReducerValue);
+  const globalReducerResults = deepClone(initialReducerValue);
   rootData.visitDepthFirst((lazyGroupRowInfo, keys, _index, next) => {
     const [_rootKey, ...currentGroupKeys] = keys;
     const dataArray = lazyGroupRowInfo.children;
@@ -7097,6 +7278,7 @@ function lazyGroup(groupParams, rootData) {
     if (currentGroupKeys.length == groupBy.length && groupBy.length) {
       if (current) {
         current.items = dataArray;
+        indexer.indexArray(dataArray, toPrimaryKey);
       }
       return next == null ? void 0 : next();
     }
@@ -7127,6 +7309,7 @@ function lazyGroup(groupParams, rootData) {
         childrenLoading: false,
         childrenAvailable: false,
         commonData: dataObject,
+        totalChildrenCount: dataArray[i].totalChildrenCount,
         reducerResults: dataArray[i].aggregations || {}
       };
       deepMap.set(currentGroupKeys, deepMapGroupValue);
@@ -7161,7 +7344,7 @@ function processGroup(deepMap, currentGroupKeys, currentPivotKeys, item, itemInd
   } = deepMap.get(currentGroupKeys);
   currentGroupItems.push(item);
   if (reducers) {
-    computeReducersFor(item, itemIndex, reducers, reducerResults);
+    computeReducersFor(item, itemIndex, reducers, reducerResults, currentGroupKeys);
   }
   if (pivot) {
     for (let pivotIndex = 0, pivotLength = pivot.length; pivotIndex < pivotLength; pivotIndex++) {
@@ -7171,19 +7354,27 @@ function processGroup(deepMap, currentGroupKeys, currentPivotKeys, item, itemInd
       if (!pivotDeepMap.has(currentPivotKeys)) {
         topLevelPivotColumns.set(currentPivotKeys, true);
         pivotDeepMap == null ? void 0 : pivotDeepMap.set(currentPivotKeys, {
-          reducerResults: __spreadValues({}, initialReducerValue),
+          reducerResults: deepClone(initialReducerValue),
           items: []
         });
       }
       const { reducerResults: pivotReducerResults, items: pivotGroupItems } = pivotDeepMap.get(currentPivotKeys);
       pivotGroupItems.push(item);
       if (reducers) {
-        computeReducersFor(item, itemIndex, reducers, pivotReducerResults);
+        computeReducersFor(item, itemIndex, reducers, pivotReducerResults, currentGroupKeys);
       }
     }
     currentPivotKeys.length = 0;
   }
 }
+function getGroupKeysForDataItem(data, groupBy) {
+  return groupBy.reduce((groupKeys, groupBy2) => {
+    const { field: groupByProperty, toKey: groupToKey } = groupBy2;
+    const key = (groupToKey || DEFAULT_TO_KEY)(data[groupByProperty], data);
+    groupKeys.push(key);
+    return groupKeys;
+  }, []);
+}
 function group(groupParams, data) {
   const {
     groupBy,
@@ -7197,14 +7388,14 @@ function group(groupParams, data) {
   const currentGroupKeys = [];
   const currentPivotKeys = [];
   const initialReducerValue = initReducers(reducers);
-  const globalReducerResults = __spreadValues({}, initialReducerValue);
+  const globalReducerResults = deepClone(initialReducerValue);
   if (!groupByLength) {
     const deepMapGroupValue = {
       items: [],
       cache: false,
       childrenLoading: false,
       childrenAvailable: false,
-      reducerResults: __spreadValues({}, initialReducerValue)
+      reducerResults: deepClone(initialReducerValue)
     };
     if (pivot) {
       deepMapGroupValue.pivotDeepMap = new DeepMap();
@@ -7223,7 +7414,7 @@ function group(groupParams, data) {
           cache: false,
           childrenLoading: false,
           childrenAvailable: false,
-          reducerResults: __spreadValues({}, initialReducerValue)
+          reducerResults: deepClone(initialReducerValue)
         };
         if (pivot) {
           deepMapGroupValue.pivotDeepMap = new DeepMap();
@@ -7236,7 +7427,7 @@ function group(groupParams, data) {
       processGroup(deepMap, currentGroupKeys, currentPivotKeys, item, i, pivot, reducers, topLevelPivotColumns, initialReducerValue, defaultToKey);
     }
     if (reducers) {
-      computeReducersFor(item, i, reducers, globalReducerResults);
+      computeReducersFor(item, i, reducers, globalReducerResults, currentGroupKeys);
     }
     currentGroupKeys.length = 0;
   }
@@ -7313,8 +7504,9 @@ function getEnhancedGroupData(options, deepMapValue) {
     groupCount: groupItems.length,
     groupData: groupItems,
     groupKeys,
-    rowSelected: !!reducerResults[GROUP_SELECTED_REDUCER_KEY] || false,
-    childrenSelectedCount: reducerResults[GROUP_CHILDREN_SELECTED_COUNT_KEY] || 0,
+    rowSelected: false,
+    selectedChildredCount: 0,
+    deselectedChildredCount: 0,
     id: `${groupKeys}`,
     collapsed,
     dataSourceHasGrouping: true,
@@ -7324,6 +7516,7 @@ function getEnhancedGroupData(options, deepMapValue) {
     deepRowInfoArray: [],
     collapsedChildrenCount: 0,
     collapsedGroupsCount: 0,
+    totalChildrenCount: options.totalChildrenCount,
     childrenAvailable: lazyLoad ? options.childrenAvailable : true,
     childrenLoading: options.childrenLoading,
     indexInParentGroups: options.indexInParentGroups,
@@ -7360,7 +7553,7 @@ function enhancedFlatten(param) {
     toPrimaryKey,
     groupRowsState,
     isRowSelected,
-    indexer,
+    rowSelectionState,
     generateGroupRows,
     reducers = {}
   } = param;
@@ -7386,13 +7579,21 @@ function enhancedFlatten(param) {
       indexInAll: result.length,
       groupKeys,
       error: deepMapValue.error,
+      totalChildrenCount: deepMapValue.totalChildrenCount,
       childrenLoading: deepMapValue.childrenLoading,
       childrenAvailable: deepMapValue.childrenAvailable,
       directChildrenCount: groupKeys.length === groupByStrings.length ? deepMapValue.items.length : deepMap.getDirectChildrenSizeFor(groupKeys),
       directChildrenLoadedCount: 0,
       collapsed
     }, deepMapValue);
-    indexer.add(enhancedGroupData.indexInAll, enhancedGroupData.id);
+    if (isRowSelected) {
+      enhancedGroupData.rowSelected = isRowSelected(enhancedGroupData);
+      if (rowSelectionState) {
+        const selectionCount = rowSelectionState.getSelectionCountFor(enhancedGroupData.groupKeys);
+        enhancedGroupData.selectedChildredCount = selectionCount.selectedCount;
+        enhancedGroupData.deselectedChildredCount = selectionCount.deselectedCount;
+      }
+    }
     const parent = parents[parents.length - 1];
     const parentCollapsed = (_b = parent == null ? void 0 : parent.collapsed) != null ? _b : false;
     let include = generateGroupRows || collapsed;
@@ -7455,7 +7656,6 @@ function enhancedFlatten(param) {
             if (isRowSelected) {
               rowInfo.rowSelected = isRowSelected(rowInfo);
             }
-            indexer.add(rowInfo.indexInAll, rowInfo.id);
             parents.forEach((parent2, i) => {
               const last = i === parents.length - 1;
               if (last && item) {
@@ -8257,212 +8457,540 @@ function lazyLoadRange(options, cache) {
   }, initialPromise);
 }
 
-// src/components/DataSource/BooleanCollectionState.ts
-var BooleanCollectionState = class {
-  constructor(state) {
+// src/components/DataSource/RowSelectionState.ts
+var RowSelectionState = class {
+  constructor(state, getConfig, _forTestingOnly) {
+    this.selectedRows = null;
+    this.deselectedRows = null;
+    this.defaultSelection = false;
+    this.selectedMap = new DeepMap();
+    this.deselectedMap = new DeepMap();
+    this.selectionCache = new DeepMap();
+    this.selectionCountCache = new DeepMap();
+    this.mapSet = (name, key) => {
+      if (!Array.isArray(key)) {
+        key = [...this.getGroupKeysForPrimaryKey(key), key];
+      }
+      this.xcache();
+      if (name === "selected") {
+        this.selectedMap.set(key, true);
+      } else {
+        this.deselectedMap.set(key, true);
+      }
+    };
+    this._selectedMapSet = (key) => {
+      this.mapSet("selected", key);
+    };
+    this._deselectedMapSet = (key) => {
+      this.mapSet("deselected", key);
+    };
     const stateObject = state instanceof Object.getPrototypeOf(this).constructor ? state.getState() : state;
-    const positiveItems = this.getPositiveFromState(stateObject);
-    const negativeItems = this.getNegativeFromState(stateObject);
-    this.update({
-      negativeItems,
-      positiveItems
-    });
+    this.getConfig = getConfig;
+    if (_forTestingOnly) {
+      Object.assign(this, _forTestingOnly);
+    }
+    this.update(stateObject);
   }
-  getInitialState() {
-    return this.initialState;
+  getGroupKeysForPrimaryKey(pk) {
+    const { indexer, groupBy } = this.getConfig();
+    const data = indexer.getDataForPrimaryKey(pk);
+    return data ? getGroupKeysForDataItem(data, groupBy) : [];
   }
-  destroy() {
-    var _a, _b;
-    (_a = this.positiveMap) == null ? void 0 : _a.clear();
-    (_b = this.negativeMap) == null ? void 0 : _b.clear();
-    delete this.positiveMap;
-    delete this.negativeMap;
+  getGroupDeepMap() {
+    return this.getConfig().groupDeepMap;
   }
-  update(state) {
-    const { positiveItems, negativeItems } = state;
-    this.allNegative = negativeItems === true;
-    this.allPositive = positiveItems === true;
-    if (this.allNegative && this.allPositive) {
-      throw `Cannot have both negativeItems and positiveItems be true!`;
-    }
-    if (negativeItems && negativeItems !== true) {
-      if (!this.negativeMap) {
-        this.negativeMap = new Map();
-      }
-      this.negativeMap.clear();
-      for (let k in negativeItems) {
-        if (negativeItems.hasOwnProperty(k)) {
-          this.negativeMap.set(k, true);
-        }
-      }
-      if (this.positiveMap) {
-        this.positiveMap.clear();
-      }
+  getGroupCount(groupKeys) {
+    var _a;
+    if (groupKeys.length == 0) {
+      return this.getConfig().totalCount;
     }
-    if (positiveItems && positiveItems !== true) {
-      if (!this.positiveMap) {
-        this.positiveMap = new Map();
-      }
-      this.positiveMap.clear();
-      for (let k in positiveItems) {
-        if (positiveItems.hasOwnProperty(k)) {
-          this.positiveMap.set(k, true);
-        }
-      }
-      if (this.negativeMap) {
-        this.negativeMap.clear();
-      }
+    const groupDeepMap = this.getGroupDeepMap();
+    const deepMapValue = groupDeepMap == null ? void 0 : groupDeepMap.get(groupKeys);
+    if (!deepMapValue) {
+      return 0;
     }
+    return (_a = deepMapValue.totalChildrenCount) != null ? _a : deepMapValue.items.length || 0;
   }
-  isDefaultNegativeSelection() {
-    return this.allNegative;
+  getGroupKeysDirectlyInsideGroup(groupKeys) {
+    const { groupDeepMap } = this.getConfig();
+    return (groupDeepMap == null ? void 0 : groupDeepMap.getKeysStartingWith(groupKeys, true, 1)) || [];
   }
-  isDefaultPositiveSelection() {
-    return this.allPositive;
+  getGroupByLength() {
+    return this.getConfig().groupBy.length;
   }
-  areAllNegative() {
-    return this.allNegative && (this.positiveMap ? this.positiveMap.size === 0 : true);
+  static from(rowSeleStateObject, getConfig, _forTestingOnly) {
+    return new RowSelectionState(rowSeleStateObject, getConfig, _forTestingOnly);
   }
-  areAllPositive() {
-    return this.allPositive && (this.negativeMap ? this.negativeMap.size === 0 : true);
+  update(stateObject) {
+    var _a, _b;
+    this.selectedRows = stateObject.selectedRows || null;
+    this.deselectedRows = stateObject.deselectedRows || null;
+    this.selectedMap.clear();
+    this.deselectedMap.clear();
+    (_a = this.selectedRows) == null ? void 0 : _a.forEach(this._selectedMapSet);
+    (_b = this.deselectedRows) == null ? void 0 : _b.forEach(this._deselectedMapSet);
+    this.defaultSelection = stateObject.defaultSelection;
+    this.xcache();
+  }
+  xcache() {
+    this.selectionCache.clear();
+    this.selectionCountCache.clear();
   }
-  makeAllNegative() {
+  getState() {
+    const normalize = (allKeys) => {
+      const groupByLength = this.getGroupByLength();
+      return allKeys.map((keys) => keys.length > groupByLength ? keys.pop() : keys);
+    };
+    const selectedRows = normalize(this.selectedMap.topDownKeys());
+    const deselectedRows = normalize(this.deselectedMap.topDownKeys());
+    return {
+      defaultSelection: this.defaultSelection,
+      selectedRows,
+      deselectedRows
+    };
+  }
+  deselectAll() {
     this.update({
-      negativeItems: true,
-      positiveItems: {}
+      defaultSelection: false,
+      selectedRows: [],
+      deselectedRows: []
     });
   }
-  makeAllPositive() {
+  selectAll() {
     this.update({
-      positiveItems: true,
-      negativeItems: {}
+      defaultSelection: true,
+      deselectedRows: [],
+      selectedRows: []
     });
   }
-  isItemPositive(key) {
-    var _a, _b;
-    key = `${key}`;
-    if (this.allPositive === true) {
-      if (this.allNegative === true) {
-        throw 'Cannot have both positiveItems and negativeItems be "true"';
-      }
-      return !((_a = this.negativeMap) == null ? void 0 : _a.has(key));
-    }
-    return !!((_b = this.positiveMap) == null ? void 0 : _b.has(key));
-  }
-  isItemNegative(key) {
-    return !this.isItemPositive(key);
+  isRowDefaultSelected() {
+    return this.defaultSelection === true;
   }
-  setItemValue(key, shouldMakePositive) {
-    var _a;
-    key = `${key}`;
-    if (shouldMakePositive === this.isItemPositive(key)) {
-      return;
+  isRowDefaultDeselected() {
+    return this.defaultSelection === false;
+  }
+  isRowSelected(key, groupKeys) {
+    groupKeys = groupKeys || this.getGroupKeysForPrimaryKey(key);
+    const finalKey = [...groupKeys, key];
+    const cachedResult = this.selectionCache.get(finalKey);
+    if (cachedResult !== void 0) {
+      return cachedResult;
+    }
+    const inSelected = this.selectedMap.has(finalKey);
+    const inDeselected = this.deselectedMap.has(finalKey);
+    if (inSelected) {
+      this.selectionCache.set(finalKey, true);
+      return true;
     }
-    if (shouldMakePositive) {
-      if (this.allNegative === true) {
-        if (!this.positiveMap) {
-          throw `No positiveMap found when trying to set item ${key} be positive`;
-        }
-        this.positiveMap.set(key, true);
-      } else if (this.allPositive === true) {
-        if (!this.negativeMap) {
-          throw `No negativeMap found when trying to set item ${key} be positive`;
-        }
-        this.negativeMap.delete(key);
+    if (inDeselected) {
+      this.selectionCache.set(finalKey, false);
+      return false;
+    }
+    if (this.selectedMap.has(groupKeys)) {
+      this.selectionCache.set(finalKey, true);
+      return true;
+    }
+    if (this.deselectedMap.has(groupKeys)) {
+      this.selectionCache.set(finalKey, false);
+      return false;
+    }
+    groupKeys = [...groupKeys];
+    while (groupKeys.length) {
+      groupKeys.pop();
+      const inSelected2 = this.selectedMap.has(groupKeys);
+      const inDeselected2 = this.deselectedMap.has(groupKeys);
+      if (inSelected2) {
+        this.selectionCache.set(finalKey, true);
+        return true;
       }
-    } else {
-      if (this.allPositive === true) {
-        if (!this.negativeMap) {
-          throw `No negativeMap found when trying to set item ${key} be negative`;
-        }
-        this.negativeMap.set(key, true);
-      } else if (this.allNegative === true) {
-        if (!this.positiveMap) {
-          throw `No positiveMap found when trying to set item ${key} be negative`;
-        }
-        (_a = this.positiveMap) == null ? void 0 : _a.delete(key);
+      if (inDeselected2) {
+        this.selectionCache.set(finalKey, false);
+        return false;
       }
     }
+    this.selectionCache.set(finalKey, this.defaultSelection);
+    return this.defaultSelection;
   }
-  makeItemNegative(key) {
-    this.setItemValue(key, false);
-  }
-  makeItemPositive(key) {
-    this.setItemValue(key, true);
-  }
-  toggleItem(key) {
-    this.setItemValue(key, !this.isItemPositive(key));
+  isRowDeselected(key, groupKeys) {
+    return !this.isRowSelected(key, groupKeys);
   }
-};
-
-// src/components/DataSource/RowSelectionState.ts
-function reduceKeysToRecord(acc, key) {
-  acc[key] = true;
-  return acc;
-}
-var RowSelectionState = class extends BooleanCollectionState {
-  constructor(state) {
-    super(state);
+  setRowSelected(key, selected, groupKeys) {
+    if (selected) {
+      this.setRowAsSelected(key, groupKeys);
+    } else {
+      this.setRowAsDeselected(key, groupKeys);
+    }
   }
-  getState() {
-    var _a, _b, _c, _d;
-    return {
-      selectedRows: this.allPositive ? true : (_b = [...((_a = this.positiveMap) == null ? void 0 : _a.keys()) || []].reduce(reduceKeysToRecord, {})) != null ? _b : {},
-      deselectedRows: this.allNegative ? true : (_d = [...((_c = this.negativeMap) == null ? void 0 : _c.keys()) || []].reduce(reduceKeysToRecord, {})) != null ? _d : {}
-    };
+  getGroupRowSelectionState(initialGroupKeys) {
+    const cachedResult = this.selectionCache.get(initialGroupKeys);
+    if (cachedResult !== void 0) {
+      return cachedResult;
+    }
+    const { selectedCount, deselectedCount } = this.getSelectionCountFor(initialGroupKeys, this.getGroupRowBooleanSelectionStateFromParent(initialGroupKeys));
+    const result = selectedCount && deselectedCount ? null : selectedCount ? true : false;
+    this.selectionCache.set(initialGroupKeys, result);
+    return result;
   }
-  getPositiveFromState(state) {
-    return state.selectedRows;
+  getGroupRowBooleanSelectionStateFromParent(initialGroupKeys) {
+    if (!initialGroupKeys.length) {
+      return this.defaultSelection;
+    }
+    const groupKeys = [...initialGroupKeys];
+    const selfDeselected = this.deselectedMap.has(groupKeys);
+    const selfSelected = this.selectedMap.has(groupKeys);
+    let selectionState = selfSelected && !selfDeselected ? true : selfDeselected && !selfSelected ? false : void 0;
+    if (selectionState === void 0) {
+      while (groupKeys.length) {
+        groupKeys.pop();
+        if (this.deselectedMap.has(groupKeys)) {
+          selectionState = false;
+          break;
+        }
+        if (this.selectedMap.has(groupKeys)) {
+          selectionState = true;
+          break;
+        }
+      }
+    }
+    if (selectionState === void 0) {
+      selectionState = this.defaultSelection;
+    }
+    return selectionState;
   }
-  getNegativeFromState(state) {
-    return state.deselectedRows;
+  isGroupRowPartlySelected(groupKeys) {
+    return this.getGroupRowSelectionState(groupKeys) === null;
   }
-  areAllSelected() {
-    return this.areAllPositive();
+  isGroupRowSelected(groupKeys) {
+    return this.getGroupRowSelectionState(groupKeys) === true;
   }
-  areAllDeselected() {
-    return this.areAllNegative();
+  isGroupRowDeselected(groupKeys) {
+    return this.getGroupRowSelectionState(groupKeys) === false;
   }
-  deselectAll() {
-    this.makeAllNegative();
+  selectGroupRow(groupKeys) {
+    const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys, true);
+    selectedKeys.forEach((groupKeys2) => {
+      this.selectedMap.delete(groupKeys2);
+    });
+    this._selectedMapSet(groupKeys);
+    const deselectedKeys = this.deselectedMap.getKeysStartingWith(groupKeys);
+    deselectedKeys.forEach((groupKeys2) => {
+      this.deselectedMap.delete(groupKeys2);
+    });
   }
-  selectAll() {
-    this.makeAllPositive();
+  deselectGroupRow(groupKeys) {
+    const deselectedKeys = this.deselectedMap.getKeysStartingWith(groupKeys, true);
+    deselectedKeys.forEach((groupKeys2) => {
+      this.deselectedMap.delete(groupKeys2);
+    });
+    this._deselectedMapSet(groupKeys);
+    const selectedKeys = this.selectedMap.getKeysStartingWith(groupKeys);
+    selectedKeys.forEach((groupKeys2) => {
+      this.selectedMap.delete(groupKeys2);
+    });
   }
-  isRowDefaultSelected() {
-    return this.isDefaultPositiveSelection();
+  setRowAsSelected(key, groupKeys) {
+    groupKeys = groupKeys || this.getGroupKeysForPrimaryKey(key);
+    const finalKey = [...groupKeys, key];
+    this.deselectedMap.delete(finalKey);
+    this.xcache();
+    if (this.getGroupRowSelectionState(groupKeys) !== true) {
+      this._selectedMapSet(finalKey);
+      if (this.getGroupRowSelectionState(groupKeys) === true) {
+        this.selectGroupRow(groupKeys);
+      }
+    }
   }
-  isRowDefaultDeselected() {
-    return this.isDefaultNegativeSelection();
+  setRowAsDeselected(key, groupKeys) {
+    groupKeys = groupKeys || this.getGroupKeysForPrimaryKey(key);
+    const finalKey = [...groupKeys, key];
+    this.selectedMap.delete(finalKey);
+    if (this.getGroupRowSelectionState(groupKeys) !== false) {
+      this._deselectedMapSet(finalKey);
+      if (this.getGroupRowSelectionState(groupKeys) === false) {
+        this.deselectGroupRow(groupKeys);
+      }
+    }
   }
-  isRowSelected(key) {
-    return this.isItemPositive(key);
+  deselectRow(key, groupKeys) {
+    this.setRowSelected(key, false, groupKeys);
   }
-  isRowDeselected(key) {
-    return !this.isItemPositive(key);
+  selectRow(key, groupKeys) {
+    this.setRowSelected(key, true, groupKeys);
   }
-  setRowSelected(key, selected) {
-    return this.setItemValue(key, selected);
+  toggleGroupRowSelection(groupKeys) {
+    const groupRowSelectionState = this.getGroupRowSelectionState(groupKeys);
+    if (groupRowSelectionState === true) {
+      this.deselectGroupRow(groupKeys);
+    } else {
+      this.selectGroupRow(groupKeys);
+    }
   }
-  deselectRow(key) {
-    this.setRowSelected(key, false);
+  toggleRowSelection(key, groupKeys) {
+    if (this.isRowSelected(key, groupKeys)) {
+      this.deselectRow(key, groupKeys);
+    } else {
+      this.selectRow(key, groupKeys);
+    }
   }
-  selectRow(key) {
-    this.setRowSelected(key, true);
+  getSelectedCount() {
+    return this.getSelectionCountFor([]).selectedCount;
   }
-  toggleRowSelection(key) {
-    this.toggleItem(key);
+  getDeselectedCount() {
+    return this.getSelectionCountFor([]).deselectedCount;
   }
-  getSelectedCount(maxCount) {
+  getSelectionCountFor(groupKeys = [], parentSelected) {
     var _a, _b;
-    if (this.isRowDefaultSelected()) {
-      const unselectedCount = this.negativeMap ? this.negativeMap.size : 0;
-      return maxCount ? maxCount - unselectedCount : -unselectedCount;
-    }
-    return (_b = (_a = this.positiveMap) == null ? void 0 : _a.size) != null ? _b : 0;
+    const cachedResult = this.selectionCountCache.get(groupKeys);
+    if (cachedResult != null) {
+      return cachedResult;
+    }
+    if (groupKeys.length > this.getGroupByLength()) {
+      const result2 = this.isRowSelected(groupKeys) ? { selectedCount: 1, deselectedCount: 0 } : {
+        selectedCount: 0,
+        deselectedCount: 1
+      };
+      this.selectionCountCache.set(groupKeys, result2);
+      return result2;
+    }
+    parentSelected = parentSelected != null ? parentSelected : this.getGroupRowBooleanSelectionStateFromParent(groupKeys);
+    let allKeys = this.getGroupKeysDirectlyInsideGroup(groupKeys);
+    if (groupKeys.length === this.getGroupByLength()) {
+      const selectionState = this.selectedMap.has(groupKeys) ? true : this.deselectedMap.has(groupKeys) ? false : parentSelected;
+      const totalCount = this.getGroupCount(groupKeys);
+      let selectedCount2 = this.selectedMap.getKeysStartingWith(groupKeys, true, 1).length;
+      let deselectedCount2 = this.deselectedMap.getKeysStartingWith(groupKeys, true, 1).length;
+      const notSpecifiedCount = totalCount - (selectedCount2 + deselectedCount2);
+      const result2 = {
+        selectedCount: selectedCount2 + (selectionState ? notSpecifiedCount : 0),
+        deselectedCount: deselectedCount2 + (selectionState ? 0 : notSpecifiedCount)
+      };
+      this.selectionCountCache.set(groupKeys, result2);
+      return result2;
+    }
+    let selectedCount = 0;
+    let deselectedCount = 0;
+    if (this.getConfig().lazyLoad && !allKeys.length) {
+      const totalChildrenCount = ((_b = (_a = this.getConfig().groupDeepMap) == null ? void 0 : _a.get(groupKeys)) == null ? void 0 : _b.totalChildrenCount) || 0;
+      if (parentSelected) {
+        selectedCount = totalChildrenCount;
+        deselectedCount = this.deselectedMap.getAllChildrenSizeFor(groupKeys);
+        if (deselectedCount === totalChildrenCount) {
+          selectedCount = 0;
+        }
+      } else {
+        deselectedCount = totalChildrenCount;
+        selectedCount = this.selectedMap.getAllChildrenSizeFor(groupKeys);
+        if (selectedCount === totalChildrenCount) {
+          deselectedCount = 0;
+        }
+      }
+    }
+    allKeys.forEach((keys) => {
+      let isSelected = this.selectedMap.get(keys);
+      let isDeselected = this.deselectedMap.get(keys);
+      const selected = isSelected ? true : isDeselected ? false : parentSelected;
+      const { selectedCount: selCount, deselectedCount: deselCount } = this.getSelectionCountFor(keys, selected);
+      selectedCount += selCount;
+      deselectedCount += deselCount;
+    });
+    const result = {
+      selectedCount,
+      deselectedCount
+    };
+    this.selectionCountCache.set(groupKeys, result);
+    return result;
   }
 };
 
+// src/components/InfiniteTable/api/getSelectionApi.ts
+function rowSelectionStateConfigGetter(stateOrStateGetter) {
+  return () => {
+    const state = typeof stateOrStateGetter === "function" ? stateOrStateGetter() : stateOrStateGetter;
+    return {
+      lazyLoad: !!state.lazyLoad,
+      groupBy: state.groupBy,
+      groupDeepMap: state.groupDeepMap,
+      indexer: state.indexer,
+      totalCount: state.unfilteredCount
+    };
+  };
+}
+function getSelectionApi(param) {
+  const {
+    getDataSourceState,
+    dataSourceActions
+  } = param;
+  const selectionApi = {
+    get allRowsSelected() {
+      return getDataSourceState().allRowsSelected;
+    },
+    selectAll() {
+      const { rowSelection, selectionMode } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw "Selection mode is not multi-row";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.selectAll();
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    deselectAll() {
+      const { rowSelection, selectionMode } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw "Selection mode is not multi-row";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.deselectAll();
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    isRowSelected(pk, groupKeys) {
+      const { rowSelection, selectionMode, indexer, groupBy } = getDataSourceState();
+      if (selectionMode === "single-row") {
+        return rowSelection === pk;
+      }
+      if (selectionMode !== "multi-row") {
+        throw "Selection mode is not multi-row or single-row";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      if (!groupKeys) {
+        const data = indexer.getDataForPrimaryKey(pk);
+        groupKeys = data ? getGroupKeysForDataItem(data, groupBy) : [];
+      }
+      return rowSelection.isRowSelected(pk, groupKeys);
+    },
+    isRowDeselected(pk, groupKeys) {
+      return !this.isRowSelected(pk, groupKeys);
+    },
+    selectRow(pk, groupKeys) {
+      const { rowSelection, selectionMode, indexer, groupBy } = getDataSourceState();
+      if (selectionMode === "single-row") {
+        dataSourceActions.rowSelection = pk;
+        return;
+      }
+      if (selectionMode !== "multi-row") {
+        throw "Selection mode is not multi-row or single-row";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      if (!groupKeys) {
+        const data = indexer.getDataForPrimaryKey(pk);
+        groupKeys = data ? getGroupKeysForDataItem(data, groupBy) : [];
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.selectRow(pk, groupKeys);
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    deselectRow(pk, groupKeys) {
+      const { selectionMode, rowSelection, indexer, groupBy } = getDataSourceState();
+      if (selectionMode === "single-row") {
+        dataSourceActions.rowSelection = null;
+        return;
+      }
+      if (selectionMode !== "multi-row") {
+        throw "Selection mode is not multi-row or single-row";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      if (selectionMode === "multi-row") {
+        if (!groupKeys) {
+          const data = indexer.getDataForPrimaryKey(pk);
+          groupKeys = data ? getGroupKeysForDataItem(data, groupBy) : [];
+        }
+        const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+        rowSelectionState.deselectRow(pk, groupKeys);
+        dataSourceActions.rowSelection = rowSelectionState;
+      }
+    },
+    toggleRowSelection(pk, groupKeys) {
+      if (this.isRowSelected(pk, groupKeys)) {
+        this.deselectRow(pk, groupKeys);
+      } else {
+        this.selectRow(pk, groupKeys);
+      }
+    },
+    selectGroupRow(groupKeys) {
+      const { selectionMode, rowSelection, groupBy } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw 'Selection mode should be "multi-row"';
+      }
+      if (!groupBy) {
+        throw "No grouping specified";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.selectGroupRow(groupKeys);
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    deselectGroupRow(groupKeys) {
+      const { selectionMode, rowSelection, groupBy } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw 'Selection mode should be "multi-row"';
+      }
+      if (!groupBy) {
+        throw "No grouping specified";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.deselectGroupRow(groupKeys);
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    toggleGroupRowSelection(groupKeys) {
+      const { selectionMode, rowSelection, groupBy } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw 'Selection mode should be "multi-row"';
+      }
+      if (!groupBy) {
+        throw "No grouping specified";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+      rowSelectionState.toggleGroupRowSelection(groupKeys);
+      dataSourceActions.rowSelection = rowSelectionState;
+    },
+    getGroupRowSelectionState(groupKeys) {
+      const { selectionMode, rowSelection, groupBy } = getDataSourceState();
+      if (selectionMode !== "multi-row") {
+        throw 'Selection mode should be "multi-row"';
+      }
+      if (!groupBy) {
+        throw "No grouping specified";
+      }
+      if (!(rowSelection instanceof RowSelectionState)) {
+        throw "Invalid row selection";
+      }
+      return rowSelection.getGroupRowSelectionState(groupKeys);
+    },
+    getSelectedPrimaryKeys: () => {
+      const selected = [];
+      getDataSourceState().dataArray.forEach((rowInfo) => {
+        if (!rowInfo.isGroupRow && rowInfo.rowSelected) {
+          selected.push(rowInfo.id);
+        }
+      });
+      return selected;
+    }
+  };
+  if (false) {
+    globalThis.selectionApi = selectionApi;
+  }
+  return selectionApi;
+}
+
 // src/components/utils/discardCallsWithEqualArg.ts
 var map = new WeakMap();
 var getCompareDefault = (a) => a;
@@ -8494,22 +9022,23 @@ function discardCallsWithEqualArg(fn, timeframe = 50, getCompareObject) {
 // src/components/DataSource/Indexer.ts
 var Indexer = class {
   constructor() {
-    this.indexToPrimaryKey = new Map();
-    this.primaryKeyToIndex = new Map();
-  }
-  add(index, primaryKey) {
-    this.indexToPrimaryKey.set(index, primaryKey);
-    this.primaryKeyToIndex.set(`${primaryKey}`, index);
-  }
-  clear() {
-    this.indexToPrimaryKey.clear();
-    this.primaryKeyToIndex.clear();
-  }
-  getIndexOf(primaryKey) {
-    return this.primaryKeyToIndex.get(`${primaryKey}`);
-  }
-  getPrimaryKeyFor(index) {
-    return this.indexToPrimaryKey.get(index);
+    this.primaryKeyToData = new Map();
+    this.add = (primaryKey, data) => {
+      this.primaryKeyToData.set(`${primaryKey}`, data);
+    };
+    this.clear = () => {
+      this.primaryKeyToData.clear();
+    };
+    this.getDataForPrimaryKey = (primaryKey) => {
+      return this.primaryKeyToData.get(`${primaryKey}`);
+    };
+    this.indexArray = (arr, toPrimaryKey) => {
+      arr.forEach((item) => {
+        if (item != null) {
+          this.add(toPrimaryKey(item), item);
+        }
+      });
+    };
   }
 };
 
@@ -8570,7 +9099,7 @@ function initSetupState() {
     groupDeepMap: void 0,
     reducerResults: void 0,
     allRowsSelected: false,
-    selectedRowCount: 0,
+    someRowsSelected: false,
     postSortDataArray: void 0,
     postGroupDataArray: void 0,
     lastSortDataArray: void 0,
@@ -8626,7 +9155,7 @@ function getLivePaginationCursorValue(livePaginationCursorProp, state) {
   return livePaginationCursor;
 }
 function mapPropsToState(params) {
-  var _a, _b, _c;
+  var _a, _b;
   const { props, state, oldState } = params;
   const controlledSort = isControlledValue(props.sortInfo);
   const controlledFilter = isControlledValue(props.filterValue);
@@ -8653,36 +9182,34 @@ function mapPropsToState(params) {
           selectionMode = "single-row";
         }
       }
-      selectionMode = selectionMode != null ? selectionMode : "multi-row";
+      selectionMode = selectionMode != null ? selectionMode : false;
     }
   }
   let rowSelectionState = null;
-  let currentRowSelection = props.rowSelection !== void 0 ? props.rowSelection : (_b = state.rowSelection) != null ? _b : props.defaultRowSelection !== void 0 ? props.defaultRowSelection : null;
+  let currentRowSelection = props.rowSelection !== void 0 ? props.rowSelection : state.rowSelection === void 0 ? props.defaultRowSelection !== void 0 ? props.defaultRowSelection : null : state.rowSelection;
   if (selectionMode !== false) {
     if (selectionMode === "single-row" || selectionMode === "multi-row") {
       if (currentRowSelection === null) {
         rowSelectionState = selectionMode === "single-row" ? null : new RowSelectionState({
-          selectedRows: {},
-          deselectedRows: true
-        });
+          selectedRows: [],
+          deselectedRows: [],
+          defaultSelection: false
+        }, rowSelectionStateConfigGetter(state));
       } else {
-        rowSelectionState = selectionMode === "single-row" ? currentRowSelection : currentRowSelection instanceof RowSelectionState ? currentRowSelection : new RowSelectionState(currentRowSelection);
+        rowSelectionState = selectionMode === "single-row" ? currentRowSelection : currentRowSelection instanceof RowSelectionState ? currentRowSelection : new RowSelectionState(currentRowSelection, rowSelectionStateConfigGetter(state));
       }
     }
   }
   const primaryKeyDescriptor = state.primaryKey;
-  const toPrimaryKey = typeof primaryKeyDescriptor === "function" ? (data, index) => primaryKeyDescriptor({ data, index }) : (data, _index) => {
-    const pk = data[primaryKeyDescriptor];
-    return pk;
-  };
+  const toPrimaryKey = typeof primaryKeyDescriptor === "function" ? (data) => primaryKeyDescriptor(data) : (data) => data[primaryKeyDescriptor];
   const result = {
     selectionMode,
+    rowSelection: rowSelectionState,
     toPrimaryKey,
-    rowSelection: rowSelectionState != null ? rowSelectionState : null,
     operatorsByFilterType,
     controlledSort,
     controlledFilter,
-    filterMode: ((_c = props.filterMode) != null ? _c : props.filterFunction != null) ? "local" : typeof props.data === "function" ? "remote" : "local",
+    filterMode: ((_b = props.filterMode) != null ? _b : props.filterFunction != null) ? "local" : typeof props.data === "function" ? "remote" : "local",
     multiSort: Array.isArray(controlledSort ? props.sortInfo : props.defaultSortInfo),
     lazyLoadBatchSize: typeof props.lazyLoad === "object" ? props.lazyLoad.batchSize : void 0
   };
@@ -8714,20 +9241,17 @@ function getMappedCallbacks() {
     rowSelection: (rowSelection, state) => {
       if (state.selectionMode === "single-row") {
         return {
-          callbackParam: {
-            selectionMode: "single-row",
-            rowSelection
-          }
+          callbackParams: [
+            rowSelection,
+            "single-row"
+          ]
         };
       }
       return {
-        callbackParam: {
-          selectionMode: "multi-row",
-          get rowSelection() {
-            return rowSelection.getState();
-          },
-          rowSelectionState: rowSelection
-        }
+        callbackParams: [
+          rowSelection.getState(),
+          "multi-row"
+        ]
       };
     }
   };
@@ -9079,16 +9603,16 @@ function filterDataSource(params) {
   return dataArray;
 }
 function concludeReducer(params) {
-  var _a, _b, _c, _d;
+  var _a, _b;
   const { state, previousState } = params;
-  const primaryKeyDescriptor = state.primaryKey;
   const sortInfo = state.sortInfo;
   let shouldSort = !!(sortInfo == null ? void 0 : sortInfo.length) && !state.controlledSort;
   if (state.lazyLoad || state.livePagination) {
     shouldSort = false;
   }
   let originalDataArrayChanged = haveDepsChanged(previousState, state, [
-    "originalDataArray"
+    "originalDataArray",
+    "originalLazyGroupDataChangeDetect"
   ]);
   const dataSourceChange = previousState && state.data !== previousState.data;
   let lazyLoadGroupDataChange = state.lazyLoad && previousState && (previousState.groupBy !== state.groupBy || previousState.sortInfo !== state.sortInfo);
@@ -9099,6 +9623,13 @@ function concludeReducer(params) {
     state.originalLazyGroupData = new DeepMap();
     originalDataArrayChanged = true;
   }
+  const shouldIndex = originalDataArrayChanged;
+  if (shouldIndex) {
+    state.indexer.clear();
+    if (!state.lazyLoad) {
+      state.indexer.indexArray(state.originalDataArray, state.toPrimaryKey);
+    }
+  }
   const { filterFunction, filterValue, filterTypes, operatorsByFilterType } = state;
   const shouldFilter = !!filterFunction || Array.isArray(filterValue) && filterValue.length;
   const shouldFilterClientSide = shouldFilter && state.filterMode === "local";
@@ -9117,7 +9648,8 @@ function concludeReducer(params) {
   const shouldGroup = groupBy.length > 0 || !!pivotBy;
   const selectionDepsChanged = haveDepsChanged(previousState, state, [
     "rowSelection",
-    "isRowSelected"
+    "isRowSelected",
+    "originalLazyGroupDataChangeDetect"
   ]);
   const groupsDepsChanged = originalDataArrayChanged || sortDepsChanged || haveDepsChanged(previousState, state, [
     "generateGroupRows",
@@ -9131,13 +9663,10 @@ function concludeReducer(params) {
     "pivotGrandTotalColumnPosition",
     "showSeparatePivotColumnForSingleAggregation"
   ]);
-  const shouldGroupAgain = shouldGroup && (groupsDepsChanged || !state.lastGroupDataArray) || selectionDepsChanged && state.selectionMode === "multi-row";
+  const shouldGroupAgain = shouldGroup && (groupsDepsChanged || !state.lastGroupDataArray) || selectionDepsChanged;
   const now = Date.now();
   let dataArray = state.originalDataArray;
-  const toPrimaryKey = typeof primaryKeyDescriptor === "function" ? (data, index) => primaryKeyDescriptor({ data, index }) : (data, _index) => {
-    const pk = data[primaryKeyDescriptor];
-    return pk;
-  };
+  const toPrimaryKey = state.toPrimaryKey;
   if (!shouldFilter) {
     state.unfilteredCount = dataArray.length;
   }
@@ -9167,60 +9696,47 @@ function concludeReducer(params) {
   }
   state.postSortDataArray = dataArray;
   let rowInfoDataArray = state.dataArray;
+  const rowSelectionState = state.rowSelection instanceof RowSelectionState ? state.rowSelection : void 0;
+  rowSelectionState == null ? void 0 : rowSelectionState.xcache();
   let isRowSelected = state.selectionMode === "single-row" ? (rowInfo) => {
     return rowInfo.id === state.rowSelection;
   } : state.selectionMode === "multi-row" ? (rowInfo) => {
-    return state.rowSelection.isRowSelected(rowInfo.id);
+    const rowSelection = rowSelectionState;
+    return rowInfo.isGroupRow ? rowSelection.getGroupRowSelectionState(rowInfo.groupKeys) : rowSelection.isRowSelected(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
   } : void 0;
-  if (state.isRowSelected) {
-    isRowSelected = (rowInfo) => state.isRowSelected(rowInfo, state.rowSelection, state.selectionMode) || false;
+  if (state.isRowSelected && state.selectionMode === "multi-row") {
+    isRowSelected = (rowInfo) => state.isRowSelected(rowInfo, rowSelectionState, state.selectionMode);
   }
   if (shouldGroup) {
     if (shouldGroupAgain) {
       let aggregationReducers = state.aggregationReducers;
-      if (state.selectionMode === "multi-row") {
-        const groupSelectedReducer = {
-          initialValue: true,
-          reducer: (groupSelected, _value, data, index) => {
-            const rowId = toPrimaryKey(data, index);
-            return groupSelected && state.rowSelection.isRowSelected(rowId);
-          }
-        };
-        const groupChildrenSelectedCountReducer = {
-          initialValue: 0,
-          reducer: (selectedCount, _value, data, index) => {
-            const rowId = toPrimaryKey(data, index);
-            return selectedCount + state.rowSelection.isRowSelected(rowId);
-          }
-        };
-        aggregationReducers = __spreadProps(__spreadValues({}, aggregationReducers), {
-          [GROUP_SELECTED_REDUCER_KEY]: groupSelectedReducer,
-          [GROUP_CHILDREN_SELECTED_COUNT_KEY]: groupChildrenSelectedCountReducer
-        });
-      }
       const groupResult = state.lazyLoad ? lazyGroup({
         groupBy,
         pivot: pivotBy,
         mappings: state.pivotMappings,
-        reducers: aggregationReducers
+        reducers: aggregationReducers,
+        indexer: state.indexer,
+        toPrimaryKey
       }, state.originalLazyGroupData) : group({
         groupBy,
         pivot: pivotBy,
         reducers: aggregationReducers
       }, dataArray);
-      state.indexer.clear();
+      state.groupDeepMap = groupResult.deepMap;
+      if (rowSelectionState) {
+        rowSelectionState.getConfig = rowSelectionStateConfigGetter(state);
+      }
       const flattenResult = enhancedFlatten({
         groupResult,
         lazyLoad: !!state.lazyLoad,
         reducers: aggregationReducers,
         toPrimaryKey,
         isRowSelected,
-        indexer: state.indexer,
+        rowSelectionState,
         groupRowsState: state.groupRowsState,
         generateGroupRows: state.generateGroupRows
       });
       rowInfoDataArray = flattenResult.data;
-      state.groupDeepMap = groupResult.deepMap;
       state.reducerResults = groupResult.reducerResults;
       const pivotGroupsAndCols = pivotBy ? getPivotColumnsAndColumnGroups({
         deepMap: groupResult.topLevelPivotColumns,
@@ -9242,10 +9758,8 @@ function concludeReducer(params) {
     state.pivotColumns = void 0;
     const arrayDifferentAfterSortStep = previousState.postSortDataArray != state.postSortDataArray;
     if (arrayDifferentAfterSortStep || groupsDepsChanged || selectionDepsChanged) {
-      state.indexer.clear();
       rowInfoDataArray = dataArray.map((data, index) => {
-        const rowInfo = toRowInfo(data, data ? toPrimaryKey(data, index) : index, index, isRowSelected);
-        state.indexer.add(index, rowInfo.id);
+        const rowInfo = toRowInfo(data, data ? toPrimaryKey(data) : index, index, isRowSelected);
         return rowInfo;
       });
     }
@@ -9257,13 +9771,27 @@ function concludeReducer(params) {
   state.dataArray = rowInfoDataArray;
   state.reducedAt = now;
   if (state.selectionMode === "multi-row") {
-    if (shouldGroup) {
-      state.allRowsSelected = ((_c = state.reducerResults) == null ? void 0 : _c[GROUP_SELECTED_REDUCER_KEY]) || false;
-      state.selectedRowCount = ((_d = state.reducerResults) == null ? void 0 : _d[GROUP_CHILDREN_SELECTED_COUNT_KEY]) || 0;
+    if (shouldGroup && state.lazyLoad) {
+      let allRowsSelected = true;
+      let someRowsSelected = false;
+      state.dataArray.forEach((rowInfo) => {
+        if (rowInfo.isGroupRow && rowInfo.groupKeys.length === 1) {
+          const { rowSelected } = rowInfo;
+          if (rowSelected !== true) {
+            allRowsSelected = false;
+          }
+          if (rowSelected === true || rowSelected === null) {
+            someRowsSelected = true;
+          }
+        }
+      });
+      state.allRowsSelected = allRowsSelected;
+      state.someRowsSelected = someRowsSelected;
     } else {
-      const dataArrayCount = state.dataArray.length;
-      state.selectedRowCount = state.rowSelection.getSelectedCount(dataArrayCount);
-      state.allRowsSelected = dataArrayCount === state.selectedRowCount;
+      const dataArrayCount = state.filteredCount;
+      const selectedRowCount = state.rowSelection.getSelectedCount();
+      state.allRowsSelected = dataArrayCount === selectedRowCount;
+      state.someRowsSelected = selectedRowCount > 0;
     }
   }
   if (false) {
@@ -9307,6 +9835,7 @@ function DataSourceCmp({ children }) {
   };
   if (false) {
     globalThis.getDataSourceState = getState;
+    globalThis.dataSourceActions = componentActions;
   }
   useLoadData();
   return /* @__PURE__ */ createElement30(DataSourceContext.Provider, {
@@ -9321,128 +9850,42 @@ function DataSource(props) {
   }));
 }
 
-// src/components/InfiniteTable/getImperativeApi.ts
-function getImperativeApi(getComputed, getState, getDataSourceState, componentActions, dataSourceActions) {
-  function setGroupRowSelection(groupKeys, selected) {
-    const {
-      selectionMode,
-      rowSelection: currentRowSelection,
-      groupDeepMap,
-      toPrimaryKey
-    } = getDataSourceState();
-    if (selectionMode === "multi-row" && groupDeepMap) {
-      const rowSelectionState = new RowSelectionState(currentRowSelection);
-      const groupResult = groupDeepMap.get(groupKeys);
-      if (groupResult == null ? void 0 : groupResult.items) {
-        groupResult.items.forEach((data) => {
-          const id = toPrimaryKey(data);
-          if (selected) {
-            rowSelectionState.selectRow(id);
-          } else {
-            rowSelectionState.deselectRow(id);
-          }
-        });
-      }
-      const primaryKey = `${groupKeys}`;
-      const index = getDataSourceState().indexer.getIndexOf(primaryKey);
-      if (index != null) {
-        const rowInfo = getDataSourceState().dataArray[index];
-        rowInfo.deepRowInfoArray.forEach((rowInfo2) => {
-          if (!rowInfo2.isGroupRow) {
-            if (selected) {
-              rowSelectionState.selectRow(rowInfo2.id);
-            } else {
-              rowSelectionState.deselectRow(rowInfo2.id);
-            }
-          }
-        });
-        dataSourceActions.rowSelection = rowSelectionState;
-        return true;
-      }
-    }
-    return false;
-  }
+// src/components/InfiniteTable/api/getImperativeApi.ts
+function getImperativeApi(param) {
+  const {
+    getComputed,
+    getState,
+    getDataSourceState,
+    componentActions,
+    dataSourceActions
+  } = param;
+  const selectionApi = getSelectionApi({
+    dataSourceActions,
+    getDataSourceState
+  });
   const imperativeApi = {
-    get allRowsSelected() {
-      return getDataSourceState().allRowsSelected;
-    },
-    getSelectedRowCount() {
-      const { selectionMode, selectedRowCount } = getDataSourceState();
-      if (selectionMode != "multi-row") {
-        throw `Cannot get the selected row count unless "selectionMode" is "multi-row"!`;
-      }
-      return selectedRowCount;
-    },
-    getSelectedRows() {
-      const { rowSelection, indexer, dataArray } = getDataSourceState();
-      if (!rowSelection || !(rowSelection instanceof RowSelectionState)) {
-        return [];
-      }
-      if (rowSelection.isRowDefaultDeselected()) {
-        const { selectedRows } = rowSelection.getState();
-        return Object.keys(selectedRows).reduce((res, id) => {
-          const index = indexer.getIndexOf(id);
-          if (index == null) {
-            return res;
-          }
-          const rowInfo = dataArray[index];
-          if (!rowInfo || !rowInfo.data) {
-            return res;
-          }
-          res.push(rowInfo.data);
-          return res;
-        }, []);
-      } else {
-        return dataArray.filter((rowInfo) => {
-          return !rowInfo.isGroupRow && rowSelection.isRowSelected(rowInfo.id);
-        }).map((rowInfo) => rowInfo.data);
-      }
-      return [];
+    get selectionApi() {
+      return selectionApi;
     },
     setColumnOrder: (columnOrder) => {
       componentActions.columnOrder = columnOrder;
     },
-    selectRow: (pk) => {
-      const { selectionMode, rowSelection: currentRowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const rowSelectionState = new RowSelectionState(currentRowSelection);
-        rowSelectionState.selectRow(pk);
-        dataSourceActions.rowSelection = rowSelectionState;
+    collapseGroupRow(groupKeys) {
+      const state = getDataSourceState();
+      if (state.groupRowsState.isGroupRowExpanded(groupKeys)) {
+        this.toggleGroupRow(groupKeys);
         return true;
-      } else if (selectionMode === "single-row") {
-        dataSourceActions.rowSelection = pk;
-        return false;
       }
       return false;
     },
-    deselectRow: (pk) => {
-      const { selectionMode, rowSelection: currentRowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const rowSelectionState = new RowSelectionState(currentRowSelection);
-        rowSelectionState.deselectRow(pk);
-        dataSourceActions.rowSelection = rowSelectionState;
-        return true;
-      } else if (selectionMode === "single-row") {
-        dataSourceActions.rowSelection = null;
+    expandGroupRow(groupKeys) {
+      const state = getDataSourceState();
+      if (state.groupRowsState.isGroupRowCollapsed(groupKeys)) {
+        this.toggleGroupRow(groupKeys);
         return true;
       }
       return false;
     },
-    isRowSelected: (pk) => {
-      const { selectionMode, rowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        return rowSelection.isRowSelected(pk);
-      } else if (selectionMode === "single-row") {
-        return rowSelection === pk;
-      }
-      return false;
-    },
-    selectGroupRow: (groupKeys) => {
-      return setGroupRowSelection(groupKeys, true);
-    },
-    deselectGroupRow: (groupKeys) => {
-      return setGroupRowSelection(groupKeys, false);
-    },
     toggleGroupRow(groupKeys) {
       const state = getDataSourceState();
       const newState = new GroupRowsState(state.groupRowsState);
@@ -9470,64 +9913,6 @@ function getImperativeApi(getComputed, getState, getDataSourceState, componentAc
         }
       }
     },
-    isGroupRowSelected: (groupKeys) => {
-      const { selectionMode } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const primaryKey = `${groupKeys}`;
-        const index = getDataSourceState().indexer.getIndexOf(primaryKey);
-        if (index != null) {
-          const rowInfo = getDataSourceState().dataArray[index];
-          return rowInfo.rowSelected;
-        }
-      }
-      return false;
-    },
-    toggleGroupRowSelection(groupKeys) {
-      const { selectionMode } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        if (this.isGroupRowSelected(groupKeys)) {
-          this.deselectGroupRow(groupKeys);
-        } else {
-          this.selectGroupRow(groupKeys);
-        }
-        return true;
-      }
-      return false;
-    },
-    toggleRowSelection: (pk) => {
-      const { selectionMode, rowSelection: currentRowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const rowSelectionState = new RowSelectionState(currentRowSelection);
-        rowSelectionState.toggleRowSelection(pk);
-        dataSourceActions.rowSelection = rowSelectionState;
-        return true;
-      } else if (selectionMode === "single-row") {
-        const rowSelection = currentRowSelection === pk ? null : pk;
-        dataSourceActions.rowSelection = rowSelection;
-        return true;
-      }
-      return false;
-    },
-    selectAllRows: () => {
-      const { selectionMode, rowSelection: currentRowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const rowSelectionState = new RowSelectionState(currentRowSelection);
-        rowSelectionState.selectAll();
-        dataSourceActions.rowSelection = rowSelectionState;
-        return true;
-      }
-      return false;
-    },
-    deselectAllRows: () => {
-      const { selectionMode, rowSelection: currentRowSelection } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        const rowSelectionState = new RowSelectionState(currentRowSelection);
-        rowSelectionState.deselectAll();
-        dataSourceActions.rowSelection = rowSelectionState;
-        return true;
-      }
-      return false;
-    },
     setColumnVisibility: (columnVisibility) => {
       componentActions.columnVisibility = columnVisibility;
     },
@@ -9802,6 +10187,7 @@ function useCellRendering(param) {
     computedPinnedStartColumns,
     computedPinnedEndColumns,
     computedVisibleColumns,
+    computedVisibleColumnsMap,
     rowspan,
     toggleGroupRow,
     columnSize
@@ -9905,6 +10291,7 @@ function useCellRendering(param) {
       domRef,
       width,
       column,
+      columnsMap: computedVisibleColumnsMap,
       rowStyle,
       rowClassName
     };
@@ -9913,6 +10300,7 @@ function useCellRendering(param) {
     rowHeight,
     getData,
     computedVisibleColumns,
+    computedVisibleColumnsMap,
     groupRenderStrategy,
     toggleGroupRow,
     showZebraRows,
@@ -9928,42 +10316,112 @@ function useCellRendering(param) {
 // src/components/InfiniteTable/hooks/useComputed.ts
 import { useCallback as useCallback17, useEffect as useEffect26, useState as useState14 } from "react";
 
-// src/components/InfiniteTable/hooks/useColumnGroups.ts
-import { useEffect as useEffect20 } from "react";
-
-// src/components/hooks/useInterceptedMap.ts
-import { useEffect as useEffect19 } from "react";
-function interceptMap(map2, fns) {
-  const { set, delete: deleteKey, clear } = map2;
-  if (fns.set) {
-    map2.set = (key, value) => {
-      set.call(map2, key, value);
-      fns.set(key, value);
-      return map2;
-    };
+// src/components/InfiniteTable/utils/MultiRowSelector.ts
+function ensureMinMax(start, end) {
+  return start < end ? [start, end] : [end, start];
+}
+var MultiRowSelector = class {
+  constructor(options) {
+    this.multiSelectStartIndex = 0;
+    this.getIdForIndex = options.getIdForIndex;
   }
-  if (fns.delete) {
-    map2.delete = (key) => {
-      const removed = deleteKey.call(map2, key);
-      fns.delete(key);
-      return removed;
-    };
+  set rowSelectionState(rowSelectionState) {
+    this._rowSelectionState = rowSelectionState;
   }
-  if (fns.clear || fns.beforeClear) {
-    map2.clear = () => {
-      if (fns.beforeClear) {
-        fns.beforeClear(map2);
-      }
-      const result = clear.call(map2);
-      if (fns.clear) {
-        fns.clear();
-      }
-      return result;
-    };
+  get rowSelectionState() {
+    return this._rowSelectionState;
   }
-  return () => {
-    if (set) {
-      map2.set = set;
+  selectRange(startIndex, endIndex) {
+    const [start, end] = ensureMinMax(startIndex, endIndex);
+    const rowSelectionState = this.rowSelectionState;
+    for (let i = start; i <= end; i++) {
+      const id = this.getIdForIndex(i);
+      rowSelectionState.selectRow(id);
+    }
+  }
+  deselectRange(startIndex, endIndex) {
+    const [start, end] = ensureMinMax(startIndex, endIndex);
+    const rowSelectionState = this.rowSelectionState;
+    for (let i = start; i <= end; i++) {
+      const id = this.getIdForIndex(i);
+      rowSelectionState.deselectRow(id);
+    }
+  }
+  resetClick(index) {
+    this.rowSelectionState.deselectAll();
+    const id = this.getIdForIndex(index);
+    this.rowSelectionState.selectRow(id);
+    this.multiSelectStartIndex = index;
+    this.multiSelectEndIndex = void 0;
+  }
+  singleAddClick(index) {
+    const id = this.getIdForIndex(index);
+    if (this.rowSelectionState.isRowSelected(id)) {
+      this.rowSelectionState.deselectRow(id);
+      if (this.rowSelectionState.isRowSelected(this.getIdForIndex(index + 1))) {
+        this.multiSelectStartIndex = index + 1;
+      } else {
+      }
+    } else {
+      this.rowSelectionState.selectRow(id);
+      this.multiSelectStartIndex = index;
+      let multiSelectEndIndex = void 0;
+      for (let i = index - 1; i >= 0; i--) {
+        const id2 = this.getIdForIndex(i);
+        if (this.rowSelectionState.isRowSelected(id2)) {
+          multiSelectEndIndex = i;
+        } else {
+          break;
+        }
+      }
+      this.multiSelectEndIndex = multiSelectEndIndex;
+    }
+  }
+  multiSelectClick(index) {
+    if (this.multiSelectEndIndex != null) {
+      this.deselectRange(this.multiSelectStartIndex, this.multiSelectEndIndex);
+    }
+    this.selectRange(this.multiSelectStartIndex, index);
+    this.multiSelectEndIndex = index;
+  }
+};
+
+// src/components/InfiniteTable/hooks/useColumnGroups.ts
+import { useEffect as useEffect20 } from "react";
+
+// src/components/hooks/useInterceptedMap.ts
+import { useEffect as useEffect19 } from "react";
+function interceptMap(map2, fns) {
+  const { set, delete: deleteKey, clear } = map2;
+  if (fns.set) {
+    map2.set = (key, value) => {
+      set.call(map2, key, value);
+      fns.set(key, value);
+      return map2;
+    };
+  }
+  if (fns.delete) {
+    map2.delete = (key) => {
+      const removed = deleteKey.call(map2, key);
+      fns.delete(key);
+      return removed;
+    };
+  }
+  if (fns.clear || fns.beforeClear) {
+    map2.clear = () => {
+      if (fns.beforeClear) {
+        fns.beforeClear(map2);
+      }
+      const result = clear.call(map2);
+      if (fns.clear) {
+        fns.clear();
+      }
+      return result;
+    };
+  }
+  return () => {
+    if (set) {
+      map2.set = set;
     }
     if (deleteKey) {
       map2.delete = deleteKey;
@@ -10119,13 +10577,13 @@ import { useState as useState12 } from "react";
 
 // src/components/InfiniteTable/components/icons/ExpanderIcon.css.ts
 var import_createRuntimeFn6 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-var ExpanderIconCls = "_16lm1iw6 _16lm1iwh _16lm1iwd";
-var ExpanderIconClsVariants = (0, import_createRuntimeFn6.createRuntimeFn)({ defaultClassName: "", variantClassNames: { expanded: { true: "_16lm1iwc", false: "_198z9782" } }, defaultVariants: {}, compoundVariants: [] });
+var ExpanderIconCls = "_16lm1iw6 _16lm1iwi _16lm1iwe";
+var ExpanderIconClsVariants = (0, import_createRuntimeFn6.createRuntimeFn)({ defaultClassName: "", variantClassNames: { expanded: { true: "_16lm1iwc", false: "_198z9782" }, direction: { end: "_198z9783", start: "_198z9784" } }, defaultVariants: {}, compoundVariants: [[{ expanded: false, direction: "end" }, "_16lm1iwd"]] });
 
 // src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
 function ExpanderIcon(props) {
   var _a;
-  const { size = 24 } = props;
+  const { size = 24, direction = "start" } = props;
   const [expanded, setExpanded] = useState12((_a = props.expanded) != null ? _a : props.defaultExpanded);
   const onClick = () => {
     var _a2;
@@ -10148,8 +10606,9 @@ function ExpanderIcon(props) {
     style: props.style,
     onClick,
     className: join(props.className, ExpanderIconCls, ExpanderIconClsVariants({
+      direction: direction || "start",
       expanded
-    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`)
+    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`, `InfiniteIcon-expander--${direction === "end" ? "end" : "start"}`)
   }, /* @__PURE__ */ createElement32("path", {
     d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z"
   }));
@@ -10161,7 +10620,7 @@ import {
 } from "react";
 
 // src/components/InfiniteTable/components/icons/LoadingIcon.css.ts
-var LoadingIconCls = "_16lm1iw8 _16lm1iwh _16lm1iwd";
+var LoadingIconCls = "_16lm1iw8 _16lm1iwi _16lm1iwe";
 
 // src/components/InfiniteTable/components/icons/LoadingIcon.tsx
 var LoadingIcon = (props) => {
@@ -10207,7 +10666,7 @@ function getGroupColumnRender({
   groupRenderStrategy
 }) {
   return (renderOptions) => {
-    const { rowInfo, renderBag } = renderOptions;
+    const { rowInfo, renderBag, column } = renderOptions;
     let { value: valueToRender, groupIcon, selectionCheckBox } = renderBag;
     const groupRowInfo = rowInfo;
     if (groupRenderStrategy === "multi-column") {
@@ -10217,7 +10676,7 @@ function getGroupColumnRender({
     } else if (groupRenderStrategy === "single-column" && !groupRowInfo.isGroupRow) {
     }
     return /* @__PURE__ */ createElement34("div", {
-      className: join(display.flex, alignItems.center, groupRenderStrategy === "single-column" || groupRenderStrategy === "multi-column" && !rowInfo.isGroupRow && selectionCheckBox ? GroupRowExpanderCls : null)
+      className: join(display.flex, column.align === "end" ? flexFlow.rowReverse : flexFlow.row, alignItems.center, groupRenderStrategy === "single-column" || groupRenderStrategy === "multi-column" && !rowInfo.isGroupRow && selectionCheckBox ? GroupRowExpanderCls({ align: column.align || "start" }) : null)
     }, groupIcon, selectionCheckBox, /* @__PURE__ */ createElement34("div", {
       className: cssEllipsisClassName
     }, valueToRender != null ? valueToRender : null));
@@ -10231,7 +10690,7 @@ function getGroupColumnRenderGroupIcon({
 }) {
   return (renderOptions) => {
     var _a, _b, _c;
-    const { rowInfo, value, groupBy, pivotBy } = renderOptions;
+    const { rowInfo, value, groupBy, pivotBy, column } = renderOptions;
     const groupRowInfo = groupRenderStrategy !== "inline" ? rowInfo : rowInfo.isGroupRow && ((_a = rowInfo.parents) == null ? void 0 : _a[groupIndexForColumn]) || rowInfo;
     if (!groupRowInfo) {
       return null;
@@ -10263,6 +10722,7 @@ function getGroupColumnRenderGroupIcon({
     } else if (showExpanderIcon) {
       const defaultIcon = /* @__PURE__ */ createElement34(ExpanderIcon, {
         expanded: !collapsed,
+        direction: column.align === "end" ? "end" : "start",
         onChange: () => {
           toggleGroupRow(groupKeys);
         }
@@ -10280,8 +10740,11 @@ function getGroupColumnRenderGroupIcon({
   };
 }
 function getColumnForGroupBy(options, toggleGroupRow, groupColumnFromProps) {
-  var _a;
   const { groupByForColumn, groupIndexForColumn, groupRenderStrategy } = options;
+  let userDefinedGroupColumn = typeof groupColumnFromProps === "function" ? groupColumnFromProps(options, toggleGroupRow) : __spreadValues({}, groupColumnFromProps);
+  if (groupByForColumn.column) {
+    userDefinedGroupColumn = __spreadValues(__spreadValues({}, userDefinedGroupColumn), groupByForColumn.column);
+  }
   let generatedGroupColumn = __spreadProps(__spreadValues({
     header: `Group by ${groupByForColumn.field}`,
     groupByField: groupByForColumn.field,
@@ -10291,9 +10754,9 @@ function getColumnForGroupBy(options, toggleGroupRow, groupColumnFromProps) {
       groupIndexForColumn,
       groupRenderStrategy
     })
-  }, groupByForColumn.column), {
+  }, userDefinedGroupColumn), {
     renderGroupIcon: getGroupColumnRenderGroupIcon({
-      initialRenderGroupIcon: (_a = groupByForColumn.column) == null ? void 0 : _a.renderGroupIcon,
+      initialRenderGroupIcon: userDefinedGroupColumn == null ? void 0 : userDefinedGroupColumn.renderGroupIcon,
       groupIndexForColumn,
       toggleGroupRow,
       groupRenderStrategy
@@ -10314,7 +10777,7 @@ function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
     header: `Group`,
     groupByField: options.groupBy.map((g) => g.field),
     sortable: false,
-    renderSelectionCheckBox: true,
+    renderSelectionCheckBox: options.selectionMode === "multi-row",
     style: styleForGroupColumn,
     render: getGroupColumnRender({
       groupIndexForColumn: 0,
@@ -10511,7 +10974,7 @@ function useColumnsWhenInlineGroupRenderStrategy(groupByMap) {
 }
 function useColumnsWhenGrouping() {
   const {
-    componentState: { groupBy, pivotBy }
+    componentState: { groupBy, pivotBy, selectionMode }
   } = useDataSourceContextValue();
   const {
     componentActions,
@@ -10538,7 +11001,8 @@ function useColumnsWhenGrouping() {
         groupBy,
         pivotBy,
         pivotColumns,
-        toggleGroupRow
+        toggleGroupRow,
+        selectionMode
       });
       componentActions.columnsWhenGrouping = columnsWhenGrouping;
     };
@@ -10552,6 +11016,7 @@ function useColumnsWhenGrouping() {
     columns,
     groupBy,
     pivotBy,
+    selectionMode,
     groupColumn,
     groupRenderStrategy,
     pivotColumns,
@@ -10695,6 +11160,7 @@ function getColumnsWhenGrouping(params) {
     pivotColumns,
     groupBy,
     pivotBy,
+    selectionMode,
     groupColumn,
     pivotTotalColumnPosition,
     pivotGrandTotalColumnPosition,
@@ -10715,7 +11181,8 @@ function getColumnsWhenGrouping(params) {
         pivotBy,
         groupIndexForColumn,
         groupCount: arr.length,
-        groupRenderStrategy
+        groupRenderStrategy,
+        selectionMode
       }, toggleGroupRow, groupColumn);
       computedColumns.set(generatedGroupColumn.id || `group-by-${groupByForColumn.field}`, generatedGroupColumn);
     });
@@ -10724,7 +11191,8 @@ function getColumnsWhenGrouping(params) {
       groupCount: groupBy.length,
       groupBy,
       pivotBy,
-      groupRenderStrategy
+      groupRenderStrategy,
+      selectionMode
     }, toggleGroupRow, groupColumn);
     computedColumns.set(singleGroupColumn.id || "group-by", singleGroupColumn);
   }
@@ -11134,7 +11602,10 @@ var getComputedVisibleColumns = ({
     computedVisibleColumns,
     computedVisibleColumnsMap,
     computedPinnedEndWidth,
-    computedPinnedStartWidth
+    computedPinnedStartWidth,
+    renderSelectionCheckBox: computedVisibleColumns.reduce((bool, c) => {
+      return bool || !!c.renderSelectionCheckBox;
+    }, false)
   };
   return result;
 };
@@ -11195,7 +11666,8 @@ var useComputedVisibleColumns = ({
     computedUnpinnedOffset,
     computedPinnedEndOffset,
     computedPinnedEndWidth,
-    computedPinnedStartWidth
+    computedPinnedStartWidth,
+    renderSelectionCheckBox
   } = useMemo10(() => {
     return getComputedVisibleColumns({
       columns,
@@ -11246,6 +11718,7 @@ var useComputedVisibleColumns = ({
     columnsRenderId
   ]);
   const result = {
+    renderSelectionCheckBox,
     columns,
     computedPinnedEndWidth,
     computedPinnedStartWidth,
@@ -11353,7 +11826,8 @@ function useComputed() {
     computedPinnedEndOffset,
     computedRemainingSpace,
     computedPinnedStartWidth,
-    computedPinnedEndWidth
+    computedPinnedEndWidth,
+    renderSelectionCheckBox
   } = useComputedVisibleColumns({
     columns,
     columnCssEllipsis: componentState.columnCssEllipsis,
@@ -11384,12 +11858,20 @@ function useComputed() {
   const scrollbars = useScrollbars(brain);
   const computedPinnedStartOverflow = computedPinnedStartWidth ? computedPinnedStartColumnsWidth > computedPinnedStartWidth : false;
   const computedPinnedEndOverflow = computedPinnedEndWidth ? computedPinnedEndColumnsWidth > computedPinnedEndWidth : false;
+  const [multiRowSelector] = useState14(() => {
+    const multiRowSelector2 = new MultiRowSelector({
+      getIdForIndex: (index) => getDataSourceState().dataArray[index].id
+    });
+    return multiRowSelector2;
+  });
   return {
+    multiRowSelector,
     showColumnFilters: !!dataSourceState.filterValue,
     scrollbars,
     columnSize,
     rowspan,
     toggleGroupRow,
+    renderSelectionCheckBox,
     computedPinnedStartOverflow,
     computedPinnedEndOverflow,
     computedPinnedStartWidth,
@@ -11572,7 +12054,7 @@ var useLicense = (licenseKey = "") => {
   const valid = useMemo11(() => {
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "0.4.0"
+      version: "0.4.3"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;
@@ -11582,149 +12064,19 @@ var useLicense = (licenseKey = "") => {
   return valid;
 };
 
-// src/components/InfiniteTable/hooks/useRowSelection.ts
-import { useEffect as useEffect27, useState as useState15 } from "react";
-
-// src/components/InfiniteTable/utils/MultiRowSelector.ts
-function ensureMinMax(start, end) {
-  return start < end ? [start, end] : [end, start];
-}
-var MultiRowSelector = class {
-  constructor(options) {
-    this.multiSelectStartIndex = 0;
-    this.getIdForIndex = options.getIdForIndex;
-  }
-  set rowSelectionState(rowSelectionState) {
-    this._rowSelectionState = rowSelectionState;
-  }
-  get rowSelectionState() {
-    return this._rowSelectionState;
-  }
-  selectRange(startIndex, endIndex) {
-    const [start, end] = ensureMinMax(startIndex, endIndex);
-    const rowSelectionState = this.rowSelectionState;
-    for (let i = start; i <= end; i++) {
-      const id = this.getIdForIndex(i);
-      rowSelectionState.selectRow(id);
-    }
-  }
-  deselectRange(startIndex, endIndex) {
-    const [start, end] = ensureMinMax(startIndex, endIndex);
-    const rowSelectionState = this.rowSelectionState;
-    for (let i = start; i <= end; i++) {
-      const id = this.getIdForIndex(i);
-      rowSelectionState.deselectRow(id);
-    }
-  }
-  resetClick(index) {
-    this.rowSelectionState.deselectAll();
-    const id = this.getIdForIndex(index);
-    this.rowSelectionState.selectRow(id);
-    this.multiSelectStartIndex = index;
-    this.multiSelectEndIndex = void 0;
-  }
-  singleAddClick(index) {
-    const id = this.getIdForIndex(index);
-    if (this.rowSelectionState.isRowSelected(id)) {
-      this.rowSelectionState.deselectRow(id);
-      if (this.rowSelectionState.isRowSelected(this.getIdForIndex(index + 1))) {
-        this.multiSelectStartIndex = index + 1;
-      } else {
-      }
-    } else {
-      this.rowSelectionState.selectRow(id);
-      this.multiSelectStartIndex = index;
-      let multiSelectEndIndex = void 0;
-      for (let i = index - 1; i >= 0; i--) {
-        const id2 = this.getIdForIndex(i);
-        if (this.rowSelectionState.isRowSelected(id2)) {
-          multiSelectEndIndex = i;
-        } else {
-          break;
-        }
-      }
-      this.multiSelectEndIndex = multiSelectEndIndex;
-    }
-  }
-  multiSelectClick(index) {
-    if (this.multiSelectEndIndex != null) {
-      this.deselectRange(this.multiSelectStartIndex, this.multiSelectEndIndex);
-    }
-    this.selectRange(this.multiSelectStartIndex, index);
-    this.multiSelectEndIndex = index;
-  }
-};
-
-// src/components/InfiniteTable/hooks/useRowSelection.ts
-function useRowSelection() {
-  const { getState } = useInfiniteTable();
-  const [multiRowSelector] = useState15(() => {
-    const multiRowSelector2 = new MultiRowSelector({
-      getIdForIndex: (index) => getDataSourceState().dataArray[index].id
-    });
-    return multiRowSelector2;
-  });
-  const { getState: getDataSourceState, componentActions } = useDataSourceContextValue();
-  useEffect27(() => {
-    const removeOnClick = getState().cellClick.onChange((args) => {
-      if (args == null) {
-        return;
-      }
-      const { rowIndex, event } = args;
-      let {
-        rowSelection: rowSelectionState,
-        selectionMode,
-        groupBy
-      } = getDataSourceState();
-      if (groupBy.length) {
-        return;
-      }
-      if (selectionMode === "multi-row") {
-        rowSelectionState = new RowSelectionState(rowSelectionState);
-        multiRowSelector.rowSelectionState = rowSelectionState;
-        if (rowSelectionState && typeof rowSelectionState === "object") {
-          if (event.shiftKey) {
-            multiRowSelector.multiSelectClick(rowIndex);
-          } else if (event.metaKey || event.ctrlKey) {
-            multiRowSelector.singleAddClick(rowIndex);
-          } else {
-            multiRowSelector.resetClick(rowIndex);
-          }
-          componentActions.rowSelection = rowSelectionState;
-        }
-      } else if (selectionMode === "single-row") {
-      }
-    });
-    const removeOnKeyDown = getState().keyDown.onChange((event) => {
-      let { rowSelection: rowSelectionState, selectionMode } = getDataSourceState();
-      if (selectionMode === "multi-row") {
-        if ((event == null ? void 0 : event.key) === "a" && (event.ctrlKey || event.metaKey)) {
-          rowSelectionState = new RowSelectionState(rowSelectionState);
-          rowSelectionState.selectAll();
-          componentActions.rowSelection = rowSelectionState;
-        }
-      }
-    });
-    return () => {
-      removeOnClick();
-      removeOnKeyDown();
-    };
-  }, [multiRowSelector]);
-}
-
 // src/components/InfiniteTable/hooks/useScrollToActiveCell.ts
-import { useRef as useRef22, useEffect as useEffect28 } from "react";
+import { useRef as useRef22, useEffect as useEffect27 } from "react";
 var RETRIES = 10;
 function useScrollToActiveCell(activeCellIndex, dataCount, imperativeApi) {
   const didScrollRef = useRef22(false);
   const rafId = useRef22(null);
-  useEffect28(() => {
+  useEffect27(() => {
     if (activeCellIndex != null) {
       didScrollRef.current = false;
       cancelRaf(rafId.current);
     }
   }, [activeCellIndex]);
-  useEffect28(() => {
+  useEffect27(() => {
     if (activeCellIndex != null && !didScrollRef.current) {
       let tryScroll = function(times = 0) {
         times++;
@@ -11747,18 +12099,18 @@ function useScrollToActiveCell(activeCellIndex, dataCount, imperativeApi) {
 }
 
 // src/components/InfiniteTable/hooks/useScrollToActiveRow.ts
-import { useRef as useRef23, useEffect as useEffect29 } from "react";
+import { useRef as useRef23, useEffect as useEffect28 } from "react";
 var RETRIES2 = 10;
 function useScrollToActiveRow(activeRowIndex, dataCount, imperativeApi) {
   const didScrollRef = useRef23(false);
   const rafId = useRef23(null);
-  useEffect29(() => {
+  useEffect28(() => {
     if (activeRowIndex != null) {
       didScrollRef.current = false;
       cancelAnimationFrame(rafId.current);
     }
   }, [activeRowIndex]);
-  useEffect29(() => {
+  useEffect28(() => {
     if (activeRowIndex != null && !didScrollRef.current) {
       let tryScroll = function(times = 0) {
         times++;
@@ -11779,225 +12131,34 @@ function useScrollToActiveRow(activeRowIndex, dataCount, imperativeApi) {
   }, [activeRowIndex, dataCount]);
 }
 
-// src/components/utils/clamp.ts
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
+// src/components/InfiniteTable/state/getInitialState.ts
+import { createRef } from "react";
 
-// src/components/InfiniteTable/keyboardNavigationAndSelection.ts
-function handleRowNavigation(options) {
-  const { key, getState, getDataSourceState, actions } = options;
-  const arrLength = getDataSourceState().dataArray.length;
-  const state = getState();
-  const { brain } = state;
-  let { activeRowIndex } = state;
-  if (activeRowIndex == null) {
-    return false;
-  }
-  const {
-    start: [startRow],
-    end: [endRow]
-  } = brain.getRenderRange();
-  const renderRowCount = endRow - startRow - 1;
-  const min = 0;
-  const max = arrLength - 1;
-  const KeyToFunction = {
-    ArrowDown: () => {
-      activeRowIndex = clamp(activeRowIndex + 1, min, max);
-    },
-    ArrowUp: () => {
-      activeRowIndex = clamp(activeRowIndex - 1, min, max);
-    },
-    PageDown: () => {
-      activeRowIndex = Math.min(activeRowIndex + renderRowCount, arrLength - 1);
-    },
-    PageUp: () => {
-      activeRowIndex = Math.max(activeRowIndex - renderRowCount, min);
-    },
-    End: () => {
-      activeRowIndex = max;
-    },
-    Home: () => {
-      activeRowIndex = min;
-    }
-  };
-  const Fn = KeyToFunction[key];
-  if (!Fn) {
-    return false;
-  }
-  Fn();
-  actions.activeRowIndex = activeRowIndex;
-  return true;
-}
-function handleCellNavigation(options) {
-  const { key, shiftKey, getState, getComputed, getDataSourceState, actions } = options;
-  const state = getState();
-  const { activeCellIndex, brain } = state;
-  if (!activeCellIndex) {
-    return false;
-  }
-  let [rowIndex, colIndex] = activeCellIndex;
-  const {
-    start: [startRow, startCol],
-    end: [endRow, endCol]
-  } = brain.getRenderRange();
-  const renderRowCount = endRow - startRow - 1;
-  const renderColCount = endCol - startCol - 1;
-  const maxRow = getDataSourceState().dataArray.length - 1;
-  const maxCol = getComputed().computedVisibleColumns.length - 1;
-  const minRow = 0;
-  const minCol = 0;
-  rowIndex = clamp(rowIndex, 0, maxRow);
-  colIndex = clamp(colIndex, 0, maxCol);
-  actions.activeCellIndex = [rowIndex, colIndex];
-  const KeyToFunction = {
-    ArrowDown: () => {
-      rowIndex = clamp(rowIndex + 1, minRow, maxRow);
-    },
-    ArrowUp: () => {
-      rowIndex = clamp(rowIndex - 1, minRow, maxRow);
-    },
-    ArrowLeft: () => {
-      colIndex = clamp(colIndex - 1, minCol, maxCol);
-    },
-    ArrowRight: () => {
-      colIndex = clamp(colIndex + 1, minCol, maxCol);
-    },
-    PageDown: () => {
-      if (!shiftKey) {
-        rowIndex = Math.min(rowIndex + renderRowCount, maxRow);
-      } else {
-        colIndex = Math.min(colIndex + renderColCount, maxCol);
-      }
-    },
-    PageUp: () => {
-      if (!shiftKey) {
-        rowIndex = Math.max(rowIndex - renderRowCount, minRow);
-      } else {
-        colIndex = Math.max(colIndex - renderColCount, minCol);
-      }
-    },
-    End: () => {
-      if (!shiftKey) {
-        rowIndex = maxRow;
-      } else {
-        colIndex = maxCol;
-      }
-    },
-    Home: () => {
-      if (!shiftKey) {
-        rowIndex = minRow;
-      } else {
-        colIndex = minCol;
-      }
-    }
-  };
-  const Fn = KeyToFunction[key];
-  if (!Fn) {
-    return false;
-  }
-  Fn();
-  actions.activeCellIndex = [rowIndex, colIndex];
-  return true;
-}
-var validKeys = {
-  ArrowUp: true,
-  ArrowDown: true,
-  ArrowLeft: true,
-  ArrowRight: true,
-  PageUp: true,
-  PageDown: true,
-  Home: true,
-  End: true,
-  Enter: true,
-  " ": true
-};
-function handleKeyboardNavigation(options) {
-  const { getState, getDataSourceState, imperativeApi } = options;
-  const state = getState();
-  const dataSourceState = getDataSourceState();
-  const { activeRowIndex, activeCellIndex, keyboardNavigation } = state;
-  if (!validKeys[options.key]) {
-    return false;
-  }
-  if (options.key === "Enter") {
-    if (keyboardNavigation === "row" && activeRowIndex != null) {
-      const rowInfo = dataSourceState.dataArray[activeRowIndex];
-      if (rowInfo && rowInfo.isGroupRow) {
-        imperativeApi.toggleGroupRow(rowInfo.groupKeys);
-        return true;
-      }
-    }
-    if (keyboardNavigation === "cell" && activeCellIndex != null) {
-      const rowInfo = dataSourceState.dataArray[activeCellIndex[0]];
-      if (rowInfo && rowInfo.isGroupRow) {
-        imperativeApi.toggleGroupRow(rowInfo.groupKeys);
-        return true;
-      }
-    }
-    return false;
-  }
-  if (options.key === " ") {
-    if (keyboardNavigation === "row" && activeRowIndex != null) {
-      const rowInfo = dataSourceState.dataArray[activeRowIndex];
-      if (rowInfo) {
-        if (rowInfo.isGroupRow) {
-          imperativeApi.toggleGroupRowSelection(rowInfo.groupKeys);
-        } else {
-          imperativeApi.toggleRowSelection(rowInfo.id);
-        }
-        return true;
-      }
-    }
-    if (keyboardNavigation === "cell" && activeCellIndex != null) {
-      const rowInfo = dataSourceState.dataArray[activeCellIndex[0]];
-      if (rowInfo) {
-        if (rowInfo.isGroupRow) {
-          imperativeApi.toggleGroupRowSelection(rowInfo.groupKeys);
-        } else {
-          imperativeApi.toggleRowSelection(rowInfo.id);
-        }
-        return true;
-      }
-    }
-  }
-  if (activeRowIndex != null && keyboardNavigation === "row") {
-    return handleRowNavigation(options);
-  }
-  if (activeCellIndex != null && keyboardNavigation === "cell") {
-    return handleCellNavigation(options);
-  }
-  return false;
-}
-
-// src/components/InfiniteTable/state/getInitialState.ts
-import { createRef } from "react";
-
-// src/components/VirtualBrain/ScrollListener.ts
-var initialScrollPosition = {
-  scrollLeft: 0,
-  scrollTop: 0
-};
-var ScrollListener = class {
-  constructor() {
-    this.scrollPosition = initialScrollPosition;
-    this.onScrollFns = [];
-    this.getScrollPosition = () => {
-      return this.scrollPosition;
-    };
-    this.onScroll = (fn) => {
-      this.onScrollFns.push(fn);
-      return () => {
-        this.onScrollFns = this.onScrollFns.filter((f) => f !== fn);
-      };
-    };
-    this.setScrollPosition = (scrollPosition) => {
-      this.scrollPosition = scrollPosition;
-      this.notifyScrollChange();
-    };
-    this.destroy = () => {
-      this.onScrollFns = [];
-    };
+// src/components/VirtualBrain/ScrollListener.ts
+var initialScrollPosition = {
+  scrollLeft: 0,
+  scrollTop: 0
+};
+var ScrollListener = class {
+  constructor() {
+    this.scrollPosition = initialScrollPosition;
+    this.onScrollFns = [];
+    this.getScrollPosition = () => {
+      return this.scrollPosition;
+    };
+    this.onScroll = (fn) => {
+      this.onScrollFns.push(fn);
+      return () => {
+        this.onScrollFns = this.onScrollFns.filter((f) => f !== fn);
+      };
+    };
+    this.setScrollPosition = (scrollPosition) => {
+      this.scrollPosition = scrollPosition;
+      this.notifyScrollChange();
+    };
+    this.destroy = () => {
+      this.onScrollFns = [];
+    };
   }
   notifyScrollChange() {
     const { scrollPosition } = this;
@@ -12141,6 +12302,7 @@ var forwardProps4 = (setupState) => {
     pivotTotalColumnPosition: (pivotTotalColumnPosition) => pivotTotalColumnPosition != null ? pivotTotalColumnPosition : "end",
     pivotGrandTotalColumnPosition: 1,
     licenseKey: (licenseKey) => licenseKey || "",
+    keyboardSelection: (keyboardSelection) => keyboardSelection != null ? keyboardSelection : true,
     activeRowIndex: 1,
     activeCellIndex: 1,
     columnOrder: (columnOrder) => columnOrder != null ? columnOrder : true,
@@ -12215,6 +12377,388 @@ var mapPropsToState2 = (params) => {
 // src/components/InfiniteTable/utils/toCSSVarName.ts
 var toCSSVarName = (value) => `--infinite-${value}`;
 
+// src/components/InfiniteTable/eventHandlers/index.ts
+import { useCallback as useCallback18, useMemo as useMemo12, useEffect as useEffect29 } from "react";
+
+// src/components/InfiniteTable/eventHandlers/onCellClick.ts
+function onCellClick(context, event) {
+  updateRowSelectionOnCellClick(context, event);
+}
+function updateRowSelectionOnCellClick(context, event) {
+  const { rowIndex, getDataSourceState, getComputed, dataSourceActions } = context;
+  const { multiRowSelector, renderSelectionCheckBox } = getComputed();
+  const dataSourceState = getDataSourceState();
+  const { selectionMode, groupBy } = dataSourceState;
+  let { rowSelection: rowSelectionState } = dataSourceState;
+  if (groupBy.length) {
+    return false;
+  }
+  if (selectionMode === "multi-row") {
+    if (renderSelectionCheckBox && !event.key) {
+      return false;
+    }
+    rowSelectionState = new RowSelectionState(rowSelectionState, rowSelectionStateConfigGetter(getDataSourceState));
+    multiRowSelector.rowSelectionState = rowSelectionState;
+    if (rowSelectionState && typeof rowSelectionState === "object") {
+      if (event.shiftKey) {
+        multiRowSelector.multiSelectClick(rowIndex);
+      } else if (event.metaKey || event.ctrlKey) {
+        multiRowSelector.singleAddClick(rowIndex);
+      } else {
+        multiRowSelector.resetClick(rowIndex);
+      }
+      dataSourceActions.rowSelection = rowSelectionState;
+      return true;
+    }
+  } else if (selectionMode === "single-row") {
+  }
+  return false;
+}
+
+// src/components/utils/clamp.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/components/InfiniteTable/eventHandlers/keyboardNavigation.ts
+function handleRowNavigation(options) {
+  const { key, getState, getDataSourceState, actions, api } = options;
+  const dataArray = getDataSourceState().dataArray;
+  const arrLength = dataArray.length;
+  const state = getState();
+  const { brain } = state;
+  let { activeRowIndex } = state;
+  if (activeRowIndex == null) {
+    return false;
+  }
+  const {
+    start: [startRow],
+    end: [endRow]
+  } = brain.getRenderRange();
+  const renderRowCount = endRow - startRow - 1;
+  const min = 0;
+  const max = arrLength - 1;
+  const KeyToFunction = {
+    ArrowDown: () => {
+      activeRowIndex = clamp(activeRowIndex + 1, min, max);
+    },
+    ArrowUp: () => {
+      activeRowIndex = clamp(activeRowIndex - 1, min, max);
+    },
+    ArrowLeft: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.collapseGroupRow(rowInfo.groupKeys);
+      }
+      return false;
+    },
+    ArrowRight: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.expandGroupRow(rowInfo.groupKeys);
+      }
+      return false;
+    },
+    Enter: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.toggleGroupRow(rowInfo.groupKeys);
+      }
+      return false;
+    },
+    PageDown: () => {
+      activeRowIndex = Math.min(activeRowIndex + renderRowCount, arrLength - 1);
+    },
+    PageUp: () => {
+      activeRowIndex = Math.max(activeRowIndex - renderRowCount, min);
+    },
+    End: () => {
+      activeRowIndex = max;
+    },
+    Home: () => {
+      activeRowIndex = min;
+    }
+  };
+  const Fn = KeyToFunction[key];
+  if (!Fn) {
+    return false;
+  }
+  Fn();
+  actions.activeRowIndex = activeRowIndex;
+  return true;
+}
+function handleCellNavigation(options) {
+  const {
+    api,
+    key,
+    shiftKey,
+    getState,
+    getComputed,
+    getDataSourceState,
+    actions
+  } = options;
+  const dataArray = getDataSourceState().dataArray;
+  const state = getState();
+  const { activeCellIndex, brain } = state;
+  if (!activeCellIndex) {
+    return false;
+  }
+  let [rowIndex, colIndex] = activeCellIndex;
+  const {
+    start: [startRow, startCol],
+    end: [endRow, endCol]
+  } = brain.getRenderRange();
+  const renderRowCount = endRow - startRow - 1;
+  const renderColCount = endCol - startCol - 1;
+  const maxRow = getDataSourceState().dataArray.length - 1;
+  const maxCol = getComputed().computedVisibleColumns.length - 1;
+  const minRow = 0;
+  const minCol = 0;
+  rowIndex = clamp(rowIndex, 0, maxRow);
+  colIndex = clamp(colIndex, 0, maxCol);
+  actions.activeCellIndex = [rowIndex, colIndex];
+  const KeyToFunction = {
+    ArrowDown: () => {
+      rowIndex = clamp(rowIndex + 1, minRow, maxRow);
+    },
+    ArrowUp: () => {
+      rowIndex = clamp(rowIndex - 1, minRow, maxRow);
+    },
+    ArrowLeft: () => {
+      colIndex = clamp(colIndex - 1, minCol, maxCol);
+    },
+    ArrowRight: () => {
+      colIndex = clamp(colIndex + 1, minCol, maxCol);
+    },
+    Enter: () => {
+      const rowInfo = dataArray[rowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.toggleGroupRow(rowInfo.groupKeys);
+      }
+      return false;
+    },
+    PageDown: () => {
+      if (!shiftKey) {
+        rowIndex = Math.min(rowIndex + renderRowCount, maxRow);
+      } else {
+        colIndex = Math.min(colIndex + renderColCount, maxCol);
+      }
+    },
+    PageUp: () => {
+      if (!shiftKey) {
+        rowIndex = Math.max(rowIndex - renderRowCount, minRow);
+      } else {
+        colIndex = Math.max(colIndex - renderColCount, minCol);
+      }
+    },
+    End: () => {
+      if (!shiftKey) {
+        rowIndex = maxRow;
+      } else {
+        colIndex = maxCol;
+      }
+    },
+    Home: () => {
+      if (!shiftKey) {
+        rowIndex = minRow;
+      } else {
+        colIndex = minCol;
+      }
+    }
+  };
+  const Fn = KeyToFunction[key];
+  if (!Fn) {
+    return false;
+  }
+  Fn();
+  actions.activeCellIndex = [rowIndex, colIndex];
+  return true;
+}
+var validKeys = {
+  ArrowUp: true,
+  ArrowDown: true,
+  ArrowLeft: true,
+  ArrowRight: true,
+  PageUp: true,
+  PageDown: true,
+  Home: true,
+  End: true,
+  Enter: true,
+  " ": true
+};
+function handleKeyboardNavigation(options) {
+  const { getState } = options;
+  const state = getState();
+  const { activeRowIndex, activeCellIndex, keyboardNavigation } = state;
+  if (!validKeys[options.key]) {
+    return false;
+  }
+  if (activeRowIndex != null && keyboardNavigation === "row") {
+    return handleRowNavigation(options);
+  }
+  if (activeCellIndex != null && keyboardNavigation === "cell") {
+    return handleCellNavigation(options);
+  }
+  return false;
+}
+
+// src/components/InfiniteTable/eventHandlers/keyboardSelection.ts
+var validKeys2 = {
+  Enter: true,
+  " ": true,
+  a: true
+};
+function handleKeyboardSelection(context) {
+  const {
+    getState,
+    getDataSourceState,
+    dataSourceActions,
+    api: imperativeApi,
+    key,
+    ctrlKey,
+    metaKey
+  } = context;
+  if (!validKeys2[key]) {
+    return false;
+  }
+  const state = getState();
+  const dataSourceState = getDataSourceState();
+  const {
+    activeRowIndex,
+    activeCellIndex,
+    keyboardNavigation,
+    keyboardSelection
+  } = state;
+  const { selectionMode, groupBy, rowSelection } = dataSourceState;
+  if (keyboardSelection === false) {
+    return false;
+  }
+  const rowIndex = keyboardNavigation === "row" && activeRowIndex != null ? activeRowIndex : keyboardNavigation === "cell" && activeCellIndex != null ? activeCellIndex[0] : null;
+  const rowInfo = rowIndex != null ? dataSourceState.dataArray[rowIndex] : null;
+  if (!rowInfo || rowIndex == null) {
+    return false;
+  }
+  if (selectionMode === "single-row" && key === " ") {
+    imperativeApi.selectionApi.toggleRowSelection(rowInfo.id);
+    return true;
+  }
+  if (selectionMode !== "multi-row") {
+    return false;
+  }
+  if (key === "a" && (ctrlKey || metaKey)) {
+    const rowSelectionState = new RowSelectionState(rowSelection, rowSelectionStateConfigGetter(getDataSourceState));
+    rowSelectionState.selectAll();
+    dataSourceActions.rowSelection = rowSelectionState;
+    return true;
+  }
+  if (key === " ") {
+    if (groupBy.length) {
+      if (rowInfo.isGroupRow) {
+        imperativeApi.selectionApi.toggleGroupRowSelection(rowInfo.groupKeys);
+      } else {
+        imperativeApi.selectionApi.toggleRowSelection(rowInfo.id);
+      }
+      return true;
+    } else {
+      const event = __spreadValues({}, context);
+      const { renderSelectionCheckBox } = context.getComputed();
+      if (renderSelectionCheckBox) {
+        event.shiftKey = false;
+        event.metaKey = false;
+        event.ctrlKey = true;
+      }
+      return updateRowSelectionOnCellClick(__spreadProps(__spreadValues({}, context), { rowIndex }), event);
+    }
+  }
+  return false;
+}
+
+// src/components/InfiniteTable/eventHandlers/onKeyDown.ts
+function onKeyDown(context, event) {
+  const keyboardHandlerContext = __spreadProps(__spreadValues({}, context), {
+    key: event.key,
+    metaKey: event.metaKey,
+    ctrlKey: event.ctrlKey,
+    shiftKey: event.shiftKey
+  });
+  if (handleKeyboardSelection(keyboardHandlerContext)) {
+    event.preventDefault();
+  }
+  if (handleKeyboardNavigation(keyboardHandlerContext)) {
+    event.preventDefault();
+  }
+}
+
+// src/components/InfiniteTable/eventHandlers/index.ts
+function useEventHandlersContext() {
+  const {
+    getState,
+    componentActions: actions,
+    imperativeApi,
+    getComputed
+  } = useInfiniteTable();
+  const { getState: getDataSourceState, componentActions: dataSourceActions } = useDataSourceContextValue();
+  const context = useMemo12(() => {
+    const context2 = {
+      getComputed,
+      api: imperativeApi,
+      getState,
+      actions,
+      getDataSourceState,
+      dataSourceActions
+    };
+    return context2;
+  }, [getState, actions, getDataSourceState, dataSourceActions]);
+  return context;
+}
+function handleDOMEvents() {
+  const context = useEventHandlersContext();
+  useEffect29(() => {
+    const removeOnKeyDown = context.getState().keyDown.onChange((event) => {
+      onKeyDown(__spreadProps(__spreadValues({}, context), {
+        key: event.key,
+        metaKey: event.metaKey,
+        ctrlKey: event.ctrlKey,
+        shiftKey: event.shiftKey,
+        preventDefault: () => event.preventDefault()
+      }), event);
+    });
+    function cellClickHandler(cellClickParam) {
+      if (!cellClickParam) {
+        return;
+      }
+      const event = cellClickParam.event;
+      const virtualEvent = {
+        metaKey: event.metaKey,
+        ctrlKey: event.ctrlKey,
+        shiftKey: event.shiftKey,
+        key: "",
+        preventDefault: () => event.preventDefault()
+      };
+      onCellClick(__spreadValues(__spreadProps(__spreadValues({}, context), {
+        rowIndex: cellClickParam.rowIndex,
+        colIndex: cellClickParam.colIndex
+      }), virtualEvent), virtualEvent);
+    }
+    const removeOnCellClick = context.getState().cellClick.onChange(cellClickHandler);
+    return () => {
+      removeOnKeyDown();
+      removeOnCellClick();
+    };
+  }, []);
+}
+function subscribeToDOMEvents() {
+  const { getState } = useInfiniteTable();
+  const onKeyDown2 = useCallback18((event) => {
+    getState().keyDown(event);
+  }, []);
+  return { onKeyDown: onKeyDown2 };
+}
+function useDOMEventHandlers() {
+  handleDOMEvents();
+  return subscribeToDOMEvents();
+}
+
 // src/components/InfiniteTable/index.tsx
 var InfiniteTableClassName = internalProps.rootClassName;
 var HOVERED_CLASS_NAMES = [RowHoverCls, "InfiniteColumnCell--hovered"];
@@ -12232,14 +12776,7 @@ var InfiniteTableRoot = getComponentStateRoot({
 });
 var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
   var _a;
-  const {
-    componentState,
-    getComputed,
-    computed,
-    componentActions: actions,
-    getState,
-    imperativeApi
-  } = useInfiniteTable();
+  const { componentState, getComputed, computed, imperativeApi } = useInfiniteTable();
   const {
     componentState: { loading, dataArray },
     getState: getDataSourceState,
@@ -12268,7 +12805,7 @@ var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
   } = componentState;
   useScrollToActiveRow(activeRowIndex, dataArray.length, imperativeApi);
   useScrollToActiveCell(activeCellIndex, dataArray.length, imperativeApi);
-  useRowSelection();
+  const { onKeyDown: onKeyDown2 } = useDOMEventHandlers();
   const { bodySize } = componentState;
   const { scrollbars } = computed;
   const { renderCell } = useCellRendering({
@@ -12296,22 +12833,8 @@ var InfiniteTableComponent = memo13(function InfiniteTableComponent2() {
     dataSourceActions.scrollStopDelayUpdatedByTable = scrollStopDelay;
   }, [scrollStopDelay]);
   useAutoSizeColumns();
-  const onKeyDown = useCallback18((event) => {
-    getState().keyDown(event);
-    if (handleKeyboardNavigation({
-      getState,
-      actions,
-      getDataSourceState,
-      getComputed,
-      imperativeApi,
-      key: event.key,
-      shiftKey: !!event.shiftKey
-    })) {
-      event.preventDefault();
-    }
-  }, []);
   return /* @__PURE__ */ createElement35("div", __spreadValues({
-    onKeyDown,
+    onKeyDown: onKeyDown2,
     ref: domRef
   }, domProps), header ? /* @__PURE__ */ createElement35(TableHeaderWrapper, {
     bodyBrain: brain,
@@ -12358,8 +12881,14 @@ function InfiniteTableContextProvider() {
     globalThis.getComputed = getComputed;
   }
   const { getState: getDataSourceState, componentActions: dataSourceActions } = useDataSourceContextValue();
-  const [imperativeApi] = useState16(() => {
-    return getImperativeApi(getComputed, getState, getDataSourceState, componentActions, dataSourceActions);
+  const [imperativeApi] = useState15(() => {
+    return getImperativeApi({
+      getComputed,
+      getState,
+      getDataSourceState,
+      componentActions,
+      dataSourceActions
+    });
   });
   const contextValue = {
     componentActions,