@revolist/revogrid 4.22.0 → 4.23.0

package/dist/collection/components/overlay/selection.utils.js

@@ -49,8 +49,8 @@ export function getCurrentCell({ x, y }, { el, rows, cols }) {
         cellX = width - 1;
     }
     // Get the row and column items based on the cell position
-    const rgRow = getItemByPosition(rows, cellY);
-    const rgCol = getItemByPosition(cols, cellX);
+    const rgRow = getItemByPosition(rows, cellY + (rows.renderOffset || 0));
+    const rgCol = getItemByPosition(cols, cellX + (cols.renderOffset || 0));
     // Set the row and column index to 0 if they are before the first item
     if (rgCol.itemIndex < 0) {
         rgCol.itemIndex = 0;
@@ -120,10 +120,12 @@ export function styleByCellProps(styles) {
     };
 }
 export function getCell({ x, y, x1, y1 }, dimensionRow, dimensionCol) {
-    const top = getItemByIndex(dimensionRow, y).start;
-    const left = getItemByIndex(dimensionCol, x).start;
-    const bottom = getItemByIndex(dimensionRow, y1).end;
-    const right = getItemByIndex(dimensionCol, x1).end;
+    const rowOffset = dimensionRow.renderOffset || 0;
+    const colOffset = dimensionCol.renderOffset || 0;
+    const top = getItemByIndex(dimensionRow, y).start - rowOffset;
+    const left = getItemByIndex(dimensionCol, x).start - colOffset;
+    const bottom = getItemByIndex(dimensionRow, y1).end - rowOffset;
+    const right = getItemByIndex(dimensionCol, x1).end - colOffset;
     return {
         left,
         right,

package/dist/collection/components/revoGrid/revo-grid.js

@@ -626,12 +626,13 @@ export class RevoGridComponent {
             return;
         }
         const columns = this.columnProvider.setColumns(beforeApplyEvent.detail);
+        const order = {};
+        for (const prop of Object.keys(beforeApplyEvent.detail.sort)) {
+            order[prop] = beforeApplyEvent.detail.sort[prop].order;
+        }
         this.aftercolumnsset.emit({
             columns,
-            order: Object.entries(beforeApplyEvent.detail.sort).reduce((acc, [prop, column]) => {
-                acc[prop] = column.order;
-                return acc;
-            }, {}),
+            order,
         });
     }
     disableVirtualXChanged(newVal = false, prevVal = false) {
@@ -920,7 +921,7 @@ export class RevoGridComponent {
         if (Object.keys((_a = this.trimmedRows) !== null && _a !== void 0 ? _a : {}).length > 0) {
             this.trimmedRowsChanged(this.trimmedRows);
         }
-        this.rowDefChanged(this.rowDefinitions);
+        this.rowDefChanged(this.rowDefinitions, undefined, undefined, false);
         // init grouping
         if (this.grouping && Object.keys(this.grouping).length > 0) {
             this.groupingChanged(this.grouping);

package/dist/collection/components/revoGrid/viewport.service.js

@@ -108,7 +108,8 @@ export default class ViewportService {
         (_a = this.config.dimensionProvider) === null || _a === void 0 ? void 0 : _a.setCustomSizes(type, detail, true);
         // set resize event
         const changedItems = {};
-        for (const [i, size] of Object.entries(detail || {})) {
+        for (const i of Object.keys(detail || {})) {
+            const size = detail[i];
             const virtualIndex = parseInt(i, 10);
             const item = getSourceItem(store, virtualIndex);
             if (item) {

package/dist/collection/components/scroll/revogr-viewport-scroll.js

@@ -3,7 +3,7 @@
  */
 import { h, Host, } from "@stencil/core";
 import GridResizeService from "../revoGrid/viewport.resize.service";
-import LocalScrollService from "../../services/local.scroll.service";
+import LocalScrollService, { getContentSize } from "../../services/local.scroll.service";
 import { LocalScrollTimer } from "../../services/local.scroll.timer";
 import { CONTENT_SLOT, FOOTER_SLOT, HEADER_SLOT, } from "../revoGrid/viewport.helpers";
 /**
@@ -34,7 +34,7 @@ export class RevogrViewportScroll {
      * @param e
      */
     async changeScroll(e, silent = false) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (silent) {
             if (e.coordinate && this.verticalScroll) {
                 switch (e.dimension) {
@@ -47,15 +47,16 @@ export class RevogrViewportScroll {
             return;
         }
         if (e.delta) {
+            let currentPhysicalCoordinate = 0;
             switch (e.dimension) {
                 case 'rgCol':
-                    e.coordinate = this.horizontalScroll.scrollLeft + e.delta;
+                    currentPhysicalCoordinate = this.horizontalScroll.scrollLeft;
                     break;
                 case 'rgRow':
-                    e.coordinate = ((_b = (_a = this.verticalScroll) === null || _a === void 0 ? void 0 : _a.scrollTop) !== null && _b !== void 0 ? _b : 0) + e.delta;
+                    currentPhysicalCoordinate = (_b = (_a = this.verticalScroll) === null || _a === void 0 ? void 0 : _a.scrollTop) !== null && _b !== void 0 ? _b : 0;
                     break;
             }
-            this.setScroll(e);
+            return (_d = (_c = this.localScrollService) === null || _c === void 0 ? void 0 : _c.setScrollByDelta(e, currentPhysicalCoordinate)) !== null && _d !== void 0 ? _d : e;
         }
         return e;
     }
@@ -207,7 +208,10 @@ export class RevogrViewportScroll {
         this.setScrollVisibility('rgCol', this.horizontalScroll.clientWidth, this.contentWidth);
     }
     render() {
-        return (h(Host, { key: 'adc7378dba1794ca2ec263d52b09abefe50bcbfd', onWheel: this.horizontalMouseWheel, onScroll: (e) => this.applyScroll('rgCol', e) }, h("div", { key: '7b57a8a0ea44629fefcfe4d2cd77bf0f048d8e06', class: "inner-content-table", style: { width: `${this.contentWidth}px` } }, h("div", { key: 'cca3de158bc2a7f0651f578a281819be5698b257', class: "header-wrapper", ref: e => (this.header = e) }, h("slot", { key: '1d170147dabe034f2c35481a8e2fedd6de2b6aed', name: HEADER_SLOT })), h("div", { key: 'b6dd29a91bb1f380a83a035dfdb749ca669936f2', class: "vertical-inner", ref: el => (this.verticalScroll = el), onWheel: this.verticalMouseWheel, onScroll: (e) => this.applyScroll('rgRow', e) }, h("div", { key: '9bce27bf8ec4d3b679aa9a34eb6379a8c2d46cac', class: "content-wrapper", style: { height: `${this.contentHeight}px` } }, h("slot", { key: 'b44a082c9fbb948fd87bd235b4cd4356fd4a3536', name: CONTENT_SLOT }))), h("div", { key: '28c305ff6bc664f1d1bbb117e8b8565c8d4bb6b2', class: "footer-wrapper", ref: e => (this.footer = e) }, h("slot", { key: '96312fb7f18198fd1feb9dcc00c79cde74ba9c9f', name: FOOTER_SLOT })))));
+        var _a, _b, _c, _d;
+        const physicalContentHeight = getContentSize(this.contentHeight, (_b = (_a = this.verticalScroll) === null || _a === void 0 ? void 0 : _a.clientHeight) !== null && _b !== void 0 ? _b : 0);
+        const physicalContentWidth = getContentSize(this.contentWidth, (_d = (_c = this.horizontalScroll) === null || _c === void 0 ? void 0 : _c.clientWidth) !== null && _d !== void 0 ? _d : 0);
+        return (h(Host, { key: 'a0c47dede9d131dea8c8ca449e8a323f24d9b113', onWheel: this.horizontalMouseWheel, onScroll: (e) => this.applyScroll('rgCol', e) }, h("div", { key: '6c960e753ffe522ba4afb1c379264873b6c617f3', class: "inner-content-table", style: { width: `${physicalContentWidth}px` } }, h("div", { key: '1a6cbcbd3634e84756b54c8150aebd25c824e14a', class: "header-wrapper", ref: e => (this.header = e) }, h("slot", { key: 'e4202c687bc39b4f78f3ed9840e979b032f06af8', name: HEADER_SLOT })), h("div", { key: '651415b5b32e72735065b183317386a34042bb85', class: "vertical-inner", ref: el => (this.verticalScroll = el), onWheel: this.verticalMouseWheel, onScroll: (e) => this.applyScroll('rgRow', e) }, h("div", { key: 'e65623b78d80957d8676adb019618953ef267ec3', class: "content-wrapper", style: { height: `${physicalContentHeight}px` } }, h("slot", { key: '5af47b12ef1226587cf774233447b5252d65e836', name: CONTENT_SLOT }))), h("div", { key: 'cbc0fd64fbfb53d3b18e547bbe34e32b7bb9c043', class: "footer-wrapper", ref: e => (this.footer = e) }, h("slot", { key: 'a8e4bfaef400973121090bac3069eb85469a95f3', name: FOOTER_SLOT })))));
     }
     /**
      * Extra layer for scroll event monitoring, where MouseWheel event is not passing

package/dist/collection/components/scrollable/revogr-scroll-virtual.js

@@ -37,15 +37,9 @@ export class RevogrScrollVirtual {
      */
     async changeScroll(e) {
         if (e.delta) {
-            switch (e.dimension) {
-                case 'rgCol':
-                    e.coordinate = this.element.scrollLeft + e.delta;
-                    break;
-                case 'rgRow':
-                    e.coordinate = this.element.scrollTop + e.delta;
-                    break;
-            }
-            this.setScroll(e);
+            const scrollProperty = e.dimension === 'rgRow' ? 'scrollTop' : 'scrollLeft';
+            const currentPhysicalCoordinate = this.element[scrollProperty];
+            return this.localScrollService.setScrollByDelta(e, currentPhysicalCoordinate);
         }
         return e;
     }
@@ -108,7 +102,7 @@ export class RevogrScrollVirtual {
     }
     render() {
         const size = getContentSize(this.realSize, this.dimension === 'rgRow' ? this.element.clientHeight : this.element.clientWidth, this.clientSize);
-        return (h(Host, { key: '57f81ec9deb2395e96b283338c03b9ad44f1e929', onScroll: (e) => this.onScroll(e) }, h("div", { key: '1a8c869adab53b362c351dae8d53664f33c4212c', style: {
+        return (h(Host, { key: '7213817ef941eee4050b714266598ec0c2961ee9', onScroll: (e) => this.onScroll(e) }, h("div", { key: '501da49c63253ab943172494b9dbf5399be56cee', style: {
                 [this.dimension === 'rgRow' ? 'height' : 'width']: `${size}px`,
             } })));
     }

package/dist/collection/plugins/filter/filter.panel.js

@@ -250,7 +250,8 @@ export class FilterPanel {
         const options = [];
         const prop = this.changes.prop;
         const hidden = new Set();
-        Object.entries(this.filterItems).forEach(([_, values]) => {
+        Object.keys(this.filterItems).forEach((prop) => {
+            const values = this.filterItems[prop];
             values.forEach((filter) => {
                 if (filter.hidden) {
                     hidden.add(filter.type);

package/dist/collection/plugins/filter/filter.plugin.js

@@ -152,17 +152,24 @@ export class FilterPlugin extends BasePlugin {
             }
         }
         if (config.collection) {
-            const filtersWithFilterFunctionPresent = Object.entries(config.collection).filter(([, item]) => this.filterFunctionsIndexedByType[item.type]);
-            this.filterCollection = Object.fromEntries(filtersWithFilterFunctionPresent);
+            const filterCollection = {};
+            for (const prop of Object.keys(config.collection)) {
+                const item = config.collection[prop];
+                if (this.filterFunctionsIndexedByType[item.type]) {
+                    filterCollection[prop] = item;
+                }
+            }
+            this.filterCollection = filterCollection;
         }
         else {
             this.filterCollection = {};
         }
         if (config.localization) {
             if (config.localization.filterNames) {
-                Object.entries(config.localization.filterNames).forEach(([k, v]) => {
+                const filterNames = config.localization.filterNames;
+                Object.keys(filterNames).forEach((k) => {
                     if (this.filterNameIndexByType[k] != void 0) {
-                        this.filterNameIndexByType[k] = v;
+                        this.filterNameIndexByType[k] = filterNames[k];
                     }
                 });
             }

package/dist/collection/plugins/groupingRow/grouping.row.plugin.js

@@ -1,6 +1,18 @@
 /*!
  * Built by Revolist OU ❤️
  */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { getPhysical, setItems, columnTypes, } from "../../store/index";
 import { BasePlugin } from "../base.plugin";
 import { FILTER_TRIMMED_TYPE } from "../filter/filter.plugin";
@@ -97,6 +109,18 @@ export class GroupingRowPlugin extends BasePlugin {
         const sortingPlugin = this.providers.plugins.getByClass(SortingPlugin);
         return !!(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sortingPromise);
     }
+    /**
+     * Returns grouping options for regrouping that must preserve current UI state.
+     *
+     * `expandedAll` and config `prevExpanded` are initial/config instructions.
+     * Reusing them after sorting would reopen groups the user collapsed before
+     * sorting instead of using the current grouped source state.
+     */
+    getCurrentExpandedOptions() {
+        var _a;
+        const _b = (_a = this.options) !== null && _a !== void 0 ? _a : {}, { expandedAll: _expandedAll, prevExpanded: _prevExpanded } = _b, options = __rest(_b, ["expandedAll", "prevExpanded"]);
+        return options;
+    }
     /**
      * Starts global source update with group clearing and applying new one
      * Initiated when need to reapply grouping
@@ -199,7 +223,7 @@ export class GroupingRowPlugin extends BasePlugin {
             if (!((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.length)) {
                 return;
             }
-            this.doSourceUpdate(Object.assign({}, this.options));
+            this.doSourceUpdate(this.getCurrentExpandedOptions());
         });
         /**
          * Apply logic for focus inside of grouping

package/dist/collection/plugins/moveColumn/column.drag.plugin.js

@@ -13,11 +13,11 @@ import { dispatch } from "../dispatcher";
 import { ON_COLUMN_CLICK } from "../../components/header/header-cell-renderer";
 import { isColGrouping } from "../../utils/column.utils";
 const COLUMN_CLICK = ON_COLUMN_CLICK;
-const MOVE = 'columndragmousemove';
-const DRAG_END = 'columndragend';
-const BEFORE_DRAG_END = 'beforecolumndragend';
+export const COLUMN_DRAG_MOVE_EVENT = 'columndragmousemove';
+export const COLUMN_DRAG_END_EVENT = 'columndragend';
+export const BEFORE_COLUMN_DRAG_END_EVENT = 'beforecolumndragend';
 // use this event subscription to drop D&D for particular columns
-const DRAG_START = 'columndragstart';
+export const COLUMN_DRAG_START_EVENT = 'columndragstart';
 export class ColumnMovePlugin extends BasePlugin {
     constructor(revogrid, providers) {
         super(revogrid, providers);
@@ -47,7 +47,7 @@ export class ColumnMovePlugin extends BasePlugin {
         if (event.defaultPrevented) {
             return;
         }
-        const { defaultPrevented } = dispatch(this.revogrid, DRAG_START, data);
+        const { defaultPrevented } = dispatch(this.revogrid, COLUMN_DRAG_START_EVENT, data);
         // check if allowed to drag particulat column
         if (defaultPrevented) {
             return;
@@ -68,7 +68,7 @@ export class ColumnMovePlugin extends BasePlugin {
         const cols = this.getDimension(data.pin || 'rgCol');
         const gridRect = this.revogrid.getBoundingClientRect();
         const elRect = dataEl.getBoundingClientRect();
-        const startItem = getItemByPosition(cols, getLeftRelative(event.x, gridRect.left, elRect.left - gridRect.left));
+        const startItem = getItemByPosition(cols, getLeftRelative(event.x, gridRect.left, elRect.left - gridRect.left) + (cols.renderOffset || 0));
         this.staticDragData = {
             startPos: event.x,
             startItem,
@@ -78,7 +78,7 @@ export class ColumnMovePlugin extends BasePlugin {
             gridEl: this.revogrid,
             cols,
         };
-        this.dragData = this.getData(this.staticDragData);
+        this.dragData = this.getData(this.staticDragData, []);
         mousemove.target.addEventListener('mousemove', mousemove.callback);
         this.orderUi.start(event, Object.assign(Object.assign({}, this.dragData), this.staticDragData));
     }
@@ -86,24 +86,24 @@ export class ColumnMovePlugin extends BasePlugin {
         if (!this.staticDragData) {
             return;
         }
-        const dragData = (this.dragData = this.getData(this.staticDragData));
+        const dragData = (this.dragData = this.getData(this.staticDragData, []));
         if (!dragData) {
             return;
         }
         const start = this.staticDragData.startPos;
         if (Math.abs(start - e.x) > 10) {
             const x = getLeftRelative(e.x, this.dragData.gridRect.left, this.dragData.scrollOffset);
-            const rgCol = getItemByPosition(this.staticDragData.cols, x);
+            const rgCol = getItemByPosition(this.staticDragData.cols, x + (this.staticDragData.cols.renderOffset || 0));
             this.orderUi.autoscroll(x, dragData.elRect.width);
             // prevent position change if out of bounds
             if (rgCol.itemIndex >= this.staticDragData.cols.count) {
                 return;
             }
-            this.orderUi.showHandler(rgCol.end + dragData.scrollOffset, dragData.gridRect.width);
+            this.orderUi.showHandler(rgCol.end - (this.staticDragData.cols.renderOffset || 0) + dragData.scrollOffset, dragData.gridRect.width);
         }
     }
     move(e) {
-        dispatch(this.revogrid, MOVE, e);
+        dispatch(this.revogrid, COLUMN_DRAG_MOVE_EVENT, e);
         // then do move
         this.moveFunc(e);
     }
@@ -117,11 +117,12 @@ export class ColumnMovePlugin extends BasePlugin {
             if (relativePos < 0) {
                 relativePos = 0;
             }
-            const newPosition = getItemByPosition(this.staticDragData.cols, relativePos);
+            const newPosition = getItemByPosition(this.staticDragData.cols, relativePos + (this.staticDragData.cols.renderOffset || 0));
             const store = this.providers.column.stores[this.dragData.type].store;
+            const source = store.get('source');
             const newItems = [...store.get('items')];
             // prevent position change if needed
-            const { defaultPrevented: stopDrag } = dispatch(this.revogrid, BEFORE_DRAG_END, Object.assign(Object.assign({}, this.staticDragData), { startPosition: this.staticDragData.startItem, newPosition, newItem: store.get('source')[newItems[this.staticDragData.startItem.itemIndex]] }));
+            const { defaultPrevented: stopDrag } = dispatch(this.revogrid, BEFORE_COLUMN_DRAG_END_EVENT, Object.assign(Object.assign({}, this.staticDragData), { startPosition: this.staticDragData.startItem, newPosition, newItem: source[newItems[this.staticDragData.startItem.itemIndex]] }));
             if (!stopDrag) {
                 const prevItems = [...newItems];
                 // todo: if move item out of group remove item from group
@@ -130,7 +131,7 @@ export class ColumnMovePlugin extends BasePlugin {
                 store.set('items', newItems);
                 this.providers.dimension.updateSizesPositionByNewDataIndexes(this.dragData.type, newItems, prevItems);
             }
-            dispatch(this.revogrid, DRAG_END, this.dragData);
+            dispatch(this.revogrid, COLUMN_DRAG_END_EVENT, this.getData(this.staticDragData, newItems, source));
         }
         this.clearOrder();
     }
@@ -150,13 +151,15 @@ export class ColumnMovePlugin extends BasePlugin {
         super.clearSubscriptions();
         this.clearLocalSubscriptions();
     }
-    getData({ gridEl, dataEl, pin, }) {
+    getData({ gridEl, dataEl, pin }, order, source = []) {
         const gridRect = gridEl.getBoundingClientRect();
         const elRect = dataEl.getBoundingClientRect();
         const scrollOffset = elRect.left - gridRect.left;
         return {
+            columns: order.map(index => source[index]).filter(Boolean),
             elRect,
             gridRect,
+            order,
             type: pin || 'rgCol',
             scrollOffset,
         };

package/dist/collection/plugins/sorting/sorting.func.js

@@ -1,13 +1,177 @@
 /*!
  * Built by Revolist OU ❤️
  */
+import { GROUP_COLUMN_PROP } from "../groupingRow/grouping.const";
 import { isGrouping } from "../groupingRow/grouping.service";
 import { getCellRaw } from "../../utils/column.utils";
-export function sortIndexByItems(indexes, source, sortingFunc = {}) {
+/**
+ * Checks whether a sorting map contains at least one active order.
+ *
+ * Empty maps and properties with `undefined` order are treated as inactive.
+ */
+export function hasActiveSorting(sorting) {
+    for (const prop of Object.keys(sorting || {})) {
+        if (sorting === null || sorting === void 0 ? void 0 : sorting[prop]) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Compares column properties after object-key coercion.
+ */
+function isSameColumnProp(a, b) {
+    return String(a) === String(b);
+}
+/**
+ * Returns active sorting properties in explicit priority order.
+ */
+function getActiveSortingProps(sorting, sortingOrder) {
+    const activeProps = [];
+    const add = (prop) => {
+        if ((sorting === null || sorting === void 0 ? void 0 : sorting[prop]) && !activeProps.some(active => isSameColumnProp(active, prop))) {
+            activeProps.push(prop);
+        }
+    };
+    sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+    Object.keys(sorting || {}).forEach(add);
+    return activeProps;
+}
+/**
+ * Returns one-based additive sorting rank for a column.
+ *
+ * A single active sort does not need a visible rank, so it returns undefined.
+ */
+export function getSortingIndex(sorting, prop, sortingOrder) {
+    const activeProps = getActiveSortingProps(sorting, sortingOrder);
+    if (activeProps.length <= 1) {
+        return undefined;
+    }
+    const index = activeProps.findIndex(active => isSameColumnProp(active, prop));
+    return index >= 0 ? index + 1 : undefined;
+}
+/**
+ * Collects only active comparator functions from a sorting function map.
+ *
+ * This keeps undefined comparator entries from triggering sorting work.
+ */
+function activeSortingEntries(sortingFunc = {}, sortingOrder) {
+    const entries = [];
+    const add = (prop) => {
+        const cmp = sortingFunc[prop];
+        if (typeof cmp === 'function' && !entries.some(([active]) => isSameColumnProp(active, prop))) {
+            entries.push([prop, cmp]);
+        }
+    };
+    sortingOrder === null || sortingOrder === void 0 ? void 0 : sortingOrder.forEach(add);
+    Object.keys(sortingFunc).forEach(add);
+    return entries;
+}
+/**
+ * Reads and normalizes a value for the built-in default comparer.
+ */
+function getDefaultCompareValue(item, prop, column) {
+    const aRaw = column ? getCellRaw(item, column) : item === null || item === void 0 ? void 0 : item[prop];
+    return typeof aRaw === 'number' ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
+}
+function isEmptyCompareValue(value) {
+    return value === '' || value === null || value === undefined;
+}
+/**
+ * Compares two already-normalized default comparer values.
+ */
+function compareValues(av, bv) {
+    if (av === bv) {
+        return 0;
+    }
+    const aEmpty = isEmptyCompareValue(av);
+    const bEmpty = isEmptyCompareValue(bv);
+    if (aEmpty || bEmpty) {
+        if (aEmpty && bEmpty) {
+            return 0;
+        }
+        return aEmpty ? -1 : 1;
+    }
+    if (av > bv) {
+        return 1;
+    }
+    return -1;
+}
+/**
+ * Sorts indexes by precomputed values for default column comparers.
+ *
+ * This avoids repeatedly parsing the same cell value during large default
+ * sorts while preserving normal multi-column ordering.
+ */
+function sortIndexByDefaultComparers(indexes, source, entries, sorting, sortingColumns) {
+    const prepared = entries.map(([prop]) => {
+        const values = [];
+        const column = sortingColumns[prop];
+        for (const index of indexes) {
+            values[index] = getDefaultCompareValue(source[index], prop, column);
+        }
+        return {
+            order: sorting[prop],
+            values,
+        };
+    });
+    return indexes.sort((a, b) => {
+        for (const { order, values } of prepared) {
+            const sorted = compareValues(values[a], values[b]);
+            if (sorted) {
+                return order === 'desc' ? -sorted : sorted;
+            }
+        }
+        return 0;
+    });
+}
+/**
+ * Detects whether the optimized default-comparer path can be used.
+ *
+ * Grouped rows and custom `cellCompare` functions stay on the legacy
+ * comparator path to preserve their exact behavior.
+ */
+function canUseDefaultCompareFastPath(entries, indexes, source, sorting, sortingColumns) {
+    return !indexes.some(index => isGrouping(source[index])) && !!sorting && !!sortingColumns && entries.every(([prop]) => {
+        const order = sorting[prop];
+        const column = sortingColumns[prop];
+        return !!order && !(column === null || column === void 0 ? void 0 : column.cellCompare);
+    });
+}
+/**
+ * Group placeholder rows are generated for their grouping column. If sorting is
+ * requested for another column, the grouped source must be unwrapped first.
+ */
+function hasGroupingRowsForOtherSorting(entries, indexes, source) {
+    return indexes.some(index => {
+        const item = source[index];
+        return isGrouping(item) && !entries.some(([prop]) => isSameColumnProp(item[GROUP_COLUMN_PROP], prop));
+    });
+}
+/**
+ * Sorts row indexes against a source collection.
+ *
+ * @param indexes - Current proxy row indexes to sort.
+ * @param source - Full source collection addressed by the indexes.
+ * @param sortingFunc - Comparator functions by column property.
+ * @param sorting - Active sorting order by column property.
+ * @param sortingColumns - Column metadata by property for default-comparer optimization.
+ * @param sortingOrder - Active sorting priority in click/config insertion order.
+ * @returns Sorted proxy indexes. With no sorting function keys, returns source-order indexes.
+ */
+export function sortIndexByItems(indexes, source, sortingFunc = {}, sorting, sortingColumns, sortingOrder) {
+    const hasSortingKeys = Object.keys(sortingFunc).length > 0;
+    const sortingEntries = activeSortingEntries(sortingFunc, sortingOrder);
     // if no sorting - return unsorted indexes
-    if (Object.entries(sortingFunc).length === 0) {
+    if (sortingEntries.length === 0) {
         // Unsorted indexes
-        return [...Array(indexes.length).keys()];
+        return hasSortingKeys ? indexes : [...new Array(indexes.length).keys()];
+    }
+    if (hasGroupingRowsForOtherSorting(sortingEntries, indexes, source)) {
+        return indexes;
+    }
+    if (canUseDefaultCompareFastPath(sortingEntries, indexes, source, sorting, sortingColumns)) {
+        return sortIndexByDefaultComparers(indexes, source, sortingEntries, sorting, sortingColumns);
     }
     //
     /**
@@ -17,15 +181,15 @@ export function sortIndexByItems(indexes, source, sortingFunc = {}) {
     return indexes.sort((a, b) => {
         const itemA = source[a];
         const itemB = source[b];
-        for (const [prop, cmp] of Object.entries(sortingFunc)) {
+        for (const [prop, cmp] of sortingEntries) {
             if (isGrouping(itemA)) {
-                if (itemA['__rvgr-prop'] !== prop) {
-                    return 0;
+                if (!isSameColumnProp(itemA[GROUP_COLUMN_PROP], prop)) {
+                    return a - b;
                 }
             }
             if (isGrouping(itemB)) {
-                if (itemB['__rvgr-prop'] !== prop) {
-                    return 0;
+                if (!isSameColumnProp(itemB[GROUP_COLUMN_PROP], prop)) {
+                    return a - b;
                 }
             }
             /**
@@ -45,13 +209,7 @@ export function defaultCellCompare(prop, a, b) {
     const bRaw = this.column ? getCellRaw(b, this.column) : b === null || b === void 0 ? void 0 : b[prop];
     const av = typeof aRaw === 'number' ? aRaw : aRaw === null || aRaw === void 0 ? void 0 : aRaw.toString().toLowerCase();
     const bv = typeof bRaw === 'number' ? bRaw : bRaw === null || bRaw === void 0 ? void 0 : bRaw.toString().toLowerCase();
-    if (av === bv) {
-        return 0;
-    }
-    if (av > bv) {
-        return 1;
-    }
-    return -1;
+    return compareValues(av, bv);
 }
 export function descCellCompare(cmp) {
     return (prop, a, b) => {