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

package/src/web/interfaces.ts

@@ -1,6 +1,12 @@
-import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';
+import {
+  UserSelect,
+  ActiveCursor,
+  MouseButton,
+  TouchAction,
+} from '../handlers/gestureHandlerCommon';
 import { Directions } from '../Directions';
 import { State } from '../State';
+import { PointerType } from '../PointerType';
 
 export interface HitSlop {
   left?: number;
@@ -22,6 +28,7 @@ type ConfigArgs =
   | boolean
   | HitSlop
   | UserSelect
+  | TouchAction
   | ActiveCursor
   | Directions
   | Handler[]
@@ -29,13 +36,18 @@ type ConfigArgs =
   | undefined;
 
 export interface Config extends Record<string, ConfigArgs> {
-  enabled?: boolean;
+  enabled: boolean;
   simultaneousHandlers?: Handler[] | null;
   waitFor?: Handler[] | null;
+  blocksHandlers?: Handler[] | null;
   hitSlop?: HitSlop;
   shouldCancelWhenOutside?: boolean;
   userSelect?: UserSelect;
   activeCursor?: ActiveCursor;
+  mouseButton?: MouseButton;
+  enableContextMenu?: boolean;
+  touchAction?: TouchAction;
+  manualActivation?: boolean;
 
   activateAfterLongPress?: number;
   failOffsetXStart?: number;
@@ -66,6 +78,7 @@ export interface Config extends Record<string, ConfigArgs> {
   shouldActivateOnStart?: boolean;
   disallowInterruption?: boolean;
   direction?: Directions;
+  enableTrackpadTwoFingerGesture?: boolean;
 }
 
 type NativeEventArgs = number | State | boolean | undefined;
@@ -76,6 +89,12 @@ interface NativeEvent extends Record<string, NativeEventArgs> {
   handlerTag: number;
   target: number;
   oldState?: State;
+  pointerType: PointerType;
+}
+
+export interface Point {
+  x: number;
+  y: number;
 }
 
 export interface PointerData {
@@ -95,6 +114,7 @@ interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
   changedTouches: PointerData[];
   allTouches: PointerData[];
   numberOfTouches: number;
+  pointerType: PointerType;
 }
 
 export interface ResultEvent extends Record<string, NativeEvent | number> {
@@ -113,6 +133,14 @@ export interface PropsRef {
   onGestureHandlerStateChange: () => void;
 }
 
+export interface StylusData {
+  tiltX: number;
+  tiltY: number;
+  azimuthAngle: number;
+  altitudeAngle: number;
+  pressure: number;
+}
+
 export interface AdaptedEvent {
   x: number;
   y: number;
@@ -121,22 +149,10 @@ export interface AdaptedEvent {
   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,
+  button?: MouseButton;
+  stylusData?: StylusData;
+  wheelDeltaY?: number;
 }
 
 export enum EventTypes {
@@ -158,9 +174,17 @@ export enum TouchEventType {
   CANCELLED,
 }
 
-export enum PointerType {
-  NONE = 'none',
-  MOUSE = 'mouse',
-  TOUCH = 'touch',
-  PEN = 'pen',
+export enum WheelDevice {
+  UNDETERMINED,
+  MOUSE,
+  TOUCHPAD,
 }
+
+export type GestureHandlerRef = {
+  viewTag: GestureHandlerRef;
+  current: HTMLElement;
+};
+
+export type SVGRef = {
+  elementRef: { current: SVGElement };
+};

package/src/web/tools/CircularBuffer.ts

@@ -1,31 +1,27 @@
 export default class CircularBuffer<T> {
-  private bufferSize: number;
+  private capacity: number;
   private buffer: T[];
   private index: number;
-  private actualSize: number;
+  private _size: number;
 
   constructor(size: number) {
-    this.bufferSize = size;
+    this.capacity = size;
     this.buffer = new Array<T>(size);
     this.index = 0;
-    this.actualSize = 0;
-  }
-
-  public get size(): number {
-    return this.actualSize;
+    this._size = 0;
   }
 
   public push(element: T): void {
     this.buffer[this.index] = element;
-    this.index = (this.index + 1) % this.bufferSize;
-    this.actualSize = Math.min(this.actualSize + 1, this.bufferSize);
+    this.index = (this.index + 1) % this.capacity;
+    this._size = Math.min(this.size + 1, this.capacity);
   }
 
   public get(at: number): T {
-    if (this.actualSize === this.bufferSize) {
-      let index = (this.index + at) % this.bufferSize;
+    if (this._size === this.capacity) {
+      let index = (this.index + at) % this.capacity;
       if (index < 0) {
-        index += this.bufferSize;
+        index += this.capacity;
       }
 
       return this.buffer[index];
@@ -35,8 +31,12 @@ export default class CircularBuffer<T> {
   }
 
   public clear(): void {
-    this.buffer = new Array<T>(this.bufferSize);
+    this.buffer = new Array<T>(this.capacity);
     this.index = 0;
-    this.actualSize = 0;
+    this._size = 0;
+  }
+
+  public get size() {
+    return this._size;
   }
 }

package/src/web/tools/EventManager.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
-import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
+import { AdaptedEvent, EventTypes } from '../interfaces';
+
+type PointerEventCallback = (event: AdaptedEvent) => void;
 
 export default abstract class EventManager<T> {
   protected readonly view: T;
@@ -11,12 +13,12 @@ export default abstract class EventManager<T> {
     this.activePointersCounter = 0;
   }
 
-  public abstract setListeners(): void;
+  public abstract registerListeners(): void;
+  public abstract unregisterListeners(): void;
+
   protected abstract mapEvent(
     event: Event,
-    eventType: EventTypes,
-    index?: number,
-    touchEventType?: TouchEventType
+    eventType: EventTypes
   ): AdaptedEvent;
 
   protected onPointerDown(_event: AdaptedEvent): void {}
@@ -24,8 +26,8 @@ export default abstract class EventManager<T> {
   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 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
@@ -35,42 +37,44 @@ export default abstract class EventManager<T> {
   protected onPointerOutOfBounds(_event: AdaptedEvent): void {}
   protected onPointerMoveOver(_event: AdaptedEvent): void {}
   protected onPointerMoveOut(_event: AdaptedEvent): void {}
+  protected onWheel(_event: AdaptedEvent): void {}
 
-  public setOnPointerDown(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerDown(callback: PointerEventCallback): void {
     this.onPointerDown = callback;
   }
-  public setOnPointerAdd(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerAdd(callback: PointerEventCallback): void {
     this.onPointerAdd = callback;
   }
-  public setOnPointerUp(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerUp(callback: PointerEventCallback): void {
     this.onPointerUp = callback;
   }
-  public setOnPointerRemove(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerRemove(callback: PointerEventCallback): void {
     this.onPointerRemove = callback;
   }
-  public setOnPointerMove(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerMove(callback: PointerEventCallback): void {
     this.onPointerMove = callback;
   }
-  public setOnPointerLeave(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerLeave(callback: PointerEventCallback): void {
     this.onPointerLeave = callback;
   }
-  public setOnPointerEnter(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerEnter(callback: PointerEventCallback): void {
     this.onPointerEnter = callback;
   }
-  public setOnPointerCancel(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerCancel(callback: PointerEventCallback): void {
     this.onPointerCancel = callback;
   }
-  public setOnPointerOutOfBounds(
-    callback: (event: AdaptedEvent) => void
-  ): void {
+  public setOnPointerOutOfBounds(callback: PointerEventCallback): void {
     this.onPointerOutOfBounds = callback;
   }
-  public setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerMoveOver(callback: PointerEventCallback): void {
     this.onPointerMoveOver = callback;
   }
-  public setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void {
+  public setOnPointerMoveOut(callback: PointerEventCallback): void {
     this.onPointerMoveOut = callback;
   }
+  public setOnWheel(callback: PointerEventCallback): void {
+    this.onWheel = callback;
+  }
 
   protected markAsInBounds(pointerId: number): void {
     if (this.pointersInBounds.indexOf(pointerId) >= 0) {

package/src/web/tools/GestureHandlerDelegate.ts

@@ -1,4 +1,4 @@
-import type GestureHandler from '../handlers/GestureHandler';
+import { Config } from '../interfaces';
 
 export interface MeasureResult {
   pageX: number;
@@ -7,10 +7,10 @@ export interface MeasureResult {
   height: number;
 }
 
-export interface GestureHandlerDelegate<T> {
-  getView(): T;
+export interface GestureHandlerDelegate<TComponent, THandler> {
+  view: TComponent;
 
-  init(viewRef: number, handler: GestureHandler): void;
+  init(viewRef: number, handler: THandler): void;
   isPointerInBounds({ x, y }: { x: number; y: number }): boolean;
   measureView(): MeasureResult;
   reset(): void;
@@ -20,4 +20,7 @@ export interface GestureHandlerDelegate<T> {
   onEnd(): void;
   onCancel(): void;
   onFail(): void;
+  onEnabledChange(enabled: boolean): void;
+
+  destroy(config: Config): void;
 }