@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

package/src/web/handlers/RotationGestureHandler.ts

@@ -1,172 +0,0 @@
-import { State } from '../../State';
-import { AdaptedEvent, Config } from '../interfaces';
-
-import GestureHandler from './GestureHandler';
-import RotationGestureDetector, {
-  RotationGestureListener,
-} from '../detectors/RotationGestureDetector';
-
-const ROTATION_RECOGNITION_THRESHOLD = Math.PI / 36;
-
-export default class RotationGestureHandler extends GestureHandler {
-  private rotation = 0;
-  private velocity = 0;
-
-  private cachedAnchorX = 0;
-  private cachedAnchorY = 0;
-
-  private rotationGestureListener: RotationGestureListener = {
-    onRotationBegin: (_detector: RotationGestureDetector): boolean => true,
-    onRotation: (detector: RotationGestureDetector): boolean => {
-      const previousRotation: number = this.rotation;
-      this.rotation += detector.getRotation();
-
-      const delta = detector.getTimeDelta();
-
-      if (delta > 0) {
-        this.velocity = (this.rotation - previousRotation) / delta;
-      }
-
-      if (
-        Math.abs(this.rotation) >= ROTATION_RECOGNITION_THRESHOLD &&
-        this.currentState === State.BEGAN
-      ) {
-        this.activate();
-      }
-
-      return true;
-    },
-    onRotationEnd: (_detector: RotationGestureDetector): void => {
-      this.end();
-    },
-  };
-
-  private rotationGestureDetector: RotationGestureDetector =
-    new RotationGestureDetector(this.rotationGestureListener);
-
-  public init(ref: number, propsRef: React.RefObject<unknown>): void {
-    super.init(ref, propsRef);
-
-    this.setShouldCancelWhenOutside(false);
-  }
-
-  public updateGestureConfig({ enabled = true, ...props }: Config): void {
-    super.updateGestureConfig({ enabled: enabled, ...props });
-  }
-
-  protected transformNativeEvent() {
-    return {
-      rotation: this.rotation ? this.rotation : 0,
-      anchorX: this.getAnchorX(),
-      anchorY: this.getAnchorY(),
-      velocity: this.velocity ? this.velocity : 0,
-    };
-  }
-
-  public getAnchorX(): number {
-    const anchorX = this.rotationGestureDetector.getAnchorX();
-
-    return anchorX ? anchorX : this.cachedAnchorX;
-  }
-
-  public getAnchorY(): number {
-    const anchorY = this.rotationGestureDetector.getAnchorY();
-
-    return anchorY ? anchorY : this.cachedAnchorY;
-  }
-
-  protected onPointerDown(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-  }
-
-  protected onPointerAdd(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerAdd(event);
-
-    this.tryBegin();
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    if (this.tracker.getTrackedPointersCount() < 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);
-  }
-
-  protected onPointerOutOfBounds(event: AdaptedEvent): void {
-    if (this.tracker.getTrackedPointersCount() < 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);
-  }
-
-  protected onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.tracker.removeFromTracker(event.pointerId);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-
-    if (this.currentState !== State.ACTIVE) {
-      return;
-    }
-
-    if (this.currentState === State.ACTIVE) {
-      this.end();
-    } else {
-      this.fail();
-    }
-  }
-
-  protected onPointerRemove(event: AdaptedEvent): void {
-    super.onPointerRemove(event);
-    this.rotationGestureDetector.onTouchEvent(event, this.tracker);
-    this.tracker.removeFromTracker(event.pointerId);
-  }
-
-  protected tryBegin(): void {
-    if (this.currentState !== State.UNDETERMINED) {
-      return;
-    }
-
-    this.begin();
-  }
-
-  public activate(_force?: boolean): void {
-    super.activate();
-  }
-
-  protected onReset(): void {
-    if (this.currentState === State.ACTIVE) {
-      return;
-    }
-
-    this.rotation = 0;
-    this.velocity = 0;
-    this.rotationGestureDetector.reset();
-  }
-}

