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

package/src/web/handlers/HoverGestureHandler.ts

@@ -1,49 +0,0 @@
-import { State } from '../../State';
-import { AdaptedEvent, StylusData } from '../interfaces';
-import GestureHandlerOrchestrator from '../tools/GestureHandlerOrchestrator';
-import GestureHandler from './GestureHandler';
-
-export default class HoverGestureHandler extends GestureHandler {
-  private stylusData: StylusData | undefined;
-
-  protected transformNativeEvent(): Record<string, unknown> {
-    return {
-      ...super.transformNativeEvent(),
-      stylusData: this.stylusData,
-    };
-  }
-
-  protected onPointerMoveOver(event: AdaptedEvent): void {
-    GestureHandlerOrchestrator.instance.recordHandlerIfNotPresent(this);
-
-    this.tracker.addToTracker(event);
-    this.stylusData = event.stylusData;
-    super.onPointerMoveOver(event);
-
-    if (this.state === State.UNDETERMINED) {
-      this.begin();
-      this.activate();
-    }
-  }
-
-  protected onPointerMoveOut(event: AdaptedEvent): void {
-    this.tracker.removeFromTracker(event.pointerId);
-    this.stylusData = event.stylusData;
-
-    super.onPointerMoveOut(event);
-
-    this.end();
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    this.tracker.track(event);
-    this.stylusData = event.stylusData;
-
-    super.onPointerMove(event);
-  }
-
-  protected onPointerCancel(event: AdaptedEvent): void {
-    super.onPointerCancel(event);
-    this.reset();
-  }
-}

package/src/web/handlers/IGestureHandler.ts

@@ -1,49 +0,0 @@
-import type { PointerType } from '../../PointerType';
-import type { MouseButton } from '../../handlers/gestureHandlerCommon';
-import type { State } from '../../State';
-import type { Config } from '../interfaces';
-import type EventManager from '../tools/EventManager';
-import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import type PointerTracker from '../tools/PointerTracker';
-
-export default interface IGestureHandler {
-  active: boolean;
-  activationIndex: number;
-  awaiting: boolean;
-  handlerTag: number;
-  readonly config: Config;
-  readonly delegate: GestureHandlerDelegate<unknown, this>;
-  readonly tracker: PointerTracker;
-  state: State;
-  shouldCancelWhenOutside: boolean;
-  shouldResetProgress: boolean;
-  enabled: boolean;
-  pointerType: PointerType;
-
-  attachEventManager: (manager: EventManager<unknown>) => void;
-
-  isButtonInConfig: (
-    mouseButton: MouseButton | undefined
-  ) => boolean | number | undefined;
-
-  getTrackedPointersID: () => number[];
-
-  begin: () => void;
-  activate: (force: boolean) => void;
-  end: () => void;
-  fail: () => void;
-  cancel: () => void;
-
-  reset: () => void;
-
-  shouldWaitForHandlerFailure: (handler: IGestureHandler) => boolean;
-  shouldRequireToWaitForFailure: (handler: IGestureHandler) => boolean;
-  shouldRecognizeSimultaneously: (handler: IGestureHandler) => boolean;
-  shouldBeCancelledByOther: (handler: IGestureHandler) => boolean;
-
-  sendEvent: (newState: State, oldState: State) => void;
-
-  updateGestureConfig: (config: Config) => void;
-
-  isButton?: () => boolean;
-}

package/src/web/handlers/LongPressGestureHandler.ts

