@revolist/revogrid 4.27.0 → 4.27.2

package/dist/esm/{row-resize.plugin-BRiaHlHA.js → row-resize.plugin-Beu0pMds.js}

@@ -1,14 +1,14 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { J as reduce, g as getRange, K as baseEach, C as getColumnType, c as columnTypes, L as toInteger, u as isGrouping, t as getGroupingName, r as rowTypes, A as getCellRaw, j as GROUP_COLUMN_PROP, I as getColumnByProp, h as GROUP_EXPANDED, x as getParsedGroup, y as isSameGroup, G as GROUP_DEPTH, e as PSEUDO_GROUP_ITEM_VALUE, d as PSEUDO_GROUP_ITEM_ID, o as GROUPING_ROW_TYPE, p as getSource, f as PSEUDO_GROUP_COLUMN, s as gatherGrouping, m as GROUP_EXPAND_EVENT, v as isGroupingColumn, q as getExpanded, E as isColGrouping } from './column.service-CM-wgGs8.js';
+import { K as reduce, g as getRange, L as baseEach, D as getColumnType, c as columnTypes, M as toInteger, u as isGrouping, t as getGroupingName, r as rowTypes, G as GROUP_DEPTH, A as getCellRaw, j as GROUP_COLUMN_PROP, J as getColumnByProp, h as GROUP_EXPANDED, x as getParsedGroup, y as isSameGroup, e as PSEUDO_GROUP_ITEM_VALUE, d as PSEUDO_GROUP_ITEM_ID, o as GROUPING_ROW_TYPE, f as PSEUDO_GROUP_COLUMN, p as getSource, s as gatherGrouping, B as BEFORE_GROUPING_APPLY_EVENT, m as GROUP_EXPAND_EVENT, v as isGroupingColumn, q as getExpanded, F as isColGrouping } from './column.service-pu_fdQ0S.js';
 import { L as createStore, m as setStore, j as calculateDimensionData, N as identity, O as isArray, b as getSourceItem, g as getPhysical, e as setItems, k as getItemByPosition, l as getItemByIndex } from './dimension.helpers-Cln9sALu.js';
-import { j as calculateRowHeaderSize } from './viewport.store-DWMKRDSH.js';
+import { j as calculateRowHeaderSize, g as getViewportMaxCoordinate } from './viewport.store-DWMKRDSH.js';
 import { g as getScrollbarSize, t as timeout } from './index-BvMNbQyq.js';
 import { h } from './index-CtimkLsB.js';
-import { b as FILTER_PROP, i as isFilterBtn } from './filter.button-DMhpuAiw.js';
+import { b as FILTER_PROP, i as isFilterBtn } from './filter.button-CEPUxLUo.js';
 import { d as debounce } from './debounce-PCRWZliA.js';
