handsontable 17.1.0 → 18.0.0-rc2

package/3rdparty/walkontable/src/event.mjs

@@ -48,14 +48,34 @@ function _class_private_method_init(obj, privateSet) {
     _check_private_redeclaration(obj, privateSet);
     privateSet.add(obj);
 }
-import { closestDown, hasClass, isChildOf, getParent } from '../../../helpers/dom/element.mjs';
-import { partial } from '../../../helpers/function.mjs';
+import { closestDown, eventTargetEl, hasClass, isChildOf, getParent } from '../../../helpers/dom/element.mjs';
+import { clamp } from '../../../helpers/number.mjs';
+import { findColumnAtX, findRowAtY } from './utils/cellCoords.mjs';
 import { isTouchSupported } from '../../../helpers/feature.mjs';
 import { isMobileBrowser, isChromeWebKit, isFirefoxWebKit, isIOS } from '../../../helpers/browser.mjs';
-import { isDefined } from '../../../helpers/mixed.mjs';
 const LONG_PRESS_DELAY = 500;
 const LONG_PRESS_MOVE_THRESHOLD = 10;
-var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new WeakMap(), _wtTable = /*#__PURE__*/ new WeakMap(), _selectionManager = /*#__PURE__*/ new WeakMap(), _parent = /*#__PURE__*/ new WeakMap(), /**
+var /**
+   * Walkontable settings instance.
+   *
+   * @type {Settings}
+   */ _wtSettings = /*#__PURE__*/ new WeakMap(), /**
+   * DOM bindings for walkontable elements.
+   *
+   * @type {DomBindings}
+   */ _domBindings = /*#__PURE__*/ new WeakMap(), /**
+   * Reference to the walkontable table.
+   *
+   * @type {Table}
+   */ _wtTable = /*#__PURE__*/ new WeakMap(), /**
+   * Selection manager instance.
+   *
+   * @type {SelectionManager}
+   */ _selectionManager = /*#__PURE__*/ new WeakMap(), /**
+   * Parent Event instance, or null for the root instance.
+   *
+   * @type {Event | null}
+   */ _parent = /*#__PURE__*/ new WeakMap(), /**
    * Instance of {@link EventManager}.
    *
    * @type {EventManager}
@@ -79,10 +99,41 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    *
    * @type {number|null}
    */ _longPressTimeout = /*#__PURE__*/ new WeakMap(), /**
-   * Starting coordinates of a touch gesture (used to detect movement that cancels long-press).
+   * Marks that the long-press contextmenu gesture has been triggered for the current touch.
+   *
+   * @type {boolean}
+   */ _longPressFired = /*#__PURE__*/ new WeakMap(), /**
+   * Starting coordinates of a touch gesture (used to detect movement that cancels long-press
+   * and to distinguish a tap from a scroll).
    *
    * @type {{ x: number, y: number }|null}
    */ _touchStartCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Marks that the current touch gesture has moved beyond the threshold and should be treated
+   * as a scroll rather than a tap.
+   *
+   * @type {boolean}
+   */ _touchWasMoved = /*#__PURE__*/ new WeakMap(), /**
+   * The original `touchstart` event captured so the synthesized mousedown can be deferred to
+   * `touchend` and only fired when the gesture is a tap (not a scroll).
+   *
+   * @type {TouchEvent|null}
+   */ _deferredTouchStartEvent = /*#__PURE__*/ new WeakMap(), /**
+   * @type {boolean}
+   */ _mouseDown = /*#__PURE__*/ new WeakMap(), /**
+   * The last renderable coords seen in `onMouseMove` while the mouse was outside the viewport.
+   * Used to skip the `onCellMouseOverOutside` listener call (and therefore `setRangeEnd`) when
+   * repeated mousemove events land on the same edge cell.
+   *
+   * @type {{ row: number, col: number } | null}
+   */ _mouseOverOutsideLastCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Returns the cell coordinates for the given mouse position and whether the mouse is
+   * outside the visible viewport. When the mouse is outside, the nearest edge cell is returned.
+   *
+   * @private
+   * @param {number} mouseX Client X coordinate of the mouse.
+   * @param {number} mouseY Client Y coordinate of the mouse.
+   * @returns {{ coords: CellCoords, isOutside: boolean }}
+   */ _getCellCoordsFromMousePosition = /*#__PURE__*/ new WeakSet(), /**
    * Starts the long-press timer. When the timer fires, a synthetic `contextmenu` event is
    * dispatched on the original touch target so that the existing contextmenu hook chain
    * (and ContextMenu plugin) work without changes.
@@ -93,12 +144,7 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    * Cancels the pending long-press timer.
    *
    * @private
-   */ _cancelLongPressTimer = /*#__PURE__*/ new WeakSet(), /**
-   * OnTouchMove callback. Cancels the long-press timer if the finger moves beyond the threshold.
-   *
-   * @private
-   * @param {TouchEvent} event The touch event object.
-   */ _onTouchMove = /*#__PURE__*/ new WeakSet();
+   */ _cancelLongPressTimer = /*#__PURE__*/ new WeakSet();
 /**
  * @class Event
  */ class Event {
@@ -110,27 +156,18 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
         _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'contextmenu', (event)=>this.onContextMenu(event));
         _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).TABLE, 'mouseover', (event)=>this.onMouseOver(event));
         _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).TABLE, 'mouseout', (event)=>this.onMouseOut(event));
