react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/web/tools/EventManager.js

@@ -0,0 +1,85 @@
+export default class EventManager {
+    view;
+    pointersInBounds = [];
+    activePointersCounter;
+    constructor(view) {
+        this.view = view;
+        this.activePointersCounter = 0;
+    }
+    onPointerDown(_event) { }
+    onPointerAdd(_event) { }
+    onPointerUp(_event) { }
+    onPointerRemove(_event) { }
+    onPointerMove(_event) { }
+    onPointerLeave(_event) { } // Called only when pointer is pressed (or touching)
+    onPointerEnter(_event) { } // Called only when pointer is pressed (or touching)
+    onPointerCancel(_event) {
+        // When pointer cancel is triggered and there are more pointers on the view, only one pointer is cancelled
+        // Because we want all pointers to be cancelled by that event, we are doing it manually by reseting handler and changing activePointersCounter to 0
+        // Events that correspond to removing the pointer (pointerup, touchend) have condition, that they don't perform any action when activePointersCounter
+        // is equal to 0. This prevents counter from going to negative values, when pointers are removed from view after one of them has been cancelled
+    }
+    onPointerOutOfBounds(_event) { }
+    onPointerMoveOver(_event) { }
+    onPointerMoveOut(_event) { }
+    onWheel(_event) { }
+    setOnPointerDown(callback) {
+        this.onPointerDown = callback;
+    }
+    setOnPointerAdd(callback) {
+        this.onPointerAdd = callback;
+    }
+    setOnPointerUp(callback) {
+        this.onPointerUp = callback;
+    }
+    setOnPointerRemove(callback) {
+        this.onPointerRemove = callback;
+    }
+    setOnPointerMove(callback) {
+        this.onPointerMove = callback;
+    }
+    setOnPointerLeave(callback) {
+        this.onPointerLeave = callback;
+    }
+    setOnPointerEnter(callback) {
+        this.onPointerEnter = callback;
+    }
+    setOnPointerCancel(callback) {
+        this.onPointerCancel = callback;
+    }
+    setOnPointerOutOfBounds(callback) {
+        this.onPointerOutOfBounds = callback;
+    }
+    setOnPointerMoveOver(callback) {
+        this.onPointerMoveOver = callback;
+    }
+    setOnPointerMoveOut(callback) {
+        this.onPointerMoveOut = callback;
+    }
+    setOnWheel(callback) {
+        this.onWheel = callback;
+    }
+    markAsInBounds(pointerId) {
+        if (this.pointersInBounds.indexOf(pointerId) >= 0) {
+            return;
+        }
+        this.pointersInBounds.push(pointerId);
+    }
+    markAsOutOfBounds(pointerId) {
+        const index = this.pointersInBounds.indexOf(pointerId);
+        if (index < 0) {
+            return;
+        }
+        this.pointersInBounds.splice(index, 1);
+    }
+    resetManager() {
+        // Reseting activePointersCounter is necessary to make gestures such as pinch work properly
+        // There are gestures that end when there is still one active pointer (like pinch/rotation)
+        // When these gestures end, they are reset, but they still receive events from pointer that is active
+        // This causes trouble, since only onPointerDown registers gesture in orchestrator, and while gestures receive
+        // Events from active pointer after they finished, next pointerdown event will be registered as additional pointer, not the first one
+        // This casues trouble like gestures getting stuck in END state, even though they should have gone to UNDETERMINED
+        this.activePointersCounter = 0;
+        this.pointersInBounds = [];
+    }
+}

package/lib/typescript/web/tools/GestureHandlerDelegate.d.ts

@@ -0,0 +1,24 @@
+import { Config } from '../interfaces';
+export interface MeasureResult {
+    pageX: number;
+    pageY: number;
+    width: number;
+    height: number;
+}
+export interface GestureHandlerDelegate<TComponent, THandler> {
+    view: TComponent;
+    init(viewRef: number, handler: THandler): void;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
+    measureView(): MeasureResult;
+    reset(): void;
+    onBegin(): void;
+    onActivate(): void;
+    onEnd(): void;
+    onCancel(): void;
+    onFail(): void;
+    onEnabledChange(enabled: boolean): void;
+    destroy(config: Config): void;
+}

