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

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

@@ -1,189 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _EventManager = _interopRequireDefault(require("./EventManager"));
-var _gestureHandlerCommon = require("../../handlers/gestureHandlerCommon");
-var _interfaces = require("../interfaces");
-var _utils = require("../utils");
-var _PointerType = require("../../PointerType");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const POINTER_CAPTURE_EXCLUDE_LIST = new Set(['SELECT', 'INPUT']);
-class PointerEventManager extends _EventManager.default {
-  trackedPointers = new Set();
-  mouseButtonsMapper = new Map();
-  constructor(view) {
-    super(view);
-    this.mouseButtonsMapper.set(0, _gestureHandlerCommon.MouseButton.LEFT);
-    this.mouseButtonsMapper.set(1, _gestureHandlerCommon.MouseButton.MIDDLE);
-    this.mouseButtonsMapper.set(2, _gestureHandlerCommon.MouseButton.RIGHT);
-    this.mouseButtonsMapper.set(3, _gestureHandlerCommon.MouseButton.BUTTON_4);
-    this.mouseButtonsMapper.set(4, _gestureHandlerCommon.MouseButton.BUTTON_5);
-    this.lastPosition = {
-      x: -Infinity,
-      y: -Infinity
-    };
-  }
-  pointerDownCallback = event => {
-    if (!(0, _utils.isPointerInBounds)(this.view, {
-      x: event.clientX,
-      y: event.clientY
-    })) {
-      return;
-    }
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.DOWN);
-    const target = event.target;
-    if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.setPointerCapture(adaptedEvent.pointerId);
-    }
-    this.markAsInBounds(adaptedEvent.pointerId);
-    this.trackedPointers.add(adaptedEvent.pointerId);
-    if (++this.activePointersCounter > 1) {
-      adaptedEvent.eventType = _interfaces.EventTypes.ADDITIONAL_POINTER_DOWN;
-      this.onPointerAdd(adaptedEvent);
-    } else {
-      this.onPointerDown(adaptedEvent);
-    }
-  };
-  pointerUpCallback = event => {
-    // When we call reset on gesture handlers, it also resets their event managers
-    // In some handlers (like RotationGestureHandler) reset is called before all pointers leave view
-    // This means, that activePointersCounter will be set to 0, while there are still remaining pointers on view
-    // Removing them will end in activePointersCounter going below 0, therefore handlers won't behave properly
-    if (this.activePointersCounter === 0) {
-      return;
-    }
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.UP);
-    const target = event.target;
-    if (!POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.releasePointerCapture(adaptedEvent.pointerId);
-    }
-    this.markAsOutOfBounds(adaptedEvent.pointerId);
-    this.trackedPointers.delete(adaptedEvent.pointerId);
-    if (--this.activePointersCounter > 0) {
-      adaptedEvent.eventType = _interfaces.EventTypes.ADDITIONAL_POINTER_UP;
-      this.onPointerRemove(adaptedEvent);
-    } else {
-      this.onPointerUp(adaptedEvent);
-    }
-  };
-  pointerMoveCallback = event => {
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.MOVE);
-    const target = event.target;
-
-    // You may be wondering why are we setting pointer capture here, when we
-    // already set it in `pointerdown` handler. Well, that's a great question,
-    // for which I don't have an answer. Specification (https://www.w3.org/TR/pointerevents2/#dom-element-setpointercapture)
-    // says that the requirement for `setPointerCapture` to work is that pointer
-    // must be in 'active buttons state`, otherwise it will fail silently, which
-    // is lovely. Obviously, when `pointerdown` is fired, one of the buttons
-    // (when using mouse) is pressed, but that doesn't mean that `setPointerCapture`
-    // will succeed, for some reason. Since it fails silently, we don't actually know
-    // if it worked or not (there's `gotpointercapture` event, but the complexity of
-    // incorporating it here seems stupid), so we just call it again here, every time
-    // pointer moves until it succeeds.
-    // God, I do love web development.
-    if (!target?.hasPointerCapture(event.pointerId) && !POINTER_CAPTURE_EXCLUDE_LIST.has(target.tagName)) {
-      target.setPointerCapture(event.pointerId);
-    }
-    const inBounds = (0, _utils.isPointerInBounds)(this.view, {
-      x: adaptedEvent.x,
-      y: adaptedEvent.y
-    });
-    const pointerIndex = this.pointersInBounds.indexOf(adaptedEvent.pointerId);
-    if (inBounds) {
-      if (pointerIndex < 0) {
-        adaptedEvent.eventType = _interfaces.EventTypes.ENTER;
-        this.onPointerEnter(adaptedEvent);
-        this.markAsInBounds(adaptedEvent.pointerId);
-      } else {
-        this.onPointerMove(adaptedEvent);
-      }
-    } else {
-      if (pointerIndex >= 0) {
-        adaptedEvent.eventType = _interfaces.EventTypes.LEAVE;
-        this.onPointerLeave(adaptedEvent);
-        this.markAsOutOfBounds(adaptedEvent.pointerId);
-      } else {
-        this.onPointerOutOfBounds(adaptedEvent);
-      }
-    }
-    this.lastPosition.x = event.x;
-    this.lastPosition.y = event.y;
-  };
-  pointerCancelCallback = event => {
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.CANCEL);
-    this.onPointerCancel(adaptedEvent);
-    this.markAsOutOfBounds(adaptedEvent.pointerId);
-    this.activePointersCounter = 0;
-    this.trackedPointers.clear();
-  };
-  pointerEnterCallback = event => {
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.ENTER);
-    this.onPointerMoveOver(adaptedEvent);
-  };
-  pointerLeaveCallback = event => {
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.LEAVE);
-    this.onPointerMoveOut(adaptedEvent);
-  };
-  lostPointerCaptureCallback = event => {
-    const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.CANCEL);
-    if (this.trackedPointers.has(adaptedEvent.pointerId)) {
-      // In some cases the `pointerup` event is not fired, but `lostpointercapture` is.
-      // Here we simulate the `pointercancel` event to make sure the gesture handler stops tracking it.
-      this.onPointerCancel(adaptedEvent);
-      this.activePointersCounter = 0;
-      this.trackedPointers.clear();
-    }
-  };
-  registerListeners() {
-    this.view.addEventListener('pointerdown', this.pointerDownCallback);
-    this.view.addEventListener('pointerup', this.pointerUpCallback);
-    this.view.addEventListener('pointermove', this.pointerMoveCallback);
-    this.view.addEventListener('pointercancel', this.pointerCancelCallback);
-
-    // onPointerEnter and onPointerLeave are triggered by a custom logic responsible for
-    // handling shouldCancelWhenOutside flag, and are unreliable unless the pointer is down.
-    // We therefore use pointerenter and pointerleave events to handle the hover gesture,
-    // mapping them to onPointerMoveOver and onPointerMoveOut respectively.
-    this.view.addEventListener('pointerenter', this.pointerEnterCallback);
-    this.view.addEventListener('pointerleave', this.pointerLeaveCallback);
-    this.view.addEventListener('lostpointercapture', this.lostPointerCaptureCallback);
-  }
-  unregisterListeners() {
-    this.view.removeEventListener('pointerdown', this.pointerDownCallback);
-    this.view.removeEventListener('pointerup', this.pointerUpCallback);
-    this.view.removeEventListener('pointermove', this.pointerMoveCallback);
-    this.view.removeEventListener('pointercancel', this.pointerCancelCallback);
-    this.view.removeEventListener('pointerenter', this.pointerEnterCallback);
-    this.view.removeEventListener('pointerleave', this.pointerLeaveCallback);
-    this.view.removeEventListener('lostpointercapture', this.lostPointerCaptureCallback);
-  }
-  mapEvent(event, eventType) {
-    const rect = this.view.getBoundingClientRect();
-    const {
-      scaleX,
-      scaleY
-    } = (0, _utils.calculateViewScale)(this.view);
-    return {
-      x: event.clientX,
-      y: event.clientY,
-      offsetX: (event.clientX - rect.left) / scaleX,
-      offsetY: (event.clientY - rect.top) / scaleY,
-      pointerId: event.pointerId,
-      eventType: eventType,
-      pointerType: _utils.PointerTypeMapping.get(event.pointerType) ?? _PointerType.PointerType.OTHER,
-      button: this.mouseButtonsMapper.get(event.button),
-      time: event.timeStamp,
-      stylusData: (0, _utils.tryExtractStylusData)(event)
-    };
-  }
-  resetManager() {
-    super.resetManager();
-    this.trackedPointers.clear();
-  }
-}
-exports.default = PointerEventManager;
-//# sourceMappingURL=PointerEventManager.js.map

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

