@revolist/revogrid 4.27.0 → 4.27.1

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

@@ -21,7 +21,7 @@ import GridScrollingService from "./viewport.scrolling.service";
 import { SelectionStoreConnector } from "../../services/selection.store.connector";
 import OrderRenderer from "../order/order-renderer";
 import { StretchColumn, isStretchPlugin, } from "../../plugins/column.stretch.plugin";
-import { rowDefinitionByType, rowDefinitionRemoveByType } from "./grid.helpers";
+import { rowDefinitionByType } from "./grid.helpers";
 import { ColumnMovePlugin } from "../../plugins/moveColumn/column.drag.plugin";
 import { getPropertyFromEvent } from "../../utils/events";
 import { isMobileDevice } from "../../utils/mobile";
@@ -857,29 +857,31 @@ export class RevoGridComponent {
             vals: after,
             oldVals: before,
         });
-        // apply new values
+        this.dimensionProvider.syncRowDefinitions(newVal);
         const newRows = rowDefinitionByType(newVal);
-        // clear current defs
-        if (oldVal) {
-            const remove = rowDefinitionRemoveByType(oldVal);
-            // clear all old data and drop sizes
-            for (const t in remove) {
-                if (remove.hasOwnProperty(t)) {
-                    const type = t;
-                    const store = this.dataProvider.stores[type];
-                    const sourceLength = store.store.get('source').length;
-                    this.dimensionProvider.clearSize(type, sourceLength);
-                }
-            }
-        }
-        // set new sizes
+        const oldRows = rowDefinitionByType(oldVal);
+        const dataProvider = this.dataProvider;
+        const dimensionProvider = this.dimensionProvider;
         rowTypes.forEach((t) => {
-            var _a;
             const newSizes = newRows[t];
-            // apply new sizes or force update
-            if (newSizes || forceUpdate) {
-                (_a = this.dimensionProvider) === null || _a === void 0 ? void 0 : _a.setCustomSizes(t, (newSizes === null || newSizes === void 0 ? void 0 : newSizes.sizes) || {});
+            const oldSizes = oldRows[t];
+            if (!newSizes && !oldSizes && !forceUpdate) {
+                return;
             }
+            const sizes = Object.assign({}, dimensionProvider.stores[t].store.get('sizes'));
+            const definitionSizes = (newSizes === null || newSizes === void 0 ? void 0 : newSizes.sizes) || {};
+            const previousDefinitionSizes = (oldSizes === null || oldSizes === void 0 ? void 0 : oldSizes.sizes) || {};
+            const items = dataProvider.stores[t].store.get('items');
+            items.forEach((physicalIndex, virtualIndex) => {
+                if (Object.hasOwn(previousDefinitionSizes, physicalIndex) &&
+                    sizes[virtualIndex] === previousDefinitionSizes[physicalIndex]) {
+                    delete sizes[virtualIndex];
+                }
+                if (Object.hasOwn(definitionSizes, physicalIndex)) {
+                    sizes[virtualIndex] = definitionSizes[physicalIndex];
+                }
+            });
+            dimensionProvider.setCustomSizes(t, sizes);
         });
     }
     trimmedRowsChanged(newVal = {}) {
@@ -928,6 +930,9 @@ export class RevoGridComponent {
     rowHeadersChange(rowHeaders) {
         this.rowheaderschanged.emit(rowHeaders);
     }
+    resizeRowChanged() {
+        this.syncRowResizeConfig();
+    }
     /**
      * Register external VNodes
      */
@@ -950,6 +955,7 @@ export class RevoGridComponent {
      */
     pluginsChanged(plugins = [], prevPlugins) {
         this.pluginService.addUserPluginsAndCreate(this.element, plugins, prevPlugins, this.getPluginData());
+        this.syncRowResizeConfig();
     }
     // #endregion
     // #region Plugins
@@ -990,11 +996,15 @@ export class RevoGridComponent {
         this.pluginService.add(new SortingPlugin(this.element, pluginData));
         // register grouping plugin
         this.pluginService.add(new GroupingRowPlugin(this.element, pluginData));
-        this.pluginService.add(RowResizePlugin.fromGridProperty(this.element, pluginData));
+        this.pluginService.add(new RowResizePlugin(this.element, pluginData));
         if (this.canMoveColumns) {
             this.pluginService.add(new ColumnMovePlugin(this.element, pluginData));
         }
     }
+    syncRowResizeConfig() {
+        const plugin = this.pluginService.getByClass(RowResizePlugin);
+        plugin === null || plugin === void 0 ? void 0 : plugin.syncGridConfig();
+    }
     getPluginData() {
         if (!this.dimensionProvider || !this.dataProvider || !this.columnProvider || !this.viewportProvider || !this.selectionStoreConnector) {
             return;
@@ -1037,6 +1047,9 @@ export class RevoGridComponent {
         this.themeService.setDefinitions(this.themeDefinitions);
         this.dimensionProvider = new DimensionProvider(this.viewportProvider, {
             realSizeChanged: (k) => this.contentsizechanged.emit(k),
+            rowDefinitionsChanged: definitions => {
+                this.rowDefinitions = definitions;
+            },
         });
         this.dimensionProvider.setSettings({ originItemSize: getColumnSize(this.colSize) }, 'rgCol');
         this.columnProvider = new ColumnDataProvider();
@@ -3873,6 +3886,9 @@ export class RevoGridComponent {
             }, {
                 "propName": "rowHeaders",
                 "methodName": "rowHeadersChange"
+            }, {
+                "propName": "resizeRow",
+                "methodName": "resizeRowChanged"
             }, {
                 "propName": "registerVNode",
                 "methodName": "registerOutsideVNodes"

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;