handsontable 17.1.0 → 18.0.0-rc2

package/plugins/dragToScroll/dragToScroll.d.ts

@@ -1,22 +1,143 @@
-import Core from '../../core';
 import { BasePlugin } from '../base';
-
-interface DOMBoundaries {
-  left: number;
-  right: number;
-  top: number;
-  bottom: number;
+export declare const PLUGIN_KEY = "dragToScroll";
+export declare const PLUGIN_PRIORITY = 100;
+/**
+ * Represents viewport boundaries used for drag-to-scroll detection.
+ */
+interface Boundaries {
+    width?: number;
+    height?: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
 }
-
-export type Settings = boolean;
-
-export class DragToScroll extends BasePlugin {
-  constructor(hotInstance: Core);
-
-  boundaries: DOMRect | undefined;
-
-  isEnabled(): boolean;
-  setBoundaries(boundaries: DOMRect | DOMBoundaries): void;
-  setCallback(callback: () => void): void;
-  check(x: number, y: number): void;
+/**
+ * @description
+ * Plugin used to scroll Handsontable by selecting a cell and dragging outside of the visible viewport.
+ *
+ *
+ * @class DragToScroll
+ * @plugin DragToScroll
+ */
+export declare class DragToScroll extends BasePlugin {
+    #private;
+    /**
+     * Returns the plugin key used to identify this plugin in Handsontable settings.
+     */
+    static get PLUGIN_KEY(): string;
+    /**
+     * Returns the priority order used to determine the order in which plugins are initialized.
+     */
+    static get PLUGIN_PRIORITY(): number;
+    /**
+     * Returns the default settings applied when the plugin is enabled without explicit configuration.
+     */
+    static get DEFAULT_SETTINGS(): {
+        interval: {
+            min: number;
+            max: number;
+        };
+        rampDistance: number;
+    };
+    /**
+     * Size of an element and its position relative to the viewport,
+     * e.g. {bottom: 449, height: 441, left: 8, right: 814, top: 8, width: 806, x: 8, y:8}.
+     *
+     * @type {DOMRect}
+     */
+    boundaries: Boundaries | null;
+    /**
+     * Callback function.
+     *
+     * @private
+     * @type {Function}
+     */
+    callback: ((diffX: number, diffY: number) => void) | null;
+    /**
+     * Flag indicates mouseDown/mouseUp.
+     *
+     * @private
+     * @type {boolean}
+     */
+    listening: boolean;
+    /**
+     * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
+     * hook and if it returns `true` then the {@link DragToScroll#enablePlugin} method is called.
+     *
+     * @returns {boolean}
+     */
+    isEnabled(): boolean;
+    /**
+     * Enables the plugin functionality for this Handsontable instance.
+     */
+    enablePlugin(): void;
+    /**
+     * Updates the plugin's state.
+     *
+     * This method is executed when [`updateSettings()`](@/api/core.md#updatesettings) is invoked with any of the following configuration options:
+     *  - [`dragToScroll`](@/api/options.md#dragtoscroll)
+     */
+    updatePlugin(): void;
+    /**
+     * Disables the plugin functionality for this Handsontable instance.
+     */
+    disablePlugin(): void;
+    /**
+     * Sets the boundaries/dimensions of the scrollable viewport.
+     *
+     * @param {DOMRect|{left: number, right: number, top: number, bottom: number}} [boundaries] An object with
+     * coordinates. Contains the window boundaries by default. The object is compatible with DOMRect.
+     */
+    setBoundaries(boundaries?: Boundaries): void;
+    /**
+     * Changes callback function.
+     *
+     * @param {Function} callback The callback function.
+     */
+    setCallback(callback: (diffX: number, diffY: number) => void): void;
+    /**
+     * Checks if the mouse position (X, Y) is outside the viewport and fires a callback with calculated X an Y diffs
+     * between passed boundaries.
+     *
+     * @param {number} x Mouse X coordinate to check.
+     * @param {number} y Mouse Y coordinate to check.
+     */
+    check(x: number, y: number): void;
+    /**
+     * Enables listening on `mousemove` event.
+     *
+     * @private
+     */
+    listen(): void;
+    /**
+     * Disables listening on `mousemove` event.
+     *
+     * @private
+     */
+    unlisten(): void;
+    /**
+     * Returns current state of listening.
+     *
+     * @private
+     * @returns {boolean}
+     */
+    isListening(): boolean;
+    /**
+     * Registers dom listeners.
+     *
+     * @private
+     */
+    registerEvents(): void;
+    /**
+     * Unbinds the events used by the plugin.
+     *
+     * @private
+     */
+    unregisterEvents(): void;
+    /**
+     * Destroys the plugin instance.
+     */
+    destroy(): void;
 }
+export {};

package/plugins/dragToScroll/dragToScroll.js

@@ -22,11 +22,48 @@ _export(exports, {
 const _base = require("../base");
 const _event = require("../../helpers/dom/event");
 const _element = require("../../helpers/dom/element");
+const _cellCoords = require("../../helpers/dom/cellCoords");
+const _autoScroller = require("./autoScroller");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
     }
 }
+function _class_apply_descriptor_get(receiver, descriptor) {
+    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.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    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) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, 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");
@@ -40,18 +77,104 @@ function _class_private_method_init(obj, privateSet) {
 const PLUGIN_KEY = 'dragToScroll';
 const PLUGIN_PRIORITY = 100;
 var /**
+   * Auto scroller for managing independent horizontal and vertical scroll timers.
+   *
+   * @type {AutoScroller}
+   */ _autoScroller1 = /*#__PURE__*/ new WeakMap(), /**
+   * Flag indicates if the mouse is outside the viewport.
+   *
+   * @type {boolean}
+   */ _isOutsideViewport = /*#__PURE__*/ new WeakMap(), /**
+   * Kind of drag currently active: `'cell'` for a regular mouse-drag selection,
+   * `'corner'` for an autofill fill-handle drag, or `null` when no drag is active.
+   * Only `'cell'` drags extend the selection via `#onAfterScroll`.
+   *
+   * @type {('cell' | 'corner' | null)}
+   */ _activeDragKind = /*#__PURE__*/ new WeakMap(), /**
+   * Last observed mouse X coordinate (client space). Cached so that the viewport
+   * can recompute the edge cell on each `afterScroll` tick even when the mouse
+   * stays stationary outside the viewport.
+   *
+   * @type {number | null}
+   */ _lastClientX = /*#__PURE__*/ new WeakMap(), /**
+   * Last observed mouse Y coordinate (client space).
+   *
+   * @type {number | null}
+   */ _lastClientY = /*#__PURE__*/ new WeakMap(), /**
+   * Reference to the controller object from `beforeOnCellMouseDown`. The
+   * object is mutated in-place by all hook handlers, so by the time
+   * `#onAfterScroll` reads it the flags are fully set.
+   *
+   * @type {object | null}
+   */ _mouseDownController = /*#__PURE__*/ new WeakMap(), /**
    * On after on cell/cellCorner mouse down listener.
    *
+   * @param {('cell' | 'corner')} kind Which drag started — a regular cell selection drag
+   *   (`'cell'`) or an autofill fill-handle drag (`'corner'`).
    * @param {MouseEvent} event The mouse event object.
-   */ _setupListening = /*#__PURE__*/ new WeakSet();
+   * @param {object} [controller] The controller object from `beforeOnCellMouseDown`.
+   */ _setupListening = /*#__PURE__*/ new WeakSet(), /**
+   * Scrolls the viewport horizontally by one column. Stops the horizontal axis
+   * of the auto-scroller when `scrollViewportTo` reports that no scroll
+   * happened — meaning the viewport is already pegged against the first or
+   * last column.
+   *
+   * Under RTL, the screen-x → column-index mapping is visually inverted:
+   * a mouse past the screen-right edge wants to reveal LOWER column indexes
+   * (which are visually to the right of the current viewport), and past the
+   * screen-left edge wants HIGHER column indexes.
+   *
+   * @param {number} distance Horizontal distance from viewport edge (positive = right, negative = left).
+   */ _scrollHorizontal = /*#__PURE__*/ new WeakSet(), /**
+   * Scrolls the viewport vertically by one row. Stops the vertical axis of the
+   * auto-scroller when `scrollViewportTo` reports that no scroll happened.
+   *
+   * @param {number} distance Vertical distance from viewport edge (positive = down, negative = up).
+   */ _scrollVertical = /*#__PURE__*/ new WeakSet(), /**
+   * Prevents viewport scroll when the cursor is outside the viewport during
+   * an active drag-scroll. Limited to the active-drag window so that ordinary
+   * `selectCell` / mouse-click selections still scroll-into-view normally.
+   *
+   * @param {number} row Selection start visual row index.
+   * @param {number} column Selection start visual column index.
+   * @param {number} endRow Selection end visual row index.
+   * @param {number} endColumn Selection end visual column index.
+   * @param {object} preventScrolling A reference to the observable object with the `value` property.
+   *                                  Property `preventScrolling.value` expects a boolean value that
+   *                                  Handsontable uses to control scroll behavior after selection.
+   */ _onAfterSelection = /*#__PURE__*/ new WeakMap(), /**
+   * 'mouseMove' event callback.
+   *
+   * @private
+   * @param {MouseEvent} event `mousemove` event properties.
+   */ _onMouseMove = /*#__PURE__*/ new WeakSet(), /**
+   * Extends the regular drag-select selection to the cell at the clamped mouse position
+   * after each viewport auto-scroll tick. Autofill drags are skipped — the autofill plugin
+   * owns its own selection extension via its `afterScroll` hook.
+   */ _onAfterScroll = /*#__PURE__*/ new WeakMap();
 class DragToScroll extends _base.BasePlugin {
-    static get PLUGIN_KEY() {
+    /**
+   * Returns the plugin key used to identify this plugin in Handsontable settings.
+   */ static get PLUGIN_KEY() {
         return PLUGIN_KEY;
     }
-    static get PLUGIN_PRIORITY() {
+    /**
+   * Returns the priority order used to determine the order in which plugins are initialized.
+   */ static get PLUGIN_PRIORITY() {
         return PLUGIN_PRIORITY;
     }
     /**
+   * Returns the default settings applied when the plugin is enabled without explicit configuration.
+   */ static get DEFAULT_SETTINGS() {
+        return {
+            interval: {
+                min: 20,
+                max: 500
+            },
+            rampDistance: 120
+        };
+    }
+    /**
    * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
    * hook and if it returns `true` then the {@link DragToScroll#enablePlugin} method is called.
    *
@@ -65,8 +188,17 @@ class DragToScroll extends _base.BasePlugin {
         if (this.enabled) {
             return;
         }
-        this.addHook('afterOnCellMouseDown', (event)=>_class_private_method_get(this, _setupListening, setupListening).call(this, event));
-        this.addHook('afterOnCellCornerMouseDown', (event)=>_class_private_method_get(this, _setupListening, setupListening).call(this, event));
+        _class_private_field_get(this, _autoScroller1).configure({
+            intervalRange: this.getSetting('interval'),
+            rampDistance: this.getSetting('rampDistance')
+        });
+        this.addHook('beforeOnCellMouseDown', (event, _coords, _TD, controller)=>{
+            const typedController = typeof controller === 'object' && controller !== null ? controller : null;
+            _class_private_method_get(this, _setupListening, setupListening).call(this, 'cell', event, typedController);
+        });
+        this.addHook('afterOnCellCornerMouseDown', (event)=>_class_private_method_get(this, _setupListening, setupListening).call(this, 'corner', event));
+        this.addHook('afterSelection', _class_private_field_get(this, _onAfterSelection));
+        this.addHook('afterScroll', _class_private_field_get(this, _onAfterScroll));
         this.registerEvents();
         super.enablePlugin();
     }
@@ -83,6 +215,7 @@ class DragToScroll extends _base.BasePlugin {
     /**
    * Disables the plugin functionality for this Handsontable instance.
    */ disablePlugin() {
+        _class_private_field_get(this, _autoScroller1).stop();
         this.unregisterEvents();
         super.disablePlugin();
     }
@@ -115,21 +248,27 @@ class DragToScroll extends _base.BasePlugin {
    */ check(x, y) {
         let diffX = 0;
         let diffY = 0;
-        if (y < this.boundaries.top) {
-            // y is less than top
-            diffY = y - this.boundaries.top;
-        } else if (y > this.boundaries.bottom) {
-            // y is more than bottom
-            diffY = y - this.boundaries.bottom;
+        const { boundaries } = this;
+        if (boundaries) {
+            if (y < boundaries.top) {
+                // y is less than top
+                diffY = y - boundaries.top;
+            } else if (y > boundaries.bottom) {
+                // y is more than bottom
+                diffY = y - boundaries.bottom;
+            }
+            if (x < boundaries.left) {
+                // x is less than left
+                diffX = x - boundaries.left;
+            } else if (x > boundaries.right) {
+                // x is more than right
+                diffX = x - boundaries.right;
+            }
         }
-        if (x < this.boundaries.left) {
-            // x is less than left
-            diffX = x - this.boundaries.left;
-        } else if (x > this.boundaries.right) {
-            // x is more than right
-            diffX = x - this.boundaries.right;
+        _class_private_field_set(this, _isOutsideViewport, diffY !== 0 || diffX !== 0);
+        if (this.callback) {
+            this.callback(diffX, diffY);
         }
-        this.callback(diffX, diffY);
     }
     /**
    * Enables listening on `mousemove` event.
@@ -144,6 +283,12 @@ class DragToScroll extends _base.BasePlugin {
    * @private
    */ unlisten() {
         this.listening = false;
+        _class_private_field_set(this, _activeDragKind, null);
+        _class_private_field_set(this, _lastClientX, null);
+        _class_private_field_set(this, _lastClientY, null);
+        _class_private_field_set(this, _isOutsideViewport, false);
+        _class_private_field_set(this, _mouseDownController, null);
+        _class_private_field_get(this, _autoScroller1).stop();
     }
     /**
    * Returns current state of listening.
@@ -163,7 +308,9 @@ class DragToScroll extends _base.BasePlugin {
         while(frame){
             this.eventManager.addEventListener(frame.document, 'contextmenu', ()=>this.unlisten());
             this.eventManager.addEventListener(frame.document, 'mouseup', ()=>this.unlisten());
-            this.eventManager.addEventListener(frame.document, 'mousemove', (event)=>this.onMouseMove(event));
+            this.eventManager.addEventListener(frame.document, 'mousemove', (event)=>{
+                _class_private_method_get(this, _onMouseMove, onMouseMove).call(this, event);
+            });
             frame = (0, _element.getParentWindow)(frame);
         }
     }
@@ -175,23 +322,37 @@ class DragToScroll extends _base.BasePlugin {
         this.eventManager.clear();
     }
     /**
-   * 'mouseMove' event callback.
-   *
-   * @private
-   * @param {MouseEvent} event `mousemove` event properties.
-   */ onMouseMove(event) {
-        if (!this.isListening()) {
-            return;
-        }
-        this.check(event.clientX, event.clientY);
-    }
-    /**
    * Destroys the plugin instance.
    */ destroy() {
+        _class_private_field_get(this, _autoScroller1).destroy();
         super.destroy();
     }
     constructor(...args){
-        super(...args), _class_private_method_init(this, _setupListening), /**
+        super(...args), _class_private_method_init(this, _setupListening), _class_private_method_init(this, _scrollHorizontal), _class_private_method_init(this, _scrollVertical), _class_private_method_init(this, _onMouseMove), _class_private_field_init(this, _autoScroller1, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _isOutsideViewport, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _activeDragKind, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _lastClientX, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _lastClientY, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _mouseDownController, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterSelection, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _onAfterScroll, {
+            writable: true,
+            value: void 0
+        }), /**
    * Size of an element and its position relative to the viewport,
    * e.g. {bottom: 449, height: 441, left: 8, right: 814, top: 8, width: 806, x: 8, y:8}.
    *
@@ -206,19 +367,149 @@ class DragToScroll extends _base.BasePlugin {
    *
    * @private
    * @type {boolean}
-   */ this.listening = false;
+   */ this.listening = false, _class_private_field_set(this, _autoScroller1, new _autoScroller.AutoScroller((fn, delay)=>this.hot._registerTimeout(fn, delay)).addLocalHook('scrollHorizontal', (distance)=>_class_private_method_get(this, _scrollHorizontal, scrollHorizontal).call(this, distance)).addLocalHook('scrollVertical', (distance)=>_class_private_method_get(this, _scrollVertical, scrollVertical).call(this, distance))), _class_private_field_set(this, _isOutsideViewport, false), _class_private_field_set(this, _activeDragKind, null), _class_private_field_set(this, _lastClientX, null), _class_private_field_set(this, _lastClientY, null), _class_private_field_set(this, _mouseDownController, null), _class_private_field_set(this, _onAfterSelection, (row, column, endRow, endColumn, preventScrolling)=>{
+            if (this.listening && _class_private_field_get(this, _isOutsideViewport)) {
+                preventScrolling.value = true;
+            }
+        }), _class_private_field_set(this, _onAfterScroll, ()=>{
+            if (_class_private_field_get(this, _activeDragKind) !== 'cell') {
+                return;
+            }
+            if (!_class_private_field_get(this, _isOutsideViewport)) {
+                return;
+            }
+            if (_class_private_field_get(this, _lastClientX) === null || _class_private_field_get(this, _lastClientY) === null) {
+                return;
+            }
+            if (this.hot.getSettings().selectionMode === 'single') {
+                return;
+            }
+            // When another plugin claimed the drag via the controller (e.g. manualRowMove
+            // sets controller.row = true), skip selection extension. The controller object
+            // is captured by reference in #setupListening and mutated in-place by later
+            // handlers, so by now the flags reflect the final state.
+            if (_class_private_field_get(this, _mouseDownController)?.row || _class_private_field_get(this, _mouseDownController)?.column) {
+                return;
+            }
+            const { selection, view } = this.hot;
+            const edgeCell = (0, _cellCoords.getCellCoordsFromMousePosition)(this.hot, _class_private_field_get(this, _lastClientX), _class_private_field_get(this, _lastClientY));
+            if (!edgeCell) {
+                return;
+            }
+            let targetRow = edgeCell.row ?? 0;
+            let targetCol = edgeCell.col ?? 0;
+            // Clamp the target to the last fully visible row/column so that the
+            // selection border stays inside the viewport. Without this, the target
+            // could land on a partially visible row/column whose border is clipped
+            // by the viewport edge.
+            const firstFullyVisibleRow = view.getFirstFullyVisibleRow() ?? 0;
+            const lastFullyVisibleRow = view.getLastFullyVisibleRow() ?? 0;
+            const firstFullyVisibleColumn = view.getFirstFullyVisibleColumn() ?? 0;
+            const lastFullyVisibleColumn = view.getLastFullyVisibleColumn() ?? 0;
+            if (targetRow > lastFullyVisibleRow) {
+                targetRow = lastFullyVisibleRow;
+            } else if (targetRow < firstFullyVisibleRow) {
+                targetRow = firstFullyVisibleRow;
+            }
+            if (targetCol > lastFullyVisibleColumn) {
+                targetCol = lastFullyVisibleColumn;
+            } else if (targetCol < firstFullyVisibleColumn) {
+                targetCol = firstFullyVisibleColumn;
+            }
+            // Preserve "whole row" / "whole column" semantics for header-based selections.
+            // This mirrors the logic in mouseEventHandler.js mouseOver().
+            if (selection.isSelectedByRowHeader()) {
+                targetCol = this.hot.countCols() - 1;
+            }
+            if (selection.isSelectedByColumnHeader()) {
+                targetRow = this.hot.countRows() - 1;
+            }
+            const target = this.hot._createCellCoords(targetRow, targetCol);
+            const currentRange = this.hot.getSelectedRangeLast();
+            // Skip the setRangeEnd call when the edge cell matches the current
+            // selection end. Avoids a redundant `afterSelection` firing and re-render
+            // on each tick.
+            if (currentRange && currentRange.to.row === target.row && currentRange.to.col === target.col) {
+                return;
+            }
+            selection.setRangeEnd(target);
+        });
     }
 }
-function setupListening(event) {
+function setupListening(kind, event, controller = null) {
     if ((0, _event.isRightClick)(event)) {
         return;
     }
+    // Regular drag-select is a no-op when selectionMode is 'single'. Autofill
+    // drag is unaffected.
+    if (kind === 'cell' && this.hot.getSettings().selectionMode === 'single') {
+        return;
+    }
+    _class_private_field_set(this, _activeDragKind, kind);
+    _class_private_field_set(this, _mouseDownController, controller);
     const scrollHandler = this.hot.view._wt.wtOverlays.topOverlay.mainTableScrollableElement;
-    this.setBoundaries(scrollHandler !== this.hot.rootWindow ? scrollHandler.getBoundingClientRect() : undefined);
+    if (scrollHandler === this.hot.rootWindow) {
+        this.setBoundaries();
+    } else {
+        const boundaries = scrollHandler.getBoundingClientRect();
+        this.setBoundaries({
+            left: boundaries.left + this.hot.view.getRowHeaderWidth(),
+            right: boundaries.right,
+            top: boundaries.top + this.hot.view.getColumnHeaderHeight(),
+            bottom: boundaries.bottom
+        });
+    }
     this.setCallback((scrollX, scrollY)=>{
-        const horizontalScrollValue = scrollHandler.scrollLeft ?? scrollHandler.scrollX;
-        const verticalScrollValue = scrollHandler.scrollTop ?? scrollHandler.scrollY;
-        scrollHandler.scroll(horizontalScrollValue + Math.sign(scrollX) * 50, verticalScrollValue + Math.sign(scrollY) * 20);
+        const { selection } = this.hot;
+        // Suppress the irrelevant scroll axis for header-based selections:
+        // row header drags only need vertical scrolling, column header drags only horizontal.
+        const x = selection.isSelectedByRowHeader() ? 0 : scrollX;
+        const y = selection.isSelectedByColumnHeader() ? 0 : scrollY;
+        // Always call update — passing (0, 0) stops the timers when the mouse
+        // returns inside the viewport.
+        _class_private_field_get(this, _autoScroller1).update({
+            x,
+            y
+        });
     });
     this.listen();
 }
+function scrollHorizontal(distance) {
+    const shouldAdvance = this.hot.isRtl() ? distance < 0 : distance > 0;
+    // Advance (right in LTR / left in RTL): target the first column past the last fully visible one.
+    // Retreat (left in LTR / right in RTL): target the column before the first partially visible one.
+    // No explicit horizontalSnap — auto-snapping in scrollViewportHorizontally detects which side the
+    // target column is on and snaps accordingly: off-screen right → 'end' (right edge), off-screen
+    // left → 'start' (left edge). This keeps the selection stuck to whichever viewport edge the
+    // mouse pushed past, and works correctly for both LTR and RTL layouts.
+    const scrollColumn = shouldAdvance ? this.hot.getLastFullyVisibleColumn() + 1 : this.hot.getFirstPartiallyVisibleColumn() - 1;
+    // The no-op callback causes hot.scrollViewportTo to call view.render() after scrolling,
+    // which ensures afterScroll fires even in environments where programmatic window.scrollTo()
+    // does not emit a native `scroll` DOM event (e.g. headless Chrome without scroll-event support).
+    const isScrolled = this.hot.scrollViewportTo({
+        col: scrollColumn
+    }, ()=>{});
+    if (!isScrolled) {
+        _class_private_field_get(this, _autoScroller1).stopHorizontal();
+    }
+}
+function scrollVertical(distance) {
+    const firstVisibleRow = this.hot.getFirstFullyVisibleRow();
+    const lastVisibleRow = this.hot.getLastFullyVisibleRow();
+    const scrollRow = distance > 0 ? lastVisibleRow + 1 : firstVisibleRow - 1;
+    // See the comment in #scrollHorizontal for why a no-op callback is passed.
+    const isScrolled = this.hot.scrollViewportTo({
+        row: scrollRow
+    }, ()=>{});
+    if (!isScrolled) {
+        _class_private_field_get(this, _autoScroller1).stopVertical();
+    }
+}
+function onMouseMove(event) {
+    if (!this.isListening()) {
+        return;
+    }
+    _class_private_field_set(this, _lastClientX, event.clientX);
+    _class_private_field_set(this, _lastClientY, event.clientY);
+    this.check(event.clientX, event.clientY);
+}