@@ -1,175 +0,0 @@
-import { State } from '../../State';
-import { AdaptedEvent, Config } from '../interfaces';
-
-import GestureHandler from './GestureHandler';
-
-const DEFAULT_MIN_DURATION_MS = 500;
-const DEFAULT_MAX_DIST_DP = 10;
-const SCALING_FACTOR = 10;
-
-export default class LongPressGestureHandler extends GestureHandler {
-  private minDurationMs = DEFAULT_MIN_DURATION_MS;
-  private defaultMaxDistSq = DEFAULT_MAX_DIST_DP * SCALING_FACTOR;
-
-  private maxDistSq = this.defaultMaxDistSq;
-  private numberOfPointers = 1;
-  private startX = 0;
-  private startY = 0;
-
-  private startTime = 0;
-  private previousTime = 0;
-
-  private activationTimeout: number | undefined;
-
-  public init(ref: number, propsRef: React.RefObject<unknown>) {
-    if (this.config.enableContextMenu === undefined) {
-      this.config.enableContextMenu = false;
-    }
-
-    super.init(ref, propsRef);
-  }
-
-  protected transformNativeEvent() {
-    return {
-      ...super.transformNativeEvent(),
-      duration: Date.now() - this.startTime,
-    };
-  }
-
-  public updateGestureConfig({ enabled = true, ...props }: Config): void {
-    super.updateGestureConfig({ enabled: enabled, ...props });
-
-    if (this.config.minDurationMs !== undefined) {
-      this.minDurationMs = this.config.minDurationMs;
-    }
-
-    if (this.config.maxDist !== undefined) {
-      this.maxDistSq = this.config.maxDist * this.config.maxDist;
-    }
-
-    if (this.config.numberOfPointers !== undefined) {
-      this.numberOfPointers = this.config.numberOfPointers;
-    }
-  }
-
-  protected resetConfig(): void {
-    super.resetConfig();
-    this.minDurationMs = DEFAULT_MIN_DURATION_MS;
-    this.maxDistSq = this.defaultMaxDistSq;
-  }
-
-  protected onStateChange(_newState: State, _oldState: State): void {
-    clearTimeout(this.activationTimeout);
-  }
-
-  protected onPointerDown(event: AdaptedEvent): void {
-    if (!this.isButtonInConfig(event.button)) {
-      return;
-    }
-
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-
-    this.startX = event.x;
-    this.startY = event.y;
-
-    this.tryBegin();
-    this.tryActivate();
-
-    this.tryToSendTouchEvent(event);
-  }
-  protected onPointerAdd(event: AdaptedEvent): void {
-    super.onPointerAdd(event);
-    this.tracker.addToTracker(event);
-
-    if (this.tracker.trackedPointersCount > this.numberOfPointers) {
-      this.fail();
-      return;
-    }
-
-    const absoluteCoordsAverage = this.tracker.getAbsoluteCoordsAverage();
-
-    this.startX = absoluteCoordsAverage.x;
-    this.startY = absoluteCoordsAverage.y;
-
-    this.tryActivate();
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    super.onPointerMove(event);
-    this.tracker.track(event);
-    this.checkDistanceFail();
-  }
-
-  protected onPointerOutOfBounds(event: AdaptedEvent): void {
-    super.onPointerOutOfBounds(event);
-    this.tracker.track(event);
-    this.checkDistanceFail();
-  }
-
-  protected onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.tracker.removeFromTracker(event.pointerId);
-
-    if (this.state === State.ACTIVE) {
-      this.end();
-    } else {
-      this.fail();
-    }
-  }
-
-  protected onPointerRemove(event: AdaptedEvent): void {
-    super.onPointerRemove(event);
-    this.tracker.removeFromTracker(event.pointerId);
-
-    if (
-      this.tracker.trackedPointersCount < this.numberOfPointers &&
-      this.state !== State.ACTIVE
-    ) {
-      this.fail();
-    }
-  }
-
-  private tryBegin(): void {
-    if (this.state !== State.UNDETERMINED) {
-      return;
-    }
-
-    this.previousTime = Date.now();
-    this.startTime = this.previousTime;
-
-    this.begin();
-  }
-
-  private tryActivate(): void {
-    if (this.tracker.trackedPointersCount !== this.numberOfPointers) {
-      return;
-    }
-
-    if (this.minDurationMs > 0) {
-      this.activationTimeout = setTimeout(() => {
-        this.activate();
-      }, this.minDurationMs);
-    } else if (this.minDurationMs === 0) {
-      this.activate();
-    }
-  }
-
-  private checkDistanceFail(): void {
-    const absoluteCoordsAverage = this.tracker.getAbsoluteCoordsAverage();
-
-    const dx = absoluteCoordsAverage.x - this.startX;
-    const dy = absoluteCoordsAverage.y - this.startY;
-    const distSq = dx * dx + dy * dy;
-
-    if (distSq <= this.maxDistSq) {
-      return;
-    }
-
-    if (this.state === State.ACTIVE) {
-      this.cancel();
-    } else {
-      this.fail();
-    }
-  }
-}

package/src/web/handlers/ManualGestureHandler.ts

@@ -1,37 +0,0 @@
-import { AdaptedEvent } from '../interfaces';
-import GestureHandler from './GestureHandler';
-
-export default class ManualGestureHandler extends GestureHandler {
-  protected onPointerDown(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-    this.begin();
-
-    this.tryToSendTouchEvent(event);
-  }
-
-  protected onPointerAdd(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerAdd(event);
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    this.tracker.track(event);
-    super.onPointerMove(event);
-  }
-
-  protected onPointerOutOfBounds(event: AdaptedEvent): void {
-    this.tracker.track(event);
-    super.onPointerOutOfBounds(event);
-  }
-
-  protected onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.tracker.removeFromTracker(event.pointerId);
-  }
-
-  protected onPointerRemove(event: AdaptedEvent): void {
-    super.onPointerRemove(event);
-    this.tracker.removeFromTracker(event.pointerId);
-  }
-}

package/src/web/handlers/NativeViewGestureHandler.ts

