@infinite-table/infinite-react 0.4.3 → 0.4.6

package/index.js

@@ -4223,8 +4223,8 @@ var InfiniteTableFooter = React15.forwardRef(function InfiniteTableFooter2(props
 });
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderCell.tsx
-var React25 = __toModule(require("react"));
-var import_react23 = __toModule(require("react"));
+var React28 = __toModule(require("react"));
+var import_react24 = __toModule(require("react"));
 var import_react_dom = __toModule(require("react-dom"));
 
 // src/components/DataSource/defaultFilterTypes.ts
@@ -4320,6 +4320,9 @@ function useCellClassName(column, baseClasses, variants, extraFlags) {
   if (column.computedLastInCategory) {
     result.push(...baseClasses.map((c) => `${c}--last-in-category`));
   }
+  if (extraFlags.rowSelected) {
+    result.push(...baseClasses.map((c) => `${c}--row-selected`));
+  }
   if (column.computedPinned) {
     result.push(...baseClasses.map((c) => `${c}--pinned-${column.computedPinned}`));
   } else {
@@ -4912,11 +4915,49 @@ function shallowEqualObjects(objA, objB, ignoreKeys) {
   return true;
 }
 
+// src/components/InfiniteTable/hooks/adjustColumnOrderForAllColumns.ts
+function adjustColumnOrderForAllColumns(options) {
+  const {
+    newColumnOrder,
+    visibleColumnOrder,
+    existingColumnOrder,
+    dragColumnId
+  } = options;
+  if (visibleColumnOrder.length !== newColumnOrder.length) {
+    console.warn("new column order cannot contain less columns than the visible column order");
+    return newColumnOrder;
+  }
+  const dragIndex = visibleColumnOrder.indexOf(dragColumnId);
+  const dropIndex = newColumnOrder.indexOf(dragColumnId);
+  if (dragIndex === dropIndex) {
+    return existingColumnOrder;
+  }
+  if (dropIndex > dragIndex) {
+    const indexInNewOrder = newColumnOrder.indexOf(dragColumnId);
+    const prevColIdInNewOrder = newColumnOrder[indexInNewOrder - 1];
+    const prevColIndexInExiting = existingColumnOrder.indexOf(prevColIdInNewOrder);
+    const indexInExisting = existingColumnOrder.indexOf(dragColumnId);
+    return moveXatY(existingColumnOrder, indexInExisting, prevColIndexInExiting);
+  } else {
+    const indexInNewOrder = newColumnOrder.indexOf(dragColumnId);
+    const nextColIdInNewOrder = newColumnOrder[indexInNewOrder + 1];
+    const nextColIndexInExiting = existingColumnOrder.indexOf(nextColIdInNewOrder);
+    const indexInExisting = existingColumnOrder.indexOf(dragColumnId);
+    return moveXatY(existingColumnOrder, indexInExisting, nextColIndexInExiting);
+  }
+  return newColumnOrder;
+}
+
 // src/components/InfiniteTable/hooks/useColumnPointerEvents.ts
 var columnOffsetAtIndex4 = stripVar(InternalVars.columnOffsetAtIndex);
 var columnWidthAtIndex3 = stripVar(InternalVars.columnWidthAtIndex);
 var baseZIndexForCells2 = stripVar(InternalVars.baseZIndexForCells);
 var equalPinning = (pinning1, pinning2) => {
+  const empty1 = !pinning1 || Object.keys(pinning1).length === 0;
+  const empty2 = !pinning2 || Object.keys(pinning2).length === 0;
+  if (empty1 && empty2) {
+    return true;
+  }
   if (!!pinning1 != !!pinning2) {
     return false;
   }
@@ -4983,14 +5024,19 @@ var useColumnPointerEvents = ({
     function persistColumnOrder(reorderDragResult2) {
       const { columnPinning, columnOrder } = reorderDragResult2;
       if (!equalPinning(getState().columnPinning, columnPinning)) {
-        console.log("update pinning");
         componentActions.columnPinning = columnPinning;
       }
-      if (JSON.stringify(columnOrder, getComputed().computedColumnOrder)) {
+      const currentComputedColumnOrder = getComputed().computedColumnOrder;
+      if (JSON.stringify(columnOrder, currentComputedColumnOrder)) {
         computedVisibleColumns.forEach((col) => {
           setInfiniteColumnOffsetWhileReordering(col.computedVisibleIndex, "", rootRef.current);
         });
-        componentActions.columnOrder = columnOrder;
+        componentActions.columnOrder = adjustColumnOrderForAllColumns({
+          newColumnOrder: columnOrder,
+          visibleColumnOrder: getComputed().computedVisibleColumns.map((c) => c.id),
+          existingColumnOrder: currentComputedColumnOrder,
+          dragColumnId: columnId
+        });
       }
     }
     const onPointerMove = (e2) => {
@@ -5051,11 +5097,255 @@ var useColumnPointerEvents = ({
 };
 
 // src/components/InfiniteTable/utils/RenderHookComponent.tsx
-var React19 = __toModule(require("react"));
+var React22 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableColumnCell.tsx
+var React21 = __toModule(require("react"));
+var import_react19 = __toModule(require("react"));
+
+// src/components/InfiniteTable/utils/getColumnForGroupBy.tsx
 var React18 = __toModule(require("react"));
-var import_react18 = __toModule(require("react"));
+
+// src/components/DataSource/state/rowInfoStatus.ts
+var showLoadingIcon = (rowInfo) => {
+  if (rowInfo.dataSourceHasGrouping) {
+    return rowInfo.isGroupRow ? rowInfo.childrenLoading || !rowInfo.selfLoaded : !rowInfo.selfLoaded;
+  }
+  return !rowInfo.selfLoaded;
+};
+
+// src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
+var React16 = __toModule(require("react"));
+var import_react17 = __toModule(require("react"));
+
+// src/components/InfiniteTable/components/icons/ExpanderIcon.css.ts
+var import_createRuntimeFn2 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var ExpanderIconCls = "_16lm1iw6 _16lm1iwi _16lm1iwe";
+var ExpanderIconClsVariants = (0, import_createRuntimeFn2.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, direction = "start" } = props;
+  const [expanded, setExpanded] = (0, import_react17.useState)((_a = props.expanded) != null ? _a : props.defaultExpanded);
+  const onClick = () => {
+    var _a2;
+    (_a2 = props.onChange) == null ? void 0 : _a2.call(props, !expanded);
+    if (!isControlled("expanded", props)) {
+      setExpanded(!expanded);
+    }
+  };
+  React16.useEffect(() => {
+    if (isControlled("expanded", props)) {
+      setExpanded(props.expanded);
+    }
+  }, [props.expanded]);
+  return /* @__PURE__ */ React16.createElement("svg", {
+    "data-name": "expander-icon",
+    xmlns: "http://www.w3.org/2000/svg",
+    height: `${size}px`,
+    viewBox: "0 0 24 24",
+    width: `${size}px`,
+    style: props.style,
+    onClick,
+    className: join(props.className, ExpanderIconCls, ExpanderIconClsVariants({
+      direction: direction || "start",
+      expanded
+    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`, `InfiniteIcon-expander--${direction === "end" ? "end" : "start"}`)
+  }, /* @__PURE__ */ React16.createElement("path", {
+    d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z"
+  }));
+}
+
+// src/components/InfiniteTable/components/icons/LoadingIcon.tsx
+var React17 = __toModule(require("react"));
+
+// src/components/InfiniteTable/components/icons/LoadingIcon.css.ts
+var LoadingIconCls = "_16lm1iw8 _16lm1iwi _16lm1iwe";
+
+// src/components/InfiniteTable/components/icons/LoadingIcon.tsx
+var LoadingIcon = (props) => {
+  return /* @__PURE__ */ React17.createElement("svg", {
+    xmlns: "http://www.w3.org/2000/svg",
+    style: {
+      margin: "auto",
+      display: "block",
+      shapeRendering: "auto"
+    },
+    width: "24px",
+    height: "24px",
+    viewBox: "0 0 100 100",
+    preserveAspectRatio: "xMidYMid",
+    className: join(props.className, LoadingIconCls, "InfiniteIcon", "InfiniteIcon-loading")
+  }, /* @__PURE__ */ React17.createElement("circle", {
+    cx: "50",
+    cy: "50",
+    fill: "none",
+    strokeWidth: "10",
+    r: "35",
+    strokeDasharray: "164.93361431346415 56.97787143782138"
+  }, /* @__PURE__ */ React17.createElement("animateTransform", {
+    attributeName: "transform",
+    type: "rotate",
+    repeatCount: "indefinite",
+    dur: "1s",
+    values: "0 50 50;360 50 50",
+    keyTimes: "0;1"
+  })));
+};
+
+// src/components/InfiniteTable/components/InfiniteTableRow/row.css.ts
+var import_createRuntimeFn3 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var GroupRowExpanderCls = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "", variantClassNames: { align: { start: "_7pupv0b", center: "_7pupv0c", end: "_7pupv0d" } }, defaultVariants: {}, compoundVariants: [] });
+var RowClsRecipe = (0, import_createRuntimeFn3.createRuntimeFn)({ defaultClassName: "_7pupv00", variantClassNames: { zebra: { false: "_7pupv02", even: "_7pupv03", odd: "_7pupv04" }, groupRow: { true: "_7pupv05", false: "_7pupv06" }, inlineGroupRow: { true: "_7pupv07", false: "_7pupv08" }, showHoverRows: { true: "_7pupv09", false: "_7pupv0a" } }, defaultVariants: {}, compoundVariants: [] });
+var RowHoverCls = "_7pupv01";
+
+// src/components/InfiniteTable/utils/getColumnForGroupBy.tsx
+function styleForGroupColumn({
+  rowInfo
+}) {
+  return {
+    [stripVar(ThemeVars.components.Row.groupNesting)]: rowInfo.dataSourceHasGrouping ? rowInfo.isGroupRow ? rowInfo.groupNesting - 1 : rowInfo.groupNesting : 0
+  };
+}
+function getGroupColumnRender({
+  groupIndexForColumn,
+  groupRenderStrategy
+}) {
+  return (renderOptions) => {
+    const { rowInfo, renderBag, column } = renderOptions;
+    let { value: valueToRender, groupIcon, selectionCheckBox } = renderBag;
+    const groupRowInfo = rowInfo;
+    if (groupRenderStrategy === "multi-column") {
+      if (groupIndexForColumn + 1 !== groupRowInfo.groupNesting && groupRowInfo.isGroupRow) {
+        return null;
+      }
+    } else if (groupRenderStrategy === "single-column" && !groupRowInfo.isGroupRow) {
+    }
+    return /* @__PURE__ */ React18.createElement("div", {
+      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__ */ React18.createElement("div", {
+      className: cssEllipsisClassName
+    }, valueToRender != null ? valueToRender : null));
+  };
+}
+function getGroupColumnRenderGroupIcon({
+  groupIndexForColumn,
+  groupRenderStrategy,
+  toggleGroupRow,
+  initialRenderGroupIcon
+}) {
+  return (renderOptions) => {
+    var _a, _b, _c;
+    const {
+      rowInfo,
+      value,
+      rootGroupBy: groupBy,
+      pivotBy,
+      column
+    } = renderOptions;
+    const groupRowInfo = groupRenderStrategy !== "inline" ? rowInfo : rowInfo.isGroupRow && ((_a = rowInfo.parents) == null ? void 0 : _a[groupIndexForColumn]) || rowInfo;
+    if (!groupRowInfo) {
+      return null;
+    }
+    const collapsed = groupRowInfo.collapsed;
+    if (groupRenderStrategy === "inline") {
+      if (groupRowInfo.groupCount === 1) {
+        return value;
+      }
+      if (groupRowInfo.groupNesting === groupIndexForColumn && collapsed) {
+        return null;
+      }
+    } else {
+      if (!groupRowInfo.isGroupRow) {
+        return null;
+      }
+      if (groupRenderStrategy === "multi-column") {
+        if (groupIndexForColumn + 1 !== groupRowInfo.groupNesting) {
+          return null;
+        }
+      }
+    }
+    const groupKeys = groupRowInfo.groupKeys;
+    let icon = null;
+    const showExpanderIcon = pivotBy ? (((_b = groupRowInfo.groupKeys) == null ? void 0 : _b.length) || 0) < (groupBy == null ? void 0 : groupBy.length) : (((_c = groupRowInfo.groupKeys) == null ? void 0 : _c.length) || 0) <= (groupBy == null ? void 0 : groupBy.length);
+    const isLoading = showLoadingIcon(groupRowInfo);
+    if (isLoading) {
+      icon = /* @__PURE__ */ React18.createElement(LoadingIcon, null);
+    } else if (showExpanderIcon) {
+      const defaultIcon = /* @__PURE__ */ React18.createElement(ExpanderIcon, {
+        expanded: !collapsed,
+        direction: column.align === "end" ? "end" : "start",
+        onChange: () => {
+          toggleGroupRow(groupKeys);
+        }
+      });
+      icon = defaultIcon;
+    }
+    if (initialRenderGroupIcon) {
+      renderOptions.renderBag.groupIcon = icon;
+      icon = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
+        render: initialRenderGroupIcon,
+        renderParam: renderOptions
+      });
+    }
+    return icon;
+  };
+}
+function getColumnForGroupBy(options, toggleGroupRow, groupColumnFromProps) {
+  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,
+    render: getGroupColumnRender({
+      groupIndexForColumn,
+      groupRenderStrategy
+    })
+  }, userDefinedGroupColumn), {
+    renderGroupIcon: getGroupColumnRenderGroupIcon({
+      initialRenderGroupIcon: userDefinedGroupColumn == null ? void 0 : userDefinedGroupColumn.renderGroupIcon,
+      groupIndexForColumn,
+      toggleGroupRow,
+      groupRenderStrategy
+    })
+  });
+  if (groupColumnFromProps) {
+    if (typeof groupColumnFromProps === "function") {
+      generatedGroupColumn = __spreadValues(__spreadValues({}, generatedGroupColumn), groupColumnFromProps(options, toggleGroupRow));
+    } else {
+      generatedGroupColumn = __spreadValues(__spreadValues({}, generatedGroupColumn), groupColumnFromProps);
+    }
+  }
+  return generatedGroupColumn;
+}
+function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
+  const theGroupColumnFromProps = typeof groupColumnFromProps === "function" ? groupColumnFromProps(options, toggleGroupRow) : groupColumnFromProps;
+  const base = {};
+  if (options.sortable != void 0) {
+    base.sortable = options.sortable;
+  }
+  let generatedGroupColumn = __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, base), {
+    header: `Group`,
+    groupByField: options.groupBy.map((g) => g.field),
+    renderSelectionCheckBox: options.selectionMode === "multi-row",
+    render: getGroupColumnRender({
+      groupIndexForColumn: 0,
+      groupRenderStrategy: "single-column"
+    })
+  }), groupColumnFromProps), {
+    renderGroupIcon: getGroupColumnRenderGroupIcon({
+      initialRenderGroupIcon: theGroupColumnFromProps == null ? void 0 : theGroupColumnFromProps.renderGroupIcon,
+      groupIndexForColumn: 0,
+      toggleGroupRow,
+      groupRenderStrategy: "single-column"
+    })
+  });
+  return generatedGroupColumn;
+}
 
 // src/components/InfiniteTable/utils/objectValuesExcept.ts
 function objectValuesExcept(obj, exceptList) {
@@ -5068,14 +5358,14 @@ function objectValuesExcept(obj, exceptList) {
 }
 
 // src/components/InfiniteTable/components/cell.css.ts
-var import_createRuntimeFn2 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn4 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 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 ColumnCellRecipe = (0, import_createRuntimeFn4.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
-var React16 = __toModule(require("react"));
-var import_react17 = __toModule(require("react"));
+var React19 = __toModule(require("react"));
+var import_react18 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/CheckBox.css.ts
 var CheckBoxCls = "_16lm1iwe";
@@ -5102,11 +5392,11 @@ var InfiniteCheckBoxRoot = getComponentStateRoot({
 function InfiniteCheckBoxComponent() {
   const { componentState, componentActions } = useComponentState();
   const { checked, domProps } = componentState;
-  const inputRef = (0, import_react17.useRef)(null);
-  (0, import_react17.useEffect)(() => {
+  const inputRef = (0, import_react18.useRef)(null);
+  (0, import_react18.useEffect)(() => {
     inputRef.current.indeterminate = checked == null;
   }, [checked]);
-  return /* @__PURE__ */ React16.createElement("input", __spreadProps(__spreadValues({}, domProps), {
+  return /* @__PURE__ */ React19.createElement("input", __spreadProps(__spreadValues({}, domProps), {
     className: join(CheckBoxCls, domProps == null ? void 0 : domProps.className),
     type: "checkbox",
     ref: inputRef,
@@ -5117,19 +5407,162 @@ function InfiniteCheckBoxComponent() {
   }));
 }
 function InfiniteCheckBox(props) {
-  return /* @__PURE__ */ React16.createElement(InfiniteCheckBoxRoot, __spreadValues({}, props), /* @__PURE__ */ React16.createElement(InfiniteCheckBoxComponent, null));
+  return /* @__PURE__ */ React19.createElement(InfiniteCheckBoxRoot, __spreadValues({}, props), /* @__PURE__ */ React19.createElement(InfiniteCheckBoxComponent, null));
 }
 
-// src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
-var React17 = __toModule(require("react"));
-var { rootClassName: rootClassName5 } = internalProps;
-var InfiniteTableCellClassName = `${rootClassName5}Cell`;
-var InfiniteTableCellContentClassName = `${rootClassName5}Cell_content`;
-var columnWidthAtIndex4 = stripVar(InternalVars.columnWidthAtIndex);
-var columnReorderEffectDurationAtIndex2 = stripVar(InternalVars.columnReorderEffectDurationAtIndex);
-function InfiniteTableCellFn(props) {
-  var _b, _c, _d;
-  const _a = props, {
+// src/components/InfiniteTable/components/InfiniteTableRow/columnRendering.tsx
+function isColumnWithField(c) {
+  return typeof c.field === "string";
+}
+function getGroupByColumn(options) {
+  const { column, rowInfo, fieldsToColumn } = options;
+  let groupByColumn = void 0;
+  if (column.groupByField) {
+    if (rowInfo.isGroupRow) {
+      groupByColumn = fieldsToColumn.get(rowInfo.groupBy[rowInfo.groupBy.length - 1]);
+    } else if (column.field) {
+      groupByColumn = fieldsToColumn.get(column.field);
+    }
+  }
+  return groupByColumn;
+}
+function getColumnRenderingParams(options) {
+  const { column } = options;
+  const groupByColumn = getGroupByColumn(options);
+  const formattedResult = getFormattedValueContextForCell(__spreadProps(__spreadValues({}, options), {
+    column: groupByColumn || column
+  }));
+  const { formattedValueContext } = formattedResult;
+  return {
+    stylingParam: __spreadValues({
+      column: options.column
+    }, formattedValueContext),
+    formattedValueContext,
+    renderFunctions: {
+      renderGroupIcon: column.renderGroupIcon || (groupByColumn == null ? void 0 : groupByColumn.renderGroupIcon),
+      renderSelectionCheckBox: column.renderSelectionCheckBox,
+      renderValue: column.renderValue || (groupByColumn == null ? void 0 : groupByColumn.renderValue),
+      renderGroupValue: column.renderGroupValue || (groupByColumn == null ? void 0 : groupByColumn.renderGroupValue),
+      renderLeafValue: column.renderLeafValue || (groupByColumn == null ? void 0 : groupByColumn.renderLeafValue)
+    },
+    renderParams: getColumnRenderParam(__spreadProps(__spreadValues({}, options), {
+      formattedValueContext
+    })),
+    groupByColumn
+  };
+}
+function getColumnRenderParam(options) {
+  const {
+    column,
+    context,
+    rowInfo,
+    columnsMap,
+    fieldsToColumn,
+    formattedValueContext
+  } = options;
+  const { value } = formattedValueContext;
+  const { api: imperativeApi, getDataSourceState } = context;
+  const { indexInAll: rowIndex } = rowInfo;
+  const dataSourceState = getDataSourceState();
+  const { selectionMode } = dataSourceState;
+  const groupByColumn = getGroupByColumn({ rowInfo, column, fieldsToColumn });
+  const toggleGroupRow = imperativeApi.toggleGroupRow;
+  const renderParam = __spreadProps(__spreadValues({
+    column,
+    columnsMap,
+    fieldsToColumn
+  }, formattedValueContext), {
+    groupByColumn,
+    selectionMode,
+    api: imperativeApi,
+    selectRow: imperativeApi.selectionApi.selectRow,
+    deselectRow: imperativeApi.selectionApi.deselectRow,
+    toggleRowSelection: imperativeApi.selectionApi.toggleRowSelection,
+    renderBag: {
+      value,
+      selectionCheckBox: null,
+      groupIcon: null
+    },
+    selectCurrentRow: () => {
+      return imperativeApi.selectionApi.selectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
+    },
+    deselectCurrentRow: () => {
+      return imperativeApi.selectionApi.deselectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
+    },
+    rowIndex,
+    toggleGroupRow,
+    toggleCurrentGroupRow: () => {
+      if (!rowInfo.isGroupRow) {
+        return;
+      }
+      toggleGroupRow(rowInfo.groupKeys);
+    },
+    toggleCurrentGroupRowSelection: () => {
+      if (!rowInfo.isGroupRow) {
+        return;
+      }
+      return imperativeApi.selectionApi.toggleGroupRowSelection(rowInfo.isGroupRow ? rowInfo.groupKeys : []);
+    },
+    rootGroupBy: dataSourceState.groupBy,
+    pivotBy: dataSourceState.pivotBy
+  });
+  return renderParam;
+}
+function getRawValueForCell(column, rowInfo) {
+  const { data, isGroupRow, dataSourceHasGrouping } = rowInfo;
+  const groupBy = dataSourceHasGrouping ? rowInfo.groupBy : void 0;
+  let value = isGroupRow && groupBy && column.groupByField ? rowInfo.value : isColumnWithField(column) ? data == null ? void 0 : data[column.field] : null;
+  if (column.valueGetter) {
+    if (!rowInfo.isGroupRow && rowInfo.data) {
+      value = column.valueGetter({ data: rowInfo.data, field: column.field });
+    }
+  }
+  return value;
+}
+function getFormattedValueParamForCell(rawValue, column, rowInfo, context) {
+  const { rowSelected, indexInAll: rowIndex } = rowInfo;
+  const { activeRowIndex, keyboardNavigation } = context.getState();
+  const rowActive = rowIndex === activeRowIndex && keyboardNavigation === "row";
+  return rowInfo.isGroupRow ? {
+    rowInfo,
+    isGroupRow: rowInfo.isGroupRow,
+    data: rowInfo.data,
+    rowSelected,
+    rowActive,
+    value: rawValue,
+    field: column.field
+  } : {
+    rowInfo,
+    isGroupRow: rowInfo.isGroupRow,
+    data: rowInfo.data,
+    rowSelected,
+    rowActive,
+    value: rawValue,
+    field: column.field
+  };
+}
+function getFormattedValueContextForCell(options) {
+  const { column, rowInfo, context } = options;
+  const rawValue = getRawValueForCell(column, rowInfo);
+  const formattedValueContext = getFormattedValueParamForCell(rawValue, column, rowInfo, context);
+  const formattedValue = column.valueFormatter ? column.valueFormatter(formattedValueContext) : rawValue;
+  formattedValueContext.value = formattedValue;
+  return {
+    formattedValue,
+    formattedValueContext
+  };
+}
+
+// src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableCell.tsx
+var React20 = __toModule(require("react"));
+var { rootClassName: rootClassName5 } = internalProps;
+var InfiniteTableCellClassName = `${rootClassName5}Cell`;
+var InfiniteTableCellContentClassName = `${rootClassName5}Cell_content`;
+var columnWidthAtIndex4 = stripVar(InternalVars.columnWidthAtIndex);
+var columnReorderEffectDurationAtIndex2 = stripVar(InternalVars.columnReorderEffectDurationAtIndex);
+function InfiniteTableCellFn(props) {
+  var _b, _c, _d;
+  const _a = props, {
     cssEllipsis = true,
     virtualized = true,
     skipColumnShifting = false,
@@ -5138,6 +5571,7 @@ function InfiniteTableCellFn(props) {
     domRef,
     width,
     contentClassName,
+    rowId,
     afterChildren,
     beforeChildren,
     cellType,
@@ -5152,6 +5586,7 @@ function InfiniteTableCellFn(props) {
     "domRef",
     "width",
     "contentClassName",
+    "rowId",
     "afterChildren",
     "beforeChildren",
     "cellType",
@@ -5168,25 +5603,28 @@ function InfiniteTableCellFn(props) {
     "data-column-id": column.id,
     "data-z-index": style.zIndex,
     className: join(domProps.className, justifyContent[(_b = column.align) != null ? _b : "start"], InfiniteTableCellClassName, ColumnCellCls),
-    children: /* @__PURE__ */ React17.createElement(React17.Fragment, null, beforeChildren, /* @__PURE__ */ React17.createElement("div", {
+    children: /* @__PURE__ */ React20.createElement(React20.Fragment, null, beforeChildren, /* @__PURE__ */ React20.createElement("div", {
       className: join(InfiniteTableCellContentClassName, cssEllipsis ? cssEllipsisClassName : overflow.hidden, contentClassName),
       style: contentStyle
     }, children), afterChildren)
   });
+  if (rowId != null) {
+    finalDOMProps["data-row-id"] = `${rowId}`;
+  }
   const RenderComponent = cellType === "body" ? (_c = column.components) == null ? void 0 : _c.ColumnCell : (_d = column.components) == null ? void 0 : _d.HeaderCell;
   if (RenderComponent) {
-    return /* @__PURE__ */ React17.createElement(RenderComponent, __spreadValues({}, finalDOMProps));
+    return /* @__PURE__ */ React20.createElement(RenderComponent, __spreadValues({}, finalDOMProps));
   }
-  return /* @__PURE__ */ React17.createElement("div", __spreadProps(__spreadValues({}, finalDOMProps), {
+  return /* @__PURE__ */ React20.createElement("div", __spreadProps(__spreadValues({}, finalDOMProps), {
     ref: domRef
   }));
 }
-var InfiniteTableCell = React17.memo(InfiniteTableCellFn);
+var InfiniteTableCell = React20.memo(InfiniteTableCellFn);
 
 // src/components/InfiniteTable/components/InfiniteTableRow/InfiniteTableColumnCell.tsx
 var { rootClassName: rootClassName6 } = internalProps;
 var columnZIndexAtIndex4 = stripVar(InternalVars.columnZIndexAtIndex);
-var InfiniteTableColumnCellContext = React18.createContext(null);
+var InfiniteTableColumnCellContext = React21.createContext(null);
 var InfiniteTableColumnCellClassName = `${rootClassName6}ColumnCell`;
 var defaultRenderSelectionCheckBox = (params) => {
   const {
@@ -5199,7 +5637,7 @@ var defaultRenderSelectionCheckBox = (params) => {
   if (rowInfo.isGroupRow && !column.groupByField) {
     return null;
   }
-  return /* @__PURE__ */ React18.createElement(InfiniteCheckBox, {
+  return /* @__PURE__ */ React21.createElement(InfiniteCheckBox, {
     domProps: {
       className: SelectionCheckboxCls
     },
@@ -5217,8 +5655,12 @@ var defaultRenderSelectionCheckBox = (params) => {
     checked: rowInfo.rowSelected
   });
 };
-function isColumnWithField(c) {
-  return typeof c.field === "string";
+function applyColumnClassName(columnClassName, param) {
+  const colClassName = columnClassName ? typeof columnClassName === "function" ? columnClassName(param) : columnClassName : void 0;
+  return colClassName;
+}
+function applyColumnStyle(existingStyle, columnStyle, param) {
+  return typeof columnStyle === "function" ? __spreadValues(__spreadValues({}, existingStyle), columnStyle(param)) : __spreadValues(__spreadValues({}, existingStyle), columnStyle);
 }
 function InfiniteTableColumnCellFn(props) {
   var _a;
@@ -5230,55 +5672,59 @@ function InfiniteTableColumnCellFn(props) {
     column,
     onMouseLeave,
     onMouseEnter,
-    toggleGroupRow,
     rowIndex,
     rowHeight,
     columnsMap,
+    fieldsToColumn,
     domRef,
     hidden,
     showZebraRows
   } = props;
   if (!column) {
-    return /* @__PURE__ */ React18.createElement("div", {
+    return /* @__PURE__ */ React21.createElement("div", {
       ref: domRef
     }, "no column");
   }
-  const { data, isGroupRow, dataSourceHasGrouping, rowSelected } = rowInfo;
-  const groupBy = dataSourceHasGrouping ? rowInfo.groupBy : void 0;
-  const groupRowInfo = null;
+  const { rowSelected } = rowInfo;
   const { getState, componentActions, imperativeApi } = useInfiniteTable();
+  const { componentState: dataSourceState, getState: getDataSourceState } = useDataSourceContextValue();
   const { activeRowIndex, keyboardNavigation } = getState();
   const rowActive = rowIndex === activeRowIndex && keyboardNavigation === "row";
-  let value = isGroupRow && groupBy && column.groupByField ? rowInfo.value : isColumnWithField(column) ? data == null ? void 0 : data[column.field] : null;
-  if (column.valueGetter) {
-    if (!rowInfo.isGroupRow && rowInfo.data) {
-      value = column.valueGetter({ data: rowInfo.data, field: column.field });
-    }
-  }
-  if (column.valueFormatter) {
-    value = column.valueFormatter(isGroupRow ? {
-      data: rowInfo.data,
-      isGroupRow,
-      rowInfo,
-      rowActive,
-      field: column.field,
-      value
-    } : {
-      data: rowInfo.data,
-      isGroupRow,
-      rowActive,
-      rowInfo,
-      field: column.field,
-      value
-    });
-  }
-  const onClick = (0, import_react18.useCallback)((event) => {
+  const renderingContext = {
+    getState,
+    getDataSourceState,
+    actions: componentActions,
+    api: imperativeApi
+  };
+  const {
+    stylingParam,
+    renderParams,
+    formattedValueContext,
+    renderFunctions,
+    groupByColumn
+  } = getColumnRenderingParams({
+    column,
+    rowInfo,
+    columnsMap,
+    fieldsToColumn,
+    context: renderingContext
+  });
+  const renderParam = renderParams;
+  const onClick = (0, import_react19.useCallback)((event) => {
     const colIndex = column.computedVisibleIndex;
     getState().cellClick({
       rowIndex,
       colIndex,
       event
     });
+  }, [rowIndex, column.computedVisibleIndex, keyboardNavigation]);
+  const onMouseDown = (0, import_react19.useCallback)((event) => {
+    const colIndex = column.computedVisibleIndex;
+    getState().cellMouseDown({
+      rowIndex,
+      colIndex,
+      event
+    });
     if (keyboardNavigation === "row") {
       componentActions.activeRowIndex = rowIndex;
       return;
@@ -5287,121 +5733,73 @@ function InfiniteTableColumnCellFn(props) {
       componentActions.activeCellIndex = [rowIndex, colIndex];
     }
   }, [rowIndex, column.computedVisibleIndex, keyboardNavigation]);
-  const { componentState: computedDataSource } = useDataSourceContextValue();
-  const { selectionMode } = computedDataSource;
-  const rest = rowInfo.isGroupRow ? {
-    rowInfo,
-    isGroupRow: rowInfo.isGroupRow,
-    data: rowInfo.data,
-    rowActive,
-    value,
-    field: column.field
-  } : {
-    rowInfo,
-    isGroupRow: rowInfo.isGroupRow,
-    data: rowInfo.data,
-    rowActive,
-    value,
-    field: column.field
-  };
-  const stylingRenderParam = __spreadValues({
-    column
-  }, rest);
-  const renderParam = __spreadProps(__spreadValues({
-    column,
-    columnsMap,
-    domRef,
-    groupRowInfo
-  }, rest), {
-    selectionMode,
-    selectRow: imperativeApi.selectionApi.selectRow,
-    deselectRow: imperativeApi.selectionApi.deselectRow,
-    toggleRowSelection: imperativeApi.selectionApi.toggleRowSelection,
-    renderBag: {
-      value,
-      selectionCheckBox: null,
-      groupIcon: null
-    },
-    selectCurrentRow: (0, import_react18.useCallback)(() => {
-      return imperativeApi.selectionApi.selectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
-    }, [rowInfo]),
-    deselectCurrentRow: (0, import_react18.useCallback)(() => {
-      return imperativeApi.selectionApi.deselectRow(rowInfo.id, rowInfo.dataSourceHasGrouping ? rowInfo.groupKeys : void 0);
-    }, [rowInfo]),
-    rowIndex,
-    toggleGroupRow,
-    toggleCurrentGroupRow: (0, import_react18.useCallback)(() => {
-      if (!rowInfo.isGroupRow) {
-        return;
-      }
-      toggleGroupRow(rowInfo.groupKeys);
-    }, [rowInfo]),
-    toggleCurrentGroupRowSelection: (0, import_react18.useCallback)(() => {
-      if (!rowInfo.isGroupRow) {
-        return;
-      }
-      return imperativeApi.selectionApi.toggleGroupRowSelection(rowInfo.isGroupRow ? rowInfo.groupKeys : []);
-    }, [rowInfo]),
-    groupBy: computedDataSource.groupBy,
-    pivotBy: computedDataSource.pivotBy
-  });
-  const renderChildren = (0, import_react18.useCallback)(() => {
+  const { selectionMode } = dataSourceState;
+  renderParam.domRef = domRef;
+  renderParam.selectCurrentRow = (0, import_react19.useCallback)(renderParam.selectCurrentRow, [
+    rowInfo
+  ]);
+  renderParam.deselectCurrentRow = (0, import_react19.useCallback)(renderParam.deselectCurrentRow, [
+    rowInfo
+  ]);
+  renderParam.toggleCurrentGroupRow = (0, import_react19.useCallback)(renderParam.toggleCurrentGroupRow, [rowInfo]);
+  renderParam.toggleCurrentGroupRowSelection = (0, import_react19.useCallback)(renderParam.toggleCurrentGroupRowSelection, [rowInfo]);
+  const renderChildren = (0, import_react19.useCallback)(() => {
     if (hidden) {
       return null;
     }
-    if (column.renderGroupIcon) {
-      renderParam.renderBag.groupIcon = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
-        render: column.renderGroupIcon,
+    if (renderFunctions.renderGroupIcon) {
+      renderParam.renderBag.groupIcon = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
+        render: renderFunctions.renderGroupIcon,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
         })
       });
     }
-    if (column.renderSelectionCheckBox && selectionMode == "multi-row") {
-      renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
+    if (renderFunctions.renderSelectionCheckBox && selectionMode == "multi-row") {
+      renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
         render: defaultRenderSelectionCheckBox,
         renderParam
       });
-      if (column.renderSelectionCheckBox !== true) {
-        renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
-          render: column.renderSelectionCheckBox,
+      if (renderFunctions.renderSelectionCheckBox !== true) {
+        renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
+          render: renderFunctions.renderSelectionCheckBox,
           renderParam: __spreadProps(__spreadValues({}, renderParam), {
             renderBag: __spreadValues({}, renderParam.renderBag)
           })
         });
       }
     }
-    if (column.renderValue) {
-      renderParam.renderBag.value = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
-        render: column.renderValue,
+    if (renderFunctions.renderValue) {
+      renderParam.renderBag.value = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
+        render: renderFunctions.renderValue,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
         })
       });
     }
-    if (rowInfo.isGroupRow && column.renderGroupValue) {
-      renderParam.renderBag.value = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
-        render: column.renderGroupValue,
+    if (rowInfo.isGroupRow && renderFunctions.renderGroupValue) {
+      renderParam.renderBag.value = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
+        render: renderFunctions.renderGroupValue,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
         })
       });
     }
-    if (!rowInfo.isGroupRow && column.renderLeafValue) {
-      renderParam.renderBag.value = /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
-        render: column.renderLeafValue,
+    if (!rowInfo.isGroupRow && renderFunctions.renderLeafValue) {
+      renderParam.renderBag.value = /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
+        render: renderFunctions.renderLeafValue,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
         })
       });
     }
     if (column.render) {
-      return /* @__PURE__ */ React18.createElement(RenderCellHookComponent, {
+      return /* @__PURE__ */ React21.createElement(RenderCellHookComponent, {
         render: column.render,
         renderParam
       });
     }
-    return /* @__PURE__ */ React18.createElement(React18.Fragment, 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);
+    return /* @__PURE__ */ React21.createElement(React21.Fragment, 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,
@@ -5409,19 +5807,34 @@ function InfiniteTableColumnCellFn(props) {
       renderBag: true
     })
   ]);
-  const rowPropsAndStyleArgs = __spreadProps(__spreadValues({}, rest), {
+  const rowPropsAndStyleArgs = __spreadProps(__spreadValues({}, formattedValueContext), {
     rowIndex
   });
   const rowComputedClassName = typeof rowClassName === "function" ? rowClassName(rowPropsAndStyleArgs) : rowClassName;
-  const colClassName = column.className ? typeof column.className === "function" ? column.className(stylingRenderParam) : column.className : void 0;
+  let colClassName = void 0;
+  if (groupByColumn == null ? void 0 : groupByColumn.className) {
+    colClassName = applyColumnClassName(groupByColumn.className, stylingParam);
+  }
+  if (column.className) {
+    colClassName = join(colClassName, applyColumnClassName(column.className, stylingParam));
+  }
   let style;
+  if (rowInfo.dataSourceHasGrouping && column.groupByField) {
+    style = styleForGroupColumn({ rowInfo });
+  }
   if (rowStyle) {
     style = typeof rowStyle === "function" ? __spreadValues(__spreadValues({}, style), rowStyle(rowPropsAndStyleArgs)) : __spreadValues(__spreadValues({}, style), rowStyle);
   }
-  style = column.style ? typeof column.style === "function" ? __spreadValues(__spreadValues({}, style), column.style(stylingRenderParam) || {}) : __spreadValues(__spreadValues({}, style), column.style) : style || {};
+  if (groupByColumn == null ? void 0 : groupByColumn.style) {
+    style = applyColumnStyle(style, groupByColumn.style, stylingParam);
+  }
+  if (column.style) {
+    style = applyColumnStyle(style, column.style, stylingParam);
+  }
+  style = style || {};
   style.height = rowHeight;
   style.zIndex = `var(${columnZIndexAtIndex4}-${column.computedVisibleIndex})`;
-  const memoizedStyle = (0, import_react18.useMemo)(() => style, [!style ? null : JSON.stringify(style)]);
+  const memoizedStyle = (0, import_react19.useMemo)(() => style, [!style ? null : JSON.stringify(style)]);
   const odd = (rowInfo.indexInAll != null ? rowInfo.indexInAll : rowIndex) % 2 === 1;
   const zebra = showZebraRows ? odd ? "odd" : "even" : false;
   const cellProps = {
@@ -5429,19 +5842,21 @@ function InfiniteTableColumnCellFn(props) {
     cellType: "body",
     column,
     width,
+    rowId: rowInfo.id,
     style: memoizedStyle,
     onMouseLeave,
     onMouseEnter,
     onClick,
+    onMouseDown,
     cssEllipsis: (_a = column.cssEllipsis) != null ? _a : true,
     className: join(useCellClassName(column, [InfiniteTableColumnCellClassName, InfiniteTableCellClassName], ColumnCellRecipe, { dragging: false, zebra, rowActive, rowSelected }), colClassName, rowComputedClassName),
     renderChildren
   };
-  return /* @__PURE__ */ React18.createElement(InfiniteTableCell, __spreadValues({}, cellProps));
+  return /* @__PURE__ */ React21.createElement(InfiniteTableCell, __spreadValues({}, cellProps));
 }
-var InfiniteTableColumnCell = React18.memo(InfiniteTableColumnCellFn);
+var InfiniteTableColumnCell = React21.memo(InfiniteTableColumnCellFn);
 function useInfiniteColumnCell() {
-  const result = (0, import_react18.useContext)(InfiniteTableColumnCellContext);
+  const result = (0, import_react19.useContext)(InfiniteTableColumnCellContext);
   return result;
 }
 
@@ -5452,25 +5867,25 @@ function RenderHookComponent(props) {
 }
 function RenderCellHookComponent(props) {
   const ContextProvider = InfiniteTableColumnCellContext.Provider;
-  return /* @__PURE__ */ React19.createElement(ContextProvider, {
+  return /* @__PURE__ */ React22.createElement(ContextProvider, {
     value: props.renderParam
-  }, /* @__PURE__ */ React19.createElement(RenderHookComponent, {
+  }, /* @__PURE__ */ React22.createElement(RenderHookComponent, {
     render: props.render,
     renderParam: props.renderParam
   }));
 }
 function RenderHeaderCellHookComponent(props) {
   const ContextProvider = InfiniteTableHeaderCellContext.Provider;
-  return /* @__PURE__ */ React19.createElement(ContextProvider, {
+  return /* @__PURE__ */ React22.createElement(ContextProvider, {
     value: props.renderParam
-  }, /* @__PURE__ */ React19.createElement(RenderHookComponent, {
+  }, /* @__PURE__ */ React22.createElement(RenderHookComponent, {
     render: props.render,
     renderParam: props.renderParam
   }));
 }
 
 // src/components/InfiniteTable/components/FilterEditors.tsx
-var React20 = __toModule(require("react"));
+var React23 = __toModule(require("react"));
 function getFilterEditors() {
   return {
     string: StringFilterEditor,
@@ -5479,7 +5894,7 @@ function getFilterEditors() {
 }
 var defaultFilterEditors = getFilterEditors();
 function StringFilterEditor(props) {
-  return /* @__PURE__ */ React20.createElement("input", {
+  return /* @__PURE__ */ React23.createElement("input", {
     "aria-label": `Filter for ${props.ariaLabel}`,
     type: "text",
     value: props.filterValue,
@@ -5490,7 +5905,7 @@ function StringFilterEditor(props) {
   });
 }
 function NumberFilterEditor(props) {
-  return /* @__PURE__ */ React20.createElement("input", {
+  return /* @__PURE__ */ React23.createElement("input", {
     "aria-label": `Filter for ${props.ariaLabel}`,
     type: "number",
     value: props.filterValue,
@@ -5506,23 +5921,23 @@ function NumberFilterEditor(props) {
 }
 
 // src/components/InfiniteTable/components/icons/SortIcon.tsx
-var React21 = __toModule(require("react"));
-var import_react19 = __toModule(require("react"));
+var React24 = __toModule(require("react"));
+var import_react20 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/header.css.ts
-var import_createRuntimeFn3 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn5 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 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 HeaderCellContentRecipe = (0, import_createRuntimeFn5.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 HeaderCellRecipe = (0, import_createRuntimeFn5.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_createRuntimeFn5.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 HeaderSortIconRecipe = (0, import_createRuntimeFn5.createRuntimeFn)({ defaultClassName: "", variantClassNames: { align: { start: "_12zfob11", center: "_12zfob12", end: "_12zfob13" } }, defaultVariants: {}, compoundVariants: [] });
 var HeaderWrapperCls = "_12zfob11h _16lm1iw1m _16lm1iw1 _16lm1iwu _16lm1iw1f";
 
 // src/components/InfiniteTable/components/icons/SortIcon.tsx
@@ -5534,8 +5949,8 @@ var defaultLineStyle = {
 var InfiniteTableIconClassName = "InfiniteTableIcon";
 function SortIcon(props) {
   var _a;
-  const [rendered, setRendered] = (0, import_react19.useState)(true);
-  const [opacity, setOpacity] = (0, import_react19.useState)(0);
+  const [rendered, setRendered] = (0, import_react20.useState)(true);
+  const [opacity, setOpacity] = (0, import_react20.useState)(0);
   const { direction, lineWidth = 1, style, className, index } = props;
   const showIndex = index != null && index > 0;
   const size = (_a = props.size) != null ? _a : 16;
@@ -5549,7 +5964,7 @@ function SortIcon(props) {
   }), props.lineStyle), {
     opacity
   });
-  (0, import_react19.useEffect)(() => {
+  (0, import_react20.useEffect)(() => {
     const newOpacity = direction != 0 ? 1 : 0;
     if (!rendered && newOpacity) {
       setRendered(true);
@@ -5579,37 +5994,37 @@ function SortIcon(props) {
   if (direction === -1) {
     indexStyle.top = "100%";
   }
-  return /* @__PURE__ */ React21.createElement("div", {
+  return /* @__PURE__ */ React24.createElement("div", {
     style: __spreadProps(__spreadValues({}, style), { width: size }),
     className: join(className, InfiniteTableIconClassName, `${InfiniteTableIconClassName}-sort`)
-  }, showIndex ? /* @__PURE__ */ React21.createElement("div", {
+  }, showIndex ? /* @__PURE__ */ React24.createElement("div", {
     "data-name": "index",
     style: indexStyle,
     className: HeaderSortIconIndexCls
-  }, index) : null, /* @__PURE__ */ React21.createElement("div", {
+  }, index) : null, /* @__PURE__ */ React24.createElement("div", {
     style: __spreadValues({ width: sizes[0] }, lineStyle),
     onTransitionEnd
-  }), /* @__PURE__ */ React21.createElement("div", {
+  }), /* @__PURE__ */ React24.createElement("div", {
     style: __spreadValues({ width: sizes[1] }, lineStyle)
-  }), /* @__PURE__ */ React21.createElement("div", {
+  }), /* @__PURE__ */ React24.createElement("div", {
     style: __spreadValues({ width: sizes[2] }, lineStyle)
   }));
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableColumnHeaderFilter.tsx
-var React22 = __toModule(require("react"));
-var import_react20 = __toModule(require("react"));
+var React25 = __toModule(require("react"));
+var import_react21 = __toModule(require("react"));
 var { rootClassName: rootClassName7 } = internalProps;
 var InfiniteTableColumnHeaderFilterClassName = `${rootClassName7}HeaderCell__filter`;
 var stopPropagation = (e) => e.stopPropagation();
 function InfiniteTableColumnHeaderFilter(props) {
   var _a, _b, _c, _d;
-  const [theValue, setTheValue] = (0, import_react20.useState)((_b = (_a = props.columnFilterValue) == null ? void 0 : _a.filterValue) != null ? _b : "");
+  const [theValue, setTheValue] = (0, import_react21.useState)((_b = (_a = props.columnFilterValue) == null ? void 0 : _a.filterValue) != null ? _b : "");
   const onInputChange = (filterValue) => {
     setTheValue(filterValue);
     props.onChange(filterValue);
   };
-  (0, import_react20.useEffect)(() => {
+  (0, import_react21.useEffect)(() => {
     var _a2;
     if (props.columnFilterValue) {
       if (theValue !== props.columnFilterValue.filterValue) {
@@ -5636,15 +6051,15 @@ function InfiniteTableColumnHeaderFilter(props) {
     onChange: onInputChange
   };
   const FilterEditor = props.filterEditor;
-  return /* @__PURE__ */ React22.createElement("div", {
+  return /* @__PURE__ */ React25.createElement("div", {
     onPointerUp: stopPropagation,
     onPointerDown: stopPropagation,
     className: `${InfiniteTableColumnHeaderFilterClassName} ${HeaderFilterCls}`,
     style: { height: props.columnHeaderHeight }
-  }, FilterEditor ? /* @__PURE__ */ React22.createElement(FilterEditor, __spreadValues({}, filterEditorProps)) : null);
+  }, FilterEditor ? /* @__PURE__ */ React25.createElement(FilterEditor, __spreadValues({}, filterEditorProps)) : null);
 }
 function InfiniteTableColumnHeaderFilterEmpty() {
-  return /* @__PURE__ */ React22.createElement("div", {
+  return /* @__PURE__ */ React25.createElement("div", {
     onPointerUp: stopPropagation,
     onPointerDown: stopPropagation,
     className: `${InfiniteTableColumnHeaderFilterClassName} ${HeaderFilterCls}`,
@@ -5653,8 +6068,8 @@ function InfiniteTableColumnHeaderFilterEmpty() {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/useColumnResizeHandle.tsx
-var React24 = __toModule(require("react"));
-var import_react22 = __toModule(require("react"));
+var React27 = __toModule(require("react"));
+var import_react23 = __toModule(require("react"));
 
 // src/components/flexbox/index.ts
 var computeFlex = (params) => {
@@ -5993,8 +6408,8 @@ var computeGroupResize = (params) => {
 };
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/index.tsx
-var import_react21 = __toModule(require("react"));
-var React23 = __toModule(require("react"));
+var import_react22 = __toModule(require("react"));
+var React26 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/columnResizer.ts
 function getColumnResizer(colIndex, {
@@ -6085,18 +6500,18 @@ function getColumnGroupResizer(colIndexes, config) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/ResizeHandle.css.ts
-var import_createRuntimeFn4 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
+var import_createRuntimeFn6 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
 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"]] });
+var ResizeHandleDraggerClsRecipe = (0, import_createRuntimeFn6.createRuntimeFn)({ defaultClassName: "zneyzhb _16lm1iw2 _16lm1iw13 _16lm1iw18", variantClassNames: { constrained: { false: "zneyzhc", true: "zneyzhd" } }, defaultVariants: {}, compoundVariants: [] });
+var ResizeHandleRecipeCls = (0, import_createRuntimeFn6.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;
 var InfiniteTableHeaderCellResizeHandleCls = `${rootClassName8}HeaderCell_ResizeHandle`;
 function ResizeHandleFn(props) {
-  const domRef = (0, import_react21.useRef)(null);
-  const [constrained, setConstrained] = (0, import_react21.useState)(false);
-  const constrainedRef = (0, import_react21.useRef)(constrained);
+  const domRef = (0, import_react22.useRef)(null);
+  const [constrained, setConstrained] = (0, import_react22.useState)(false);
+  const constrainedRef = (0, import_react22.useRef)(constrained);
   constrainedRef.current = constrained;
   const col = props.columns[props.columnIndex];
   if (!col) {
@@ -6148,7 +6563,7 @@ function ResizeHandleFn(props) {
   const style = (computedPinned === false || computedPinned === "start") && computedLastInCategory ? {
     right: computedPinned === "start" ? 0 : 0
   } : computedPinned === "end" && computedFirstInCategory ? { right: "none", left: 0 } : void 0;
-  return /* @__PURE__ */ React23.createElement("div", {
+  return /* @__PURE__ */ React26.createElement("div", {
     ref: domRef,
     className: `${InfiniteTableHeaderCellResizeHandleCls} ${ResizeHandleCls} ${ResizeHandleRecipeCls({
       computedPinned,
@@ -6156,14 +6571,14 @@ function ResizeHandleFn(props) {
       computedLastInCategory
     })}`,
     onPointerDown
-  }, /* @__PURE__ */ React23.createElement("div", {
+  }, /* @__PURE__ */ React26.createElement("div", {
     style,
     className: ResizeHandleDraggerClsRecipe({
       constrained
     })
   }));
 }
-var ResizeHandle = React23.memo(ResizeHandleFn);
+var ResizeHandle = React26.memo(ResizeHandleFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/useColumnResizeHandle.tsx
 function useColumnResizeHandle(column) {
@@ -6173,7 +6588,7 @@ function useColumnResizeHandle(column) {
     getComputed,
     componentActions
   } = useInfiniteTable();
-  const computeResizeForDiff = (0, import_react22.useCallback)(({
+  const computeResizeForDiff = (0, import_react23.useCallback)(({
     diff,
     shareSpaceOnResize
   }) => {
@@ -6208,7 +6623,7 @@ function useColumnResizeHandle(column) {
     });
     return result;
   }, [column]);
-  const onColumnResize = (0, import_react22.useCallback)(({
+  const onColumnResize = (0, import_react23.useCallback)(({
     diff,
     shareSpaceOnResize
   }) => {
@@ -6221,7 +6636,7 @@ function useColumnResizeHandle(column) {
     }
     componentActions.columnSizing = columnSizing;
   }, [computeResizeForDiff]);
-  const resizeHandle = column.computedResizable ? /* @__PURE__ */ React24.createElement(ResizeHandle, {
+  const resizeHandle = column.computedResizable ? /* @__PURE__ */ React27.createElement(ResizeHandle, {
     columns: computedVisibleColumns,
     columnIndex: column.computedVisibleIndex,
     computeResize: computeResizeForDiff,
@@ -6234,7 +6649,7 @@ function useColumnResizeHandle(column) {
 var defaultRenderSelectionCheckBox2 = (params) => {
   const { allRowsSelected, someRowsSelected, api } = params;
   const selected = allRowsSelected ? true : someRowsSelected ? null : false;
-  return /* @__PURE__ */ React25.createElement(InfiniteCheckBox, {
+  return /* @__PURE__ */ React28.createElement(InfiniteCheckBox, {
     domProps: {
       className: SelectionCheckboxCls
     },
@@ -6248,7 +6663,7 @@ var defaultRenderSelectionCheckBox2 = (params) => {
     checked: selected
   });
 };
-var InfiniteTableHeaderCellContext = React25.createContext(null);
+var InfiniteTableHeaderCellContext = React28.createContext(null);
 var { rootClassName: rootClassName9 } = internalProps;
 var InfiniteTableHeaderCellClassName = `${rootClassName9}HeaderCell`;
 var columnZIndexAtIndex5 = stripVar(InternalVars.columnZIndexAtIndex);
@@ -6270,13 +6685,13 @@ function InfiniteTableHeaderCell(props) {
   const { onResize, height, width, headerOptions, columnsMap } = props;
   const sortInfo = column.computedSortInfo;
   let header = column.header;
-  const ref = (0, import_react23.useCallback)((node) => {
+  const ref = (0, import_react24.useCallback)((node) => {
     var _a2;
     domRef.current = node;
     (_a2 = props.domRef) == null ? void 0 : _a2.call(props, node);
   }, [props.domRef]);
   const alwaysShow = headerOptions.alwaysReserveSpaceForSortIcon;
-  const sortIcon = column.computedSortable && (column.computedSorted || alwaysShow) ? /* @__PURE__ */ React25.createElement(SortIcon, {
+  const sortIcon = column.computedSortable && (column.computedSorted || alwaysShow) ? /* @__PURE__ */ React28.createElement(SortIcon, {
     index: column.computedMultiSort ? column.computedSortIndex + 1 : void 0,
     className: `${InfiniteTableHeaderCellClassName}__sort-icon ${HeaderSortIconCls} ${HeaderSortIconRecipe({
       align: column.align || "start"
@@ -6303,7 +6718,7 @@ function InfiniteTableHeaderCell(props) {
   const align = column.align || "start";
   const renderChildren = () => {
     if (column.renderSortIcon) {
-      renderParam.renderBag.sortIcon = /* @__PURE__ */ React25.createElement(RenderHeaderCellHookComponent, {
+      renderParam.renderBag.sortIcon = /* @__PURE__ */ React28.createElement(RenderHeaderCellHookComponent, {
         render: column.renderSortIcon,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
@@ -6311,12 +6726,12 @@ function InfiniteTableHeaderCell(props) {
       });
     }
     if (column.renderSelectionCheckBox && selectionMode === "multi-row") {
-      renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React25.createElement(RenderHeaderCellHookComponent, {
+      renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React28.createElement(RenderHeaderCellHookComponent, {
         render: defaultRenderSelectionCheckBox2,
         renderParam
       });
       if (column.renderHeaderSelectionCheckBox && column.renderHeaderSelectionCheckBox !== true) {
-        renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React25.createElement(RenderHeaderCellHookComponent, {
+        renderParam.renderBag.selectionCheckBox = /* @__PURE__ */ React28.createElement(RenderHeaderCellHookComponent, {
           render: column.renderHeaderSelectionCheckBox,
           renderParam: __spreadProps(__spreadValues({}, renderParam), {
             renderBag: __spreadValues({}, renderParam.renderBag)
@@ -6325,7 +6740,7 @@ function InfiniteTableHeaderCell(props) {
       }
     }
     if (header instanceof Function) {
-      renderParam.renderBag.header = /* @__PURE__ */ React25.createElement(RenderHookComponent, {
+      renderParam.renderBag.header = /* @__PURE__ */ React28.createElement(RenderHeaderCellHookComponent, {
         render: header,
         renderParam: __spreadProps(__spreadValues({}, renderParam), {
           renderBag: __spreadValues({}, renderParam.renderBag)
@@ -6333,20 +6748,20 @@ function InfiniteTableHeaderCell(props) {
       });
     }
     if (column.renderHeader) {
-      return /* @__PURE__ */ React25.createElement(RenderHeaderCellHookComponent, {
+      return /* @__PURE__ */ React28.createElement(RenderHeaderCellHookComponent, {
         render: column.renderHeader,
         renderParam
       });
     }
-    return /* @__PURE__ */ React25.createElement(React25.Fragment, 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);
+    return /* @__PURE__ */ React28.createElement(React28.Fragment, 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 = (0, import_react23.useRef)(null);
+  const domRef = (0, import_react24.useRef)(null);
   const {
     componentActions: dataSourceActions,
     getState: getDataSourceState,
     componentState: { filterDelay, filterTypes }
   } = useDataSourceContextValue();
-  (0, import_react23.useEffect)(() => {
+  (0, import_react24.useEffect)(() => {
     let clearOnResize = null;
     const node = domRef.current;
     if (onResize && node) {
@@ -6369,7 +6784,7 @@ function InfiniteTableHeaderCell(props) {
   });
   let draggingProxy = null;
   if (dragging && proxyPosition) {
-    draggingProxy = /* @__PURE__ */ React25.createElement("div", {
+    draggingProxy = /* @__PURE__ */ React28.createElement("div", {
       key: column.id,
       className: `${InfiniteTableHeaderCellClassName}Proxy ${HeaderCellProxy}`,
       style: {
@@ -6387,7 +6802,7 @@ function InfiniteTableHeaderCell(props) {
   const contentRecipeVariants = {
     filtered: column.computedFiltered
   };
-  const setFilterValue = (0, import_react23.useCallback)((filterValue) => {
+  const setFilterValue = (0, import_react24.useCallback)((filterValue) => {
     var _a2;
     const state = getDataSourceState();
     let newFilterValue = (_a2 = state.filterValue) != null ? _a2 : [];
@@ -6411,7 +6826,7 @@ function InfiniteTableHeaderCell(props) {
     });
     dataSourceActions.filterValue = newFilterValue;
   }, [column, filterTypes]);
-  const debouncedOnFilterValueChange = React25.useMemo(() => {
+  const debouncedOnFilterValueChange = React28.useMemo(() => {
     const fn = (filterValue) => {
       let newFilterValueForColumn;
       if (column.computedFilterValue) {
@@ -6451,9 +6866,9 @@ function InfiniteTableHeaderCell(props) {
   const resizeHandle = useColumnResizeHandle(column);
   const zIndex2 = `var(${columnZIndexAtIndex5}-${column.computedVisibleIndex})`;
   style.zIndex = zIndex2;
-  return /* @__PURE__ */ React25.createElement(ContextProvider, {
+  return /* @__PURE__ */ React28.createElement(ContextProvider, {
     value: renderParam
-  }, /* @__PURE__ */ React25.createElement(InfiniteTableCell, {
+  }, /* @__PURE__ */ React28.createElement(InfiniteTableCell, {
     domRef: ref,
     cellType: "header",
     column,
@@ -6472,7 +6887,7 @@ function InfiniteTableHeaderCell(props) {
       rowActive: false
     }), CellCls),
     cssEllipsis: (_e = (_d = column.headerCssEllipsis) != null ? _d : column.cssEllipsis) != null ? _e : true,
-    afterChildren: /* @__PURE__ */ React25.createElement(React25.Fragment, null, showColumnFilters ? column.computedFilterable ? /* @__PURE__ */ React25.createElement(InfiniteTableColumnHeaderFilter, {
+    afterChildren: /* @__PURE__ */ React28.createElement(React28.Fragment, null, showColumnFilters ? column.computedFilterable ? /* @__PURE__ */ React28.createElement(InfiniteTableColumnHeaderFilter, {
       filterEditor: FilterEditor,
       filterTypes,
       onChange: debouncedOnFilterValueChange,
@@ -6480,17 +6895,17 @@ function InfiniteTableHeaderCell(props) {
       columnLabel: column.field || column.name || column.id,
       columnFilterValue: column.computedFilterValue,
       columnHeaderHeight
-    }) : /* @__PURE__ */ React25.createElement(InfiniteTableColumnHeaderFilterEmpty, null) : null, resizeHandle),
+    }) : /* @__PURE__ */ React28.createElement(InfiniteTableColumnHeaderFilterEmpty, null) : null, resizeHandle),
     renderChildren
   }), draggingProxy);
 }
 function useInfiniteHeaderCell() {
-  const result = (0, import_react23.useContext)(InfiniteTableHeaderCellContext);
+  const result = (0, import_react24.useContext)(InfiniteTableHeaderCellContext);
   return result;
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderWrapper.tsx
-var React30 = __toModule(require("react"));
+var React33 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/buildColumnAndGroupTree.ts
 function buildColumnAndGroupTree(columns, columnGroups, columnGroupsDepthsMap, columnGroupsMaxDepth) {
@@ -6593,25 +7008,25 @@ function assignGroupOffsetsAndComputedWidths(items, groupOffset = 0) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeader.tsx
-var React29 = __toModule(require("react"));
-var import_react26 = __toModule(require("react"));
+var React32 = __toModule(require("react"));
+var import_react27 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderGroup.tsx
-var React28 = __toModule(require("react"));
+var React31 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/useColumnGroupResizeHandle.tsx
-var React27 = __toModule(require("react"));
-var import_react25 = __toModule(require("react"));
+var React30 = __toModule(require("react"));
+var import_react26 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/ResizeHandle/GroupResizeHandle.tsx
-var import_react24 = __toModule(require("react"));
-var React26 = __toModule(require("react"));
+var import_react25 = __toModule(require("react"));
+var React29 = __toModule(require("react"));
 var { rootClassName: rootClassName10 } = internalProps;
 var InfiniteTableHeaderCellResizeHandleCls2 = `${rootClassName10}HeaderCell_ResizeHandle`;
 function GroupResizeHandleFn(props) {
-  const domRef = (0, import_react24.useRef)(null);
-  const [constrained, setConstrained] = (0, import_react24.useState)(false);
-  const constrainedRef = (0, import_react24.useRef)(constrained);
+  const domRef = (0, import_react25.useRef)(null);
+  const [constrained, setConstrained] = (0, import_react25.useState)(false);
+  const constrainedRef = (0, import_react25.useRef)(constrained);
   constrainedRef.current = constrained;
   const col = props.groupColumns[0];
   if (!col) {
@@ -6671,7 +7086,7 @@ function GroupResizeHandleFn(props) {
   const style = (computedPinned === false || computedPinned === "start") && computedLastInCategory ? {
     right: computedPinned === "start" ? 0 : ThemeVars.components.HeaderCell.resizeHandleWidth
   } : computedPinned === "end" && computedFirstInCategory ? { right: "none", left: 0 } : void 0;
-  return /* @__PURE__ */ React26.createElement("div", {
+  return /* @__PURE__ */ React29.createElement("div", {
     ref: domRef,
     className: `${InfiniteTableHeaderCellResizeHandleCls2} ${ResizeHandleCls} ${ResizeHandleRecipeCls({
       computedPinned,
@@ -6679,14 +7094,14 @@ function GroupResizeHandleFn(props) {
       computedLastInCategory
     })}`,
     onPointerDown
-  }, /* @__PURE__ */ React26.createElement("div", {
+  }, /* @__PURE__ */ React29.createElement("div", {
     style: __spreadValues(__spreadValues({}, style), props.style),
     className: ResizeHandleDraggerClsRecipe({
       constrained
     })
   }));
 }
-var GroupResizeHandle = React26.memo(GroupResizeHandleFn);
+var GroupResizeHandle = React29.memo(GroupResizeHandleFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/useColumnGroupResizeHandle.tsx
 function useColumnGroupResizeHandle(groupColumns, config) {
@@ -6698,7 +7113,7 @@ function useColumnGroupResizeHandle(groupColumns, config) {
     componentActions
   } = useInfiniteTable();
   const lastColumnInGroup = groupColumns[groupColumns.length - 1];
-  const computeResizeForDiff = (0, import_react25.useCallback)((diff) => {
+  const computeResizeForDiff = (0, import_react26.useCallback)((diff) => {
     const state = getState();
     const { columnSizing, viewportReservedWidth, bodySize } = state;
     const columns = getComputed().computedVisibleColumns;
@@ -6731,13 +7146,13 @@ function useColumnGroupResizeHandle(groupColumns, config) {
     });
     return result;
   }, [lastColumnInGroup]);
-  const onColumnResize = (0, import_react25.useCallback)((diff) => {
+  const onColumnResize = (0, import_react26.useCallback)((diff) => {
     const { columnSizing, reservedWidth } = computeResizeForDiff(diff);
     componentActions.viewportReservedWidth = reservedWidth;
     componentActions.columnSizing = columnSizing;
   }, [computeResizeForDiff]);
   const groupResizable = groupColumns.some((c) => c.computedResizable);
-  const resizeHandle = groupResizable ? /* @__PURE__ */ React27.createElement(GroupResizeHandle, {
+  const resizeHandle = groupResizable ? /* @__PURE__ */ React30.createElement(GroupResizeHandle, {
     brain: bodyBrain,
     style: {
       height: groupHeight * (columnGroupsMaxDepth - columnGroup.depth + 2)
@@ -6771,13 +7186,13 @@ function InfiniteTableHeaderGroup(props) {
   const firstColumn = columns[0];
   const width = columns.length > 1 ? `calc( ` + columns.map((col) => `var(${columnWidthAtIndex5}-${col.computedVisibleIndex})`).join(" + ") + " )" : `var(${columnWidthAtIndex5}-${firstColumn.computedVisibleIndex})`;
   const zIndex2 = `calc(var(${columnZIndexAtIndex6}-${firstColumn.computedVisibleIndex}) + ${columnGroupsMaxDepth - columnGroup.depth})`;
-  return /* @__PURE__ */ React28.createElement("div", {
+  return /* @__PURE__ */ React31.createElement("div", {
     ref: props.domRef,
     "data-group-id": columnGroup.uniqueGroupId,
     className: join(HeaderGroupCls, TableHeaderGroupClassName),
     style: { width, height },
     "data-z-index": zIndex2
-  }, /* @__PURE__ */ React28.createElement("div", {
+  }, /* @__PURE__ */ React31.createElement("div", {
     className: join(`${TableHeaderGroupClassName}__header-content`, cssEllipsisClassName)
   }, header), handle);
 }
@@ -6800,8 +7215,8 @@ function InfiniteTableHeaderFn(props) {
     computed,
     componentState: { headerBrain, headerOptions }
   } = useInfiniteTable();
-  const { computedVisibleColumnsMap, showColumnFilters } = computed;
-  (0, import_react26.useEffect)(() => {
+  const { computedColumnsMap, showColumnFilters } = computed;
+  (0, import_react27.useEffect)(() => {
     const onScroll = (scrollPosition) => {
       if (domRef.current) {
         domRef.current.style.transform = `translate3d(-${scrollPosition.scrollLeft}px, 0px, 0px)`;
@@ -6810,7 +7225,7 @@ function InfiniteTableHeaderFn(props) {
     const removeOnScroll = brain.onScroll(onScroll);
     return removeOnScroll;
   }, [brain]);
-  const domRef = (0, import_react26.useRef)(null);
+  const domRef = (0, import_react27.useRef)(null);
   const headerCls = HeaderClsRecipe({
     overflow: false
   });
@@ -6819,7 +7234,7 @@ function InfiniteTableHeaderFn(props) {
     className: join(TableHeaderClassName, `${TableHeaderClassName}--virtualized`, className, headerCls),
     style: __spreadProps(__spreadValues({}, style), { height: columnHeaderHeight })
   };
-  const renderCell = (0, import_react26.useCallback)((params) => {
+  const renderCell = (0, import_react27.useCallback)((params) => {
     const {
       rowIndex,
       colIndex,
@@ -6844,7 +7259,7 @@ function InfiniteTableHeaderFn(props) {
         computedWidth: colGroupItem.computedWidth,
         groupOffset: colGroupItem.groupOffset
       });
-      return /* @__PURE__ */ React29.createElement(InfiniteTableHeaderGroup, {
+      return /* @__PURE__ */ React32.createElement(InfiniteTableHeaderGroup, {
         bodyBrain,
         columnGroupsMaxDepth,
         domRef: domRef2,
@@ -6854,13 +7269,13 @@ function InfiniteTableHeaderFn(props) {
         columnGroup: computedColumnGroup
       });
     }
-    return /* @__PURE__ */ React29.createElement(InfiniteTableHeaderCell, {
+    return /* @__PURE__ */ React32.createElement(InfiniteTableHeaderCell, {
       domRef: domRef2,
       column,
       headerOptions,
       width: widthWithColspan,
       height: heightWithRowspan,
-      columnsMap: computedVisibleColumnsMap
+      columnsMap: computedColumnsMap
     });
   }, [
     headerOptions,
@@ -6870,14 +7285,14 @@ function InfiniteTableHeaderFn(props) {
     columnGroupsMaxDepth,
     showColumnFilters
   ]);
-  return /* @__PURE__ */ React29.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React29.createElement(RawTable, {
+  return /* @__PURE__ */ React32.createElement("div", __spreadValues({}, domProps), /* @__PURE__ */ React32.createElement(RawTable, {
     name: "header",
     renderCell,
     brain: headerBrain,
     cellHoverClassNames: []
   }));
 }
-var InfiniteTableHeader = React29.memo(InfiniteTableHeaderFn);
+var InfiniteTableHeader = React32.memo(InfiniteTableHeaderFn);
 
 // src/components/InfiniteTable/components/InfiniteTableHeader/InfiniteTableHeaderWrapper.tsx
 function TableHeaderWrapper(props) {
@@ -6900,13 +7315,13 @@ function TableHeaderWrapper(props) {
   } = tableContextValue;
   const rows = !computedColumnGroups || !computedColumnGroups.size ? 1 : columnGroupsMaxDepth + 2;
   const height = rows * columnHeaderHeight + (showColumnFilters ? columnHeaderHeight : 0);
-  const columnAndGroupTreeInfo = React30.useMemo(() => {
+  const columnAndGroupTreeInfo = React33.useMemo(() => {
     if (!computedColumnGroups || !computedColumnGroups.size) {
       return void 0;
     }
     return buildColumnAndGroupTree(computedVisibleColumns, computedColumnGroups, columnGroupsDepthsMap, columnGroupsMaxDepth);
   }, [computedVisibleColumns, computedColumnGroups, columnGroupsDepthsMap]);
-  const cellspan = React30.useCallback(({ rowIndex, colIndex }) => {
+  const cellspan = React33.useCallback(({ rowIndex, colIndex }) => {
     const column = computedVisibleColumns[colIndex];
     const rowspan2 = 1;
     const colspan2 = 1;
@@ -6939,9 +7354,9 @@ function TableHeaderWrapper(props) {
     rows,
     columnGroupsDepthsMap
   ]);
-  const rowspan = React30.useCallback(({ rowIndex, colIndex }) => cellspan({ rowIndex, colIndex }).rowspan, [cellspan]);
-  const colspan = React30.useCallback(({ rowIndex, colIndex }) => cellspan({ rowIndex, colIndex }).colspan, [cellspan]);
-  const rowHeight = React30.useCallback((index) => {
+  const rowspan = React33.useCallback(({ rowIndex, colIndex }) => cellspan({ rowIndex, colIndex }).rowspan, [cellspan]);
+  const colspan = React33.useCallback(({ rowIndex, colIndex }) => cellspan({ rowIndex, colIndex }).colspan, [cellspan]);
+  const rowHeight = React33.useCallback((index) => {
     return showColumnFilters ? index < rows - 1 ? columnHeaderHeight : 2 * columnHeaderHeight : columnHeaderHeight;
   }, [rows, showColumnFilters, columnHeaderHeight]);
   useMatrixBrain(headerBrain, {
@@ -6956,7 +7371,7 @@ function TableHeaderWrapper(props) {
     fixedColsEnd: computedPinnedEndColumns.length,
     fixedColsStart: computedPinnedStartColumns.length
   });
-  const header = /* @__PURE__ */ React30.createElement(InfiniteTableHeader, {
+  const header = /* @__PURE__ */ React33.createElement(InfiniteTableHeader, {
     columns: computedVisibleColumns,
     headerBrain,
     bodyBrain,
@@ -6964,14 +7379,14 @@ function TableHeaderWrapper(props) {
     columnGroupsMaxDepth,
     columnAndGroupTreeInfo
   });
-  const verticalScrollbarPlaceholder = scrollbars.vertical && getScrollbarWidth() ? /* @__PURE__ */ React30.createElement("div", {
+  const verticalScrollbarPlaceholder = scrollbars.vertical && getScrollbarWidth() ? /* @__PURE__ */ React33.createElement("div", {
     className: HeaderScrollbarPlaceholderCls,
     style: {
       zIndex: 1e3,
       width: getScrollbarWidth()
     }
   }) : null;
-  return /* @__PURE__ */ React30.createElement("div", {
+  return /* @__PURE__ */ React33.createElement("div", {
     className: HeaderWrapperCls,
     style: {
       height
@@ -6980,8 +7395,8 @@ function TableHeaderWrapper(props) {
 }
 
 // src/components/InfiniteTable/components/InfiniteTableLicenseFooter/index.tsx
-var React31 = __toModule(require("react"));
-var import_react27 = __toModule(require("react"));
+var React34 = __toModule(require("react"));
+var import_react28 = __toModule(require("react"));
 
 // src/components/utils/decamelize.ts
 function decamelize(str, options) {
@@ -7016,10 +7431,10 @@ var enforceStyle = (node, style) => {
     node.style.setProperty(decamelize(propertyName), propertyValue, "important");
   }
 };
-var InfiniteTableLicenseFooter = React31.forwardRef(function InfiniteTableLicenseFooter2(props, ref) {
+var InfiniteTableLicenseFooter = React34.forwardRef(function InfiniteTableLicenseFooter2(props, ref) {
   const { rootClassName: rootClassName13 } = useInternalProps();
-  const domRef = React31.useRef(null);
-  const domCallback = React31.useCallback((node) => {
+  const domRef = React34.useRef(null);
+  const domCallback = React34.useCallback((node) => {
     domRef.current = node;
     if (!ref) {
       return;
@@ -7030,7 +7445,7 @@ var InfiniteTableLicenseFooter = React31.forwardRef(function InfiniteTableLicens
       ref.current = node;
     }
   }, []);
-  (0, import_react27.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     const forceStyle = () => {
       raf(() => {
         var _a;
@@ -7044,12 +7459,12 @@ var InfiniteTableLicenseFooter = React31.forwardRef(function InfiniteTableLicens
       clearInterval(intervalId);
     };
   }, []);
-  return /* @__PURE__ */ React31.createElement("div", __spreadProps(__spreadValues({
+  return /* @__PURE__ */ React34.createElement("div", __spreadProps(__spreadValues({
     ref: domCallback
   }, props), {
     className: join(`${rootClassName13}-Footer`, FooterCls, props.className),
     style: defaultStyle
-  }), "Powered by", " ", /* @__PURE__ */ React31.createElement("a", {
+  }), "Powered by", " ", /* @__PURE__ */ React34.createElement("a", {
     href: "https://infinite-table.com",
     rel: "noopener noreferrer",
     role: "link",
@@ -7057,14 +7472,8 @@ var InfiniteTableLicenseFooter = React31.forwardRef(function InfiniteTableLicens
   }, "Infinite Table"));
 });
 
-// src/components/InfiniteTable/components/InfiniteTableRow/row.css.ts
-var import_createRuntimeFn5 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-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";
-
 // src/components/InfiniteTable/components/LoadMask.tsx
-var React32 = __toModule(require("react"));
+var React35 = __toModule(require("react"));
 
 // src/components/InfiniteTable/components/LoadMask.css.ts
 var LoadMaskCls = { visible: "qy58ya1 qy58ya0 _16lm1iw2 _16lm1iw13 _16lm1iw15 _16lm1iw1a _16lm1iw18", hidden: "qy58ya2 qy58ya0 _16lm1iw2 _16lm1iw13 _16lm1iw15 _16lm1iw1a _16lm1iw18" };
@@ -7076,15 +7485,15 @@ var { rootClassName: rootClassName12 } = internalProps;
 var baseCls3 = `${rootClassName12}-LoadMask`;
 function LoadMaskFn(props) {
   const { visible, children = "Loading" } = props;
-  return /* @__PURE__ */ React32.createElement("div", {
+  return /* @__PURE__ */ React35.createElement("div", {
     className: `${LoadMaskCls[visible ? "visible" : "hidden"]} ${baseCls3}`
-  }, /* @__PURE__ */ React32.createElement("div", {
+  }, /* @__PURE__ */ React35.createElement("div", {
     className: `${LoadMaskOverlayCls} ${baseCls3}-Overlay`
-  }), /* @__PURE__ */ React32.createElement("div", {
+  }), /* @__PURE__ */ React35.createElement("div", {
     className: `${LoadMaskTextCls} ${baseCls3}-Text`
   }, children));
 }
-var LoadMask = React32.memo(LoadMaskFn);
+var LoadMask = React35.memo(LoadMaskFn);
 
 // src/utils/deepClone.ts
 function cloneArray(arr) {
@@ -7321,14 +7730,17 @@ function group(groupParams, data) {
   }
   for (let i = 0, len = data.length; i < len; i++) {
     const item = data[i];
+    const commonData = {};
     for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
       const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
       const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+      commonData[groupByProperty] = key;
       currentGroupKeys.push(key);
       if (!deepMap.has(currentGroupKeys)) {
         const deepMapGroupValue = {
           items: [],
           cache: false,
+          commonData: __spreadValues({}, commonData),
           childrenLoading: false,
           childrenAvailable: false,
           reducerResults: deepClone(initialReducerValue)
@@ -7600,7 +8012,7 @@ function enhancedFlatten(param) {
 }
 
 // src/components/DataSource/index.tsx
-var React33 = __toModule(require("react"));
+var React36 = __toModule(require("react"));
 
 // src/utils/multisort/sortTypes.ts
 var numberComparator = function(first, second) {
@@ -7619,7 +8031,15 @@ var sortTypes_default = defaultSortTypes;
 
 // src/utils/multisort/index.ts
 var multisort = (sortInfo, array, get) => {
-  array.sort(getMultisortFunction(sortInfo, get));
+  const plainSortInfo = sortInfo.map((sortInfo2) => {
+    if (Array.isArray(sortInfo2.field)) {
+      return sortInfo2.field.map((field) => {
+        return __spreadProps(__spreadValues({}, sortInfo2), { field });
+      });
+    }
+    return sortInfo2;
+  }).flat();
+  array.sort(getMultisortFunction(plainSortInfo, get));
   return array;
 };
 multisort.knownTypes = sortTypes_default;
@@ -7852,15 +8272,15 @@ var GroupRowsState = class extends BooleanDeepCollectionState {
 };
 
 // src/components/DataSource/privateHooks/useLoadData.ts
-var import_react29 = __toModule(require("react"));
+var import_react30 = __toModule(require("react"));
 
 // src/components/hooks/useEffectWithChanges.ts
-var import_react28 = __toModule(require("react"));
+var import_react29 = __toModule(require("react"));
 function useEffectWithChanges(fn, deps) {
-  const prevRef = (0, import_react28.useRef)({});
-  const oldValuesRef = (0, import_react28.useRef)({});
+  const prevRef = (0, import_react29.useRef)({});
+  const oldValuesRef = (0, import_react29.useRef)({});
   const oldValues = oldValuesRef.current;
-  const changesRef = (0, import_react28.useRef)({});
+  const changesRef = (0, import_react29.useRef)({});
   const changes = changesRef.current;
   const useEffectDeps = [];
   for (const k in deps) {
@@ -7873,7 +8293,7 @@ function useEffectWithChanges(fn, deps) {
     }
   }
   prevRef.current = deps;
-  (0, import_react28.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     const changes2 = changesRef.current;
     const result = fn(changes2, oldValues);
     changesRef.current = {};
@@ -8139,12 +8559,12 @@ function useLoadData() {
     livePaginationCursor,
     cursorId: stateCursorId
   } = componentState;
-  const [scrollbars, setScrollbars] = (0, import_react29.useState)({
+  const [scrollbars, setScrollbars] = (0, import_react30.useState)({
     vertical: false,
     horizontal: false
   });
-  const scrollbarsRef = (0, import_react29.useRef)(scrollbars);
-  (0, import_react29.useEffect)(() => {
+  const scrollbarsRef = (0, import_react30.useRef)(scrollbars);
+  (0, import_react30.useEffect)(() => {
     notifyScrollbarsChange.onChange((scrollbars2) => {
       if (!scrollbars2) {
         return;
@@ -8154,7 +8574,7 @@ function useLoadData() {
     });
     return () => notifyScrollbarsChange.destroy();
   }, [notifyScrollbarsChange]);
-  (0, import_react29.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     if (!livePagination) {
       return;
     }
@@ -8168,7 +8588,7 @@ function useLoadData() {
     });
     return () => cancelAnimationFrame(frameId);
   }, [livePaginationCursor]);
-  (0, import_react29.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     if (!livePagination || livePaginationCursor !== void 0) {
       return;
     }
@@ -8182,7 +8602,7 @@ function useLoadData() {
     });
     return () => cancelAnimationFrame(frameId);
   }, [dataArray.length, livePaginationCursor]);
-  (0, import_react29.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     const state = getComponentState();
     const { livePaginationCursor: livePaginationCursor2, livePagination: livePagination2, dataArray: dataArray2 } = state;
     if (!scrollbars.vertical && livePagination2) {
@@ -8200,7 +8620,7 @@ function useLoadData() {
     filterValue,
     cursorId: livePagination ? stateCursorId : null
   };
-  const initialRef = (0, import_react29.useRef)(true);
+  const initialRef = (0, import_react30.useRef)(true);
   useLazyLoadRange();
   useEffectWithChanges(() => {
     const componentState2 = getComponentState();
@@ -8232,7 +8652,7 @@ function useLazyLoadRange() {
     componentActions: actions,
     componentState
   } = useComponentState();
-  (0, import_react29.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     actions.lazyLoadCacheOfLoadedBatches = new DeepMap();
   }, [componentState.data, componentState.dataParams]);
   const {
@@ -8242,7 +8662,7 @@ function useLazyLoadRange() {
     dataArray,
     scrollStopDelayUpdatedByTable
   } = componentState;
-  const latestRenderRangeRef = (0, import_react29.useRef)(null);
+  const latestRenderRangeRef = (0, import_react30.useRef)(null);
   const loadRange = (renderRange, cache = getComponentState().lazyLoadCacheOfLoadedBatches) => {
     const componentState2 = getComponentState();
     renderRange = renderRange || latestRenderRangeRef.current;
@@ -8267,8 +8687,8 @@ function useLazyLoadRange() {
       componentActions: actions
     }, cache);
   };
-  const debouncedLoadRange = (0, import_react29.useMemo)(() => debounce(loadRange, { wait: scrollStopDelayUpdatedByTable }), [scrollStopDelayUpdatedByTable]);
-  (0, import_react29.useEffect)(() => {
+  const debouncedLoadRange = (0, import_react30.useMemo)(() => debounce(loadRange, { wait: scrollStopDelayUpdatedByTable }), [scrollStopDelayUpdatedByTable]);
+  (0, import_react30.useEffect)(() => {
     if (lazyLoad) {
       return notifyRenderRangeChange.onChange((renderRange) => {
         latestRenderRangeRef.current = renderRange;
@@ -8277,7 +8697,7 @@ function useLazyLoadRange() {
     }
     return;
   }, [lazyLoadBatchSize, lazyLoad]);
-  (0, import_react29.useEffect)(() => {
+  (0, import_react30.useEffect)(() => {
     if (lazyLoadBatchSize && lazyLoadBatchSize > 0) {
       debouncedLoadRange();
     }
@@ -9069,7 +9489,7 @@ function getLivePaginationCursorValue(livePaginationCursorProp, state) {
   return livePaginationCursor;
 }
 function mapPropsToState(params) {
-  var _a, _b;
+  var _a;
   const { props, state, oldState } = params;
   const controlledSort = isControlledValue(props.sortInfo);
   const controlledFilter = isControlledValue(props.filterValue);
@@ -9088,7 +9508,7 @@ function mapPropsToState(params) {
     if (props.cellSelection !== void 0 || props.defaultCellSelection !== void 0) {
       selectionMode = "multi-cell";
     } else {
-      const rowSelectionProp = (_a = props.rowSelection) != null ? _a : props.defaultRowSelection;
+      const rowSelectionProp = props.rowSelection !== void 0 ? props.rowSelection : props.defaultRowSelection;
       if (rowSelectionProp !== void 0) {
         if (rowSelectionProp && typeof rowSelectionProp === "object") {
           selectionMode = "multi-row";
@@ -9123,7 +9543,7 @@ function mapPropsToState(params) {
     operatorsByFilterType,
     controlledSort,
     controlledFilter,
-    filterMode: ((_b = props.filterMode) != null ? _b : props.filterFunction != null) ? "local" : typeof props.data === "function" ? "remote" : "local",
+    filterMode: ((_a = props.filterMode) != null ? _a : 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
   };
@@ -9727,7 +10147,7 @@ function DataSourceWithContext(props) {
   if (typeof children === "function") {
     children = children(computedValues);
   }
-  return /* @__PURE__ */ React33.createElement(React33.Fragment, null, children);
+  return /* @__PURE__ */ React36.createElement(React36.Fragment, null, children);
 }
 var DataSourceRoot = getComponentStateRoot({
   initSetupState,
@@ -9752,14 +10172,14 @@ function DataSourceCmp({ children }) {
     globalThis.dataSourceActions = componentActions;
   }
   useLoadData();
-  return /* @__PURE__ */ React33.createElement(DataSourceContext.Provider, {
+  return /* @__PURE__ */ React36.createElement(DataSourceContext.Provider, {
     value: contextValue
-  }, /* @__PURE__ */ React33.createElement(DataSourceWithContext, {
+  }, /* @__PURE__ */ React36.createElement(DataSourceWithContext, {
     children
   }));
 }
 function DataSource(props) {
-  return /* @__PURE__ */ React33.createElement(DataSourceRoot, __spreadValues({}, props), /* @__PURE__ */ React33.createElement(DataSourceCmp, {
+  return /* @__PURE__ */ React36.createElement(DataSourceRoot, __spreadValues({}, props), /* @__PURE__ */ React36.createElement(DataSourceCmp, {
     children: props.children
   }));
 }
@@ -9930,7 +10350,7 @@ function getImperativeApi(param) {
 }
 
 // src/components/InfiniteTable/hooks/useAutoSizeColumns.ts
-var import_react30 = __toModule(require("react"));
+var import_react31 = __toModule(require("react"));
 var OFFSET = 10;
 function getColumnContentMaxWidths(domRef, options) {
   var _a;
@@ -9996,11 +10416,11 @@ function useAutoSizeColumns() {
     componentActions,
     componentState: { domRef, ready, autoSizeColumnsKey, brain }
   } = useComponentState();
-  const [refreshId, setRefreshId] = (0, import_react30.useState)(0);
+  const [refreshId, setRefreshId] = (0, import_react31.useState)(0);
   const theKey = typeof autoSizeColumnsKey === "object" ? autoSizeColumnsKey.key : autoSizeColumnsKey;
   const getTheKey = useLatest(theKey);
-  const lastExecutedIdentifierRef = (0, import_react30.useRef)(null);
-  (0, import_react30.useEffect)(() => {
+  const lastExecutedIdentifierRef = (0, import_react31.useRef)(null);
+  (0, import_react31.useEffect)(() => {
     const key = getTheKey();
     if (key == null) {
       return;
@@ -10013,7 +10433,7 @@ function useAutoSizeColumns() {
     };
     return brain.onRenderRangeChange(onChange);
   }, [brain]);
-  (0, import_react30.useEffect)(() => {
+  (0, import_react31.useEffect)(() => {
     var _a;
     if (theKey == null) {
       return;
@@ -10058,8 +10478,8 @@ function useAutoSizeColumns() {
 }
 
 // src/components/InfiniteTable/hooks/useCellRendering.tsx
-var import_react31 = __toModule(require("react"));
-var React34 = __toModule(require("react"));
+var import_react32 = __toModule(require("react"));
+var React37 = __toModule(require("react"));
 
 // src/components/InfiniteTable/hooks/useYourBrain.ts
 function useYourBrain(param) {
@@ -10095,7 +10515,8 @@ function useCellRendering(param) {
     computedPinnedStartColumns,
     computedPinnedEndColumns,
     computedVisibleColumns,
-    computedVisibleColumnsMap,
+    computedColumnsMap,
+    fieldsToColumn,
     rowspan,
     toggleGroupRow,
     columnSize
@@ -10130,13 +10551,13 @@ function useCellRendering(param) {
     bodySize,
     rowspan
   });
-  const scrollTopMaxRef = (0, import_react31.useRef)(0);
-  (0, import_react31.useEffect)(() => {
+  const scrollTopMaxRef = (0, import_react32.useRef)(0);
+  (0, import_react32.useEffect)(() => {
     return brain.onRenderCountChange(() => {
       scrollTopMaxRef.current = brain.scrollTopMax;
     });
   }, [brain]);
-  (0, import_react31.useEffect)(() => {
+  (0, import_react32.useEffect)(() => {
     return brain.onScrollStop((scrollPosition) => {
       const { scrollTop: scrollTop2 } = scrollPosition;
       if (scrollTop2 === 0) {
@@ -10153,7 +10574,7 @@ function useCellRendering(param) {
       }
     });
   }, [brain, onScrollToTop, onScrollToBottom]);
-  (0, import_react31.useEffect)(() => {
+  (0, import_react32.useEffect)(() => {
     if (!bodySize.height) {
       return;
     }
@@ -10164,10 +10585,10 @@ function useCellRendering(param) {
     }
   }, [!!bodySize.height]);
   const [, rerender] = useRerender();
-  (0, import_react31.useEffect)(() => {
+  (0, import_react32.useEffect)(() => {
     rerender();
   }, [dataSourceState]);
-  const renderCell = (0, import_react31.useCallback)((params) => {
+  const renderCell = (0, import_react32.useCallback)((params) => {
     const {
       rowIndex,
       colIndex,
@@ -10199,16 +10620,18 @@ function useCellRendering(param) {
       domRef,
       width,
       column,
-      columnsMap: computedVisibleColumnsMap,
+      columnsMap: computedColumnsMap,
+      fieldsToColumn,
       rowStyle,
       rowClassName
     };
-    return /* @__PURE__ */ React34.createElement(InfiniteTableColumnCell, __spreadValues({}, cellProps));
+    return /* @__PURE__ */ React37.createElement(InfiniteTableColumnCell, __spreadValues({}, cellProps));
   }, [
     rowHeight,
     getData,
     computedVisibleColumns,
-    computedVisibleColumnsMap,
+    computedColumnsMap,
+    fieldsToColumn,
     groupRenderStrategy,
     toggleGroupRow,
     showZebraRows,
@@ -10295,10 +10718,10 @@ var MultiRowSelector = class {
 };
 
 // src/components/InfiniteTable/hooks/useColumnGroups.ts
-var import_react33 = __toModule(require("react"));
+var import_react34 = __toModule(require("react"));
 
 // src/components/hooks/useInterceptedMap.ts
-var import_react32 = __toModule(require("react"));
+var import_react33 = __toModule(require("react"));
 function interceptMap(map2, fns) {
   const { set, delete: deleteKey, clear } = map2;
   if (fns.set) {
@@ -10328,373 +10751,141 @@ function interceptMap(map2, fns) {
     };
   }
   return () => {
-    if (set) {
-      map2.set = set;
-    }
-    if (deleteKey) {
-      map2.delete = deleteKey;
-    }
-    if (clear) {
-      map2.clear = clear;
-    }
-  };
-}
-
-// src/components/InfiniteTable/state/computeColumnGroupsDepths.ts
-function computeColumnGroupsDepths(columnGroups) {
-  const map2 = new Map();
-  columnGroups.forEach((colGroup, colGroupId) => {
-    let parentGroupId = colGroup.columnGroup;
-    let depth = 0;
-    while (parentGroupId) {
-      const parent = columnGroups.get(parentGroupId);
-      if (!parent) {
-        if (false) {
-          console.warn(`Cannot find column group ${parentGroupId}`);
-        }
-        break;
-      }
-      depth++;
-      parentGroupId = parent.columnGroup;
-    }
-    map2.set(colGroupId, depth);
-  });
-  return map2;
-}
-
-// src/components/InfiniteTable/hooks/useColumnGroups.ts
-function useColumnGroups() {
-  const {
-    componentState: {
-      computedColumnGroups,
-      collapsedColumnGroups
-    },
-    componentActions,
-    getComponentState
-  } = useComponentState();
-  (0, import_react33.useEffect)(() => {
-    const recompute = () => {
-      componentActions.columnGroupsDepthsMap = computeColumnGroupsDepths(computedColumnGroups);
-    };
-    const update = rafFn(recompute);
-    return interceptMap(computedColumnGroups, {
-      clear: update,
-      delete: update,
-      set: update
-    });
-  }, [computedColumnGroups]);
-  (0, import_react33.useEffect)(() => {
-    return interceptMap(collapsedColumnGroups, {
-      set: (key, visibleCol) => {
-        const colIds = key.slice(1);
-        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
-        colIds.forEach((colId) => {
-          columnVisibility[colId] = false;
-        });
-        delete columnVisibility[visibleCol];
-        componentActions.columnVisibility = columnVisibility;
-      },
-      beforeClear: (currentCollapsedGroups) => {
-        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
-        const keys = [...currentCollapsedGroups.keys()];
-        keys.forEach((key) => {
-          const colIds = key.slice(1);
-          colIds.forEach((colId) => {
-            delete columnVisibility[colId];
-          });
-        });
-        componentActions.columnVisibility = columnVisibility;
-      },
-      delete: (key) => {
-        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
-        const colIds = key.slice(1);
-        colIds.forEach((colId) => {
-          delete columnVisibility[colId];
-        });
-        componentActions.columnVisibility = columnVisibility;
-      }
-    });
-  }, [collapsedColumnGroups]);
-}
-
-// src/components/InfiniteTable/hooks/useColumnRowspan.ts
-var import_react34 = __toModule(require("react"));
-function useColumnRowspan(computedVisibleColumns) {
-  const { getState: getDataSourceState } = useDataSourceContextValue();
-  const rowspan = (0, import_react34.useMemo)(() => {
-    const colsWithRowspan = computedVisibleColumns.filter((col) => typeof col.rowspan === "function");
-    return colsWithRowspan.length ? ({ rowIndex, colIndex }) => {
-      const dataArray = getDataSourceState().dataArray;
-      const rowInfo = dataArray[rowIndex];
-      if (!rowInfo) {
-        return 1;
-      }
-      const data = rowInfo.data;
-      const column = computedVisibleColumns[colIndex];
-      if (!column || !column.rowspan) {
-        return 1;
-      }
-      return column.rowspan({
-        column,
-        data,
-        dataArray,
-        rowInfo,
-        rowIndex
-      });
-    } : void 0;
-  }, [computedVisibleColumns]);
-  return rowspan;
-}
-
-// src/components/InfiniteTable/hooks/useColumnSizeFn.ts
-var import_react35 = __toModule(require("react"));
-var debug4 = dbg("useColumnSizeFn");
-function useColumnSizeFn(columns) {
-  const columnSize = (0, import_react35.useCallback)((index) => {
-    const column = columns[index];
-    if (false) {
-      debug4("cannot find column at index", index, columns);
-    }
-    return column ? column.computedWidth : 0;
-  }, [columns]);
-  return columnSize;
-}
-
-// src/components/InfiniteTable/hooks/useColumnsWhen.ts
-var import_react39 = __toModule(require("react"));
-
-// src/components/InfiniteTable/utils/getColumnForGroupBy.tsx
-var React37 = __toModule(require("react"));
-
-// src/components/DataSource/state/rowInfoStatus.ts
-var showLoadingIcon = (rowInfo) => {
-  if (rowInfo.dataSourceHasGrouping) {
-    return rowInfo.isGroupRow ? rowInfo.childrenLoading || !rowInfo.selfLoaded : !rowInfo.selfLoaded;
-  }
-  return !rowInfo.selfLoaded;
-};
-
-// src/components/InfiniteTable/components/icons/ExpanderIcon.tsx
-var React35 = __toModule(require("react"));
-var import_react36 = __toModule(require("react"));
-
-// src/components/InfiniteTable/components/icons/ExpanderIcon.css.ts
-var import_createRuntimeFn6 = __toModule(require_vanilla_extract_recipes_createRuntimeFn_cjs());
-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, direction = "start" } = props;
-  const [expanded, setExpanded] = (0, import_react36.useState)((_a = props.expanded) != null ? _a : props.defaultExpanded);
-  const onClick = () => {
-    var _a2;
-    (_a2 = props.onChange) == null ? void 0 : _a2.call(props, !expanded);
-    if (!isControlled("expanded", props)) {
-      setExpanded(!expanded);
-    }
-  };
-  React35.useEffect(() => {
-    if (isControlled("expanded", props)) {
-      setExpanded(props.expanded);
-    }
-  }, [props.expanded]);
-  return /* @__PURE__ */ React35.createElement("svg", {
-    "data-name": "expander-icon",
-    xmlns: "http://www.w3.org/2000/svg",
-    height: `${size}px`,
-    viewBox: "0 0 24 24",
-    width: `${size}px`,
-    style: props.style,
-    onClick,
-    className: join(props.className, ExpanderIconCls, ExpanderIconClsVariants({
-      direction: direction || "start",
-      expanded
-    }), "InfiniteIcon", "InfiniteIcon-expander", `InfiniteIcon-expander--${expanded ? "expanded" : "collapsed"}`, `InfiniteIcon-expander--${direction === "end" ? "end" : "start"}`)
-  }, /* @__PURE__ */ React35.createElement("path", {
-    d: "M8.59 16.59L13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.41z"
-  }));
-}
-
-// src/components/InfiniteTable/components/icons/LoadingIcon.tsx
-var React36 = __toModule(require("react"));
-
-// src/components/InfiniteTable/components/icons/LoadingIcon.css.ts
-var LoadingIconCls = "_16lm1iw8 _16lm1iwi _16lm1iwe";
-
-// src/components/InfiniteTable/components/icons/LoadingIcon.tsx
-var LoadingIcon = (props) => {
-  return /* @__PURE__ */ React36.createElement("svg", {
-    xmlns: "http://www.w3.org/2000/svg",
-    style: {
-      margin: "auto",
-      display: "block",
-      shapeRendering: "auto"
-    },
-    width: "24px",
-    height: "24px",
-    viewBox: "0 0 100 100",
-    preserveAspectRatio: "xMidYMid",
-    className: join(props.className, LoadingIconCls, "InfiniteIcon", "InfiniteIcon-loading")
-  }, /* @__PURE__ */ React36.createElement("circle", {
-    cx: "50",
-    cy: "50",
-    fill: "none",
-    strokeWidth: "10",
-    r: "35",
-    strokeDasharray: "164.93361431346415 56.97787143782138"
-  }, /* @__PURE__ */ React36.createElement("animateTransform", {
-    attributeName: "transform",
-    type: "rotate",
-    repeatCount: "indefinite",
-    dur: "1s",
-    values: "0 50 50;360 50 50",
-    keyTimes: "0;1"
-  })));
-};
-
-// src/components/InfiniteTable/utils/getColumnForGroupBy.tsx
-function styleForGroupColumn({
-  rowInfo
-}) {
-  return {
-    [stripVar(ThemeVars.components.Row.groupNesting)]: rowInfo.dataSourceHasGrouping ? rowInfo.isGroupRow ? rowInfo.groupNesting - 1 : rowInfo.groupNesting : 0
-  };
-}
-function getGroupColumnRender({
-  groupIndexForColumn,
-  groupRenderStrategy
-}) {
-  return (renderOptions) => {
-    const { rowInfo, renderBag, column } = renderOptions;
-    let { value: valueToRender, groupIcon, selectionCheckBox } = renderBag;
-    const groupRowInfo = rowInfo;
-    if (groupRenderStrategy === "multi-column") {
-      if (groupIndexForColumn + 1 !== groupRowInfo.groupNesting && groupRowInfo.isGroupRow) {
-        return null;
-      }
-    } else if (groupRenderStrategy === "single-column" && !groupRowInfo.isGroupRow) {
-    }
-    return /* @__PURE__ */ React37.createElement("div", {
-      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__ */ React37.createElement("div", {
-      className: cssEllipsisClassName
-    }, valueToRender != null ? valueToRender : null));
-  };
-}
-function getGroupColumnRenderGroupIcon({
-  groupIndexForColumn,
-  groupRenderStrategy,
-  toggleGroupRow,
-  initialRenderGroupIcon
-}) {
-  return (renderOptions) => {
-    var _a, _b, _c;
-    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;
-    }
-    const collapsed = groupRowInfo.collapsed;
-    if (groupRenderStrategy === "inline") {
-      if (groupRowInfo.groupCount === 1) {
-        return value;
-      }
-      if (groupRowInfo.groupNesting === groupIndexForColumn && collapsed) {
-        return null;
-      }
-    } else {
-      if (!groupRowInfo.isGroupRow) {
-        return null;
-      }
-      if (groupRenderStrategy === "multi-column") {
-        if (groupIndexForColumn + 1 !== groupRowInfo.groupNesting) {
-          return null;
-        }
-      }
+    if (set) {
+      map2.set = set;
     }
-    const groupKeys = groupRowInfo.groupKeys;
-    let icon = null;
-    const showExpanderIcon = pivotBy ? (((_b = groupRowInfo.groupKeys) == null ? void 0 : _b.length) || 0) < (groupBy == null ? void 0 : groupBy.length) : (((_c = groupRowInfo.groupKeys) == null ? void 0 : _c.length) || 0) <= (groupBy == null ? void 0 : groupBy.length);
-    const isLoading = showLoadingIcon(groupRowInfo);
-    if (isLoading) {
-      icon = /* @__PURE__ */ React37.createElement(LoadingIcon, null);
-    } else if (showExpanderIcon) {
-      const defaultIcon = /* @__PURE__ */ React37.createElement(ExpanderIcon, {
-        expanded: !collapsed,
-        direction: column.align === "end" ? "end" : "start",
-        onChange: () => {
-          toggleGroupRow(groupKeys);
-        }
-      });
-      icon = defaultIcon;
+    if (deleteKey) {
+      map2.delete = deleteKey;
     }
-    if (initialRenderGroupIcon) {
-      renderOptions.renderBag.groupIcon = icon;
-      icon = /* @__PURE__ */ React37.createElement(RenderHookComponent, {
-        render: initialRenderGroupIcon,
-        renderParam: renderOptions
-      });
+    if (clear) {
+      map2.clear = clear;
     }
-    return icon;
   };
 }
-function getColumnForGroupBy(options, toggleGroupRow, groupColumnFromProps) {
-  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,
-    sortable: false,
-    style: styleForGroupColumn,
-    render: getGroupColumnRender({
-      groupIndexForColumn,
-      groupRenderStrategy
-    })
-  }, userDefinedGroupColumn), {
-    renderGroupIcon: getGroupColumnRenderGroupIcon({
-      initialRenderGroupIcon: userDefinedGroupColumn == null ? void 0 : userDefinedGroupColumn.renderGroupIcon,
-      groupIndexForColumn,
-      toggleGroupRow,
-      groupRenderStrategy
-    })
-  });
-  if (groupColumnFromProps) {
-    if (typeof groupColumnFromProps === "function") {
-      generatedGroupColumn = __spreadValues(__spreadValues({}, generatedGroupColumn), groupColumnFromProps(options, toggleGroupRow));
-    } else {
-      generatedGroupColumn = __spreadValues(__spreadValues({}, generatedGroupColumn), groupColumnFromProps);
+
+// src/components/InfiniteTable/state/computeColumnGroupsDepths.ts
+function computeColumnGroupsDepths(columnGroups) {
+  const map2 = new Map();
+  columnGroups.forEach((colGroup, colGroupId) => {
+    let parentGroupId = colGroup.columnGroup;
+    let depth = 0;
+    while (parentGroupId) {
+      const parent = columnGroups.get(parentGroupId);
+      if (!parent) {
+        if (false) {
+          console.warn(`Cannot find column group ${parentGroupId}`);
+        }
+        break;
+      }
+      depth++;
+      parentGroupId = parent.columnGroup;
     }
-  }
-  return generatedGroupColumn;
-}
-function getSingleGroupColumn(options, toggleGroupRow, groupColumnFromProps) {
-  const theGroupColumnFromProps = typeof groupColumnFromProps === "function" ? groupColumnFromProps(options, toggleGroupRow) : groupColumnFromProps;
-  let generatedGroupColumn = __spreadProps(__spreadValues({
-    header: `Group`,
-    groupByField: options.groupBy.map((g) => g.field),
-    sortable: false,
-    renderSelectionCheckBox: options.selectionMode === "multi-row",
-    style: styleForGroupColumn,
-    render: getGroupColumnRender({
-      groupIndexForColumn: 0,
-      groupRenderStrategy: "single-column"
-    })
-  }, groupColumnFromProps), {
-    renderGroupIcon: getGroupColumnRenderGroupIcon({
-      initialRenderGroupIcon: theGroupColumnFromProps == null ? void 0 : theGroupColumnFromProps.renderGroupIcon,
-      groupIndexForColumn: 0,
-      toggleGroupRow,
-      groupRenderStrategy: "single-column"
-    })
+    map2.set(colGroupId, depth);
   });
-  return generatedGroupColumn;
+  return map2;
+}
+
+// src/components/InfiniteTable/hooks/useColumnGroups.ts
+function useColumnGroups() {
+  const {
+    componentState: {
+      computedColumnGroups,
+      collapsedColumnGroups
+    },
+    componentActions,
+    getComponentState
+  } = useComponentState();
+  (0, import_react34.useEffect)(() => {
+    const recompute = () => {
+      componentActions.columnGroupsDepthsMap = computeColumnGroupsDepths(computedColumnGroups);
+    };
+    const update = rafFn(recompute);
+    return interceptMap(computedColumnGroups, {
+      clear: update,
+      delete: update,
+      set: update
+    });
+  }, [computedColumnGroups]);
+  (0, import_react34.useEffect)(() => {
+    return interceptMap(collapsedColumnGroups, {
+      set: (key, visibleCol) => {
+        const colIds = key.slice(1);
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
+        colIds.forEach((colId) => {
+          columnVisibility[colId] = false;
+        });
+        delete columnVisibility[visibleCol];
+        componentActions.columnVisibility = columnVisibility;
+      },
+      beforeClear: (currentCollapsedGroups) => {
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
+        const keys = [...currentCollapsedGroups.keys()];
+        keys.forEach((key) => {
+          const colIds = key.slice(1);
+          colIds.forEach((colId) => {
+            delete columnVisibility[colId];
+          });
+        });
+        componentActions.columnVisibility = columnVisibility;
+      },
+      delete: (key) => {
+        const columnVisibility = __spreadValues({}, getComponentState().columnVisibility);
+        const colIds = key.slice(1);
+        colIds.forEach((colId) => {
+          delete columnVisibility[colId];
+        });
+        componentActions.columnVisibility = columnVisibility;
+      }
+    });
+  }, [collapsedColumnGroups]);
+}
+
+// src/components/InfiniteTable/hooks/useColumnRowspan.ts
+var import_react35 = __toModule(require("react"));
+function useColumnRowspan(computedVisibleColumns) {
+  const { getState: getDataSourceState } = useDataSourceContextValue();
+  const rowspan = (0, import_react35.useMemo)(() => {
+    const colsWithRowspan = computedVisibleColumns.filter((col) => typeof col.rowspan === "function");
+    return colsWithRowspan.length ? ({ rowIndex, colIndex }) => {
+      const dataArray = getDataSourceState().dataArray;
+      const rowInfo = dataArray[rowIndex];
+      if (!rowInfo) {
+        return 1;
+      }
+      const data = rowInfo.data;
+      const column = computedVisibleColumns[colIndex];
+      if (!column || !column.rowspan) {
+        return 1;
+      }
+      return column.rowspan({
+        column,
+        data,
+        dataArray,
+        rowInfo,
+        rowIndex
+      });
+    } : void 0;
+  }, [computedVisibleColumns]);
+  return rowspan;
+}
+
+// src/components/InfiniteTable/hooks/useColumnSizeFn.ts
+var import_react36 = __toModule(require("react"));
+var debug4 = dbg("useColumnSizeFn");
+function useColumnSizeFn(columns) {
+  const columnSize = (0, import_react36.useCallback)((index) => {
+    const column = columns[index];
+    if (false) {
+      debug4("cannot find column at index", index, columns);
+    }
+    return column ? column.computedWidth : 0;
+  }, [columns]);
+  return columnSize;
 }
 
+// src/components/InfiniteTable/hooks/useColumnsWhen.ts
+var import_react39 = __toModule(require("react"));
+
 // src/components/InfiniteTable/hooks/useEffectWithRaf.ts
 var import_react37 = __toModule(require("react"));
 function useEffectWithRaf(fn, deps) {
@@ -10882,17 +11073,19 @@ function useColumnsWhenGrouping() {
     componentState: {
       columns,
       groupColumn,
+      hideColumnWhenGrouped,
       groupRenderStrategy,
       pivotColumns,
       pivotColumn,
       pivotTotalColumnPosition,
       pivotGrandTotalColumnPosition
-    }
+    },
+    getComponentState
   } = useComponentState();
   const toggleGroupRow = useToggleGroupRow();
   (0, import_react39.useEffect)(() => {
     const update = () => {
-      const columnsWhenGrouping = getColumnsWhenGrouping({
+      const { columns: columnsWhenGrouping, groupColumnIds } = getColumnsWhenGrouping({
         columns,
         groupColumn,
         pivotColumn,
@@ -10906,6 +11099,23 @@ function useColumnsWhenGrouping() {
         selectionMode
       });
       componentActions.columnsWhenGrouping = columnsWhenGrouping;
+      let currentColumnOrder = getComponentState().columnOrder;
+      if (groupColumnIds.length && Array.isArray(currentColumnOrder)) {
+        const colOrder = new Set(currentColumnOrder);
+        let shouldUpdate = false;
+        groupColumnIds.forEach((groupColId) => {
+          if (!colOrder.has(groupColId)) {
+            shouldUpdate = true;
+            currentColumnOrder = [
+              groupColId,
+              ...currentColumnOrder
+            ];
+          }
+        });
+        if (shouldUpdate) {
+          componentActions.columnOrder = currentColumnOrder;
+        }
+      }
     };
     update();
     return interceptMap(columns, {
@@ -10918,6 +11128,7 @@ function useColumnsWhenGrouping() {
     groupBy,
     pivotBy,
     selectionMode,
+    hideColumnWhenGrouped,
     groupColumn,
     groupRenderStrategy,
     pivotColumns,
@@ -10942,6 +11153,7 @@ function useHideColumns(groupByMap) {
     componentState: {
       columnTypes,
       computedColumns,
+      hideColumnWhenGrouped,
       hideEmptyGroupColumns,
       groupRenderStrategy
     }
@@ -11031,30 +11243,54 @@ function useHideColumns(groupByMap) {
   (0, import_react39.useEffect)(() => {
     const isGrouped = groupBy.length > 0;
     const currentState = getComponentState();
-    const { controlledColumnVisibility, columnVisibility } = currentState;
-    if (controlledColumnVisibility) {
-      return;
-    }
+    const {
+      columnVisibility,
+      columnVisibilityForGrouping,
+      hideColumnWhenGrouped: hideColumnWhenGrouped2
+    } = currentState;
     const newColumnVisibility = __spreadValues({}, columnVisibility);
-    let updated = false;
+    let newColumnVisibilityForGrouping = __spreadValues({}, columnVisibilityForGrouping);
+    let updatedVisibilityWhenGrouping = false;
+    let newlyHiddenColumns = new Set();
+    let newlyDisplayedColumns = new Set();
     computedColumns.forEach((col, id) => {
-      if (col.defaultHiddenWhenGroupedBy) {
-        const nowHidden = columnVisibility[id] === false;
-        const shouldBeHidden = col.defaultHiddenWhenGroupedBy === "*" && isGrouped || typeof col.defaultHiddenWhenGroupedBy === "string" && groupByMap.get(col.defaultHiddenWhenGroupedBy) || typeof col.defaultHiddenWhenGroupedBy === "object" && Object.keys(col.defaultHiddenWhenGroupedBy).reduce((acc, field) => acc || groupByMap.has(field), false);
-        if (nowHidden !== shouldBeHidden) {
-          updated = true;
-          if (shouldBeHidden) {
-            newColumnVisibility[id] = false;
-          } else {
-            delete newColumnVisibility[id];
+      if (col.defaultHiddenWhenGroupedBy || hideColumnWhenGrouped2 != null) {
+        const hideWhenGrouped = col.defaultHiddenWhenGroupedBy === "*" && isGrouped || (col.defaultHiddenWhenGroupedBy === true || hideColumnWhenGrouped2) && col.field && groupByMap.get(col.field) || typeof col.defaultHiddenWhenGroupedBy === "string" && groupByMap.get(col.defaultHiddenWhenGroupedBy) || typeof col.defaultHiddenWhenGroupedBy === "object" && Object.keys(col.defaultHiddenWhenGroupedBy).reduce((acc, field) => acc || groupByMap.has(field), false);
+        if (hideWhenGrouped) {
+          if (newColumnVisibilityForGrouping[id] !== false) {
+            if (columnVisibility[id] === false) {
+              return;
+            }
+            newColumnVisibilityForGrouping[id] = false;
+            updatedVisibilityWhenGrouping = true;
+            newlyHiddenColumns.add(id);
+          }
+        } else {
+          if (newColumnVisibilityForGrouping[id] === false) {
+            delete newColumnVisibilityForGrouping[id];
+            updatedVisibilityWhenGrouping = true;
+            newlyDisplayedColumns.add(id);
           }
         }
       }
     });
-    if (updated) {
+    if (updatedVisibilityWhenGrouping) {
+      componentActions.columnVisibilityForGrouping = newColumnVisibilityForGrouping;
+      newlyDisplayedColumns.forEach((colId) => {
+        delete newColumnVisibility[colId];
+      });
+      newlyHiddenColumns.forEach((colId) => {
+        newColumnVisibility[colId] = false;
+      });
       componentActions.columnVisibility = newColumnVisibility;
     }
-  }, [computedColumns, columnTypes, groupBy, groupByMap]);
+  }, [
+    computedColumns,
+    columnTypes,
+    groupBy,
+    groupByMap,
+    hideColumnWhenGrouped
+  ]);
 }
 function getColumnsWhenGrouping(params) {
   const {
@@ -11071,9 +11307,10 @@ function getColumnsWhenGrouping(params) {
     columns
   } = params;
   if (groupRenderStrategy === "inline") {
-    return void 0;
+    return { columns: void 0, groupColumnIds: [] };
   }
   const computedColumns = new Map();
+  const groupColumnIds = [];
   if (groupRenderStrategy === "multi-column") {
     groupBy.forEach((groupByForColumn, groupIndexForColumn, arr) => {
       const generatedGroupColumn = getColumnForGroupBy({
@@ -11085,7 +11322,9 @@ function getColumnsWhenGrouping(params) {
         groupRenderStrategy,
         selectionMode
       }, toggleGroupRow, groupColumn);
-      computedColumns.set(generatedGroupColumn.id || `group-by-${groupByForColumn.field}`, generatedGroupColumn);
+      const groupColumnId = generatedGroupColumn.id || `group-by-${groupByForColumn.field}`;
+      groupColumnIds.push(groupColumnId);
+      computedColumns.set(groupColumnId, generatedGroupColumn);
     });
   } else if (groupRenderStrategy === "single-column" && groupBy.length) {
     const singleGroupColumn = getSingleGroupColumn({
@@ -11095,7 +11334,9 @@ function getColumnsWhenGrouping(params) {
       groupRenderStrategy,
       selectionMode
     }, toggleGroupRow, groupColumn);
-    computedColumns.set(singleGroupColumn.id || "group-by", singleGroupColumn);
+    const groupColumnId = singleGroupColumn.id || "group-by";
+    groupColumnIds.push(groupColumnId);
+    computedColumns.set(groupColumnId, singleGroupColumn);
   }
   if (pivotColumns) {
     const columnsByField = {};
@@ -11142,7 +11383,10 @@ function getColumnsWhenGrouping(params) {
       computedColumns.set(colId, col);
     });
   }
-  return computedColumns.size ? computedColumns : void 0;
+  return {
+    columns: computedColumns.size ? computedColumns : void 0,
+    groupColumnIds
+  };
 }
 
 // src/components/InfiniteTable/hooks/useComputedVisibleColumns.ts
@@ -11202,6 +11446,33 @@ var getComputedPinned = (colId, columnPinning) => {
   const computedPinned = pinned === "start" || pinned === true ? "start" : pinned === "end" ? "end" : false;
   return computedPinned;
 };
+function isGroupColumnSortable(column, columns) {
+  var _a;
+  let sortableColumnOrType = (_a = column.sortable) != null ? _a : column.colType.sortable;
+  if (sortableColumnOrType != null) {
+    return sortableColumnOrType;
+  }
+  if (column.computedSortable === false) {
+    return false;
+  }
+  let groupByField = column.groupByField || [];
+  if (groupByField != null && !Array.isArray(groupByField)) {
+    groupByField = [groupByField];
+  }
+  const fields = (groupByField || []).reduce((acc, field) => {
+    acc[field] = true;
+    return acc;
+  }, {});
+  const groupColumns = [];
+  columns.forEach((col) => {
+    if (col.field && fields[col.field]) {
+      groupColumns.push(col);
+    }
+  });
+  return groupColumns.reduce((sortable, col) => {
+    return sortable && col.computedSortable === true;
+  }, true);
+}
 var getComputedVisibleColumns = ({
   columns,
   bodySize,
@@ -11248,12 +11519,16 @@ var getComputedVisibleColumns = ({
     const result2 = isColumnVisible(columnVisibility, columnVisibilityAssumeVisible, colId);
     return result2;
   });
-  const columnsArray = visibleColumnOrder.map((columnId) => columns.get(columnId)).filter(Boolean);
+  const columnIdsToVisibleIndex = new Map();
+  const visibleColumnsArray = visibleColumnOrder.map((columnId, index) => {
+    const col = columns.get(columnId);
+    columnIdsToVisibleIndex.set(columnId, index);
+    return col;
+  });
   const sortedMap = (sortInfo != null ? sortInfo : []).reduce((acc, info, index) => {
     if (info.id) {
       acc[info.id] = { sortInfo: info, index };
-    }
-    if (info.field) {
+    } else if (info.field) {
       acc[info.field] = {
         sortInfo: info,
         index
@@ -11261,54 +11536,57 @@ var getComputedVisibleColumns = ({
     }
     return acc;
   }, {});
+  function getColSize(colId) {
+    var _a, _b, _c, _d, _e, _f;
+    const column = columns.get(colId);
+    const colType = getColumnComputedType(column, columnTypes);
+    const colTypeSizing = {
+      minWidth: colType == null ? void 0 : colType.minWidth,
+      maxWidth: colType == null ? void 0 : colType.maxWidth,
+      width: colType == null ? void 0 : colType.defaultWidth,
+      flex: colType == null ? void 0 : colType.defaultFlex
+    };
+    let colSizing = assignNonNull({
+      width: column == null ? void 0 : column.defaultWidth,
+      flex: column == null ? void 0 : column.defaultFlex,
+      minWidth: column == null ? void 0 : column.minWidth,
+      maxWidth: column == null ? void 0 : column.maxWidth
+    }, columnSizing[colId]);
+    if (colSizing.width != null) {
+      delete colTypeSizing.flex;
+    }
+    if (colSizing.flex != null) {
+      delete colTypeSizing.width;
+    }
+    colSizing = assignNonNull(colTypeSizing, colSizing);
+    const colFlex = (_a = colSizing.flex) != null ? _a : void 0;
+    const colMinWidth = (_c = (_b = colSizing.minWidth) != null ? _b : column == null ? void 0 : column.minWidth) != null ? _c : columnMinWidth;
+    const colMaxWidth = (_e = (_d = colSizing.maxWidth) != null ? _d : column == null ? void 0 : column.maxWidth) != null ? _e : columnMaxWidth;
+    let size = colFlex != void 0 ? void 0 : (_f = colSizing.width) != null ? _f : columnDefaultWidth;
+    if (!size && colFlex == void 0) {
+      size = colMinWidth;
+    }
+    return {
+      size,
+      flex: colFlex,
+      minSize: colMinWidth,
+      maxSize: colMaxWidth
+    };
+  }
   const flexResult = computeFlex({
     availableSize: Math.max(bodySize.width - (viewportReservedWidth != null ? viewportReservedWidth : 0) - getScrollbarWidth(), 0),
     maxSize: columnMaxWidth,
     minSize: columnMinWidth,
-    items: visibleColumnOrder.map((colId) => {
-      var _a, _b, _c, _d, _e, _f;
-      const column = columns.get(colId);
-      const colType = getColumnComputedType(column, columnTypes);
-      const colTypeSizing = {
-        minWidth: colType == null ? void 0 : colType.minWidth,
-        maxWidth: colType == null ? void 0 : colType.maxWidth,
-        width: colType == null ? void 0 : colType.defaultWidth,
-        flex: colType == null ? void 0 : colType.defaultFlex
-      };
-      let colSizing = assignNonNull({
-        width: column == null ? void 0 : column.defaultWidth,
-        flex: column == null ? void 0 : column.defaultFlex,
-        minWidth: column == null ? void 0 : column.minWidth,
-        maxWidth: column == null ? void 0 : column.maxWidth
-      }, columnSizing[colId]);
-      if (colSizing.width != null) {
-        delete colTypeSizing.flex;
-      }
-      if (colSizing.flex != null) {
-        delete colTypeSizing.width;
-      }
-      colSizing = assignNonNull(colTypeSizing, colSizing);
-      const colFlex = (_a = colSizing.flex) != null ? _a : void 0;
-      const colMinWidth = (_c = (_b = colSizing.minWidth) != null ? _b : column == null ? void 0 : column.minWidth) != null ? _c : columnMinWidth;
-      const colMaxWidth = (_e = (_d = colSizing.maxWidth) != null ? _d : column == null ? void 0 : column.maxWidth) != null ? _e : columnMaxWidth;
-      let size = colFlex != void 0 ? void 0 : (_f = colSizing.width) != null ? _f : columnDefaultWidth;
-      if (!size && colFlex == void 0) {
-        size = colMinWidth;
-      }
-      return {
-        size,
-        flex: colFlex,
-        minSize: colMinWidth,
-        maxSize: colMaxWidth
-      };
-    })
+    items: visibleColumnOrder.map(getColSize)
   });
   const { computedSizes, flexSizes, minSizes, maxSizes } = flexResult;
   const computedPinnedStartColumns = [];
   const computedPinnedEndColumns = [];
   const computedUnpinnedColumns = [];
   const computedVisibleColumns = [];
+  computedVisibleColumns.length = visibleColumnOrder.length;
   const computedVisibleColumnsMap = new Map();
+  const computedColumnsMap = new Map();
   let computedUnpinnedColumnsWidth = 0;
   let computedPinnedStartColumnsWidth = 0;
   let computedPinnedEndColumnsWidth = 0;
@@ -11317,7 +11595,7 @@ var getComputedVisibleColumns = ({
   let totalPinnedStartWidth = 0;
   let totalUnpinnedWidth = 0;
   let totalPinnedEndWidth = 0;
-  columnsArray.forEach((_c, i) => {
+  visibleColumnsArray.forEach((_c, i) => {
     const id = visibleColumnOrder[i];
     const computedWidth = computedSizes[i];
     const pinned = computedPinnedArray[i] = getComputedPinned(id, columnPinning);
@@ -11330,39 +11608,56 @@ var getComputedVisibleColumns = ({
     }
   });
   const firstPinnedEndAbsoluteOffset = bodySize.width - totalPinnedEndWidth;
-  columnsArray.forEach((c, i) => {
+  const groupColumns = [];
+  const orderedColumns = new Map();
+  visibleColumnOrder.forEach((id, index) => {
+    const c = visibleColumnsArray[index];
+    orderedColumns.set(id, c);
+  });
+  columns.forEach((c, key) => {
+    if (!orderedColumns.has(key)) {
+      orderedColumns.set(key, c);
+    }
+  });
+  const fieldsToColumn = new Map();
+  orderedColumns.forEach((c, id) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
-    const id = visibleColumnOrder[i];
-    const nextColumnId = visibleColumnOrder[i + 1];
+    let theComputedVisibleIndex = columnIdsToVisibleIndex.get(id);
+    if (theComputedVisibleIndex == void 0) {
+      theComputedVisibleIndex = -1;
+    }
+    const computedVisible = theComputedVisibleIndex != -1;
+    const nextColumnId = visibleColumnOrder[theComputedVisibleIndex + 1];
     const colType = getColumnComputedType(c, columnTypes);
-    const computedVisibleIndex = i;
+    const computedVisibleIndex = theComputedVisibleIndex;
     const sortingInfo = sortedMap[id] ? sortedMap[id] : c.field ? (_a = sortedMap[c.field]) != null ? _a : null : null;
     const computedSortInfo = (_b = sortingInfo == null ? void 0 : sortingInfo.sortInfo) != null ? _b : null;
     const computedSorted = !!computedSortInfo;
     const computedSortedAsc = computedSorted && computedSortInfo.dir === 1;
     const computedSortedDesc = computedSorted && !computedSortedAsc;
     const computedSortIndex = (_c = sortingInfo == null ? void 0 : sortingInfo.index) != null ? _c : -1;
-    const computedWidth = computedSizes[i];
-    const computedFlex = flexSizes[i] || null;
-    const computedMinWidth = minSizes[i] || 0;
-    const computedMaxWidth = maxSizes[i] || 1e4;
-    const computedPinned = getComputedPinned(id, columnPinning);
-    const computedLast = i === visibleColumnOrder.length - 1;
+    const colSizeForNonVisibleColumn = computedVisible ? {} : getColSize(id);
+    const computedWidth = computedVisible ? computedSizes[theComputedVisibleIndex] : colSizeForNonVisibleColumn.size || 0;
+    const computedFlex = computedVisible ? flexSizes[theComputedVisibleIndex] || null : null;
+    const computedMinWidth = computedVisible ? minSizes[theComputedVisibleIndex] || 0 : colSizeForNonVisibleColumn.minSize || 0;
+    const computedMaxWidth = computedVisible ? maxSizes[theComputedVisibleIndex] || 1e4 : colSizeForNonVisibleColumn.maxSize || 1e4;
+    const computedPinned = computedVisible ? getComputedPinned(id, columnPinning) : false;
+    const computedLast = computedVisible ? theComputedVisibleIndex === visibleColumnOrder.length - 1 : false;
     let computedVisibleIndexInCategory = computedVisibleIndex;
-    const computedPinningOffset = computedPinned === "start" ? computedPinnedStartColumnsWidth : computedPinned === "end" ? computedPinnedEndColumnsWidth : computedOffset - computedPinnedStartColumnsWidth;
+    const computedPinningOffset = computedVisible ? computedPinned === "start" ? computedPinnedStartColumnsWidth : computedPinned === "end" ? computedPinnedEndColumnsWidth : computedOffset - computedPinnedStartColumnsWidth : 0;
     if (computedPinned == "start") {
-      computedVisibleIndexInCategory = computedVisibleIndex;
+      computedVisibleIndexInCategory = computedVisible ? computedVisibleIndex : -1;
     } else if (computedPinned === "end") {
-      computedVisibleIndexInCategory = computedVisibleIndex - (computedPinnedStartColumns.length + computedUnpinnedColumns.length);
+      computedVisibleIndexInCategory = computedVisible ? computedVisibleIndex - (computedPinnedStartColumns.length + computedUnpinnedColumns.length) : -1;
     } else {
-      computedVisibleIndexInCategory = computedVisibleIndex - computedPinnedStartColumns.length;
+      computedVisibleIndexInCategory = computedVisible ? computedVisibleIndex - computedPinnedStartColumns.length : -1;
     }
-    const computedAbsoluteOffset = computedPinned === "start" || computedPinned === false ? computedOffset : firstPinnedEndAbsoluteOffset + computedPinnedEndColumnsWidth;
-    const computedFirstInCategory = computedPinned !== prevPinned;
-    const computedLastInCategory = computedLast || computedPinned !== getComputedPinned(nextColumnId, columnPinning);
+    const computedAbsoluteOffset = computedVisible ? computedPinned === "start" || computedPinned === false ? computedOffset : firstPinnedEndAbsoluteOffset + computedPinnedEndColumnsWidth : -1;
+    const computedFirstInCategory = computedVisible ? computedPinned !== prevPinned : false;
+    const computedLastInCategory = computedVisible ? computedLast || computedPinned !== getComputedPinned(nextColumnId, columnPinning) : false;
     const cssEllipsis = (_e = (_d = c.cssEllipsis) != null ? _d : colType.cssEllipsis) != null ? _e : columnCssEllipsis;
     const headerCssEllipsis = (_j = (_i = (_h = (_g = (_f = c.headerCssEllipsis) != null ? _f : colType.cssEllipsis) != null ? _g : c.cssEllipsis) != null ? _h : colType.headerCssEllipsis) != null ? _i : columnHeaderCssEllipsis) != null ? _j : cssEllipsis;
-    const computedFilterValue = filterValueRecord[id] || c.field ? filterValueRecord[c.field] || null : null;
+    const computedFilterValue = computedVisible ? filterValueRecord[id] || c.field ? filterValueRecord[c.field] || null : null : null;
     const computedFiltered = computedFilterValue != null;
     const computedFilterable = (_l = (_k = c.defaultFilterable) != null ? _k : colType.defaultFilterable) != null ? _l : true;
     const computedDataType = c.dataType || colType.dataType || (Array.isArray(c.type) ? c.type[0] : c.type) || "string";
@@ -11371,14 +11666,16 @@ var getComputedVisibleColumns = ({
     const field = (_m = c.field) != null ? _m : colType.field;
     const valueGetter = (_n = c.valueGetter) != null ? _n : colType.valueGetter;
     let sortableColumnOrType = (_o = c.sortable) != null ? _o : colType.sortable;
-    if (sortableColumnOrType == null) {
+    if (sortableColumnOrType == null && !c.groupByField) {
       if (field == null && valueGetter == null) {
         sortableColumnOrType = false;
       }
     }
     let computedSortable = (_p = sortableColumnOrType != null ? sortableColumnOrType : sortable) != null ? _p : true;
     const result2 = __spreadProps(__spreadValues({
+      colType,
       align: colType.align,
+      computedVisible,
       verticalAlign: colType.verticalAlign,
       defaultHiddenWhenGroupedBy: colType.defaultHiddenWhenGroupedBy,
       valueGetter,
@@ -11421,16 +11718,17 @@ var getComputedVisibleColumns = ({
       computedDraggable: (_u = (_t = c.draggable) != null ? _t : draggableColumns) != null ? _u : true,
       computedFirstInCategory,
       computedLastInCategory,
-      computedFirst: i === 0,
+      computedFirst: theComputedVisibleIndex === 0,
       computedLast,
       toggleSort: () => {
         const currentSortInfo = computedSortInfo;
         let newColumnSortInfo;
+        const field2 = result2.groupByField ? result2.groupByField : c.field;
         if (!currentSortInfo) {
           newColumnSortInfo = {
             dir: 1,
             id,
-            field: c.field,
+            field: field2,
             type: computedSortType
           };
         } else {
@@ -11442,8 +11740,8 @@ var getComputedVisibleColumns = ({
             });
           }
         }
-        if (c.field && newColumnSortInfo && !newColumnSortInfo.field) {
-          newColumnSortInfo.field = c.field;
+        if (field2 && newColumnSortInfo && !newColumnSortInfo.field) {
+          newColumnSortInfo.field = field2;
         }
         if (c.valueGetter && newColumnSortInfo && !newColumnSortInfo.valueGetter) {
           newColumnSortInfo.valueGetter = (data) => c.valueGetter({ data, field: c.field });
@@ -11470,22 +11768,34 @@ var getComputedVisibleColumns = ({
       id,
       header: (_x = (_w = (_v = c.header) != null ? _v : colType.header) != null ? _w : c.name) != null ? _x : c.field
     });
-    computedOffset += computedWidth;
-    computedVisibleColumnsMap.set(result2.id, result2);
-    computedVisibleColumns.push(result2);
-    if (computedPinned === "start") {
-      computedPinnedStartColumns.push(result2);
-      computedPinnedStartColumnsWidth += result2.computedWidth;
-    }
-    if (computedPinned === "end") {
-      computedPinnedEndColumns.push(result2);
-      computedPinnedEndColumnsWidth += result2.computedWidth;
-    }
-    if (!computedPinned) {
-      computedUnpinnedColumns.push(result2);
-      computedUnpinnedColumnsWidth += result2.computedWidth;
-    }
-    prevPinned = computedPinned;
+    if (computedVisible) {
+      computedOffset += computedWidth;
+      computedVisibleColumnsMap.set(result2.id, result2);
+      computedVisibleColumns[theComputedVisibleIndex] = result2;
+      if (computedPinned === "start") {
+        computedPinnedStartColumns.push(result2);
+        computedPinnedStartColumnsWidth += result2.computedWidth;
+      }
+      if (computedPinned === "end") {
+        computedPinnedEndColumns.push(result2);
+        computedPinnedEndColumnsWidth += result2.computedWidth;
+      }
+      if (!computedPinned) {
+        computedUnpinnedColumns.push(result2);
+        computedUnpinnedColumnsWidth += result2.computedWidth;
+      }
+      prevPinned = computedPinned;
+    }
+    if (result2.groupByField) {
+      groupColumns.push(result2);
+    }
+    computedColumnsMap.set(result2.id, result2);
+    if (result2.field && !result2.groupByField && !fieldsToColumn.has(result2.field)) {
+      fieldsToColumn.set(result2.field, result2);
+    }
+  });
+  groupColumns.forEach((col) => {
+    col.computedSortable = isGroupColumnSortable(col, computedColumnsMap);
   });
   const computedPinnedStartWidth = pinnedStartMaxWidth != null ? Math.min(pinnedStartMaxWidth, computedPinnedStartColumnsWidth) : computedPinnedStartColumnsWidth;
   const computedPinnedEndWidth = pinnedEndMaxWidth != null ? Math.min(pinnedEndMaxWidth, computedPinnedEndColumnsWidth) : computedPinnedEndColumnsWidth;
@@ -11501,12 +11811,14 @@ var getComputedVisibleColumns = ({
     computedPinnedEndOffset: computedPinnedStartColumnsWidth + computedUnpinnedColumnsWidth,
     computedUnpinnedColumns,
     computedVisibleColumns,
+    computedColumnsMap,
     computedVisibleColumnsMap,
     computedPinnedEndWidth,
     computedPinnedStartWidth,
     renderSelectionCheckBox: computedVisibleColumns.reduce((bool, c) => {
       return bool || !!c.renderSelectionCheckBox;
-    }, false)
+    }, false),
+    fieldsToColumn
   };
   return result;
 };
@@ -11568,7 +11880,9 @@ var useComputedVisibleColumns = ({
     computedPinnedEndOffset,
     computedPinnedEndWidth,
     computedPinnedStartWidth,
-    renderSelectionCheckBox
+    renderSelectionCheckBox,
+    computedColumnsMap,
+    fieldsToColumn
   } = (0, import_react41.useMemo)(() => {
     return getComputedVisibleColumns({
       columns,
@@ -11621,6 +11935,7 @@ var useComputedVisibleColumns = ({
   const result = {
     renderSelectionCheckBox,
     columns,
+    computedColumnsMap,
     computedPinnedEndWidth,
     computedPinnedStartWidth,
     computedRemainingSpace,
@@ -11634,7 +11949,8 @@ var useComputedVisibleColumns = ({
     computedUnpinnedColumns,
     computedVisibleColumns,
     computedVisibleColumnsMap,
-    computedColumnOrder
+    computedColumnOrder,
+    fieldsToColumn
   };
   return result;
 };
@@ -11728,7 +12044,9 @@ function useComputed() {
     computedRemainingSpace,
     computedPinnedStartWidth,
     computedPinnedEndWidth,
-    renderSelectionCheckBox
+    renderSelectionCheckBox,
+    computedColumnsMap,
+    fieldsToColumn
   } = useComputedVisibleColumns({
     columns,
     columnCssEllipsis: componentState.columnCssEllipsis,
@@ -11772,6 +12090,7 @@ function useComputed() {
     columnSize,
     rowspan,
     toggleGroupRow,
+    computedColumnsMap,
     renderSelectionCheckBox,
     computedPinnedStartOverflow,
     computedPinnedEndOverflow,
@@ -11789,7 +12108,8 @@ function useComputed() {
     computedPinnedEndColumnsWidth,
     computedUnpinnedColumnsWidth,
     computedUnpinnedOffset,
-    computedPinnedEndOffset
+    computedPinnedEndOffset,
+    fieldsToColumn
   };
 }
 
@@ -11955,7 +12275,7 @@ var useLicense = (licenseKey = "") => {
   const valid = (0, import_react44.useMemo)(() => {
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "0.4.3"
+      version: "0.4.6"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;
@@ -12135,6 +12455,7 @@ function initSetupState2() {
     onRowHeightCSSVarChange: buildSubscriptionCallback(),
     onColumnHeaderHeightCSSVarChange: buildSubscriptionCallback(),
     cellClick: buildSubscriptionCallback(),
+    cellMouseDown: buildSubscriptionCallback(),
     keyDown: buildSubscriptionCallback(),
     bodySize: {
       width: 0,
@@ -12149,6 +12470,7 @@ function initSetupState2() {
     focused: false,
     focusedWithin: false,
     columnsWhenGrouping: columnsGeneratedForGrouping,
+    columnVisibilityForGrouping: {},
     pinnedStartScrollListener: new ScrollListener(),
     pinnedEndScrollListener: new ScrollListener(),
     columnsWhenInlineGroupRenderStrategy: void 0
@@ -12189,6 +12511,7 @@ var forwardProps4 = (setupState) => {
     filterEditors: (filterEditors) => __spreadValues(__spreadValues({}, defaultFilterEditors), filterEditors),
     viewportReservedWidth: (viewportReservedWidth) => viewportReservedWidth != null ? viewportReservedWidth : 0,
     resizableColumns: (resizableColumns) => resizableColumns != null ? resizableColumns : true,
+    hideColumnWhenGrouped: (hideColumnWhenGrouped) => hideColumnWhenGrouped != null ? hideColumnWhenGrouped : false,
     columnMinWidth: (columnMinWidth) => columnMinWidth != null ? columnMinWidth : 30,
     columnMaxWidth: (columnMaxWidth) => columnMaxWidth != null ? columnMaxWidth : 5e3,
     columnDefaultWidth: (columnDefaultWidth) => columnDefaultWidth != null ? columnDefaultWidth : 200,
@@ -12265,6 +12588,7 @@ var mapPropsToState2 = (params) => {
     groupRenderStrategy,
     groupBy,
     computedColumns,
+    initialColumns: props.columns,
     keyboardNavigation: (_a = props.keyboardNavigation) != null ? _a : state.activeCellIndex != null ? "cell" : state.activeRowIndex != null ? "row" : "cell",
     columnHeaderCssEllipsis: (_c = (_b = props.columnHeaderCssEllipsis) != null ? _b : props.columnCssEllipsis) != null ? _c : true,
     columnGroupsDepthsMap,
@@ -12286,11 +12610,10 @@ function onCellClick(context, event) {
   updateRowSelectionOnCellClick(context, event);
 }
 function updateRowSelectionOnCellClick(context, event) {
-  const { rowIndex, getDataSourceState, getComputed, dataSourceActions } = context;
+  const { rowIndex, getDataSourceState, getComputed, dataSourceActions, api } = context;
   const { multiRowSelector, renderSelectionCheckBox } = getComputed();
   const dataSourceState = getDataSourceState();
-  const { selectionMode, groupBy } = dataSourceState;
-  let { rowSelection: rowSelectionState } = dataSourceState;
+  const { selectionMode, groupBy, dataArray } = dataSourceState;
   if (groupBy.length) {
     return false;
   }
@@ -12298,6 +12621,7 @@ function updateRowSelectionOnCellClick(context, event) {
     if (renderSelectionCheckBox && !event.key) {
       return false;
     }
+    let { rowSelection: rowSelectionState } = dataSourceState;
     rowSelectionState = new RowSelectionState(rowSelectionState, rowSelectionStateConfigGetter(getDataSourceState));
     multiRowSelector.rowSelectionState = rowSelectionState;
     if (rowSelectionState && typeof rowSelectionState === "object") {
@@ -12312,6 +12636,12 @@ function updateRowSelectionOnCellClick(context, event) {
       return true;
     }
   } else if (selectionMode === "single-row") {
+    const id = dataArray[rowIndex].id;
+    if (event.metaKey || event.ctrlKey) {
+      api.selectionApi.toggleRowSelection(id);
+    } else {
+      api.selectionApi.selectRow(id);
+    }
   }
   return false;
 }