handsontable 18.0.0 → 18.1.0-rc7

package/selection/moveCells.d.ts

@@ -0,0 +1,15 @@
+interface CanMoveRangeOptions {
+    rangeCount: number;
+    isEntireRow: boolean;
+    isEntireColumn: boolean;
+    isHeader: boolean;
+}
+/**
+ * Tells whether the current selection is eligible for a `moveCells` drag: exactly one contiguous cell
+ * range that is not a full row, full column, or header selection.
+ *
+ * @param {CanMoveRangeOptions} options The selection shape flags.
+ * @returns {boolean}
+ */
+export declare function canMoveRange({ rangeCount, isEntireRow, isEntireColumn, isHeader }: CanMoveRangeOptions): boolean;
+export {};

package/selection/moveCells.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "canMoveRange", {
+    enumerable: true,
+    get: function() {
+        return canMoveRange;
+    }
+});
+function canMoveRange({ rangeCount, isEntireRow, isEntireColumn, isHeader }) {
+    return rangeCount === 1 && !isEntireRow && !isEntireColumn && !isHeader;
+}

package/selection/moveCells.mjs

@@ -0,0 +1,9 @@
+/**
+ * Tells whether the current selection is eligible for a `moveCells` drag: exactly one contiguous cell
+ * range that is not a full row, full column, or header selection.
+ *
+ * @param {CanMoveRangeOptions} options The selection shape flags.
+ * @returns {boolean}
+ */ export function canMoveRange({ rangeCount, isEntireRow, isEntireColumn, isHeader }) {
+    return rangeCount === 1 && !isEntireRow && !isEntireColumn && !isHeader;
+}

package/selection/selection.d.ts