package/lib/typescript/web/tools/GestureHandlerDelegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GestureHandlerDelegate.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/GestureHandlerDelegate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB,CAAC,UAAU,EAAE,QAAQ;IAC1D,IAAI,EAAE,UAAU,CAAC;IAEjB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/C,iBAAiB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;IAC/D,WAAW,IAAI,aAAa,CAAC;IAC7B,KAAK,IAAI,IAAI,CAAC;IAEd,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,IAAI,IAAI,CAAC;IACnB,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,IAAI,IAAI,CAAC;IACjB,MAAM,IAAI,IAAI,CAAC;IACf,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAExC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B"}

package/lib/typescript/web/tools/GestureHandlerDelegate.js

@@ -0,0 +1 @@
+export {};

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -0,0 +1,31 @@
+import { State } from '../../State';
+import type IGestureHandler from '../handlers/IGestureHandler';
+export default class GestureHandlerOrchestrator {
+    private static _instance;
+    private gestureHandlers;
+    private awaitingHandlers;
+    private awaitingHandlersTags;
+    private handlingChangeSemaphore;
+    private activationIndex;
+    private constructor();
+    private scheduleFinishedHandlersCleanup;
+    private cleanHandler;
+    removeHandlerFromOrchestrator(handler: IGestureHandler): void;
+    private cleanupFinishedHandlers;
+    private hasOtherHandlerToWaitFor;
+    private shouldBeCancelledByFinishedHandler;
+    private tryActivate;
+    private shouldActivate;
+    private cleanupAwaitingHandlers;
+    onHandlerStateChange(handler: IGestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
+    private makeActive;
+    private addAwaitingHandler;
+    recordHandlerIfNotPresent(handler: IGestureHandler): void;
+    private shouldHandlerWaitForOther;
+    private canRunSimultaneously;
+    private shouldHandlerBeCancelledBy;
+    private checkOverlap;
+    private isFinished;
+    cancelMouseAndPenGestures(currentHandler: IGestureHandler): void;
+    static get instance(): GestureHandlerOrchestrator;
+}

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GestureHandlerOrchestrator.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/GestureHandlerOrchestrator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAG/D,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAC7C,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6B;IAErD,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,oBAAoB,CAA0B;IAEtD,OAAO,CAAC,uBAAuB,CAAK;IACpC,OAAO,CAAC,eAAe,CAAK;IAI5B,OAAO;IAEP,OAAO,CAAC,+BAA+B;IAMvC,OAAO,CAAC,YAAY;IAOb,6BAA6B,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAcpE,OAAO,CAAC,uBAAuB;IAiB/B,OAAO,CAAC,wBAAwB;IAWhC,OAAO,CAAC,kCAAkC;IAa1C,OAAO,CAAC,WAAW;IAgCnB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,uBAAuB;IAoBxB,oBAAoB,CACzB,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,KAAK,EACf,QAAQ,EAAE,KAAK,EACf,cAAc,CAAC,EAAE,OAAO,GACvB,IAAI;IA8DP,OAAO,CAAC,UAAU;IAuClB,OAAO,CAAC,kBAAkB;IAYnB,yBAAyB,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAYhE,OAAO,CAAC,yBAAyB;IAWjC,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,0BAA0B;IAyBlC,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,UAAU;IAYX,yBAAyB,CAAC,cAAc,EAAE,eAAe,GAAG,IAAI;IAwBvE,WAAkB,QAAQ,IAAI,0BAA0B,CAMvD;CACF"}

package/lib/typescript/web/tools/GestureHandlerOrchestrator.js

@@ -0,0 +1,273 @@
+import { PointerType } from '../../PointerType';
+import { State } from '../../State';
+import PointerTracker from './PointerTracker';
+export default class GestureHandlerOrchestrator {
+    static _instance;
+    gestureHandlers = [];
+    awaitingHandlers = [];
+    awaitingHandlersTags = new Set();
+    handlingChangeSemaphore = 0;
+    activationIndex = 0;
+    // Private beacuse of Singleton
+    // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
+    constructor() { }
+    scheduleFinishedHandlersCleanup() {
+        if (this.handlingChangeSemaphore === 0) {
+            this.cleanupFinishedHandlers();
+        }
+    }
+    cleanHandler(handler) {
+        handler.reset();
+        handler.active = false;
+        handler.awaiting = false;
+        handler.activationIndex = Number.MAX_VALUE;
+    }
+    removeHandlerFromOrchestrator(handler) {
+        const indexInGestureHandlers = this.gestureHandlers.indexOf(handler);
+        const indexInAwaitingHandlers = this.awaitingHandlers.indexOf(handler);
+        if (indexInGestureHandlers >= 0) {
+            this.gestureHandlers.splice(indexInGestureHandlers, 1);
+        }
+        if (indexInAwaitingHandlers >= 0) {
+            this.awaitingHandlers.splice(indexInAwaitingHandlers, 1);
+            this.awaitingHandlersTags.delete(handler.handlerTag);
+        }
+    }
+    cleanupFinishedHandlers() {
+        const handlersToRemove = new Set();
+        for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+            const handler = this.gestureHandlers[i];
+            if (this.isFinished(handler.state) && !handler.awaiting) {
+                this.cleanHandler(handler);
+                handlersToRemove.add(handler);
+            }
+        }
+        this.gestureHandlers = this.gestureHandlers.filter((handler) => !handlersToRemove.has(handler));
+    }
+    hasOtherHandlerToWaitFor(handler) {
+        const hasToWaitFor = (otherHandler) => {
+            return (!this.isFinished(otherHandler.state) &&
+                this.shouldHandlerWaitForOther(handler, otherHandler));
+        };
+        return this.gestureHandlers.some(hasToWaitFor);
+    }
+    shouldBeCancelledByFinishedHandler(handler) {
+        const shouldBeCancelled = (otherHandler) => {
+            return (this.shouldHandlerWaitForOther(handler, otherHandler) &&
+                otherHandler.state === State.END);
+        };
+        return this.gestureHandlers.some(shouldBeCancelled);
+    }
+    tryActivate(handler) {
+        if (this.shouldBeCancelledByFinishedHandler(handler)) {
+            handler.cancel();
+            return;
+        }
+        if (this.hasOtherHandlerToWaitFor(handler)) {
+            this.addAwaitingHandler(handler);
+            return;
+        }
+        const handlerState = handler.state;
+        if (handlerState === State.CANCELLED || handlerState === State.FAILED) {
+            return;
+        }
+        if (this.shouldActivate(handler)) {
+            this.makeActive(handler);
+            return;
+        }
+        if (handlerState === State.ACTIVE) {
+            handler.fail();
+            return;
+        }
+        if (handlerState === State.BEGAN) {
+            handler.cancel();
+        }
+    }
+    shouldActivate(handler) {
+        const shouldBeCancelledBy = (otherHandler) => {
+            return this.shouldHandlerBeCancelledBy(handler, otherHandler);
+        };
+        return !this.gestureHandlers.some(shouldBeCancelledBy);
+    }
+    cleanupAwaitingHandlers(handler) {
+        const shouldWait = (otherHandler) => {
+            return (!otherHandler.awaiting &&
+                this.shouldHandlerWaitForOther(otherHandler, handler));
+        };
+        for (const otherHandler of this.awaitingHandlers) {
+            if (shouldWait(otherHandler)) {
+                this.cleanHandler(otherHandler);
+                this.awaitingHandlersTags.delete(otherHandler.handlerTag);
+            }
+        }
+        this.awaitingHandlers = this.awaitingHandlers.filter((otherHandler) => this.awaitingHandlersTags.has(otherHandler.handlerTag));
+    }
+    onHandlerStateChange(handler, newState, oldState, sendIfDisabled) {
+        if (!handler.enabled && !sendIfDisabled) {
+            return;
+        }
+        this.handlingChangeSemaphore += 1;
+        if (this.isFinished(newState)) {
+            for (const otherHandler of this.awaitingHandlers) {
+                if (!this.shouldHandlerWaitForOther(otherHandler, handler) ||
+                    !this.awaitingHandlersTags.has(otherHandler.handlerTag)) {
+                    continue;
+                }
+                if (newState !== State.END) {
+                    this.tryActivate(otherHandler);
+                    continue;
+                }
+                otherHandler.cancel();
+                if (otherHandler.state === State.END) {
+                    // Handle edge case, where discrete gestures end immediately after activation thus
+                    // their state is set to END and when the gesture they are waiting for activates they
+                    // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
+                    // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
+                    otherHandler.sendEvent(State.CANCELLED, State.BEGAN);
+                }
+                otherHandler.awaiting = false;
+            }
+        }
+        if (newState === State.ACTIVE) {
+            this.tryActivate(handler);
+        }
+        else if (oldState === State.ACTIVE || oldState === State.END) {
+            if (handler.active) {
+                handler.sendEvent(newState, oldState);
+            }
+            else if (oldState === State.ACTIVE &&
+                (newState === State.CANCELLED || newState === State.FAILED)) {
+                handler.sendEvent(newState, State.BEGAN);
+            }
+        }
+        else if (oldState !== State.UNDETERMINED ||
+            newState !== State.CANCELLED) {
+            handler.sendEvent(newState, oldState);
+        }
+        this.handlingChangeSemaphore -= 1;
+        this.scheduleFinishedHandlersCleanup();
+        if (!this.awaitingHandlers.includes(handler)) {
+            this.cleanupAwaitingHandlers(handler);
+        }
+    }
+    makeActive(handler) {
+        const currentState = handler.state;
+        handler.active = true;
+        handler.shouldResetProgress = true;
+        handler.activationIndex = this.activationIndex++;
+        for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+            if (this.shouldHandlerBeCancelledBy(this.gestureHandlers[i], handler)) {
+                this.gestureHandlers[i].cancel();
+            }
+        }
+        for (const otherHandler of this.awaitingHandlers) {
+            if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
+                otherHandler.awaiting = false;
+            }
+        }
+        handler.sendEvent(State.ACTIVE, State.BEGAN);
+        if (currentState !== State.ACTIVE) {
+            handler.sendEvent(State.END, State.ACTIVE);
+            if (currentState !== State.END) {
+                handler.sendEvent(State.UNDETERMINED, State.END);
+            }
+        }
+        if (!handler.awaiting) {
+            return;
+        }
+        handler.awaiting = false;
+        this.awaitingHandlers = this.awaitingHandlers.filter((otherHandler) => otherHandler !== handler);
+    }
+    addAwaitingHandler(handler) {
+        if (this.awaitingHandlers.includes(handler)) {
+            return;
+        }
+        this.awaitingHandlers.push(handler);
+        this.awaitingHandlersTags.add(handler.handlerTag);
+        handler.awaiting = true;
+        handler.activationIndex = this.activationIndex++;
+    }
+    recordHandlerIfNotPresent(handler) {
+        if (this.gestureHandlers.includes(handler)) {
+            return;
+        }
+        this.gestureHandlers.push(handler);
+        handler.active = false;
+        handler.awaiting = false;
+        handler.activationIndex = Number.MAX_SAFE_INTEGER;
+    }
+    shouldHandlerWaitForOther(handler, otherHandler) {
+        return (handler !== otherHandler &&
+            (handler.shouldWaitForHandlerFailure(otherHandler) ||
+                otherHandler.shouldRequireToWaitForFailure(handler)));
+    }
+    canRunSimultaneously(gh1, gh2) {
+        return (gh1 === gh2 ||
+            gh1.shouldRecognizeSimultaneously(gh2) ||
+            gh2.shouldRecognizeSimultaneously(gh1));
+    }
+    shouldHandlerBeCancelledBy(handler, otherHandler) {
+        if (this.canRunSimultaneously(handler, otherHandler)) {
+            return false;
+        }
+        if (handler.awaiting || handler.state === State.ACTIVE) {
+            return handler.shouldBeCancelledByOther(otherHandler);
+        }
+        const handlerPointers = handler.getTrackedPointersID();
+        const otherPointers = otherHandler.getTrackedPointersID();
+        if (!PointerTracker.shareCommonPointers(handlerPointers, otherPointers) &&
+            handler.delegate.view !== otherHandler.delegate.view) {
+            return this.checkOverlap(handler, otherHandler);
+        }
+        return true;
+    }
+    checkOverlap(handler, otherHandler) {
+        // If handlers don't have common pointers, default return value is false.
+        // However, if at least on pointer overlaps with both handlers, we return true
+        // This solves issue in overlapping parents example
+        // TODO: Find better way to handle that issue, for example by activation order and handler cancelling
+        const isPointerWithinBothBounds = (pointer) => {
+            const point = handler.tracker.getLastAbsoluteCoords(pointer);
+            return (point &&
+                handler.delegate.isPointerInBounds(point) &&
+                otherHandler.delegate.isPointerInBounds(point));
+        };
+        return handler.getTrackedPointersID().some(isPointerWithinBothBounds);
+    }
+    isFinished(state) {
+        return (state === State.END || state === State.FAILED || state === State.CANCELLED);
+    }
+    // This function is called when handler receives touchdown event
+    // If handler is using mouse or pen as a pointer and any handler receives touch event,
+    // mouse/pen event dissappears - it doesn't send onPointerCancel nor onPointerUp (and others)
+    // This became a problem because handler was left at active state without any signal to end or fail
+    // To handle this, when new touch event is received, we loop through active handlers and check which type of
+    // pointer they're using. If there are any handler with mouse/pen as a pointer, we cancel them
+    cancelMouseAndPenGestures(currentHandler) {
+        this.gestureHandlers.forEach((handler) => {
+            if (handler.pointerType !== PointerType.MOUSE &&
+                handler.pointerType !== PointerType.STYLUS) {
+                return;
+            }
+            if (handler !== currentHandler) {
+                handler.cancel();
+            }
+            else {
+                // Handler that received touch event should have its pointer tracker reset
+                // This allows handler to smoothly change from mouse/pen to touch
+                // The drawback is, that when we try to use mouse/pen one more time, it doesn't send onPointerDown at the first time
+                // so it is required to click two times to get handler to work
+                //
+                // However, handler will receive manually created onPointerEnter that is triggered in EventManager in onPointerMove method.
+                // There may be possibility to use that fact to make handler respond properly to first mouse click
+                handler.tracker.resetTracker();
+            }
+        });
+    }
+    static get instance() {
+        if (!GestureHandlerOrchestrator._instance) {
+            GestureHandlerOrchestrator._instance = new GestureHandlerOrchestrator();
+        }
+        return GestureHandlerOrchestrator._instance;
+    }
+}

