handsontable 18.0.0 → 18.1.0-rc7

package/plugins/autofill/autofill.mjs

@@ -70,9 +70,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 +119,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 +249,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 +619,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 +628,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 +673,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 +713,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/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

@@ -137,6 +137,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 +239,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 +561,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 +570,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 +597,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 +741,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;
+}

package/plugins/collapsibleColumns/collapsibleColumns.mjs

@@ -116,6 +116,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.
@@ -151,6 +179,10 @@ var /**
  * 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
@@ -289,16 +321,15 @@ var /**
         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).
@@ -612,7 +643,7 @@ var /**
         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, {
@@ -621,6 +652,9 @@ var /**
         }), _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
@@ -645,6 +679,29 @@ var /**
    * @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 ?? {};
@@ -766,3 +823,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;
+}

package/plugins/columnSorting/columnSorting.d.ts

@@ -1,5 +1,5 @@
 import { BasePlugin } from '../base';
-import { IndexesSequence, PhysicalIndexToValueMap as IndexToValueMap } from '../../translations';
+import type { IndexesSequence, PhysicalIndexToValueMap as IndexToValueMap } from '../../translations';
 import { ColumnStatesManager } from './columnStatesManager';
 export interface ColumnSortingConfig {
     column: number;
@@ -9,6 +9,20 @@ export declare const PLUGIN_KEY = "columnSorting";
 export declare const PLUGIN_PRIORITY = 50;
 export declare const APPEND_COLUMN_CONFIG_STRATEGY = "append";
 export declare const REPLACE_COLUMN_CONFIG_STRATEGY = "replace";
+/**
+ * A press on a sortable column header, waiting to be resolved on mouse up.
+ */
+export interface HeaderSortPress {
+    column: number;
+    isCtrlPressed: boolean;
+    /**
+     * Settles once the cell that was being edited at press time has finished validating, or `null`
+     * when nothing was being edited.
+     */
+    validation: Promise<void> | null;
+    /** Set when ManualColumnMove ran its move before this press was resolved. */
+    consumedByMove: boolean;
+}
 export interface SortConfig {
     column: number;
     sortOrder: string;
@@ -47,7 +61,7 @@ export interface SortConfig {
  * }
  *
  * // as an object passed to the `column` property, allows specifying a custom options for the desired column.
- * // please take a look at documentation of `column` property: https://handsontable.com/docs/Options.html#columns
+ * // see the `columns` option documentation: @/api/options.md#columns
  * columns: [{
  *   columnSorting: {
  *     indicator: false, // disable indicator for the first column,
@@ -308,6 +322,11 @@ export declare class ColumnSorting extends BasePlugin {
     /**
      * Callback for the `onAfterOnCellMouseDown` hook.
      *
+     * Queues the sort rather than running it. The header is also the surface ManualColumnMove
+     * drags a column by, so which action the user meant is only known once the button is
+     * released: a press that stays put is a click to sort, a press that travels is a drag.
+     * Selection changes stay here so the header still reacts the moment it is pressed.
+     *
      * @private
      * @param {Event} event Event which are provided by hook.
      * @param {CellCoords} coords Visual coords of the selected cell.
@@ -316,6 +335,16 @@ export declare class ColumnSorting extends BasePlugin {
         row: number;
         col: number;
     }): void;
+    /**
+     * Applies the sort queued by a header press.
+     *
+     * Kept separate from the press handler so `MultiColumnSorting` can choose a different sort
+     * configuration for the same gesture without repeating the click-versus-drag handling.
+     *
+     * @private
+     * @param {object} press The press that queued this sort.
+     */
+    applyHeaderClickSort(press: HeaderSortPress): void;
     /**
      * Destroys the plugin instance.
      */