package/src/web/handlers/TapGestureHandler.ts

@@ -1,273 +0,0 @@
-import { State } from '../../State';
-import { AdaptedEvent, Config, 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 {
-  private maxDeltaX = Number.MIN_SAFE_INTEGER;
-  private maxDeltaY = Number.MIN_SAFE_INTEGER;
-  private maxDistSq = Number.MIN_SAFE_INTEGER;
-  private maxDurationMs = DEFAULT_MAX_DURATION_MS;
-  private maxDelayMs = DEFAULT_MAX_DELAY_MS;
-
-  private numberOfTaps = DEFAULT_NUMBER_OF_TAPS;
-  private minNumberOfPointers = DEFAULT_MIN_NUMBER_OF_POINTERS;
-  private currentMaxNumberOfPointers = 1;
-
-  private startX = 0;
-  private startY = 0;
-  private offsetX = 0;
-  private offsetY = 0;
-  private lastX = 0;
-  private lastY = 0;
-
-  private waitTimeout: number | undefined;
-  private delayTimeout: number | undefined;
-
-  private tapsSoFar = 0;
-
-  public init(ref: number, propsRef: React.RefObject<unknown>): void {
-    super.init(ref, propsRef);
-  }
-
-  public updateGestureConfig({ enabled = true, ...props }: Config): void {
-    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;
-    }
-  }
-
-  protected resetConfig(): void {
-    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;
-  }
-
-  private clearTimeouts(): void {
-    clearTimeout(this.waitTimeout);
-    clearTimeout(this.delayTimeout);
-  }
-
-  private startTap(): void {
-    this.clearTimeouts();
-
-    this.waitTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
-  }
-
-  private endTap(): void {
-    this.clearTimeouts();
-
-    if (
-      ++this.tapsSoFar === this.numberOfTaps &&
-      this.currentMaxNumberOfPointers >= this.minNumberOfPointers
-    ) {
-      this.activate();
-    } else {
-      this.delayTimeout = setTimeout(() => this.fail(), this.maxDelayMs);
-    }
-  }
-
-  //Handling Events
-  protected onPointerDown(event: AdaptedEvent): void {
-    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);
-  }
-
-  protected onPointerAdd(event: AdaptedEvent): void {
-    super.onPointerAdd(event);
-    this.tracker.addToTracker(event);
-    this.trySettingPosition(event);
-
-    this.offsetX += this.lastX - this.startX;
-    this.offsetY += this.lastY - this.startY;
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.startX = this.tracker.getLastAvgX();
-    this.startY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-  }
-
-  protected onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.tracker.removeFromTracker(event.pointerId);
-
-    this.updateState(event);
-  }
-
-  protected onPointerRemove(event: AdaptedEvent): void {
-    super.onPointerRemove(event);
-    this.tracker.removeFromTracker(event.pointerId);
-
-    this.offsetX += this.lastX - this.startX;
-    this.offsetY += this.lastY = this.startY;
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.startX = this.lastX;
-    this.startY = this.lastY;
-
-    this.updateState(event);
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    this.trySettingPosition(event);
-    this.tracker.track(event);
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-
-    super.onPointerMove(event);
-  }
-
-  protected onPointerOutOfBounds(event: AdaptedEvent): void {
-    this.trySettingPosition(event);
-    this.tracker.track(event);
-
-    this.lastX = this.tracker.getLastAvgX();
-    this.lastY = this.tracker.getLastAvgY();
-
-    this.updateState(event);
-
-    super.onPointerOutOfBounds(event);
-  }
-
-  private updateState(event: AdaptedEvent): void {
-    if (
-      this.currentMaxNumberOfPointers < this.tracker.getTrackedPointersCount()
-    ) {
-      this.currentMaxNumberOfPointers = this.tracker.getTrackedPointersCount();
-    }
-
-    if (this.shouldFail()) {
-      this.fail();
-      return;
-    }
-
-    switch (this.currentState) {
-      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;
-    }
-  }
-
-  private trySettingPosition(event: AdaptedEvent): void {
-    if (this.currentState !== State.UNDETERMINED) {
-      return;
-    }
-
-    this.offsetX = 0;
-    this.offsetY = 0;
-    this.startX = event.x;
-    this.startY = event.y;
-  }
-
-  private shouldFail(): boolean {
-    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
-    );
-  }
-
-  public activate(): void {
-    super.activate();
-
-    this.end();
-  }
-
-  protected onCancel(): void {
-    this.resetProgress();
-    this.clearTimeouts();
-  }
-
-  protected resetProgress(): void {
-    this.clearTimeouts();
-    this.tapsSoFar = 0;
-    this.currentMaxNumberOfPointers = 0;
-  }
-}

