handsontable 18.0.0 → 18.1.0-rc1

package/plugins/autofill/autofill.js

@@ -34,15 +34,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");
         }
@@ -50,9 +47,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) {
@@ -69,9 +64,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) {
@@ -91,9 +84,11 @@ var /**
    *
    * @type {string|null}
    */ _currentDragDirection = /*#__PURE__*/ new WeakMap(), /**
-   * Last mouse client position.
+   * Last mouse client position. Stays `null` until the first `mousemove` of a drag, so a scroll
+   * that happens after pressing the fill handle but before any drag move is not replayed with a
+   * stale or default position.
    *
-   * @type {{ clientX: number, clientY: number }}
+   * @type {{ clientX: number, clientY: number } | null}
    */ _lastMouseClientPosition = /*#__PURE__*/ new WeakMap(), /**
    * Adjusts fill data for reverse drag directions ('up' or 'left') by reordering rows or columns.
    *
@@ -138,6 +133,10 @@ var /**
    * On mouse move listener.
    *
    * @param {MouseEvent} event `mousemove` event properties.
+   * @param {boolean} [countDragStep=true] Whether a move onto a new cell should be counted as a
+   * drag step. Only genuine pointer moves count; a scroll replay (see `#onAfterScroll`) redraws
+   * the border without counting, otherwise a scroll that shifts the cell under a resting pointer
+   * would register a drag that never happened.
    */ _onMouseMove = /*#__PURE__*/ new WeakSet(), /**
    * Refreshes the autofill borders using the last mouse client position after scroll.
    */ _onAfterScroll = /*#__PURE__*/ new WeakMap();
@@ -253,15 +252,19 @@ class Autofill extends _base.BasePlugin {
         ]);
         const copyableRows = [];
         const copyableColumns = [];
+        const seenRows = new Set();
+        const seenColumns = new Set();
         const data = [];
         (0, _array.arrayEach)(copyableRanges, (range)=>{
             for(let visualRow = range.startRow; visualRow <= range.endRow; visualRow += 1){
-                if (copyableRows.indexOf(visualRow) === -1) {
+                if (!seenRows.has(visualRow)) {
+                    seenRows.add(visualRow);
                     copyableRows.push(visualRow);
                 }
             }
             for(let visualColumn = range.startCol; visualColumn <= range.endCol; visualColumn += 1){
-                if (copyableColumns.indexOf(visualColumn) === -1) {
+                if (!seenColumns.has(visualColumn)) {
+                    seenColumns.add(visualColumn);
                     copyableColumns.push(visualColumn);
                 }
             }
@@ -619,10 +622,7 @@ class Autofill extends _base.BasePlugin {
    *
    * @private
    * @type {boolean}
-   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, {
-            clientX: 0,
-            clientY: 0
-        }), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
+   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, null), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
             const selectionApplied = this.selectAdjacent();
             if (selectionApplied) {
                 this.fillIn();
@@ -631,9 +631,10 @@ class Autofill extends _base.BasePlugin {
             this.handleDraggedCells = 1;
             this.mouseDownOnCellCorner = true;
             _class_private_field_set(this, _currentDragDirection, null);
+            _class_private_field_set(this, _lastMouseClientPosition, null);
         }), _class_private_field_set(this, _onAfterScroll, ()=>{
-            if (this.mouseDownOnCellCorner) {
-                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition));
+            if (this.mouseDownOnCellCorner && _class_private_field_get(this, _lastMouseClientPosition)) {
+                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition), false);
             }
         });
     }
