@revolist/revogrid 4.26.2 → 4.27.0

package/dist/collection/plugins/filter/filter.plugin.js

@@ -6,8 +6,9 @@ import { h } from "@stencil/core";
 import { BasePlugin } from "../base.plugin";
 import { FILTER_PROP, isFilterBtn } from "./filter.button";
 import { filterCoreFunctionsIndexedByType, filterNames, filterTypes, } from "./filter.indexed";
-import { timeout } from "../../utils";
 import { resolveBlankSemantics } from "./filter.blank";
+import { timeout } from "../../utils";
+import { ASYNC_FILTER_ROW_THRESHOLD, FILTER_CHUNK_SIZE, FILTER_TIME_BUDGET_MS, } from "./filter.constants";
 export * from './filter.types';
 export * from './filter.indexed';
 export * from './filter.blank';
@@ -55,6 +56,7 @@ export class FilterPlugin extends BasePlugin {
         this.filterFunctionsIndexedByType = Object.assign({}, filterCoreFunctionsIndexedByType);
         this.filterProp = FILTER_PROP;
         this.allowDuplicateOperators = true;
+        this.filteringRunId = 0;
         if (config) {
             this.initConfig(config);
         }
@@ -63,7 +65,7 @@ export 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
@@ -80,12 +82,26 @@ export 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) {
@@ -246,7 +262,7 @@ export 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 : ''];
@@ -256,6 +272,8 @@ export 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.
@@ -280,7 +298,25 @@ export 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,
@@ -288,10 +324,12 @@ export 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', {
@@ -305,6 +343,10 @@ export 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);
@@ -328,10 +370,67 @@ export 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

package/dist/collection/plugins/filter/filter.style.css

@@ -127,6 +127,8 @@ revogr-filter-panel .filter-panel-dialog .filter-actions button {
   visibility: visible;
   cursor: pointer;
   border-radius: 4px;
+  position: relative;
+  z-index: 1;
 }
 .rgHeaderCell .rv-filter.active {
   color: var(--rg-theme-filter-panel-icon-active);

package/dist/collection/plugins/groupingRow/grouping.row.plugin.js

@@ -166,7 +166,7 @@ export 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.
@@ -266,10 +266,17 @@ export 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]);

package/dist/collection/plugins/groupingRow/grouping.row.renderer.js

@@ -88,7 +88,7 @@ export const GroupingRowRenderer = (props) => {
             depth })))));
     }
     return (h(RowRenderer, Object.assign({}, props, groupRowAttrs), hasExpand && [
-        h("button", { class: { [GROUP_EXPAND_BTN]: true }, onClick: e => expandEvent(e, model, itemIndex) }, expandSvgIconVNode(expanded)),
+        h("button", { type: "button", class: { [GROUP_EXPAND_BTN]: true }, onClick: e => expandEvent(e, model, itemIndex) }, expandSvgIconVNode(expanded)),
         String(name),
     ]));
 };

package/dist/collection/plugins/groupingRow/grouping.service.js

@@ -158,7 +158,7 @@ export function isGrouping(rgRow) {
     return typeof (rgRow === null || rgRow === void 0 ? void 0 : rgRow[PSEUDO_GROUP_ITEM]) !== 'undefined';
 }
 export function isGroupingColumn(column) {
-    return typeof (column === null || column === void 0 ? void 0 : column[PSEUDO_GROUP_COLUMN]) !== 'undefined';
+    return (column === null || column === void 0 ? void 0 : column[PSEUDO_GROUP_COLUMN]) !== undefined;
 }
 export function measureEqualDepth(groupA, groupB) {
     const ln = groupA.length;

package/dist/collection/plugins/index.js

@@ -9,6 +9,7 @@ export * from './export/export.plugin';
 export * from './filter/filter.plugin';
 export * from './groupingRow/grouping.row.plugin';
 export * from './moveColumn/column.drag.plugin';
+export * from './row-resize';
 export * from './sorting/sorting.plugin';
 export * from './sorting/sorting.sign';
 export * from './add-rows-on-paste.plugin';

package/dist/collection/plugins/row-resize/index.js

@@ -0,0 +1,6 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+export * from './row-resize.plugin';
+export * from './row-resize.types';
+export * from './row-resize.utils';

package/dist/collection/plugins/row-resize/row-resize.plugin.js

@@ -0,0 +1,385 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { getItemByIndex } from "../../store/index";
+import { BasePlugin } from "../base.plugin";
+import { GROUP_EXPAND_EVENT } from "../groupingRow/grouping.const";
+import { clampRowResizeHeight, createRowResizePatch, getRowResizeIndexes, mergeRowResizeDefinitions, resolveRowResizeConfig, } from "./row-resize.utils";
+export const ROW_RESIZE_HANDLE_CLASS = 'row-resize-handle';
+export const BEFORE_ROW_RESIZE_EVENT = 'beforerowresize';
+export const ROW_RESIZE_EVENT = 'rowresize';
+export const AFTER_ROW_RESIZE_EVENT = 'afterrowresize';
+export const ROW_RESIZE_CANCEL_EVENT = 'rowresizecancel';
+export 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();
+    }
+}

package/dist/collection/plugins/row-resize/row-resize.types.js

@@ -0,0 +1 @@
+export {};