handsontable 18.0.0 → 18.1.0-rc7

package/plugins/selectionHandles/selectionHandles.mjs

@@ -0,0 +1,323 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+import { BasePlugin } from '../base/index.mjs';
+import { addClass, removeClass } from '../../helpers/dom/element.mjs';
+import { getCellCoordsFromMousePosition } from '../../helpers/dom/cellCoords.mjs';
+import { isRightClick } from '../../helpers/dom/event.mjs';
+import { clampEdge } from './helpers.mjs';
+export const PLUGIN_KEY = 'selectionHandles';
+export const PLUGIN_PRIORITY = 24;
+var /**
+   * Stores the active selection resize session.
+   *
+   * @type {object|null}
+   */ _drag = /*#__PURE__*/ new WeakMap(), /**
+   * Stores the last visual cell coordinate under the pointer.
+   */ _lastCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Saves the host cursor while a resize is active.
+   */ _bodyCursor = /*#__PURE__*/ new WeakMap(), /**
+   * Stores the latest pointer position so scrolling can continue the resize.
+   */ _pointerPosition = /*#__PURE__*/ new WeakMap(), /**
+   * Records the topmost range under the pointer.
+   */ _onCellMouseOver = /*#__PURE__*/ new WeakMap(), /**
+   * Starts a selection resize session.
+   */ _onHandleMouseDown = /*#__PURE__*/ new WeakMap(), /**
+   * Applies a resize to the captured selection layer.
+   */ _onMouseMove = /*#__PURE__*/ new WeakMap(), /**
+   * Continues the resize after DragToScroll changes the rendered viewport.
+   */ _onAfterScroll = /*#__PURE__*/ new WeakMap(), /**
+   * Resizes the selected range toward the current pointer coordinates.
+   *
+   * @param {number} clientX The pointer's viewport X coordinate.
+   * @param {number} clientY The pointer's viewport Y coordinate.
+   */ _resizeSelection = /*#__PURE__*/ new WeakSet(), /**
+   * Clears hover state after the pointer leaves the grid.
+   */ _onRootMouseLeave = /*#__PURE__*/ new WeakMap(), /**
+   * Restores handle hover after ordinary selection drags.
+   */ _onDocumentMouseUp = /*#__PURE__*/ new WeakMap(), /**
+   * Ends the active resize session.
+   */ _endDrag = /*#__PURE__*/ new WeakMap();
+/**
+ * Enables desktop selection edge handles and their resize interaction.
+ */ export class SelectionHandles extends BasePlugin {
+    /**
+   * Returns the plugin key.
+   */ static get PLUGIN_KEY() {
+        return PLUGIN_KEY;
+    }
+    /**
+   * Returns the plugin priority.
+   */ static get PLUGIN_PRIORITY() {
+        return PLUGIN_PRIORITY;
+    }
+    /**
+   * Returns the settings that trigger a plugin update.
+   */ static get SETTING_KEYS() {
+        return [
+            PLUGIN_KEY
+        ];
+    }
+    /**
+   * Checks whether the plugin is enabled in the Handsontable settings.
+   *
+   * @returns {boolean}
+   */ isEnabled() {
+        return this.hot.getSettings()[PLUGIN_KEY] === true;
+    }
+    /**
+   * Checks whether a resize drag is currently in progress. Reachable through `getPlugin` because
+   * DragToScroll needs it — it must not start auto-scrolling for a press this plugin rejected — but
+   * internal, not part of the public API.
+   *
+   * @private
+   * @returns {boolean}
+   */ isDragActive() {
+        return _class_private_field_get(this, _drag) !== null;
+    }
+    /**
+   * Enables handle hover and resize interactions.
+   */ enablePlugin() {
+        if (this.enabled) {
+            return;
+        }
+        this.addHook('afterOnSelectionHandleMouseDown', _class_private_field_get(this, _onHandleMouseDown));
+        this.addHook('beforeOnCellMouseOver', _class_private_field_get(this, _onCellMouseOver));
+        this.addHook('afterScroll', _class_private_field_get(this, _onAfterScroll));
+        this.eventManager.addEventListener(this.hot.rootElement, 'mouseleave', _class_private_field_get(this, _onRootMouseLeave));
+        this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _onDocumentMouseUp));
+        super.enablePlugin();
+    }
+    /**
+   * Updates the plugin after its setting changes.
+   */ updatePlugin() {
+        this.disablePlugin();
+        this.enablePlugin();
+        super.updatePlugin();
+    }
+    /**
+   * Disables the plugin and clears transient resize state.
+   */ disablePlugin() {
+        super.disablePlugin();
+        _class_private_field_get(this, _endDrag).call(this);
+        this.hot.selection.setHandlesHoveredLayer(null);
+    }
+    /**
+   * Destroys the plugin and clears an active resize interaction.
+   */ destroy() {
+        _class_private_field_get(this, _endDrag).call(this);
+        super.destroy();
+    }
+    constructor(...args){
+        super(...args), _class_private_method_init(this, _resizeSelection), _class_private_field_init(this, _drag, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _lastCoords, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _bodyCursor, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _pointerPosition, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onCellMouseOver, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onHandleMouseDown, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onMouseMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterScroll, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onRootMouseLeave, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onDocumentMouseUp, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _endDrag, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_set(this, _drag, null), _class_private_field_set(this, _lastCoords, null), _class_private_field_set(this, _bodyCursor, ''), _class_private_field_set(this, _pointerPosition, null), _class_private_field_set(this, _onCellMouseOver, (_event, coords)=>{
+            _class_private_field_set(this, _lastCoords, coords);
+            if (!_class_private_field_get(this, _drag)) {
+                this.hot.selection.setHandlesHoveredLayer(this.hot.selection.getLayerContaining(coords));
+            }
+        }), _class_private_field_set(this, _onHandleMouseDown, (event, edge)=>{
+            // A right-press opens the context menu; it must not also start (and on release, commit) a resize.
+            if (isRightClick(event)) {
+                return;
+            }
+            const selection = this.hot.selection;
+            const layer = selection.getHandlesHoveredLayer() ?? selection.getLayerLevel();
+            const range = selection.getSelectedRange().peekByIndex(layer);
+            if (!range) {
+                return;
+            }
+            const start = range.getTopStartCorner();
+            const end = range.getBottomEndCorner();
+            const focus = range.highlight;
+            const fromRow = start.row;
+            const fromCol = start.col;
+            const toRow = end.row;
+            const toCol = end.col;
+            _class_private_field_set(this, _drag, {
+                edge,
+                layer,
+                fromRow,
+                fromCol,
+                toRow,
+                toCol,
+                focusRow: focus.row ?? fromRow,
+                focusCol: focus.col ?? fromCol
+            });
+            _class_private_field_set(this, _pointerPosition, {
+                clientX: event.clientX,
+                clientY: event.clientY
+            });
+            _class_private_field_set(this, _bodyCursor, this.hot.rootDocument.body.style.cursor);
+            this.hot.rootDocument.body.style.cursor = edge === 'top' || edge === 'bottom' ? 'ns-resize' : 'ew-resize';
+            addClass(this.hot.rootElement, `ht__resizing-selection--${edge}`);
+            this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mousemove', _class_private_field_get(this, _onMouseMove));
+            this.eventManager.addEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _endDrag));
+        }), _class_private_field_set(this, _onMouseMove, (event)=>{
+            if (!(event instanceof this.hot.rootWindow.MouseEvent)) {
+                return;
+            }
+            if (!_class_private_field_get(this, _drag)) {
+                return;
+            }
+            _class_private_field_set(this, _pointerPosition, {
+                clientX: event.clientX,
+                clientY: event.clientY
+            });
+            _class_private_method_get(this, _resizeSelection, resizeSelection).call(this, event.clientX, event.clientY);
+        }), _class_private_field_set(this, _onAfterScroll, ()=>{
+            if (_class_private_field_get(this, _drag) && _class_private_field_get(this, _pointerPosition)) {
+                _class_private_method_get(this, _resizeSelection, resizeSelection).call(this, _class_private_field_get(this, _pointerPosition).clientX, _class_private_field_get(this, _pointerPosition).clientY);
+            }
+        }), _class_private_field_set(this, _onRootMouseLeave, ()=>{
+            if (!_class_private_field_get(this, _drag)) {
+                this.hot.selection.setHandlesHoveredLayer(null);
+            }
+        }), _class_private_field_set(this, _onDocumentMouseUp, ()=>{
+            if (!_class_private_field_get(this, _drag) && _class_private_field_get(this, _lastCoords)) {
+                this.hot.selection.setHandlesHoveredLayer(this.hot.selection.getLayerContaining(_class_private_field_get(this, _lastCoords)));
+            }
+        }), _class_private_field_set(this, _endDrag, ()=>{
+            if (!_class_private_field_get(this, _drag)) {
+                return;
+            }
+            _class_private_field_set(this, _drag, null);
+            _class_private_field_set(this, _pointerPosition, null);
+            this.eventManager.removeEventListener(this.hot.rootDocument.documentElement, 'mousemove', _class_private_field_get(this, _onMouseMove));
+            this.eventManager.removeEventListener(this.hot.rootDocument.documentElement, 'mouseup', _class_private_field_get(this, _endDrag));
+            removeClass(this.hot.rootElement, [
+                'ht__resizing-selection--top',
+                'ht__resizing-selection--bottom',
+                'ht__resizing-selection--start',
+                'ht__resizing-selection--end'
+            ]);
+            this.hot.rootDocument.body.style.cursor = _class_private_field_get(this, _bodyCursor);
+        });
+    }
+}
+function resizeSelection(clientX, clientY) {
+    if (!_class_private_field_get(this, _drag)) {
+        return;
+    }
+    const { edge, layer, fromRow, toRow, fromCol, toCol, focusRow, focusCol } = _class_private_field_get(this, _drag);
+    const pointer = getCellCoordsFromMousePosition(this.hot, clientX, clientY);
+    let anchor;
+    let end;
+    if (edge === 'top') {
+        anchor = this.hot._createCellCoords(toRow, toCol);
+        end = this.hot._createCellCoords(clampEdge({
+            edge,
+            target: pointer.row,
+            oppositeIndex: toRow
+        }), fromCol);
+    } else if (edge === 'bottom') {
+        anchor = this.hot._createCellCoords(fromRow, fromCol);
+        end = this.hot._createCellCoords(clampEdge({
+            edge,
+            target: pointer.row,
+            oppositeIndex: fromRow
+        }), toCol);
+    } else if (edge === 'start') {
+        anchor = this.hot._createCellCoords(toRow, toCol);
+        end = this.hot._createCellCoords(fromRow, clampEdge({
+            edge,
+            target: pointer.col,
+            oppositeIndex: toCol
+        }));
+    } else {
+        anchor = this.hot._createCellCoords(fromRow, fromCol);
+        end = this.hot._createCellCoords(toRow, clampEdge({
+            edge,
+            target: pointer.col,
+            oppositeIndex: fromCol
+        }));
+    }
+    const range = this.hot.selection.getSelectedRange().peekByIndex(layer);
+    if (!range) {
+        return;
+    }
+    const row = Math.min(Math.max(focusRow, Math.min(anchor.row, end.row)), Math.max(anchor.row, end.row));
+    const col = Math.min(Math.max(focusCol, Math.min(anchor.col, end.col)), Math.max(anchor.col, end.col));
+    range.setFrom(anchor);
+    range.setTo(anchor);
+    range.setHighlight(this.hot._createCellCoords(row, col));
+    this.hot.selection.setRangeEnd(end, layer);
+}

