react-native-gesture-handler 2.27.1 → 2.27.2

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

@@ -1,202 +0,0 @@
-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.js

@@ -1,25 +0,0 @@
-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.js

@@ -1,37 +0,0 @@
-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.js

@@ -1,85 +0,0 @@
-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.js

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

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

@@ -1,273 +0,0 @@
-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;
-    }
-}