react-native-gesture-handler 2.4.1 → 2.6.0

package/lib/module/web/detectors/ScaleGestureDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ScaleGestureDetector.ts"],"names":["DEFAULT_TOUCH_SLOP","EventTypes","ScaleGestureDetector","constructor","callbacks","onScaleBegin","onScale","onScaleEnd","spanSlop","minSpan","onTouchEvent","event","tracker","adaptEvent","currentTime","time","action","eventType","numOfPointers","getTrackedPointersCount","streamComplete","UP","ADDITIONAL_POINTER_UP","CANCEL","DOWN","inProgress","initialSpan","configChanged","ADDITIONAL_POINTER_DOWN","pointerUp","ignoredPointer","pointerId","undefined","div","sumX","getSumX","sumY","getSumY","focusX","focusY","devSumX","devSumY","getData","forEach","value","key","Math","abs","lastX","lastY","devX","devY","spanX","spanY","span","hypot","wasInProgress","prevSpan","currentSpan","prevTime","MOVE","getCurrentSpan","getFocusX","getFocusY","getTimeDelta","getScaleFactor"],"mappings":"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","sourcesContent":["import { DEFAULT_TOUCH_SLOP } from '../constants';\nimport { AdaptedPointerEvent, EventTypes } from '../interfaces';\n\nimport PointerTracker from '../tools/PointerTracker';\n\nexport interface ScaleGestureListener {\n  onScaleBegin: (detector: ScaleGestureDetector) => boolean;\n  onScale: (\n    detector: ScaleGestureDetector,\n    event: AdaptedPointerEvent\n  ) => boolean;\n  onScaleEnd: (\n    detector: ScaleGestureDetector,\n    event: AdaptedPointerEvent\n  ) => void;\n}\n\nexport default class ScaleGestureDetector implements ScaleGestureListener {\n  public onScaleBegin: (detector: ScaleGestureDetector) => boolean;\n  public onScale: (\n    detector: ScaleGestureDetector,\n    event: AdaptedPointerEvent\n  ) => boolean;\n  public onScaleEnd: (\n    detector: ScaleGestureDetector,\n    event: AdaptedPointerEvent\n  ) => void;\n\n  private focusX!: number;\n  private focusY!: number;\n\n  private currentSpan!: number;\n  private prevSpan!: number;\n  private initialSpan!: number;\n\n  private currentTime!: number;\n  private prevTime!: number;\n\n  private inProgress = false;\n\n  private spanSlop: number;\n  private minSpan: number;\n\n  public constructor(callbacks: ScaleGestureListener) {\n    this.onScaleBegin = callbacks.onScaleBegin;\n    this.onScale = callbacks.onScale;\n    this.onScaleEnd = callbacks.onScaleEnd;\n\n    this.spanSlop = DEFAULT_TOUCH_SLOP * 2;\n    this.minSpan = 0;\n  }\n\n  public onTouchEvent(\n    event: AdaptedPointerEvent,\n    tracker: PointerTracker\n  ): boolean {\n    this.adaptEvent(event, tracker);\n\n    this.currentTime = event.time;\n\n    const action: EventTypes = event.eventType;\n    const numOfPointers = tracker.getTrackedPointersCount();\n\n    const streamComplete: boolean =\n      action === EventTypes.UP ||\n      action === EventTypes.ADDITIONAL_POINTER_UP ||\n      action === EventTypes.CANCEL;\n\n    if (action === EventTypes.DOWN || streamComplete) {\n      if (this.inProgress) {\n        this.onScaleEnd(this, event);\n        this.inProgress = false;\n        this.initialSpan = 0;\n      }\n\n      if (streamComplete) {\n        return true;\n      }\n    }\n\n    const configChanged: boolean =\n      action === EventTypes.DOWN ||\n      action === EventTypes.ADDITIONAL_POINTER_UP ||\n      action === EventTypes.ADDITIONAL_POINTER_DOWN;\n\n    const pointerUp = action === EventTypes.ADDITIONAL_POINTER_UP;\n\n    const ignoredPointer: number | undefined = pointerUp\n      ? event.pointerId\n      : undefined;\n\n    //Determine focal point\n\n    const div: number = pointerUp ? numOfPointers - 1 : numOfPointers;\n\n    const sumX = tracker.getSumX(ignoredPointer);\n    const sumY = tracker.getSumY(ignoredPointer);\n\n    const focusX = sumX / div;\n    const focusY = sumY / div;\n\n    //Determine average deviation from focal point\n\n    let devSumX = 0;\n    let devSumY = 0;\n\n    tracker.getData().forEach((value, key) => {\n      if (key === ignoredPointer) {\n        return;\n      }\n\n      devSumX += Math.abs(value.lastX - focusX);\n      devSumY += Math.abs(value.lastY - focusY);\n    });\n\n    const devX: number = devSumX / div;\n    const devY: number = devSumY / div;\n\n    const spanX: number = devX * 2;\n    const spanY: number = devY * 2;\n\n    const span = Math.hypot(spanX, spanY);\n\n    //Begin/end events\n    const wasInProgress: boolean = this.inProgress;\n    this.focusX = focusX;\n    this.focusY = focusY;\n\n    if (this.inProgress && (span < this.minSpan || configChanged)) {\n      this.onScaleEnd(this, event);\n      this.inProgress = false;\n      this.initialSpan = span;\n    }\n\n    if (configChanged) {\n      this.initialSpan = this.prevSpan = this.currentSpan = span;\n    }\n\n    if (\n      !this.inProgress &&\n      span >= this.minSpan &&\n      (wasInProgress || Math.abs(span - this.initialSpan) > this.spanSlop)\n    ) {\n      this.prevSpan = this.currentSpan = span;\n      this.prevTime = this.currentTime;\n      this.inProgress = this.onScaleBegin(this);\n    }\n\n    //Handle motion\n    if (action !== EventTypes.MOVE) {\n      return true;\n    }\n\n    this.currentSpan = span;\n\n    if (this.inProgress && !this.onScale(this, event)) {\n      return true;\n    }\n\n    this.prevSpan = this.currentSpan;\n    this.prevTime = this.currentTime;\n\n    return true;\n  }\n\n  private adaptEvent(\n    event: AdaptedPointerEvent,\n    tracker: PointerTracker\n  ): void {\n    if (\n      tracker.getTrackedPointersCount() > 1 &&\n      event.eventType === EventTypes.DOWN\n    ) {\n      event.eventType = EventTypes.ADDITIONAL_POINTER_DOWN;\n    }\n\n    if (\n      tracker.getTrackedPointersCount() > 1 &&\n      event.eventType === EventTypes.UP\n    ) {\n      event.eventType = EventTypes.ADDITIONAL_POINTER_UP;\n    }\n  }\n\n  public getCurrentSpan(): number {\n    return this.currentSpan;\n  }\n\n  public getFocusX(): number {\n    return this.focusX;\n  }\n\n  public getFocusY(): number {\n    return this.focusY;\n  }\n\n  public getTimeDelta(): number {\n    return this.currentTime - this.prevTime;\n  }\n\n  public getScaleFactor(numOfPointers: number): number {\n    if (numOfPointers < 2) {\n      return 1;\n    }\n\n    return this.prevSpan > 0 ? this.currentSpan / this.prevSpan : 1;\n  }\n}\n"]}

package/lib/module/web/handlers/FlingGestureHandler.js

@@ -0,0 +1,139 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { State } from '../../State';
+import { Direction } from '../constants';
+import GestureHandler from './GestureHandler';
+const DEFAULT_MAX_DURATION_MS = 800;
+const DEFAULT_MIN_ACCEPTABLE_DELTA = 160;
+const DEFAULT_DIRECTION = Direction.RIGHT;
+const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
+export default class FlingGestureHandler extends GestureHandler {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "numberOfPointersRequired", DEFAULT_NUMBER_OF_TOUCHES_REQUIRED);
+
+    _defineProperty(this, "direction", DEFAULT_DIRECTION);
+
+    _defineProperty(this, "maxDurationMs", DEFAULT_MAX_DURATION_MS);
+
+    _defineProperty(this, "minAcceptableDelta", DEFAULT_MIN_ACCEPTABLE_DELTA);
+
+    _defineProperty(this, "delayTimeout", void 0);
+
+    _defineProperty(this, "startX", 0);
+
+    _defineProperty(this, "startY", 0);
+
+    _defineProperty(this, "maxNumberOfPointersSimultaneously", 0);
+  }
+
+  init(ref, propsRef) {
+    super.init(ref, propsRef);
+  }
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    super.updateGestureConfig({
+      enabled: enabled,
+      ...props
+    });
+    this.enabled = enabled;
+
+    if (this.config.direction) {
+      this.direction = this.config.direction;
+    }
+
+    if (this.config.numberOfPointers) {
+      this.numberOfPointersRequired = this.config.numberOfPointers;
+    }
+  }
+
+  transformNativeEvent(event) {
+    return {
+      x: event.offsetX,
+      y: event.offsetY,
+      absoluteX: event.x,
+      absoluteY: event.y
+    };
+  }
+
+  startFling(event) {
+    this.startX = event.x;
+    this.startY = event.y;
+    this.begin(event);
+    this.maxNumberOfPointersSimultaneously = 1;
+    this.delayTimeout = setTimeout(() => this.fail(event), this.maxDurationMs);
+  }
+
+  tryEndFling(event) {
+    if (this.maxNumberOfPointersSimultaneously === this.numberOfPointersRequired && (this.direction & Direction.RIGHT && event.x - this.startX > this.minAcceptableDelta || this.direction & Direction.LEFT && this.startX - event.x > this.minAcceptableDelta || this.direction & Direction.UP && this.startY - event.y > this.minAcceptableDelta || this.direction & Direction.DOWN && event.y - this.startY > this.minAcceptableDelta)) {
+      clearTimeout(this.delayTimeout);
+      this.activate(event);
+      return true;
+    }
+
+    return false;
+  }
+
+  endFling(event) {
+    if (!this.tryEndFling(event)) {
+      this.fail(event);
+    }
+  }
+
+  onPointerDown(event) {
+    super.onPointerDown(event);
+    this.tracker.addToTracker(event);
+
+    if (this.currentState === State.UNDETERMINED) {
+      this.startFling(event);
+    }
+
+    if (this.currentState !== State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling(event);
+
+    if (this.tracker.getTrackedPointersCount() > this.maxNumberOfPointersSimultaneously) {
+      this.maxNumberOfPointersSimultaneously = this.tracker.getTrackedPointersCount();
+    }
+  }
+
+  onPointerMove(event) {
+    this.tracker.track(event);
+
+    if (this.currentState !== State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling(event);
+    super.onPointerMove(event);
+  }
+
+  onPointerUp(event) {
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState !== State.BEGAN) {
+      return;
+    }
+
+    this.endFling(event);
+  }
+
+  activate(event, force) {
+    super.activate(event, force);
+    this.end(event);
+  }
+
+  resetConfig() {
+    super.resetConfig();
+    this.numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
+    this.direction = DEFAULT_DIRECTION;
+  }
+
+}
+//# sourceMappingURL=FlingGestureHandler.js.map

