handsontable 17.1.0 → 18.0.0-rc2

package/plugins/undoRedo/actions/removeRow.mjs

@@ -7,19 +7,32 @@ import { deepClone } from '../../../helpers/object.mjs';
  * @class RemoveRowAction
  * @private
  */ export class RemoveRowAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeRemoveRow` hook listener that captures removed row data and records a RemoveRowAction.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeRemoveRow', (index, amount, logicRows, source)=>{
             const wrappedAction = ()=>{
                 const physicalRowIndex = hot.toPhysicalRow(index);
                 const lastRowIndex = physicalRowIndex + amount - 1;
-                const removedData = deepClone(hot.getSourceData(physicalRowIndex, 0, physicalRowIndex + amount - 1, hot.countSourceCols() - 1));
+                const removedData = [];
+                for(let i = 0; i < amount; i++){
+                    const rowData = deepClone(hot.getSourceDataAtRow(physicalRowIndex + i));
+                    // `nestedRows` manages its `__children` tree restoration on undo
+                    // independently; writing `__children` back via `setSourceDataAtCell`
+                    // would clash with the plugin's internal state.
+                    if (rowData && typeof rowData === 'object' && !Array.isArray(rowData)) {
+                        delete rowData.__children;
+                    }
+                    removedData.push(rowData);
+                }
                 return new RemoveRowAction({
                     index: physicalRowIndex,
                     data: removedData,
-                    fixedRowsBottom: hot.getSettings().fixedRowsBottom,
-                    fixedRowsTop: hot.getSettings().fixedRowsTop,
+                    fixedRowsBottom: hot.getSettings().fixedRowsBottom ?? 0,
+                    fixedRowsTop: hot.getSettings().fixedRowsTop ?? 0,
                     rowIndexesSequence: hot.rowIndexMapper.getIndexesSequence(),
-                    removedCellMetas: getCellMetas(hot, physicalRowIndex, lastRowIndex, 0, hot.countCols() - 1)
+                    removedCellMetas: getCellMetas(hot, physicalRowIndex, lastRowIndex, 0, hot.countCols() - 1),
+                    removedMergedCells: collectAffectedMergedCells(hot, index, amount)
                 });
             };
             undoRedoPlugin.done(wrappedAction, source);
@@ -35,9 +48,10 @@ import { deepClone } from '../../../helpers/object.mjs';
         settings.fixedRowsBottom = this.fixedRowsBottom;
         settings.fixedRowsTop = this.fixedRowsTop;
         // Prepare the change list to fill the source data.
-        this.data.forEach((dataRow, rowIndexDelta)=>{
+        this.data.forEach((row, rowIndexDelta)=>{
+            const dataRow = row;
             Object.keys(dataRow).forEach((columnProp)=>{
-                const columnIndex = parseInt(columnProp, 10);
+                const columnIndex = Number.parseInt(columnProp, 10);
                 changes.push([
                     this.index + rowIndexDelta,
                     isNaN(columnIndex) ? columnProp : columnIndex,
@@ -54,11 +68,13 @@ import { deepClone } from '../../../helpers/object.mjs';
         hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
         hot.alter('insert_row_above', hot.toVisualRow(this.index), this.data.length, 'UndoRedo.undo');
         hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
-        this.removedCellMetas.forEach(([rowIndex, columnIndex, cellMeta])=>{
+        this.removedCellMetas.forEach((entry)=>{
+            const [rowIndex, columnIndex, cellMeta] = entry;
             hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
         });
+        restoreMergedCells(hot, this.removedMergedCells);
         hot.addHookOnce('afterViewRender', undoneCallback);
-        hot.setSourceDataAtCell(changes, null, null, 'UndoRedo.undo');
+        hot.setSourceDataAtCell(changes, undefined, undefined, 'UndoRedo.undo');
     }
     /**
    * @param {Core} hot The Handsontable instance.
@@ -67,7 +83,9 @@ import { deepClone } from '../../../helpers/object.mjs';
         hot.addHookOnce('afterRemoveRow', redoneCallback);
         hot.alter('remove_row', hot.toVisualRow(this.index), this.data.length, 'UndoRedo.redo');
     }
-    constructor({ index, data, fixedRowsBottom, fixedRowsTop, rowIndexesSequence, removedCellMetas }){
+    /**
+   * Initializes the remove row action with the removed data, row index sequence, fixed-row counts, cell meta backup, and affected merged cells.
+   */ constructor({ index, data, fixedRowsBottom, fixedRowsTop, rowIndexesSequence, removedCellMetas, removedMergedCells }){
         super('remove_row');
         this.index = index;
         this.data = data;
@@ -75,5 +93,61 @@ import { deepClone } from '../../../helpers/object.mjs';
         this.fixedRowsTop = fixedRowsTop;
         this.rowIndexesSequence = rowIndexesSequence;
         this.removedCellMetas = removedCellMetas;
+        this.removedMergedCells = removedMergedCells;
+    }
+}
+/**
+ * Collects merged cells that overlap the removed visual row range.
+ * The plugin's own `shiftCollections` logic mutates surviving merges asymmetrically
+ * (a partial top removal cannot be reversed on `afterCreateRow`), so on undo we
+ * must restore every overlapping merge from its pre-removal state.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {number} visualRow First visual row being removed.
+ * @param {number} amount Number of rows being removed.
+ * @returns {Array} Array of `{ row, col, rowspan, colspan }` objects.
+ */ function collectAffectedMergedCells(hot, visualRow, amount) {
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    if (!mergeCellsPlugin?.enabled) {
+        return [];
+    }
+    const lastVisualRow = visualRow + amount - 1;
+    const affected = [];
+    mergeCellsPlugin.mergedCellsCollection?.mergedCells.forEach(({ row, col, rowspan, colspan })=>{
+        const mergeStart = row;
+        const mergeEnd = row + rowspan - 1;
+        if (mergeStart <= lastVisualRow && mergeEnd >= visualRow) {
+            affected.push({
+                row,
+                col,
+                rowspan,
+                colspan
+            });
+        }
+    });
+    return affected;
+}
+/**
+ * Re-applies merged cells affected by row removal. Any leftover partial merge in
+ * the captured area is unmerged first so the original range can be re-merged.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {Array} mergedCells Array of `{ row, col, rowspan, colspan }` objects.
+ */ function restoreMergedCells(hot, mergedCells) {
+    if (!mergedCells || mergedCells.length === 0) {
+        return;
+    }
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    if (!mergeCellsPlugin?.enabled) {
+        return;
     }
+    mergedCells.forEach(({ row, col, rowspan, colspan })=>{
+        const endRow = row + rowspan - 1;
+        const endCol = col + colspan - 1;
+        const start = hot._createCellCoords(row, col);
+        const end = hot._createCellCoords(endRow, endCol);
+        const range = hot._createCellRange(start, start, end);
+        mergeCellsPlugin.unmergeRange(range, true);
+        mergeCellsPlugin.merge(row, col, endRow, endCol);
+    });
 }

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

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

package/plugins/undoRedo/actions/rowMove.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 move changes.
+ *
+ * @class RowMoveAction
+ * @private
+ */
+export declare class RowMoveAction extends BaseAction {
+    /**
+     * @param {number[]} rows An array with moved rows.
+     */
+    rows: number[];
+    /**
+     * @param {number} finalIndex The destination index.
+     */
+    finalRowIndex: number;
+    /**
+     * Initializes the row move action with the array of moved row indexes and their destination index.
+     */
+    constructor({ rows, finalIndex }: {
+        rows: number[];
+        finalIndex: number;
+    });
+    /**
+     * Registers the `beforeRowMove` hook listener that records a new RowMoveAction whenever rows are moved.
+     */
+    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/rowMove.js

@@ -11,14 +11,16 @@ Object.defineProperty(exports, "RowMoveAction", {
 const _base = require("./_base");
 const _moves = require("../../../helpers/moves");
 class RowMoveAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeRowMove` hook listener that records a new RowMoveAction whenever rows are moved.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeRowMove', (rows, finalIndex)=>{
             if (rows === false) {
                 return;
             }
             undoRedoPlugin.done(()=>new RowMoveAction({
-                    rows,
-                    finalIndex
+                    rows: rows,
+                    finalIndex: finalIndex
                 }));
         });
     }