package/plugins/trimRows/trimRows.d.ts

@@ -1,5 +1,5 @@
 import { BasePlugin } from '../base';
-import { TrimmingMap } from '../../translations';
+import type { TrimmingMap } from '../../translations';
 export declare const PLUGIN_KEY = "trimRows";
 export declare const PLUGIN_PRIORITY = 330;
 /**

package/plugins/trimRows/trimRows.js

@@ -20,7 +20,6 @@ _export(exports, {
     }
 });
 const _base = require("../base");
-const _translations = require("../../translations");
 const _array = require("../../helpers/array");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
@@ -100,8 +99,13 @@ class TrimRows extends _base.BasePlugin {
         if (this.enabled) {
             return;
         }
-        this.trimmedRowsMap = this.hot.rowIndexMapper.registerMap('trimRows', new _translations.TrimmingMap());
+        this.trimmedRowsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap('trimRows', 'trimming');
         this.trimmedRowsMap.addLocalHook('init', _class_private_field_get(this, _onMapInit));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.rowIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_field_get(this, _onMapInit).call(this);
+        }
         super.enablePlugin();
     }
     /**

package/plugins/trimRows/trimRows.mjs

@@ -39,7 +39,6 @@ function _class_private_field_set(receiver, privateMap, value) {
     return value;
 }
 import { BasePlugin } from '../base/index.mjs';
-import { TrimmingMap } from '../../translations/index.mjs';
 import { arrayEach, arrayReduce } from '../../helpers/array.mjs';
 export const PLUGIN_KEY = 'trimRows';
 export const PLUGIN_PRIORITY = 330;
@@ -224,8 +223,13 @@ var /**
         if (this.enabled) {
             return;
         }
-        this.trimmedRowsMap = this.hot.rowIndexMapper.registerMap('trimRows', new TrimmingMap());
+        this.trimmedRowsMap = this.hot.rowIndexMapper.createAndRegisterIndexMap('trimRows', 'trimming');
         this.trimmedRowsMap.addLocalHook('init', _class_private_field_get(this, _onMapInit));
+        // `createAndRegisterIndexMap` initializes the map synchronously when the dataset is already
+        // loaded (a plugin re-enable), before the hook above could attach - replay the init handler.
+        if (this.hot.rowIndexMapper.getNumberOfIndexes() > 0) {
+            _class_private_field_get(this, _onMapInit).call(this);
+        }
         super.enablePlugin();
     }
     /**

package/plugins/types.d.ts

@@ -33,6 +33,7 @@ import type { ManualColumnResize } from './manualColumnResize';
 import type { ManualRowMove } from './manualRowMove';
 import type { ManualRowResize } from './manualRowResize';
 import type { MergeCells } from './mergeCells';
+import type { MoveCells } from './moveCells';
 import type { MultiColumnSorting } from './multiColumnSorting';
 import type { MultipleSelectionHandles } from './multipleSelectionHandles';
 import type { NestedHeaders } from './nestedHeaders';
@@ -40,6 +41,7 @@ import type { NestedRows } from './nestedRows';
 import type { Notification } from './notification';
 import type { Pagination } from './pagination';
 import type { Search } from './search';
+import type { SelectionHandles } from './selectionHandles';
 import type { StretchColumns } from './stretchColumns';
 import type { TouchScroll } from './touchScroll';
 import type { TrimRows } from './trimRows';
@@ -77,6 +79,7 @@ export interface PluginTypeMap {
     manualRowMove: ManualRowMove;
     manualRowResize: ManualRowResize;
     mergeCells: MergeCells;
+    moveCells: MoveCells;
     multiColumnSorting: MultiColumnSorting;
     multipleSelectionHandles: MultipleSelectionHandles;
     nestedHeaders: NestedHeaders;
@@ -84,6 +87,7 @@ export interface PluginTypeMap {
     notification: Notification;
     pagination: Pagination;
     search: Search;
+    selectionHandles: SelectionHandles;
     stretchColumns: StretchColumns;
     touchScroll: TouchScroll;
     trimRows: TrimRows;

package/plugins/undoRedo/actions/cellAlignment.js

@@ -44,7 +44,7 @@ class CellAlignmentAction extends _base.BaseAction {
    * @param {Core} hot The Handsontable instance.
    * @param {function(): void} redoneCallback The callback to be called after the action is redone.
    */ redo(hot, redoneCallback) {
-        (0, _utils.align)(this.range, this.type, this.alignment, (row, col)=>hot.getCellMeta(row, col), (row, col, key, value)=>hot.setCellMeta(row, col, key, value));
+        (0, _utils.align)(this.range, this.type, this.alignment, (row, col)=>hot.getCellMetaTransient(row, col), (row, col, key, value)=>hot.setCellMeta(row, col, key, value));
         hot.addHookOnce('afterViewRender', redoneCallback);
         hot.render();
     }