package/lib/typescript/web/tools/GestureHandlerWebDelegate.d.ts

@@ -0,0 +1,35 @@
+import type IGestureHandler from '../handlers/IGestureHandler';
+import { GestureHandlerDelegate, MeasureResult } from './GestureHandlerDelegate';
+import { Config } from '../interfaces';
+export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement, IGestureHandler> {
+    private isInitialized;
+    private _view;
+    private gestureHandler;
+    private eventManagers;
+    private defaultViewStyles;
+    init(viewRef: number, handler: IGestureHandler): void;
+    isPointerInBounds({ x, y }: {
+        x: number;
+        y: number;
+    }): boolean;
+    measureView(): MeasureResult;
+    reset(): void;
+    tryResetCursor(): void;
+    private shouldDisableContextMenu;
+    private addContextMenuListeners;
+    private removeContextMenuListeners;
+    private disableContextMenu;
+    private enableContextMenu;
+    private setUserSelect;
+    private setTouchAction;
+    private setContextMenu;
+    onEnabledChange(enabled: boolean): void;
+    onBegin(): void;
+    onActivate(): void;
+    onEnd(): void;
+    onCancel(): void;
+    onFail(): void;
+    destroy(config: Config): void;
+    get view(): HTMLElement;
+    set view(value: HTMLElement);
+}

