react-native-gesture-handler 2.26.0 → 2.27.1

package/lib/typescript/web/handlers/TapGestureHandler.js

@@ -0,0 +1,202 @@
+import { State } from '../../State';
+import { EventTypes } from '../interfaces';
+import GestureHandler from './GestureHandler';
+const DEFAULT_MAX_DURATION_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 500;
+const DEFAULT_NUMBER_OF_TAPS = 1;
+const DEFAULT_MIN_NUMBER_OF_POINTERS = 1;
+export default class TapGestureHandler extends GestureHandler {
+    maxDeltaX = Number.MIN_SAFE_INTEGER;
+    maxDeltaY = Number.MIN_SAFE_INTEGER;
+    maxDistSq = Number.MIN_SAFE_INTEGER;
+    maxDurationMs = DEFAULT_MAX_DURATION_MS;
+    maxDelayMs = DEFAULT_MAX_DELAY_MS;
+    numberOfTaps = DEFAULT_NUMBER_OF_TAPS;
+    minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS;
+    currentMaxNumberOfPointers = 1;
+    startX = 0;
+    startY = 0;
+    offsetX = 0;
+    offsetY = 0;
+    lastX = 0;
+    lastY = 0;
+    waitTimeout;
+    delayTimeout;
+    tapsSoFar = 0;
+    updateGestureConfig({ enabled = true, ...props }) {
+        super.updateGestureConfig({ enabled: enabled, ...props });
+        if (this.config.numberOfTaps !== undefined) {
+            this.numberOfTaps = this.config.numberOfTaps;
+        }
+        if (this.config.maxDurationMs !== undefined) {
+            this.maxDurationMs = this.config.maxDurationMs;
+        }
+        if (this.config.maxDelayMs !== undefined) {
+            this.maxDelayMs = this.config.maxDelayMs;
+        }
+        if (this.config.maxDeltaX !== undefined) {
+            this.maxDeltaX = this.config.maxDeltaX;
+        }
+        if (this.config.maxDeltaY !== undefined) {
+            this.maxDeltaY = this.config.maxDeltaY;
+        }
+        if (this.config.maxDist !== undefined) {
+            this.maxDistSq = this.config.maxDist * this.config.maxDist;
+        }
+        if (this.config.minPointers !== undefined) {
+            this.minNumberOfPointers = this.config.minPointers;
+        }
+    }
+    resetConfig() {
+        super.resetConfig();
+        this.maxDeltaX = Number.MIN_SAFE_INTEGER;
+        this.maxDeltaY = Number.MIN_SAFE_INTEGER;
+        this.maxDistSq = Number.MIN_SAFE_INTEGER;
+        this.maxDurationMs = DEFAULT_MAX_DURATION_MS;
+        this.maxDelayMs = DEFAULT_MAX_DELAY_MS;
+        this.numberOfTaps = DEFAULT_NUMBER_OF_TAPS;
+        this.minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS;
+    }
+    clearTimeouts() {
+        clearTimeout(this.waitTimeout);
+        clearTimeout(this.delayTimeout);
+    }
+    startTap() {
+        this.clearTimeouts();
+        this.waitTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
+    }
+    endTap() {
+        this.clearTimeouts();
+        if (++this.tapsSoFar === this.numberOfTaps &&
+            this.currentMaxNumberOfPointers >= this.minNumberOfPointers) {
+            this.activate();
+        }
+        else {
+            this.delayTimeout = setTimeout(() => this.fail(), this.maxDelayMs);
+        }
+    }
+    updateLastCoords() {
+        const { x, y } = this.tracker.getAbsoluteCoordsAverage();
+        this.lastX = x;
+        this.lastY = y;
+    }
+    // Handling Events
+    onPointerDown(event) {
+        if (!this.isButtonInConfig(event.button)) {
+            return;
+        }
+        this.tracker.addToTracker(event);
+        super.onPointerDown(event);
+        this.trySettingPosition(event);
+        this.startX = event.x;
+        this.startY = event.y;
+        this.lastX = event.x;
+        this.lastY = event.y;
+        this.updateState(event);
+        this.tryToSendTouchEvent(event);
+    }
+    onPointerAdd(event) {
+        super.onPointerAdd(event);
+        this.tracker.addToTracker(event);
+        this.trySettingPosition(event);
+        this.offsetX += this.lastX - this.startX;
+        this.offsetY += this.lastY - this.startY;
+        this.updateLastCoords();
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+        this.updateState(event);
+    }
+    onPointerUp(event) {
+        super.onPointerUp(event);
+        this.updateLastCoords();
+        this.tracker.removeFromTracker(event.pointerId);
+        this.updateState(event);
+    }
+    onPointerRemove(event) {
+        super.onPointerRemove(event);
+        this.tracker.removeFromTracker(event.pointerId);
+        this.offsetX += this.lastX - this.startX;
+        this.offsetY += this.lastY = this.startY;
+        this.updateLastCoords();
+        this.startX = this.lastX;
+        this.startY = this.lastY;
+        this.updateState(event);
+    }
+    onPointerMove(event) {
+        this.trySettingPosition(event);
+        this.tracker.track(event);
+        this.updateLastCoords();
+        this.updateState(event);
+        super.onPointerMove(event);
+    }
+    onPointerOutOfBounds(event) {
+        this.trySettingPosition(event);
+        this.tracker.track(event);
+        this.updateLastCoords();
+        this.updateState(event);
+        super.onPointerOutOfBounds(event);
+    }
+    updateState(event) {
+        if (this.currentMaxNumberOfPointers < this.tracker.trackedPointersCount) {
+            this.currentMaxNumberOfPointers = this.tracker.trackedPointersCount;
+        }
+        if (this.shouldFail()) {
+            this.fail();
+            return;
+        }
+        switch (this.state) {
+            case State.UNDETERMINED:
+                if (event.eventType === EventTypes.DOWN) {
+                    this.begin();
+                }
+                this.startTap();
+                break;
+            case State.BEGAN:
+                if (event.eventType === EventTypes.UP) {
+                    this.endTap();
+                }
+                if (event.eventType === EventTypes.DOWN) {
+                    this.startTap();
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    trySettingPosition(event) {
+        if (this.state !== State.UNDETERMINED) {
+            return;
+        }
+        this.offsetX = 0;
+        this.offsetY = 0;
+        this.startX = event.x;
+        this.startY = event.y;
+    }
+    shouldFail() {
+        const dx = this.lastX - this.startX + this.offsetX;
+        if (this.maxDeltaX !== Number.MIN_SAFE_INTEGER &&
+            Math.abs(dx) > this.maxDeltaX) {
+            return true;
+        }
+        const dy = this.lastY - this.startY + this.offsetY;
+        if (this.maxDeltaY !== Number.MIN_SAFE_INTEGER &&
+            Math.abs(dy) > this.maxDeltaY) {
+            return true;
+        }
+        const distSq = dy * dy + dx * dx;
+        return (this.maxDistSq !== Number.MIN_SAFE_INTEGER && distSq > this.maxDistSq);
+    }
+    activate() {
+        super.activate();
+        this.end();
+    }
+    onCancel() {
+        this.resetProgress();
+        this.clearTimeouts();
+    }
+    resetProgress() {
+        this.clearTimeouts();
+        this.tapsSoFar = 0;
+        this.currentMaxNumberOfPointers = 0;
+    }
+}

package/lib/typescript/web/interfaces.d.ts

@@ -155,4 +155,3 @@ export type SVGRef = {
     };
 };
 export {};
-//# sourceMappingURL=interfaces.d.ts.map

package/lib/typescript/web/interfaces.js

@@ -0,0 +1,25 @@
+export var EventTypes;
+(function (EventTypes) {
+    EventTypes[EventTypes["DOWN"] = 0] = "DOWN";
+    EventTypes[EventTypes["ADDITIONAL_POINTER_DOWN"] = 1] = "ADDITIONAL_POINTER_DOWN";
+    EventTypes[EventTypes["UP"] = 2] = "UP";
+    EventTypes[EventTypes["ADDITIONAL_POINTER_UP"] = 3] = "ADDITIONAL_POINTER_UP";
+    EventTypes[EventTypes["MOVE"] = 4] = "MOVE";
+    EventTypes[EventTypes["ENTER"] = 5] = "ENTER";
+    EventTypes[EventTypes["LEAVE"] = 6] = "LEAVE";
+    EventTypes[EventTypes["CANCEL"] = 7] = "CANCEL";
+})(EventTypes || (EventTypes = {}));
+export var TouchEventType;
+(function (TouchEventType) {
+    TouchEventType[TouchEventType["UNDETERMINED"] = 0] = "UNDETERMINED";
+    TouchEventType[TouchEventType["DOWN"] = 1] = "DOWN";
+    TouchEventType[TouchEventType["MOVE"] = 2] = "MOVE";
+    TouchEventType[TouchEventType["UP"] = 3] = "UP";
+    TouchEventType[TouchEventType["CANCELLED"] = 4] = "CANCELLED";
+})(TouchEventType || (TouchEventType = {}));
+export var WheelDevice;
+(function (WheelDevice) {
+    WheelDevice[WheelDevice["UNDETERMINED"] = 0] = "UNDETERMINED";
+    WheelDevice[WheelDevice["MOUSE"] = 1] = "MOUSE";
+    WheelDevice[WheelDevice["TOUCHPAD"] = 2] = "TOUCHPAD";
+})(WheelDevice || (WheelDevice = {}));

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

@@ -9,4 +9,3 @@ export default class CircularBuffer<T> {
     clear(): void;
     get size(): number;
 }
-//# sourceMappingURL=CircularBuffer.d.ts.map

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

@@ -0,0 +1,37 @@
+export default class CircularBuffer {
+    capacity;
+    buffer;
+    index;
+    _size;
+    constructor(size) {
+        this.capacity = size;
+        this.buffer = new Array(size);
+        this.index = 0;
+        this._size = 0;
+    }
+    push(element) {
+        this.buffer[this.index] = element;
+        this.index = (this.index + 1) % this.capacity;
+        this._size = Math.min(this.size + 1, this.capacity);
+    }
+    get(at) {
+        if (this._size === this.capacity) {
+            let index = (this.index + at) % this.capacity;
+            if (index < 0) {
+                index += this.capacity;
+            }
+            return this.buffer[index];
+        }
+        else {
+            return this.buffer[at];
+        }
+    }
+    clear() {
+        this.buffer = new Array(this.capacity);
+        this.index = 0;
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+}

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

@@ -37,4 +37,3 @@ export default abstract class EventManager<T> {
     resetManager(): void;
 }
 export {};
-//# sourceMappingURL=EventManager.d.ts.map

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

@@ -22,4 +22,3 @@ export interface GestureHandlerDelegate<TComponent, THandler> {
     onEnabledChange(enabled: boolean): void;
     destroy(config: Config): void;
 }
-//# sourceMappingURL=GestureHandlerDelegate.d.ts.map

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

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

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

@@ -29,4 +29,3 @@ export default class GestureHandlerOrchestrator {
     cancelMouseAndPenGestures(currentHandler: IGestureHandler): void;
     static get instance(): GestureHandlerOrchestrator;
 }
-//# sourceMappingURL=GestureHandlerOrchestrator.d.ts.map

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

@@ -1 +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;IAsBpB,OAAO,CAAC,UAAU;IAYX,yBAAyB,CAAC,cAAc,EAAE,eAAe,GAAG,IAAI;IAwBvE,WAAkB,QAAQ,IAAI,0BAA0B,CAMvD;CACF"}
+{"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

@@ -33,4 +33,3 @@ export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate
     get view(): HTMLElement;
     set view(value: HTMLElement);
 }
-//# sourceMappingURL=GestureHandlerWebDelegate.d.ts.map