handsontable 18.0.0 → 18.1.0-rc7

package/plugins/undoRedo/actions/index.js

@@ -16,6 +16,7 @@ const _createRow = require("./createRow");
 const _dataChange = require("./dataChange");
 const _filters = require("./filters");
 const _mergeCells = require("./mergeCells");
+const _moveCells = require("./moveCells");
 const _removeColumn = require("./removeColumn");
 const _removeRow = require("./removeRow");
 const _rowMove = require("./rowMove");
@@ -30,6 +31,7 @@ function registerActions(hot, undoRedoPlugin) {
         _dataChange.DataChangeAction,
         _filters.FiltersAction,
         _mergeCells.MergeCellsAction,
+        _moveCells.MoveCellsAction,
         _removeColumn.RemoveColumnAction,
         _removeRow.RemoveRowAction,
         _rowMove.RowMoveAction,

package/plugins/undoRedo/actions/index.mjs

@@ -6,6 +6,7 @@ import { CreateRowAction } from './createRow.mjs';
 import { DataChangeAction } from './dataChange.mjs';
 import { FiltersAction } from './filters.mjs';
 import { MergeCellsAction } from './mergeCells.mjs';
+import { MoveCellsAction } from './moveCells.mjs';
 import { RemoveColumnAction } from './removeColumn.mjs';
 import { RemoveRowAction } from './removeRow.mjs';
 import { RowMoveAction } from './rowMove.mjs';
@@ -25,6 +26,7 @@ import { UnmergeCellsAction } from './unmergeCells.mjs';
         DataChangeAction,
         FiltersAction,
         MergeCellsAction,
+        MoveCellsAction,
         RemoveColumnAction,
         RemoveRowAction,
         RowMoveAction,

package/plugins/undoRedo/actions/moveCells.d.mts

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

package/plugins/undoRedo/actions/moveCells.d.ts

@@ -0,0 +1,104 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import { BaseAction } from './_base';
+import type { MovableMetaEntry } from '../../../utils/movableMeta';
+/**
+ * A snapshot of the values and movable meta for a rectangular cell region.
+ */
+interface RegionSnapshot {
+    /**
+     * Top row of the region (visual).
+     */
+    fromRow: number;
+    /**
+     * Left column of the region (visual).
+     */
+    fromCol: number;
+    /**
+     * Bottom row of the region (visual).
+     */
+    toRow: number;
+    /**
+     * Right column of the region (visual).
+     */
+    toCol: number;
+    /**
+     * Source-format cell values (formula strings for formula cells).
+     */
+    data: unknown[][];
+    /**
+     * Sparse list of the cells that carried own movable meta — one entry per styled cell, not per
+     * region cell, so the snapshot (and the `deepClone` the undo stack runs over it) stays small
+     * for large unstyled regions.
+     */
+    meta: MovableMetaEntry[];
+}
+/**
+ * Action that tracks move-cells (drag-to-move selection) changes.
+ *
+ * A single undo step covers the whole move: it restores both the source region (overwritten
+ * with `null` on move) and the target region (overwritten with the moved data).
+ *
+ * @class MoveCellsAction
+ * @private
+ */
+export declare class MoveCellsAction extends BaseAction {
+    /**
+     * Source-region snapshot captured before the move.
+     */
+    sourceSnapshot: RegionSnapshot;
+    /**
+     * Target-region snapshot captured before the move (the overwritten data).
+     */
+    targetSnapshot: RegionSnapshot;
+    /**
+     * `true` when the operation was a copy (source is kept intact).
+     */
+    isCopy: boolean;
+    /**
+     * Initializes the action with snapshots of the source and target regions before the move.
+     */
+    constructor({ sourceSnapshot, targetSnapshot, isCopy, }: {
+        sourceSnapshot: RegionSnapshot;
+        targetSnapshot: RegionSnapshot;
+        isCopy: boolean;
+    });
+    /**
+     * Registers the `beforeMoveCells` hook listener that snapshots both the source and
+     * target regions before mutation, and then pushes a new `MoveCellsAction` into the
+     * undo stack via the `afterMoveCells` hook.
+     *
+     * Note: `afterMoveCells` only fires when the move was NOT vetoed. When `beforeMoveCells`
+     * returns `false` (or any guard in `moveCellRange` rejects the move), `afterMoveCells` is
+     * never called, so `pendingSnapshot` is simply overwritten on the next move attempt — a
+     * stale snapshot cannot enqueue a spurious undo action.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * Restores the grid to the state before the move.
+     *
+     * For a move (not copy): restores both the source region (which was cleared) and the
+     * target region (which was overwritten).
+     *
+     * For a copy: the source was not modified, so only the target region is restored.
+     *
+     * After restoring data, selects the source region to reflect the pre-move state.
+     *
+     * @param {HotInstance} hot The Handsontable instance.
+     * @param {HookCallback} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * Re-applies the move after it has been undone.
+     *
+     * After the move re-runs, selects the target region to reflect the post-move state.
+     *
+     * @param {HotInstance} hot The Handsontable instance.
+     * @param {(result?: { wasRedone?: boolean }) => void} redoneCallback The callback that settles
+     * the redo state.
+     */
+    redo(hot: HotInstance, redoneCallback: (result?: {
+        wasRedone?: boolean;
+    }) => void): void;
+}
+export {};

package/plugins/undoRedo/actions/moveCells.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MoveCellsAction", {
+    enumerable: true,
+    get: function() {
+        return MoveCellsAction;
+    }
+});
+const _range = require("../../../3rdparty/walkontable/src/cell/range");
+const _base = require("./_base");
+const _object = require("../../../helpers/object");
+const _movableMeta = require("../../../utils/movableMeta");
+/**
+ * Captures the source-format values and movable meta for a rectangular region.
+ *
+ * @param {HotInstance} hot The Handsontable instance.
+ * @param {number} fromRow Top row of the region (visual).
+ * @param {number} fromCol Left column of the region (visual).
+ * @param {number} toRow Bottom row of the region (visual).
+ * @param {number} toCol Right column of the region (visual).
+ * @returns {RegionSnapshot}
+ */ function snapshotRegion(hot, fromRow, fromCol, toRow, toCol) {
+    const data = [];
+    for(let r = fromRow; r <= toRow; r++){
+        const physicalRow = hot.toPhysicalRow(r);
+        const rowData = [];
+        for(let c = fromCol; c <= toCol; c++){
+            rowData.push(hot.getSourceDataAtCell(physicalRow, c));
+        }
+        data.push(rowData);
+    }
+    return {
+        fromRow,
+        fromCol,
+        toRow,
+        toCol,
+        data,
+        meta: (0, _movableMeta.collectMovableMeta)(hot, fromRow, fromCol, toRow, toCol)
+    };
+}
+/**
+ * Restores a previously snapshotted region — writes both the cell values and movable meta.
+ *
+ * @param {HotInstance} hot The Handsontable instance.
+ * @param {RegionSnapshot} snapshot The snapshot to restore.
+ */ function restoreRegion(hot, snapshot) {
+    const { fromRow, fromCol, toRow, toCol, data, meta } = snapshot;
+    // Restore values through populateFromArray which triggers the normal data-write path
+    // and lets the Formulas plugin re-register formula strings in HyperFormula.
+    hot.populateFromArray(fromRow, fromCol, data, toRow, toCol, 'UndoRedo.undo');
+    // Restore movable meta sparsely: clear the movable keys the region carries NOW that the
+    // snapshot does not record (they arrived with the move being undone), then write the recorded
+    // ones back. Scanning the current state instead of blanket-removing over the whole region keeps
+    // the per-cell `removeCellMeta` hook dispatch proportional to styled cells, not to region area.
+    const snapshotByCoord = new Map(meta.map((entry)=>[
+            `${entry.row}:${entry.col}`,
+            entry.meta
+        ]));
+    (0, _movableMeta.collectMovableMeta)(hot, fromRow, fromCol, toRow, toCol).forEach(({ row, col, meta: currentMeta })=>{
+        const recorded = snapshotByCoord.get(`${row}:${col}`);
+        for (const key of _movableMeta.MOVABLE_META_KEYS){
+            if ((0, _object.hasOwnProperty)(currentMeta, key) && !(recorded && (0, _object.hasOwnProperty)(recorded, key))) {
+                hot.removeCellMeta(row, col, key);
+            }
+        }
+    });
+    meta.forEach(({ row, col, meta: recordedMeta })=>{
+        for (const key of _movableMeta.MOVABLE_META_KEYS){
+            if ((0, _object.hasOwnProperty)(recordedMeta, key)) {
+                hot.setCellMeta(row, col, key, recordedMeta[key]);
+            }
+        }
+    });
+}
+class MoveCellsAction extends _base.BaseAction {
+    /**
+   * Registers the `beforeMoveCells` hook listener that snapshots both the source and
+   * target regions before mutation, and then pushes a new `MoveCellsAction` into the
+   * undo stack via the `afterMoveCells` hook.
+   *
+   * Note: `afterMoveCells` only fires when the move was NOT vetoed. When `beforeMoveCells`
+   * returns `false` (or any guard in `moveCellRange` rejects the move), `afterMoveCells` is
+   * never called, so `pendingSnapshot` is simply overwritten on the next move attempt — a
+   * stale snapshot cannot enqueue a spurious undo action.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
+        const plugin = undoRedoPlugin;
+        let pendingSnapshot = null;
+        hot.addHook('beforeMoveCells', (sourceRange, targetTopLeft, isCopy)=>{
+            // Covers the documented `false` veto value AND any garbage a preceding listener folded into
+            // the argument — `Hooks.run` threads a truthy return value into the next listener's first
+            // argument, and the global bucket runs before this one.
+            if (!(0, _range.isCellRangeLike)(sourceRange)) {
+                pendingSnapshot = null;
+                return false;
+            }
+            // `sourceRange` is narrowed by the guard above; `targetTopLeft` carries the raw CellCoords.
+            const src = sourceRange;
+            const target = targetTopLeft;
+            const topStart = src.getTopStartCorner();
+            const bottomEnd = src.getBottomEndCorner();
+            const fromRow = topStart.row;
+            const fromCol = topStart.col;
+            const toRow = bottomEnd.row;
+            const toCol = bottomEnd.col;
+            const height = toRow - fromRow + 1;
+            const width = toCol - fromCol + 1;
+            const targetBottom = target.row + height - 1;
+            const targetRight = target.col + width - 1;
+            // Capture both regions before any data mutation.
+            const sourceSnapshot = snapshotRegion(hot, fromRow, fromCol, toRow, toCol);
+            const targetSnapshot = snapshotRegion(hot, target.row, target.col, targetBottom, targetRight);
+            pendingSnapshot = {
+                sourceSnapshot,
+                targetSnapshot,
+                isCopy: isCopy
+            };
+        });
+        // afterMoveCells only fires when the move was NOT vetoed (see JSDoc on startRegisteringEvents),
+        // so the snapshot here is always valid and corresponds to the move that just completed.
+        hot.addHook('afterMoveCells', ()=>{
+            if (pendingSnapshot === null) {
+                return;
+            }
+            const snapshot = pendingSnapshot;
+            pendingSnapshot = null;
+            plugin.done(()=>new MoveCellsAction(snapshot));
+        });
+    }
+    /**
+   * Restores the grid to the state before the move.
+   *
+   * For a move (not copy): restores both the source region (which was cleared) and the
+   * target region (which was overwritten).
+   *
+   * For a copy: the source was not modified, so only the target region is restored.
+   *
+   * After restoring data, selects the source region to reflect the pre-move state.
+   *
+   * @param {HotInstance} hot The Handsontable instance.
+   * @param {HookCallback} undoneCallback The callback to be called after the action is undone.
+   */ undo(hot, undoneCallback) {
+        hot.batch(()=>{
+            // Restore the target region to what it held before the move.
+            restoreRegion(hot, this.targetSnapshot);
+            if (!this.isCopy) {
+                // Restore the source region which was cleared during the move.
+                restoreRegion(hot, this.sourceSnapshot);
+            }
+        });
+        hot.render();
+        hot.deselectCell();
+        const { fromRow, fromCol, toRow, toCol } = this.sourceSnapshot;
+        hot.selectCells([
+            [
+                fromRow,
+                fromCol,
+                toRow,
+                toCol
+            ]
+        ], false, false);
+        // Call undoneCallback after the batch and selection are settled. This mirrors
+        // the pattern in dataChange.ts and avoids the latent fragility of firing the
+        // callback inside an afterChange hook (which would break if afterChange becomes async).
+        // The undoneCallback resets ignoreNewActions in the UndoRedo plugin — calling it here
+        // ensures that reset happens after all data mutations are complete.
+        undoneCallback();
+    }
+    /**
+   * Re-applies the move after it has been undone.
+   *
+   * After the move re-runs, selects the target region to reflect the post-move state.
+   *
+   * @param {HotInstance} hot The Handsontable instance.
+   * @param {(result?: { wasRedone?: boolean }) => void} redoneCallback The callback that settles
+   * the redo state.
+   */ redo(hot, redoneCallback) {
+        const { fromRow, fromCol, toRow, toCol } = this.sourceSnapshot;
+        const { fromRow: targetRow, fromCol: targetCol } = this.targetSnapshot;
+        const height = toRow - fromRow + 1;
+        const width = toCol - fromCol + 1;
+        const sourceRange = hot._createCellRange(hot._createCellCoords(fromRow, fromCol), hot._createCellCoords(fromRow, fromCol), hot._createCellCoords(toRow, toCol));
+        const targetTopLeft = hot._createCellCoords(targetRow, targetCol);
+        const onAfterMoveCells = ()=>{
+            hot.render();
+            // Restore selection to the target range so the user sees where the data ended up.
+            const targetEndRow = targetRow + height - 1;
+            const targetEndCol = targetCol + width - 1;
+            hot.selectCells([
+                [
+                    targetRow,
+                    targetCol,
+                    targetEndRow,
+                    targetEndCol
+                ]
+            ], false, false);
+            redoneCallback();
+        };
+        const moveCells = hot.getPlugin('moveCells');
+        // `base.ts` is the tree-shakeable entry, so a consumer can register UndoRedo without MoveCells.
+        // The record path implies the plugin was present, but nothing guarantees it still is at redo time.
+        if (!moveCells) {
+            redoneCallback({
+                wasRedone: false
+            });
+            return;
+        }
+        hot.addHookOnce('afterMoveCells', onAfterMoveCells);
+        if (!moveCells.moveCellRange(sourceRange, targetTopLeft, this.isCopy)) {
+            hot.removeHook('afterMoveCells', onAfterMoveCells);
+            redoneCallback({
+                wasRedone: false
+            });
+        }
+    }
+    /**
+   * Initializes the action with snapshots of the source and target regions before the move.
+   */ constructor({ sourceSnapshot, targetSnapshot, isCopy }){
+        super('move_cells');
+        this.sourceSnapshot = sourceSnapshot;
+        this.targetSnapshot = targetSnapshot;
+        this.isCopy = isCopy;
+    }
+}