@@ -1,192 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _VelocityTracker = _interopRequireDefault(require("./VelocityTracker"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const MAX_POINTERS = 20;
-class PointerTracker {
-  velocityTracker = new _VelocityTracker.default();
-  _trackedPointers = new Map();
-  touchEventsIds = new Map();
-  cachedAbsoluteAverages = {
-    x: 0,
-    y: 0
-  };
-  cachedRelativeAverages = {
-    x: 0,
-    y: 0
-  };
-  constructor() {
-    this.lastMovedPointerId = NaN;
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-  addToTracker(event) {
-    if (this.trackedPointers.has(event.pointerId)) {
-      return;
-    }
-    this.lastMovedPointerId = event.pointerId;
-    const newElement = {
-      abosoluteCoords: {
-        x: event.x,
-        y: event.y
-      },
-      relativeCoords: {
-        x: event.offsetX,
-        y: event.offsetY
-      },
-      timestamp: event.time,
-      velocityX: 0,
-      velocityY: 0
-    };
-    this.trackedPointers.set(event.pointerId, newElement);
-    this.mapTouchEventId(event.pointerId);
-    this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
-    this.cachedRelativeAverages = this.getRelativeCoordsAverage();
-  }
-  removeFromTracker(pointerId) {
-    this.trackedPointers.delete(pointerId);
-    this.removeMappedTouchId(pointerId);
-  }
-  track(event) {
-    const pointerData = this.trackedPointers.get(event.pointerId);
-    if (!pointerData) {
-      return;
-    }
-    this.lastMovedPointerId = event.pointerId;
-    this.velocityTracker.add(event);
-    const [velocityX, velocityY] = this.velocityTracker.velocity;
-    pointerData.velocityX = velocityX;
-    pointerData.velocityY = velocityY;
-    pointerData.abosoluteCoords = {
-      x: event.x,
-      y: event.y
-    };
-    pointerData.relativeCoords = {
-      x: event.offsetX,
-      y: event.offsetY
-    };
-    this.trackedPointers.set(event.pointerId, pointerData);
-    this.cachedAbsoluteAverages = this.getAbsoluteCoordsAverage();
-    this.cachedRelativeAverages = this.getRelativeCoordsAverage();
-  }
-
-  // Mapping TouchEvents ID
-  mapTouchEventId(id) {
-    for (const [mappedId, touchId] of this.touchEventsIds) {
-      if (isNaN(touchId)) {
-        this.touchEventsIds.set(mappedId, id);
-        break;
-      }
-    }
-  }
-  removeMappedTouchId(id) {
-    const mappedId = this.getMappedTouchEventId(id);
-    if (!isNaN(mappedId)) {
-      this.touchEventsIds.set(mappedId, NaN);
-    }
-  }
-  getMappedTouchEventId(touchEventId) {
-    for (const [key, value] of this.touchEventsIds.entries()) {
-      if (value === touchEventId) {
-        return key;
-      }
-    }
-    return NaN;
-  }
-  getVelocity(pointerId) {
-    const pointerData = this.trackedPointers.get(pointerId);
-    return pointerData ? {
-      x: pointerData.velocityX,
-      y: pointerData.velocityY
-    } : null;
-  }
-  getLastAbsoluteCoords(pointerId) {
-    return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)?.abosoluteCoords;
-  }
-  getLastRelativeCoords(pointerId) {
-    return this.trackedPointers.get(pointerId ?? this.lastMovedPointerId)?.relativeCoords;
-  }
-
-  // Some handlers use these methods to send average values in native event.
-  // This may happen when pointers have already been removed from tracker (i.e. pointerup event).
-  // In situation when NaN would be sent as a response, we return cached value.
-  // That prevents handlers from crashing
-
-  getAbsoluteCoordsAverage() {
-    const coordsSum = this.getAbsoluteCoordsSum();
-    const avgX = coordsSum.x / this.trackedPointers.size;
-    const avgY = coordsSum.y / this.trackedPointers.size;
-    const averages = {
-      x: isNaN(avgX) ? this.cachedAbsoluteAverages.x : avgX,
-      y: isNaN(avgY) ? this.cachedAbsoluteAverages.y : avgY
-    };
-    return averages;
-  }
-  getRelativeCoordsAverage() {
-    const coordsSum = this.getRelativeCoordsSum();
-    const avgX = coordsSum.x / this.trackedPointers.size;
-    const avgY = coordsSum.y / this.trackedPointers.size;
-    const averages = {
-      x: isNaN(avgX) ? this.cachedRelativeAverages.x : avgX,
-      y: isNaN(avgY) ? this.cachedRelativeAverages.y : avgY
-    };
-    return averages;
-  }
-  getAbsoluteCoordsSum(ignoredPointer) {
-    const sum = {
-      x: 0,
-      y: 0
-    };
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sum.x += value.abosoluteCoords.x;
-        sum.y += value.abosoluteCoords.y;
-      }
-    });
-    return sum;
-  }
-  getRelativeCoordsSum(ignoredPointer) {
-    const sum = {
-      x: 0,
-      y: 0
-    };
-    this.trackedPointers.forEach((value, key) => {
-      if (key !== ignoredPointer) {
-        sum.x += value.relativeCoords.x;
-        sum.y += value.relativeCoords.y;
-      }
-    });
-    return sum;
-  }
-  resetTracker() {
-    this.velocityTracker.reset();
-    this.trackedPointers.clear();
-    this.lastMovedPointerId = NaN;
-    for (let i = 0; i < MAX_POINTERS; ++i) {
-      this.touchEventsIds.set(i, NaN);
-    }
-  }
-  static shareCommonPointers(stPointers, ndPointers) {
-    return stPointers.some(pointerId => ndPointers.includes(pointerId));
-  }
-  get trackedPointersCount() {
-    return this.trackedPointers.size;
-  }
-  get trackedPointersIDs() {
-    const keys = [];
-    this.trackedPointers.forEach((_value, key) => {
-      keys.push(key);
-    });
-    return keys;
-  }
-  get trackedPointers() {
-    return this._trackedPointers;
-  }
-}
-exports.default = PointerTracker;
-//# sourceMappingURL=PointerTracker.js.map

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

