@revolist/revogrid 4.26.2 → 4.27.0

package/dist/esm/{column.drag.plugin-DDBKeTGI.js → row-resize.plugin-BRiaHlHA.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 { 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 { 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 { 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-Bqh1PrgH.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
@@ -2675,7 +2778,7 @@ class GroupingRowPlugin extends BasePlugin {
             customRenderer: options.groupLabelTemplate,
             cellRenderer: options.groupCellTemplate,
         });
-        this.updateTrimmed(trimmed, oldNewIndexMap, undefined, sourceWithGroups);
+        this.updateTrimmed(trimmed, oldNewIndexMap, undefined, sourceWithGroups, { filterTrimmedMode: 'recompute-after-source-set' });
     }
     /**
      * External call to apply grouping. Called by revogrid when prop changed.
@@ -2775,10 +2878,17 @@ class GroupingRowPlugin extends BasePlugin {
         this.providers.data.setData(source, GROUPING_ROW_TYPE, this.revogrid.disableVirtualY, undefined, true);
         this.updateTrimmed(undefined, undefined, oldNewIndexes, source);
     }
-    updateTrimmed(trimmedGroup = {}, firstLevelMap = {}, secondLevelMap, source = this.getStore().get('source')) {
+    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 +3158,436 @@ 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 {
+    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.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.reapplyCommittedSizes = () => this.applyCommittedSizes(false);
+        this.rebuildCommittedSizes = () => this.applyCommittedSizes(true);
+        this.syncAppliedIndexes = () => {
+            for (const [rowType, committed] of this.committedSizes) {
+                const items = this.providers.data.stores[rowType].store.get('items');
+                const indexes = new Set();
+                items.forEach((physicalIndex, virtualIndex) => {
+                    if (committed.has(physicalIndex)) {
+                        indexes.add(virtualIndex);
+                    }
+                });
+                this.appliedIndexes.set(rowType, indexes);
+            }
+        };
+        this.config = resolveRowResizeConfig(config);
+        this.rowDefinitionsRef = revogrid.rowDefinitions;
+        if (new.target !== RowResizePlugin) {
+            this.enabled = true;
+            this.registerEventListeners();
+        }
+    }
+    registerEventListeners() {
+        this.addEventListener('beforerowrender', this.decorateRow);
+        this.addEventListener('beforeanysource', ({ detail }) => {
+            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.addEventListener('afteranysource', this.rebuildCommittedSizes);
+        this.addEventListener('beforesourcesortingapply', this.cancelForDataChange);
+        this.addEventListener('aftersortingapply', this.reapplyCommittedSizes);
+        this.addEventListener('beforefilterapply', this.cancelForDataChange);
+        this.addEventListener('beforerowdefinition', ({ detail }) => {
+            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.addEventListener(GROUP_EXPAND_EVENT, () => {
+            queueMicrotask(this.reapplyCommittedSizes);
+        });
+        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 &&
+            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 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.rowDefinitionsRef = this.revogrid.rowDefinitions;
+                this.registerEventListeners();
+            }
+            else {
+                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 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),
+            startEvent: event,
+            lastEvent: event,
+        };
+        const beforeEvent = this.emit(BEFORE_ROW_RESIZE_EVENT, this.eventDetail(active, event, startHeight));
+        if (beforeEvent.defaultPrevented) {
+            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) {
+            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);
+        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);
+        const detail = Object.assign(Object.assign({}, this.eventDetail(active, active.lastEvent || active.startEvent, 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');
+        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;
+        }
+    }
+    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);
+        }
+    }
+    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');
+        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 };