package/plugins/undoRedo/actions/moveCells.mjs

@@ -0,0 +1,227 @@
+import { isCellRangeLike } from '../../../3rdparty/walkontable/src/cell/range.mjs';
+import { BaseAction } from './_base.mjs';
+import { hasOwnProperty } from '../../../helpers/object.mjs';
+// Imported from the shared module rather than duplicated: undo must restore exactly the key set
+// `moveCellRange` moved, and two copies would silently drift the moment a key is added to one of
+// them. The module lives in `utils/` (not in the MoveCells plugin) so this action does not import
+// another plugin — registering just `UndoRedo` must not pull MoveCells code into the bundle.
+import { collectMovableMeta, MOVABLE_META_KEYS } from '../../../utils/movableMeta.mjs';
+/**
+ * Captures the source-format values and movable meta for a rectangular region.
+ *
+ * @param {HotInstance} hot The Handsontable instance.
+ * @param {number} fromRow Top row of the region (visual).
+ * @param {number} fromCol Left column of the region (visual).
+ * @param {number} toRow Bottom row of the region (visual).
+ * @param {number} toCol Right column of the region (visual).
+ * @returns {RegionSnapshot}
+ */ function snapshotRegion(hot, fromRow, fromCol, toRow, toCol) {
+    const data = [];
+    for(let r = fromRow; r <= toRow; r++){
+        const physicalRow = hot.toPhysicalRow(r);
+        const rowData = [];
+        for(let c = fromCol; c <= toCol; c++){
+            rowData.push(hot.getSourceDataAtCell(physicalRow, c));
+        }
+        data.push(rowData);
+    }
+    return {
+        fromRow,
+        fromCol,
+        toRow,
+        toCol,
+        data,
+        meta: collectMovableMeta(hot, fromRow, fromCol, toRow, toCol)
+    };
+}
+/**
+ * Restores a previously snapshotted region — writes both the cell values and movable meta.
+ *
+ * @param {HotInstance} hot The Handsontable instance.
+ * @param {RegionSnapshot} snapshot The snapshot to restore.
+ */ function restoreRegion(hot, snapshot) {
+    const { fromRow, fromCol, toRow, toCol, data, meta } = snapshot;
+    // Restore values through populateFromArray which triggers the normal data-write path
+    // and lets the Formulas plugin re-register formula strings in HyperFormula.
+    hot.populateFromArray(fromRow, fromCol, data, toRow, toCol, 'UndoRedo.undo');
+    // Restore movable meta sparsely: clear the movable keys the region carries NOW that the
+    // snapshot does not record (they arrived with the move being undone), then write the recorded
+    // ones back. Scanning the current state instead of blanket-removing over the whole region keeps
+    // the per-cell `removeCellMeta` hook dispatch proportional to styled cells, not to region area.
+    const snapshotByCoord = new Map(meta.map((entry)=>[
+            `${entry.row}:${entry.col}`,
+            entry.meta
+        ]));
+    collectMovableMeta(hot, fromRow, fromCol, toRow, toCol).forEach(({ row, col, meta: currentMeta })=>{
+        const recorded = snapshotByCoord.get(`${row}:${col}`);
+        for (const key of MOVABLE_META_KEYS){
+            if (hasOwnProperty(currentMeta, key) && !(recorded && hasOwnProperty(recorded, key))) {
+                hot.removeCellMeta(row, col, key);
+            }
+        }
+    });
+    meta.forEach(({ row, col, meta: recordedMeta })=>{
+        for (const key of MOVABLE_META_KEYS){
+            if (hasOwnProperty(recordedMeta, key)) {
+                hot.setCellMeta(row, col, key, recordedMeta[key]);
+            }
+        }
+    });
+}
+/**
+ * Action that tracks move-cells (drag-to-move selection) changes.
+ *
+ * A single undo step covers the whole move: it restores both the source region (overwritten
+ * with `null` on move) and the target region (overwritten with the moved data).
+ *
+ * @class MoveCellsAction
+ * @private
+ */ export class MoveCellsAction extends BaseAction {
+    /**
+   * Registers the `beforeMoveCells` hook listener that snapshots both the source and
+   * target regions before mutation, and then pushes a new `MoveCellsAction` into the
+   * undo stack via the `afterMoveCells` hook.
+   *
+   * Note: `afterMoveCells` only fires when the move was NOT vetoed. When `beforeMoveCells`
+   * returns `false` (or any guard in `moveCellRange` rejects the move), `afterMoveCells` is
+   * never called, so `pendingSnapshot` is simply overwritten on the next move attempt — a
+   * stale snapshot cannot enqueue a spurious undo action.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
+        const plugin = undoRedoPlugin;
+        let pendingSnapshot = null;
+        hot.addHook('beforeMoveCells', (sourceRange, targetTopLeft, isCopy)=>{
+            // Covers the documented `false` veto value AND any garbage a preceding listener folded into
+            // the argument — `Hooks.run` threads a truthy return value into the next listener's first
+            // argument, and the global bucket runs before this one.
+            if (!isCellRangeLike(sourceRange)) {
+                pendingSnapshot = null;
+                return false;
+            }
+            // `sourceRange` is narrowed by the guard above; `targetTopLeft` carries the raw CellCoords.
+            const src = sourceRange;
+            const target = targetTopLeft;
+            const topStart = src.getTopStartCorner();
+            const bottomEnd = src.getBottomEndCorner();
+            const fromRow = topStart.row;
+            const fromCol = topStart.col;
+            const toRow = bottomEnd.row;
+            const toCol = bottomEnd.col;
+            const height = toRow - fromRow + 1;
+            const width = toCol - fromCol + 1;
+            const targetBottom = target.row + height - 1;
+            const targetRight = target.col + width - 1;
+            // Capture both regions before any data mutation.
+            const sourceSnapshot = snapshotRegion(hot, fromRow, fromCol, toRow, toCol);
+            const targetSnapshot = snapshotRegion(hot, target.row, target.col, targetBottom, targetRight);
+            pendingSnapshot = {
+                sourceSnapshot,
+                targetSnapshot,
+                isCopy: isCopy
+            };
+        });
+        // afterMoveCells only fires when the move was NOT vetoed (see JSDoc on startRegisteringEvents),
+        // so the snapshot here is always valid and corresponds to the move that just completed.
+        hot.addHook('afterMoveCells', ()=>{
+            if (pendingSnapshot === null) {
+                return;
+            }
+            const snapshot = pendingSnapshot;
+            pendingSnapshot = null;
+            plugin.done(()=>new MoveCellsAction(snapshot));
+        });
+    }
+    /**
+   * Restores the grid to the state before the move.
+   *
+   * For a move (not copy): restores both the source region (which was cleared) and the
+   * target region (which was overwritten).
+   *
+   * For a copy: the source was not modified, so only the target region is restored.
+   *
+   * After restoring data, selects the source region to reflect the pre-move state.
+   *
+   * @param {HotInstance} hot The Handsontable instance.
+   * @param {HookCallback} undoneCallback The callback to be called after the action is undone.
+   */ undo(hot, undoneCallback) {
+        hot.batch(()=>{
+            // Restore the target region to what it held before the move.
+            restoreRegion(hot, this.targetSnapshot);
+            if (!this.isCopy) {
+                // Restore the source region which was cleared during the move.
+                restoreRegion(hot, this.sourceSnapshot);
+            }
+        });
+        hot.render();
+        hot.deselectCell();
+        const { fromRow, fromCol, toRow, toCol } = this.sourceSnapshot;
+        hot.selectCells([
+            [
+                fromRow,
+                fromCol,
+                toRow,
+                toCol
+            ]
+        ], false, false);
+        // Call undoneCallback after the batch and selection are settled. This mirrors
+        // the pattern in dataChange.ts and avoids the latent fragility of firing the
+        // callback inside an afterChange hook (which would break if afterChange becomes async).
+        // The undoneCallback resets ignoreNewActions in the UndoRedo plugin — calling it here
+        // ensures that reset happens after all data mutations are complete.
+        undoneCallback();
+    }
+    /**
+   * Re-applies the move after it has been undone.
+   *
+   * After the move re-runs, selects the target region to reflect the post-move state.
+   *
+   * @param {HotInstance} hot The Handsontable instance.
+   * @param {(result?: { wasRedone?: boolean }) => void} redoneCallback The callback that settles
+   * the redo state.
+   */ redo(hot, redoneCallback) {
+        const { fromRow, fromCol, toRow, toCol } = this.sourceSnapshot;
+        const { fromRow: targetRow, fromCol: targetCol } = this.targetSnapshot;
+        const height = toRow - fromRow + 1;
+        const width = toCol - fromCol + 1;
+        const sourceRange = hot._createCellRange(hot._createCellCoords(fromRow, fromCol), hot._createCellCoords(fromRow, fromCol), hot._createCellCoords(toRow, toCol));
+        const targetTopLeft = hot._createCellCoords(targetRow, targetCol);
+        const onAfterMoveCells = ()=>{
+            hot.render();
+            // Restore selection to the target range so the user sees where the data ended up.
+            const targetEndRow = targetRow + height - 1;
+            const targetEndCol = targetCol + width - 1;
+            hot.selectCells([
+                [
+                    targetRow,
+                    targetCol,
+                    targetEndRow,
+                    targetEndCol
+                ]
+            ], false, false);
+            redoneCallback();
+        };
+        const moveCells = hot.getPlugin('moveCells');
+        // `base.ts` is the tree-shakeable entry, so a consumer can register UndoRedo without MoveCells.
+        // The record path implies the plugin was present, but nothing guarantees it still is at redo time.
+        if (!moveCells) {
+            redoneCallback({
+                wasRedone: false
+            });
+            return;
+        }
+        hot.addHookOnce('afterMoveCells', onAfterMoveCells);
+        if (!moveCells.moveCellRange(sourceRange, targetTopLeft, this.isCopy)) {
+            hot.removeHook('afterMoveCells', onAfterMoveCells);
+            redoneCallback({
+                wasRedone: false
+            });
+        }
+    }
+    /**
+   * Initializes the action with snapshots of the source and target regions before the move.
+   */ constructor({ sourceSnapshot, targetSnapshot, isCopy }){
+        super('move_cells');
+        this.sourceSnapshot = sourceSnapshot;
+        this.targetSnapshot = targetSnapshot;
+        this.isCopy = isCopy;
+    }
+}