@@ -1,37 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _Directions = require("../../Directions");
-var _constants = require("../constants");
-class Vector {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-    this._magnitude = Math.hypot(this.x, this.y);
-    const isMagnitudeSufficient = this._magnitude > _constants.MINIMAL_RECOGNIZABLE_MAGNITUDE;
-    this.unitX = isMagnitudeSufficient ? this.x / this._magnitude : 0;
-    this.unitY = isMagnitudeSufficient ? this.y / this._magnitude : 0;
-  }
-  static fromDirection(direction) {
-    return DirectionToVectorMappings.get(direction) ?? new Vector(0, 0);
-  }
-  static fromVelocity(tracker, pointerId) {
-    const velocity = tracker.getVelocity(pointerId);
-    return velocity ? new Vector(velocity.x, velocity.y) : null;
-  }
-  get magnitude() {
-    return this._magnitude;
-  }
-  computeSimilarity(vector) {
-    return this.unitX * vector.unitX + this.unitY * vector.unitY;
-  }
-  isSimilar(vector, threshold) {
-    return this.computeSimilarity(vector) > threshold;
-  }
-}
-exports.default = Vector;
-const DirectionToVectorMappings = new Map([[_Directions.Directions.LEFT, new Vector(-1, 0)], [_Directions.Directions.RIGHT, new Vector(1, 0)], [_Directions.Directions.UP, new Vector(0, -1)], [_Directions.Directions.DOWN, new Vector(0, 1)], [_Directions.DiagonalDirections.UP_RIGHT, new Vector(1, -1)], [_Directions.DiagonalDirections.DOWN_RIGHT, new Vector(1, 1)], [_Directions.DiagonalDirections.UP_LEFT, new Vector(-1, -1)], [_Directions.DiagonalDirections.DOWN_LEFT, new Vector(-1, 1)]]);
-//# sourceMappingURL=Vector.js.map

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

