@revolist/revogrid 4.27.0 → 4.27.2

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

@@ -5,7 +5,7 @@
 import { h } from "@stencil/core";
 import { BasePlugin } from "../base.plugin";
 import { FILTER_PROP, isFilterBtn } from "./filter.button";
-import { filterCoreFunctionsIndexedByType, filterNames, filterTypes, } from "./filter.indexed";
+import { filterCoreFunctionsIndexedByType, filterNames, filterTypeDefaults, filterTypes, } from "./filter.indexed";
 import { resolveBlankSemantics } from "./filter.blank";
 import { timeout } from "../../utils";
 import { ASYNC_FILTER_ROW_THRESHOLD, FILTER_CHUNK_SIZE, FILTER_TIME_BUDGET_MS, } from "./filter.constants";
@@ -30,6 +30,8 @@ export const FILTE_PANEL = 'revogr-filter-panel';
  *
  * @property {FilterLocalization|undefined} localization - translation for filter popup captions.
  *
+ * @property {boolean|undefined} defaultFilter - creates a draft condition when an empty filter panel opens. Defaults to true.
+ *
  * @property {boolean|undefined} disableDynamicFiltering - disables dynamic filtering. A way to apply filters on Save only.
  */
 /**
@@ -51,7 +53,7 @@ export class FilterPlugin extends BasePlugin {
          *    number: ['eqN', 'neqN', 'gt']
          *  }
          */
-        this.filterByType = Object.assign({}, filterTypes);
+        this.filterByType = Object.fromEntries(Object.entries(filterTypes).map(([type, filters]) => [type, [...filters]]));
         this.filterNameIndexByType = Object.assign({}, filterNames);
         this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
         this.filterProp = FILTER_PROP;
