@revolist/revogrid 4.26.2 → 4.27.0

package/dist/cjs/{column.drag.plugin-CK5HADlW.js → row-resize.plugin-BRQy_qNn.js}

@@ -3,14 +3,14 @@
  */
 'use strict';
 
-var column_service = require('./column.service-C7p5eC5V.js');
-var dimension_helpers = require('./dimension.helpers-CgHhnN1d.js');
-var viewport_store = require('./viewport.store-B4Clk4m9.js');
-var index$1 = require('./index--FdNLz1Z.js');
+var column_service = require('./column.service-Bbml5C2j.js');
+var dimension_helpers = require('./dimension.helpers-CptesQOZ.js');
+var viewport_store = require('./viewport.store-mhsdi61t.js');
+var index$1 = require('./index-BVESmpqW.js');
 var index = require('./index-DRvxCueo.js');
 var filter_button = require('./filter.button-F2Bw3UAd.js');
 var debounce = require('./debounce-CcpHiH2p.js');
-var headerCellRenderer = require('./header-cell-renderer-DHClfIto.js');
+var headerCellRenderer = require('./header-cell-renderer-BljFI6wj.js');
 
 /**
  * Public theme tokens and their CSS custom-property counterparts.
@@ -153,9 +153,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);
@@ -1382,6 +1380,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';
@@ -1426,6 +1431,7 @@ class FilterPlugin extends BasePlugin {
         this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
         this.filterProp = filter_button.FILTER_PROP;
         this.allowDuplicateOperators = true;
+        this.filteringRunId = 0;
         if (config) {
             this.initConfig(config);
         }
@@ -1434,7 +1440,7 @@ class FilterPlugin extends BasePlugin {
             ...existingNodes,
             index.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
@@ -1451,12 +1457,26 @@ class FilterPlugin extends BasePlugin {
                     }
                 });
             }
-            if (Object.keys(this.multiFilterItems).length === 0) {
+            if (!this.hasActiveFilters()) {
+                this.cancelFiltering();
                 return;
             }
-            await index$1.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) {
@@ -1617,7 +1637,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 : ''];
@@ -1627,6 +1647,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.
@@ -1651,7 +1673,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 index$1.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,
@@ -1659,10 +1699,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', {
@@ -1676,6 +1718,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);
@@ -1699,10 +1745,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 index$1.timeout();
+                sliceStarted = performance.now();
+            }
+        }
+        return runId === this.filteringRunId ? trimmed : undefined;
+    }
+    destroy() {
+        this.cancelFiltering();
+        super.destroy();
     }
     /**
      * Get trimmed rows based on filter
@@ -2677,7 +2780,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.
@@ -2777,10 +2880,17 @@ class GroupingRowPlugin extends BasePlugin {
         this.providers.data.setData(source, column_service.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]);
@@ -3050,14 +3160,449 @@ function getColumnDragPosition(targetItem, startItem, renderOffset, scrollOffset
     return insertionEdge - renderOffset + scrollOffset;
 }
 
+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(column_service.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 = dimension_helpers.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 = dimension_helpers.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();
+    }
+}
+
+exports.AFTER_ROW_RESIZE_EVENT = AFTER_ROW_RESIZE_EVENT;
 exports.AutoSizeColumnPlugin = AutoSizeColumnPlugin;
 exports.BEFORE_COLUMN_DRAG_END_EVENT = BEFORE_COLUMN_DRAG_END_EVENT;
+exports.BEFORE_ROW_RESIZE_EVENT = BEFORE_ROW_RESIZE_EVENT;
 exports.BasePlugin = BasePlugin;
 exports.COLUMN_DRAG_END_EVENT = COLUMN_DRAG_END_EVENT;
 exports.COLUMN_DRAG_MOVE_EVENT = COLUMN_DRAG_MOVE_EVENT;
 exports.COLUMN_DRAG_START_EVENT = COLUMN_DRAG_START_EVENT;
 exports.ColumnMovePlugin = ColumnMovePlugin;
 exports.DEFAULT_BLANK_SEMANTICS = DEFAULT_BLANK_SEMANTICS;
+exports.DEFAULT_MIN_ROW_HEIGHT = DEFAULT_MIN_ROW_HEIGHT;
 exports.DimensionStore = DimensionStore;
 exports.ExportCsv = ExportCsv;
 exports.ExportFilePlugin = ExportFilePlugin;
@@ -3066,9 +3611,15 @@ exports.FILTER_TRIMMED_TYPE = FILTER_TRIMMED_TYPE;
 exports.FILTE_PANEL = FILTE_PANEL;
 exports.FilterPlugin = FilterPlugin;
 exports.GroupingRowPlugin = GroupingRowPlugin;
+exports.ROW_RESIZE_CANCEL_EVENT = ROW_RESIZE_CANCEL_EVENT;
+exports.ROW_RESIZE_EVENT = ROW_RESIZE_EVENT;
+exports.ROW_RESIZE_HANDLE_CLASS = ROW_RESIZE_HANDLE_CLASS;
+exports.RowResizePlugin = RowResizePlugin;
 exports.SelectionStore = SelectionStore;
 exports.SortingPlugin = SortingPlugin;
 exports.StretchColumn = StretchColumn;
+exports.clampRowResizeHeight = clampRowResizeHeight;
+exports.createRowResizePatch = createRowResizePatch;
 exports.defaultCellCompare = defaultCellCompare;
 exports.defineTheme = defineTheme;
 exports.descCellCompare = descCellCompare;
@@ -3081,10 +3632,13 @@ exports.getColumnDragPosition = getColumnDragPosition;
 exports.getComparer = getComparer;
 exports.getLeftRelative = getLeftRelative;
 exports.getNextOrder = getNextOrder;
+exports.getRowResizeIndexes = getRowResizeIndexes;
 exports.getSortingIndex = getSortingIndex;
 exports.hasActiveSorting = hasActiveSorting;
 exports.isBlankValue = isBlankValue;
 exports.isStretchPlugin = isStretchPlugin;
+exports.mergeRowResizeDefinitions = mergeRowResizeDefinitions;
 exports.resolveBlankSemantics = resolveBlankSemantics;
+exports.resolveRowResizeConfig = resolveRowResizeConfig;
 exports.sortIndexByItems = sortIndexByItems;
 exports.themeTokenCssVariables = themeTokenCssVariables;