package/src/web/interfaces.ts

@@ -1,167 +0,0 @@
-import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';
-import { Directions } from '../Directions';
-import { State } from '../State';
-
-export interface HitSlop {
-  left?: number;
-  right?: number;
-  top?: number;
-  bottom?: number;
-  horizontal?: number;
-  vertical?: number;
-  width?: number;
-  height?: number;
-}
-
-export interface Handler {
-  handlerTag: number;
-}
-
-type ConfigArgs =
-  | number
-  | boolean
-  | HitSlop
-  | UserSelect
-  | ActiveCursor
-  | Directions
-  | Handler[]
-  | null
-  | undefined;
-
-export interface Config extends Record<string, ConfigArgs> {
-  enabled?: boolean;
-  simultaneousHandlers?: Handler[] | null;
-  waitFor?: Handler[] | null;
-  blocksHandlers?: Handler[] | null;
-  hitSlop?: HitSlop;
-  shouldCancelWhenOutside?: boolean;
-  userSelect?: UserSelect;
-  activeCursor?: ActiveCursor;
-
-  activateAfterLongPress?: number;
-  failOffsetXStart?: number;
-  failOffsetYStart?: number;
-  failOffsetXEnd?: number;
-  failOffsetYEnd?: number;
-  activeOffsetXStart?: number;
-  activeOffsetXEnd?: number;
-  activeOffsetYStart?: number;
-  activeOffsetYEnd?: number;
-  minPointers?: number;
-  maxPointers?: number;
-  minDist?: number;
-  minDistSq?: number;
-  minVelocity?: number;
-  minVelocityX?: number;
-  minVelocityY?: number;
-  minVelocitySq?: number;
-  maxDist?: number;
-  maxDistSq?: number;
-  numberOfPointers?: number;
-  minDurationMs?: number;
-  numberOfTaps?: number;
-  maxDurationMs?: number;
-  maxDelayMs?: number;
-  maxDeltaX?: number;
-  maxDeltaY?: number;
-  shouldActivateOnStart?: boolean;
-  disallowInterruption?: boolean;
-  direction?: Directions;
-}
-
-type NativeEventArgs = number | State | boolean | undefined;
-interface NativeEvent extends Record<string, NativeEventArgs> {
-  numberOfPointers: number;
-  state: State;
-  pointerInside: boolean | undefined;
-  handlerTag: number;
-  target: number;
-  oldState?: State;
-}
-
-export interface PointerData {
-  id: number;
-  x: number;
-  y: number;
-  absoluteX: number;
-  absoluteY: number;
-}
-
-type TouchNativeArgs = number | State | TouchEventType | PointerData[];
-
-interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
-  handlerTag: number;
-  state: State;
-  eventType: TouchEventType;
-  changedTouches: PointerData[];
-  allTouches: PointerData[];
-  numberOfTouches: number;
-}
-
-export interface ResultEvent extends Record<string, NativeEvent | number> {
-  nativeEvent: NativeEvent;
-  timeStamp: number;
-}
-
-export interface ResultTouchEvent
-  extends Record<string, NativeTouchEvent | number> {
-  nativeEvent: NativeTouchEvent;
-  timeStamp: number;
-}
-
-export interface PropsRef {
-  onGestureHandlerEvent: () => void;
-  onGestureHandlerStateChange: () => void;
-}
-
-export interface AdaptedEvent {
-  x: number;
-  y: number;
-  offsetX: number;
-  offsetY: number;
-  pointerId: number;
-  eventType: EventTypes;
-  pointerType: PointerType;
-  buttons: number;
-  time: number;
-  allTouches?: TouchList;
-  changedTouches?: TouchList;
-  touchEventType?: TouchEventType;
-}
-
-export enum MouseButtons {
-  NONE,
-  LEFT,
-  RIGHT,
-  LEFT_RIGHT,
-  SCROLL,
-  SCROLL_LEFT,
-  SCROLL_RIGHT,
-  SCROLL_LEFT_RIGHT,
-}
-
-export enum EventTypes {
-  DOWN,
-  ADDITIONAL_POINTER_DOWN,
-  UP,
-  ADDITIONAL_POINTER_UP,
-  MOVE,
-  ENTER,
-  LEAVE,
-  CANCEL,
-}
-
-export enum TouchEventType {
-  UNDETERMINED,
-  DOWN,
-  MOVE,
-  UP,
-  CANCELLED,
-}
-
-export enum PointerType {
-  NONE = 'none',
-  MOUSE = 'mouse',
-  TOUCH = 'touch',
-  PEN = 'pen',
-}

