handsontable 18.0.0 → 18.1.0-rc1

package/plugins/nestedHeaders/nestedHeaders.js

@@ -28,6 +28,7 @@ const _selection = require("../../selection");
 const _base = require("../base");
 const _stateManager = /*#__PURE__*/ _interop_require_default(require("./stateManager"));
 const _columnVisibility = require("./stateManager/columnVisibility");
+const _columnArrangement = require("./stateManager/columnArrangement");
 const _ghostTable = /*#__PURE__*/ _interop_require_default(require("./utils/ghostTable"));
 const _navigation = require("./utils/navigation");
 function _check_private_redeclaration(obj, privateCollection) {
@@ -36,15 +37,12 @@ function _check_private_redeclaration(obj, privateCollection) {
     }
 }
 function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
-    }
+    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.set) descriptor.set.call(receiver, value);
+    else {
         if (!descriptor.writable) {
             throw new TypeError("attempted to set read only private field");
         }
@@ -52,9 +50,7 @@ function _class_apply_descriptor_set(receiver, descriptor, value) {
     }
 }
 function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
+    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) {
@@ -71,9 +67,7 @@ function _class_private_field_set(receiver, privateMap, 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");
-    }
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
     return fn;
 }
 function _class_private_method_init(obj, privateSet) {
@@ -90,13 +84,61 @@ const PLUGIN_PRIORITY = 280;
 var /**
    * Manages the state tree of nested header spans and their visibility.
    */ _stateManager1 = /*#__PURE__*/ new WeakMap(), /**
+   * Set by afterColumnMove when a move runs inside a batched (suspended) index operation. The
+   * structure cannot be re-derived there (the mapper's caches are stale until resume), so the rebuild
+   * is deferred to the cacheUpdated that fires on resume, where the visual<->physical mapping is fresh.
+   */ _structureRebuildPending = /*#__PURE__*/ new WeakMap(), /**
+   * The physical indexes of the columns a move is relocating, captured in `beforeColumnMove` (where
+   * the pre-move mapping is fresh). After the move, `#reparentMovedColumns` translates them to their
+   * new visual positions and re-parents them into the cohesive group they were dropped inside. Cleared
+   * once consumed. Null when no move is in flight.
+   */ _movedPhysicalColumns = /*#__PURE__*/ new WeakMap(), /**
+   * The column index sequence captured in `beforeColumnMove`, before the move is applied. Compared
+   * against the post-move sequence so a no-op move (e.g. clicking a selected group header, which
+   * "moves" the columns to their own position) skips re-parenting - recomputing membership there
+   * would needlessly drop a column's existing adoption. Null when no move is in flight.
+   */ _preMoveColumnSequence = /*#__PURE__*/ new WeakMap(), /**
    * Handler bound to columnIndexMapper's cacheUpdated local hook. Keeps header colspan state
    * in sync with the current hiding map whenever visibility or column order changes.
    */ _onColumnIndexMapperCacheUpdated = /*#__PURE__*/ new WeakMap(), /**
+   * Handler bound to the afterColumnMove hook. A non-batched move is re-derived directly by
+   * #onColumnIndexMapperCacheUpdated (the cache update carries the 'move' source). A batched move's
+   * cache update fires on resume with the source already cleared, so flag a pending rebuild here -
+   * the resume cache update consumes it once the mapping is fresh.
+   */ _onAfterColumnMove = /*#__PURE__*/ new WeakMap(), /**
+   * Handler bound to the beforeColumnMove hook. Captures the moved columns as physical indexes while
+   * the pre-move mapping is fresh; `#reparentMovedColumns` consumes them after the move to re-parent
+   * each into the cohesive group it lands inside (or standalone).
+   *
+   * @param {number[]} movedColumns Visual indexes of the columns being moved.
+   * @param {number} finalIndex The target visual index (unused).
+   * @param {number|undefined} dropIndex The drop visual index (unused).
+   * @param {boolean} movePossible Whether the move can be performed.
+   */ _onBeforeColumnMove = /*#__PURE__*/ new WeakMap(), /**
+   * Re-parents the columns captured by `#onBeforeColumnMove` after the move completes. Translates the
+   * stored physical indexes to their new visual positions (the mapping is fresh by the time this runs)
+   * and hands them to the state manager, which records the membership overrides the derive needs to
+   * keep `columnDropMode: 'adopt'` groups cohesive.
+   */ _reparentMovedColumns = /*#__PURE__*/ new WeakSet(), /**
+   * Reports whether the captured moved columns account for the whole reordering between the pre-move
+   * and current physical index sequences. Removing those columns from both sequences must leave
+   * identical residuals, which holds by construction for any single `moveIndexes` call and fails when
+   * the cache update came from an unrelated reordering consuming a stale capture.
+   *
+   * @param {number[]} movedPhysicalColumns The physical indexes captured before the move.
+   * @param {number[]} previousSequence The physical index sequence captured before the move.
+   * @param {number[]} currentSequence The physical index sequence after the move.
+   * @returns {boolean} `true` when the captured columns explain the observed reordering.
+   */ _capturedMoveExplainsReorder = /*#__PURE__*/ new WeakSet(), /**
    * Stores the initial focus coordinates before a column header click initiates a range selection.
    */ _focusInitialCoords = /*#__PURE__*/ new WeakMap(), /**
    * Indicates whether a column selection drag triggered by a nested header click is currently in progress.
    */ _isColumnsSelectionInProgress = /*#__PURE__*/ new WeakMap(), /**
+   * Holds the columns to be selected when the pointer moves over a nested header during a drag. The selection
+   * is applied in the `afterOnCellMouseOver` hook so that it stays gated by `stopImmediatePropagation` called
+   * in a `beforeOnCellMouseOver` listener - mirroring how the mouse-down path applies its selection in
+   * `afterOnCellMouseDown`. Reset on every `beforeOnCellMouseOver` to avoid applying a stale range.
+   */ _columnsToSelectOnMouseOver = /*#__PURE__*/ new WeakMap(), /**
    * Keeps the last highlight position made by column selection. The coords are necessary to scroll
    * the viewport to the correct position when the nested header is clicked when the `navigableHeaders`
    * option is disabled.
@@ -168,8 +210,16 @@ var /**
    */ _onBeforeOnCellMouseDown = /*#__PURE__*/ new WeakMap(), /**
    * Initiates a column selection when a nested header cell is clicked, selecting all columns covered by the header span.
    */ _onAfterOnCellMouseDown = /*#__PURE__*/ new WeakMap(), /**
-   * Extends the column selection range when the pointer moves over a nested header cell during a drag selection.
+   * Computes the column selection range when the pointer moves over a nested header cell during a drag
+   * selection and stores it for the `afterOnCellMouseOver` hook to apply. Blocks the core's default
+   * selection handling through the `controller` so the range is driven solely by this plugin. The actual
+   * selection is deferred to `afterOnCellMouseOver` so it stays cancellable through `stopImmediatePropagation`.
    */ _onBeforeOnCellMouseOver = /*#__PURE__*/ new WeakMap(), /**
+   * Applies the column selection computed in `beforeOnCellMouseOver`. Running in the `afterOnCellMouseOver`
+   * hook keeps the selection cancellable - the core skips this hook when `stopImmediatePropagation` is called
+   * in a `beforeOnCellMouseOver` listener, so a drag over nested headers can be blocked the same way it is for
+   * regular column headers.
+   */ _onAfterOnCellMouseOver = /*#__PURE__*/ new WeakMap(), /**
    * Clears the in-progress column selection flag when the pointer button is released.
    */ _onBeforeOnCellMouseUp = /*#__PURE__*/ new WeakMap(), /**
    * Adjusts the selection highlight position when navigable headers are enabled and a multi-column header is selected.
@@ -180,8 +230,19 @@ var /**
    */ _onBeforeSelectColumns = /*#__PURE__*/ new WeakMap(), /**
    * Replaces the default column header renderer array with layer-specific renderers generated by this plugin.
    */ _onAfterGetColumnHeaderRenderers = /*#__PURE__*/ new WeakMap(), /**
-   * Extends the viewport start column to include any header spans that begin outside the calculated viewport boundary.
+   * Extends the viewport's rendered column range so that every nested header group intersecting
+   * the viewport is rendered in full. A wide colspan straddling a viewport edge would otherwise
+   * render only partially, so its `<th>` width changes as columns enter or leave the render range
+   * while scrolling - which makes the center-aligned header label jump. Expanding both the start
+   * and the end boundary to the group's edges keeps each colspan `<th>` at a constant width while
+   * the group is visible (issue #4628).
    */ _onAfterViewportColumnCalculatorOverride = /*#__PURE__*/ new WeakMap(), /**
+   * Extends the viewport start column to include any header spans that begin before the calculated
+   * viewport start boundary.
+   */ _extendViewportStartColumn = /*#__PURE__*/ new WeakSet(), /**
+   * Extends the viewport end column to include any header spans that end after the calculated
+   * viewport end boundary, keeping a colspan header that straddles the right edge fully rendered.
+   */ _extendViewportEndColumn = /*#__PURE__*/ new WeakSet(), /**
    * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook.
    *
    * When `autoColumnSize` is explicitly disabled, the user opts out of auto-sizing
@@ -220,6 +281,7 @@ _onInit = /*#__PURE__*/ new WeakMap(), /**
    *
    * @param {number} visualColumnIndex A visual column index from which the columns were removed.
    * @param {number} amount The number of removed columns.
+   * @param {number[]} physicalColumns The physical indexes of the removed columns.
    */ _onAfterRemoveCol = /*#__PURE__*/ new WeakMap(), /**
    * Builds the widths map before the view is rendered.
    */ _onBeforeViewRender = /*#__PURE__*/ new WeakMap();
@@ -254,9 +316,12 @@ class NestedHeaders extends _base.BasePlugin {
         this.addHook('afterLoadData', _class_private_field_get(this, _onAfterLoadData));
         this.addHook('afterCreateCol', _class_private_field_get(this, _onAfterCreateCol));
         this.addHook('afterRemoveCol', _class_private_field_get(this, _onAfterRemoveCol));
+        this.addHook('beforeColumnMove', _class_private_field_get(this, _onBeforeColumnMove));
+        this.addHook('afterColumnMove', _class_private_field_get(this, _onAfterColumnMove));
         this.addHook('beforeOnCellMouseDown', _class_private_field_get(this, _onBeforeOnCellMouseDown));
         this.addHook('afterOnCellMouseDown', _class_private_field_get(this, _onAfterOnCellMouseDown));
         this.addHook('beforeOnCellMouseOver', _class_private_field_get(this, _onBeforeOnCellMouseOver));
+        this.addHook('afterOnCellMouseOver', _class_private_field_get(this, _onAfterOnCellMouseOver));
         this.addHook('beforeOnCellMouseUp', _class_private_field_get(this, _onBeforeOnCellMouseUp));
         this.addHook('beforeSelectionHighlightSet', _class_private_field_get(this, _onBeforeSelectionHighlightSet));
         this.addHook('modifyTransformStart', _class_private_field_get(this, _onModifyTransformStart));
@@ -291,6 +356,8 @@ class NestedHeaders extends _base.BasePlugin {
         _class_private_field_set(this, _rowspanHeaderNavigationContextRow, null);
         _class_private_field_set(this, _expectedNextKeyboardHighlightCoords, null);
         _class_private_field_get(this, _stateManager1).setColumnsLimit(this.hot.countCols());
+        // Derive the header structure against the live column arrangement so it follows column moves.
+        _class_private_field_get(this, _stateManager1).setColumnArrangement((0, _columnArrangement.createColumnArrangementAdapter)(this.hot));
         if (Array.isArray(nestedHeaders)) {
             this.detectedOverlappedHeaders = _class_private_field_get(this, _stateManager1).setState(nestedHeaders);
         }
@@ -460,18 +527,36 @@ class NestedHeaders extends _base.BasePlugin {
         return _class_private_field_get(this, _stateManager1).getHeaderTreeNodeData(coords.row, coords.col);
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _applyColspan), _class_private_method_init(this, _applyRowspan), _class_private_method_init(this, _findRenderableHeaderRow), _class_private_method_init(this, _getRootHeaderRowspan), _class_private_method_init(this, _isNavigableHeaderCell), _class_private_method_init(this, _findNearestNavigableHeaderColumn), _class_private_field_init(this, _stateManager1, {
+        super(...args), _class_private_method_init(this, _reparentMovedColumns), _class_private_method_init(this, _capturedMoveExplainsReorder), _class_private_method_init(this, _applyColspan), _class_private_method_init(this, _applyRowspan), _class_private_method_init(this, _findRenderableHeaderRow), _class_private_method_init(this, _getRootHeaderRowspan), _class_private_method_init(this, _isNavigableHeaderCell), _class_private_method_init(this, _findNearestNavigableHeaderColumn), _class_private_method_init(this, _extendViewportStartColumn), _class_private_method_init(this, _extendViewportEndColumn), _class_private_field_init(this, _stateManager1, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _structureRebuildPending, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _movedPhysicalColumns, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _preMoveColumnSequence, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _onColumnIndexMapperCacheUpdated, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onAfterColumnMove, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnMove, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _focusInitialCoords, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _isColumnsSelectionInProgress, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _columnsToSelectOnMouseOver, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _recentlyHighlightCoords, {
             writable: true,
             value: void 0
@@ -510,6 +595,9 @@ class NestedHeaders extends _base.BasePlugin {
         }), _class_private_field_init(this, _onBeforeOnCellMouseOver, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onAfterOnCellMouseOver, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onBeforeOnCellMouseUp, {
             writable: true,
             value: void 0
@@ -555,10 +643,33 @@ class NestedHeaders extends _base.BasePlugin {
         }), _class_private_field_init(this, _onBeforeViewRender, {
             writable: true,
             value: void 0
-        }), _class_private_field_set(this, _stateManager1, new _stateManager.default()), _class_private_field_set(this, _onColumnIndexMapperCacheUpdated, ({ hiddenIndexesChanged })=>{
+        }), _class_private_field_set(this, _stateManager1, new _stateManager.default()), _class_private_field_set(this, _structureRebuildPending, false), _class_private_field_set(this, _movedPhysicalColumns, null), _class_private_field_set(this, _preMoveColumnSequence, null), _class_private_field_set(this, _onColumnIndexMapperCacheUpdated, ({ indexesSequenceChanged, hiddenIndexesChanged })=>{
             if (!this.enabled) {
                 return;
             }
+            // A column move changes the visual<->physical mapping without mutating the authored settings, so
+            // re-derive the header tree to make the structure (labels and group spans) follow the data; a
+            // group whose columns are no longer adjacent renders as multiple same-label banners. A non-batched
+            // move carries the 'move' change source on this cache update. A batched / suspended move's cache
+            // update fires on resume with the source already cleared, so afterColumnMove flags a pending
+            // rebuild for that case. Both re-derive here, where the mapping is fresh. The 'move' gate excludes
+            // init / insert / remove, which rebuild through their own paths (setState, afterCreateCol,
+            // afterRemoveCol) and would otherwise be double-processed (e.g. re-applying a collapse twice).
+            const isColumnMove = indexesSequenceChanged && this.hot.columnIndexMapper.indexesChangeSource === 'move';
+            if (isColumnMove || _class_private_field_get(this, _structureRebuildPending)) {
+                // Re-parent the moved columns first (cohesive groups adopt/release members), then re-derive so
+                // the tree reflects both the new arrangement and the membership changes.
+                _class_private_method_get(this, _reparentMovedColumns, reparentMovedColumns).call(this);
+                _class_private_field_get(this, _stateManager1).rebuildState();
+                // Only release the captured move state once it has been consumed here. A move that splits a
+                // collapsed group makes CollapsibleColumns expand it from its own beforeColumnMove handler; that
+                // expansion mutates the hiding map and fires a synchronous cacheUpdated (hiddenIndexesChanged
+                // only) before moveIndexes runs. Clearing the capture unconditionally on that intermediate update
+                // dropped #movedPhysicalColumns, so the real move's cacheUpdated found nothing to re-parent.
+                _class_private_field_set(this, _structureRebuildPending, false);
+                _class_private_field_set(this, _movedPhysicalColumns, null);
+                _class_private_field_set(this, _preMoveColumnSequence, null);
+            }
             // syncVisibility must run on every cache update (including a pure column move) so the tree's
             // colspan / isHidden stay aligned with the current visual<->physical mapping (DEV-1717).
             _class_private_field_get(this, _stateManager1).syncVisibility((0, _columnVisibility.createColumnVisibilityAdapter)(this.hot));
@@ -569,7 +680,16 @@ class NestedHeaders extends _base.BasePlugin {
             if (hiddenIndexesChanged) {
                 this.ghostTable.buildWidthsMap();
             }
-        }), _class_private_field_set(this, _focusInitialCoords, null), _class_private_field_set(this, _isColumnsSelectionInProgress, false), _class_private_field_set(this, _recentlyHighlightCoords, null), _class_private_field_set(this, _rowspanHeaderNavigationContextRow, null), _class_private_field_set(this, _expectedNextKeyboardHighlightCoords, null), _class_private_field_set(this, _updateWidthsMap, false), /**
+        }), _class_private_field_set(this, _onAfterColumnMove, ()=>{
+            if (this.enabled && this.hot.columnIndexMapper.isBatched) {
+                _class_private_field_set(this, _structureRebuildPending, true);
+            }
+        }), _class_private_field_set(this, _onBeforeColumnMove, (movedColumns, finalIndex, dropIndex, movePossible)=>{
+            if (this.enabled && movePossible !== false) {
+                _class_private_field_set(this, _movedPhysicalColumns, movedColumns.map((visualColumn)=>this.hot.toPhysicalColumn(visualColumn)));
+                _class_private_field_set(this, _preMoveColumnSequence, this.hot.columnIndexMapper.getIndexesSequence());
+            }
+        }), _class_private_field_set(this, _focusInitialCoords, null), _class_private_field_set(this, _isColumnsSelectionInProgress, false), _class_private_field_set(this, _columnsToSelectOnMouseOver, null), _class_private_field_set(this, _recentlyHighlightCoords, null), _class_private_field_set(this, _rowspanHeaderNavigationContextRow, null), _class_private_field_set(this, _expectedNextKeyboardHighlightCoords, null), _class_private_field_set(this, _updateWidthsMap, false), /**
    * Custom helper for getting widths of the nested headers.
    */ // @TODO This should be changed after refactor handsontable/utils/ghostTable.
         this.ghostTable = new _ghostTable.default({
@@ -752,6 +872,7 @@ class NestedHeaders extends _base.BasePlugin {
                 selection.selectColumns(...columnsToSelect);
             }
         }), _class_private_field_set(this, _onBeforeOnCellMouseOver, (event, coords, TD, controller)=>{
+            _class_private_field_set(this, _columnsToSelectOnMouseOver, null);
             if (!this.hot.view.isMouseDown() || controller.column) {
                 return;
             }
@@ -790,6 +911,13 @@ class NestedHeaders extends _base.BasePlugin {
                     headerLevel
                 ];
             }
+            _class_private_field_set(this, _columnsToSelectOnMouseOver, columnsToSelect);
+        }), _class_private_field_set(this, _onAfterOnCellMouseOver, ()=>{
+            if (_class_private_field_get(this, _columnsToSelectOnMouseOver) === null) {
+                return;
+            }
+            const columnsToSelect = _class_private_field_get(this, _columnsToSelectOnMouseOver);
+            _class_private_field_set(this, _columnsToSelectOnMouseOver, null);
             this.hot.selection.selectColumns(...columnsToSelect);
         }), _class_private_field_set(this, _onBeforeOnCellMouseUp, ()=>{
             _class_private_field_set(this, _isColumnsSelectionInProgress, false);
@@ -971,21 +1099,8 @@ class NestedHeaders extends _base.BasePlugin {
                 }
             }
         }), _class_private_field_set(this, _onAfterViewportColumnCalculatorOverride, (calc)=>{
-            const headerLayersCount = _class_private_field_get(this, _stateManager1).getLayersCount();
-            let newStartColumn = calc.startColumn;
-            let nonRenderable = !!headerLayersCount;
-            for(let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++){
-                const startColumn = _class_private_field_get(this, _stateManager1).findLeftMostColumnIndex(headerLayer, calc.startColumn);
-                const renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn);
-                if (startColumn >= 0) {
-                    nonRenderable = false;
-                }
-                if ((0, _number.isNumeric)(renderedStartColumn) && renderedStartColumn !== null && renderedStartColumn < calc.startColumn) {
-                    newStartColumn = renderedStartColumn;
-                    break;
-                }
-            }
-            calc.startColumn = nonRenderable ? _class_private_field_get(this, _stateManager1).getHeaderTreeNodeData(0, newStartColumn)?.columnIndex ?? newStartColumn : newStartColumn;
+            _class_private_method_get(this, _extendViewportStartColumn, extendViewportStartColumn).call(this, calc);
+            _class_private_method_get(this, _extendViewportEndColumn, extendViewportEndColumn).call(this, calc);
         }), _class_private_field_set(this, _onModifyColWidth, (width, column)=>{
             if (this.hot.getSettings().autoColumnSize === false) {
                 return width;
@@ -1020,10 +1135,13 @@ class NestedHeaders extends _base.BasePlugin {
                 this.updatePlugin();
             }
         }), _class_private_field_set(this, _onAfterCreateCol, (visualColumnIndex, amount)=>{
-            _class_private_field_get(this, _stateManager1).insertColumns(visualColumnIndex, amount);
+            // The authored header settings are keyed by physical column, but the hook reports a visual index.
+            // Translate it so the structure stays aligned after a column move, where visual != physical.
+            const physicalColumnIndex = this.hot.columnIndexMapper.getPhysicalFromVisualIndex(visualColumnIndex) ?? visualColumnIndex;
+            _class_private_field_get(this, _stateManager1).insertColumns(visualColumnIndex, physicalColumnIndex, amount);
             _class_private_field_set(this, _updateWidthsMap, true);
-        }), _class_private_field_set(this, _onAfterRemoveCol, (visualColumnIndex, amount)=>{
-            _class_private_field_get(this, _stateManager1).removeColumns(visualColumnIndex, amount);
+        }), _class_private_field_set(this, _onAfterRemoveCol, (visualColumnIndex, amount, physicalColumns)=>{
+            _class_private_field_get(this, _stateManager1).removeColumns(visualColumnIndex, amount, physicalColumns);
             _class_private_field_set(this, _updateWidthsMap, true);
         }), _class_private_field_set(this, _onBeforeViewRender, ()=>{
             if (_class_private_field_get(this, _updateWidthsMap)) {
@@ -1033,6 +1151,44 @@ class NestedHeaders extends _base.BasePlugin {
         });
     }
 }
+function reparentMovedColumns() {
+    const movedPhysicalColumns = _class_private_field_get(this, _movedPhysicalColumns);
+    const previous = _class_private_field_get(this, _preMoveColumnSequence);
+    if (movedPhysicalColumns === null || previous === null) {
+        return;
+    }
+    // A no-op move (the column order is unchanged - e.g. clicking a selected group header) must not
+    // re-parent: recomputing membership for the "moved" columns would drop a prior adoption and split
+    // the group. Only re-parent when the move actually reordered the columns.
+    const sequence = this.hot.columnIndexMapper.getIndexesSequence();
+    if (previous.length === sequence.length && previous.every((physicalColumn, index)=>physicalColumn === sequence[index])) {
+        return;
+    }
+    // The capture is only valid for the move that produced this cache update. A hard-vetoed move
+    // (a beforeColumnMove handler returning false) leaves the capture set with no move performed, and
+    // a later 'move' cache update from another path (e.g. manualColumnFreeze calling moveIndexes
+    // directly, which skips beforeColumnMove) would then re-parent the stale columns. moveIndexes
+    // rebuilds the sequence as the non-moved columns in their original order with the moved columns
+    // reinserted, so removing the captured columns from both sequences must leave identical residuals.
+    // When they differ, this update came from a different reordering - skip rather than misapply it.
+    if (!_class_private_method_get(this, _capturedMoveExplainsReorder, capturedMoveExplainsReorder).call(this, movedPhysicalColumns, previous, sequence)) {
+        return;
+    }
+    const movedVisualColumns = [];
+    movedPhysicalColumns.forEach((physicalColumn)=>{
+        const visualColumn = this.hot.columnIndexMapper.getVisualFromPhysicalIndex(physicalColumn);
+        if (visualColumn !== null) {
+            movedVisualColumns.push(visualColumn);
+        }
+    });
+    _class_private_field_get(this, _stateManager1).reparentColumns(movedVisualColumns);
+}
+function capturedMoveExplainsReorder(movedPhysicalColumns, previousSequence, currentSequence) {
+    const movedSet = new Set(movedPhysicalColumns);
+    const residualBefore = previousSequence.filter((physicalColumn)=>!movedSet.has(physicalColumn));
+    const residualAfter = currentSequence.filter((physicalColumn)=>!movedSet.has(physicalColumn));
+    return residualBefore.length === residualAfter.length && residualBefore.every((physicalColumn, index)=>physicalColumn === residualAfter[index]);
+}
 function applyColspan(TH, colspan, visualColumnIndex, renderedColumnIndex, fixedColumnsStart) {
     if (colspan === undefined || colspan <= 1) {
         return;
@@ -1100,3 +1256,39 @@ function findNearestNavigableHeaderColumn(headerRow, visualColumnIndex, directio
     }
     return null;
 }
+function extendViewportStartColumn(calc) {
+    const headerLayersCount = _class_private_field_get(this, _stateManager1).getLayersCount();
+    let newStartColumn = calc.startColumn;
+    let nonRenderable = !!headerLayersCount;
+    for(let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++){
+        const startColumn = _class_private_field_get(this, _stateManager1).findLeftMostColumnIndex(headerLayer, calc.startColumn);
+        const renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn);
+        if (startColumn >= 0) {
+            nonRenderable = false;
+        }
+        if ((0, _number.isNumeric)(renderedStartColumn) && renderedStartColumn !== null && renderedStartColumn < calc.startColumn) {
+            newStartColumn = renderedStartColumn;
+            break;
+        }
+    }
+    calc.startColumn = nonRenderable ? _class_private_field_get(this, _stateManager1).getHeaderTreeNodeData(0, newStartColumn)?.columnIndex ?? newStartColumn : newStartColumn;
+}
+function extendViewportEndColumn(calc) {
+    const columnIndexMapper = this.hot.columnIndexMapper;
+    const headerLayersCount = _class_private_field_get(this, _stateManager1).getLayersCount();
+    const visualEndColumn = columnIndexMapper.getVisualFromRenderableIndex(calc.endColumn);
+    if (visualEndColumn === null) {
+        return;
+    }
+    for(let headerLayer = 0; headerLayer < headerLayersCount; headerLayer++){
+        const endColumn = _class_private_field_get(this, _stateManager1).findRightMostColumnIndex(headerLayer, visualEndColumn);
+        const nearestColumn = columnIndexMapper.getNearestNotHiddenIndex(endColumn, -1);
+        const renderedEndColumn = nearestColumn === null ? null : columnIndexMapper.getRenderableFromVisualIndex(nearestColumn);
+        // The top header layer holds the widest spans, so the first layer that expands the
+        // boundary already yields the largest extent - no deeper layer can exceed it.
+        if (renderedEndColumn !== null && renderedEndColumn > calc.endColumn) {
+            calc.endColumn = renderedEndColumn;
+            break;
+        }
+    }
+}