@@ -241,6 +241,23 @@ declare class Selection {
      * @returns {boolean}
      */
     isMultiple(cellRange?: CellRange | undefined): unknown;
+    /**
+     * Tells whether the `moveCells` move zone should show on the area (multi-cell) selection border:
+     * the selection is movable (see {@link Selection##isSelectionMovable}) and spans more than one cell.
+     *
+     * @private
+     * @returns {boolean}
+     */
+    isRangeMovable(): boolean;
+    /**
+     * Tells whether the `moveCells` move zone should show on the focus (single-cell) selection border:
+     * the selection is movable (see {@link Selection##isSelectionMovable}) and there is exactly one
+     * selected cell.
+     *
+     * @private
+     * @returns {boolean}
+     */
+    isSingleCellMovable(): boolean;
     /**
      * Checks if the last selection involves changing the focus cell position only.
      *
@@ -301,6 +318,14 @@ declare class Selection {
      * @returns {boolean}
      */
     inInSelection(coords: CellCoords): boolean;
+    /**
+     * Returns the visual layer index of the selected range containing the given coords, or `null`.
+     * When multiple ranges overlap the coord, the topmost layer (highest index) wins.
+     *
+     * @param {CellCoords} coords The visual cell coordinates to test.
+     * @returns {number | null} The highest-index (topmost) layer that contains `coords`, or `null` if none do.
+     */
+    getLayerContaining(coords: CellCoords): number | null;
     /**
      * Returns `true` if the cell corner should be visible.
      *
@@ -323,6 +348,32 @@ declare class Selection {
      * @returns {boolean} `true` if the corner element has to be visible, `false` otherwise.
      */
     isAreaCornerVisible(layerLevel: number): unknown;
+    /**
+     * Tells whether the adjustment handles should render for the given highlight layer.
+     *
+     * @private
+     * @param {number} layerLevel The area highlight layer level.
+     * @returns {boolean}
+     */
+    isAdjustHandlesVisibleFor(layerLevel: number): boolean;
+    /**
+     * Returns the selection layer currently showing adjustment handles, or `null`.
+     * This is an internal method used by the SelectionHandles plugin's hover and drag wiring, and is
+     * not part of the public API.
+     *
+     * @private
+     * @returns {number | null}
+     */
+    getHandlesHoveredLayer(): number | null;
+    /**
+     * Sets which selection layer currently shows adjustment handles and refreshes the borders.
+     * This is an internal method called by the SelectionHandles plugin's hover wiring, and is not part
+     * of the public API.
+     *
+     * @private
+     * @param {number | null} layer The hovered layer level, or `null` to hide all handles.
+     */
+    setHandlesHoveredLayer(layer: number | null): void;
     /**
      * Clear the selection by resetting the collected ranges and highlights.
      */
@@ -342,9 +393,12 @@ declare class Selection {
      * @param {{row: number, col: number} | boolean} [options.focusPosition] The argument allows changing the cell/header
      * focus position. The value takes an object with a `row` and `col` properties from -N to N, where
      * negative values point to the headers and positive values point to the cell range. If `false`, the focus
-     * position won't be changed.
+     * position won't be changed. When the {@link Options#navigableHeaders} option is disabled (the default), a
+     * `focusPosition` that points to a header is relocated to the nearest cell in the data set.
      * @param {boolean} [options.disableHeadersHighlight] If `true`, disables highlighting the headers even when
-     * the logical coordinates points on them.
+     * the logical coordinates points on them. This only suppresses the highlight shown on headers of a fully-selected
+     * row or column. It doesn't affect the focus indicator on the individual cell or header that holds the focus,
+     * which stays visible even when {@link Options#navigableHeaders} moves the focus onto a header.
      */
     selectAll(includeRowHeaders?: boolean, includeColumnHeaders?: boolean, options?: {
         focusPosition?: SelectionFocusPosition | boolean;

package/selection/selection.js

@@ -14,6 +14,7 @@ const _object = require("./../helpers/object");
 const _mixed = require("./../helpers/mixed");
 const _number = require("./../helpers/number");
 const _localHooks = /*#__PURE__*/ _interop_require_default(require("./../mixins/localHooks"));
+const _moveCells = require("./moveCells");
 const _transformation = require("./transformation");
 const _utils = require("./utils");
 const _templateLiteralTag = require("./../helpers/templateLiteralTag");
@@ -164,6 +165,10 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    *
    * @type {number}
    */ _activeSelectionLayer = /*#__PURE__*/ new WeakMap(), /**
+   * Visual layer index of the range currently hovered while `selectionHandles` is on, or `null`.
+   *
+   * @type {number | null}
+   */ _handlesHoveredLayer = /*#__PURE__*/ new WeakMap(), /**
    * Applies header-type highlights for the given cell range.
    *
    * @param {CellRange} cellRange The cell range to highlight.
@@ -176,7 +181,20 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * @param {object | null | undefined} activeCornerHeaderHighlight The active corner header highlight instance.
    * @param {object | null | undefined} rowHighlight The row highlight instance.
    * @param {object | null | undefined} columnHighlight The column highlight instance.
-   */ _applyHeaderHighlights = /*#__PURE__*/ new WeakSet();
+   */ _applyHeaderHighlights = /*#__PURE__*/ new WeakSet(), /**
+   * Tells whether the current selection is eligible for a `moveCells` drag at all: the feature is
+   * on (the setting is enabled AND the plugin has not been disabled at runtime), no editor is open,
+   * visual selection is not disabled, and the selection shape passes {@link canMoveRange}
+   * (exactly one contiguous range that is not a full row, full column, or header selection).
+   * Mirrors the eligibility gate applied when a move drag starts, so the move zone and grab
+   * cursor never show for a selection that a drag would reject. The editor check matches
+   * {@link Selection#isCellCornerVisible} — starting a drag mid-edit would swallow the mousedown
+   * that normally commits the editor, so the release could rewrite a cell whose editor still holds
+   * an uncommitted value.
+   *
+   * @private
+   * @returns {boolean}
+   */ _isSelectionMovable = /*#__PURE__*/ new WeakSet();
 /**
  * @typedef {object} SelectionState
  * @property {CellRange[]} ranges The array of all ranges.
@@ -629,6 +647,27 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return isMultipleListener.value;
     }
     /**
+   * Tells whether the `moveCells` move zone should show on the area (multi-cell) selection border:
+   * the selection is movable (see {@link Selection##isSelectionMovable}) and spans more than one cell.
+   *
+   * @private
+   * @returns {boolean}
+   */ isRangeMovable() {
+        const range = this.getActiveSelectedRange();
+        return _class_private_method_get(this, _isSelectionMovable, isSelectionMovable).call(this) && !!range && !range.isSingle();
+    }
+    /**
+   * Tells whether the `moveCells` move zone should show on the focus (single-cell) selection border:
+   * the selection is movable (see {@link Selection##isSelectionMovable}) and there is exactly one
+   * selected cell.
+   *
+   * @private
+   * @returns {boolean}
+   */ isSingleCellMovable() {
+        const range = this.getActiveSelectedRange();
+        return _class_private_method_get(this, _isSelectionMovable, isSelectionMovable).call(this) && !!range && range.isSingle();
+    }
+    /**
    * Checks if the last selection involves changing the focus cell position only.
    *
    * @returns {boolean}
@@ -717,6 +756,23 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return this.selectedRange.includes(coords);
     }
     /**
+   * Returns the visual layer index of the selected range containing the given coords, or `null`.
+   * When multiple ranges overlap the coord, the topmost layer (highest index) wins.
+   *
+   * @param {CellCoords} coords The visual cell coordinates to test.
+   * @returns {number | null} The highest-index (topmost) layer that contains `coords`, or `null` if none do.
+   */ getLayerContaining(coords) {
+        if (this.selectedRange.isEmpty()) {
+            return null;
+        }
+        for(let layer = this.selectedRange.size() - 1; layer >= 0; layer--){
+            if (this.selectedRange.peekByIndex(layer)?.includes(coords)) {
+                return layer;
+            }
+        }
+        return null;
+    }
+    /**
    * Returns `true` if the cell corner should be visible.
    *
    * @private
@@ -746,6 +802,61 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return this.settings.fillHandle && !this.tableProps.isEditorOpened() && this.isMultiple();
     }
     /**
+   * Tells whether the adjustment handles should render for the given highlight layer.
+   *
+   * @private
+   * @param {number} layerLevel The area highlight layer level.
+   * @returns {boolean}
+   */ isAdjustHandlesVisibleFor(layerLevel) {
+        // The editor check matches `isCellCornerVisible`/`isAreaCornerVisible`: the handles must not
+        // render (nor start a drag) while a cell editor holds an uncommitted value. The plugin check
+        // keeps a runtime `disablePlugin()` effective even though the setting still reads `true`.
+        if (this.settings.selectionHandles !== true || this.tableProps.isEditorOpened() || !this.tableProps.isPluginEnabled('selectionHandles')) {
+            return false;
+        }
+        if (this.settings.selectionMode === 'single') {
+            return false;
+        }
+        if (_class_private_field_get(this, _handlesHoveredLayer) !== layerLevel) {
+            return false;
+        }
+        // Hide handles for full-row, full-column, and select-all selections
+        // because those cannot be meaningfully resized via edge handles.
+        // A select-all range spans all columns (isEntireRowSelected) AND all rows
+        // (isEntireColumnSelected), so it is already covered by those two checks —
+        // no separate isSelectedByCorner() call is needed here, and adding one would
+        // incorrectly suppress handles on valid non-top layers in multiple-selection
+        // mode (isSelectedByCorner() always inspects the topmost layer via getLayerLevel()).
+        if (this.isEntireRowSelected(layerLevel) || this.isEntireColumnSelected(layerLevel)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Returns the selection layer currently showing adjustment handles, or `null`.
+   * This is an internal method used by the SelectionHandles plugin's hover and drag wiring, and is
+   * not part of the public API.
+   *
+   * @private
+   * @returns {number | null}
+   */ getHandlesHoveredLayer() {
+        return _class_private_field_get(this, _handlesHoveredLayer);
+    }
+    /**
+   * Sets which selection layer currently shows adjustment handles and refreshes the borders.
+   * This is an internal method called by the SelectionHandles plugin's hover wiring, and is not part
+   * of the public API.
+   *
+   * @private
+   * @param {number | null} layer The hovered layer level, or `null` to hide all handles.
+   */ setHandlesHoveredLayer(layer) {
+        if (_class_private_field_get(this, _handlesHoveredLayer) === layer) {
+            return;
+        }
+        _class_private_field_set(this, _handlesHoveredLayer, layer);
+        this.refresh();
+    }
+    /**
    * Clear the selection by resetting the collected ranges and highlights.
    */ clear() {
         // TODO: collections selectedByColumnHeader and selectedByRowHeader should be clear too.
@@ -773,9 +884,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * @param {{row: number, col: number} | boolean} [options.focusPosition] The argument allows changing the cell/header
    * focus position. The value takes an object with a `row` and `col` properties from -N to N, where
    * negative values point to the headers and positive values point to the cell range. If `false`, the focus
-   * position won't be changed.
+   * position won't be changed. When the {@link Options#navigableHeaders} option is disabled (the default), a
+   * `focusPosition` that points to a header is relocated to the nearest cell in the data set.
    * @param {boolean} [options.disableHeadersHighlight] If `true`, disables highlighting the headers even when
-   * the logical coordinates points on them.
+   * the logical coordinates points on them. This only suppresses the highlight shown on headers of a fully-selected
+   * row or column. It doesn't affect the focus indicator on the individual cell or header that holds the focus,
+   * which stays visible even when {@link Options#navigableHeaders} moves the focus onto a header.
    */ selectAll(includeRowHeaders = false, includeColumnHeaders = false, options = {
         focusPosition: false,
         disableHeadersHighlight: false
@@ -905,7 +1019,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             this.selectedByColumnHeader.add(this.getLayerLevel());
             this.setRangeEnd(to);
             this.runLocalHooks('afterSelectColumns', from, to, highlight);
-            this.finish();
+            // For mouse-driven selection the process is finished by the document-level `mouseup`/`touchend`
+            // handler once the user releases the button. Finishing here as well would fire `afterSelectionEnd`
+            // prematurely on the initial `mousedown`, causing it to run twice for a header drag (#7133).
+            if (this.getSelectionSource() !== 'mouse') {
+                this.finish();
+            }
         }
         return isValid;
     }
@@ -952,7 +1071,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             this.selectedByRowHeader.add(this.getLayerLevel());
             this.setRangeEnd(to);
             this.runLocalHooks('afterSelectRows', from, to, highlight);
-            this.finish();
+            // For mouse-driven selection the process is finished by the document-level `mouseup`/`touchend`
+            // handler once the user releases the button. Finishing here as well would fire `afterSelectionEnd`
+            // prematurely on the initial `mousedown`, causing it to run twice for a header drag (#7133).
+            if (this.getSelectionSource() !== 'mouse') {
+                this.finish();
+            }
         }
         return isValid;
     }
@@ -1090,6 +1214,7 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * Initializes the Selection manager with grid settings and table API references, and sets up transformation modules and highlight layers.
    */ constructor(settings, tableProps){
         _class_private_method_init(this, _applyHeaderHighlights);
+        _class_private_method_init(this, _isSelectionMovable);
         /**
    * The module for modifying coordinates of the start and end selection.
    *
@@ -1126,6 +1251,10 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _handlesHoveredLayer, {
+            writable: true,
+            value: void 0
+        });
         /**
    * The flag which determines if the selection is in progress.
    *
@@ -1155,6 +1284,7 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         _class_private_field_set(this, _selectionSource, 'unknown');
         _class_private_field_set(this, _expectedLayersCount, -1);
         _class_private_field_set(this, _activeSelectionLayer, 0);
+        _class_private_field_set(this, _handlesHoveredLayer, null);
         this.settings = settings;
         this.tableProps = tableProps;
         this.highlight = new _highlight.default({
@@ -1170,6 +1300,9 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             disabledCellSelection: (row, column)=>this.tableProps.isDisabledCellSelection(row, column),
             cellCornerVisible: ()=>this.isCellCornerVisible(),
             areaCornerVisible: (layerLevel)=>this.isAreaCornerVisible(layerLevel),
+            adjustHandlesVisible: (layerLevel)=>this.isAdjustHandlesVisibleFor(layerLevel),
+            moveEnabled: ()=>this.isRangeMovable(),
+            cellMoveEnabled: ()=>this.isSingleCellMovable(),
             visualToRenderableCoords: (coords)=>this.tableProps.visualToRenderableCoords(coords),
             renderableToVisualCoords: (coords)=>this.tableProps.renderableToVisualCoords(coords),
             createCellCoords: (row, column)=>this.tableProps.createCellCoords(row, column),
@@ -1235,5 +1368,16 @@ function applyHeaderHighlights(cellRange, countRows, countCols, rowHeaderHighlig
         activeCornerHeaderHighlight?.add(this.tableProps.createCellCoords(-this.tableProps.countColHeaders(), -this.tableProps.countRowHeaders())).add(this.tableProps.createCellCoords(-1, -1)).commit();
     }
 }
+function isSelectionMovable() {
+    if (this.settings.moveCells !== true || this.settings.disableVisualSelection || this.tableProps.isEditorOpened() || !this.tableProps.isPluginEnabled('moveCells')) {
+        return false;
+    }
+    return (0, _moveCells.canMoveRange)({
+        rangeCount: this.getSelectedRange().size(),
+        isEntireRow: this.isEntireRowSelected(),
+        isEntireColumn: this.isEntireColumnSelected(),
+        isHeader: this.isSelectedByRowHeader() || this.isSelectedByColumnHeader()
+    });
+}
 (0, _object.mixin)(Selection, _localHooks.default);
 const _default = Selection;

package/selection/selection.mjs

@@ -54,6 +54,7 @@ import { createObjectPropListener, mixin } from './../helpers/object.mjs';
 import { isUndefined } from './../helpers/mixed.mjs';
 import { clamp } from './../helpers/number.mjs';
 import localHooks from './../mixins/localHooks.mjs';
+import { canMoveRange } from './moveCells.mjs';
 import { ExtenderTransformation, FocusTransformation } from './transformation/index.mjs';
 import { detectSelectionType, normalizeSelectionFactory, SELECTION_TYPE_EMPTY, SELECTION_TYPE_UNRECOGNIZED } from './utils.mjs';
 import { toSingleLine } from './../helpers/templateLiteralTag.mjs';
@@ -108,6 +109,10 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    *
    * @type {number}
    */ _activeSelectionLayer = /*#__PURE__*/ new WeakMap(), /**
+   * Visual layer index of the range currently hovered while `selectionHandles` is on, or `null`.
+   *
+   * @type {number | null}
+   */ _handlesHoveredLayer = /*#__PURE__*/ new WeakMap(), /**
    * Applies header-type highlights for the given cell range.
    *
    * @param {CellRange} cellRange The cell range to highlight.
@@ -120,7 +125,20 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * @param {object | null | undefined} activeCornerHeaderHighlight The active corner header highlight instance.
    * @param {object | null | undefined} rowHighlight The row highlight instance.
    * @param {object | null | undefined} columnHighlight The column highlight instance.
-   */ _applyHeaderHighlights = /*#__PURE__*/ new WeakSet();
+   */ _applyHeaderHighlights = /*#__PURE__*/ new WeakSet(), /**
+   * Tells whether the current selection is eligible for a `moveCells` drag at all: the feature is
+   * on (the setting is enabled AND the plugin has not been disabled at runtime), no editor is open,
+   * visual selection is not disabled, and the selection shape passes {@link canMoveRange}
+   * (exactly one contiguous range that is not a full row, full column, or header selection).
+   * Mirrors the eligibility gate applied when a move drag starts, so the move zone and grab
+   * cursor never show for a selection that a drag would reject. The editor check matches
+   * {@link Selection#isCellCornerVisible} — starting a drag mid-edit would swallow the mousedown
+   * that normally commits the editor, so the release could rewrite a cell whose editor still holds
+   * an uncommitted value.
+   *
+   * @private
+   * @returns {boolean}
+   */ _isSelectionMovable = /*#__PURE__*/ new WeakSet();
 /**
  * @typedef {object} SelectionState
  * @property {CellRange[]} ranges The array of all ranges.
@@ -573,6 +591,27 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return isMultipleListener.value;
     }
     /**
+   * Tells whether the `moveCells` move zone should show on the area (multi-cell) selection border:
+   * the selection is movable (see {@link Selection##isSelectionMovable}) and spans more than one cell.
+   *
+   * @private
+   * @returns {boolean}
+   */ isRangeMovable() {
+        const range = this.getActiveSelectedRange();
+        return _class_private_method_get(this, _isSelectionMovable, isSelectionMovable).call(this) && !!range && !range.isSingle();
+    }
+    /**
+   * Tells whether the `moveCells` move zone should show on the focus (single-cell) selection border:
+   * the selection is movable (see {@link Selection##isSelectionMovable}) and there is exactly one
+   * selected cell.
+   *
+   * @private
+   * @returns {boolean}
+   */ isSingleCellMovable() {
+        const range = this.getActiveSelectedRange();
+        return _class_private_method_get(this, _isSelectionMovable, isSelectionMovable).call(this) && !!range && range.isSingle();
+    }
+    /**
    * Checks if the last selection involves changing the focus cell position only.
    *
    * @returns {boolean}
@@ -661,6 +700,23 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return this.selectedRange.includes(coords);
     }
     /**
+   * Returns the visual layer index of the selected range containing the given coords, or `null`.
+   * When multiple ranges overlap the coord, the topmost layer (highest index) wins.
+   *
+   * @param {CellCoords} coords The visual cell coordinates to test.
+   * @returns {number | null} The highest-index (topmost) layer that contains `coords`, or `null` if none do.
+   */ getLayerContaining(coords) {
+        if (this.selectedRange.isEmpty()) {
+            return null;
+        }
+        for(let layer = this.selectedRange.size() - 1; layer >= 0; layer--){
+            if (this.selectedRange.peekByIndex(layer)?.includes(coords)) {
+                return layer;
+            }
+        }
+        return null;
+    }
+    /**
    * Returns `true` if the cell corner should be visible.
    *
    * @private
@@ -690,6 +746,61 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         return this.settings.fillHandle && !this.tableProps.isEditorOpened() && this.isMultiple();
     }
     /**
+   * Tells whether the adjustment handles should render for the given highlight layer.
+   *
+   * @private
+   * @param {number} layerLevel The area highlight layer level.
+   * @returns {boolean}
+   */ isAdjustHandlesVisibleFor(layerLevel) {
+        // The editor check matches `isCellCornerVisible`/`isAreaCornerVisible`: the handles must not
+        // render (nor start a drag) while a cell editor holds an uncommitted value. The plugin check
+        // keeps a runtime `disablePlugin()` effective even though the setting still reads `true`.
+        if (this.settings.selectionHandles !== true || this.tableProps.isEditorOpened() || !this.tableProps.isPluginEnabled('selectionHandles')) {
+            return false;
+        }
+        if (this.settings.selectionMode === 'single') {
+            return false;
+        }
+        if (_class_private_field_get(this, _handlesHoveredLayer) !== layerLevel) {
+            return false;
+        }
+        // Hide handles for full-row, full-column, and select-all selections
+        // because those cannot be meaningfully resized via edge handles.
+        // A select-all range spans all columns (isEntireRowSelected) AND all rows
+        // (isEntireColumnSelected), so it is already covered by those two checks —
+        // no separate isSelectedByCorner() call is needed here, and adding one would
+        // incorrectly suppress handles on valid non-top layers in multiple-selection
+        // mode (isSelectedByCorner() always inspects the topmost layer via getLayerLevel()).
+        if (this.isEntireRowSelected(layerLevel) || this.isEntireColumnSelected(layerLevel)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Returns the selection layer currently showing adjustment handles, or `null`.
+   * This is an internal method used by the SelectionHandles plugin's hover and drag wiring, and is
+   * not part of the public API.
+   *
+   * @private
+   * @returns {number | null}
+   */ getHandlesHoveredLayer() {
+        return _class_private_field_get(this, _handlesHoveredLayer);
+    }
+    /**
+   * Sets which selection layer currently shows adjustment handles and refreshes the borders.
+   * This is an internal method called by the SelectionHandles plugin's hover wiring, and is not part
+   * of the public API.
+   *
+   * @private
+   * @param {number | null} layer The hovered layer level, or `null` to hide all handles.
+   */ setHandlesHoveredLayer(layer) {
+        if (_class_private_field_get(this, _handlesHoveredLayer) === layer) {
+            return;
+        }
+        _class_private_field_set(this, _handlesHoveredLayer, layer);
+        this.refresh();
+    }
+    /**
    * Clear the selection by resetting the collected ranges and highlights.
    */ clear() {
         // TODO: collections selectedByColumnHeader and selectedByRowHeader should be clear too.
@@ -717,9 +828,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * @param {{row: number, col: number} | boolean} [options.focusPosition] The argument allows changing the cell/header
    * focus position. The value takes an object with a `row` and `col` properties from -N to N, where
    * negative values point to the headers and positive values point to the cell range. If `false`, the focus
-   * position won't be changed.
+   * position won't be changed. When the {@link Options#navigableHeaders} option is disabled (the default), a
+   * `focusPosition` that points to a header is relocated to the nearest cell in the data set.
    * @param {boolean} [options.disableHeadersHighlight] If `true`, disables highlighting the headers even when
-   * the logical coordinates points on them.
+   * the logical coordinates points on them. This only suppresses the highlight shown on headers of a fully-selected
+   * row or column. It doesn't affect the focus indicator on the individual cell or header that holds the focus,
+   * which stays visible even when {@link Options#navigableHeaders} moves the focus onto a header.
    */ selectAll(includeRowHeaders = false, includeColumnHeaders = false, options = {
         focusPosition: false,
         disableHeadersHighlight: false
@@ -849,7 +963,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             this.selectedByColumnHeader.add(this.getLayerLevel());
             this.setRangeEnd(to);
             this.runLocalHooks('afterSelectColumns', from, to, highlight);
-            this.finish();
+            // For mouse-driven selection the process is finished by the document-level `mouseup`/`touchend`
+            // handler once the user releases the button. Finishing here as well would fire `afterSelectionEnd`
+            // prematurely on the initial `mousedown`, causing it to run twice for a header drag (#7133).
+            if (this.getSelectionSource() !== 'mouse') {
+                this.finish();
+            }
         }
         return isValid;
     }
@@ -896,7 +1015,12 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             this.selectedByRowHeader.add(this.getLayerLevel());
             this.setRangeEnd(to);
             this.runLocalHooks('afterSelectRows', from, to, highlight);
-            this.finish();
+            // For mouse-driven selection the process is finished by the document-level `mouseup`/`touchend`
+            // handler once the user releases the button. Finishing here as well would fire `afterSelectionEnd`
+            // prematurely on the initial `mousedown`, causing it to run twice for a header drag (#7133).
+            if (this.getSelectionSource() !== 'mouse') {
+                this.finish();
+            }
         }
         return isValid;
     }
@@ -1034,6 +1158,7 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
    * Initializes the Selection manager with grid settings and table API references, and sets up transformation modules and highlight layers.
    */ constructor(settings, tableProps){
         _class_private_method_init(this, _applyHeaderHighlights);
+        _class_private_method_init(this, _isSelectionMovable);
         /**
    * The module for modifying coordinates of the start and end selection.
    *
@@ -1070,6 +1195,10 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _handlesHoveredLayer, {
+            writable: true,
+            value: void 0
+        });
         /**
    * The flag which determines if the selection is in progress.
    *
@@ -1099,6 +1228,7 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
         _class_private_field_set(this, _selectionSource, 'unknown');
         _class_private_field_set(this, _expectedLayersCount, -1);
         _class_private_field_set(this, _activeSelectionLayer, 0);
+        _class_private_field_set(this, _handlesHoveredLayer, null);
         this.settings = settings;
         this.tableProps = tableProps;
         this.highlight = new Highlight({
@@ -1114,6 +1244,9 @@ var _extenderTransformation = /*#__PURE__*/ new WeakMap(), _focusTransformation
             disabledCellSelection: (row, column)=>this.tableProps.isDisabledCellSelection(row, column),
             cellCornerVisible: ()=>this.isCellCornerVisible(),
             areaCornerVisible: (layerLevel)=>this.isAreaCornerVisible(layerLevel),
+            adjustHandlesVisible: (layerLevel)=>this.isAdjustHandlesVisibleFor(layerLevel),
+            moveEnabled: ()=>this.isRangeMovable(),
+            cellMoveEnabled: ()=>this.isSingleCellMovable(),
             visualToRenderableCoords: (coords)=>this.tableProps.visualToRenderableCoords(coords),
             renderableToVisualCoords: (coords)=>this.tableProps.renderableToVisualCoords(coords),
             createCellCoords: (row, column)=>this.tableProps.createCellCoords(row, column),
@@ -1179,5 +1312,16 @@ function applyHeaderHighlights(cellRange, countRows, countCols, rowHeaderHighlig
         activeCornerHeaderHighlight?.add(this.tableProps.createCellCoords(-this.tableProps.countColHeaders(), -this.tableProps.countRowHeaders())).add(this.tableProps.createCellCoords(-1, -1)).commit();
     }
 }
+function isSelectionMovable() {
+    if (this.settings.moveCells !== true || this.settings.disableVisualSelection || this.tableProps.isEditorOpened() || !this.tableProps.isPluginEnabled('moveCells')) {
+        return false;
+    }
+    return canMoveRange({
+        rangeCount: this.getSelectedRange().size(),
+        isEntireRow: this.isEntireRowSelected(),
+        isEntireColumn: this.isEntireColumnSelected(),
+        isHeader: this.isSelectedByRowHeader() || this.isSelectedByColumnHeader()
+    });
+}
 mixin(Selection, localHooks);
 export default Selection;

package/selection/types.d.ts

@@ -23,6 +23,7 @@ export interface SelectionTableProps {
     columnIndexMapper: IndexMapper;
     propToCol(prop: string | number): number;
     isEditorOpened(): boolean;
+    isPluginEnabled(pluginName: string): boolean;
     isDisabledCellSelection(row: number, column: number): boolean;
     visualToRenderableCoords(coords: CellCoords): {
         row: number | null;
@@ -57,6 +58,8 @@ export interface SelectionSettings {
     selectionMode?: 'single' | 'range' | 'multiple';
     disableVisualSelection?: boolean | string | string[];
     fillHandle?: unknown;
+    selectionHandles?: boolean;
+    moveCells?: boolean;
     [key: string]: unknown;
 }
 /**