package/src/web/tools/EventManager.ts

@@ -1,104 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
-
-export default abstract class EventManager<T> {
-  protected readonly view: T;
-  protected pointersInBounds: number[] = [];
-  protected activePointersCounter: number;
-
-  constructor(view: T) {
-    this.view = view;
-    this.activePointersCounter = 0;
-  }
-
-  public abstract setListeners(): void;
-  protected abstract mapEvent(
-    event: Event,
-    eventType: EventTypes,
-    index?: number,
-    touchEventType?: TouchEventType
-  ): AdaptedEvent;
-
-  protected onPointerDown(_event: AdaptedEvent): void {}
-  protected onPointerAdd(_event: AdaptedEvent): void {}
-  protected onPointerUp(_event: AdaptedEvent): void {}
-  protected onPointerRemove(_event: AdaptedEvent): void {}
-  protected onPointerMove(_event: AdaptedEvent): void {}
-  protected onPointerLeave(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)
-  protected onPointerEnter(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)
-  protected onPointerCancel(_event: AdaptedEvent): void {
-    // 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
-  }
-  protected onPointerOutOfBounds(_event: AdaptedEvent): void {}
-  protected onPointerMoveOver(_event: AdaptedEvent): void {}
-  protected onPointerMoveOut(_event: AdaptedEvent): void {}
-
-  public setOnPointerDown(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerDown = callback;
-  }
-  public setOnPointerAdd(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerAdd = callback;
-  }
-  public setOnPointerUp(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerUp = callback;
-  }
-  public setOnPointerRemove(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerRemove = callback;
-  }
-  public setOnPointerMove(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerMove = callback;
-  }
-  public setOnPointerLeave(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerLeave = callback;
-  }
-  public setOnPointerEnter(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerEnter = callback;
-  }
-  public setOnPointerCancel(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerCancel = callback;
-  }
-  public setOnPointerOutOfBounds(
-    callback: (event: AdaptedEvent) => void
-  ): void {
-    this.onPointerOutOfBounds = callback;
-  }
-  public setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerMoveOver = callback;
-  }
-  public setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void {
-    this.onPointerMoveOut = callback;
-  }
-
-  protected markAsInBounds(pointerId: number): void {
-    if (this.pointersInBounds.indexOf(pointerId) >= 0) {
-      return;
-    }
-
-    this.pointersInBounds.push(pointerId);
-  }
-
-  protected markAsOutOfBounds(pointerId: number): void {
-    const index: number = this.pointersInBounds.indexOf(pointerId);
-
-    if (index < 0) {
-      return;
-    }
-
-    this.pointersInBounds.splice(index, 1);
-  }
-
-  public resetManager(): void {
-    // 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 = [];
-  }
-}