package/plugins/undoRedo/actions/cellAlignment.mjs

@@ -39,7 +39,7 @@ import { arrayEach } from '../../../helpers/array.mjs';
    * @param {Core} hot The Handsontable instance.
    * @param {function(): void} redoneCallback The callback to be called after the action is redone.
    */ redo(hot, redoneCallback) {
-        align(this.range, this.type, this.alignment, (row, col)=>hot.getCellMeta(row, col), (row, col, key, value)=>hot.setCellMeta(row, col, key, value));
+        align(this.range, this.type, this.alignment, (row, col)=>hot.getCellMetaTransient(row, col), (row, col, key, value)=>hot.setCellMeta(row, col, key, value));
         hot.addHookOnce('afterViewRender', redoneCallback);
         hot.render();
     }

package/plugins/undoRedo/actions/createColumn.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "CreateColumnAction", {
     }
 });
 const _base = require("./_base");
+const _fixedCounts = require("./fixedCounts");
 class CreateColumnAction extends _base.BaseAction {
     /**
    * Registers the `afterCreateCol` hook listener that records a new CreateColumnAction after columns are inserted.
@@ -25,7 +26,9 @@ class CreateColumnAction extends _base.BaseAction {
    * @param {function(): void} undoneCallback The callback to be called after the action is undone.
    */ undo(hot, undoneCallback) {
         hot.addHookOnce('afterRemoveCol', undoneCallback);
-        hot.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
+        (0, _fixedCounts.removeAndKeepFixedCounts)(hot, _fixedCounts.FIXED_COLUMN_COUNTS, ()=>{
+            hot.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
+        });
     }
     /**
    * @param {Core} hot The Handsontable instance.

package/plugins/undoRedo/actions/createColumn.mjs

@@ -1,4 +1,5 @@
 import { BaseAction } from './_base.mjs';
+import { FIXED_COLUMN_COUNTS, removeAndKeepFixedCounts } from './fixedCounts.mjs';
 /**
  * Action that tracks column creation.
  *
@@ -20,7 +21,9 @@ import { BaseAction } from './_base.mjs';
    * @param {function(): void} undoneCallback The callback to be called after the action is undone.
    */ undo(hot, undoneCallback) {
         hot.addHookOnce('afterRemoveCol', undoneCallback);
-        hot.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
+        removeAndKeepFixedCounts(hot, FIXED_COLUMN_COUNTS, ()=>{
+            hot.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
+        });
     }
     /**
    * @param {Core} hot The Handsontable instance.

package/plugins/undoRedo/actions/createRow.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "CreateRowAction", {
     }
 });
 const _base = require("./_base");
+const _fixedCounts = require("./fixedCounts");
 class CreateRowAction extends _base.BaseAction {
     /**
    * Registers the `afterCreateRow` hook listener that records a new CreateRowAction after rows are inserted.
@@ -30,7 +31,9 @@ class CreateRowAction extends _base.BaseAction {
             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');
+        (0, _fixedCounts.removeAndKeepFixedCounts)(hot, _fixedCounts.FIXED_ROW_COUNTS, ()=>{
+            hot.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
+        });
     }
     /**
    * @param {Core} hot The Handsontable instance.

package/plugins/undoRedo/actions/createRow.mjs

@@ -1,4 +1,5 @@
 import { BaseAction } from './_base.mjs';
+import { FIXED_ROW_COUNTS, removeAndKeepFixedCounts } from './fixedCounts.mjs';
 /**
  * Action that tracks row creation.
  *
@@ -25,7 +26,9 @@ import { BaseAction } from './_base.mjs';
             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');
+        removeAndKeepFixedCounts(hot, FIXED_ROW_COUNTS, ()=>{
+            hot.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
+        });
     }
     /**
    * @param {Core} hot The Handsontable instance.

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

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

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

@@ -0,0 +1,36 @@
+import type { HotInstance } from '../../../core/types';
+/**
+ * A fixed-area counter, described by the setting its value is read from and the setting its value is
+ * written to. The two keys differ for the fixed columns - see `FIXED_COLUMN_COUNTS`.
+ */
+interface FixedCount {
+    readKey: string;
+    writeKey: string;
+}
+/**
+ * The counters that `alter` lowers when it removes rows from a fixed area.
+ */
+export declare const FIXED_ROW_COUNTS: FixedCount[];
+/**
+ * The counters that `alter` lowers when it removes columns from a fixed area.
+ *
+ * Since 12.0.0, the "fixedColumnsLeft" option is replaced with the "fixedColumnsStart" option. The old
+ * name still works, and using both names together throws an error. To prevent that, the engine needs to
+ * modify the original option key to bypass the validation.
+ */
+export declare const FIXED_COLUMN_COUNTS: FixedCount[];
+/**
+ * Removes rows or columns and brings back the fixed-area counters that the removal lowered.
+ *
+ * Undoing an insertion removes the created rows or columns. When they belong to a fixed area, `alter`
+ * lowers the matching counter, which un-pins a row or column that was pinned before the insertion
+ * (DEV-2551). The values from before the removal are put back from the `beforeRender` hook, so `alter`
+ * still draws the grid once, with the counters already correct. Only a decrease is reverted - a value
+ * raised in the meantime by `updateSettings` stays as the user set it.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {Array} counts The counters to keep.
+ * @param {function(): void} removeCallback The callback that removes the rows or columns.
+ */
+export declare function removeAndKeepFixedCounts(hot: HotInstance, counts: FixedCount[], removeCallback: () => void): void;
+export {};

package/plugins/undoRedo/actions/fixedCounts.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get FIXED_COLUMN_COUNTS () {
+        return FIXED_COLUMN_COUNTS;
+    },
+    get FIXED_ROW_COUNTS () {
+        return FIXED_ROW_COUNTS;
+    },
+    get removeAndKeepFixedCounts () {
+        return removeAndKeepFixedCounts;
+    }
+});
+const FIXED_ROW_COUNTS = [
+    {
+        readKey: 'fixedRowsTop',
+        writeKey: 'fixedRowsTop'
+    },
+    {
+        readKey: 'fixedRowsBottom',
+        writeKey: 'fixedRowsBottom'
+    }
+];
+const FIXED_COLUMN_COUNTS = [
+    {
+        readKey: 'fixedColumnsStart',
+        writeKey: '_fixedColumnsStart'
+    }
+];
+function removeAndKeepFixedCounts(hot, counts, removeCallback) {
+    // Changing by the reference as `updateSettings` doesn't work the best.
+    const settings = hot.getSettings();
+    const countsBefore = counts.map(({ readKey })=>settings[readKey] ?? 0);
+    const restore = ()=>{
+        let wasRestored = false;
+        counts.forEach(({ readKey, writeKey }, index)=>{
+            if ((settings[readKey] ?? 0) < countsBefore[index]) {
+                settings[writeKey] = countsBefore[index];
+                wasRestored = true;
+            }
+        });
+        return wasRestored;
+    };
+    const onBeforeRender = ()=>{
+        restore();
+    };
+    // `alter` lowers the counters after the rows or columns are gone, but before it renders the grid.
+    hot.addHookOnce('beforeRender', onBeforeRender);
+    removeCallback();
+    hot.removeHook('beforeRender', onBeforeRender);
+    // The hook doesn't run while the rendering is suspended, so the counters are restored here instead.
+    if (restore()) {
+        hot.render();
+    }
+}