@@ -1,175 +0,0 @@
-import { Platform } from 'react-native';
-import { State } from '../../State';
-import { DEFAULT_TOUCH_SLOP } from '../constants';
-import { AdaptedEvent, Config } from '../interfaces';
-
-import GestureHandler from './GestureHandler';
-export default class NativeViewGestureHandler extends GestureHandler {
-  private buttonRole!: boolean;
-
-  // TODO: Implement logic for activation on start
-  // @ts-ignore Logic yet to be implemented
-  private shouldActivateOnStart = false;
-  private disallowInterruption = false;
-
-  private startX = 0;
-  private startY = 0;
-  private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
-
-  public init(ref: number, propsRef: React.RefObject<unknown>): void {
-    super.init(ref, propsRef);
-
-    this.shouldCancelWhenOutside = true;
-
-    if (Platform.OS !== 'web') {
-      return;
-    }
-
-    const view = this.delegate.view as HTMLElement;
-
-    this.restoreViewStyles(view);
-    this.buttonRole = view.getAttribute('role') === 'button';
-  }
-
-  public updateGestureConfig({ enabled = true, ...props }: Config): void {
-    super.updateGestureConfig({ enabled: enabled, ...props });
-
-    if (this.config.shouldActivateOnStart !== undefined) {
-      this.shouldActivateOnStart = this.config.shouldActivateOnStart;
-    }
-    if (this.config.disallowInterruption !== undefined) {
-      this.disallowInterruption = this.config.disallowInterruption;
-    }
-
-    const view = this.delegate.view as HTMLElement;
-    this.restoreViewStyles(view);
-  }
-
-  private restoreViewStyles(view: HTMLElement) {
-    if (!view) {
-      return;
-    }
-
-    view.style['touchAction'] = 'auto';
-    // @ts-ignore Turns on defualt touch behavior on Safari
-    view.style['WebkitTouchCallout'] = 'auto';
-  }
-
-  protected onPointerDown(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerDown(event);
-    this.newPointerAction();
-
-    this.tryToSendTouchEvent(event);
-  }
-
-  protected onPointerAdd(event: AdaptedEvent): void {
-    this.tracker.addToTracker(event);
-    super.onPointerAdd(event);
-    this.newPointerAction();
-  }
-
-  private newPointerAction(): void {
-    const lastCoords = this.tracker.getAbsoluteCoordsAverage();
-    this.startX = lastCoords.x;
-    this.startY = lastCoords.y;
-
-    if (this.state !== State.UNDETERMINED) {
-      return;
-    }
-
-    this.begin();
-
-    const view = this.delegate.view as HTMLElement;
-    const isRNGHText = view.hasAttribute('rnghtext');
-
-    if (this.buttonRole || isRNGHText) {
-      this.activate();
-    }
-  }
-
-  protected onPointerMove(event: AdaptedEvent): void {
-    this.tracker.track(event);
-
-    const lastCoords = this.tracker.getAbsoluteCoordsAverage();
-    const dx = this.startX - lastCoords.x;
-    const dy = this.startY - lastCoords.y;
-    const distSq = dx * dx + dy * dy;
-
-    if (distSq >= this.minDistSq) {
-      if (this.buttonRole && this.state === State.ACTIVE) {
-        this.cancel();
-      } else if (!this.buttonRole && this.state === State.BEGAN) {
-        this.activate();
-      }
-    }
-  }
-
-  protected onPointerLeave(): void {
-    if (this.state === State.BEGAN || this.state === State.ACTIVE) {
-      this.cancel();
-    }
-  }
-
-  protected onPointerUp(event: AdaptedEvent): void {
-    super.onPointerUp(event);
-    this.onUp(event);
-  }
-
-  protected onPointerRemove(event: AdaptedEvent): void {
-    super.onPointerRemove(event);
-    this.onUp(event);
-  }
-
-  private onUp(event: AdaptedEvent): void {
-    this.tracker.removeFromTracker(event.pointerId);
-
-    if (this.tracker.trackedPointersCount === 0) {
-      if (this.state === State.ACTIVE) {
-        this.end();
-      } else {
-        this.fail();
-      }
-    }
-  }
-
-  public shouldRecognizeSimultaneously(handler: GestureHandler): boolean {
-    if (super.shouldRecognizeSimultaneously(handler)) {
-      return true;
-    }
-
-    if (
-      handler instanceof NativeViewGestureHandler &&
-      handler.state === State.ACTIVE &&
-      handler.disallowsInterruption()
-    ) {
-      return false;
-    }
-
-    const canBeInterrupted = !this.disallowInterruption;
-
-    if (
-      this.state === State.ACTIVE &&
-      handler.state === State.ACTIVE &&
-      canBeInterrupted
-    ) {
-      return false;
-    }
-
-    return (
-      this.state === State.ACTIVE && canBeInterrupted && handler.handlerTag > 0
-    );
-  }
-
-  public shouldBeCancelledByOther(_handler: GestureHandler): boolean {
-    return !this.disallowInterruption;
-  }
-
-  public disallowsInterruption(): boolean {
-    return this.disallowInterruption;
-  }
-
-  public isButton(): boolean {
-    return this.buttonRole;
-  }
-}