package/lib/module/web/handlers/FlingGestureHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["FlingGestureHandler.ts"],"names":["State","Direction","GestureHandler","DEFAULT_MAX_DURATION_MS","DEFAULT_MIN_ACCEPTABLE_DELTA","DEFAULT_DIRECTION","RIGHT","DEFAULT_NUMBER_OF_TOUCHES_REQUIRED","FlingGestureHandler","init","ref","propsRef","updateGestureConfig","enabled","props","config","direction","numberOfPointers","numberOfPointersRequired","transformNativeEvent","event","x","offsetX","y","offsetY","absoluteX","absoluteY","startFling","startX","startY","begin","maxNumberOfPointersSimultaneously","delayTimeout","setTimeout","fail","maxDurationMs","tryEndFling","minAcceptableDelta","LEFT","UP","DOWN","clearTimeout","activate","endFling","onPointerDown","tracker","addToTracker","currentState","UNDETERMINED","BEGAN","getTrackedPointersCount","onPointerMove","track","onPointerUp","removeFromTracker","pointerId","force","end","resetConfig"],"mappings":"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","sourcesContent":["import { State } from '../../State';\nimport { Direction } from '../constants';\nimport { AdaptedPointerEvent } from '../interfaces';\n\nimport GestureHandler from './GestureHandler';\n\nconst DEFAULT_MAX_DURATION_MS = 800;\nconst DEFAULT_MIN_ACCEPTABLE_DELTA = 160;\nconst DEFAULT_DIRECTION = Direction.RIGHT;\nconst DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;\n\nexport default class FlingGestureHandler extends GestureHandler {\n  private numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;\n  private direction = DEFAULT_DIRECTION;\n\n  private maxDurationMs = DEFAULT_MAX_DURATION_MS;\n  private minAcceptableDelta = DEFAULT_MIN_ACCEPTABLE_DELTA;\n  private delayTimeout!: number;\n\n  private startX = 0;\n  private startY = 0;\n\n  private maxNumberOfPointersSimultaneously = 0;\n\n  public init(ref: number, propsRef: React.RefObject<unknown>): void {\n    super.init(ref, propsRef);\n  }\n\n  public updateGestureConfig({ enabled = true, ...props }): void {\n    super.updateGestureConfig({ enabled: enabled, ...props });\n\n    this.enabled = enabled;\n\n    if (this.config.direction) {\n      this.direction = this.config.direction;\n    }\n\n    if (this.config.numberOfPointers) {\n      this.numberOfPointersRequired = this.config.numberOfPointers;\n    }\n  }\n\n  protected transformNativeEvent(event: AdaptedPointerEvent) {\n    return {\n      x: event.offsetX,\n      y: event.offsetY,\n      absoluteX: event.x,\n      absoluteY: event.y,\n    };\n  }\n\n  private startFling(event: AdaptedPointerEvent): void {\n    this.startX = event.x;\n    this.startY = event.y;\n\n    this.begin(event);\n\n    this.maxNumberOfPointersSimultaneously = 1;\n\n    this.delayTimeout = setTimeout(() => this.fail(event), this.maxDurationMs);\n  }\n\n  private tryEndFling(event: AdaptedPointerEvent): boolean {\n    if (\n      this.maxNumberOfPointersSimultaneously ===\n        this.numberOfPointersRequired &&\n      ((this.direction & Direction.RIGHT &&\n        event.x - this.startX > this.minAcceptableDelta) ||\n        (this.direction & Direction.LEFT &&\n          this.startX - event.x > this.minAcceptableDelta) ||\n        (this.direction & Direction.UP &&\n          this.startY - event.y > this.minAcceptableDelta) ||\n        (this.direction & Direction.DOWN &&\n          event.y - this.startY > this.minAcceptableDelta))\n    ) {\n      clearTimeout(this.delayTimeout);\n      this.activate(event);\n\n      return true;\n    }\n\n    return false;\n  }\n\n  private endFling(event: AdaptedPointerEvent) {\n    if (!this.tryEndFling(event)) {\n      this.fail(event);\n    }\n  }\n\n  protected onPointerDown(event: AdaptedPointerEvent): void {\n    super.onPointerDown(event);\n\n    this.tracker.addToTracker(event);\n\n    if (this.currentState === State.UNDETERMINED) {\n      this.startFling(event);\n    }\n\n    if (this.currentState !== State.BEGAN) {\n      return;\n    }\n\n    this.tryEndFling(event);\n\n    if (\n      this.tracker.getTrackedPointersCount() >\n      this.maxNumberOfPointersSimultaneously\n    ) {\n      this.maxNumberOfPointersSimultaneously = this.tracker.getTrackedPointersCount();\n    }\n  }\n\n  protected onPointerMove(event: AdaptedPointerEvent): void {\n    this.tracker.track(event);\n\n    if (this.currentState !== State.BEGAN) {\n      return;\n    }\n\n    this.tryEndFling(event);\n\n    super.onPointerMove(event);\n  }\n\n  protected onPointerUp(event: AdaptedPointerEvent): void {\n    this.tracker.removeFromTracker(event.pointerId);\n\n    if (this.currentState !== State.BEGAN) {\n      return;\n    }\n\n    this.endFling(event);\n  }\n\n  protected activate(event: AdaptedPointerEvent, force?: boolean): void {\n    super.activate(event, force);\n    this.end(event);\n  }\n\n  protected resetConfig(): void {\n    super.resetConfig();\n    this.numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;\n    this.direction = DEFAULT_DIRECTION;\n  }\n}\n"]}

