@revolist/revogrid 4.26.2 → 4.27.1

package/dist/esm/{column.drag.plugin-DDBKeTGI.js → row-resize.plugin-DBOgjLdE.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-Cfw3L0PN.js';
-import { K as createStore, l as setStore, i as calculateDimensionData, L as identity, N as isArray, b as getSourceItem, g as getPhysical, e as setItems, j as getItemByPosition } from './dimension.helpers-fl4HSSK9.js';
-import { j as calculateRowHeaderSize } from './viewport.store-BSXmsiZc.js';
-import { g as getScrollbarSize, t as timeout } from './index-D24ku9ej.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, 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 { d as debounce } from './debounce-PCRWZliA.js';
-import { O as ON_COLUMN_CLICK, d as dispatch } from './header-cell-renderer-Cqtg1ETB.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.
@@ -151,9 +151,7 @@ const trimmedPlugin = (storeService) => {
                 }
                 case 'trimmed': {
                     const trim = val;
-                    if (!trimmedPreviousSizes) {
-                        trimmedPreviousSizes = storeService.store.get('sizes');
-                    }
+                    trimmedPreviousSizes !== null && trimmedPreviousSizes !== void 0 ? trimmedPreviousSizes : (trimmedPreviousSizes = storeService.store.get('sizes'));
                     trimmingObject = removeMultipleAndShift(trimmedPreviousSizes, trim || {});
                     // save a reference to the trimmed object to prevent changes after trimming
                     storeService.setSizes(trimmingObject);
@@ -1380,6 +1378,13 @@ const filterNames = {
     lte: '<=',
 };
 
+/** Fewer rows keep the existing synchronous filtering behavior. */
+const ASYNC_FILTER_ROW_THRESHOLD = 15000;
+/** Maximum rows evaluated in one filtering chunk. */
+const FILTER_CHUNK_SIZE = 1000;
+/** Yield after approximately this much accumulated filtering work. */
+const FILTER_TIME_BUDGET_MS = 5;
+
 // filter.plugin.tsx
 const FILTER_TRIMMED_TYPE = 'filter';
 const FILTER_CONFIG_CHANGED_EVENT = 'filterconfigchanged';
@@ -1424,6 +1429,7 @@ class FilterPlugin extends BasePlugin {
         this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
         this.filterProp = FILTER_PROP;
         this.allowDuplicateOperators = true;
+        this.filteringRunId = 0;
         if (config) {
             this.initConfig(config);
         }
@@ -1432,7 +1438,7 @@ class FilterPlugin extends BasePlugin {
             ...existingNodes,
             h("revogr-filter-panel", { filterNames: this.filterNameIndexByType, filterEntities: this.filterFunctionsIndexedByType, filterCaptions: (_a = config === null || config === void 0 ? void 0 : config.localization) === null || _a === void 0 ? void 0 : _a.captions, onFilterChange: e => this.onFilterChange(e.detail), onResetChange: e => this.onFilterReset(e.detail), disableDynamicFiltering: config === null || config === void 0 ? void 0 : config.disableDynamicFiltering, closeOnOutsideClick: config === null || config === void 0 ? void 0 : config.closeFilterPanelOnOutsideClick, allowDuplicateOperators: this.allowDuplicateOperators, ref: e => (this.pop = e) }, ' ', this.extraContent()),
         ];
-        const aftersourceset = async () => {
+        const aftersourceset = () => {
             const filterCollectionProps = Object.keys(this.filterCollection);
             if (filterCollectionProps.length > 0) {
                 // handle old way of filtering by reworking FilterCollection to new MultiFilterItem
@@ -1449,12 +1455,26 @@ class FilterPlugin extends BasePlugin {
                     }
                 });
             }
-            if (Object.keys(this.multiFilterItems).length === 0) {
+            if (!this.hasActiveFilters()) {
+                this.cancelFiltering();
                 return;
             }
-            await timeout();
-            await this.runFiltering(this.multiFilterItems);
+            void this.runFiltering(this.multiFilterItems);
         };
+        /**
+         * This executes before the data store replaces its source.
+         * For a large source with active filters:
+         * 1. Existing filtering runs are invalidated.
+         * 2. Pending state starts.
+         * 3. Visible rows become empty.
+         * 4. The source is replaced while the DataStore guard prevents it from exposing unfiltered rows.
+         */
+        this.addEventListener('beforesourceset', ({ detail }) => {
+            if (detail.source.length >= ASYNC_FILTER_ROW_THRESHOLD &&
+                this.hasActiveFilters()) {
+                this.deferFiltering();
+            }
+        });
         this.addEventListener('headerclick', e => this.headerclick(e));
         this.addEventListener(FILTER_CONFIG_CHANGED_EVENT, ({ detail }) => {
             if (!detail) {
@@ -1615,7 +1635,7 @@ class FilterPlugin extends BasePlugin {
         // store the filter items
         this.multiFilterItems = filterItems;
         // run the filtering when the items change
-        this.runFiltering(this.multiFilterItems);
+        await this.runFiltering(this.multiFilterItems);
     }
     onFilterReset(prop) {
         delete this.multiFilterItems[prop !== null && prop !== void 0 ? prop : ''];
@@ -1625,6 +1645,8 @@ class FilterPlugin extends BasePlugin {
      * Triggers grid filtering
      */
     async doFiltering(collection, source, columns, filterItems) {
+        // creates the execution token - owns the actual calculation
+        const runId = this.beginFiltering();
         const columnsToUpdate = [];
         /**
          * Loop through the columns and update the columns that need to be updated with the `hasFilter` property.
@@ -1649,7 +1671,25 @@ class FilterPlugin extends BasePlugin {
                 column[this.filterProp] = true;
             }
         });
-        const itemsToTrim = this.getRowFilter(source, filterItems, columnByProp);
+        let itemsToTrim;
+        const hasFilters = Object.keys(filterItems).length > 0 || this.hasActiveFilters();
+        const isLargeSource = hasFilters && source.length >= ASYNC_FILTER_ROW_THRESHOLD;
+        if (isLargeSource) {
+            this.providers.data.setItemsPending(true);
+            await timeout();
+        }
+        if (!hasFilters) {
+            itemsToTrim = {};
+        }
+        else if (isLargeSource && this.supportsChunkedFiltering()) {
+            itemsToTrim = await this.getRowFilterInChunks(source, filterItems, columnByProp, runId);
+        }
+        else {
+            itemsToTrim = this.getRowFilter(source, filterItems, columnByProp);
+        }
+        if (!itemsToTrim || runId !== this.filteringRunId) {
+            return;
+        }
         // check is filter event prevented
         const { defaultPrevented, detail } = this.emit('beforefiltertrimmed', {
             collection,
@@ -1657,10 +1697,12 @@ class FilterPlugin extends BasePlugin {
             source,
             filterItems,
         });
-        if (defaultPrevented) {
+        if (defaultPrevented || runId !== this.filteringRunId) {
+            this.releaseFiltering(runId);
             return;
         }
         this.providers.data.setTrimmed({ [FILTER_TRIMMED_TYPE]: detail.itemsToFilter });
+        this.releaseFiltering(runId);
         // applies the hasFilter to the columns to show filter icon
         this.providers.column.updateColumns(columnsToUpdate);
         this.emit('afterfilterapply', {
@@ -1674,6 +1716,10 @@ class FilterPlugin extends BasePlugin {
         await this.runFiltering(this.multiFilterItems);
     }
     async runFiltering(multiFilterItems) {
+        // runFiltering: First token: "Is this request still valid after event handlers run?"
+        // doFiltering: Second token: "Is this calculation still the newest one?"
+        // creates a preflight token and sets the grid to a pending state
+        const runId = this.beginFiltering();
         const collection = {};
         // handle old filterCollection to return the first filter only (if any) from multiFilterItems
         const filterProps = Object.keys(multiFilterItems);
@@ -1697,10 +1743,67 @@ class FilterPlugin extends BasePlugin {
             columns,
             filterItems: this.multiFilterItems,
         });
-        if (defaultPrevented) {
+        if (defaultPrevented || runId !== this.filteringRunId) {
+            this.releaseFiltering(runId);
             return;
         }
-        this.doFiltering(detail.collection, detail.source, detail.columns, detail.filterItems);
+        await this.doFiltering(detail.collection, detail.source, detail.columns, detail.filterItems);
+    }
+    /** Whether this plugin currently owns filter state that must follow a new source. */
+    hasActiveFilters() {
+        return (Object.keys(this.multiFilterItems).length > 0 ||
+            Object.keys(this.filterCollection).length > 0);
+    }
+    /** Preserve whole-source semantics for plugins that override getRowFilter. */
+    supportsChunkedFiltering() {
+        return this.getRowFilter === FilterPlugin.prototype.getRowFilter;
+    }
+    /**
+     * Hide visible rows and invalidate current filtering until a deferred filter
+     * run is ready. Used by filter extensions with their own debounced state.
+     */
+    deferFiltering() {
+        this.beginFiltering(true);
+    }
+    beginFiltering(pending = false) {
+        const runId = ++this.filteringRunId;
+        if (pending) {
+            this.providers.data.setItemsPending(true);
+        }
+        return runId;
+    }
+    releaseFiltering(runId) {
+        if (runId === this.filteringRunId) {
+            this.providers.data.setItemsPending(false);
+        }
+    }
+    cancelFiltering() {
+        this.releaseFiltering(this.beginFiltering());
+    }
+    async getRowFilterInChunks(rows, filterItems, columnByProp, runId) {
+        const trimmed = {};
+        let sliceStarted = performance.now();
+        for (let offset = 0; offset < rows.length; offset += FILTER_CHUNK_SIZE) {
+            if (runId !== this.filteringRunId) {
+                return;
+            }
+            const end = Math.min(offset + FILTER_CHUNK_SIZE, rows.length);
+            const chunkTrimmed = this.getRowFilter(rows.slice(offset, end), filterItems, columnByProp);
+            // filter that chunk
+            for (const chunkIndex in chunkTrimmed) {
+                trimmed[offset + Number(chunkIndex)] = true;
+            }
+            if (end < rows.length &&
+                performance.now() - sliceStarted >= FILTER_TIME_BUDGET_MS) {
+                await timeout();
+                sliceStarted = performance.now();
+            }
+        }
+        return runId === this.filteringRunId ? trimmed : undefined;
+    }
+    destroy() {
+        this.cancelFiltering();
+        super.destroy();
     }
     /**
      * Get trimmed rows based on filter
@@ -1804,6 +1907,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.
  *
@@ -2041,18 +2198,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.
@@ -2212,6 +2357,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');
@@ -2219,7 +2365,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({
@@ -2245,6 +2394,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.
      *
@@ -2428,8 +2587,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;
@@ -2462,7 +2623,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;
@@ -2523,18 +2684,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;
@@ -2550,15 +2699,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 {
@@ -2566,7 +2716,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) {
@@ -2588,7 +2738,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;
@@ -2614,21 +2764,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
@@ -2641,7 +2783,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
@@ -2651,8 +2798,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
@@ -2661,9 +2813,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));
@@ -2675,7 +2832,8 @@ class GroupingRowPlugin extends BasePlugin {
             customRenderer: options.groupLabelTemplate,
             cellRenderer: options.groupCellTemplate,
         });
-        this.updateTrimmed(trimmed, oldNewIndexMap, undefined, sourceWithGroups);
+        queueMicrotask(() => this.remapRowDefinitions(oldNewIndexes !== null && oldNewIndexes !== void 0 ? oldNewIndexes : {}, oldNewIndexMap, currentSource, sourceWithGroups));
+        this.updateTrimmed(trimmed, oldNewIndexMap, undefined, sourceWithGroups, { filterTrimmedMode: 'recompute-after-source-set' });
     }
     /**
      * External call to apply grouping. Called by revogrid when prop changed.
@@ -2710,10 +2868,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 }) => {
@@ -2728,17 +2882,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
@@ -2771,14 +2914,69 @@ 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();
+        }
     }
-    updateTrimmed(trimmedGroup = {}, firstLevelMap = {}, secondLevelMap, source = this.getStore().get('source')) {
+    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
         const trimemedOptionsToUpgrade = processDoubleConversionTrimmed(this.getStore().get('trimmed'), firstLevelMap, secondLevelMap);
         for (let type in trimemedOptionsToUpgrade) {
+            if (filterTrimmedMode === 'recompute-after-source-set' &&
+                type === FILTER_TRIMMED_TYPE) {
+                // The filter plugin recalculates this trim against the installed source
+                // during aftersourceset. Reapplying remapped old indexes afterwards
+                // would overwrite that fresh result.
+                continue;
+            }
             if (type === FILTER_TRIMMED_TYPE) {
                 /** Regrouping changes physical indexes, so filter trim needs fresh group-header state. */
                 trimemedOptionsToUpgrade[type] = filterOutEmptyGroupRows(source, trimemedOptionsToUpgrade[type]);
@@ -3048,4 +3246,467 @@ function getColumnDragPosition(targetItem, startItem, renderOffset, scrollOffset
     return insertionEdge - renderOffset + scrollOffset;
 }
 
-export { AutoSizeColumnPlugin as A, BasePlugin as B, ColumnAutoSizeMode as C, DimensionStore as D, ExportFilePlugin as E, FILTER_TRIMMED_TYPE as F, GroupingRowPlugin as G, sortIndexByItems as H, defaultCellCompare as I, descCellCompare as J, getNextOrder as K, getComparer as L, SelectionStore as S, 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, SortingPlugin as x, hasActiveSorting as y, getSortingIndex as z };
+const DEFAULT_MIN_ROW_HEIGHT = 20;
+const finiteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+function resolveRowResizeConfig(config = {}) {
+    const minHeight = finiteNumber(config.minHeight)
+        ? Math.max(1, Math.round(config.minHeight))
+        : DEFAULT_MIN_ROW_HEIGHT;
+    const maxHeight = finiteNumber(config.maxHeight)
+        ? Math.max(minHeight, Math.round(config.maxHeight))
+        : undefined;
+    return { minHeight, maxHeight, fullRow: config.fullRow === true };
+}
+function clampRowResizeHeight(height, config) {
+    var _a;
+    const rounded = Number.isFinite(height)
+        ? Math.round(height)
+        : config.minHeight;
+    return Math.min(Math.max(rounded, config.minHeight), (_a = config.maxHeight) !== null && _a !== void 0 ? _a : Number.POSITIVE_INFINITY);
+}
+function getRowResizeIndexes({ rowType, rowIndex, rowCount, selectedRange, selectedRowType, }) {
+    if (!selectedRange ||
+        selectedRowType !== rowType ||
+        rowIndex < Math.min(selectedRange.y, selectedRange.y1) ||
+        rowIndex > Math.max(selectedRange.y, selectedRange.y1)) {
+        return rowIndex >= 0 && rowIndex < rowCount ? [rowIndex] : [];
+    }
+    const start = Math.max(0, Math.min(selectedRange.y, selectedRange.y1));
+    const end = Math.min(rowCount - 1, Math.max(selectedRange.y, selectedRange.y1));
+    return Array.from({ length: Math.max(0, end - start + 1) }, (_, i) => start + i);
+}
+function createRowResizePatch(indexes, size) {
+    return indexes.reduce((patch, index) => {
+        patch[index] = size;
+        return patch;
+    }, {});
+}
+function mergeRowResizeDefinitions(definitions, rowType, physicalIndexes, size) {
+    const targetIndexes = new Set(physicalIndexes);
+    const existingIndexes = new Set();
+    const merged = definitions.map(definition => {
+        if (definition.type !== rowType || !targetIndexes.has(definition.index)) {
+            return definition;
+        }
+        existingIndexes.add(definition.index);
+        return Object.assign(Object.assign({}, definition), { size });
+    });
+    for (const index of targetIndexes) {
+        if (!existingIndexes.has(index)) {
+            merged.push({ type: rowType, index, size });
+        }
+    }
+    return merged;
+}
+
+const ROW_RESIZE_HANDLE_CLASS = 'row-resize-handle';
+const BEFORE_ROW_RESIZE_EVENT = 'beforerowresize';
+const ROW_RESIZE_EVENT = 'rowresize';
+const AFTER_ROW_RESIZE_EVENT = 'afterrowresize';
+const ROW_RESIZE_CANCEL_EVENT = 'rowresizecancel';
+class RowResizePlugin extends BasePlugin {
+    constructor(revogrid, providers, config = {}) {
+        super(revogrid, providers);
+        this.enabled = false;
+        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 ||
+                (detail.colType !== 'rowHeaders' && !this.config.fullRow)) {
+                return;
+            }
+            const handle = this.h('div', {
+                'key': `row-resize-${detail.rowType}-${detail.item.itemIndex}`,
+                'class': { [ROW_RESIZE_HANDLE_CLASS]: true },
+                'data-row-resize-index': detail.item.itemIndex,
+                'aria-hidden': 'true',
+                'onPointerDown': (event) => this.startResize(event, detail.rowType, detail.item.itemIndex),
+            });
+            detail.node.$children$ = [...(detail.node.$children$ || []), handle];
+        };
+        this.cancelForDataChange = () => this.cancel('data-change');
+        this.onPointerMove = (event) => {
+            const active = this.active;
+            if ((active === null || active === void 0 ? void 0 : active.pointerId) !== event.pointerId) {
+                return;
+            }
+            event.preventDefault();
+            active.lastEvent = event;
+            this.pendingHeight = clampRowResizeHeight(active.startHeight + event.clientY - active.startY, this.config);
+            if (this.animationFrame === undefined) {
+                const view = this.revogrid.ownerDocument.defaultView;
+                this.animationFrame = view === null || view === void 0 ? void 0 : view.requestAnimationFrame(() => {
+                    this.animationFrame = undefined;
+                    this.flushPendingResize();
+                });
+            }
+        };
+        this.onPointerUp = (event) => {
+            const active = this.active;
+            if ((active === null || active === void 0 ? void 0 : active.pointerId) !== event.pointerId) {
+                return;
+            }
+            event.preventDefault();
+            active.lastEvent = event;
+            this.pendingHeight = clampRowResizeHeight(active.startHeight + event.clientY - active.startY, this.config);
+            this.flushPendingResize();
+            if (this.active !== active) {
+                return;
+            }
+            const detail = this.eventDetail(active, event, active.currentHeight);
+            this.finishGesture();
+            this.commitResize(active);
+            this.emit(AFTER_ROW_RESIZE_EVENT, detail);
+        };
+        this.onPointerCancel = (event) => {
+            var _a;
+            if (((_a = this.active) === null || _a === void 0 ? void 0 : _a.pointerId) === event.pointerId) {
+                this.active.lastEvent = event;
+                this.cancel('pointercancel');
+            }
+        };
+        this.onKeyDown = (event) => {
+            if (event.key === 'Escape' && this.active) {
+                event.preventDefault();
+                this.cancel('escape');
+            }
+        };
+        this.onWindowBlur = () => this.cancel('blur');
+        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) => {
+                    const size = definitions.get(physicalIndex);
+                    if (size !== undefined) {
+                        sizes[virtualIndex] = size;
+                        indexes.add(virtualIndex);
+                    }
+                });
+                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);
+        if (new.target !== RowResizePlugin) {
+            this.enabled = true;
+            this.registerEventListeners();
+        }
+    }
+    registerEventListeners() {
+        this.addEventListener('beforerowrender', this.decorateRow);
+        this.addEventListener('beforeanysource', () => {
+            this.cancel('data-change');
+            this.keepBottomAnchor = false;
+        });
+        this.addEventListener('afteranysource', ({ detail }) => {
+            this.pendingSourceCounts.set(detail.type, detail.source.length);
+            this.scheduleRowDefinitionRemap();
+        });
+        this.addEventListener('beforesourcesortingapply', this.cancelForDataChange);
+        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('afterfilterapply', this.scheduleRowDefinitionRemap);
+        this.addEventListener('beforerowdefinition', () => {
+            this.cancel('data-change');
+            this.scheduleRowDefinitionRemap();
+        });
+        this.addEventListener('afterthemechanged', this.scheduleRowDefinitionRemap);
+        this.addEventListener('aftertrimmed', this.scheduleRowDefinitionRemap);
+        this.addEventListener('roworderchange', this.scheduleRowDefinitionRemap);
+        this.addEventListener(GROUP_EXPAND_EVENT, () => {
+            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');
+            }
+        });
+    }
+    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 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;
+        if (enabled === this.enabled && !configChanged) {
+            return;
+        }
+        this.cancel('config-change');
+        this.config = config;
+        if (enabled !== this.enabled) {
+            this.enabled = enabled;
+            if (enabled) {
+                this.registerEventListeners();
+            }
+            else {
+                this.pendingBottomAnchor = false;
+                this.keepBottomAnchor = false;
+                this.rowDefinitionRemapQueued = false;
+                this.pendingSourceCounts.clear();
+                this.clearSubscriptions();
+            }
+        }
+        if (refresh) {
+            queueMicrotask(() => void this.revogrid.refresh());
+        }
+    }
+    startResize(event, rowType, index) {
+        var _a, _b;
+        if (!this.enabled ||
+            this.active ||
+            event.defaultPrevented ||
+            !event.isPrimary ||
+            (event.pointerType !== 'touch' && event.button !== 0)) {
+            return;
+        }
+        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
+            ? this.providers.selection.storesYToType[focusedStore.position.y]
+            : undefined;
+        const indexes = getRowResizeIndexes({
+            rowType,
+            rowIndex: index,
+            rowCount: dimensionState.count,
+            selectedRange: this.providers.selection.selectedRange,
+            selectedRowType,
+        });
+        if (!indexes.length) {
+            return;
+        }
+        const previousSizes = indexes.reduce((sizes, rowIndex) => {
+            const row = getItemByIndex(dimensionState, rowIndex);
+            sizes[rowIndex] = row.end - row.start;
+            return sizes;
+        }, {});
+        const startHeight = item.end - item.start;
+        const active = {
+            pointerId: event.pointerId,
+            rowType,
+            index,
+            indexes,
+            startY: event.clientY,
+            startHeight,
+            currentHeight: startHeight,
+            previousSizes,
+            originalCustomSizes: Object.assign({}, dimensionState.sizes),
+            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();
+        const doc = this.revogrid.ownerDocument;
+        this.previousBodyCursor = ((_a = doc.body) === null || _a === void 0 ? void 0 : _a.style.cursor) || '';
+        if (doc.body) {
+            doc.body.style.cursor = 'row-resize';
+        }
+        doc.addEventListener('pointermove', this.onPointerMove, true);
+        doc.addEventListener('pointerup', this.onPointerUp, true);
+        doc.addEventListener('pointercancel', this.onPointerCancel, true);
+        doc.addEventListener('keydown', this.onKeyDown, true);
+        (_b = doc.defaultView) === null || _b === void 0 ? void 0 : _b.addEventListener('blur', this.onWindowBlur);
+    }
+    flushPendingResize() {
+        const active = this.active;
+        if (!active || this.pendingHeight === undefined) {
+            return;
+        }
+        const size = this.pendingHeight;
+        this.pendingHeight = undefined;
+        if (size === active.currentHeight) {
+            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));
+    }
+    cancel(reason) {
+        const active = this.active;
+        if (!active) {
+            return;
+        }
+        const currentSizes = Object.assign({}, this.providers.dimension.stores[active.rowType].store.get('sizes'));
+        for (const index of active.indexes) {
+            if (Object.hasOwn(active.originalCustomSizes, index)) {
+                currentSizes[index] = active.originalCustomSizes[index];
+            }
+            else {
+                delete currentSizes[index];
+            }
+        }
+        this.providers.dimension.setCustomSizes(active.rowType, currentSizes);
+        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);
+    }
+    eventDetail(active, originalEvent, size) {
+        return {
+            rowType: active.rowType,
+            index: active.index,
+            indexes: [...active.indexes],
+            size,
+            previousSizes: Object.assign({}, active.previousSizes),
+            originalEvent,
+        };
+    }
+    commitResize(active) {
+        if (active.currentHeight === active.startHeight) {
+            return;
+        }
+        const items = this.providers.data.stores[active.rowType].store.get('items');
+        const physicalIndexes = active.indexes.reduce((result, index) => {
+            const physicalIndex = items[index];
+            if (physicalIndex !== undefined) {
+                result.push(physicalIndex);
+            }
+            return result;
+        }, []);
+        if (physicalIndexes.length) {
+            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);
+        }
+    }
+    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() {
+        const doc = this.revogrid.ownerDocument;
+        const view = doc.defaultView;
+        if (this.animationFrame !== undefined) {
+            view === null || view === void 0 ? void 0 : view.cancelAnimationFrame(this.animationFrame);
+        }
+        doc.removeEventListener('pointermove', this.onPointerMove, true);
+        doc.removeEventListener('pointerup', this.onPointerUp, true);
+        doc.removeEventListener('pointercancel', this.onPointerCancel, true);
+        doc.removeEventListener('keydown', this.onKeyDown, true);
+        view === null || view === void 0 ? void 0 : view.removeEventListener('blur', this.onWindowBlur);
+        if (doc.body) {
+            doc.body.style.cursor = this.previousBodyCursor;
+        }
+        this.animationFrame = undefined;
+        this.pendingHeight = undefined;
+        this.active = undefined;
+    }
+    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 };