package/plugins/undoRedo/actions/removeColumn.d.ts

@@ -45,9 +45,19 @@ export declare class RemoveColumnAction extends BaseAction {
      */
     removedCellMetas: unknown[];
     /**
-     * Initializes the remove column action with the removed data, column indexes, headers, position sequences, and cell meta backup.
+     * @param {Array} removedMergedCells List of merged cell ranges that overlap the removed
+     *   columns. Stored as plain `{ row, col, rowspan, colspan }` objects in visual coords.
      */
-    constructor({ index, indexes, data, amount, headers, columnPositions, rowPositions, fixedColumnsStart, removedCellMetas }: {
+    removedMergedCells: {
+        row: number;
+        col: number;
+        rowspan: number;
+        colspan: number;
+    }[];
+    /**
+     * Initializes the remove column action with the removed data, column indexes, headers, position sequences, cell meta backup, and affected merged cells.
+     */
+    constructor({ index, indexes, data, amount, headers, columnPositions, rowPositions, fixedColumnsStart, removedCellMetas, removedMergedCells, }: {
         index: number;
         indexes: number[];
         data: unknown[][];
@@ -57,6 +67,12 @@ export declare class RemoveColumnAction extends BaseAction {
         rowPositions: number[];
         fixedColumnsStart: number;
         removedCellMetas: unknown[];
+        removedMergedCells: Array<{
+            row: number;
+            col: number;
+            rowspan: number;
+            colspan: number;
+        }>;
     });
     /**
      * Registers the `beforeRemoveCol` hook listener that captures removed column data and records a RemoveColumnAction.

package/plugins/undoRedo/actions/removeColumn.js

@@ -52,7 +52,8 @@ class RemoveColumnAction extends _base.BaseAction {
                     columnPositions: hot.columnIndexMapper.getIndexesSequence(),
                     rowPositions: hot.rowIndexMapper.getIndexesSequence(),
                     fixedColumnsStart: hot.getSettings().fixedColumnsStart ?? 0,
-                    removedCellMetas: (0, _utils.getCellMetas)(hot, 0, hot.countRows(), columnIndex, lastColumnIndex)
+                    removedCellMetas: (0, _utils.getCellMetas)(hot, 0, hot.countRows(), columnIndex, lastColumnIndex),
+                    removedMergedCells: (0, _utils.collectAffectedMergedCells)(hot, 'col', columnIndex, amount)
                 });
             };
             undoRedoPlugin.done(wrappedAction, source);
@@ -64,7 +65,11 @@ class RemoveColumnAction extends _base.BaseAction {
    */ undo(hot, undoneCallback) {
         const settings = hot.getSettings();
         // Changing by the reference as `updateSettings` doesn't work the best.
-        settings.fixedColumnsStart = this.fixedColumnsStart;
+        // Since 12.0.0, the "fixedColumnsLeft" is replaced with the "fixedColumnsStart" option.
+        // However, keeping the old name still in effect. When both option names are used together,
+        // the error is thrown. To prevent that, the engine needs to modify the original option key
+        // to bypass the validation.
+        settings._fixedColumnsStart = this.fixedColumnsStart;
         const ascendingIndexes = this.indexes.slice(0).sort((a, b)=>a - b);
         const sortByIndexes = (elem, j, arr)=>arr[this.indexes.indexOf(ascendingIndexes[j])];
         const removedDataLength = this.data.length;
@@ -108,6 +113,7 @@ class RemoveColumnAction extends _base.BaseAction {
             const [rowIndex, columnIndex, cellMeta] = entry;
             hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
         });
+        (0, _utils.restoreMergedCells)(hot, this.removedMergedCells);
         hot.addHookOnce('afterViewRender', undoneCallback);
         hot.setSourceDataAtCell(changes, undefined, undefined, 'UndoRedo.undo');
     }
@@ -119,8 +125,8 @@ class RemoveColumnAction extends _base.BaseAction {
         hot.alter('remove_col', this.index, this.amount, 'UndoRedo.redo');
     }
     /**
-   * Initializes the remove column action with the removed data, column indexes, headers, position sequences, and cell meta backup.
-   */ constructor({ index, indexes, data, amount, headers, columnPositions, rowPositions, fixedColumnsStart, removedCellMetas }){
+   * Initializes the remove column action with the removed data, column indexes, headers, position sequences, cell meta backup, and affected merged cells.
+   */ constructor({ index, indexes, data, amount, headers, columnPositions, rowPositions, fixedColumnsStart, removedCellMetas, removedMergedCells }){
         super('remove_col');
         this.index = index;
         this.indexes = indexes;
@@ -131,5 +137,6 @@ class RemoveColumnAction extends _base.BaseAction {
         this.rowPositions = rowPositions.slice(0);
         this.fixedColumnsStart = fixedColumnsStart;
         this.removedCellMetas = removedCellMetas;
+        this.removedMergedCells = removedMergedCells;
     }
 }