package/lib/module/web/handlers/GestureHandler.js

@@ -0,0 +1,521 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { findNodeHandle } from 'react-native';
+import { State } from '../../State';
+import EventManager from '../tools/EventManager';
+import GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';
+import PointerTracker from '../tools/PointerTracker';
+export default class GestureHandler {
+  // Orchestrator properties
+  constructor() {
+    _defineProperty(this, "lastSentState", null);
+
+    _defineProperty(this, "currentState", State.UNDETERMINED);
+
+    _defineProperty(this, "shouldCancellWhenOutside", false);
+
+    _defineProperty(this, "hasCustomActivationCriteria", void 0);
+
+    _defineProperty(this, "enabled", false);
+
+    _defineProperty(this, "ref", void 0);
+
+    _defineProperty(this, "propsRef", void 0);
+
+    _defineProperty(this, "config", {
+      enabled: false
+    });
+
+    _defineProperty(this, "handlerTag", void 0);
+
+    _defineProperty(this, "view", null);
+
+    _defineProperty(this, "eventManager", void 0);
+
+    _defineProperty(this, "tracker", new PointerTracker());
+
+    _defineProperty(this, "interactionManager", void 0);
+
+    _defineProperty(this, "activationIndex", 0);
+
+    _defineProperty(this, "awaiting", false);
+
+    _defineProperty(this, "active", false);
+
+    _defineProperty(this, "shouldResetProgress", false);
+
+    _defineProperty(this, "sendEvent", (event, newState, oldState) => {
+      const {
+        onGestureHandlerEvent,
+        onGestureHandlerStateChange
+      } = this.propsRef.current;
+      const resultEvent = this.transformEventData(event, newState, oldState); // In the new API oldState field has to be undefined, unless we send event state changed
+      // Here the order is flipped to avoid workarounds such as making backup of the state and setting it to undefined first, then changing it back
+      // Flipping order with setting oldState to undefined solves issue, when events were being sent twice instead of once
+      // However, this may cause trouble in the future (but for now we don't know that)
+
+      if (this.lastSentState !== newState) {
+        this.lastSentState = newState;
+        invokeNullableMethod(onGestureHandlerStateChange, resultEvent);
+      }
+
+      if (this.currentState === State.ACTIVE) {
+        resultEvent.nativeEvent.oldState = undefined;
+        invokeNullableMethod(onGestureHandlerEvent, resultEvent);
+      }
+    });
+
+    this.hasCustomActivationCriteria = false;
+  } //
+  // Initializing handler
+  //
+
+
+  init(ref, propsRef) {
+    this.propsRef = propsRef;
+    this.ref = ref;
+    this.currentState = State.UNDETERMINED;
+    this.setView(ref);
+    this.setEventManager();
+  }
+
+  setView(ref) {
+    if (!ref) {
+      this.view = null;
+      return;
+    }
+
+    this.view = findNodeHandle(ref);
+    this.view.style['touchAction'] = 'none';
+    this.view.style['webkitUserSelect'] = 'none';
+    this.view.style['userSelect'] = 'none'; //@ts-ignore This one disables default events on Safari
+
+    this.view.style['WebkitTouchCallout'] = 'none';
+  }
+
+  setEventManager() {
+    if (!this.view) {
+      return;
+    }
+
+    this.eventManager = new EventManager(this.view);
+    this.eventManager.setOnPointerDown(this.onPointerDown.bind(this));
+    this.eventManager.setOnPointerUp(this.onPointerUp.bind(this));
+    this.eventManager.setOnPointerMove(this.onPointerMove.bind(this));
+    this.eventManager.setOnPointerEnter(this.onPointerEnter.bind(this));
+    this.eventManager.setOnPointerOut(this.onPointerOut.bind(this));
+    this.eventManager.setOnPointerCancel(this.onPointerCancel.bind(this));
+    this.eventManager.setOnPointerOutOfBounds(this.onPointerOutOfBounds.bind(this));
+    this.eventManager.setListeners();
+  }
+
+  setInteractionManager(manager) {
+    this.interactionManager = manager;
+  } //
+  // Resetting handler
+  //
+
+
+  onCancel() {}
+
+  onReset() {}
+
+  resetProgress() {}
+
+  reset() {
+    this.tracker.resetTracker();
+    this.onReset();
+    this.currentState = State.UNDETERMINED;
+  } //
+  // State logic
+  //
+
+
+  moveToState(newState, event) {
+    if (this.currentState === newState) {
+      return;
+    }
+
+    const oldState = this.currentState;
+    this.currentState = newState;
+    GestureHandlerOrchestrator.getInstance().onHandlerStateChange(this, newState, oldState, event);
+    this.onStateChange(newState, oldState);
+  }
+
+  onStateChange(_newState, _oldState) {}
+
+  begin(event) {
+    if (!this.checkHitSlop(event)) {
+      return;
+    }
+
+    if (this.currentState === State.UNDETERMINED) {
+      this.moveToState(State.BEGAN, event);
+    }
+  }
+
+  fail(event) {
+    if (this.currentState === State.ACTIVE || this.currentState === State.BEGAN) {
+      this.moveToState(State.FAILED, event);
+    }
+
+    this.resetProgress();
+  }
+
+  cancel(event) {
+    if (this.currentState === State.ACTIVE || this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+      this.onCancel();
+      this.moveToState(State.CANCELLED, event);
+    }
+  }
+
+  activate(event, _force = false) {
+    if (this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+      this.moveToState(State.ACTIVE, event);
+    }
+  }
+
+  end(event) {
+    if (this.currentState === State.BEGAN || this.currentState === State.ACTIVE) {
+      this.moveToState(State.END, event);
+    }
+
+    this.resetProgress();
+  } //
+  // Methods for orchestrator
+  //
+
+
+  isAwaiting() {
+    return this.awaiting;
+  }
+
+  setAwaiting(value) {
+    this.awaiting = value;
+  }
+
+  isActive() {
+    return this.active;
+  }
+
+  setActive(value) {
+    this.active = value;
+  }
+
+  getShouldResetProgress() {
+    return this.shouldResetProgress;
+  }
+
+  setShouldResetProgress(value) {
+    this.shouldResetProgress = value;
+  }
+
+  getActivationIndex() {
+    return this.activationIndex;
+  }
+
+  setActivationIndex(value) {
+    this.activationIndex = value;
+  }
+
+  shouldWaitForHandlerFailure(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return this.interactionManager.shouldWaitForHandlerFailure(this, handler);
+  }
+
+  shouldRequireToWaitForFailure(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return this.interactionManager.shouldRequireHandlerToWaitForFailure(this, handler);
+  }
+
+  shouldRecognizeSimultaneously(handler) {
+    if (handler === this) {
+      return true;
+    }
+
+    return this.interactionManager.shouldRecognizeSimultaneously(this, handler);
+  }
+
+  shouldBeCancelledByOther(handler) {
+    if (handler === this) {
+      return false;
+    }
+
+    return this.interactionManager.shouldHandlerBeCancelledBy(this, handler);
+  } //
+  // Event actions
+  //
+
+
+  onPointerDown(_event) {
+    GestureHandlerOrchestrator.getInstance().recordHandlerIfNotPresent(this);
+  } // Adding another pointer to existing ones
+
+
+  onPointerAdd(_event) {}
+
+  onPointerUp(_event) {} // Removing pointer, when there is more than one pointers
+
+
+  onPointerRemove(_event) {}
+
+  onPointerMove(event) {
+    this.tryToSendMoveEvent(event, false);
+  }
+
+  onPointerOut(_event) {}
+
+  onPointerEnter(_event) {}
+
+  onPointerCancel(_event) {}
+
+  onPointerOutOfBounds(event) {
+    this.tryToSendMoveEvent(event, true);
+  }
+
+  tryToSendMoveEvent(event, out) {
+    if (this.currentState === State.ACTIVE && (!out || out && !this.shouldCancellWhenOutside)) {
+      this.sendEvent(event, this.currentState, this.currentState);
+    }
+  } //
+  // Events Sending
+  //
+
+
+  transformEventData(event, newState, oldState) {
+    var _this$eventManager;
+
+    return {
+      nativeEvent: {
+        numberOfPointers: this.tracker.getTrackedPointersCount(),
+        state: newState,
+        pointerInside: (_this$eventManager = this.eventManager) === null || _this$eventManager === void 0 ? void 0 : _this$eventManager.isPointerInBounds({
+          x: event.x,
+          y: event.y
+        }),
+        ...this.transformNativeEvent(event),
+        handlerTag: this.handlerTag,
+        target: this.ref,
+        oldState: newState !== oldState ? oldState : undefined
+      },
+      timeStamp: Date.now()
+    };
+  }
+
+  transformNativeEvent(_event) {
+    return {};
+  } //
+  // Handling config
+  //
+
+
+  updateGestureConfig({
+    enabled = true,
+    ...props
+  }) {
+    this.config = {
+      enabled,
+      ...props
+    };
+    this.validateHitSlops();
+  }
+
+  checkCustomActivationCriteria(criterias) {
+    for (const key in this.config) {
+      if (criterias.indexOf(key) >= 0) {
+        this.hasCustomActivationCriteria = true;
+      }
+    }
+  }
+
+  validateHitSlops() {
+    if (!this.config.hitSlop) {
+      return;
+    }
+
+    if (this.config.hitSlop.left !== undefined && this.config.hitSlop.right !== undefined && this.config.hitSlop.width !== undefined) {
+      throw new Error('HitSlop Error: Cannot define left, right and width at the same time');
+    }
+
+    if (this.config.hitSlop.width !== undefined && this.config.hitSlop.left === undefined && this.config.hitSlop.right === undefined) {
+      throw new Error('HitSlop Error: When width is defined, either left or right has to be defined');
+    }
+
+    if (this.config.hitSlop.height !== undefined && this.config.hitSlop.top !== undefined && this.config.hitSlop.bottom !== undefined) {
+      throw new Error('HitSlop Error: Cannot define top, bottom and height at the same time');
+    }
+
+    if (this.config.hitSlop.height !== undefined && this.config.hitSlop.top === undefined && this.config.hitSlop.bottom === undefined) {
+      throw new Error('HitSlop Error: When height is defined, either top or bottom has to be defined');
+    }
+  }
+
+  checkHitSlop(event) {
+    if (!this.config.hitSlop || !this.view) {
+      return true;
+    }
+
+    const width = this.view.getBoundingClientRect().width;
+    const height = this.view.getBoundingClientRect().height;
+    let left = 0;
+    let top = 0;
+    let right = width;
+    let bottom = height;
+
+    if (this.config.hitSlop.horizontal !== undefined) {
+      left -= this.config.hitSlop.horizontal;
+      right += this.config.hitSlop.horizontal;
+    }
+
+    if (this.config.hitSlop.vertical !== undefined) {
+      top -= this.config.hitSlop.vertical;
+      bottom += this.config.hitSlop.vertical;
+    }
+
+    if (this.config.hitSlop.left !== undefined) {
+      left = -this.config.hitSlop.left;
+    }
+
+    if (this.config.hitSlop.right !== undefined) {
+      right = width + this.config.hitSlop.right;
+    }
+
+    if (this.config.hitSlop.top !== undefined) {
+      top = -this.config.hitSlop.top;
+    }
+
+    if (this.config.hitSlop.bottom !== undefined) {
+      bottom = width + this.config.hitSlop.bottom;
+    }
+
+    if (this.config.hitSlop.width !== undefined) {
+      if (this.config.hitSlop.left !== undefined) {
+        right = left + this.config.hitSlop.width;
+      } else if (this.config.hitSlop.right !== undefined) {
+        left = right - this.config.hitSlop.width;
+      }
+    }
+
+    if (this.config.hitSlop.height !== undefined) {
+      if (this.config.hitSlop.top !== undefined) {
+        bottom = top + this.config.hitSlop.height;
+      } else if (this.config.hitSlop.bottom !== undefined) {
+        top = bottom - this.config.hitSlop.height;
+      }
+    }
+
+    if (event.offsetX >= left && event.offsetX <= right && event.offsetY >= top && event.offsetY <= bottom) {
+      return true;
+    }
+
+    return false;
+  }
+
+  resetConfig() {} //
+  // Getters and setters
+  //
+
+
+  getTag() {
+    return this.handlerTag;
+  }
+
+  setTag(tag) {
+    this.handlerTag = tag;
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  getShouldEnableGestureOnSetup() {
+    throw new Error('Must override GestureHandler.shouldEnableGestureOnSetup');
+  }
+
+  getView() {
+    return this.view;
+  }
+
+  getEventManager() {
+    return this.eventManager;
+  }
+
+  getTracker() {
+    return this.tracker;
+  }
+
+  getTrackedPointersID() {
+    return this.tracker.getTrackedPointersID();
+  }
+
+  getState() {
+    return this.currentState;
+  }
+
+  setShouldCancelWhenOutside(flag) {
+    this.shouldCancellWhenOutside = flag;
+  }
+
+  getShouldCancelWhenOutside() {
+    return this.shouldCancellWhenOutside;
+  }
+
+}
+
+function invokeNullableMethod(method, event) {
+  if (!method) {
+    return;
+  }
+
+  if (typeof method === 'function') {
+    method(event);
+    return;
+  }
+
+  if ('__getHandler' in method && typeof method.__getHandler === 'function') {
+    const handler = method.__getHandler();
+
+    invokeNullableMethod(handler, event);
+    return;
+  }
+
+  if (!('__nodeConfig' in method)) {
+    return;
+  }
+
+  const {
+    argMapping
+  } = method.__nodeConfig;
+
+  if (!Array.isArray(argMapping)) {
+    return;
+  }
+
+  for (const [index, [key, value]] of argMapping.entries()) {
+    if (!(key in event.nativeEvent)) {
+      continue;
+    } // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+
+    const nativeValue = event.nativeEvent[key]; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
+    if (value !== null && value !== void 0 && value.setValue) {
+      //Reanimated API
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+      value.setValue(nativeValue);
+    } else {
+      //RN Animated API
+      method.__nodeConfig.argMapping[index] = [key, nativeValue];
+    }
+  }
+
+  return;
+}
+//# sourceMappingURL=GestureHandler.js.map