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

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

@@ -1,116 +0,0 @@
-"use strict";
-
-import { State } from '../../State';
-import { DEFAULT_TOUCH_SLOP } from '../constants';
-import GestureHandler from './GestureHandler';
-import ScaleGestureDetector from '../detectors/ScaleGestureDetector';
-export default class PinchGestureHandler extends GestureHandler {
-  scale = 1;
-  velocity = 0;
-  startingSpan = 0;
-  spanSlop = DEFAULT_TOUCH_SLOP;
-  scaleDetectorListener = {
-    onScaleBegin: detector => {
-      this.startingSpan = detector.currentSpan;
-      return true;
-    },
-    onScale: detector => {
-      const prevScaleFactor = this.scale;
-      this.scale *= detector.calculateScaleFactor(this.tracker.trackedPointersCount);
-      const delta = detector.timeDelta;
-      if (delta > 0) {
-        this.velocity = (this.scale - prevScaleFactor) / delta;
-      }
-      if (Math.abs(this.startingSpan - detector.currentSpan) >= this.spanSlop && this.state === State.BEGAN) {
-        this.activate();
-      }
-      return true;
-    },
-    onScaleEnd: _detector => {}
-  };
-  scaleGestureDetector = new ScaleGestureDetector(this.scaleDetectorListener);
-  init(ref, propsRef) {
-    super.init(ref, propsRef);
-    this.shouldCancelWhenOutside = false;
-  }
-  transformNativeEvent() {
-    return {
-      focalX: this.scaleGestureDetector.focusX,
-      focalY: this.scaleGestureDetector.focusY,
-      velocity: this.velocity,
-      scale: this.scale
-    };
-  }
-  onPointerDown(event) {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerAdd(event) {
-    this.tracker.addToTracker(event);
-    super.onPointerAdd(event);
-    this.tryBegin();
-    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
-  }
-  onPointerUp(event) {
-    super.onPointerUp(event);
-    this.tracker.removeFromTracker(event.pointerId);
-    if (this.state !== State.ACTIVE) {
-      return;
-    }
-    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
-    if (this.state === State.ACTIVE) {
-      this.end();
-    } else {
-      this.fail();
-    }
-  }
-  onPointerRemove(event) {
-    super.onPointerRemove(event);
-    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
-    this.tracker.removeFromTracker(event.pointerId);
-    if (this.state === State.ACTIVE && this.tracker.trackedPointersCount < 2) {
-      this.end();
-    }
-  }
-  onPointerMove(event) {
-    if (this.tracker.trackedPointersCount < 2) {
-      return;
-    }
-    this.tracker.track(event);
-    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
-    super.onPointerMove(event);
-  }
-  onPointerOutOfBounds(event) {
-    if (this.tracker.trackedPointersCount < 2) {
-      return;
-    }
-    this.tracker.track(event);
-    this.scaleGestureDetector.onTouchEvent(event, this.tracker);
-    super.onPointerOutOfBounds(event);
-  }
-  tryBegin() {
-    if (this.state !== State.UNDETERMINED) {
-      return;
-    }
-    this.resetProgress();
-    this.begin();
-  }
-  activate(force) {
-    if (this.state !== State.ACTIVE) {
-      this.resetProgress();
-    }
-    super.activate(force);
-  }
-  onReset() {
-    this.resetProgress();
-  }
-  resetProgress() {
-    if (this.state === State.ACTIVE) {
-      return;
-    }
-    this.velocity = 0;
-    this.scale = 1;
-  }
-}
-//# sourceMappingURL=PinchGestureHandler.js.map

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

@@ -1,123 +0,0 @@
-"use strict";
-
-import { State } from '../../State';
-import GestureHandler from './GestureHandler';
-import RotationGestureDetector from '../detectors/RotationGestureDetector';
-const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
-export default class RotationGestureHandler extends GestureHandler {
-  rotation = 0;
-  velocity = 0;
-  cachedAnchorX = 0;
-  cachedAnchorY = 0;
-  rotationGestureListener = {
-    onRotationBegin: _detector => true,
-    onRotation: detector => {
-      const previousRotation = this.rotation;
-      this.rotation += detector.rotation;
-      const delta = detector.timeDelta;
-      if (delta > 0) {
-        this.velocity = (this.rotation - previousRotation) / delta;
-      }
-      if (Math.abs(this.rotation) >= ROTATION_RECOGNITION_THRESHOLD && this.state === State.BEGAN) {
-        this.activate();
-      }
-      return true;
-    },
-    onRotationEnd: _detector => {
-      this.end();
-    }
-  };
-  rotationGestureDetector = new RotationGestureDetector(this.rotationGestureListener);
-  init(ref, propsRef) {
-    super.init(ref, propsRef);
-    this.shouldCancelWhenOutside = false;
-  }
-  transformNativeEvent() {
-    return {
-      rotation: this.rotation ? this.rotation : 0,
-      anchorX: this.getAnchorX(),
-      anchorY: this.getAnchorY(),
-      velocity: this.velocity ? this.velocity : 0
-    };
-  }
-  getAnchorX() {
-    const anchorX = this.rotationGestureDetector.anchorX;
-    return anchorX ? anchorX : this.cachedAnchorX;
-  }
-  getAnchorY() {
-    const anchorY = this.rotationGestureDetector.anchorY;
-    return anchorY ? anchorY : this.cachedAnchorY;
-  }
-  onPointerDown(event) {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-    this.tryToSendTouchEvent(event);
-  }
-  onPointerAdd(event) {
-    this.tracker.addToTracker(event);
-    super.onPointerAdd(event);
-    this.tryBegin();
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-  }
-  onPointerMove(event) {
-    if (this.tracker.trackedPointersCount < 2) {
-      return;
-    }
-    if (this.getAnchorX()) {
-      this.cachedAnchorX = this.getAnchorX();
-    }
-    if (this.getAnchorY()) {
-      this.cachedAnchorY = this.getAnchorY();
-    }
-    this.tracker.track(event);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-    super.onPointerMove(event);
-  }
-  onPointerOutOfBounds(event) {
-    if (this.tracker.trackedPointersCount < 2) {
-      return;
-    }
-    if (this.getAnchorX()) {
-      this.cachedAnchorX = this.getAnchorX();
-    }
-    if (this.getAnchorY()) {
-      this.cachedAnchorY = this.getAnchorY();
-    }
-    this.tracker.track(event);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-    super.onPointerOutOfBounds(event);
-  }
-  onPointerUp(event) {
-    super.onPointerUp(event);
-    this.tracker.removeFromTracker(event.pointerId);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-    if (this.state !== State.ACTIVE) {
-      return;
-    }
-    if (this.state === State.ACTIVE) {
-      this.end();
-    } else {
-      this.fail();
-    }
-  }
-  onPointerRemove(event) {
-    super.onPointerRemove(event);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-    this.tracker.removeFromTracker(event.pointerId);
-  }
-  tryBegin() {
-    if (this.state !== State.UNDETERMINED) {
-      return;
-    }
-    this.begin();
-  }
-  onReset() {
-    if (this.state === State.ACTIVE) {
-      return;
-    }
-    this.rotation = 0;
-    this.velocity = 0;
-    this.rotationGestureDetector.reset();
-  }
-}
-//# sourceMappingURL=RotationGestureHandler.js.map

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

@@ -1,209 +0,0 @@
-"use strict";
-
-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;
-  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;
-  }
-}
-//# sourceMappingURL=TapGestureHandler.js.map

package/lib/module/web/interfaces.js

@@ -1,28 +0,0 @@
-"use strict";
-
-export let 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;
-}({});
-export let 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;
-}({});
-export let 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/module/web/tools/CircularBuffer.js

@@ -1,35 +0,0 @@
-"use strict";
-
-export default 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;
-  }
-}
-//# sourceMappingURL=CircularBuffer.js.map

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

@@ -1,89 +0,0 @@
-"use strict";
-
-/* eslint-disable @typescript-eslint/no-empty-function */
-
-export default 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 = [];
-  }
-}
-//# sourceMappingURL=EventManager.js.map

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

@@ -1,4 +0,0 @@
-"use strict";
-
-export {};
-//# sourceMappingURL=GestureHandlerDelegate.js.map