package/lib/typescript/web/tools/GestureHandlerWebDelegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GestureHandlerWebDelegate.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/GestureHandlerWebDelegate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EACL,sBAAsB,EACtB,aAAa,EACd,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAUvC,qBAAa,yBACX,YAAW,sBAAsB,CAAC,WAAW,EAAE,eAAe,CAAC;IAE/D,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,KAAK,CAAe;IAE5B,OAAO,CAAC,cAAc,CAAmB;IACzC,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,iBAAiB,CAGvB;IAEF,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI;IAgCrD,iBAAiB,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IAI9D,WAAW,IAAI,aAAa;IAW5B,KAAK,IAAI,IAAI;IAMb,cAAc;IAYd,OAAO,CAAC,wBAAwB;IAQhC,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,0BAA0B;IAQlC,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,cAAc;IAUtB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAyBvC,OAAO,IAAI,IAAI;IAIf,UAAU,IAAI,IAAI;IAWlB,KAAK,IAAI,IAAI;IAIb,QAAQ,IAAI,IAAI;IAIhB,MAAM,IAAI,IAAI;IAIP,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQpC,IAAW,IAAI,IAGQ,WAAW,CADjC;IACD,IAAW,IAAI,CAAC,KAAK,EAAE,WAAW,EAEjC;CACF"}