-import { O as ON_COLUMN_CLICK, d as dispatch } from './header-cell-renderer-Bqh1PrgH.js';
+import { O as ON_COLUMN_CLICK, d as dispatch } from './header-cell-renderer-YCiVIQ2E.js';
 
 /**
  * Public theme tokens and their CSS custom-property counterparts.
@@ -1361,6 +1361,11 @@ const filterTypes = {
     boolean: ['notEmpty', 'empty'],
     array: ['notEmpty', 'empty'],
 };
+/** Preferred initial operator for built-in filter families. */
+const filterTypeDefaults = {
+    string: 'contains',
+    number: 'eqN',
+};
 const filterNames = {
     none: 'None',
     empty: 'Is blank',
@@ -1403,6 +1408,8 @@ 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.
  */
 /**
@@ -1424,7 +1431,7 @@ 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;
@@ -1508,11 +1515,16 @@ 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);
@@ -1601,11 +1613,12 @@ 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] };
@@ -1625,6 +1638,41 @@ 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]);
     }
@@ -1907,6 +1955,60 @@ function allAndConditionsSatisfied(pendingResults) {
     return !pendingResults.includes(true);
 }
 
+/**
+ * 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.
+ */
+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;
+}
+
 /**
  * Checks whether a sorting map contains at least one active order.
  *
@@ -2144,18 +2246,6 @@ function getComparer(column, order) {
 function getSortableRowIndexes(indexes, source) {
     return indexes.filter(index => !isGrouping(source[index]));
 }
-function mergeSortedRowsWithGroups(indexes, source, sortedRows) {
-    if (sortedRows.length === indexes.length) {
-        return sortedRows;
-    }
-    let rowIndex = 0;
-    return indexes.map(index => {
-        if (isGrouping(source[index])) {
-            return index;
-        }
-        return sortedRows[rowIndex++];
-    });
-}
 /**
  * Lifecycle
  * 1. @event `beforesorting` - Triggered when sorting just starts. Nothing has happened yet. This can be triggered from a column or from the source. If the type is from rows, the column will be undefined.
@@ -2315,6 +2405,7 @@ class SortingPlugin extends BasePlugin {
         storeService.setData({ proxyItems: newItemsOrder });
     }
     applySortingForStore(type, sorting, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate) {
+        var _a;
         const storeService = this.providers.data.stores[type];
         // row data
         const source = storeService.store.get('source');
@@ -2322,7 +2413,10 @@ class SortingPlugin extends BasePlugin {
         const proxyItems = storeService.store.get('proxyItems');
         const sortItems = getSortableRowIndexes(proxyItems, source);
         const sortedItems = sortIndexByItems([...sortItems], source, sortingFunc, sorting, sortingColumns, sortingOrder);
-        const newItemsOrder = mergeSortedRowsWithGroups(proxyItems, source, sortedItems);
+        const hasGroupingRows = sortedItems.length !== proxyItems.length;
+        const newItemsOrder = hasGroupingRows
+            ? (_a = gatherGroupedRowIndexes(source, sortedItems)) !== null && _a !== void 0 ? _a : proxyItems
+            : sortedItems;
         // take row indexes before trim applied and proxy items
         const prevItems = storeService.store.get('items');
         storeService.setData({
@@ -2348,6 +2442,16 @@ class SortingPlugin extends BasePlugin {
         }
         this.postponeSort(order, sortingFunc, sortingColumns, sortingOrder, ignoreViewportUpdate);
     }
+    /**
+     * Schedules the current active sort again after another plugin rebuilds row
+     * proxy indexes while keeping the physical source unchanged.
+     */
+    reapplySorting() {
+        if (!hasActiveSorting(this.sorting) || !this.sortingFunc) {
+            return;
+        }
+        this.startSorting(this.sorting, this.sortingFunc, this.sortingColumns, this.sortingOrder);
+    }
     /**
      * Applies sorting requested by a sortable header click.
      *
@@ -2531,8 +2635,10 @@ 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);
+function convertGroupingIndex(initialIndex, firstLevelMap, secondLevelMap) {
+    const sourceIndex = typeof initialIndex === 'number'
+        ? initialIndex
+        : Number.parseInt(initialIndex, 10);
     const firstConversionIndex = firstLevelMap[sourceIndex];
     if (!secondLevelMap) {
         return firstConversionIndex;
@@ -2565,7 +2671,7 @@ function processDoubleConversionTrimmed(initiallyTrimed, firstLevelMap, secondLe
              * 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;
@@ -2626,18 +2732,6 @@ function filterOutEmptyGroupRows(source, filterTrimmed) {
     return trimmed;
 }
 
-var __rest = (undefined && undefined.__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;
-};
 class GroupingRowPlugin extends BasePlugin {
     getStore(type = GROUPING_ROW_TYPE) {
         return this.providers.data.stores[type].store;
@@ -2653,15 +2747,16 @@ 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 {
@@ -2669,7 +2764,7 @@ 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) {
@@ -2691,7 +2786,7 @@ 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;
@@ -2717,21 +2812,13 @@ 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 : {}, 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
@@ -2744,7 +2831,12 @@ 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
@@ -2754,8 +2846,13 @@ 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
@@ -2764,9 +2861,14 @@ 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));
@@ -2778,6 +2880,7 @@ 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' });
     }
     /**
@@ -2813,10 +2916,6 @@ 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 }) => {
@@ -2831,17 +2930,6 @@ 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
@@ -2874,9 +2962,57 @@ 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
@@ -3217,18 +3353,14 @@ const ROW_RESIZE_EVENT = 'rowresize';
 const AFTER_ROW_RESIZE_EVENT = 'afterrowresize';
 const ROW_RESIZE_CANCEL_EVENT = 'rowresizecancel';
 class RowResizePlugin extends BasePlugin {
-    static fromGridProperty(revogrid, providers) {
-        const plugin = new RowResizePlugin(revogrid, providers);
-        plugin.controlFromGridProperty();
-        return plugin;
-    }
     constructor(revogrid, providers, config = {}) {
         super(revogrid, providers);
         this.enabled = false;
-        this.gridResizeRow = false;
-        this.gridPlugins = [];
-        this.committedSizes = new Map();
-        this.appliedIndexes = new Map();
+        this.appliedDefinitionIndexes = new Map();
+        this.pendingBottomAnchor = false;
+        this.keepBottomAnchor = false;
+        this.rowDefinitionRemapQueued = false;
+        this.pendingSourceCounts = new Map();
         this.previousBodyCursor = '';
         this.decorateRow = ({ detail, }) => {
             if (!this.enabled ||
@@ -3292,22 +3424,72 @@ class RowResizePlugin extends BasePlugin {
             }
         };
         this.onWindowBlur = () => this.cancel('blur');
-        this.reapplyCommittedSizes = () => this.applyCommittedSizes(false);
-        this.rebuildCommittedSizes = () => this.applyCommittedSizes(true);
-        this.syncAppliedIndexes = () => {
-            for (const [rowType, committed] of this.committedSizes) {
+        this.updateBottomAnchorState = ({ detail, }) => {
+            if (detail.dimension !== 'rgRow') {
+                return;
+            }
+            this.keepBottomAnchor = this.isMainViewportAtBottom(detail.coordinate);
+        };
+        this.applyPendingBottomAnchor = () => {
+            if (!this.pendingBottomAnchor) {
+                return;
+            }
+            this.pendingBottomAnchor = false;
+            const dimension = this.providers.dimension.stores.rgRow.store;
+            // Scroll surfaces have slightly different client sizes. Give the shared
+            // scrolling service the content end and let each surface clamp to its own
+            // exact bottom coordinate.
+            void this.revogrid.scrollToCoordinate({ y: dimension.get('realSize') });
+        };
+        this.scheduleRowDefinitionRemap = () => {
+            if (this.rowDefinitionRemapQueued) {
+                return;
+            }
+            this.rowDefinitionRemapQueued = true;
+            queueMicrotask(() => {
+                if (!this.rowDefinitionRemapQueued) {
+                    return;
+                }
+                this.pruneRowDefinitions();
+                this.reapplyRowDefinitionSizes();
+                this.rowDefinitionRemapQueued = false;
+            });
+        };
+        /** Map source-indexed row definitions back onto the current virtual order. */
+        this.reapplyRowDefinitionSizes = () => {
+            const rowDefinitions = this.providers.dimension.getRowDefinitions();
+            for (const rowType of rowTypes) {
                 const items = this.providers.data.stores[rowType].store.get('items');
+                const definitions = new Map(rowDefinitions
+                    .filter(definition => definition.type === rowType)
+                    .map(definition => [definition.index, definition.size]));
+                const appliedIndexes = this.appliedDefinitionIndexes.get(rowType);
+                if (!definitions.size && !(appliedIndexes === null || appliedIndexes === void 0 ? void 0 : appliedIndexes.size)) {
+                    continue;
+                }
+                const dimension = this.providers.dimension.stores[rowType];
+                const currentSizes = dimension.store.get('sizes');
+                const sizes = Object.assign({}, currentSizes);
+                for (const index of appliedIndexes || []) {
+                    delete sizes[index];
+                }
                 const indexes = new Set();
                 items.forEach((physicalIndex, virtualIndex) => {
-                    if (committed.has(physicalIndex)) {
+                    const size = definitions.get(physicalIndex);
+                    if (size !== undefined) {
+                        sizes[virtualIndex] = size;
                         indexes.add(virtualIndex);
                     }
                 });
-                this.appliedIndexes.set(rowType, indexes);
+                this.appliedDefinitionIndexes.set(rowType, indexes);
+                const sizeKeys = Object.keys(sizes);
+                if (sizeKeys.length !== Object.keys(currentSizes).length ||
+                    sizeKeys.some(index => sizes[index] !== currentSizes[index])) {
+                    this.providers.dimension.setCustomSizes(rowType, sizes);
+                }
             }
         };
         this.config = resolveRowResizeConfig(config);
-        this.rowDefinitionsRef = revogrid.rowDefinitions;
         if (new.target !== RowResizePlugin) {
             this.enabled = true;
             this.registerEventListeners();
@@ -3315,77 +3497,53 @@ class RowResizePlugin extends BasePlugin {
     }
     registerEventListeners() {
         this.addEventListener('beforerowrender', this.decorateRow);
-        this.addEventListener('beforeanysource', ({ detail }) => {
+        this.addEventListener('beforeanysource', () => {
             this.cancel('data-change');
-            const committed = this.committedSizes.get(detail.type);
-            if (!committed) {
-                return;
-            }
-            const removedIndexes = new Set();
-            for (const index of committed.keys()) {
-                if (index >= detail.source.length) {
-                    committed.delete(index);
-                    removedIndexes.add(index);
-                }
-            }
-            if (removedIndexes.size) {
-                const rowDefinitions = this.revogrid.rowDefinitions.filter(definition => definition.type !== detail.type ||
-                    !removedIndexes.has(definition.index));
-                this.rowDefinitionsRef = rowDefinitions;
-                this.revogrid.rowDefinitions = rowDefinitions;
-            }
+            this.keepBottomAnchor = false;
+        });
+        this.addEventListener('afteranysource', ({ detail }) => {
+            this.pendingSourceCounts.set(detail.type, detail.source.length);
+            this.scheduleRowDefinitionRemap();
         });
-        this.addEventListener('afteranysource', this.rebuildCommittedSizes);
         this.addEventListener('beforesourcesortingapply', this.cancelForDataChange);
-        this.addEventListener('aftersortingapply', this.reapplyCommittedSizes);
+        this.addEventListener('beforesortingapply', this.cancelForDataChange);
+        this.addEventListener('sortingconfigchanged', this.cancelForDataChange);
+        this.addEventListener(BEFORE_GROUPING_APPLY_EVENT, this.cancelForDataChange);
+        this.addEventListener('aftersortingapply', this.scheduleRowDefinitionRemap);
         this.addEventListener('beforefilterapply', this.cancelForDataChange);
-        this.addEventListener('beforerowdefinition', ({ detail }) => {
+        this.addEventListener('afterfilterapply', this.scheduleRowDefinitionRemap);
+        this.addEventListener('beforerowdefinition', () => {
             this.cancel('data-change');
-            if (detail.vals !== this.rowDefinitionsRef) {
-                this.committedSizes.clear();
-                this.appliedIndexes.clear();
-                this.rowDefinitionsRef = detail.vals;
-            }
-        });
-        this.addEventListener('afterthemechanged', this.reapplyCommittedSizes);
-        this.addEventListener('aftertrimmed', this.syncAppliedIndexes);
-        this.addEventListener('roworderchange', () => {
-            queueMicrotask(this.reapplyCommittedSizes);
+            this.scheduleRowDefinitionRemap();
         });
+        this.addEventListener('afterthemechanged', this.scheduleRowDefinitionRemap);
+        this.addEventListener('aftertrimmed', this.scheduleRowDefinitionRemap);
+        this.addEventListener('roworderchange', this.scheduleRowDefinitionRemap);
         this.addEventListener(GROUP_EXPAND_EVENT, () => {
-            queueMicrotask(this.reapplyCommittedSizes);
+            if (this.keepBottomAnchor) {
+                this.pendingBottomAnchor = true;
+            }
+            this.scheduleRowDefinitionRemap();
         });
+        this.addEventListener('aftergridrender', this.applyPendingBottomAnchor);
+        this.addEventListener('viewportscroll', this.updateBottomAnchorState);
         this.addEventListener('rowheaderschanged', ({ detail }) => {
             if (!detail && !this.config.fullRow) {
                 this.cancel('row-headers-hidden');
             }
         });
     }
-    controlFromGridProperty() {
-        this.gridResizeRow = this.revogrid.resizeRow;
-        this.gridPlugins = this.revogrid.plugins;
-        this.syncGridProperty(false);
-        this.watch('resizeRow', value => {
-            this.gridResizeRow = value;
-            this.syncGridProperty();
-        });
-        this.watch('plugins', value => {
-            this.gridPlugins = value || [];
-            this.syncGridProperty();
-        });
-    }
-    syncGridProperty(refresh = true) {
-        const hasConfiguredPlugin = this.gridPlugins.some(plugin => plugin !== RowResizePlugin &&
+    syncGridConfig(refresh = true) {
+        const { plugins = [], resizeRow } = this.revogrid;
+        const isCorePlugin = this.constructor === RowResizePlugin;
+        const hasConfiguredPlugin = plugins.some(plugin => plugin !== RowResizePlugin &&
             plugin.prototype instanceof RowResizePlugin);
-        const explicitlyEnabled = this.gridPlugins.includes(RowResizePlugin);
-        const enabled = hasConfiguredPlugin
-            ? false
-            : explicitlyEnabled || !!this.gridResizeRow;
-        const config = resolveRowResizeConfig(!hasConfiguredPlugin &&
-            !explicitlyEnabled &&
-            typeof this.gridResizeRow === 'object'
-            ? this.gridResizeRow
-            : undefined);
+        const enabled = !isCorePlugin ||
+            (!hasConfiguredPlugin && !!resizeRow);
+        const resizeConfig = typeof resizeRow === 'object' ? resizeRow : undefined;
+        const config = isCorePlugin
+            ? resolveRowResizeConfig(resizeConfig)
+            : this.config;
         const configChanged = config.minHeight !== this.config.minHeight ||
             config.maxHeight !== this.config.maxHeight ||
             config.fullRow !== this.config.fullRow;
@@ -3397,10 +3555,13 @@ class RowResizePlugin extends BasePlugin {
         if (enabled !== this.enabled) {
             this.enabled = enabled;
             if (enabled) {
-                this.rowDefinitionsRef = this.revogrid.rowDefinitions;
                 this.registerEventListeners();
             }
             else {
+                this.pendingBottomAnchor = false;
+                this.keepBottomAnchor = false;
+                this.rowDefinitionRemapQueued = false;
+                this.pendingSourceCounts.clear();
                 this.clearSubscriptions();
             }
         }
@@ -3419,6 +3580,7 @@ class RowResizePlugin extends BasePlugin {
         }
         const dimension = this.providers.dimension.stores[rowType];
         const dimensionState = dimension.getCurrentState();
+        const viewport = this.providers.viewport.stores[rowType];
         const item = getItemByIndex(dimensionState, index);
         const focusedStore = this.providers.selection.focusedStore;
         const selectedRowType = focusedStore
@@ -3450,16 +3612,23 @@ class RowResizePlugin extends BasePlugin {
             currentHeight: startHeight,
             previousSizes,
             originalCustomSizes: Object.assign({}, dimensionState.sizes),
-            startEvent: event,
+            bottomAnchored: rowType === 'rgRow' &&
+                this.isMainViewportAtBottom(viewport.lastCoordinate),
             lastEvent: event,
         };
+        this.active = active;
         const beforeEvent = this.emit(BEFORE_ROW_RESIZE_EVENT, this.eventDetail(active, event, startHeight));
         if (beforeEvent.defaultPrevented) {
+            if (this.active === active) {
+                this.active = undefined;
+            }
+            return;
+        }
+        if (!this.enabled || this.active !== active) {
             return;
         }
         event.preventDefault();
         event.stopPropagation();
-        this.active = active;
         const doc = this.revogrid.ownerDocument;
         this.previousBodyCursor = ((_a = doc.body) === null || _a === void 0 ? void 0 : _a.style.cursor) || '';
         if (doc.body) {
@@ -3482,6 +3651,7 @@ class RowResizePlugin extends BasePlugin {
             return;
         }
         this.providers.dimension.setCustomSizes(active.rowType, createRowResizePatch(active.indexes, size), true);
+        this.requestBottomAnchor(active);
         active.currentHeight = size;
         this.emit(ROW_RESIZE_EVENT, this.eventDetail(active, active.lastEvent, size));
     }
@@ -3500,7 +3670,8 @@ class RowResizePlugin extends BasePlugin {
             }
         }
         this.providers.dimension.setCustomSizes(active.rowType, currentSizes);
-        const detail = Object.assign(Object.assign({}, this.eventDetail(active, active.lastEvent || active.startEvent, active.startHeight)), { reason });
+        this.requestBottomAnchor(active);
+        const detail = Object.assign(Object.assign({}, this.eventDetail(active, active.lastEvent, active.startHeight)), { reason });
         this.finishGesture();
         this.emit(ROW_RESIZE_CANCEL_EVENT, detail);
     }
@@ -3519,51 +3690,44 @@ class RowResizePlugin extends BasePlugin {
             return;
         }
         const items = this.providers.data.stores[active.rowType].store.get('items');
-        let committed = this.committedSizes.get(active.rowType);
-        if (!committed) {
-            committed = new Map();
-            this.committedSizes.set(active.rowType, committed);
-        }
-        let applied = this.appliedIndexes.get(active.rowType);
-        if (!applied) {
-            applied = new Set();
-            this.appliedIndexes.set(active.rowType, applied);
-        }
         const physicalIndexes = active.indexes.reduce((result, index) => {
             const physicalIndex = items[index];
             if (physicalIndex !== undefined) {
-                committed.set(physicalIndex, active.currentHeight);
-                applied.add(index);
                 result.push(physicalIndex);
             }
             return result;
         }, []);
         if (physicalIndexes.length) {
-            const rowDefinitions = mergeRowResizeDefinitions(this.revogrid.rowDefinitions, active.rowType, physicalIndexes, active.currentHeight);
-            this.rowDefinitionsRef = rowDefinitions;
-            this.revogrid.rowDefinitions = rowDefinitions;
+            const rowDefinitions = mergeRowResizeDefinitions(this.providers.dimension.getRowDefinitions(), active.rowType, physicalIndexes, active.currentHeight);
+            this.providers.dimension.setRowDefinitions(rowDefinitions);
+            this.scheduleRowDefinitionRemap();
+            this.keepBottomAnchor = active.bottomAnchored;
+            this.requestBottomAnchor(active);
         }
     }
-    applyCommittedSizes(clearAppliedIndexes) {
-        for (const [rowType, committed] of this.committedSizes) {
-            const dimension = this.providers.dimension.stores[rowType];
-            const sizes = Object.assign({}, dimension.store.get('sizes'));
-            if (clearAppliedIndexes) {
-                for (const index of this.appliedIndexes.get(rowType) || []) {
-                    delete sizes[index];
-                }
-            }
-            const items = this.providers.data.stores[rowType].store.get('items');
-            const indexes = new Set();
-            items.forEach((physicalIndex, virtualIndex) => {
-                const size = committed.get(physicalIndex);
-                if (size !== undefined) {
-                    sizes[virtualIndex] = size;
-                    indexes.add(virtualIndex);
-                }
-            });
-            this.appliedIndexes.set(rowType, indexes);
-            this.providers.dimension.setCustomSizes(rowType, sizes);
+    requestBottomAnchor(active) {
+        if (active.bottomAnchored) {
+            this.pendingBottomAnchor = true;
+        }
+    }
+    isMainViewportAtBottom(coordinate) {
+        const dimension = this.providers.dimension.stores.rgRow.getCurrentState();
+        const viewport = this.providers.viewport.stores.rgRow.store.state;
+        return (dimension.realSize > viewport.clientSize &&
+            coordinate >= getViewportMaxCoordinate(dimension, viewport.virtualSize));
+    }
+    pruneRowDefinitions() {
+        if (!this.pendingSourceCounts.size) {
+            return;
+        }
+        const definitions = this.providers.dimension.getRowDefinitions();
+        const rowDefinitions = definitions.filter(definition => {
+            const count = this.pendingSourceCounts.get(definition.type);
+            return count === undefined || definition.index < count;
+        });
+        this.pendingSourceCounts.clear();
+        if (rowDefinitions.length !== definitions.length) {
+            this.providers.dimension.setRowDefinitions(rowDefinitions);
         }
     }
     finishGesture() {
@@ -3586,8 +3750,11 @@ class RowResizePlugin extends BasePlugin {
     }
     destroy() {
         this.cancel('destroy');
+        this.keepBottomAnchor = false;
+        this.rowDefinitionRemapQueued = false;
+        this.pendingSourceCounts.clear();
         super.destroy();
     }
 }
 
-export { AutoSizeColumnPlugin as A, BasePlugin as B, ColumnAutoSizeMode as C, DimensionStore as D, ExportFilePlugin as E, FILTER_TRIMMED_TYPE as F, GroupingRowPlugin as G, ROW_RESIZE_CANCEL_EVENT as H, RowResizePlugin as I, DEFAULT_MIN_ROW_HEIGHT as J, resolveRowResizeConfig as K, clampRowResizeHeight as L, getRowResizeIndexes as M, createRowResizePatch as N, mergeRowResizeDefinitions as O, SortingPlugin as P, hasActiveSorting as Q, ROW_RESIZE_HANDLE_CLASS as R, SelectionStore as S, getSortingIndex as T, sortIndexByItems as U, defaultCellCompare as V, descCellCompare as W, getNextOrder as X, getComparer as Y, StretchColumn as a, ExportCsv as b, FILTER_CONFIG_CHANGED_EVENT as c, defineTheme as d, FILTE_PANEL as e, FilterPlugin as f, filterCoreFunctionsIndexedByType as g, filterTypes as h, isStretchPlugin as i, filterNames as j, DEFAULT_BLANK_SEMANTICS as k, isBlankValue as l, doCollapse as m, doExpand as n, COLUMN_DRAG_MOVE_EVENT as o, COLUMN_DRAG_END_EVENT as p, BEFORE_COLUMN_DRAG_END_EVENT as q, resolveBlankSemantics as r, COLUMN_DRAG_START_EVENT as s, themeTokenCssVariables as t, ColumnMovePlugin as u, getLeftRelative as v, getColumnDragPosition as w, BEFORE_ROW_RESIZE_EVENT as x, ROW_RESIZE_EVENT as y, AFTER_ROW_RESIZE_EVENT as z };
+export { AutoSizeColumnPlugin as A, BasePlugin as B, ColumnAutoSizeMode as C, DimensionStore as D, ExportFilePlugin as E, FILTER_TRIMMED_TYPE as F, GroupingRowPlugin as G, AFTER_ROW_RESIZE_EVENT as H, ROW_RESIZE_CANCEL_EVENT as I, RowResizePlugin as J, DEFAULT_MIN_ROW_HEIGHT as K, resolveRowResizeConfig as L, clampRowResizeHeight as M, getRowResizeIndexes as N, createRowResizePatch as O, mergeRowResizeDefinitions as P, SortingPlugin as Q, ROW_RESIZE_HANDLE_CLASS as R, SelectionStore as S, hasActiveSorting as T, getSortingIndex as U, sortIndexByItems as V, defaultCellCompare as W, descCellCompare as X, getNextOrder as Y, getComparer as Z, StretchColumn as a, ExportCsv as b, FILTER_CONFIG_CHANGED_EVENT as c, defineTheme as d, FILTE_PANEL as e, FilterPlugin as f, filterCoreFunctionsIndexedByType as g, filterTypes as h, isStretchPlugin as i, filterTypeDefaults as j, filterNames as k, DEFAULT_BLANK_SEMANTICS as l, isBlankValue as m, doCollapse as n, doExpand as o, COLUMN_DRAG_MOVE_EVENT as p, COLUMN_DRAG_END_EVENT as q, resolveBlankSemantics as r, BEFORE_COLUMN_DRAG_END_EVENT as s, themeTokenCssVariables as t, COLUMN_DRAG_START_EVENT as u, ColumnMovePlugin as v, getLeftRelative as w, getColumnDragPosition as x, BEFORE_ROW_RESIZE_EVENT as y, ROW_RESIZE_EVENT as z };