@@ -675,7 +676,9 @@ function extendFillDataWithSourceData(fillData, selectionSourceData, startOfDrag
         fullFillData.push([]);
         for(let columnIndex = Math.min(startOfDragCoords.col, endOfDragCoords.col); columnIndex <= Math.max(startOfDragCoords.col, endOfDragCoords.col); columnIndex += 1){
             const targetCellSourceData = this.hot.getSourceDataAtCell(rowIndex, columnIndex);
-            const cellMeta = this.hot.getCellMeta(rowIndex, columnIndex);
+            // The transient read keeps a large drag-fill or fill-down from permanently materializing
+            // one meta object per filled cell - the loop only reads `source`/`_complexDataFormat`.
+            const cellMeta = this.hot.getCellMetaTransient(rowIndex, columnIndex);
             const cellSource = cellMeta.source;
             const cellSourceFirstItem = Array.isArray(cellSource) ? cellSource[0] : undefined;
             const isComplexDataFormatCell = cellMeta._complexDataFormat || (0, _object.isObject)(cellSourceFirstItem) || Array.isArray(cellSourceFirstItem);
@@ -713,14 +716,22 @@ function onMouseUp() {
         _class_private_field_set(this, _currentDragDirection, null);
     }
 }
-function onMouseMove(event) {
+function onMouseMove(event, countDragStep = true) {
     if (this.mouseDownOnCellCorner) {
         const { clientX, clientY } = event;
         const cellCoords = (0, _cellCoords.getCellCoordsFromMousePosition)(this.hot, clientX, clientY);
+        const selectedRange = this.hot.getSelectedRangeLast();
         _class_private_field_set(this, _lastMouseClientPosition, {
             clientX,
             clientY
         });
+        // The `beforeOnCellMouseOver`-based counting doesn't fire when the pointer leaves
+        // the table element (e.g. dragging the last column's fill handle at a slight angle,
+        // past the table's edge), so count the drag here as well. Otherwise the fill made
+        // with such a drag would never be committed on mouseup.
+        if (countDragStep && this.handleDraggedCells > 0 && selectedRange && !selectedRange.includes(cellCoords)) {
+            this.handleDraggedCells += 1;
+        }
         this.redrawBorders(cellCoords);
     }
     const mouseWasDraggedOutside = this.getIfMouseWasDraggedOutside(event);

package/plugins/autofill/autofill.mjs

@@ -4,15 +4,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");
         }
@@ -20,9 +17,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) {
@@ -39,9 +34,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) {
@@ -70,9 +63,11 @@ var /**
    *
    * @type {string|null}
    */ _currentDragDirection = /*#__PURE__*/ new WeakMap(), /**
-   * Last mouse client position.
+   * Last mouse client position. Stays `null` until the first `mousemove` of a drag, so a scroll
+   * that happens after pressing the fill handle but before any drag move is not replayed with a
+   * stale or default position.
    *
-   * @type {{ clientX: number, clientY: number }}
+   * @type {{ clientX: number, clientY: number } | null}
    */ _lastMouseClientPosition = /*#__PURE__*/ new WeakMap(), /**
    * Adjusts fill data for reverse drag directions ('up' or 'left') by reordering rows or columns.
    *
@@ -117,6 +112,10 @@ var /**
    * On mouse move listener.
    *
    * @param {MouseEvent} event `mousemove` event properties.
+   * @param {boolean} [countDragStep=true] Whether a move onto a new cell should be counted as a
+   * drag step. Only genuine pointer moves count; a scroll replay (see `#onAfterScroll`) redraws
+   * the border without counting, otherwise a scroll that shifts the cell under a resting pointer
+   * would register a drag that never happened.
    */ _onMouseMove = /*#__PURE__*/ new WeakSet(), /**
    * Refreshes the autofill borders using the last mouse client position after scroll.
    */ _onAfterScroll = /*#__PURE__*/ new WeakMap();
@@ -243,15 +242,19 @@ var /**
         ]);
         const copyableRows = [];
         const copyableColumns = [];
+        const seenRows = new Set();
+        const seenColumns = new Set();
         const data = [];
         arrayEach(copyableRanges, (range)=>{
             for(let visualRow = range.startRow; visualRow <= range.endRow; visualRow += 1){
-                if (copyableRows.indexOf(visualRow) === -1) {
+                if (!seenRows.has(visualRow)) {
+                    seenRows.add(visualRow);
                     copyableRows.push(visualRow);
                 }
             }
             for(let visualColumn = range.startCol; visualColumn <= range.endCol; visualColumn += 1){
-                if (copyableColumns.indexOf(visualColumn) === -1) {
+                if (!seenColumns.has(visualColumn)) {
+                    seenColumns.add(visualColumn);
                     copyableColumns.push(visualColumn);
                 }
             }
@@ -609,10 +612,7 @@ var /**
    *
    * @private
    * @type {boolean}
-   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, {
-            clientX: 0,
-            clientY: 0
-        }), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
+   */ this.autoInsertRow = false, _class_private_field_set(this, _currentDragDirection, null), _class_private_field_set(this, _lastMouseClientPosition, null), _class_private_field_set(this, _onCellCornerDblClick, ()=>{
             const selectionApplied = this.selectAdjacent();
             if (selectionApplied) {
                 this.fillIn();
@@ -621,9 +621,10 @@ var /**
             this.handleDraggedCells = 1;
             this.mouseDownOnCellCorner = true;
             _class_private_field_set(this, _currentDragDirection, null);
+            _class_private_field_set(this, _lastMouseClientPosition, null);
         }), _class_private_field_set(this, _onAfterScroll, ()=>{
-            if (this.mouseDownOnCellCorner) {
-                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition));
+            if (this.mouseDownOnCellCorner && _class_private_field_get(this, _lastMouseClientPosition)) {
+                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, _class_private_field_get(this, _lastMouseClientPosition), false);
             }
         });
     }
@@ -665,7 +666,9 @@ function extendFillDataWithSourceData(fillData, selectionSourceData, startOfDrag
         fullFillData.push([]);
         for(let columnIndex = Math.min(startOfDragCoords.col, endOfDragCoords.col); columnIndex <= Math.max(startOfDragCoords.col, endOfDragCoords.col); columnIndex += 1){
             const targetCellSourceData = this.hot.getSourceDataAtCell(rowIndex, columnIndex);
-            const cellMeta = this.hot.getCellMeta(rowIndex, columnIndex);
+            // The transient read keeps a large drag-fill or fill-down from permanently materializing
+            // one meta object per filled cell - the loop only reads `source`/`_complexDataFormat`.
+            const cellMeta = this.hot.getCellMetaTransient(rowIndex, columnIndex);
             const cellSource = cellMeta.source;
             const cellSourceFirstItem = Array.isArray(cellSource) ? cellSource[0] : undefined;
             const isComplexDataFormatCell = cellMeta._complexDataFormat || isObject(cellSourceFirstItem) || Array.isArray(cellSourceFirstItem);
@@ -703,14 +706,22 @@ function onMouseUp() {
         _class_private_field_set(this, _currentDragDirection, null);
     }
 }
-function onMouseMove(event) {
+function onMouseMove(event, countDragStep = true) {
     if (this.mouseDownOnCellCorner) {
         const { clientX, clientY } = event;
         const cellCoords = getCellCoordsFromMousePosition(this.hot, clientX, clientY);
+        const selectedRange = this.hot.getSelectedRangeLast();
         _class_private_field_set(this, _lastMouseClientPosition, {
             clientX,
             clientY
         });
+        // The `beforeOnCellMouseOver`-based counting doesn't fire when the pointer leaves
+        // the table element (e.g. dragging the last column's fill handle at a slight angle,
+        // past the table's edge), so count the drag here as well. Otherwise the fill made
+        // with such a drag would never be committed on mouseup.
+        if (countDragStep && this.handleDraggedCells > 0 && selectedRange && !selectedRange.includes(cellCoords)) {
+            this.handleDraggedCells += 1;
+        }
         this.redrawBorders(cellCoords);
     }
     const mouseWasDraggedOutside = this.getIfMouseWasDraggedOutside(event);

package/plugins/base/base.d.ts

@@ -1,4 +1,5 @@
 import type { HotInstance } from '../../core/types';
+import type { HookCallback } from '../../core/hooks/bucket';
 import type { Events } from '../../core/settings';
 import EventManager from '../../eventManager';
 export declare const defaultMainSettingSymbol: unique symbol;
@@ -133,6 +134,15 @@ export declare class BasePlugin {
      *                              If 0 or no order index is provided, the callback will be added between the "negative" and "positive" indexes.
      */
     addHook<K extends keyof Events>(name: K, callback: Events[K], orderIndex?: number): void;
+    /**
+     * Registers a hook listener under a known hook name, accepting any explicitly-annotated callback
+     * (see the overload-ladder description on `HotInstance` in `core/types.ts`).
+     */
+    addHook<K extends keyof Events>(name: K, callback: HookCallback, orderIndex?: number): void;
+    /**
+     * Registers a hook listener under a dynamically-named hook.
+     */
+    addHook(name: string, callback: HookCallback, orderIndex?: number): void;
     /**
      * Remove all hooks listeners by hook name.
      *

package/plugins/base/base.js

@@ -37,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");
         }
@@ -53,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) {
@@ -72,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) {

package/plugins/base/base.mjs

@@ -4,15 +4,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");
         }
@@ -20,9 +17,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) {
@@ -39,9 +34,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) {

package/plugins/bindRowsWithHeaders/bindRowsWithHeaders.js

@@ -28,15 +28,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");
         }
@@ -44,9 +41,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) {

package/plugins/bindRowsWithHeaders/bindRowsWithHeaders.mjs

@@ -4,15 +4,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");
         }
@@ -20,9 +17,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) {

package/plugins/collapsibleColumns/collapsibleColumns.d.ts

@@ -18,6 +18,10 @@ export declare const PLUGIN_PRIORITY = 290;
  * To limit this functionality to a smaller group of headers, define the `collapsibleColumns` property as an array
  * of objects, as in the example below.
  *
+ * Read more:
+ * - [Guides: Column groups](@/guides/columns/column-groups/column-groups.md#collapsible-headers)
+ * - [Configuration options: `collapsibleColumns`](@/api/options.md#collapsiblecolumns)
+ *
  * @example
  * ::: only-for javascript
  * ```js

package/plugins/collapsibleColumns/collapsibleColumns.js

@@ -34,15 +34,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");
         }
@@ -50,9 +47,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) {
@@ -69,9 +64,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) {
@@ -137,6 +130,34 @@ var /**
    * insertion or removal. The tree (with `isCollapsed` restored) is the source of truth, so a full
    * refresh keeps the hidden set correct without tracking shifted indexes manually.
    */ _onAfterColumnStructureChange = /*#__PURE__*/ new WeakMap(), /**
+   * Expands, before a column move runs, any collapsed group the move would split - whether by taking
+   * some (but not all) of the group's columns out, or by dropping an unrelated column into the middle
+   * of its span. Both leave the group's columns non-adjacent, which drops its collapse indicator while
+   * the columns stay hidden, with no control left to expand them. Expanding while the group is still
+   * contiguous releases its columns through the normal expand path; hiding does not change visual
+   * indexes, so the pending move's coordinates stay valid. A move that keeps a group's columns
+   * together (including moving the whole group) leaves it collapsed.
+   *
+   * @param {number[]} movedColumns Visual indexes of the columns being moved.
+   * @param {number} finalIndex The visual index the moved columns will start at after the move.
+   * @param {number|undefined} dropIndex The drop visual index (unused).
+   * @param {boolean} movePossible Whether the move can be performed.
+   */ _onBeforeColumnMove = /*#__PURE__*/ new WeakMap(), /**
+   * Projects the visual column order a pending move will produce, expressed in the current visual
+   * indexes. Mirrors the move itself: remove the moved columns, then re-insert them at `finalIndex`.
+   *
+   * @param {number[]} movedColumns Visual indexes of the columns being moved.
+   * @param {number} finalIndex The visual index the moved columns will start at after the move.
+   * @returns {number[]} The current visual indexes in their post-move order.
+   */ _projectColumnOrderAfterMove = /*#__PURE__*/ new WeakSet(), /**
+   * Reports whether a group's columns stop being adjacent in the projected post-move order. The group
+   * is split when its members no longer occupy one contiguous run of positions.
+   *
+   * @param {number} columnIndex The group's leftmost visual column index.
+   * @param {number} origColspan The group's column span.
+   * @param {Map<number, number>} positionByColumn Maps a current visual index to its post-move position.
+   * @returns {boolean} `true` when the move would split the group.
+   */ _isGroupSplitByOrder = /*#__PURE__*/ new WeakSet(), /**
    * Adds the indicator to the headers.
    *
    * @param {number} column Column index.
@@ -211,16 +232,15 @@ class CollapsibleColumns extends _base.BasePlugin {
         this.addHook('afterLoadData', _class_private_field_get(this, _onAfterLoadData));
         this.addHook('afterGetColHeader', _class_private_field_get(this, _onAfterGetColHeader));
         this.addHook('beforeOnCellMouseDown', _class_private_field_get(this, _onBeforeOnCellMouseDown));
-        // NestedHeaders (priority 280) rebuilds the header tree on column insert/remove before this
+        // NestedHeaders (priority 280) rebuilds the header tree on column insert/remove/move before this
         // plugin (priority 290) runs, so refreshing here re-derives the `visibleWhen` hidden set against
-        // the freshly rebuilt tree (with `isCollapsed` already restored). There is intentionally no
-        // `afterColumnMove` refresh: a `manualColumnMove` does not rebuild the tree (its `columnIndex`
-        // values are structural), and the collapsed-columns map already strands its entries on a move the
-        // same way - so collapsed groups (legacy and `visibleWhen` alike) do not survive `manualColumnMove`.
-        // That is a pre-existing collapsible-columns limitation; refreshing only `visibleWhen` here would
-        // diverge from legacy collapse without fixing it.
+        // the freshly rebuilt tree (with `isCollapsed` re-attached by group identity). On a move a group
+        // that stayed contiguous keeps its collapse; a split group has its `isCollapsed` dropped, so the
+        // re-derived `visibleWhen` set excludes it and these columns are released.
         this.addHook('afterCreateCol', _class_private_field_get(this, _onAfterColumnStructureChange));
         this.addHook('afterRemoveCol', _class_private_field_get(this, _onAfterColumnStructureChange));
+        this.addHook('beforeColumnMove', _class_private_field_get(this, _onBeforeColumnMove));
+        this.addHook('afterColumnMove', _class_private_field_get(this, _onAfterColumnStructureChange));
         this.registerShortcuts();
         super.enablePlugin();
         // @TODO: Workaround for broken plugin initialization abstraction (#6806).
@@ -534,7 +554,7 @@ class CollapsibleColumns extends _base.BasePlugin {
         super.destroy();
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _checkIsActionPossible), _class_private_method_init(this, _adjustSelectionAfterHide), _class_private_method_init(this, _refreshVisibleWhenColumns), _class_private_field_init(this, _collapsedColumnsMap, {
+        super(...args), _class_private_method_init(this, _checkIsActionPossible), _class_private_method_init(this, _adjustSelectionAfterHide), _class_private_method_init(this, _refreshVisibleWhenColumns), _class_private_method_init(this, _projectColumnOrderAfterMove), _class_private_method_init(this, _isGroupSplitByOrder), _class_private_field_init(this, _collapsedColumnsMap, {
             writable: true,
             value: void 0
         }), _class_private_field_init(this, _visibleWhenMap, {
@@ -543,6 +563,9 @@ class CollapsibleColumns extends _base.BasePlugin {
         }), _class_private_field_init(this, _onAfterColumnStructureChange, {
             writable: true,
             value: void 0
+        }), _class_private_field_init(this, _onBeforeColumnMove, {
+            writable: true,
+            value: void 0
         }), _class_private_field_init(this, _onAfterGetColHeader, {
             writable: true,
             value: void 0
@@ -567,6 +590,29 @@ class CollapsibleColumns extends _base.BasePlugin {
    * @type {StateManager}
    */ this.headerStateManager = null, _class_private_field_set(this, _collapsedColumnsMap, null), _class_private_field_set(this, _visibleWhenMap, null), _class_private_field_set(this, _onAfterColumnStructureChange, ()=>{
             _class_private_method_get(this, _refreshVisibleWhenColumns, refreshVisibleWhenColumns).call(this);
+        }), _class_private_field_set(this, _onBeforeColumnMove, (movedColumns, finalIndex, dropIndex, movePossible)=>{
+            const stateManager = this.headerStateManager;
+            if (movePossible === false || !stateManager) {
+                return;
+            }
+            const projectedOrder = _class_private_method_get(this, _projectColumnOrderAfterMove, projectColumnOrderAfterMove).call(this, movedColumns, finalIndex);
+            const positionByColumn = new Map(projectedOrder.map((visualColumn, position)=>[
+                    visualColumn,
+                    position
+                ]));
+            stateManager.getCollapsedGroups().forEach(({ headerLevel, columnIndex, origColspan })=>{
+                if (_class_private_method_get(this, _isGroupSplitByOrder, isGroupSplitByOrder).call(this, columnIndex, origColspan, positionByColumn)) {
+                    const row = stateManager.levelToRowCoords(headerLevel);
+                    if (row !== null) {
+                        this.toggleCollapsibleSection([
+                            {
+                                row,
+                                col: columnIndex
+                            }
+                        ], 'expand');
+                    }
+                }
+            });
         }), _class_private_field_set(this, _onAfterGetColHeader, (column, TH, headerLevel)=>{
             const headerSettings = this.headerStateManager?.getHeaderSettings(headerLevel, column);
             const { collapsible, origColspan, isCollapsed } = headerSettings ?? {};
@@ -688,3 +734,31 @@ function refreshVisibleWhenColumns(visualColumnsToHide = this.headerStateManager
         });
     }, true);
 }
+function projectColumnOrderAfterMove(movedColumns, finalIndex) {
+    const movedColumnsSet = new Set(movedColumns);
+    const remaining = [];
+    for(let column = 0, columnsCount = this.hot.countCols(); column < columnsCount; column++){
+        if (!movedColumnsSet.has(column)) {
+            remaining.push(column);
+        }
+    }
+    return [
+        ...remaining.slice(0, finalIndex),
+        ...movedColumns,
+        ...remaining.slice(finalIndex)
+    ];
+}
+function isGroupSplitByOrder(columnIndex, origColspan, positionByColumn) {
+    let minPosition = Infinity;
+    let maxPosition = -Infinity;
+    let memberCount = 0;
+    for(let column = columnIndex; column < columnIndex + origColspan; column++){
+        const position = positionByColumn.get(column);
+        if (position !== undefined) {
+            minPosition = Math.min(minPosition, position);
+            maxPosition = Math.max(maxPosition, position);
+            memberCount += 1;
+        }
+    }
+    return memberCount > 0 && maxPosition - minPosition !== memberCount - 1;
+}