handsontable 18.0.0 → 18.1.0-rc1

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");
@@ -25,15 +26,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");
         }
@@ -41,9 +39,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) {
@@ -60,9 +56,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) {
@@ -83,18 +77,12 @@ function _getRequireWildcardCache(nodeInterop) {
     })(nodeInterop);
 }
 function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return {
+        default: obj
+    };
     var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
+    if (cache && cache.has(obj)) return cache.get(obj);
     var newObj = {
         __proto__: null
     };
@@ -102,17 +90,12 @@ function _interop_require_wildcard(obj, nodeInterop) {
     for(var key in obj){
         if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
             var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
+            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+            else newObj[key] = obj[key];
         }
     }
     newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
+    if (cache) cache.set(obj, newObj);
     return newObj;
 }
 /**
@@ -164,6 +147,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 +163,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 +629,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 +738,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 +784,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 +866,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 +1001,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 +1053,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 +1196,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 +1233,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 +1266,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 +1282,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 +1350,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;