@amazon-devices/react-native-gesture-handler 4.0.1 → 4.0.2

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

@@ -1,215 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _State = require("../../State");
-var _interfaces = require("../interfaces");
-var _GestureHandler = _interopRequireDefault(require("./GestureHandler"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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;
-class TapGestureHandler extends _GestureHandler.default {
-  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;
-  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.State.UNDETERMINED:
-        if (event.eventType === _interfaces.EventTypes.DOWN) {
-          this.begin();
-        }
-        this.startTap();
-        break;
-      case _State.State.BEGAN:
-        if (event.eventType === _interfaces.EventTypes.UP) {
-          this.endTap();
-        }
-        if (event.eventType === _interfaces.EventTypes.DOWN) {
-          this.startTap();
-        }
-        break;
-      default:
-        break;
-    }
-  }
-  trySettingPosition(event) {
-    if (this.state !== _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;
-  }
-}
-exports.default = TapGestureHandler;
-//# sourceMappingURL=TapGestureHandler.js.map

package/lib/commonjs/web/interfaces.js

@@ -1,32 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WheelDevice = exports.TouchEventType = exports.EventTypes = void 0;
-let EventTypes = exports.EventTypes = /*#__PURE__*/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";
-  return EventTypes;
-}({});
-let TouchEventType = exports.TouchEventType = /*#__PURE__*/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";
-  return TouchEventType;
-}({});
-let WheelDevice = exports.WheelDevice = /*#__PURE__*/function (WheelDevice) {
-  WheelDevice[WheelDevice["UNDETERMINED"] = 0] = "UNDETERMINED";
-  WheelDevice[WheelDevice["MOUSE"] = 1] = "MOUSE";
-  WheelDevice[WheelDevice["TOUCHPAD"] = 2] = "TOUCHPAD";
-  return WheelDevice;
-}({});
-//# sourceMappingURL=interfaces.js.map

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

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-class CircularBuffer {
-  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;
-  }
-}
-exports.default = CircularBuffer;
-//# sourceMappingURL=CircularBuffer.js.map

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

@@ -1,94 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-class EventManager {
-  pointersInBounds = [];
-  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 = [];
-  }
-}
-exports.default = EventManager;
-//# sourceMappingURL=EventManager.js.map

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

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=GestureHandlerDelegate.js.map

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

@@ -1,267 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _PointerType = require("../../PointerType");
-var _State = require("../../State");
-var _PointerTracker = _interopRequireDefault(require("./PointerTracker"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class GestureHandlerOrchestrator {
-  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.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.State.CANCELLED || handlerState === _State.State.FAILED) {
-      return;
-    }
-    if (this.shouldActivate(handler)) {
-      this.makeActive(handler);
-      return;
-    }
-    if (handlerState === _State.State.ACTIVE) {
-      handler.fail();
-      return;
-    }
-    if (handlerState === _State.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.State.END) {
-          this.tryActivate(otherHandler);
-          continue;
-        }
-        otherHandler.cancel();
-        if (otherHandler.state === _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.State.CANCELLED, _State.State.BEGAN);
-        }
-        otherHandler.awaiting = false;
-      }
-    }
-    if (newState === _State.State.ACTIVE) {
-      this.tryActivate(handler);
-    } else if (oldState === _State.State.ACTIVE || oldState === _State.State.END) {
-      if (handler.active) {
-        handler.sendEvent(newState, oldState);
-      } else if (oldState === _State.State.ACTIVE && (newState === _State.State.CANCELLED || newState === _State.State.FAILED)) {
-        handler.sendEvent(newState, _State.State.BEGAN);
-      }
-    } else if (oldState !== _State.State.UNDETERMINED || newState !== _State.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.State.ACTIVE, _State.State.BEGAN);
-    if (currentState !== _State.State.ACTIVE) {
-      handler.sendEvent(_State.State.END, _State.State.ACTIVE);
-      if (currentState !== _State.State.END) {
-        handler.sendEvent(_State.State.UNDETERMINED, _State.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.State.ACTIVE) {
-      return handler.shouldBeCancelledByOther(otherHandler);
-    }
-    const handlerPointers = handler.getTrackedPointersID();
-    const otherPointers = otherHandler.getTrackedPointersID();
-    if (!_PointerTracker.default.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.State.END || state === _State.State.FAILED || state === _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.PointerType.MOUSE && handler.pointerType !== _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;
-  }
-}
-exports.default = GestureHandlerOrchestrator;
-//# sourceMappingURL=GestureHandlerOrchestrator.js.map