@@ -50,7 +52,9 @@ class RowMoveAction extends _base.BaseAction {
         hot.deselectCell();
         hot.selectRows(this.finalRowIndex, this.finalRowIndex + this.rows.length - 1);
     }
-    constructor({ rows, finalIndex }){
+    /**
+   * Initializes the row move action with the array of moved row indexes and their destination index.
+   */ constructor({ rows, finalIndex }){
         super('row_move');
         this.rows = rows.slice();
         this.finalRowIndex = finalIndex;

package/plugins/undoRedo/actions/rowMove.mjs

@@ -6,14 +6,16 @@ import { getMoves } from '../../../helpers/moves.mjs';
  * @class RowMoveAction
  * @private
  */ export class RowMoveAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `beforeRowMove` hook listener that records a new RowMoveAction whenever rows are moved.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('beforeRowMove', (rows, finalIndex)=>{
             if (rows === false) {
                 return;
             }
             undoRedoPlugin.done(()=>new RowMoveAction({
-                    rows,
-                    finalIndex
+                    rows: rows,
+                    finalIndex: finalIndex
                 }));
         });
     }
@@ -45,7 +47,9 @@ import { getMoves } from '../../../helpers/moves.mjs';
         hot.deselectCell();
         hot.selectRows(this.finalRowIndex, this.finalRowIndex + this.rows.length - 1);
     }