@@ -1,85 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _CircularBuffer = _interopRequireDefault(require("./CircularBuffer"));
-var _LeastSquareSolver = _interopRequireDefault(require("./LeastSquareSolver"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class VelocityTracker {
-  assumePointerMoveStoppedMilliseconds = 40;
-  historySize = 20;
-  horizonMilliseconds = 300;
-  minSampleSize = 3;
-  constructor() {
-    this.samples = new _CircularBuffer.default(this.historySize);
-  }
-  add(event) {
-    this.samples.push(event);
-  }
-
-  // Returns an estimate of the velocity of the object being tracked by the
-  // tracker given the current information available to the tracker.
-  //
-  // Information is added using [addPosition].
-  //
-  // Returns null if there is no data on which to base an estimate.
-  getVelocityEstimate() {
-    const x = [];
-    const y = [];
-    const w = [];
-    const time = [];
-    let sampleCount = 0;
-    let index = this.samples.size - 1;
-    const newestSample = this.samples.get(index);
-    if (!newestSample) {
-      return null;
-    }
-    let previousSample = newestSample;
-
-    // Starting with the most recent PointAtTime sample, iterate backwards while
-    // the samples represent continuous motion.
-    while (sampleCount < this.samples.size) {
-      const sample = this.samples.get(index);
-      const age = newestSample.time - sample.time;
-      const delta = Math.abs(sample.time - previousSample.time);
-      previousSample = sample;
-      if (age > this.horizonMilliseconds || delta > this.assumePointerMoveStoppedMilliseconds) {
-        break;
-      }
-      x.push(sample.x);
-      y.push(sample.y);
-      w.push(1);
-      time.push(-age);
-      sampleCount++;
-      index--;
-    }
-    if (sampleCount >= this.minSampleSize) {
-      const xSolver = new _LeastSquareSolver.default(time, x, w);
-      const xFit = xSolver.solve(2);
-      if (xFit !== null) {
-        const ySolver = new _LeastSquareSolver.default(time, y, w);
-        const yFit = ySolver.solve(2);
-        if (yFit !== null) {
-          const xVelocity = xFit.coefficients[1] * 1000;
-          const yVelocity = yFit.coefficients[1] * 1000;
-          return [xVelocity, yVelocity];
-        }
-      }
-    }
-    return null;
-  }
-  get velocity() {
-    const estimate = this.getVelocityEstimate();
-    if (estimate !== null) {
-      return estimate;
-    }
-    return [0, 0];
-  }
-  reset() {
-    this.samples.clear();
-  }
-}
-exports.default = VelocityTracker;
-//# sourceMappingURL=VelocityTracker.js.map

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

@@ -1,55 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _EventManager = _interopRequireDefault(require("./EventManager"));
-var _interfaces = require("../interfaces");
-var _PointerType = require("../../PointerType");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-class WheelEventManager extends _EventManager.default {
-  wheelDelta = {
-    x: 0,
-    y: 0
-  };
-  resetDelta = _event => {
-    this.wheelDelta = {
-      x: 0,
-      y: 0
-    };
-  };
-  wheelCallback = event => {
-    this.wheelDelta.x += event.deltaX;
-    this.wheelDelta.y += event.deltaY;
-    const adaptedEvent = this.mapEvent(event);
-    this.onWheel(adaptedEvent);
-  };
-  registerListeners() {
-    this.view.addEventListener('pointermove', this.resetDelta);
-    this.view.addEventListener('wheel', this.wheelCallback);
-  }
-  unregisterListeners() {
-    this.view.removeEventListener('pointermove', this.resetDelta);
-    this.view.removeEventListener('wheel', this.wheelCallback);
-  }
-  mapEvent(event) {
-    return {
-      x: event.clientX + this.wheelDelta.x,
-      y: event.clientY + this.wheelDelta.y,
-      offsetX: event.offsetX - event.deltaX,
-      offsetY: event.offsetY - event.deltaY,
-      pointerId: -1,
-      eventType: _interfaces.EventTypes.MOVE,
-      pointerType: _PointerType.PointerType.OTHER,
-      time: event.timeStamp,
-      // @ts-ignore It does exist, but it's deprecated
-      wheelDeltaY: event.wheelDeltaY
-    };
-  }
-  resetManager() {
-    super.resetManager();
-  }
-}
-exports.default = WheelEventManager;
-//# sourceMappingURL=WheelEventManager.js.map