package/lib/typescript/web/tools/GestureHandlerWebDelegate.js

@@ -0,0 +1,169 @@
+import findNodeHandle from '../../findNodeHandle';
+import PointerEventManager from './PointerEventManager';
+import { State } from '../../State';
+import { isPointerInBounds } from '../utils';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
+import KeyboardEventManager from './KeyboardEventManager';
+import WheelEventManager from './WheelEventManager';
+export class GestureHandlerWebDelegate {
+    isInitialized = false;
+    _view;
+    gestureHandler;
+    eventManagers = [];
+    defaultViewStyles = {
+        userSelect: '',
+        touchAction: '',
+    };
+    init(viewRef, handler) {
+        if (!viewRef) {
+            throw new Error(`Cannot find HTML Element for handler ${handler.handlerTag}`);
+        }
+        this.isInitialized = true;
+        this.gestureHandler = handler;
+        this.view = findNodeHandle(viewRef);
+        this.defaultViewStyles = {
+            userSelect: this.view.style.userSelect,
+            touchAction: this.view.style.touchAction,
+        };
+        const config = handler.config;
+        this.setUserSelect(config.enabled);
+        this.setTouchAction(config.enabled);
+        this.setContextMenu(config.enabled);
+        this.eventManagers.push(new PointerEventManager(this.view));
+        this.eventManagers.push(new KeyboardEventManager(this.view));
+        this.eventManagers.push(new WheelEventManager(this.view));
+        this.eventManagers.forEach((manager) => this.gestureHandler.attachEventManager(manager));
+    }
+    isPointerInBounds({ x, y }) {
+        return isPointerInBounds(this.view, { x, y });
+    }
+    measureView() {
+        const rect = this.view.getBoundingClientRect();
+        return {
+            pageX: rect.left,
+            pageY: rect.top,
+            width: rect.width,
+            height: rect.height,
+        };
+    }
+    reset() {
+        this.eventManagers.forEach((manager) => manager.resetManager());
+    }
+    tryResetCursor() {
+        const config = this.gestureHandler.config;
+        if (config.activeCursor &&
+            config.activeCursor !== 'auto' &&
+            this.gestureHandler.state === State.ACTIVE) {
+            this.view.style.cursor = 'auto';
+        }
+    }
+    shouldDisableContextMenu(config) {
+        return ((config.enableContextMenu === undefined &&
+            this.gestureHandler.isButtonInConfig(MouseButton.RIGHT)) ||
+            config.enableContextMenu === false);
+    }
+    addContextMenuListeners(config) {
+        if (this.shouldDisableContextMenu(config)) {
+            this.view.addEventListener('contextmenu', this.disableContextMenu);
+        }
+        else if (config.enableContextMenu) {
+            this.view.addEventListener('contextmenu', this.enableContextMenu);
+        }
+    }
+    removeContextMenuListeners(config) {
+        if (this.shouldDisableContextMenu(config)) {
+            this.view.removeEventListener('contextmenu', this.disableContextMenu);
+        }
+        else if (config.enableContextMenu) {
+            this.view.removeEventListener('contextmenu', this.enableContextMenu);
+        }
+    }
+    disableContextMenu(e) {
+        e.preventDefault();
+    }
+    enableContextMenu(e) {
+        e.stopPropagation();
+    }
+    setUserSelect(isHandlerEnabled) {
+        const { userSelect } = this.gestureHandler.config;
+        this.view.style['userSelect'] = isHandlerEnabled
+            ? (userSelect ?? 'none')
+            : this.defaultViewStyles.userSelect;
+        this.view.style['webkitUserSelect'] = isHandlerEnabled
+            ? (userSelect ?? 'none')
+            : this.defaultViewStyles.userSelect;
+    }
+    setTouchAction(isHandlerEnabled) {
+        const { touchAction } = this.gestureHandler.config;
+        this.view.style['touchAction'] = isHandlerEnabled
+            ? (touchAction ?? 'none')
+            : this.defaultViewStyles.touchAction;
+        // @ts-ignore This one disables default events on Safari
+        this.view.style['WebkitTouchCallout'] = isHandlerEnabled
+            ? (touchAction ?? 'none')
+            : this.defaultViewStyles.touchAction;
+    }
+    setContextMenu(isHandlerEnabled) {
+        const config = this.gestureHandler.config;
+        if (isHandlerEnabled) {
+            this.addContextMenuListeners(config);
+        }
+        else {
+            this.removeContextMenuListeners(config);
+        }
+    }
+    onEnabledChange(enabled) {
+        if (!this.isInitialized) {
+            return;
+        }
+        this.setUserSelect(enabled);
+        this.setTouchAction(enabled);
+        this.setContextMenu(enabled);
+        if (enabled) {
+            this.eventManagers.forEach((manager) => {
+                // It may look like managers will be registered twice when handler is mounted for the first time.
+                // However, `init` method is called AFTER `updateGestureConfig` - it means that delegate has not
+                // been initialized yet, so this code won't be executed.
+                //
+                // Also, because we use defined functions, not lambdas, they will not be registered multiple times.
+                manager.registerListeners();
+            });
+        }
+        else {
+            this.eventManagers.forEach((manager) => {
+                manager.unregisterListeners();
+            });
+        }
+    }
+    onBegin() {
+        // no-op for now
+    }
+    onActivate() {
+        const config = this.gestureHandler.config;
+        if ((!this.view.style.cursor || this.view.style.cursor === 'auto') &&
+            config.activeCursor) {
+            this.view.style.cursor = config.activeCursor;
+        }
+    }
+    onEnd() {
+        this.tryResetCursor();
+    }
+    onCancel() {
+        this.tryResetCursor();
+    }
+    onFail() {
+        this.tryResetCursor();
+    }
+    destroy(config) {
+        this.removeContextMenuListeners(config);
+        this.eventManagers.forEach((manager) => {
+            manager.unregisterListeners();
+        });
+    }
+    get view() {
+        return this._view;
+    }
+    set view(value) {
+        this._view = value;
+    }
+}