-    constructor({ rows, finalIndex }){
+    /**
+   * Initializes the row move action with the array of moved row indexes and their destination index.
+   */ constructor({ rows, finalIndex }){
         super('row_move');
         this.rows = rows.slice();
         this.finalRowIndex = finalIndex;

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

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

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

@@ -0,0 +1,36 @@
+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 UnmergeCellsAction
+ * @private
+ */
+export declare class UnmergeCellsAction extends BaseAction {
+    /**
+     * @param {CellRange} cellRange The merged cell range.
+     */
+    cellRange: CellRange;
+    /**
+     * Initializes the unmerge cells action with the cell range that was unmerged.
+     */
+    constructor({ cellRange }: {
+        cellRange: CellRange;
+    });
+    /**
+     * Registers the `afterUnmergeCells` hook listener that records a new UnmergeCellsAction after cells are manually unmerged.
+     */
+    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/unmergeCells.js

@@ -10,13 +10,15 @@ Object.defineProperty(exports, "UnmergeCellsAction", {
 });
 const _base = require("./_base");
 class UnmergeCellsAction extends _base.BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterUnmergeCells` hook listener that records a new UnmergeCellsAction after cells are manually unmerged.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterUnmergeCells', (cellRange, auto)=>{
             if (auto) {
                 return;
             }
             undoRedoPlugin.done(()=>new UnmergeCellsAction({
-                    cellRange
+                    cellRange: cellRange
                 }));
         });
     }
@@ -37,7 +39,9 @@ class UnmergeCellsAction extends _base.BaseAction {
         mergeCellsPlugin.unmergeRange(this.cellRange, true);
         hot.render();
     }
-    constructor({ cellRange }){
+    /**
+   * Initializes the unmerge cells action with the cell range that was unmerged.
+   */ constructor({ cellRange }){
         super('unmerge_cells');
         this.cellRange = cellRange;
     }

package/plugins/undoRedo/actions/unmergeCells.mjs

@@ -5,13 +5,15 @@ import { BaseAction } from './_base.mjs';
  * @class UnmergeCellsAction
  * @private
  */ export class UnmergeCellsAction extends BaseAction {
-    static startRegisteringEvents(hot, undoRedoPlugin) {
+    /**
+   * Registers the `afterUnmergeCells` hook listener that records a new UnmergeCellsAction after cells are manually unmerged.
+   */ static startRegisteringEvents(hot, undoRedoPlugin) {
         hot.addHook('afterUnmergeCells', (cellRange, auto)=>{
             if (auto) {
                 return;
             }
             undoRedoPlugin.done(()=>new UnmergeCellsAction({
-                    cellRange
+                    cellRange: cellRange
                 }));
         });
     }
@@ -32,7 +34,9 @@ import { BaseAction } from './_base.mjs';
         mergeCellsPlugin.unmergeRange(this.cellRange, true);
         hot.render();
     }
-    constructor({ cellRange }){
+    /**
+   * Initializes the unmerge cells action with the cell range that was unmerged.
+   */ constructor({ cellRange }){
         super('unmerge_cells');
         this.cellRange = cellRange;
     }

package/plugins/undoRedo/index.d.mts

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

package/plugins/undoRedo/index.d.ts

@@ -1 +1,2 @@
-export * from './undoRedo';
+export { PLUGIN_KEY, PLUGIN_PRIORITY, UndoRedo, } from './undoRedo';
+export type { UndoRedoAction } from './undoRedo';

package/plugins/undoRedo/undoRedo.d.mts

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

package/plugins/undoRedo/undoRedo.d.ts

@@ -1,83 +1,140 @@
-import CellRange from '../../3rdparty/walkontable/src/cell/range';
-import Core from '../../core';
-import { CellValue, CellChange } from '../../common';
-import { ColumnConditions } from '../filters';
+import type { HotInstance } from '../../core/types';
 import { BasePlugin } from '../base';
-import { Config as ColumnSortingConfig } from '../columnSorting';
-
-export type Settings = boolean;
-
-export interface CellAlignmentAction {
-  actionType: 'cell_alignment';
-  stateBefore: { [row: number]: string[] };
-  range: CellRange[];
-  type: 'horizontal' | 'vertical';
-  alignment: 'htLeft' | 'htCenter' | 'htRight' | 'htJustify' | 'htTop' | 'htMiddle' | 'htBottom';
+export interface UndoRedoAction {
+    actionType: string;
+    [key: string]: unknown;
 }
-export interface ColumnMoveAction {
-  actionType: 'col_move';
-  columns: number[];
-  finalColumnIndex: number;
-}
-export interface ColumnSortAction {
-  actionType: 'col_sort';
-  previousSortState: ColumnSortingConfig[];
-  nextSortState: ColumnSortingConfig[];
-}
-export interface InsertColAction {
-  actionType: 'insert_col';
-  amount: number;
-  index: number;
-}
-export interface InsertRowAction {
-  actionType: 'insert_row';
-  amount: number;
-  index: number;
-}
-export interface ChangeAction {
-  actionType: 'change';
-  changes: CellChange[];
-  selected: Array<[number, number]>;
-  countCols: number;
-  countRows: number;
-}
-export interface FilterAction {
-  actionType: 'filter';
-  conditionsStack: ColumnConditions[];
-  previousConditionsStack: ColumnConditions[];
-}
-export interface MergeAction {
-  actionType: 'merge_cells';
-  cellRange: CellRange[];
-}
-export interface UnmergeAction {
-  actionType: 'unmerge_cells';
-  cellRange: CellRange[];
-}
-export interface RemoveColAction {
-  actionType: 'remove_col';
-  amount: number;
-  columnPositions: number[];
-  index: number;
-  indexes: number[];
-  headers: string[];
-  data: CellValue[][];
-}
-export interface RemoveRowAction {
-  actionType: 'remove_row';
-  index: number;
-  data: CellValue[][];
-}
-
-export type Action = CellAlignmentAction | ColumnMoveAction | ColumnSortAction |
-  InsertColAction | InsertRowAction | ChangeAction | FilterAction | MergeAction |
-  UnmergeAction | RemoveColAction | RemoveRowAction;
-
-export class UndoRedo extends BasePlugin {
-  constructor(hotInstance: Core);
-  undo(): void;
-  redo(): void;
-  isUndoAvailable(): boolean;
-  isRedoAvailable(): boolean;
-  clear(): void;
+export declare const PLUGIN_KEY = "undoRedo";
+export declare const PLUGIN_PRIORITY = 1000;
+/**
+ * @description
+ * Handsontable UndoRedo plugin allows to undo and redo certain actions done in the table.
+ *
+ * __Note__, that not all actions are currently undo-able. The UndoRedo plugin is enabled by default.
+ * @example
+ * ```js
+ * undo: true
+ * ```
+ * @class UndoRedo
+ * @plugin UndoRedo
+ */
+export declare class UndoRedo extends BasePlugin {
+    #private;
+    /**
+     * Returns the plugin key used to identify this plugin in Handsontable settings.
+     */
+    static get PLUGIN_KEY(): string;
+    /**
+     * Returns the priority order used to determine the order in which plugins are initialized.
+     */
+    static get PLUGIN_PRIORITY(): number;
+    /**
+     * Returns whether the plugin handles its own settings keys without a dedicated key list.
+     */
+    static get SETTING_KEYS(): true;
+    /**
+     * The list of registered action do undo.
+     *
+     * @private
+     * @type {Array}
+     */
+    doneActions: unknown[];
+    /**
+     * The list of registered action do redo.
+     *
+     * @private
+     * @type {Array}
+     */
+    undoneActions: unknown[];
+    /**
+     * The flag that determines if new actions should be ignored.
+     *
+     * @private
+     * @type {boolean}
+     */
+    ignoreNewActions: boolean;
+    /**
+     * Initializes the plugin and registers all built-in undo/redo action handlers for the given Handsontable instance.
+     */
+    constructor(hotInstance: HotInstance);
+    /**
+     * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
+     * hook and if it returns `true` then the {@link UndoRedo#enablePlugin} method is called.
+     *
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Enables the plugin functionality for this Handsontable instance.
+     */
+    enablePlugin(): void;
+    /**
+     * Disables the plugin functionality for this Handsontable instance.
+     */
+    disablePlugin(): void;
+    /**
+     * Registers shortcuts responsible for performing undo/redo.
+     *
+     * @private
+     */
+    registerShortcuts(): void;
+    /**
+     * Unregister shortcuts responsible for performing undo/redo.
+     *
+     * @private
+     */
+    unregisterShortcuts(): void;
+    /**
+     * Stash information about performed actions.
+     *
+     * @fires Hooks#beforeUndoStackChange
+     * @fires Hooks#afterUndoStackChange
+     * @fires Hooks#beforeRedoStackChange
+     * @fires Hooks#afterRedoStackChange
+     * @param {Function} wrappedAction The action descriptor wrapped in a closure.
+     * @param {string} [source] Source of the action. It is defined just for more general actions (not related to plugins).
+     */
+    done(wrappedAction: Function, source?: string): void;
+    /**
+     * Undo the last action performed to the table.
+     *
+     * @fires Hooks#beforeUndoStackChange
+     * @fires Hooks#afterUndoStackChange
+     * @fires Hooks#beforeRedoStackChange
+     * @fires Hooks#afterRedoStackChange
+     * @fires Hooks#beforeUndo
+     * @fires Hooks#afterUndo
+     */
+    undo(): void;
+    /**
+     * Redo the previous action performed to the table (used to reverse an undo).
+     *
+     * @fires Hooks#beforeUndoStackChange
+     * @fires Hooks#afterUndoStackChange
+     * @fires Hooks#beforeRedoStackChange
+     * @fires Hooks#afterRedoStackChange
+     * @fires Hooks#beforeRedo
+     * @fires Hooks#afterRedo
+     */
+    redo(): void;
+    /**
+     * Checks if undo action is available.
+     *
+     * @returns {boolean} Return `true` if undo can be performed, `false` otherwise.
+     */
+    isUndoAvailable(): boolean;
+    /**
+     * Checks if redo action is available.
+     *
+     * @returns {boolean} Return `true` if redo can be performed, `false` otherwise.
+     */
+    isRedoAvailable(): boolean;
+    /**
+     * Clears undo and redo history.
+     */
+    clear(): void;
+    /**
+     * Destroys the plugin instance.
+     */
+    destroy(): void;
 }