handsontable 17.1.0 → 18.0.0-rc2

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

@@ -0,0 +1,40 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import { BaseAction } from './_base';
+/**
+ * Action that tracks column creation.
+ *
+ * @class CreateColumnAction
+ * @private
+ */
+export declare class CreateColumnAction extends BaseAction {
+    /**
+     * @param {number} index The visual column index.
+     */
+    index: number;
+    /**
+     * @param {number} amount The number of created columns.
+     */
+    amount: number;
+    /**
+     * Initializes the create column action with the visual insertion index and the number of columns created.
+     */
+    constructor({ index, amount }: {
+        index: number;
+        amount: number;
+    });
+    /**
+     * Registers the `afterCreateCol` hook listener that records a new CreateColumnAction after columns are inserted.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+     */
+    redo(hot: HotInstance, redoneCallback: HookCallback): void;
+}

package/plugins/undoRedo/actions/createColumn.js

@@ -10,7 +10,9 @@ Object.defineProperty(exports, "CreateColumnAction", {
 });
 const _base = require("./_base");
 class CreateColumnAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterCreateCol` hook listener that records a new CreateColumnAction after columns are inserted.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterCreateCol', (index, amount, source)=>{
             undoRedoPlugin.done(()=>new CreateColumnAction({
                     index,
@@ -32,7 +34,9 @@ class CreateColumnAction extends _base.BaseAction {
         hot.addHookOnce('afterCreateCol', redoneCallback);
         hot.alter('insert_col_start', this.index, this.amount, 'UndoRedo.redo');
     }
-    constructor({ index, amount }){
+    /**
+   * Initializes the create column action with the visual insertion index and the number of columns created.
+   */ constructor({ index, amount }){
         super('insert_col');
         this.index = index;
         this.amount = amount;

package/plugins/undoRedo/actions/createColumn.mjs

@@ -5,7 +5,9 @@ import { BaseAction } from './_base.mjs';
  * @class CreateColumnAction
  * @private
  */ export class CreateColumnAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterCreateCol` hook listener that records a new CreateColumnAction after columns are inserted.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterCreateCol', (index, amount, source)=>{
             undoRedoPlugin.done(()=>new CreateColumnAction({
                     index,
@@ -27,7 +29,9 @@ import { BaseAction } from './_base.mjs';
         hot.addHookOnce('afterCreateCol', redoneCallback);
         hot.alter('insert_col_start', this.index, this.amount, 'UndoRedo.redo');
     }
-    constructor({ index, amount }){
+    /**
+   * Initializes the create column action with the visual insertion index and the number of columns created.
+   */ constructor({ index, amount }){
         super('insert_col');
         this.index = index;
         this.amount = amount;

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

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

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

@@ -0,0 +1,40 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import { BaseAction } from './_base';
+/**
+ * Action that tracks row creation.
+ *
+ * @class CreateRowAction
+ * @private
+ */
+export declare class CreateRowAction extends BaseAction {
+    /**
+     * @param {number} index The visual row index.
+     */
+    index: number;
+    /**
+     * @param {number} amount The number of created rows.
+     */
+    amount: number;
+    /**
+     * Initializes the create row action with the visual insertion index and the number of rows created.
+     */
+    constructor({ index, amount }: {
+        index: number;
+        amount: number;
+    });
+    /**
+     * Registers the `afterCreateRow` hook listener that records a new CreateRowAction after rows are inserted.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+     */
+    redo(hot: HotInstance, redoneCallback: HookCallback): void;
+}

package/plugins/undoRedo/actions/createRow.js

@@ -10,7 +10,9 @@ Object.defineProperty(exports, "CreateRowAction", {
 });
 const _base = require("./_base");
 class CreateRowAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterCreateRow` hook listener that records a new CreateRowAction after rows are inserted.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterCreateRow', (index, amount, source)=>{
             undoRedoPlugin.done(()=>new CreateRowAction({
                     index,
@@ -24,8 +26,8 @@ class CreateRowAction extends _base.BaseAction {
    */ undo(hot, undoneCallback) {
         const rowCount = hot.countRows();
         const minSpareRows = hot.getSettings().minSpareRows;
-        if (this.index >= rowCount && this.index - minSpareRows < rowCount) {
-            this.index -= minSpareRows; // work around the situation where the needed row was removed due to an 'undo' of a made change
+        if (this.index >= rowCount && this.index - (minSpareRows ?? 0) < rowCount) {
+            this.index -= minSpareRows ?? 0; // work around the situation where the needed row was removed due to an 'undo' of a made change
         }
         hot.addHookOnce('afterRemoveRow', undoneCallback);
         hot.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
@@ -37,7 +39,9 @@ class CreateRowAction extends _base.BaseAction {
         hot.addHookOnce('afterCreateRow', redoneCallback);
         hot.alter('insert_row_above', this.index, this.amount, 'UndoRedo.redo');
     }
-    constructor({ index, amount }){
+    /**
+   * Initializes the create row action with the visual insertion index and the number of rows created.
+   */ constructor({ index, amount }){
         super('insert_row');
         this.index = index;
         this.amount = amount;

package/plugins/undoRedo/actions/createRow.mjs

@@ -5,7 +5,9 @@ import { BaseAction } from './_base.mjs';
  * @class CreateRowAction
  * @private
  */ export class CreateRowAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterCreateRow` hook listener that records a new CreateRowAction after rows are inserted.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterCreateRow', (index, amount, source)=>{
             undoRedoPlugin.done(()=>new CreateRowAction({
                     index,
@@ -19,8 +21,8 @@ import { BaseAction } from './_base.mjs';
    */ undo(hot, undoneCallback) {
         const rowCount = hot.countRows();
         const minSpareRows = hot.getSettings().minSpareRows;
-        if (this.index >= rowCount && this.index - minSpareRows < rowCount) {
-            this.index -= minSpareRows; // work around the situation where the needed row was removed due to an 'undo' of a made change
+        if (this.index >= rowCount && this.index - (minSpareRows ?? 0) < rowCount) {
+            this.index -= minSpareRows ?? 0; // work around the situation where the needed row was removed due to an 'undo' of a made change
         }
         hot.addHookOnce('afterRemoveRow', undoneCallback);
         hot.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
@@ -32,7 +34,9 @@ import { BaseAction } from './_base.mjs';
         hot.addHookOnce('afterCreateRow', redoneCallback);
         hot.alter('insert_row_above', this.index, this.amount, 'UndoRedo.redo');
     }
-    constructor({ index, amount }){
+    /**
+   * Initializes the create row action with the visual insertion index and the number of rows created.
+   */ constructor({ index, amount }){
         super('insert_row');
         this.index = index;
         this.amount = amount;

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

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

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

@@ -0,0 +1,50 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import { BaseAction } from './_base';
+/**
+ * Action that tracks data changes.
+ *
+ * @class DataChangeAction
+ * @private
+ */
+export declare class DataChangeAction extends BaseAction {
+    /**
+     * @param {Array} changes 2D array containing information about each of the edited cells.
+     */
+    changes: unknown[][];
+    /**
+     * @param {number[]} selected The cell selection.
+     */
+    selected: unknown[];
+    /**
+     * @param {number} countCols The number of columns before data change.
+     */
+    countCols: number;
+    /**
+     * @param {number} countRows The number of rows before data change.
+     */
+    countRows: number;
+    /**
+     * Initializes the data change action with the recorded cell changes, selection state, and grid dimensions at the time of the change.
+     */
+    constructor({ changes, selected, countCols, countRows }: {
+        changes: unknown[][];
+        selected: unknown[];
+        countCols: number;
+        countRows: number;
+    });
+    /**
+     * Registers the `beforeChange` hook listener that captures effective cell value changes and records them as DataChangeActions.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+     */
+    redo(hot: HotInstance, redoneCallback: HookCallback): void;
+}

package/plugins/undoRedo/actions/dataChange.js

@@ -11,35 +11,34 @@ Object.defineProperty(exports, "DataChangeAction", {
 const _base = require("./_base");
 const _object = require("../../../helpers/object");
 class DataChangeAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeChange` hook listener that captures effective cell value changes and records them as DataChangeActions.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
+        const plugin = undoRedoPlugin;
+        // Run after other beforeChange hooks (e.g. user's) so we see nullified entries and only record effective changes.
         hot.addHook('beforeChange', function(changes, source) {
             const changesLen = changes && changes.length;
             if (!changesLen) {
                 return;
             }
-            changes.find((change)=>{
-                if (change === null) {
-                    return false;
-                }
+            // Only record changes that were not nullified by other beforeChange hooks (e.g. user setting changes[i] = null).
+            const effectiveChanges = changes.filter((change)=>change !== null && change !== undefined && Array.isArray(change));
+            if (effectiveChanges.length === 0) {
+                return;
+            }
+            const hasDifferences = effectiveChanges.find((change)=>{
                 const [, , oldValue, newValue] = change;
                 return oldValue !== newValue;
             });
+            const effectiveLen = effectiveChanges.length;
             const wrappedAction = ()=>{
-                const clonedChanges = changes.reduce((arr, change)=>{
-                    if (change !== null) {
-                        arr.push([
-                            ...change
-                        ]);
-                    }
-                    return arr;
-                }, []);
-                if (clonedChanges.length === 0) {
-                    return null;
-                }
+                const clonedChanges = effectiveChanges.map((change)=>[
+                        ...change
+                    ]);
                 clonedChanges.forEach((change)=>{
                     change[1] = hot.propToCol(change[1]);
                 });
-                const selected = changesLen > 1 ? this.getSelected() : [
+                const selected = effectiveLen > 1 ? this.getSelected() : [
                     [
                         clonedChanges[0][0],
                         clonedChanges[0][1]
@@ -52,8 +51,8 @@ class DataChangeAction extends _base.BaseAction {
                     countRows: hot.countRows()
                 });
             };
-            undoRedoPlugin.done(wrappedAction, source);
-        }, undoRedoPlugin.constructor.PLUGIN_PRIORITY);
+            plugin.done(wrappedAction, source);
+        }, 1000);
     }
     /**
    * @param {Core} hot The Handsontable instance.
@@ -66,11 +65,11 @@ class DataChangeAction extends _base.BaseAction {
         hot.addHookOnce('afterChange', ()=>{
             const rowsToRemove = hot.countRows() - this.countRows;
             if (rowsToRemove > 0) {
-                hot.alter('remove_row', null, rowsToRemove, 'UndoRedo.undo');
+                hot.alter('remove_row', undefined, rowsToRemove, 'UndoRedo.undo');
             }
             const columnsToRemove = hot.countCols() - this.countCols;
             if (columnsToRemove > 0 && hot.isColumnModificationAllowed()) {
-                hot.alter('remove_col', null, columnsToRemove, 'UndoRedo.undo');
+                hot.alter('remove_col', undefined, columnsToRemove, 'UndoRedo.undo');
             }
             hot.scrollToFocusedCell();
             hot.selectCells(this.selected, false, false);
@@ -92,7 +91,9 @@ class DataChangeAction extends _base.BaseAction {
         });
         hot.setDataAtCell(data, null, null, 'UndoRedo.redo');
     }
-    constructor({ changes, selected, countCols, countRows }){
+    /**
+   * Initializes the data change action with the recorded cell changes, selection state, and grid dimensions at the time of the change.
+   */ constructor({ changes, selected, countCols, countRows }){
         super('change');
         this.changes = changes;
         this.selected = selected;

package/plugins/undoRedo/actions/dataChange.mjs

@@ -6,35 +6,34 @@ import { deepClone } from '../../../helpers/object.mjs';
  * @class DataChangeAction
  * @private
  */ export class DataChangeAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeChange` hook listener that captures effective cell value changes and records them as DataChangeActions.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
+        const plugin = undoRedoPlugin;
+        // Run after other beforeChange hooks (e.g. user's) so we see nullified entries and only record effective changes.
         hot.addHook('beforeChange', function(changes, source) {
             const changesLen = changes && changes.length;
             if (!changesLen) {
                 return;
             }
-            changes.find((change)=>{
-                if (change === null) {
-                    return false;
-                }
+            // Only record changes that were not nullified by other beforeChange hooks (e.g. user setting changes[i] = null).
+            const effectiveChanges = changes.filter((change)=>change !== null && change !== undefined && Array.isArray(change));
+            if (effectiveChanges.length === 0) {
+                return;
+            }
+            const hasDifferences = effectiveChanges.find((change)=>{
                 const [, , oldValue, newValue] = change;
                 return oldValue !== newValue;
             });
+            const effectiveLen = effectiveChanges.length;
             const wrappedAction = ()=>{
-                const clonedChanges = changes.reduce((arr, change)=>{
-                    if (change !== null) {
-                        arr.push([
-                            ...change
-                        ]);
-                    }
-                    return arr;
-                }, []);
-                if (clonedChanges.length === 0) {
-                    return null;
-                }
+                const clonedChanges = effectiveChanges.map((change)=>[
+                        ...change
+                    ]);
                 clonedChanges.forEach((change)=>{
                     change[1] = hot.propToCol(change[1]);
                 });
-                const selected = changesLen > 1 ? this.getSelected() : [
+                const selected = effectiveLen > 1 ? this.getSelected() : [
                     [
                         clonedChanges[0][0],
                         clonedChanges[0][1]
@@ -47,8 +46,8 @@ import { deepClone } from '../../../helpers/object.mjs';
                     countRows: hot.countRows()
                 });
             };
-            undoRedoPlugin.done(wrappedAction, source);
-        }, undoRedoPlugin.constructor.PLUGIN_PRIORITY);
+            plugin.done(wrappedAction, source);
+        }, 1000);
     }
     /**
    * @param {Core} hot The Handsontable instance.
@@ -61,11 +60,11 @@ import { deepClone } from '../../../helpers/object.mjs';
         hot.addHookOnce('afterChange', ()=>{
             const rowsToRemove = hot.countRows() - this.countRows;
             if (rowsToRemove > 0) {
-                hot.alter('remove_row', null, rowsToRemove, 'UndoRedo.undo');
+                hot.alter('remove_row', undefined, rowsToRemove, 'UndoRedo.undo');
             }
             const columnsToRemove = hot.countCols() - this.countCols;
             if (columnsToRemove > 0 && hot.isColumnModificationAllowed()) {
-                hot.alter('remove_col', null, columnsToRemove, 'UndoRedo.undo');
+                hot.alter('remove_col', undefined, columnsToRemove, 'UndoRedo.undo');
             }
             hot.scrollToFocusedCell();
             hot.selectCells(this.selected, false, false);
@@ -87,7 +86,9 @@ import { deepClone } from '../../../helpers/object.mjs';
         });
         hot.setDataAtCell(data, null, null, 'UndoRedo.redo');
     }
-    constructor({ changes, selected, countCols, countRows }){
+    /**
+   * Initializes the data change action with the recorded cell changes, selection state, and grid dimensions at the time of the change.
+   */ constructor({ changes, selected, countCols, countRows }){
         super('change');
         this.changes = changes;
         this.selected = selected;

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

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

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

@@ -0,0 +1,40 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import { BaseAction } from './_base';
+/**
+ * Action that tracks filter changes.
+ *
+ * @class FiltersAction
+ * @private
+ */
+export declare class FiltersAction extends BaseAction {
+    /**
+     * @param {Array} previousConditionsStack An array of the previous filter conditions.
+     */
+    conditionsStack: unknown;
+    /**
+     * @param {Array} conditionsStack An array of the filter conditions.
+     */
+    previousConditionsStack: unknown;
+    /**
+     * Initializes the filters action with the current and previous filter condition stacks.
+     */
+    constructor({ conditionsStack, previousConditionsStack }: {
+        conditionsStack: unknown;
+        previousConditionsStack: unknown;
+    });
+    /**
+     * Registers the `beforeFilter` hook listener that records a new FiltersAction whenever filter conditions change.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+     */
+    redo(hot: HotInstance, redoneCallback: HookCallback): void;
+}

package/plugins/undoRedo/actions/filters.js

@@ -10,7 +10,9 @@ Object.defineProperty(exports, "FiltersAction", {
 });
 const _base = require("./_base");
 class FiltersAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeFilter` hook listener that records a new FiltersAction whenever filter conditions change.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeFilter', (conditionsStack, previousConditionsStack)=>{
             undoRedoPlugin.done(()=>new FiltersAction({
                     conditionsStack,
@@ -36,7 +38,9 @@ class FiltersAction extends _base.BaseAction {
         filters.importConditions(this.conditionsStack);
         filters.filter();
     }
-    constructor({ conditionsStack, previousConditionsStack }){
+    /**
+   * Initializes the filters action with the current and previous filter condition stacks.
+   */ constructor({ conditionsStack, previousConditionsStack }){
         super('filter');
         this.conditionsStack = conditionsStack;
         this.previousConditionsStack = previousConditionsStack;

package/plugins/undoRedo/actions/filters.mjs

@@ -5,7 +5,9 @@ import { BaseAction } from './_base.mjs';
  * @class FiltersAction
  * @private
  */ export class FiltersAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeFilter` hook listener that records a new FiltersAction whenever filter conditions change.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeFilter', (conditionsStack, previousConditionsStack)=>{
             undoRedoPlugin.done(()=>new FiltersAction({
                     conditionsStack,
@@ -31,7 +33,9 @@ import { BaseAction } from './_base.mjs';
         filters.importConditions(this.conditionsStack);
         filters.filter();
     }
-    constructor({ conditionsStack, previousConditionsStack }){
+    /**
+   * Initializes the filters action with the current and previous filter condition stacks.
+   */ constructor({ conditionsStack, previousConditionsStack }){
         super('filter');
         this.conditionsStack = conditionsStack;
         this.previousConditionsStack = previousConditionsStack;

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

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

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

@@ -0,0 +1,8 @@
+import type { HotInstance } from '../../../core/types';
+/**
+ * Register all undo/redo actions.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {UndoRedo} undoRedoPlugin The undoRedo plugin instance.
+ */
+export declare function registerActions(hot: HotInstance, undoRedoPlugin: unknown): void;

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

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

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

@@ -0,0 +1,41 @@
+import type { HookCallback } from '../../../core/hooks/bucket';
+import type { HotInstance } from '../../../core/types';
+import type { default as CellRange } from '../../../3rdparty/walkontable/src/cell/range';
+import { BaseAction } from './_base';
+/**
+ * Action that tracks changes in merged cells.
+ *
+ * @class MergeCellsAction
+ * @private
+ */
+export declare class MergeCellsAction extends BaseAction {
+    /**
+     * @param {CellRange} cellRange The merged cell range.
+     */
+    cellRange: CellRange;
+    /**
+     * Stores the cell data captured before the merge, used to restore values when the action is undone.
+     */
+    data: unknown;
+    /**
+     * Initializes the merge cells action with the affected cell range and the original cell data.
+     */
+    constructor({ data, cellRange }: {
+        data: unknown;
+        cellRange: CellRange;
+    });
+    /**
+     * Registers the hooks needed to capture merge and unmerge events so they can be tracked for undo and redo.
+     */
+    static startRegisteringEvents(hot: HotInstance, undoRedoPlugin: unknown): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+     */
+    undo(hot: HotInstance, undoneCallback: HookCallback): void;
+    /**
+     * @param {Core} hot The Handsontable instance.
+     * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+     */
+    redo(hot: HotInstance, redoneCallback: HookCallback): void;
+}

package/plugins/undoRedo/actions/mergeCells.js

@@ -10,17 +10,20 @@ Object.defineProperty(exports, "MergeCellsAction", {
 });
 const _base = require("./_base");
 class MergeCellsAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the hooks needed to capture merge and unmerge events so they can be tracked for undo and redo.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeMergeCells', (cellRange, auto)=>{
             if (auto) {
                 return;
             }
-            const topStartCorner = cellRange.getTopStartCorner();
-            const bottomEndCorner = cellRange.getBottomEndCorner();
-            const data = hot.getData(topStartCorner.row, topStartCorner.col, bottomEndCorner.row, bottomEndCorner.col);
+            const typedCellRange = cellRange;
+            const topStartCorner = typedCellRange.getTopStartCorner();
+            const bottomEndCorner = typedCellRange.getBottomEndCorner();
+            const data = hot.getData(topStartCorner.row ?? undefined, topStartCorner.col ?? undefined, bottomEndCorner.row ?? undefined, bottomEndCorner.col ?? undefined);
             undoRedoPlugin.done(()=>new MergeCellsAction({
                     data,
-                    cellRange
+                    cellRange: typedCellRange
                 }));
         });
     }
@@ -32,7 +35,7 @@ class MergeCellsAction extends _base.BaseAction {
         hot.addHookOnce('afterViewRender', undoneCallback);
         mergeCellsPlugin.unmergeRange(this.cellRange, true);
         const topStartCorner = this.cellRange.getTopStartCorner();
-        hot.populateFromArray(topStartCorner.row, topStartCorner.col, this.data, undefined, undefined, 'MergeCells');
+        hot.populateFromArray(topStartCorner.row ?? 0, topStartCorner.col ?? 0, this.data, undefined, undefined, 'MergeCells');
     }
     /**
    * @param {Core} hot The Handsontable instance.
@@ -42,7 +45,9 @@ class MergeCellsAction extends _base.BaseAction {
         hot.addHookOnce('afterViewRender', redoneCallback);
         mergeCellsPlugin.mergeRange(this.cellRange);
     }
-    constructor({ data, cellRange }){
+    /**
+   * Initializes the merge cells action with the affected cell range and the original cell data.
+   */ constructor({ data, cellRange }){
         super('merge_cells');
         this.cellRange = cellRange;
         this.data = data;