package/lib/typescript/web/tools/InteractionManager.d.ts

@@ -0,0 +1,17 @@
+import type IGestureHandler from '../handlers/IGestureHandler';
+import { Config } from '../interfaces';
+export default class InteractionManager {
+    private static _instance;
+    private readonly waitForRelations;
+    private readonly simultaneousRelations;
+    private readonly blocksHandlersRelations;
+    private constructor();
+    configureInteractions(handler: IGestureHandler, config: Config): void;
+    shouldWaitForHandlerFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRequireHandlerToWaitForFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldHandlerBeCancelledBy(_handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    dropRelationsForHandlerWithTag(handlerTag: number): void;
+    reset(): void;
+    static get instance(): InteractionManager;
+}

package/lib/typescript/web/tools/InteractionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionManager.d.ts","sourceRoot":"","sources":["../../../../src/web/tools/InteractionManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAW,MAAM,eAAe,CAAC;AAEhD,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;IACrE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAoC;IAC1E,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAoC;IAI5E,OAAO;IAEA,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM;IA6C9D,2BAA2B,CAChC,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,eAAe,GAC5B,OAAO;IAYH,6BAA6B,CAClC,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,eAAe,GAC5B,OAAO;IAWH,oCAAoC,CACzC,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,eAAe,GAC5B,OAAO;IAYH,0BAA0B,CAC/B,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,eAAe,GAC5B,OAAO;IAUH,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAMxD,KAAK;IAMZ,WAAkB,QAAQ,IAAI,kBAAkB,CAM/C;CACF"}