handsontable 18.1.0-rc8 → 18.1.0

package/3rdparty/walkontable/src/event.d.ts

@@ -138,6 +138,23 @@ declare class Event {
      * @param {TouchEvent} event The touch event object.
      */
     onTouchEnd(event: TouchEvent): void;
+    /**
+     * OnTouchCancel callback. Browsers cancel a gesture instead of ending it whenever the system
+     * claims the touch (an edge-swipe, a dialog, a context callout) — `touchend` then never fires.
+     * Without this reset `touchApplied` stays `true` and every REAL mouse `mouseup` is routed into
+     * the touch tap detector, which has no button filter, so two right-clicks or two drag-selections
+     * ending on the same cell within the double-tap window would fire a phantom double-click.
+     * It also releases the mouse-down flag: a long-press fires `onMouseDown` from its timer, and
+     * after a cancel no `mouseup` ever follows, which would leave mouse-move selection dragging
+     * armed until the next click. The pending synthesized-pair flag is cleared for the same reason
+     * the scroll branch of `onTouchEnd` clears it: a cancelled gesture armed nothing, so a
+     * still-pending flag belongs to an earlier gesture whose pair never came, and left in place it
+     * would drop the next real mouse pair inside the ceiling on engines that do not report the
+     * input origin.
+     *
+     * @private
+     */
+    onTouchCancel(): void;
     /**
      * 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

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

@@ -20,6 +20,7 @@ const _element = require("../../../helpers/dom/element");
 const _pointerToCoords = require("./utils/pointerToCoords");
 const _feature = require("../../../helpers/feature");
 const _browser = require("../../../helpers/browser");
+const _inputOrigin = require("../../../helpers/dom/inputOrigin");
 function _check_private_redeclaration(obj, privateCollection) {
     if (privateCollection.has(obj)) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -72,6 +73,20 @@ function _class_private_method_init(obj, privateSet) {
 }
 const LONG_PRESS_DELAY = 500;
 const LONG_PRESS_MOVE_THRESHOLD = 10;
+/**
+ * How long (ms) after a mousedown the double-click detector keeps waiting for the matching
+ * second click. Mirrors the OS double-click tolerance with margin.
+ */ const DBLCLICK_MOUSEDOWN_TIMEOUT = 1000;
+/**
+ * How long (ms) after a mouseup the double-click detector keeps the first click "armed"
+ * for a mouse-driven double-click.
+ */ const DBLCLICK_MOUSEUP_TIMEOUT = 500;
+/**
+ * How long (ms) after a touch tap a second tap on the same cell counts as a double-tap. Touch
+ * taps are paired by `#handleTouchTap()`, independently of the mouse double-click slots, so a
+ * real mouse click after a tap never pairs with it. iOS drops taps under ~250 ms and humans
+ * double-tap at 300–600 ms (DEV-2687).
+ */ const TOUCH_DBLTAP_TIMEOUT = 1000;
 function createEventDeps(ctx) {
     return {
         facadeGetter: ctx.getFacade(),
@@ -99,6 +114,17 @@ var /**
    */ _dblClickTimeout = /*#__PURE__*/ new WeakMap(), /**
    * @type {number[]}
    */ _dblClickOrigin = /*#__PURE__*/ new WeakMap(), /**
+   * Coordinates of the most recent touch tap, kept for double-tap detection. Coordinates, not the
+   * resolved TD: Walkontable recycles TD elements across scrolls and re-renders, so element
+   * identity can pair two taps that landed on different cells (DEV-2687 review). Touch taps never
+   * arm the mouse double-click slots, so a mouse click after a tap cannot pair with a tap.
+   *
+   * @type {CellCoords|null}
+   */ _lastTapCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Timestamp (ms) of the most recent touch tap.
+   *
+   * @type {number}
+   */ _lastTapAt = /*#__PURE__*/ new WeakMap(), /**
    * Timer ID for the long-press gesture detection.
    *
    * @type {number|null}
@@ -123,12 +149,25 @@ var /**
    * @type {TouchEvent|null}
    */ _deferredTouchStartEvent = /*#__PURE__*/ new WeakMap(), /**
    * Timestamp (ms) of the most recent `onMouseUp` call that originated from a touch gesture.
-   * Used to suppress the browser-synthesized `mouseup` event that fires after `touchend` on
-   * devices that register both touch and mouse listeners (e.g. iPad Safari), which would
-   * otherwise trigger `onCellMouseUp` — and context-menu commands — a second time.
+   * On devices that register both touch and mouse listeners (iPad with a desktop UA, Windows
+   * touchscreens) the browser synthesizes a `mousedown`/`mouseup`/`click` sequence after
+   * `touchend`. The whole sequence must be ignored – dropping only one half fires
+   * `onCellMouseDown` a second time per tap, and the leaked pair would act as a phantom mouse
+   * click (DEV-2687).
+   * Used as the fallback for engines that do not expose `sourceCapabilities`
+   * (see `#isTouchSynthesizedMouseEvent`).
    *
    * @type {number}
    */ _lastTouchMouseUpAt = /*#__PURE__*/ new WeakMap(), /**
+   * `true` between a touch-driven `onMouseUp` and the browser-synthesized `mouseup` that follows it.
+   * Only that first pair is dropped; once it is consumed, real mouse events pass even inside the
+   * `TOUCH_SYNTHESIZED_MOUSE_WINDOW` ceiling, so a fill-handle drag or a drag-selection started with
+   * a mouse right after a tap works on engines that do not report the input origin (DEV-2687). The
+   * flag is re-armed by every touch-driven `onMouseUp` and cleared when a scroll-classified gesture
+   * ends, so a tap that synthesized nothing cannot swallow that gesture's own compatibility pair.
+   *
+   * @type {boolean}
+   */ _synthesizedPairPending = /*#__PURE__*/ new WeakMap(), /**
    * @type {boolean}
    */ _mouseDown = /*#__PURE__*/ new WeakMap(), /**
    * The last renderable coords seen in `onMouseMove` while the mouse was outside the viewport.
@@ -137,6 +176,18 @@ var /**
    *
    * @type {{ row: number, col: number } | null}
    */ _mouseOverOutsideLastCoords = /*#__PURE__*/ new WeakMap(), /**
+   * Decides whether a mouse event caught by the mouse listeners is one half of the browser-synthesized
+   * `mousedown`/`mouseup` pair that follows a touch tap, and must therefore be dropped. Order of the
+   * checks: an engine that reports the input origin and says "not touch" wins (Blink, a real mouse or
+   * pen is never dropped); otherwise the event is synthesized only if a touch-driven `onMouseUp` just
+   * armed the pair (`#synthesizedPairPending`) and the ceiling has not passed. The `mouseup` half
+   * consumes the pair, so any later mouse event inside the ceiling is treated as real. Dropping both
+   * halves keeps `onCellMouseDown` at one call per tap and context-menu commands at one execution
+   * (#12803); a tap that left no stamp (a gesture treated as a scroll) has its pair processed.
+   *
+   * @param {MouseEvent} event The mouse event object.
+   * @returns {boolean}
+   */ _isTouchSynthesizedMouseEvent = /*#__PURE__*/ new WeakSet(), /**
    * 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.
    *
@@ -145,6 +196,19 @@ var /**
    * @param {number} mouseY Client Y coordinate of the mouse.
    * @returns {{ coords: CellCoords, isOutside: boolean }}
    */ _getCellCoordsFromMousePosition = /*#__PURE__*/ new WeakSet(), /**
+   * Pairs touch taps into double-taps. Called from `onMouseUp` while `touchApplied` is `true`,
+   * i.e. for the `onMouseUp` that `onTouchEnd` drives. Two taps on the same coordinates within
+   * `TOUCH_DBLTAP_TIMEOUT` fire the double-click callbacks; a long-press, a tap outside the cells,
+   * or a tap on different coordinates resets the detector.
+   *
+   * @param {MouseEvent|TouchEvent} event The event that ended the tap.
+   * @param {ParentCell} cell The tapped cell, as returned by `parentCell()`.
+   */ _handleTouchTap = /*#__PURE__*/ new WeakSet(), /**
+   * Fires the corner or the cell double-click callback for the given cell.
+   *
+   * @param {MouseEvent|TouchEvent} event The event that completed the double-click.
+   * @param {ParentCell} cell The double-clicked cell.
+   */ _fireDblClick = /*#__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.
@@ -178,20 +242,27 @@ var /**
             _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'touchstart', (event)=>this.onTouchStart(event));
             _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'touchend', (event)=>this.onTouchEnd(event));
             _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'touchmove', (event)=>this.onTouchMove(event));
+            _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'touchcancel', ()=>this.onTouchCancel());
             _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'scroll', ()=>this.onHolderScroll());
         };
         const initMouseEvents = ()=>{
+            // On devices that register both touch and mouse listeners (e.g. iPad Safari with a
+            // desktop UA), `touchend` already drove `onMouseDown`/`onMouseUp`. The browser then
+            // synthesizes a `mousedown`/`mouseup` pair ~0-50 ms later; drop BOTH halves when the
+            // touch path handled the tap, so `onCellMouseDown` fires once per tap (DEV-2687) and
+            // context-menu commands do not execute twice (#12803).
             _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'mouseup', (event)=>{
-                // On devices that register both touch and mouse listeners (e.g. iPad Safari),
-                // `touchend` fires first and calls `onMouseUp` directly. The browser then
-                // synthesizes a `mouseup` event ~0-50 ms later; suppress it to prevent
-                // context-menu commands from executing twice.
-                if (Date.now() - _class_private_field_get(this, _lastTouchMouseUpAt) < 500) {
+                if (_class_private_method_get(this, _isTouchSynthesizedMouseEvent, isTouchSynthesizedMouseEvent).call(this, event)) {
                     return;
                 }
                 this.onMouseUp(event);
             });
-            _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'mousedown', (event)=>this.onMouseDown(event));
+            _class_private_field_get(this, _deps).eventManager.addEventListener(_class_private_field_get(this, _deps).wtTable.holder, 'mousedown', (event)=>{
+                if (_class_private_method_get(this, _isTouchSynthesizedMouseEvent, isTouchSynthesizedMouseEvent).call(this, event)) {
+                    return;
+                }
+                this.onMouseDown(event);
+            });
         };
         if ((0, _browser.isMobileBrowser)()) {
             initTouchEvents();
@@ -288,15 +359,16 @@ var /**
                 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) {
+        // The mouse double-click slots are armed by mouse clicks only; touch taps are paired by
+        // #handleTouchTap() in onMouseUp (DEV-2687).
+        if (!this.touchApplied && event.button === 0 && cell.TD) {
             _class_private_field_get(this, _dblClickOrigin)[0] = cell.TD;
             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);
+            }, DBLCLICK_MOUSEDOWN_TIMEOUT);
         }
     }
     /**
@@ -405,16 +477,16 @@ var /**
         if (cell.TD && _class_private_field_get(this, _deps).wtSettings.has('onCellMouseUp')) {
             this.callListener('onCellMouseUp', event, cell.coords, cell.TD);
         }
-        // if not left mouse button, and the origin event is not comes from touch
-        if (event.button !== 0 && !this.touchApplied) {
+        if (this.touchApplied) {
+            _class_private_method_get(this, _handleTouchTap, handleTouchTap).call(this, event, cell);
+            return;
+        }
+        // ignore non-left mouse buttons
+        if (event.button !== 0) {
             return;
         }
         if (cell.TD && cell.TD === _class_private_field_get(this, _dblClickOrigin)[0] && cell.TD === _class_private_field_get(this, _dblClickOrigin)[1]) {
-            if ((0, _element.hasClass)((0, _element.eventTargetEl)(event), 'corner')) {
-                this.callListener('onCellCornerDblClick', event, cell.coords, cell.TD);
-            } else {
-                this.callListener('onCellDblClick', event, cell.coords, cell.TD);
-            }
+            _class_private_method_get(this, _fireDblClick, fireDblClick).call(this, event, cell);
             _class_private_field_get(this, _dblClickOrigin)[0] = null;
             _class_private_field_get(this, _dblClickOrigin)[1] = null;
         } else if (cell.TD && cell.TD === _class_private_field_get(this, _dblClickOrigin)[0]) {
@@ -424,7 +496,7 @@ var /**
             }
             _class_private_field_get(this, _dblClickTimeout)[1] = setTimeout(()=>{
                 _class_private_field_get(this, _dblClickOrigin)[1] = null;
-            }, 500);
+            }, DBLCLICK_MOUSEUP_TIMEOUT);
         }
     }
     /**
@@ -494,14 +566,51 @@ var /**
         // 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)) {
-            _class_private_field_set(this, _lastTouchMouseUpAt, Date.now());
+            // The stamp is taken AFTER the tap is handled, so the selection/render work onMouseUp does
+            // is not charged against the TOUCH_SYNTHESIZED_MOUSE_WINDOW ceiling. Everything onMouseUp
+            // triggers is synchronous; the browser only dispatches the synthesized mousedown/mouseup
+            // sequence after this touchend handler returns.
             this.onMouseUp(event);
+            _class_private_field_set(this, _lastTouchMouseUpAt, Date.now());
+            _class_private_field_set(this, _synthesizedPairPending, true);
+        } else {
+            // A pure scroll gesture calls neither onMouseDown nor onMouseUp, so #handleTouchTap never
+            // runs to reset the tap detector. Reset it here so a scroll between two taps can't pair them.
+            _class_private_field_set(this, _lastTapCoords, null);
+            // This gesture armed nothing, so a still-pending flag belongs to an earlier gesture whose
+            // pair never came; clear it so THIS gesture's compatibility pair is processed.
+            _class_private_field_set(this, _synthesizedPairPending, false);
         }
         this.touchApplied = false;
         _class_private_field_set(this, _touchWasMoved, false);
         _class_private_field_set(this, _longPressFired, false);
     }
     /**
+   * OnTouchCancel callback. Browsers cancel a gesture instead of ending it whenever the system
+   * claims the touch (an edge-swipe, a dialog, a context callout) — `touchend` then never fires.
+   * Without this reset `touchApplied` stays `true` and every REAL mouse `mouseup` is routed into
+   * the touch tap detector, which has no button filter, so two right-clicks or two drag-selections
+   * ending on the same cell within the double-tap window would fire a phantom double-click.
+   * It also releases the mouse-down flag: a long-press fires `onMouseDown` from its timer, and
+   * after a cancel no `mouseup` ever follows, which would leave mouse-move selection dragging
+   * armed until the next click. The pending synthesized-pair flag is cleared for the same reason
+   * the scroll branch of `onTouchEnd` clears it: a cancelled gesture armed nothing, so a
+   * still-pending flag belongs to an earlier gesture whose pair never came, and left in place it
+   * would drop the next real mouse pair inside the ceiling on engines that do not report the
+   * input origin.
+   *
+   * @private
+   */ onTouchCancel() {
+        _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
+        this.touchApplied = false;
+        _class_private_field_set(this, _mouseDown, false);
+        _class_private_field_set(this, _touchWasMoved, false);
+        _class_private_field_set(this, _longPressFired, false);
+        _class_private_field_set(this, _deferredTouchStartEvent, null);
+        _class_private_field_set(this, _lastTapCoords, null);
+        _class_private_field_set(this, _synthesizedPairPending, 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
@@ -585,7 +694,10 @@ var /**
    * @param {EventDeps} deps The Event module dependencies.
    * @param {Event} [parent=null] The main Event instance.
    */ constructor(deps, parent = null){
+        _class_private_method_init(this, _isTouchSynthesizedMouseEvent);
         _class_private_method_init(this, _getCellCoordsFromMousePosition);
+        _class_private_method_init(this, _handleTouchTap);
+        _class_private_method_init(this, _fireDblClick);
         _class_private_method_init(this, _startLongPressTimer);
         _class_private_method_init(this, _cancelLongPressTimer);
         _class_private_field_init(this, _deps, {
@@ -608,6 +720,14 @@ var /**
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _lastTapCoords, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _lastTapAt, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_init(this, _longPressTimeout, {
             writable: true,
             value: void 0
@@ -632,6 +752,10 @@ var /**
             writable: true,
             value: void 0
         });
+        _class_private_field_init(this, _synthesizedPairPending, {
+            writable: true,
+            value: void 0
+        });
         _class_private_field_init(this, _mouseDown, {
             writable: true,
             value: void 0
@@ -649,12 +773,15 @@ var /**
             null,
             null
         ]);
+        _class_private_field_set(this, _lastTapCoords, null);
+        _class_private_field_set(this, _lastTapAt, 0);
         _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, _lastTouchMouseUpAt, 0);
+        _class_private_field_set(this, _synthesizedPairPending, false);
         _class_private_field_set(this, _mouseDown, false);
         _class_private_field_set(this, _mouseOverOutsideLastCoords, null);
         _class_private_field_set(this, _deps, deps);
@@ -662,9 +789,48 @@ var /**
         this.registerEvents();
     }
 }
+function isTouchSynthesizedMouseEvent(event) {
+    if ((0, _inputOrigin.getMouseEventTouchOrigin)(event) === false) {
+        return false;
+    }
+    const withinCeiling = Date.now() - _class_private_field_get(this, _lastTouchMouseUpAt) < _inputOrigin.TOUCH_SYNTHESIZED_MOUSE_WINDOW;
+    if (!_class_private_field_get(this, _synthesizedPairPending) || !withinCeiling) {
+        _class_private_field_set(this, _synthesizedPairPending, false);
+        return false;
+    }
+    if (event.type === 'mouseup') {
+        _class_private_field_set(this, _synthesizedPairPending, false);
+    }
+    return true;
+}
 function getCellCoordsFromMousePosition(mouseX, mouseY) {
     return (0, _pointerToCoords.getCellCoordsFromMousePosition)(_class_private_field_get(this, _deps), mouseX, mouseY);
 }
+function handleTouchTap(event, cell) {
+    if (_class_private_field_get(this, _longPressFired) || !cell.TD || !cell.coords) {
+        _class_private_field_set(this, _lastTapCoords, null);
+        return;
+    }
+    const now = Date.now();
+    const isSameCell = _class_private_field_get(this, _lastTapCoords) !== null && _class_private_field_get(this, _lastTapCoords).row === cell.coords.row && _class_private_field_get(this, _lastTapCoords).col === cell.coords.col;
+    if (isSameCell && now - _class_private_field_get(this, _lastTapAt) < TOUCH_DBLTAP_TIMEOUT) {
+        _class_private_method_get(this, _fireDblClick, fireDblClick).call(this, event, cell);
+        _class_private_field_set(this, _lastTapCoords, null);
+        return;
+    }
+    // Clone: parentCell()'s border branches return references into the live selection CellRange,
+    // which normalize() mutates in place — a stored alias could silently shift within the
+    // double-tap window.
+    _class_private_field_set(this, _lastTapCoords, cell.coords.clone());
+    _class_private_field_set(this, _lastTapAt, now);
+}
+function fireDblClick(event, cell) {
+    if ((0, _element.hasClass)((0, _element.eventTargetEl)(event), 'corner')) {
+        this.callListener('onCellCornerDblClick', event, cell.coords, cell.TD);
+    } else {
+        this.callListener('onCellDblClick', event, cell.coords, cell.TD);
+    }
+}
 function startLongPressTimer(event) {
     _class_private_method_get(this, _cancelLongPressTimer, cancelLongPressTimer).call(this);
     const touch = event.touches[0];
@@ -685,6 +851,7 @@ function startLongPressTimer(event) {
         this.onMouseDown(event);
         _class_private_field_get(this, _dblClickOrigin)[0] = null;
         _class_private_field_get(this, _dblClickOrigin)[1] = null;
+        _class_private_field_set(this, _lastTapCoords, null);
         if (_class_private_field_get(this, _dblClickTimeout)[0] !== null) {
             clearTimeout(_class_private_field_get(this, _dblClickTimeout)[0]);
         }