@@ -135,11 +137,16 @@ export class FilterPlugin extends BasePlugin {
         return null;
     }
     initConfig(config) {
-        var _a;
+        var _a, _b, _c, _d;
         this.config = config;
         this.allowDuplicateOperators = (_a = config.allowDuplicateOperators) !== null && _a !== void 0 ? _a : true;
         if (this.pop) {
             this.pop.allowDuplicateOperators = this.allowDuplicateOperators;
+            this.pop.disableDynamicFiltering =
+                (_b = config.disableDynamicFiltering) !== null && _b !== void 0 ? _b : false;
+            this.pop.closeOnOutsideClick =
+                (_c = config.closeFilterPanelOnOutsideClick) !== null && _c !== void 0 ? _c : true;
+            this.pop.filterCaptions = (_d = config.localization) === null || _d === void 0 ? void 0 : _d.captions;
         }
         if (config.multiFilterItems) {
             this.multiFilterItems = Object.assign({}, config.multiFilterItems);
@@ -228,11 +235,12 @@ export class FilterPlugin extends BasePlugin {
         }
         // filter button clicked, open filter dialog
         const buttonPos = (filterButton instanceof HTMLElement ? filterButton : el).getBoundingClientRect();
-        const data = Object.assign(Object.assign(Object.assign({}, e.detail), this.filterCollection[prop]), { x: buttonPos.x, y: buttonPos.y + buttonPos.height, anchorY: buttonPos.y, autoCorrect: true, filterTypes: this.getColumnFilter(e.detail.filter), filterItems: this.multiFilterItems, extraContent: this.extraHyperContent, extraBottomContent: this.extraBottomHyperContent });
+        const data = Object.assign(Object.assign(Object.assign({}, e.detail), this.filterCollection[prop]), { x: buttonPos.x, y: buttonPos.y + buttonPos.height, anchorY: buttonPos.y, autoCorrect: true, filterTypes: this.getColumnFilter(e.detail.filter), defaultFilterType: this.getDefaultFilter(e.detail.filter), showDefaultFilter: this.shouldShowDefaultFilter(e.detail.filter), filterItems: this.multiFilterItems, extraContent: this.extraHyperContent, extraBottomContent: this.extraBottomHyperContent });
         (_b = this.beforeshow) === null || _b === void 0 ? void 0 : _b.call(this, data);
         this.pop.show(data);
     }
-    getColumnFilter(type) {
+    getColumnFilter(config) {
+        const type = this.isColumnFilterOption(config) ? config.type : config;
         let filterType = 'string';
         if (!type) {
             return { [filterType]: this.filterByType[filterType] };
@@ -252,6 +260,41 @@ export class FilterPlugin extends BasePlugin {
         }
         return { [filterType]: this.filterByType[filterType] };
     }
+    /** Resolve the preferred operator against the column's available filters. */
+    getDefaultFilter(config) {
+        var _a;
+        const filters = this.getColumnFilter(config);
+        const availableFilters = Object.values(filters).flat();
+        const columnDefault = this.isColumnFilterOption(config)
+            ? config.default
+            : undefined;
+        if (typeof columnDefault === 'string' &&
+            availableFilters.includes(columnDefault)) {
+            return columnDefault;
+        }
+        const firstFamily = Object.keys(filters)[0];
+        const familyDefault = filterTypeDefaults[firstFamily];
+        if (familyDefault && ((_a = filters[firstFamily]) === null || _a === void 0 ? void 0 : _a.includes(familyDefault))) {
+            return familyDefault;
+        }
+        return availableFilters[0];
+    }
+    /** Resolve grid and column-level draft opt-outs. */
+    shouldShowDefaultFilter(config) {
+        var _a;
+        if (this.isColumnFilterOption(config)) {
+            if (config.default === false) {
+                return false;
+            }
+            if (typeof config.default === 'string') {
+                return true;
+            }
+        }
+        return ((_a = this.config) === null || _a === void 0 ? void 0 : _a.defaultFilter) !== false;
+    }
+    isColumnFilterOption(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
     isValidType(type) {
         return !!(typeof type === 'string' && this.filterByType[type]);
     }

package/dist/collection/plugins/filter/filter.style.css

@@ -112,15 +112,36 @@ revogr-filter-panel .filter-panel-dialog .filter-actions button {
   }
 }
 .rgHeaderCell:hover .rv-filter {
-  transition: opacity 267ms cubic-bezier(0.4, 0, 0.2, 1) 0ms, transform 178ms cubic-bezier(0.4, 0, 0.2, 1) 0ms;
+  transition: opacity 267ms cubic-bezier(0.4, 0, 0.2, 1) 0ms, width 267ms cubic-bezier(0.4, 0, 0.2, 1) 0ms, transform 178ms cubic-bezier(0.4, 0, 0.2, 1) 0ms;
 }
-.rgHeaderCell:hover .rv-filter,
+.rgHeaderCell:hover:has(.rv-filter) .header-content, .rgHeaderCell:focus-within:has(.rv-filter) .header-content, .rgHeaderCell:has(.rv-filter.active) .header-content {
+  margin-right: 24px;
+}
+.rgHeaderCell:hover:has(.rv-filter):has(.desc) .header-content, .rgHeaderCell:hover:has(.rv-filter):has(.asc) .header-content, .rgHeaderCell:focus-within:has(.rv-filter):has(.desc) .header-content, .rgHeaderCell:focus-within:has(.rv-filter):has(.asc) .header-content, .rgHeaderCell:has(.rv-filter.active):has(.desc) .header-content, .rgHeaderCell:has(.rv-filter.active):has(.asc) .header-content {
+  margin-right: 8px;
+  padding-right: 24px;
+}
+.rgHeaderCell:hover .rv-filter, .rgHeaderCell:focus-within .rv-filter,
 .rgHeaderCell .rv-filter.active {
   opacity: 1;
+  width: 24px;
+}
+@media (hover: none), (pointer: coarse) {
+  .rgHeaderCell:has(.rv-filter) .header-content {
+    margin-right: 24px;
+  }
+  .rgHeaderCell:has(.rv-filter):has(.desc) .header-content, .rgHeaderCell:has(.rv-filter):has(.asc) .header-content {
+    margin-right: 8px;
+    padding-right: 24px;
+  }
+  .rgHeaderCell .rv-filter {
+    opacity: 1;
+    width: 24px;
+  }
 }
 .rgHeaderCell .rv-filter {
   height: 24px;
-  width: 24px;
+  width: 0;
   background: none;
   border: 0;
   opacity: 0;
@@ -129,6 +150,7 @@ revogr-filter-panel .filter-panel-dialog .filter-actions button {
   border-radius: 4px;
   position: relative;
   z-index: 1;
+  padding: 0;
 }
 .rgHeaderCell .rv-filter.active {
   color: var(--rg-theme-filter-panel-icon-active);

package/dist/collection/plugins/groupingRow/grouping.const.js

@@ -12,4 +12,5 @@ export const GROUP_COLUMN_PROP = `${GRID_INTERNALS}-prop`;
 export const GROUP_ORIGINAL_INDEX = `${GRID_INTERNALS}-original-index`;
 export const GROUP_EXPAND_BTN = `group-expand`;
 export const GROUP_EXPAND_EVENT = `groupexpandclick`;
+export const BEFORE_GROUPING_APPLY_EVENT = `beforegroupingapply`;
 export const GROUPING_ROW_TYPE = 'rgRow';

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

@@ -1,26 +1,14 @@
 /*!
  * 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";
-import { SortingPlugin } from "../sorting/sorting.plugin";
-import { GROUP_EXPAND_EVENT, GROUPING_ROW_TYPE, PSEUDO_GROUP_COLUMN, } from "./grouping.const";
+import { SortingPlugin, hasActiveSorting } from "../sorting/sorting.plugin";
+import { BEFORE_GROUPING_APPLY_EVENT, GROUP_EXPAND_EVENT, GROUPING_ROW_TYPE, PSEUDO_GROUP_COLUMN, PSEUDO_GROUP_ITEM_ID, } from "./grouping.const";
 import { doExpand, doCollapse } from "./grouping.row.expand.service";
 import { gatherGrouping, getExpanded, getSource, isGrouping, isGroupingColumn, } from "./grouping.service";
-import { filterOutEmptyGroupRows, processDoubleConversionTrimmed, TRIMMED_GROUPING, } from "./grouping.trimmed.service";
+import { convertGroupingIndex, filterOutEmptyGroupRows, processDoubleConversionTrimmed, TRIMMED_GROUPING, } from "./grouping.trimmed.service";
 export * from './grouping.const';
 export * from './grouping.row.expand.service';
 export * from './grouping.row.types';
@@ -41,15 +29,16 @@ export class GroupingRowPlugin extends BasePlugin {
     }
     // expand event triggered
     onExpand({ virtualIndex }) {
-        const { source } = getSource(this.getStore().get('source'), this.getStore().get('proxyItems'));
-        let newTrimmed = this.getStore().get('trimmed')[TRIMMED_GROUPING];
-        let i = getPhysical(this.getStore(), virtualIndex);
+        const store = this.getStore();
+        const source = store.get('source');
+        let newTrimmed = store.get('trimmed')[TRIMMED_GROUPING];
+        const i = getPhysical(store, virtualIndex);
         const isExpanded = getExpanded(source[i]);
         if (!isExpanded) {
-            const { trimmed, items } = doExpand(virtualIndex, source, this.getStore().get('items'));
+            const { trimmed, items: expandedItems } = doExpand(virtualIndex, source, store.get('items'));
             newTrimmed = Object.assign(Object.assign({}, newTrimmed), trimmed);
-            if (items) {
-                setItems(this.getStore(), items);
+            if (expandedItems) {
+                setItems(store, expandedItems);
             }
         }
         else {
@@ -57,7 +46,7 @@ export class GroupingRowPlugin extends BasePlugin {
             newTrimmed = Object.assign(Object.assign({}, newTrimmed), trimmed);
             this.revogrid.clearFocus();
         }
-        this.getStore().set('source', source);
+        store.set('source', source);
         this.revogrid.addTrimmed(newTrimmed, TRIMMED_GROUPING);
     }
     setColumnGrouping(cols) {
@@ -79,7 +68,7 @@ export class GroupingRowPlugin extends BasePlugin {
     onDrag(e) {
         const { from, to } = e.detail;
         const isDown = to - from >= 0;
-        const { source } = getSource(this.getStore().get('source'), this.getStore().get('proxyItems'));
+        const source = this.getStore().get('source');
         const items = this.getStore().get('items');
         let i = isDown ? from : to;
         const end = isDown ? to : from;
@@ -105,21 +94,13 @@ export class GroupingRowPlugin extends BasePlugin {
         const source = this.getStore().get('source');
         return filterOutEmptyGroupRows(source, trimmed);
     }
-    isSortingRunning() {
-        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.
+     * Sorting changes proxy order without changing the physical source baseline.
+     * Other proxy changes, such as row dragging, are user-authored source order
+     * and must be retained when grouping is rebuilt.
      */
-    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;
+    isSortingActiveOrPending(sortingPlugin) {
+        return !!(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sortingPromise) || hasActiveSorting(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sorting);
     }
     /**
      * Starts global source update with group clearing and applying new one
@@ -132,7 +113,12 @@ export class GroupingRowPlugin extends BasePlugin {
          * @param newOldIndexMap - provides us mapping with new indexes vs old indexes, we would use it for trimmed mapping
          */
         const store = this.getStore();
-        const { source, prevExpanded, oldNewIndexes } = getSource(store.get('source'), store.get('proxyItems'), true);
+        const sortingPlugin = this.providers.plugins.getByClass(SortingPlugin);
+        const currentSource = store.get('source');
+        const sourceItems = this.isSortingActiveOrPending(sortingPlugin)
+            ? currentSource.map((_, index) => index)
+            : store.get('proxyItems');
+        const { source, prevExpanded, oldNewIndexes } = getSource(currentSource, sourceItems, true);
         const expanded = Object.assign({ prevExpanded }, options);
         /**
          * Group again
@@ -142,8 +128,13 @@ export class GroupingRowPlugin extends BasePlugin {
         const customRenderer = options === null || options === void 0 ? void 0 : options.groupLabelTemplate;
         const cellRenderer = options === null || options === void 0 ? void 0 : options.groupCellTemplate;
         // setup source
+        this.revogrid.dispatchEvent(new CustomEvent(BEFORE_GROUPING_APPLY_EVENT));
         this.providers.data.setData(sourceWithGroups, GROUPING_ROW_TYPE, this.revogrid.disableVirtualY, { depth, customRenderer, cellRenderer }, true);
+        this.remapRowDefinitions(oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, oldNewIndexMap, currentSource, sourceWithGroups);
         this.updateTrimmed(trimmed, oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, oldNewIndexMap, sourceWithGroups);
+        if (hasActiveSorting(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sorting)) {
+            sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.reapplySorting();
+        }
     }
     /**
      * Apply grouping on data set
@@ -152,9 +143,14 @@ export class GroupingRowPlugin extends BasePlugin {
      */
     onDataSet(data) {
         var _a, _b, _c;
+        const currentSource = this.getStore().get('source');
+        const sortingPlugin = this.providers.plugins.getByClass(SortingPlugin);
+        const currentItems = this.isSortingActiveOrPending(sortingPlugin)
+            ? currentSource.map((_, index) => index)
+            : this.getStore().get('proxyItems');
+        const { prevExpanded, oldNewIndexes } = getSource(currentSource, currentItems, true);
         let preservedExpanded = {};
         if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.preserveGroupingOnUpdate) !== false) {
-            let { prevExpanded } = getSource(this.getStore().get('source'), this.getStore().get('proxyItems'), true);
             preservedExpanded = prevExpanded;
         }
         const source = data.source.filter(s => !isGrouping(s));
@@ -166,6 +162,7 @@ export class GroupingRowPlugin extends BasePlugin {
             customRenderer: options.groupLabelTemplate,
             cellRenderer: options.groupCellTemplate,
         });
+        queueMicrotask(() => this.remapRowDefinitions(oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, oldNewIndexMap, currentSource, sourceWithGroups));
         this.updateTrimmed(trimmed, oldNewIndexMap, undefined, sourceWithGroups, { filterTrimmedMode: 'recompute-after-source-set' });
     }
     /**
@@ -201,10 +198,6 @@ 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) && ((_c = detail === null || detail === void 0 ? void 0 : detail.source) === null || _c === void 0 ? void 0 : _c.length))) {
                 return;
             }
-            // if sorting is running don't apply grouping, wait for sorting, then it'll apply in @aftersortingapply
-            if (this.isSortingRunning()) {
-                return;
-            }
             this.onDataSet(detail);
         });
         this.addEventListener('beforecolumnsset', ({ detail }) => {
@@ -219,17 +212,6 @@ export class GroupingRowPlugin extends BasePlugin {
         this.addEventListener('beforefiltertrimmed', ({ detail }) => {
             detail.itemsToFilter = this.beforeFilterTrimmed(detail.itemsToFilter);
         });
-        /**
-         * sorting applied need to clear grouping and apply again
-         * based on new results whole grouping order will changed
-         */
-        this.addEventListener('aftersortingapply', () => {
-            var _a, _b;
-            if (!((_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.props) === null || _b === void 0 ? void 0 : _b.length)) {
-                return;
-            }
-            this.doSourceUpdate(this.getCurrentExpandedOptions());
-        });
         /**
          * Apply logic for focus inside of grouping
          * We can't focus on grouping rows, navigation only inside of groups for now
@@ -262,9 +244,57 @@ export class GroupingRowPlugin extends BasePlugin {
             }
         });
         // clear rows
-        const { source, oldNewIndexes } = getSource(this.getStore().get('source'), this.getStore().get('proxyItems'), true);
+        const store = this.getStore();
+        const sortingPlugin = this.providers.plugins.getByClass(SortingPlugin);
+        const currentSource = store.get('source');
+        const sourceItems = this.isSortingActiveOrPending(sortingPlugin)
+            ? currentSource.map((_, index) => index)
+            : store.get('proxyItems');
+        const { source, oldNewIndexes } = getSource(currentSource, sourceItems, true);
+        this.revogrid.dispatchEvent(new CustomEvent(BEFORE_GROUPING_APPLY_EVENT));
         this.providers.data.setData(source, GROUPING_ROW_TYPE, this.revogrid.disableVirtualY, undefined, true);
+        this.remapRowDefinitions(oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, undefined, currentSource, source);
         this.updateTrimmed(undefined, undefined, oldNewIndexes, source);
+        if (hasActiveSorting(sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.sorting)) {
+            sortingPlugin === null || sortingPlugin === void 0 ? void 0 : sortingPlugin.reapplySorting();
+        }
+    }
+    remapRowDefinitions(firstLevelMap, secondLevelMap, previousSource, nextSource) {
+        const definitions = this.providers.dimension.getRowDefinitions();
+        const nextGroupIndexes = new Map();
+        nextSource === null || nextSource === void 0 ? void 0 : nextSource.forEach((row, index) => {
+            const groupId = row[PSEUDO_GROUP_ITEM_ID];
+            if (groupId && !nextGroupIndexes.has(groupId)) {
+                nextGroupIndexes.set(groupId, index);
+            }
+        });
+        let changed = false;
+        const remapped = definitions.flatMap(definition => {
+            if (definition.type !== GROUPING_ROW_TYPE) {
+                return [definition];
+            }
+            const previousRow = previousSource === null || previousSource === void 0 ? void 0 : previousSource[definition.index];
+            const groupId = previousRow === null || previousRow === void 0 ? void 0 : previousRow[PSEUDO_GROUP_ITEM_ID];
+            const index = groupId
+                ? nextGroupIndexes.get(groupId)
+                : convertGroupingIndex(definition.index, firstLevelMap, secondLevelMap);
+            if (typeof index !== 'number') {
+                changed = true;
+                return [];
+            }
+            if (index < 0) {
+                changed = true;
+                return [];
+            }
+            if (index === definition.index) {
+                return [definition];
+            }
+            changed = true;
+            return [Object.assign(Object.assign({}, definition), { index })];
+        });
+        if (changed) {
+            this.providers.dimension.setRowDefinitions(remapped);
+        }
     }
     updateTrimmed(trimmedGroup = {}, firstLevelMap = {}, secondLevelMap, source = this.getStore().get('source'), { filterTrimmedMode = 'remap', } = {}) {
         // map previously trimmed data

package/dist/collection/plugins/groupingRow/grouping.sorting.service.js

@@ -0,0 +1,58 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { GROUP_DEPTH } from "./grouping.const";
+import { isGrouping } from "./grouping.service";
+/**
+ * Restores group headers around already-sorted data indexes without rebuilding
+ * the physical source. Group insertion order follows the first sorted member,
+ * matching the order produced by regrouping a sorted source.
+ */
+export function gatherGroupedRowIndexes(source, sortedDataIndexes) {
+    const groupPathByDataIndex = new Map();
+    const currentGroupPath = [];
+    source.forEach((model, physicalIndex) => {
+        if (isGrouping(model)) {
+            const depth = model[GROUP_DEPTH];
+            if (typeof depth !== 'number') {
+                return;
+            }
+            currentGroupPath.length = depth;
+            currentGroupPath[depth] = physicalIndex;
+            return;
+        }
+        if (model != null) {
+            groupPathByDataIndex.set(physicalIndex, [...currentGroupPath]);
+        }
+    });
+    const root = {
+        children: new Map(),
+        items: [],
+    };
+    for (const physicalIndex of sortedDataIndexes) {
+        const groupPath = groupPathByDataIndex.get(physicalIndex);
+        if (!(groupPath === null || groupPath === void 0 ? void 0 : groupPath.length)) {
+            return undefined;
+        }
+        let node = root;
+        for (const groupIndex of groupPath) {
+            let child = node.children.get(groupIndex);
+            if (!child) {
+                child = { children: new Map(), items: [] };
+                node.children.set(groupIndex, child);
+            }
+            node = child;
+        }
+        node.items.push(physicalIndex);
+    }
+    const groupedIndexes = [];
+    const appendNode = (node) => {
+        node.children.forEach((child, groupIndex) => {
+            groupedIndexes.push(groupIndex);
+            appendNode(child);
+        });
+        groupedIndexes.push(...node.items);
+    };
+    appendNode(root);
+    return groupedIndexes;
+}

package/dist/collection/plugins/groupingRow/grouping.trimmed.service.js

@@ -13,8 +13,10 @@ export const TRIMMED_GROUPING = 'grouping';
  * against the grouped physical source can still be remapped. If neither path
  * resolves to a number, the caller drops the stale trim entry.
  */
-function convertTrimmedIndex(initialIndex, firstLevelMap, secondLevelMap) {
-    const sourceIndex = Number.parseInt(initialIndex, 10);
+export function convertGroupingIndex(initialIndex, firstLevelMap, secondLevelMap) {
+    const sourceIndex = typeof initialIndex === 'number'
+        ? initialIndex
+        : Number.parseInt(initialIndex, 10);
     const firstConversionIndex = firstLevelMap[sourceIndex];
     if (!secondLevelMap) {
         return firstConversionIndex;
@@ -47,7 +49,7 @@ export function processDoubleConversionTrimmed(initiallyTrimed, firstLevelMap, s
              * if item exists we find it in collection
              * we support 2 level of conversions
              */
-            const newConversionIndex = convertTrimmedIndex(initialIndex, firstLevelMap, secondLevelMap);
+            const newConversionIndex = convertGroupingIndex(initialIndex, firstLevelMap, secondLevelMap);
             // Group rows do not exist in the ungrouped index map and must not leak into new trims.
             if (typeof newConversionIndex !== 'number') {
                 continue;