+        if (_class_private_field_get(this, _wtTable).isMaster) {
+            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _domBindings).rootDocument, 'mousemove', (event)=>this.onMouseMove(event));
+            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _domBindings).rootDocument, 'mouseup', ()=>{
+                _class_private_field_set(this, _mouseDown, false);
+                _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
+            });
+        }
         const initTouchEvents = ()=>{
             _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'touchstart', (event)=>this.onTouchStart(event));
             _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'touchend', (event)=>this.onTouchEnd(event));
-            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'touchmove', (event)=>_class_private_method_get(this, _onTouchMove, onTouchMove).call(this, event));
-            if (!this.momentumScrolling) {
-                this.momentumScrolling = {};
-            }
-            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'scroll', ()=>{
-                _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
-                clearTimeout(this.momentumScrolling._timeout);
-                if (!this.momentumScrolling.ongoing) {
-                    _class_private_field_get(this, _wtSettings).getSetting('onBeforeTouchScroll');
-                }
-                this.momentumScrolling.ongoing = true;
-                this.momentumScrolling._timeout = setTimeout(()=>{
-                    if (!this.touchApplied) {
-                        this.momentumScrolling.ongoing = false;
-                        _class_private_field_get(this, _wtSettings).getSetting('onAfterMomentumScroll');
-                    }
-                }, 200);
-            });
+            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'touchmove', (event)=>this.onTouchMove(event));
+            _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'scroll', ()=>this.onHolderScroll());
         };
         const initMouseEvents = ()=>{
             _class_private_field_get(this, _eventManager).addEventListener(_class_private_field_get(this, _wtTable).holder, 'mouseup', (event)=>this.onMouseUp(event));
@@ -175,21 +212,29 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    * @param {Element} elem An element from the traversing starts.
    * @returns {object} Contains coordinates and reference to TD or TH if it exists. Otherwise it's empty object.
    */ parentCell(elem) {
-        const cell = {};
+        const cell = {
+            coords: null,
+            TD: null
+        };
         const TABLE = _class_private_field_get(this, _wtTable).TABLE;
         const TD = closestDown(elem, [
             'TD',
             'TH'
         ], TABLE);
+        const elemEl = elem;
         if (TD) {
             cell.coords = _class_private_field_get(this, _wtTable).getCoords(TD);
             cell.TD = TD;
-        } else if (hasClass(elem, 'wtBorder') && hasClass(elem, 'current')) {
-            cell.coords = _class_private_field_get(this, _selectionManager).getFocusSelection().cellRange.highlight;
-            cell.TD = _class_private_field_get(this, _wtTable).getCell(cell.coords);
-        } else if (hasClass(elem, 'wtBorder') && hasClass(elem, 'area')) {
-            if (_class_private_field_get(this, _selectionManager).getAreaSelection().cellRange) {
-                cell.coords = _class_private_field_get(this, _selectionManager).getAreaSelection().cellRange.to;
+        } else if (hasClass(elemEl, 'wtBorder') && hasClass(elemEl, 'current')) {
+            const focusCellRange = _class_private_field_get(this, _selectionManager).getFocusSelection()?.cellRange;
+            if (focusCellRange) {
+                cell.coords = focusCellRange.highlight;
+                cell.TD = _class_private_field_get(this, _wtTable).getCell(cell.coords);
+            }
+        } else if (hasClass(elemEl, 'wtBorder') && hasClass(elemEl, 'area')) {
+            const areaCellRange = _class_private_field_get(this, _selectionManager).getAreaSelection()?.cellRange;
+            if (areaCellRange) {
+                cell.coords = areaCellRange.to;
                 cell.TD = _class_private_field_get(this, _wtTable).getCell(cell.coords);
             }
         }
@@ -202,11 +247,12 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    * @param {MouseEvent} event The mouse event object.
    */ onMouseDown(event) {
         const activeElement = _class_private_field_get(this, _domBindings).rootDocument.activeElement;
-        const getParentNode = partial(getParent, event.target);
-        const realTarget = event.target;
+        const targetEl = eventTargetEl(event);
+        const getParentNode = (level)=>getParent(targetEl, level);
+        const realTarget = eventTargetEl(event);
         // ignore non-TD focusable elements from mouse down processing
         // (https://github.com/handsontable/handsontable/issues/3555)
-        if (![
+        if (activeElement && ![
             'TD',
             'TH'
         ].includes(activeElement.nodeName) && (realTarget === activeElement || getParentNode(0) === activeElement || getParentNode(1) === activeElement)) {
@@ -215,13 +261,19 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
         const cell = this.parentCell(realTarget);
         if (hasClass(realTarget, 'corner')) {
             _class_private_field_get(this, _wtSettings).getSetting('onCellCornerMouseDown', event, realTarget);
-        } else if (cell.TD && _class_private_field_get(this, _wtSettings).has('onCellMouseDown')) {
-            this.callListener('onCellMouseDown', event, cell.coords, cell.TD);
+        } else if (cell.TD) {
+            _class_private_field_set(this, _mouseDown, true);
+            _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
+            if (_class_private_field_get(this, _wtSettings).has('onCellMouseDown')) {
+                this.callListener('onCellMouseDown', event, cell.coords, cell.TD);
+            }
         }
         // doubleclick reacts only for left mouse button or from touch events
         if ((event.button === 0 || this.touchApplied) && cell.TD) {
             _class_private_field_get(this, _dblClickOrigin)[0] = cell.TD;
-            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
+            if (_class_private_field_get(this, _dblClickTimeout)[0] !== null) {
+                clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
+            }
             _class_private_field_get(this, _dblClickTimeout)[0] = setTimeout(()=>{
                 _class_private_field_get(this, _dblClickOrigin)[0] = null;
             }, 1000);
@@ -235,7 +287,7 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    */ onContextMenu(event) {
         _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
         if (_class_private_field_get(this, _wtSettings).has('onCellContextMenu')) {
-            const cell = this.parentCell(event.target);
+            const cell = this.parentCell(eventTargetEl(event));
             if (cell.TD) {
                 this.callListener('onCellContextMenu', event, cell.coords, cell.TD);
             }
@@ -251,14 +303,45 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
             return;
         }
         const table = _class_private_field_get(this, _wtTable).TABLE;
-        const td = closestDown(event.target, [
+        const td = closestDown(eventTargetEl(event), [
             'TD',
             'TH'
         ], table);
         const parent = _class_private_field_get(this, _parent) || this;
         if (td && td !== parent.lastMouseOver && isChildOf(td, table)) {
             parent.lastMouseOver = td;
-            this.callListener('onCellMouseOver', event, _class_private_field_get(this, _wtTable).getCoords(td), td);
+            const tdCoords = _class_private_field_get(this, _wtTable).getCoords(td);
+            if (tdCoords) {
+                this.callListener('onCellMouseOver', event, tdCoords, td);
+            }
+        }
+    }
+    /**
+   * OnMouseMove callback.
+   *
+   * @private
+   * @param {MouseEvent} event The mouse event object.
+   */ onMouseMove(event) {
+        if (!_class_private_field_get(this, _mouseDown)) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const { coords, isOutside } = _class_private_method_get(this, _getCellCoordsFromMousePosition, getCellCoordsFromMousePosition).call(this, event.clientX, event.clientY);
+        if (isOutside) {
+            const lastCoords = _class_private_field_get(this, _mouseOverOutsideLastCoords);
+            if (!lastCoords || lastCoords.row !== coords.row || lastCoords.col !== coords.col) {
+                const TD = _class_private_field_get(this, _wtTable).getCell(coords);
+                if (TD instanceof HTMLElement) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    _class_private_field_set(this, _mouseOverOutsideLastCoords, {
+                        row: coords.row,
+                        col: coords.col
+                    });
+                    this.callListener('onCellMouseOverOutside', event, coords, TD);
+                }
+            }
+        } else {
+            _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
         }
     }
     /**
@@ -271,7 +354,7 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
             return;
         }
         const table = _class_private_field_get(this, _wtTable).TABLE;
-        const lastTD = closestDown(event.target, [
+        const lastTD = closestDown(eventTargetEl(event), [
             'TD',
             'TH'
         ], table);
@@ -281,7 +364,10 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
         ], table);
         const parent = _class_private_field_get(this, _parent) || this;
         if (lastTD && lastTD !== nextTD && isChildOf(lastTD, table)) {
-            this.callListener('onCellMouseOut', event, _class_private_field_get(this, _wtTable).getCoords(lastTD), lastTD);
+            const lastTDCoords = _class_private_field_get(this, _wtTable).getCoords(lastTD);
+            if (lastTDCoords) {
+                this.callListener('onCellMouseOut', event, lastTDCoords, lastTD);
+            }
             if (nextTD === null) {
                 parent.lastMouseOver = null;
             }
@@ -293,7 +379,9 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    * @private
    * @param {MouseEvent} event The mouse event object.
    */ onMouseUp(event) {
-        const cell = this.parentCell(event.target);
+        _class_private_field_set(this, _mouseDown, false);
+        _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
+        const cell = this.parentCell(eventTargetEl(event));
         if (cell.TD && _class_private_field_get(this, _wtSettings).has('onCellMouseUp')) {
             this.callListener('onCellMouseUp', event, cell.coords, cell.TD);
         }
@@ -301,43 +389,58 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
         if (event.button !== 0 && !this.touchApplied) {
             return;
         }
-        if (cell.TD === _class_private_field_get(this, _dblClickOrigin)[0] && cell.TD === _class_private_field_get(this, _dblClickOrigin)[1]) {
-            if (hasClass(event.target, 'corner')) {
+        if (cell.TD && cell.TD === _class_private_field_get(this, _dblClickOrigin)[0] && cell.TD === _class_private_field_get(this, _dblClickOrigin)[1]) {
+            if (hasClass(eventTargetEl(event), 'corner')) {
                 this.callListener('onCellCornerDblClick', event, cell.coords, cell.TD);
             } else {
                 this.callListener('onCellDblClick', event, cell.coords, cell.TD);
             }
             _class_private_field_get(this, _dblClickOrigin)[0] = null;
             _class_private_field_get(this, _dblClickOrigin)[1] = null;
-        } else if (cell.TD === _class_private_field_get(this, _dblClickOrigin)[0]) {
+        } else if (cell.TD && cell.TD === _class_private_field_get(this, _dblClickOrigin)[0]) {
             _class_private_field_get(this, _dblClickOrigin)[1] = cell.TD;
-            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+            if (_class_private_field_get(this, _dblClickTimeout)[1] !== null) {
+                clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+            }
             _class_private_field_get(this, _dblClickTimeout)[1] = setTimeout(()=>{
                 _class_private_field_get(this, _dblClickOrigin)[1] = null;
             }, 500);
         }
     }
     /**
-   * OnTouchStart callback. Simulates mousedown event.
+   * OnTouchStart callback. Captures the gesture start so the synthesized mousedown can be
+   * deferred to `touchend`; this lets a touch-drag gesture scroll the grid without
+   * re-triggering the cell selection (see issue #11659).
    *
    * @private
    * @param {TouchEvent} event The touch event object.
    */ onTouchStart(event) {
-        _class_private_field_set(this, _selectedCellBeforeTouchEnd, _class_private_field_get(this, _selectionManager).getFocusSelection().cellRange);
+        _class_private_field_set(this, _selectedCellBeforeTouchEnd, _class_private_field_get(this, _selectionManager).getFocusSelection()?.cellRange ?? null);
         this.touchApplied = true;
-        this.onMouseDown(event);
+        _class_private_field_set(this, _touchWasMoved, false);
+        _class_private_field_set(this, _longPressFired, false);
+        _class_private_field_set(this, _deferredTouchStartEvent, event);
         _class_private_method_get(this, _startLongPressTimer, startLongPressTimer).call(this, event);
     }
     /**
-   * OnTouchEnd callback. Simulates mouseup event.
+   * OnTouchEnd callback. Fires the deferred mousedown only when the gesture is a tap
+   * (no movement past the threshold and no long-press); for a scroll gesture the
+   * selection stays untouched (see issue #11659).
    *
    * @private
    * @param {TouchEvent} event The touch event object.
    */ onTouchEnd(event) {
+        const wasScrolled = _class_private_field_get(this, _touchWasMoved);
+        const isTap = !wasScrolled && !_class_private_field_get(this, _longPressFired) && _class_private_field_get(this, _deferredTouchStartEvent) !== null;
+        const deferredTouchStartEvent = _class_private_field_get(this, _deferredTouchStartEvent);
         _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
-        const target = event.target;
+        _class_private_field_set(this, _deferredTouchStartEvent, null);
+        if (isTap && deferredTouchStartEvent !== null) {
+            this.onMouseDown(deferredTouchStartEvent);
+        }
+        const target = eventTargetEl(event);
         const parentCellCoords = this.parentCell(target)?.coords;
-        const isCellsRange = isDefined(parentCellCoords) && parentCellCoords.row >= 0 && parentCellCoords.col >= 0;
+        const isCellsRange = parentCellCoords !== null && parentCellCoords !== undefined && (parentCellCoords.row ?? -1) >= 0 && (parentCellCoords.col ?? -1) >= 0;
         const isEventCancelable = event.cancelable && isCellsRange && _class_private_field_get(this, _wtSettings).getSetting('isDataViewInstance');
         // To prevent accidental redirects or other actions that the interactive elements (e.q "A" link) do
         // while the cell is highlighted, all touch events that are triggered on different cells are
@@ -356,14 +459,77 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
             // matches the allow-list, the event is not prevented.
             if (isIOS() && (isChromeWebKit() || isFirefoxWebKit()) && this.selectedCellWasTouched(target) && !interactiveElements.includes(target.tagName)) {
                 event.preventDefault();
-            } else if (!this.selectedCellWasTouched(target)) {
+            } else if (!this.selectedCellWasTouched(target) && !(target.tagName === 'INPUT' && target.type === 'checkbox')) {
                 // For other browsers, prevent default is fired only for the first tap and only when the previous
-                // highlighted cell was different.
+                // highlighted cell was different. Checkbox inputs are excluded so that checkboxes with
+                // disableVisualSelection can still be toggled via touch (the focus cellRange is never populated
+                // when visual selection is disabled, so selectedCellWasTouched always returns false for them).
                 event.preventDefault();
             }
         }
-        this.onMouseUp(event);
+        // Fire mouseUp whenever the gesture also produced a mouseDown - either a tap
+        // (deferred mousedown above) or a long-press (mousedown fired from the timer
+        // callback). Skipping it for a long-press that ended in a scroll would leave
+        // an unpaired mousedown and break plugins listening to onCellMouseUp /
+        // before/after hooks (e.g. nestedHeaders, ContextMenu close logic).
+        // Suppress only for pure scroll gestures, where onMouseDown was never fired.
+        if (!wasScrolled || _class_private_field_get(this, _longPressFired)) {
+            this.onMouseUp(event);
+        }
         this.touchApplied = false;
+        _class_private_field_set(this, _touchWasMoved, false);
+        _class_private_field_set(this, _longPressFired, false);
+    }
+    /**
+   * Holder `scroll` callback. Cancels the long-press timer and runs the momentum-scroll
+   * bookkeeping. When called during an active touch sequence it also marks the gesture
+   * as a scroll so the deferred mousedown is not fired on `touchend` - native scrolling
+   * can start at ~8px, before the 10px LONG_PRESS_MOVE_THRESHOLD that `onTouchMove`
+   * watches (issue #11659).
+   *
+   * @private
+   */ onHolderScroll() {
+        if (!this.momentumScrolling) {
+            this.momentumScrolling = {};
+        }
+        if (this.touchApplied) {
+            _class_private_field_set(this, _touchWasMoved, true);
+        }
+        _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
+        clearTimeout(this.momentumScrolling._timeout);
+        if (!this.momentumScrolling.ongoing) {
+            _class_private_field_get(this, _wtSettings).getSetting('onBeforeTouchScroll');
+        }
+        this.momentumScrolling.ongoing = true;
+        this.momentumScrolling._timeout = setTimeout(()=>{
+            if (!this.touchApplied) {
+                this.momentumScrolling.ongoing = false;
+                _class_private_field_get(this, _wtSettings).getSetting('onAfterMomentumScroll');
+            }
+        }, 200);
+    }
+    /**
+   * OnTouchMove callback. Once the finger moves beyond the threshold, marks the gesture as a
+   * scroll so `touchend` skips firing the deferred mousedown, and cancels the long-press timer.
+   *
+   * @private
+   * @param {TouchEvent} event The touch event object.
+   */ onTouchMove(event) {
+        if (_class_private_field_get(this, _touchStartCoords) === null) {
+            return;
+        }
+        const touch = event.touches[0];
+        if (!touch) {
+            _class_private_field_set(this, _touchWasMoved, true);
+            _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
+            return;
+        }
+        const dx = Math.abs(touch.clientX - _class_private_field_get(this, _touchStartCoords).x);
+        const dy = Math.abs(touch.clientY - _class_private_field_get(this, _touchStartCoords).y);
+        if (dx > LONG_PRESS_MOVE_THRESHOLD || dy > LONG_PRESS_MOVE_THRESHOLD) {
+            _class_private_field_set(this, _touchWasMoved, true);
+            _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
+        }
     }
     /**
    * Call listener with backward compatibility.
@@ -382,9 +548,16 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
     /**
    * Clears double-click timeouts and destroys the internal eventManager instance.
    */ destroy() {
-        clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
-        clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+        if (_class_private_field_get(this, _dblClickTimeout)[0] !== null) {
+            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
+        }
+        if (_class_private_field_get(this, _dblClickTimeout)[1] !== null) {
+            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+        }
         _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
+        if (this.momentumScrolling) {
+            clearTimeout(this.momentumScrolling._timeout);
+        }
         _class_private_field_get(this, _eventManager).destroy();
     }
     /**
@@ -396,9 +569,9 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
    * @param {SelectionManager} selectionManager Selections.
    * @param {Event} [parent=null] The main Event instance.
    */ constructor(facadeGetter, domBindings, wtSettings, eventManager, wtTable, selectionManager, parent = null){
+        _class_private_method_init(this, _getCellCoordsFromMousePosition);
         _class_private_method_init(this, _startLongPressTimer);
         _class_private_method_init(this, _cancelLongPressTimer);
-        _class_private_method_init(this, _onTouchMove);
         _class_private_field_init(this, _wtSettings, {
             writable: true,
             value: void 0
@@ -443,10 +616,31 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _longPressFired, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_init(this, _touchStartCoords, {
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _touchWasMoved, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _deferredTouchStartEvent, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _mouseDown, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _mouseOverOutsideLastCoords, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _selectedCellBeforeTouchEnd, null);
         _class_private_field_set(this, _dblClickTimeout, [
             null,
             null
@@ -456,7 +650,12 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
             null
         ]);
         _class_private_field_set(this, _longPressTimeout, null);
+        _class_private_field_set(this, _longPressFired, false);
         _class_private_field_set(this, _touchStartCoords, null);
+        _class_private_field_set(this, _touchWasMoved, false);
+        _class_private_field_set(this, _deferredTouchStartEvent, null);
+        _class_private_field_set(this, _mouseDown, false);
+        _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
         _class_private_field_set(this, _wtSettings, wtSettings);
         _class_private_field_set(this, _domBindings, domBindings);
         _class_private_field_set(this, _wtTable, wtTable);
@@ -467,6 +666,128 @@ var _wtSettings = /*#__PURE__*/ new WeakMap(), _domBindings = /*#__PURE__*/ new
         this.registerEvents();
     }
 }
+function getCellCoordsFromMousePosition(mouseX, mouseY) {
+    const isRtl = _class_private_field_get(this, _wtSettings).getSetting('rtlMode');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const wot = _class_private_field_get(this, _facadeGetter).call(this);
+    const numberOfFixedColumnsStart = _class_private_field_get(this, _wtSettings).getSetting('fixedColumnsStart');
+    const numberOfFixedRowsTop = _class_private_field_get(this, _wtSettings).getSetting('fixedRowsTop');
+    const numberOfFixedRowsBottom = _class_private_field_get(this, _wtSettings).getSetting('fixedRowsBottom');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleRow = wot.wtScroll.getFirstPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleRow = wot.wtScroll.getLastPartiallyVisibleRow();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const firstPartiallyVisibleColumn = wot.wtScroll.getFirstPartiallyVisibleColumn();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const lastPartiallyVisibleColumn = wot.wtScroll.getLastPartiallyVisibleColumn();
+    const tableOffset = _class_private_field_get(this, _wtTable).wtRootElement.getBoundingClientRect();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const columnHeaderHeight = _class_private_field_get(this, _wtSettings).getSetting('columnHeaders').length > 0 ? wot.wtViewport.getColumnHeaderHeight() : 0;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const rowHeaderWidth = _class_private_field_get(this, _wtSettings).getSetting('rowHeaders').length > 0 ? wot.wtViewport.getRowHeaderWidth() : 0;
+    const { rootWindow } = _class_private_field_get(this, _domBindings);
+    // When the window is the scroll container and tableOffset.left/top > 0 (e.g. RTL
+    // at max-left scroll where tableOffset.left can exceed innerWidth), using it as the
+    // clamp minimum causes clamp(min > max) to always return min, mapping every mouse
+    // position to the wrong edge column. Math.min(0, tableOffset) corrects this while
+    // preserving the original boundary when the table is partially off-screen to the
+    // left/top (tableOffset < 0), which is the normal scrolled-past-origin case.
+    const tableViewportLeft = wot.wtViewport.isHorizontallyScrollableByWindow() ? Math.min(0, tableOffset.left) : tableOffset.left;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportTop = wot.wtViewport.isVerticallyScrollableByWindow() ? Math.min(0, tableOffset.top) : tableOffset.top;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportRight = wot.wtViewport.isHorizontallyScrollableByWindow() ? rootWindow.innerWidth : tableOffset.left + wot.wtViewport.getViewportWidth() + rowHeaderWidth;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const tableViewportBottom = wot.wtViewport.isVerticallyScrollableByWindow() ? rootWindow.innerHeight : tableOffset.top + wot.wtViewport.getViewportHeight() + columnHeaderHeight;
+    const clampedX = clamp(mouseX, tableViewportLeft, tableViewportRight);
+    const clampedY = clamp(mouseY, tableViewportTop, tableViewportBottom);
+    let foundColumn = null;
+    if (numberOfFixedColumnsStart > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: 0
+        }, true);
+        if (fixedCell instanceof HTMLElement) {
+            const fixedCellRect = fixedCell.getBoundingClientRect();
+            const fixedRelativeX = isRtl ? fixedCellRect.right - clampedX : clampedX - fixedCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, 0, numberOfFixedColumnsStart - 1, fixedRelativeX);
+        }
+    }
+    if (foundColumn === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (scrollCell instanceof HTMLElement) {
+            const scrollCellRect = scrollCell.getBoundingClientRect();
+            const scrollRelativeX = isRtl ? scrollCellRect.right - clampedX : clampedX - scrollCellRect.left;
+            foundColumn = findColumnAtX(wot, firstPartiallyVisibleRow, firstPartiallyVisibleColumn, lastPartiallyVisibleColumn, scrollRelativeX);
+            if (foundColumn === null) {
+                foundColumn = scrollRelativeX < 0 ? firstPartiallyVisibleColumn : lastPartiallyVisibleColumn;
+            }
+        } else {
+            foundColumn = firstPartiallyVisibleColumn;
+        }
+    }
+    let foundRow = null;
+    if (numberOfFixedRowsTop > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedCell = wot.getCell({
+            row: 0,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (fixedCell instanceof HTMLElement) {
+            const fixedCellRect = fixedCell.getBoundingClientRect();
+            const fixedRelativeY = clampedY - fixedCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, 0, numberOfFixedRowsTop - 1, fixedRelativeY);
+        }
+    }
+    if (foundRow === null && numberOfFixedRowsBottom > 0) {
+        const totalRows = _class_private_field_get(this, _wtSettings).getSetting('totalRows');
+        const bottomStartRow = totalRows - numberOfFixedRowsBottom;
+        const bottomEndRow = totalRows - 1;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const fixedBottomCell = wot.getCell({
+            row: bottomStartRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (fixedBottomCell instanceof HTMLElement) {
+            const fixedBottomCellRect = fixedBottomCell.getBoundingClientRect();
+            const fixedBottomRelativeY = clampedY - fixedBottomCellRect.top;
+            if (fixedBottomRelativeY >= 0) {
+                foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, bottomStartRow, bottomEndRow, fixedBottomRelativeY);
+                if (foundRow === null) {
+                    foundRow = bottomEndRow;
+                }
+            }
+        }
+    }
+    if (foundRow === null) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const scrollCell = wot.getCell({
+            row: firstPartiallyVisibleRow,
+            col: firstPartiallyVisibleColumn
+        }, true);
+        if (scrollCell instanceof HTMLElement) {
+            const scrollCellRect = scrollCell.getBoundingClientRect();
+            const scrollRelativeY = clampedY - scrollCellRect.top;
+            foundRow = findRowAtY(wot, firstPartiallyVisibleColumn, firstPartiallyVisibleRow, lastPartiallyVisibleRow, scrollRelativeY);
+            if (foundRow === null) {
+                foundRow = lastPartiallyVisibleRow;
+            }
+        } else {
+            foundRow = firstPartiallyVisibleRow;
+        }
+    }
+    return {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        coords: wot.createCellCoords(foundRow, foundColumn),
+        isOutside: mouseX < tableViewportLeft || mouseX > tableViewportRight || mouseY < tableViewportTop || mouseY > tableViewportBottom
+    };
+}
 function startLongPressTimer(event) {
     _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
     const touch = event.touches[0];
@@ -479,12 +800,24 @@ function startLongPressTimer(event) {
     });
     _class_private_field_set(this, _longPressTimeout, setTimeout(()=>{
         _class_private_field_set(this, _longPressTimeout, null);
+        _class_private_field_set(this, _longPressFired, true);
         _class_private_field_set(this, _touchStartCoords, null);
+        // Select the long-pressed cell so context-menu commands (e.g. "Insert row above")
+        // operate on it. With the deferred-mousedown flow, touchend skips onMouseDown
+        // when #longPressFired is true, so we fire it here before opening the menu.
+        this.onMouseDown(event);
         _class_private_field_get(this, _dblClickOrigin)[0] = null;
         _class_private_field_get(this, _dblClickOrigin)[1] = null;
-        clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
-        clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+        if (_class_private_field_get(this, _dblClickTimeout)[0] !== null) {
+            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
+        }
+        if (_class_private_field_get(this, _dblClickTimeout)[1] !== null) {
+            clearTimeout(_class_private_field_get(this, _dblClickTimeout)[1]);
+        }
         const target = event.target;
+        if (!target) {
+            return;
+        }
         const contextMenuEvent = new MouseEvent('contextmenu', {
             bubbles: true,
             cancelable: true,
@@ -503,19 +836,4 @@ function cancelLongPressTimer() {
     }
     _class_private_field_set(this, _touchStartCoords, null);
 }
-function onTouchMove(event) {
-    if (_class_private_field_get(this, _longPressTimeout) === null || _class_private_field_get(this, _touchStartCoords) === null) {
-        return;
-    }
-    const touch = event.touches[0];
-    if (!touch) {
-        _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
-        return;
-    }
-    const dx = Math.abs(touch.clientX - _class_private_field_get(this, _touchStartCoords).x);
-    const dy = Math.abs(touch.clientY - _class_private_field_get(this, _touchStartCoords).y);
-    if (dx > LONG_PRESS_MOVE_THRESHOLD || dy > LONG_PRESS_MOVE_THRESHOLD) {
-        _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
-    }
-}
 export default Event;