handsontable 18.0.0 → 18.1.0-rc7

package/plugins/mergeCells/mergeCells.mjs

@@ -104,8 +104,89 @@ var /**
    *
    * @type {boolean}
    */ _initialized = /*#__PURE__*/ new WeakMap(), /**
+   * Physical top-left (row/column) of every merged cell, captured while its visual coordinates are
+   * authoritative (creation, structural edits). Read on a pure row-trimming change to re-anchor the
+   * merge's visual `row`/`col` onto the rows that stay visible — keeping the merge whole (span
+   * unchanged) instead of clipping it. Physical indexes are stable across trimming, so one capture
+   * survives any number of filter/trim toggles.
+   *
+   * @type {WeakMap<MergedCellCoords, { physicalRow: number, physicalColumn: number }>}
+   */ _mergeAnchors = /*#__PURE__*/ new WeakMap(), /**
+   * Merges whose entire row span is currently trimmed, so they have been removed from the lookup
+   * matrix to avoid colliding with whatever physical row later surfaces at their stale visual slot.
+   * Tracked so that when such a merge becomes visible again it is force-added back to the matrix even
+   * if it lands on the exact visual `row`/`col` it held before being purged (where the
+   * "skip when unchanged" relocation optimization would otherwise leave it absent).
+   *
+   * @type {WeakSet<MergedCellCoords>}
+   */ _purgedMerges = /*#__PURE__*/ new WeakMap(), /**
+   * Eagerly removes the merge-related cell meta (`hidden`, `copyable`, `spanned`, `rowspan`,
+   * `colspan`) for every cell covered by the provided merged cell. Done at the moment the merge
+   * is dropped — rather than lazily in `afterGetCellMeta` — so the stale flags cannot linger in
+   * the cached meta and leak into consumers that read it directly (e.g. `toHTML`) when the
+   * following render is suspended/batched and never actually runs.
+   *
+   * @param {MergedCellCoords} mergedCell The merged cell whose meta should be reset.
+   */ _resetMergedCellMeta = /*#__PURE__*/ new WeakSet(), /**
    * `afterInit` hook callback.
    */ _onAfterInit = /*#__PURE__*/ new WeakMap(), /**
+   * `afterMergeCells` hook callback. Captures the physical anchor of the just-created merge so it can
+   * be re-anchored on later trimming changes (covers user/API merges; config merges are also captured
+   * in `afterInit`/`updatePlugin`).
+   *
+   * @param {CellRange} _cellRange The merged range (unused).
+   * @param {{ row: number, col: number, rowspan: number, colspan: number }} mergeParent The merged cell.
+   */ _onAfterMergeCellsCapture = /*#__PURE__*/ new WeakMap(), /**
+   * Row index mapper `cacheUpdated` callback. Re-anchors every merge onto its physical anchor's current
+   * visual position after any index-mapper cache change — a visibility change (Filters / `trimRows` /
+   * `nestedRows` collapse / `hiddenRows`) or an index-sequence change (a sort / move). The re-anchor is
+   * anchor-based and idempotent, and this hook fires after the mapper cache has been (re)built —
+   * including once at the end of a batched `suspendOperations`/`resumeOperations` block — so it is the
+   * authoritative place to position merges: it covers a plain filter, a sort and a filter batched
+   * together, and a standalone batched sort (where re-anchoring inside the in-batch `afterColumnSort`
+   * hook used to read a stale, pre-sort cache). Row/column moves additionally translate (and split)
+   * spans in their `afterRowMove`/`afterColumnMove` hooks; this re-anchor runs on top of that authoritative
+   * translation as a no-op.
+   *
+   * @param {{ trimmedIndexesChanged: boolean, hiddenIndexesChanged: boolean, indexesSequenceChanged:
+   *   boolean }} changes Cache flags.
+   */ _onRowIndexCacheUpdated = /*#__PURE__*/ new WeakMap(), /**
+   * Captures the physical top-left of a single merge from its current visual coords. While row
+   * trimming is active the merge's visual `row` may be a re-anchored, derived value (set by
+   * {@link MergeCells#reanchorMergesToVisibleRows}), so re-deriving the physical row from it would
+   * corrupt the authoritative anchor captured earlier — the previously stored `physicalRow` is kept
+   * instead. The column is never distorted by row trimming, so it is always refreshed (covering
+   * column insert/remove performed while a filter is active). A merge with no anchor yet (e.g. created
+   * during an active filter) is captured best-effort from its current, visible position.
+   *
+   * @param {MergedCellCoords} merge The merge to capture.
+   * @param {boolean} [trimmingActive] Whether row trimming is currently active (computed if omitted).
+   */ _captureAnchorOf = /*#__PURE__*/ new WeakSet(), /**
+   * Captures the physical top-left of every merge (after a bulk (re)generation).
+   */ _captureMergeAnchors = /*#__PURE__*/ new WeakSet(), /**
+   * Remaps the cached physical row of every merge's anchor after a row insert/remove. While trimming
+   * is active {@link MergeCells#captureAnchorOf} preserves the stored `physicalRow` verbatim, so the
+   * structural edit's physical renumbering has to be mirrored onto the cache here or re-anchoring would
+   * later target stale rows. Only merges still present in the collection are visited (fully removed ones
+   * were already dropped by `shiftCollections`), so each anchor always maps to a valid surviving row.
+   *
+   * @param {function(number): number} mapPhysicalRow Maps an old physical row to its new one.
+   */ _remapRowAnchors = /*#__PURE__*/ new WeakSet(), /**
+   * Whether any row is currently trimmed (Filters / `trimRows` / `nestedRows`). Trimming compresses
+   * the visual row space, so while it is active a merge's visual `row` may be a re-anchored, derived
+   * value rather than an authoritative one.
+   *
+   * @returns {boolean}
+   */ _isRowTrimmingActive = /*#__PURE__*/ new WeakSet(), /**
+   * Re-anchors every merge's visual `row`/`col` to the visual position of its captured physical
+   * top-left, keeping `rowspan`/`colspan`. The render translation then spans the merge over the
+   * visible rows from there. When the anchor's own physical row is hidden, the merge falls back to the
+   * topmost still-visible physical row within its span, so it follows the visible rows down instead of
+   * being left behind on a hidden row. Merges with no captured anchor are left untouched. Merges with
+   * a hidden anchor column or a fully hidden row span have no visible top-left, so they are purged
+   * from the lookup matrix (and re-added once they become visible again) to avoid leaving a stale
+   * entry that a later filter could resolve to as a phantom merge.
+   */ _reanchorMergesToVisibleRows = /*#__PURE__*/ new WeakSet(), /**
    * Modifies the information on whether the current selection contains multiple cells. The `afterIsMultipleSelection`
    * hook callback.
    *
@@ -189,6 +270,7 @@ var /**
    *
    * @param {number} row Row index.
    * @param {number} count Number of removed rows.
+   * @param {number[]} physicalRows Physical indexes of the removed rows.
    */ _onAfterRemoveRow = /*#__PURE__*/ new WeakMap(), /**
    * `beforeColumnMove` hook callback. Captures physical column positions of every merge
    * so they can be translated onto the new visual order in `afterColumnMove`.
@@ -268,6 +350,12 @@ var /**
    * @param {MouseEvent | KeyboardEvent} event The event which was responsible for opening the editor.
    * @returns {boolean | undefined}
    */ _onBeforeBeginEditing = /*#__PURE__*/ new WeakMap(), /**
+   * Opts the table out of single-pass rendering while merged cells are present. A virtualized merged
+   * cell's height depends on which rows are in the viewport — the very thing the predicted layout is
+   * trying to compute — so merge tables keep the legacy measure-then-render path.
+   *
+   * @returns {boolean}
+   */ _onModifySinglePassLayout = /*#__PURE__*/ new WeakMap(), /**
    * Hook used to modify the row height depends on the merged cells in the row.
    *
    * @param {number} height The row height value provided by the Core.
@@ -402,17 +490,23 @@ var /**
         this.addHook('beforeRemoveCellClassNames', _class_private_field_get(this, _onBeforeRemoveCellClassNames));
         this.addHook('beforeBeginEditing', _class_private_field_get(this, _onBeforeBeginEditing));
         this.addHook('modifyRowHeightByOverlayName', _class_private_field_get(this, _onModifyRowHeightByOverlayName));
+        this.addHook('modifySinglePassLayout', _class_private_field_get(this, _onModifySinglePassLayout));
         this.addHook('beforeUndoStackChange', (action, source)=>{
             if (source === 'MergeCells') {
                 return false;
             }
         });
+        this.addHook('afterMergeCells', _class_private_field_get(this, _onAfterMergeCellsCapture));
         this.registerShortcuts();
+        // React to the row trimming map changing (Filters / `trimRows` / `nestedRows` collapse), so a
+        // merge whose anchor row gets hidden is re-anchored onto the still-visible rows.
+        this.hot.rowIndexMapper.addLocalHook('cacheUpdated', _class_private_field_get(this, _onRowIndexCacheUpdated));
         super.enablePlugin();
     }
     /**
    * Disables the plugin functionality for this Handsontable instance.
    */ disablePlugin() {
+        this.hot.rowIndexMapper.removeLocalHook('cacheUpdated', _class_private_field_get(this, _onRowIndexCacheUpdated));
         this.clearCollections();
         this.unregisterShortcuts();
         this.hot.render();
@@ -420,6 +514,13 @@ var /**
         super.disablePlugin();
     }
     /**
+   * Destroys the plugin instance. Removes the row index mapper local hook explicitly, because
+   * `BasePlugin#destroy` only clears `addHook`-managed hooks, not raw `addLocalHook` registrations.
+   */ destroy() {
+        this.hot?.rowIndexMapper.removeLocalHook('cacheUpdated', _class_private_field_get(this, _onRowIndexCacheUpdated));
+        super.destroy();
+    }
+    /**
    * Updates the plugin's state.
    *
    * This method is executed when [`updateSettings()`](@/api/core.md#updatesettings) is invoked with any of the
@@ -430,6 +531,7 @@ var /**
         this.enablePlugin();
         this.generateFromSettings();
         _class_private_field_set(this, _initialized, true);
+        _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
         super.updatePlugin();
     }
     /**
@@ -543,6 +645,9 @@ var /**
     /**
    * Clears the merged cells from the merged cell container.
    */ clearCollections() {
+        arrayEach(this.mergedCellsCollection.mergedCells, (mergedCell)=>{
+            _class_private_method_get(this, _resetMergedCellMeta, resetMergedCellMeta).call(this, mergedCell);
+        });
         this.mergedCellsCollection.clear();
     }
     /**
@@ -667,13 +772,7 @@ var /**
         this.hot.runHooks('beforeUnmergeCells', cellRange, auto);
         arrayEach(mergedCells, (currentCollection)=>{
             this.mergedCellsCollection.remove(currentCollection.row, currentCollection.col);
-            rangeEach(0, currentCollection.rowspan - 1, (i)=>{
-                rangeEach(0, currentCollection.colspan - 1, (j)=>{
-                    this.hot.removeCellMeta(currentCollection.row + i, currentCollection.col + j, 'hidden');
-                    this.hot.removeCellMeta(currentCollection.row + i, currentCollection.col + j, 'copyable');
-                });
-            });
-            this.hot.removeCellMeta(currentCollection.row, currentCollection.col, 'spanned');
+            _class_private_method_get(this, _resetMergedCellMeta, resetMergedCellMeta).call(this, currentCollection);
         });
         this.hot.runHooks('afterUnmergeCells', cellRange, auto);
         this.hot.render();
@@ -699,10 +798,10 @@ var /**
     /**
    * Merges the specified range.
    *
-   * @param {number} startRow Start row of the merged cell.
-   * @param {number} startColumn Start column of the merged cell.
-   * @param {number} endRow End row of the merged cell.
-   * @param {number} endColumn End column of the merged cell.
+   * @param {number} startRow Visual start row of the merged cell.
+   * @param {number} startColumn Visual start column of the merged cell.
+   * @param {number} endRow Visual end row of the merged cell.
+   * @param {number} endColumn Visual end column of the merged cell.
    * @fires Hooks#beforeMergeCells
    * @fires Hooks#afterMergeCells
    */ merge(startRow, startColumn, endRow, endColumn) {
@@ -713,10 +812,10 @@ var /**
     /**
    * Unmerges the merged cell in the provided range.
    *
-   * @param {number} startRow Start row of the merged cell.
-   * @param {number} startColumn Start column of the merged cell.
-   * @param {number} endRow End row of the merged cell.
-   * @param {number} endColumn End column of the merged cell.
+   * @param {number} startRow Visual start row of the merged cell.
+   * @param {number} startColumn Visual start column of the merged cell.
+   * @param {number} endRow Visual end row of the merged cell.
+   * @param {number} endColumn Visual end column of the merged cell.
    * @fires Hooks#beforeUnmergeCells
    * @fires Hooks#afterUnmergeCells
    */ unmerge(startRow, startColumn, endRow, endColumn) {
@@ -770,16 +869,15 @@ var /**
    */ modifyViewportRowStart(calc, nrOfColumns) {
         const rowMapper = this.hot.rowIndexMapper;
         const visualStartRow = rowMapper.getVisualFromRenderableIndex(calc.startRow) ?? 0;
-        for(let visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1){
-            const mergeParentForViewportStart = this.mergedCellsCollection.get(visualStartRow, visualColumnIndex);
-            if (mergeParentForViewportStart !== false) {
-                const nearestNotHiddenRow = rowMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.row, 1);
-                const renderableIndexAtMergeStart = nearestNotHiddenRow !== null ? rowMapper.getRenderableFromVisualIndex(nearestNotHiddenRow) : null;
-                if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startRow) {
-                    calc.startRow = renderableIndexAtMergeStart;
-                    this.modifyViewportRowStart(calc, nrOfColumns);
-                    return;
-                }
+        const mergedCellsWithinRow = this.mergedCellsCollection.getByVisualRow(visualStartRow);
+        for(let i = 0; i < mergedCellsWithinRow.length; i += 1){
+            const mergeParentForViewportStart = mergedCellsWithinRow[i];
+            const nearestNotHiddenRow = rowMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.row, 1);
+            const renderableIndexAtMergeStart = nearestNotHiddenRow !== null ? rowMapper.getRenderableFromVisualIndex(nearestNotHiddenRow) : null;
+            if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startRow) {
+                calc.startRow = renderableIndexAtMergeStart;
+                this.modifyViewportRowStart(calc, nrOfColumns);
+                return;
             }
         }
     }
@@ -792,18 +890,17 @@ var /**
    */ modifyViewportRowEnd(calc, nrOfColumns) {
         const rowMapper = this.hot.rowIndexMapper;
         const visualEndRow = rowMapper.getVisualFromRenderableIndex(calc.endRow) ?? 0;
-        for(let visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1){
-            const mergeParentForViewportEnd = this.mergedCellsCollection.get(visualEndRow, visualColumnIndex);
-            if (mergeParentForViewportEnd !== false) {
-                const mergeEnd = mergeParentForViewportEnd.row + mergeParentForViewportEnd.rowspan - 1;
-                const nearestRow = rowMapper.getNearestNotHiddenIndex(mergeEnd, -1);
-                if (nearestRow !== null) {
-                    const renderableIndexAtMergeEnd = rowMapper.getRenderableFromVisualIndex(nearestRow);
-                    if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endRow) {
-                        calc.endRow = renderableIndexAtMergeEnd;
-                        this.modifyViewportRowEnd(calc, nrOfColumns);
-                        return;
-                    }
+        const mergedCellsWithinRow = this.mergedCellsCollection.getByVisualRow(visualEndRow);
+        for(let i = 0; i < mergedCellsWithinRow.length; i += 1){
+            const mergeParentForViewportEnd = mergedCellsWithinRow[i];
+            const mergeEnd = mergeParentForViewportEnd.row + mergeParentForViewportEnd.rowspan - 1;
+            const nearestRow = rowMapper.getNearestNotHiddenIndex(mergeEnd, -1);
+            if (nearestRow !== null) {
+                const renderableIndexAtMergeEnd = rowMapper.getRenderableFromVisualIndex(nearestRow);
+                if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endRow) {
+                    calc.endRow = renderableIndexAtMergeEnd;
+                    this.modifyViewportRowEnd(calc, nrOfColumns);
+                    return;
                 }
             }
         }
@@ -817,17 +914,16 @@ var /**
    */ modifyViewportColumnStart(calc, nrOfRows) {
         const columnMapper = this.hot.columnIndexMapper;
         const visualStartCol = columnMapper.getVisualFromRenderableIndex(calc.startColumn) ?? 0;
-        for(let visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1){
-            const mergeParentForViewportStart = this.mergedCellsCollection.get(visualRowIndex, visualStartCol);
-            if (mergeParentForViewportStart !== false) {
-                const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.col, 1);
-                if (nearestCol !== null) {
-                    const renderableIndexAtMergeStart = columnMapper.getRenderableFromVisualIndex(nearestCol);
-                    if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startColumn) {
-                        calc.startColumn = renderableIndexAtMergeStart;
-                        this.modifyViewportColumnStart(calc, nrOfRows);
-                        return;
-                    }
+        const mergedCellsWithinColumn = this.mergedCellsCollection.getByVisualColumn(visualStartCol);
+        for(let i = 0; i < mergedCellsWithinColumn.length; i += 1){
+            const mergeParentForViewportStart = mergedCellsWithinColumn[i];
+            const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeParentForViewportStart.col, 1);
+            if (nearestCol !== null) {
+                const renderableIndexAtMergeStart = columnMapper.getRenderableFromVisualIndex(nearestCol);
+                if (renderableIndexAtMergeStart !== null && renderableIndexAtMergeStart < calc.startColumn) {
+                    calc.startColumn = renderableIndexAtMergeStart;
+                    this.modifyViewportColumnStart(calc, nrOfRows);
+                    return;
                 }
             }
         }
@@ -841,18 +937,17 @@ var /**
    */ modifyViewportColumnEnd(calc, nrOfRows) {
         const columnMapper = this.hot.columnIndexMapper;
         const visualEndCol = columnMapper.getVisualFromRenderableIndex(calc.endColumn) ?? 0;
-        for(let visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1){
-            const mergeParentForViewportEnd = this.mergedCellsCollection.get(visualRowIndex, visualEndCol);
-            if (mergeParentForViewportEnd !== false) {
-                const mergeEnd = mergeParentForViewportEnd.col + mergeParentForViewportEnd.colspan - 1;
-                const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeEnd, -1);
-                if (nearestCol !== null) {
-                    const renderableIndexAtMergeEnd = columnMapper.getRenderableFromVisualIndex(nearestCol);
-                    if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endColumn) {
-                        calc.endColumn = renderableIndexAtMergeEnd;
-                        this.modifyViewportColumnEnd(calc, nrOfRows);
-                        return;
-                    }
+        const mergedCellsWithinColumn = this.mergedCellsCollection.getByVisualColumn(visualEndCol);
+        for(let i = 0; i < mergedCellsWithinColumn.length; i += 1){
+            const mergeParentForViewportEnd = mergedCellsWithinColumn[i];
+            const mergeEnd = mergeParentForViewportEnd.col + mergeParentForViewportEnd.colspan - 1;
+            const nearestCol = columnMapper.getNearestNotHiddenIndex(mergeEnd, -1);
+            if (nearestCol !== null) {
+                const renderableIndexAtMergeEnd = columnMapper.getRenderableFromVisualIndex(nearestCol);
+                if (renderableIndexAtMergeEnd !== null && renderableIndexAtMergeEnd > calc.endColumn) {
+                    calc.endColumn = renderableIndexAtMergeEnd;
+                    this.modifyViewportColumnEnd(calc, nrOfRows);
+                    return;
                 }
             }
         }
@@ -888,7 +983,7 @@ var /**
         ];
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _addMergeActionsToContextMenu), _class_private_field_init(this, _lastSelectedFocus, {
+        super(...args), _class_private_method_init(this, _resetMergedCellMeta), _class_private_method_init(this, _captureAnchorOf), _class_private_method_init(this, _captureMergeAnchors), _class_private_method_init(this, _remapRowAnchors), _class_private_method_init(this, _isRowTrimmingActive), _class_private_method_init(this, _reanchorMergesToVisibleRows), _class_private_method_init(this, _addMergeActionsToContextMenu), _class_private_field_init(this, _lastSelectedFocus, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _lastFocusDelta, {
@@ -909,9 +1004,21 @@ var /**
         }), _class_private_field_init(this, _initialized, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _mergeAnchors, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _purgedMerges, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onAfterInit, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onAfterMergeCellsCapture, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onRowIndexCacheUpdated, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onAfterIsMultipleSelection, {
             writable: true,
             value: void 0
@@ -999,6 +1106,9 @@ var /**
         }), _class_private_field_init(this, _onBeforeBeginEditing, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onModifySinglePassLayout, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onModifyRowHeightByOverlayName, {
             writable: true,
             value: void 0
@@ -1009,10 +1119,25 @@ var /**
             mergedCellsGetter: (row, column)=>this.mergedCellsCollection.get(row, column),
             rowIndexMapper: this.hot.rowIndexMapper,
             columnIndexMapper: this.hot.columnIndexMapper
-        })), _class_private_field_set(this, _cellRenderer, createMergeCellRenderer(this)), _class_private_field_set(this, _columnMoveSnapshot, null), _class_private_field_set(this, _rowMoveSnapshot, null), _class_private_field_set(this, _initialized, false), _class_private_field_set(this, _onAfterInit, ()=>{
+        })), _class_private_field_set(this, _cellRenderer, createMergeCellRenderer(this)), _class_private_field_set(this, _columnMoveSnapshot, null), _class_private_field_set(this, _rowMoveSnapshot, null), _class_private_field_set(this, _initialized, false), _class_private_field_set(this, _mergeAnchors, new WeakMap()), _class_private_field_set(this, _purgedMerges, new WeakSet()), _class_private_field_set(this, _onAfterInit, ()=>{
             this.generateFromSettings();
             this.hot.render();
             _class_private_field_set(this, _initialized, true);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
+        }), _class_private_field_set(this, _onAfterMergeCellsCapture, (_cellRange, mergeParent)=>{
+            const merge = this.mergedCellsCollection.get(mergeParent.row, mergeParent.col);
+            if (merge) {
+                _class_private_method_get(this, _captureAnchorOf, captureAnchorOf).call(this, merge);
+            }
+        }), _class_private_field_set(this, _onRowIndexCacheUpdated, ({ trimmedIndexesChanged, hiddenIndexesChanged, indexesSequenceChanged })=>{
+            // The hook is removed in `disablePlugin`/`destroy`, but keep a defensive guard in case a final
+            // `updateCache` still reaches us after `this.hot` has been dropped.
+            if (!this.hot || !_class_private_field_get(this, _initialized)) {
+                return;
+            }
+            if (trimmedIndexesChanged || hiddenIndexesChanged || indexesSequenceChanged) {
+                _class_private_method_get(this, _reanchorMergesToVisibleRows, reanchorMergesToVisibleRows).call(this);
+            }
         }), _class_private_field_set(this, _onAfterIsMultipleSelection, (isMultiple)=>{
             if (isMultiple) {
                 const mergedCells = this.mergedCellsCollection.mergedCells;
@@ -1343,15 +1468,47 @@ var /**
             return this.autofillCalculations.snapDragArea(baseArea, fullArea, dragDirection, mergedCellsWithinSelectionArea);
         }), _class_private_field_set(this, _onAfterCreateCol, (column, count)=>{
             this.mergedCellsCollection.shiftCollections('right', column, count);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
+            // `shiftCollections` rebuilt the matrix from every merge, re-adding any currently purged
+            // (fully hidden) merge; re-anchor to drop those stale footprints again.
+            _class_private_method_get(this, _reanchorMergesToVisibleRows, reanchorMergesToVisibleRows).call(this);
         }), _class_private_field_set(this, _onAfterRemoveCol, (column, count)=>{
             this.mergedCellsCollection.shiftCollections('left', column, count);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
+            // `shiftCollections` rebuilt the matrix from every merge, re-adding any currently purged
+            // (fully hidden) merge; re-anchor to drop those stale footprints again.
+            _class_private_method_get(this, _reanchorMergesToVisibleRows, reanchorMergesToVisibleRows).call(this);
         }), _class_private_field_set(this, _onAfterCreateRow, (row, count, source)=>{
             if (source === 'auto') {
                 return;
             }
             this.mergedCellsCollection.shiftCollections('down', row, count);
-        }), _class_private_field_set(this, _onAfterRemoveRow, (row, count)=>{
+            // Inserting renumbers physical rows at/after the insertion point up by `count`; mirror that onto the
+            // anchors the trimming-active path keeps verbatim (the non-trimming path re-derives them below).
+            if (_class_private_method_get(this, _isRowTrimmingActive, isRowTrimmingActive).call(this)) {
+                const pivot = this.hot.toPhysicalRow(row);
+                if (pivot !== null) {
+                    _class_private_method_get(this, _remapRowAnchors, remapRowAnchors).call(this, (physicalRow)=>physicalRow >= pivot ? physicalRow + count : physicalRow);
+                }
+            }
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
+            // `shiftCollections` rebuilt the matrix from every merge, re-adding any currently purged
+            // (fully hidden) merge; re-anchor to drop those stale footprints again.
+            _class_private_method_get(this, _reanchorMergesToVisibleRows, reanchorMergesToVisibleRows).call(this);
+        }), _class_private_field_set(this, _onAfterRemoveRow, (row, count, physicalRows)=>{
             this.mergedCellsCollection.shiftCollections('up', row, count);
+            // Removing renumbers each surviving physical row down by how many removed rows sat below it; mirror
+            // that onto the anchors the trimming-active path keeps verbatim. Removed physical rows interleave
+            // with trimmed ones, so the shift is counted per anchor rather than from a single pivot. An anchor
+            // whose own row was removed collapses to the same index as its first surviving span row, so it needs
+            // no special case.
+            if (_class_private_method_get(this, _isRowTrimmingActive, isRowTrimmingActive).call(this) && Array.isArray(physicalRows)) {
+                _class_private_method_get(this, _remapRowAnchors, remapRowAnchors).call(this, (physicalRow)=>physicalRow - physicalRows.reduce((shift, removed)=>shift + (removed < physicalRow ? 1 : 0), 0));
+            }
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
+            // `shiftCollections` rebuilt the matrix from every merge, re-adding any currently purged
+            // (fully hidden) merge; re-anchor to drop those stale footprints again.
+            _class_private_method_get(this, _reanchorMergesToVisibleRows, reanchorMergesToVisibleRows).call(this);
         }), _class_private_field_set(this, _onBeforeColumnMove, (_columns, _finalIndex, _dropIndex, movePossible)=>{
             if (!movePossible || !_class_private_field_get(this, _initialized)) {
                 _class_private_field_set(this, _columnMoveSnapshot, null);
@@ -1365,6 +1522,7 @@ var /**
                 return;
             }
             this.mergedCellsCollection.translateAfterAxisMove('column', snapshot);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
             this.hot.render();
         }), _class_private_field_set(this, _onBeforeRowMove, (_rows, _finalIndex, _dropIndex, movePossible)=>{
             if (!movePossible || !_class_private_field_get(this, _initialized)) {
@@ -1379,6 +1537,7 @@ var /**
                 return;
             }
             this.mergedCellsCollection.translateAfterAxisMove('row', snapshot);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
             this.hot.render();
         }), _class_private_field_set(this, _onBeforeColumnFreeze, (_column, performed)=>{
             if (!performed || !_class_private_field_get(this, _initialized)) {
@@ -1393,6 +1552,7 @@ var /**
                 return;
             }
             this.mergedCellsCollection.translateAfterAxisMove('column', snapshot);
+            _class_private_method_get(this, _captureMergeAnchors, captureMergeAnchors).call(this);
             this.hot.render();
         }), _class_private_field_set(this, _onAfterChange, (changes, source)=>{
             if (source !== 'Autofill.fill') {
@@ -1436,7 +1596,7 @@ var /**
             const from = this.hot._createCellCoords(mergeCell.row, mergeCell.col);
             const to = this.hot._createCellCoords(mergeCell.row + mergeCell.rowspan - 1, mergeCell.col + mergeCell.colspan - 1);
             return this.hot.selection.getLayerLevel() === 0 && selection.isEqual(this.hot._createCellRange(from, from, to));
-        }), _class_private_field_set(this, _onModifyRowHeightByOverlayName, (height, row, overlayType)=>{
+        }), _class_private_field_set(this, _onModifySinglePassLayout, ()=>false), _class_private_field_set(this, _onModifyRowHeightByOverlayName, (height, row, overlayType)=>{
             if (this.hot.getSettings().rowHeaders || // merged cells do not work with the bottom overlays
             overlayType === 'bottom' || overlayType === 'bottom_inline_start_corner') {
                 return height;
@@ -1484,6 +1644,104 @@ var /**
         });
     }
 }
+function resetMergedCellMeta(mergedCell) {
+    rangeEach(0, mergedCell.rowspan - 1, (i)=>{
+        rangeEach(0, mergedCell.colspan - 1, (j)=>{
+            this.hot.removeCellMeta(mergedCell.row + i, mergedCell.col + j, 'hidden');
+            this.hot.removeCellMeta(mergedCell.row + i, mergedCell.col + j, 'copyable');
+        });
+    });
+    this.hot.removeCellMeta(mergedCell.row, mergedCell.col, 'spanned');
+    this.hot.removeCellMeta(mergedCell.row, mergedCell.col, 'rowspan');
+    this.hot.removeCellMeta(mergedCell.row, mergedCell.col, 'colspan');
+}
+function captureAnchorOf(merge, trimmingActive = _class_private_method_get(this, _isRowTrimmingActive, isRowTrimmingActive).call(this)) {
+    const physicalColumn = this.hot.toPhysicalColumn(merge.col);
+    if (physicalColumn === null) {
+        return;
+    }
+    const existing = _class_private_field_get(this, _mergeAnchors).get(merge);
+    const physicalRow = trimmingActive && existing ? existing.physicalRow : this.hot.toPhysicalRow(merge.row);
+    if (physicalRow !== null) {
+        _class_private_field_get(this, _mergeAnchors).set(merge, {
+            physicalRow,
+            physicalColumn
+        });
+    }
+}
+function captureMergeAnchors() {
+    const trimmingActive = _class_private_method_get(this, _isRowTrimmingActive, isRowTrimmingActive).call(this);
+    this.mergedCellsCollection.mergedCells.forEach((merge)=>_class_private_method_get(this, _captureAnchorOf, captureAnchorOf).call(this, merge, trimmingActive));
+}
+function remapRowAnchors(mapPhysicalRow) {
+    this.mergedCellsCollection.mergedCells.forEach((merge)=>{
+        const anchor = _class_private_field_get(this, _mergeAnchors).get(merge);
+        if (!anchor) {
+            return;
+        }
+        const physicalRow = mapPhysicalRow(anchor.physicalRow);
+        if (physicalRow !== anchor.physicalRow) {
+            _class_private_field_get(this, _mergeAnchors).set(merge, {
+                physicalRow,
+                physicalColumn: anchor.physicalColumn
+            });
+        }
+    });
+}
+function isRowTrimmingActive() {
+    const { rowIndexMapper } = this.hot;
+    return rowIndexMapper.getNotTrimmedIndexesLength() < rowIndexMapper.getNumberOfIndexes();
+}
+function reanchorMergesToVisibleRows() {
+    const { mergedCells } = this.mergedCellsCollection;
+    // `cacheUpdated` fires on every filter/trim toggle, so bail out cheaply when there is nothing to
+    // re-anchor.
+    if (mergedCells.length === 0) {
+        return;
+    }
+    const relocations = [];
+    const purges = [];
+    mergedCells.forEach((merge)=>{
+        const anchor = _class_private_field_get(this, _mergeAnchors).get(merge);
+        if (!anchor) {
+            return;
+        }
+        const visualColumn = this.hot.toVisualColumn(anchor.physicalColumn);
+        let visualRow = visualColumn === null ? null : this.hot.toVisualRow(anchor.physicalRow);
+        // Anchor row hidden: re-anchor to the first still-visible physical row inside the span (the span
+        // covers physical rows `[physicalRow, physicalRow + rowspan)` since anchors are captured while
+        // the merge is fully visible).
+        for(let offset = 1; visualColumn !== null && visualRow === null && offset < merge.rowspan; offset++){
+            visualRow = this.hot.toVisualRow(anchor.physicalRow + offset);
+        }
+        // No visible top-left (whole row span or the anchor column is hidden): drop the stale matrix
+        // entry so a later filter showing a different physical row at the same visual slot does not
+        // resolve to this phantom merge. Always re-purge (removing an absent footprint is a cheap no-op)
+        // so the entry stays gone even after `shiftCollections` rebuilds the matrix from every merge on a
+        // structural edit.
+        if (visualColumn === null || visualRow === null) {
+            _class_private_field_get(this, _purgedMerges).add(merge);
+            purges.push(merge);
+            return;
+        }
+        // Force a relocation for a merge that re-enters the viewport so it is re-added to the matrix even
+        // when it lands on the same visual coordinates it had before being purged.
+        const wasPurged = _class_private_field_get(this, _purgedMerges).delete(merge);
+        if (wasPurged || merge.row !== visualRow || merge.col !== visualColumn) {
+            relocations.push({
+                mergedCell: merge,
+                row: visualRow,
+                col: visualColumn
+            });
+        }
+    });
+    if (purges.length > 0) {
+        this.mergedCellsCollection.removeFromMatrix(purges);
+    }
+    if (relocations.length > 0) {
+        this.mergedCellsCollection.relocateInMatrix(relocations);
+    }
+}
 function addMergeActionsToContextMenu(defaultOptions) {
     defaultOptions.items.push({
         name: '---------'

package/plugins/moveCells/helpers.d.mts

@@ -0,0 +1 @@
+export * from './helpers.js';

package/plugins/moveCells/helpers.d.ts

@@ -0,0 +1,21 @@
+interface ClampMoveTargetOptions {
+    pointerRow: number;
+    pointerCol: number;
+    grabRowOffset: number;
+    grabColOffset: number;
+    rangeHeight: number;
+    rangeWidth: number;
+    totalRows: number;
+    totalCols: number;
+}
+/**
+ * Computes the clamped top-left target cell for a move.
+ *
+ * @param {ClampMoveTargetOptions} options The pointer, grab offset, range dimensions, and grid extents.
+ * @returns {{ row: number, col: number }} The clamped top-left target coordinates.
+ */
+export declare function clampMoveTarget({ pointerRow, pointerCol, grabRowOffset, grabColOffset, rangeHeight, rangeWidth, totalRows, totalCols, }: ClampMoveTargetOptions): {
+    row: number;
+    col: number;
+};
+export {};

package/plugins/moveCells/helpers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "clampMoveTarget", {
+    enumerable: true,
+    get: function() {
+        return clampMoveTarget;
+    }
+});
+function clampMoveTarget({ pointerRow, pointerCol, grabRowOffset, grabColOffset, rangeHeight, rangeWidth, totalRows, totalCols }) {
+    const rawRow = pointerRow - grabRowOffset;
+    const rawCol = pointerCol - grabColOffset;
+    const maxRow = Math.max(0, totalRows - rangeHeight);
+    const maxCol = Math.max(0, totalCols - rangeWidth);
+    return {
+        row: Math.min(Math.max(0, rawRow), maxRow),
+        col: Math.min(Math.max(0, rawCol), maxCol)
+    };
+}

package/plugins/moveCells/helpers.mjs

@@ -0,0 +1,15 @@
+/**
+ * Computes the clamped top-left target cell for a move.
+ *
+ * @param {ClampMoveTargetOptions} options The pointer, grab offset, range dimensions, and grid extents.
+ * @returns {{ row: number, col: number }} The clamped top-left target coordinates.
+ */ export function clampMoveTarget({ pointerRow, pointerCol, grabRowOffset, grabColOffset, rangeHeight, rangeWidth, totalRows, totalCols }) {
+    const rawRow = pointerRow - grabRowOffset;
+    const rawCol = pointerCol - grabColOffset;
+    const maxRow = Math.max(0, totalRows - rangeHeight);
+    const maxCol = Math.max(0, totalCols - rangeWidth);
+    return {
+        row: Math.min(Math.max(0, rawRow), maxRow),
+        col: Math.min(Math.max(0, rawCol), maxCol)
+    };
+}

package/plugins/moveCells/index.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/plugins/moveCells/index.d.ts

@@ -0,0 +1 @@
+export { PLUGIN_KEY, PLUGIN_PRIORITY, MoveCells, } from './moveCells';