package/plugins/undoRedo/actions/fixedCounts.mjs

@@ -0,0 +1,62 @@
+/**
+ * The counters that `alter` lowers when it removes rows from a fixed area.
+ */ export const FIXED_ROW_COUNTS = [
+    {
+        readKey: 'fixedRowsTop',
+        writeKey: 'fixedRowsTop'
+    },
+    {
+        readKey: 'fixedRowsBottom',
+        writeKey: 'fixedRowsBottom'
+    }
+];
+/**
+ * The counters that `alter` lowers when it removes columns from a fixed area.
+ *
+ * Since 12.0.0, the "fixedColumnsLeft" option is replaced with the "fixedColumnsStart" option. The old
+ * name still works, and using both names together throws an error. To prevent that, the engine needs to
+ * modify the original option key to bypass the validation.
+ */ export const FIXED_COLUMN_COUNTS = [
+    {
+        readKey: 'fixedColumnsStart',
+        writeKey: '_fixedColumnsStart'
+    }
+];
+/**
+ * Removes rows or columns and brings back the fixed-area counters that the removal lowered.
+ *
+ * Undoing an insertion removes the created rows or columns. When they belong to a fixed area, `alter`
+ * lowers the matching counter, which un-pins a row or column that was pinned before the insertion
+ * (DEV-2551). The values from before the removal are put back from the `beforeRender` hook, so `alter`
+ * still draws the grid once, with the counters already correct. Only a decrease is reverted - a value
+ * raised in the meantime by `updateSettings` stays as the user set it.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {Array} counts The counters to keep.
+ * @param {function(): void} removeCallback The callback that removes the rows or columns.
+ */ export function removeAndKeepFixedCounts(hot, counts, removeCallback) {
+    // Changing by the reference as `updateSettings` doesn't work the best.
+    const settings = hot.getSettings();
+    const countsBefore = counts.map(({ readKey })=>settings[readKey] ?? 0);
+    const restore = ()=>{
+        let wasRestored = false;
+        counts.forEach(({ readKey, writeKey }, index)=>{
+            if ((settings[readKey] ?? 0) < countsBefore[index]) {
+                settings[writeKey] = countsBefore[index];
+                wasRestored = true;
+            }
+        });
+        return wasRestored;
+    };
+    const onBeforeRender = ()=>{
+        restore();
+    };
+    // `alter` lowers the counters after the rows or columns are gone, but before it renders the grid.
+    hot.addHookOnce('beforeRender', onBeforeRender);
+    removeCallback();
+    hot.removeHook('beforeRender', onBeforeRender);
+    // The hook doesn't run while the rendering is suspended, so the counters are restored here instead.
+    if (restore()) {
+        hot.render();
+    }
+}