react-native-gesture-handler 2.16.0-rc.0 → 2.16.0

package/lib/typescript/handlers/gestures/GestureDetector.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { GestureType, HandlerCallbacks } from './gesture';
 import { SharedValue } from './reanimatedWrapper';
-import { UserSelect } from '../gestureHandlerCommon';
+import { UserSelect, TouchAction } from '../gestureHandlerCommon';
 import { ComposedGesture } from './gestureComposition';
 export type GestureConfigReference = {
     config: GestureType[];
@@ -15,6 +15,7 @@ interface GestureDetectorProps {
     children?: React.ReactNode;
     userSelect?: UserSelect;
     enableContextMenu?: boolean;
+    touchAction?: TouchAction;
 }
 export declare const GestureDetector: (props: GestureDetectorProps) => React.JSX.Element;
 export {};

package/lib/typescript/handlers/gestures/gesture.d.ts

@@ -1,6 +1,6 @@
 import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';
 import { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';
-import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor } from '../gestureHandlerCommon';
+import { HitSlop, CommonGestureConfig, GestureTouchEvent, GestureStateChangeEvent, GestureUpdateEvent, ActiveCursor, MouseButton } from '../gestureHandlerCommon';
 import { GestureStateManagerType } from './gestureStateManager';
 import { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';
 import { PanGestureHandlerEventPayload } from '../PanGestureHandler';
@@ -8,7 +8,6 @@ import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
 import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
 import { TapGestureHandlerEventPayload } from '../TapGestureHandler';
 import { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';
-import { MouseButton } from '../../web/interfaces';
 export type GestureType = BaseGesture<Record<string, unknown>> | BaseGesture<Record<string, never>> | BaseGesture<TapGestureHandlerEventPayload> | BaseGesture<PanGestureHandlerEventPayload> | BaseGesture<LongPressGestureHandlerEventPayload> | BaseGesture<RotationGestureHandlerEventPayload> | BaseGesture<PinchGestureHandlerEventPayload> | BaseGesture<FlingGestureHandlerEventPayload> | BaseGesture<ForceTouchGestureHandlerEventPayload> | BaseGesture<NativeViewGestureHandlerPayload>;
 export type GestureRef = number | GestureType | React.RefObject<GestureType | undefined> | React.RefObject<React.ComponentType | undefined>;
 export interface BaseGestureConfig extends CommonGestureConfig, Record<string, unknown> {

package/lib/typescript/index.d.ts

@@ -1,10 +1,10 @@
 export { Directions } from './Directions';
 export { State } from './State';
-export { MouseButton } from './web/interfaces';
 export { PointerType } from './PointerType';
 export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
 export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
 export type { GestureEvent, HandlerStateChangeEvent, GestureEventPayload, HandlerStateChangeEventPayload, GestureTouchEvent, TouchData, GestureUpdateEvent, GestureStateChangeEvent, } from './handlers/gestureHandlerCommon';
+export { MouseButton } from './handlers/gestureHandlerCommon';
 export type { GestureType } from './handlers/gestures/gesture';
 export type { TapGestureHandlerEventPayload, TapGestureHandlerProps, } from './handlers/TapGestureHandler';
 export type { ForceTouchGestureHandlerEventPayload, ForceTouchGestureHandlerProps, } from './handlers/ForceTouchGestureHandler';

package/lib/typescript/mocks.d.ts

@@ -26,6 +26,7 @@ declare const _default: {
     readonly dropGestureHandler: () => void;
     readonly updateGestureHandler: () => void;
     readonly flushOperations: () => void;
+    readonly install: () => void;
     readonly Directions: {
         readonly RIGHT: 1;
         readonly LEFT: 2;

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react-native/types/modules/codegen" />
-import type { Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import type { Int32, WithDefault, Float } from 'react-native/Libraries/Types/CodegenTypes';
 import type { ViewProps, ColorValue } from 'react-native';
 interface NativeProps extends ViewProps {
     exclusive?: WithDefault<boolean, true>;
@@ -9,6 +9,9 @@ interface NativeProps extends ViewProps {
     rippleColor?: ColorValue;
     rippleRadius?: Int32;
     touchSoundDisabled?: WithDefault<boolean, false>;
+    borderWidth?: Float;
+    borderColor?: ColorValue;
+    borderStyle?: WithDefault<string, 'solid'>;
 }
 declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
 export default _default;

package/lib/typescript/web/Gestures.d.ts

@@ -0,0 +1,36 @@
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+import HammerNativeViewGestureHandler from '../web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from '../web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from '../web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from '../web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from '../web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from '../web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from '../web_hammer/FlingGestureHandler';
+export declare const Gestures: {
+    NativeViewGestureHandler: typeof NativeViewGestureHandler;
+    PanGestureHandler: typeof PanGestureHandler;
+    TapGestureHandler: typeof TapGestureHandler;
+    LongPressGestureHandler: typeof LongPressGestureHandler;
+    PinchGestureHandler: typeof PinchGestureHandler;
+    RotationGestureHandler: typeof RotationGestureHandler;
+    FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
+    HoverGestureHandler: typeof HoverGestureHandler;
+};
+export declare const HammerGestures: {
+    NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
+    PanGestureHandler: typeof HammerPanGestureHandler;
+    TapGestureHandler: typeof HammerTapGestureHandler;
+    LongPressGestureHandler: typeof HammerLongPressGestureHandler;
+    PinchGestureHandler: typeof HammerPinchGestureHandler;
+    RotationGestureHandler: typeof HammerRotationGestureHandler;
+    FlingGestureHandler: typeof HammerFlingGestureHandler;
+};

package/lib/typescript/web/constants.d.ts

@@ -1,7 +1,2 @@
 export declare const DEFAULT_TOUCH_SLOP = 15;
-export declare const Direction: {
-    RIGHT: number;
-    LEFT: number;
-    UP: number;
-    DOWN: number;
-};
+export declare const MINIMAL_FLING_VELOCITY = 0.1;

package/lib/typescript/web/handlers/FlingGestureHandler.d.ts

@@ -4,10 +4,8 @@ export default class FlingGestureHandler extends GestureHandler {
     private numberOfPointersRequired;
     private direction;
     private maxDurationMs;
-    private minAcceptableDelta;
+    private minVelocity;
     private delayTimeout;
-    private startX;
-    private startY;
     private maxNumberOfPointersSimultaneously;
     private keyPointer;
     init(ref: number, propsRef: React.RefObject<unknown>): void;
@@ -18,7 +16,9 @@ export default class FlingGestureHandler extends GestureHandler {
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     private newPointerAction;
+    private pointerMoveAction;
     protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
     protected onPointerRemove(event: AdaptedEvent): void;
     private onUp;

package/lib/typescript/web/handlers/GestureHandler.d.ts

@@ -1,10 +1,12 @@
 import { State } from '../../State';
-import { Config, AdaptedEvent, MouseButton } from '../interfaces';
+import { Config, AdaptedEvent } from '../interfaces';
 import EventManager from '../tools/EventManager';
 import PointerTracker from '../tools/PointerTracker';
 import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
+import IGestureHandler from './IGestureHandler';
+import { MouseButton } from '../../handlers/gestureHandlerCommon';
 import { PointerType } from '../../PointerType';
-export default abstract class GestureHandler {
+export default abstract class GestureHandler implements IGestureHandler {
     private lastSentState;
     protected currentState: State;
     protected shouldCancellWhenOutside: boolean;
@@ -20,8 +22,8 @@ export default abstract class GestureHandler {
     protected active: boolean;
     protected shouldResetProgress: boolean;
     protected pointerType: PointerType;
-    protected delegate: GestureHandlerDelegate<unknown>;
-    constructor(delegate: GestureHandlerDelegate<unknown>);
+    protected delegate: GestureHandlerDelegate<unknown, IGestureHandler>;
+    constructor(delegate: GestureHandlerDelegate<unknown, IGestureHandler>);
     protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
     attachEventManager(manager: EventManager<unknown>): void;
     protected onCancel(): void;
@@ -49,10 +51,10 @@ export default abstract class GestureHandler {
     setShouldResetProgress(value: boolean): void;
     getActivationIndex(): number;
     setActivationIndex(value: number): void;
-    shouldWaitForHandlerFailure(handler: GestureHandler): boolean;
-    shouldRequireToWaitForFailure(handler: GestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
-    shouldBeCancelledByOther(handler: GestureHandler): boolean;
+    shouldWaitForHandlerFailure(handler: IGestureHandler): boolean;
+    shouldRequireToWaitForFailure(handler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler): boolean;
+    shouldBeCancelledByOther(handler: IGestureHandler): boolean;
     protected onPointerDown(event: AdaptedEvent): void;
     protected onPointerAdd(event: AdaptedEvent): void;
     protected onPointerUp(event: AdaptedEvent): void;
@@ -81,7 +83,7 @@ export default abstract class GestureHandler {
     getTag(): number;
     setTag(tag: number): void;
     getConfig(): Config;
-    getDelegate(): GestureHandlerDelegate<unknown>;
+    getDelegate(): GestureHandlerDelegate<unknown, IGestureHandler>;
     getTracker(): PointerTracker;
     getTrackedPointersID(): number[];
     getState(): State;

package/lib/typescript/web/handlers/IGestureHandler.d.ts

@@ -0,0 +1,38 @@
+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 {
+    getTag: () => number;
+    getState: () => State;
+    getConfig: () => Config;
+    getDelegate: () => GestureHandlerDelegate<unknown, this>;
+    attachEventManager: (manager: EventManager<unknown>) => void;
+    isButtonInConfig: (mouseButton: MouseButton | undefined) => boolean | number | undefined;
+    getPointerType: () => PointerType;
+    getTracker: () => PointerTracker;
+    getTrackedPointersID: () => number[];
+    begin: () => void;
+    activate: () => void;
+    end: () => void;
+    fail: () => void;
+    cancel: () => void;
+    reset: () => void;
+    isEnabled: () => boolean;
+    isActive: () => boolean;
+    setActive: (value: boolean) => void;
+    isAwaiting: () => boolean;
+    setAwaiting: (value: boolean) => void;
+    setActivationIndex: (value: number) => void;
+    setShouldResetProgress: (value: boolean) => 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/lib/typescript/web/handlers/NativeViewGestureHandler.d.ts

@@ -21,4 +21,5 @@ export default class NativeViewGestureHandler extends GestureHandler {
     shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
     shouldBeCancelledByOther(_handler: GestureHandler): boolean;
     disallowsInterruption(): boolean;
+    isButton(): boolean;
 }

package/lib/typescript/web/interfaces.d.ts

@@ -1,4 +1,4 @@
-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';
@@ -15,7 +15,7 @@ export interface HitSlop {
 export interface Handler {
     handlerTag: number;
 }
-type ConfigArgs = number | boolean | HitSlop | UserSelect | ActiveCursor | Directions | Handler[] | null | undefined;
+type ConfigArgs = number | boolean | HitSlop | UserSelect | TouchAction | ActiveCursor | Directions | Handler[] | null | undefined;
 export interface Config extends Record<string, ConfigArgs> {
     enabled?: boolean;
     simultaneousHandlers?: Handler[] | null;
@@ -27,6 +27,7 @@ export interface Config extends Record<string, ConfigArgs> {
     activeCursor?: ActiveCursor;
     mouseButton?: MouseButton;
     enableContextMenu?: boolean;
+    touchAction?: TouchAction;
     activateAfterLongPress?: number;
     failOffsetXStart?: number;
     failOffsetYStart?: number;
@@ -67,6 +68,10 @@ interface NativeEvent extends Record<string, NativeEventArgs> {
     oldState?: State;
     pointerType: PointerType;
 }
+export interface Point {
+    x: number;
+    y: number;
+}
 export interface PointerData {
     id: number;
     x: number;
@@ -109,14 +114,6 @@ export interface AdaptedEvent {
     changedTouches?: TouchList;
     touchEventType?: TouchEventType;
 }
-export declare enum MouseButton {
-    LEFT = 1,
-    RIGHT = 2,
-    MIDDLE = 4,
-    BUTTON_4 = 8,
-    BUTTON_5 = 16,
-    ALL = 31
-}
 export declare enum EventTypes {
     DOWN = 0,
     ADDITIONAL_POINTER_DOWN = 1,

package/lib/typescript/web/tools/EventManager.d.ts

@@ -1,10 +1,12 @@
 import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
+type PointerEventCallback = (event: AdaptedEvent) => void;
 export default abstract class EventManager<T> {
     protected readonly view: T;
     protected pointersInBounds: number[];
     protected activePointersCounter: number;
     constructor(view: T);
-    abstract setListeners(): void;
+    abstract registerListeners(): void;
+    abstract unregisterListeners(): void;
     protected abstract mapEvent(event: Event, eventType: EventTypes, index?: number, touchEventType?: TouchEventType): AdaptedEvent;
     protected onPointerDown(_event: AdaptedEvent): void;
     protected onPointerAdd(_event: AdaptedEvent): void;
@@ -17,18 +19,19 @@ export default abstract class EventManager<T> {
     protected onPointerOutOfBounds(_event: AdaptedEvent): void;
     protected onPointerMoveOver(_event: AdaptedEvent): void;
     protected onPointerMoveOut(_event: AdaptedEvent): void;
-    setOnPointerDown(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerAdd(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerUp(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerRemove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMove(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerLeave(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerEnter(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerCancel(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerOutOfBounds(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void;
-    setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void;
+    setOnPointerDown(callback: PointerEventCallback): void;
+    setOnPointerAdd(callback: PointerEventCallback): void;
+    setOnPointerUp(callback: PointerEventCallback): void;
+    setOnPointerRemove(callback: PointerEventCallback): void;
+    setOnPointerMove(callback: PointerEventCallback): void;
+    setOnPointerLeave(callback: PointerEventCallback): void;
+    setOnPointerEnter(callback: PointerEventCallback): void;
+    setOnPointerCancel(callback: PointerEventCallback): void;
+    setOnPointerOutOfBounds(callback: PointerEventCallback): void;
+    setOnPointerMoveOver(callback: PointerEventCallback): void;
+    setOnPointerMoveOut(callback: PointerEventCallback): void;
     protected markAsInBounds(pointerId: number): void;
     protected markAsOutOfBounds(pointerId: number): void;
     resetManager(): void;
 }
+export {};

package/lib/typescript/web/tools/GestureHandlerDelegate.d.ts

@@ -1,4 +1,3 @@
-import type GestureHandler from '../handlers/GestureHandler';
 import { Config } from '../interfaces';
 export interface MeasureResult {
     pageX: number;
@@ -6,9 +5,9 @@ export interface MeasureResult {
     width: number;
     height: number;
 }
-export interface GestureHandlerDelegate<T> {
-    getView(): T;
-    init(viewRef: number, handler: GestureHandler): void;
+export interface GestureHandlerDelegate<TComponent, THandler> {
+    getView(): TComponent;
+    init(viewRef: number, handler: THandler): void;
     isPointerInBounds({ x, y }: {
         x: number;
         y: number;

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -1,29 +1,31 @@
 import { State } from '../../State';
-import GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 export default class GestureHandlerOrchestrator {
     private static instance;
     private gestureHandlers;
     private awaitingHandlers;
+    private awaitingHandlersTags;
     private handlingChangeSemaphore;
     private activationIndex;
     private constructor();
     private scheduleFinishedHandlersCleanup;
     private cleanHandler;
-    removeHandlerFromOrchestrator(handler: GestureHandler): void;
+    removeHandlerFromOrchestrator(handler: IGestureHandler): void;
     private cleanupFinishedHandlers;
     private hasOtherHandlerToWaitFor;
+    private shouldBeCancelledByFinishedHandler;
     private tryActivate;
     private shouldActivate;
     private cleanupAwaitingHandlers;
-    onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
+    onHandlerStateChange(handler: IGestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
     private makeActive;
     private addAwaitingHandler;
-    recordHandlerIfNotPresent(handler: GestureHandler): void;
+    recordHandlerIfNotPresent(handler: IGestureHandler): void;
     private shouldHandlerWaitForOther;
     private canRunSimultaneously;
     private shouldHandlerBeCancelledBy;
     private checkOverlap;
     private isFinished;
-    cancelMouseAndPenGestures(currentHandler: GestureHandler): void;
+    cancelMouseAndPenGestures(currentHandler: IGestureHandler): void;
     static getInstance(): GestureHandlerOrchestrator;
 }

package/lib/typescript/web/tools/GestureHandlerWebDelegate.d.ts

@@ -1,12 +1,12 @@
-import type GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 import { GestureHandlerDelegate, MeasureResult } from './GestureHandlerDelegate';
 import { Config } from '../interfaces';
-export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement> {
+export declare class GestureHandlerWebDelegate implements GestureHandlerDelegate<HTMLElement, IGestureHandler> {
     private view;
     private gestureHandler;
     private eventManagers;
     getView(): HTMLElement;
-    init(viewRef: number, handler: GestureHandler): void;
+    init(viewRef: number, handler: IGestureHandler): void;
     isPointerInBounds({ x, y }: {
         x: number;
         y: number;

package/lib/typescript/web/tools/InteractionManager.d.ts

@@ -1,4 +1,4 @@
-import GestureHandler from '../handlers/GestureHandler';
+import type IGestureHandler from '../handlers/IGestureHandler';
 import { Config } from '../interfaces';
 export default class InteractionManager {
     private static instance;
@@ -6,11 +6,11 @@ export default class InteractionManager {
     private readonly simultaneousRelations;
     private readonly blocksHandlersRelations;
     private constructor();
-    configureInteractions(handler: GestureHandler, config: Config): void;
-    shouldWaitForHandlerFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldRequireHandlerToWaitForFailure(handler: GestureHandler, otherHandler: GestureHandler): boolean;
-    shouldHandlerBeCancelledBy(_handler: GestureHandler, _otherHandler: GestureHandler): boolean;
+    configureInteractions(handler: IGestureHandler, config: Config): void;
+    shouldWaitForHandlerFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRecognizeSimultaneously(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldRequireHandlerToWaitForFailure(handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
+    shouldHandlerBeCancelledBy(_handler: IGestureHandler, otherHandler: IGestureHandler): boolean;
     dropRelationsForHandlerWithTag(handlerTag: number): void;
     reset(): void;
     static getInstance(): InteractionManager;

package/lib/typescript/web/tools/NodeManager.d.ts

@@ -1,11 +1,12 @@
 import { ValueOf } from '../../typeUtils';
-import { Gestures } from '../../RNGestureHandlerModule.web';
+import { Gestures } from '../Gestures';
+import type IGestureHandler from '../handlers/IGestureHandler';
 export default abstract class NodeManager {
     private static gestures;
-    static getHandler(tag: number): import("../handlers/NativeViewGestureHandler").default | import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
+    static getHandler(tag: number): IGestureHandler;
     static createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof Gestures>>): void;
     static dropGestureHandler(handlerTag: number): void;
     static getNodes(): {
-        [x: number]: import("../handlers/NativeViewGestureHandler").default | import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
+        [x: number]: import("../handlers/PanGestureHandler").default | import("../handlers/TapGestureHandler").default | import("../handlers/LongPressGestureHandler").default | import("../handlers/PinchGestureHandler").default | import("../handlers/RotationGestureHandler").default | import("../handlers/FlingGestureHandler").default | import("../handlers/NativeViewGestureHandler").default | import("../handlers/ManualGestureHandler").default | import("../handlers/HoverGestureHandler").default;
     };
 }

package/lib/typescript/web/tools/PointerEventManager.d.ts

@@ -1,10 +1,19 @@
-import { AdaptedEvent, EventTypes } from '../interfaces';
 import EventManager from './EventManager';
+import { AdaptedEvent, EventTypes } from '../interfaces';
 export default class PointerEventManager extends EventManager<HTMLElement> {
     private trackedPointers;
     private readonly mouseButtonsMapper;
+    private lastPosition;
     constructor(view: HTMLElement);
-    setListeners(): void;
+    private pointerDownCallback;
+    private pointerUpCallback;
+    private pointerMoveCallback;
+    private pointerCancelCallback;
+    private pointerEnterCallback;
+    private pointerLeaveCallback;
+    private lostPointerCaptureCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
     protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent;
     resetManager(): void;
 }

package/lib/typescript/web/tools/TouchEventManager.d.ts

@@ -1,6 +1,11 @@
 import { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';
 import EventManager from './EventManager';
 export default class TouchEventManager extends EventManager<HTMLElement> {
-    setListeners(): void;
+    private touchStartCallback;
+    private touchMoveCallback;
+    private touchEndCallback;
+    private touchCancelCallback;
+    registerListeners(): void;
+    unregisterListeners(): void;
     protected mapEvent(event: TouchEvent, eventType: EventTypes, index: number, touchEventType: TouchEventType): AdaptedEvent;
 }

package/lib/typescript/web/tools/Vector.d.ts

@@ -0,0 +1,15 @@
+import { DiagonalDirections, Directions } from '../../Directions';
+import PointerTracker from './PointerTracker';
+export default class Vector {
+    private readonly x;
+    private readonly y;
+    private readonly unitX;
+    private readonly unitY;
+    private readonly _magnitude;
+    constructor(x: number, y: number);
+    static fromDirection(direction: Directions | DiagonalDirections): Vector;
+    static fromVelocity(tracker: PointerTracker, pointerId: number): Vector;
+    get magnitude(): number;
+    computeSimilarity(vector: Vector): number;
+    isSimilar(vector: Vector, threshold: number): boolean;
+}

package/lib/typescript/web/utils.d.ts

@@ -1,6 +1,6 @@
 import { PointerType } from '../PointerType';
-export declare function isPointerInBounds(view: HTMLElement, { x, y }: {
-    x: number;
-    y: number;
-}): boolean;
+import { Point } from './interfaces';
+export declare function isPointerInBounds(view: HTMLElement, { x, y }: Point): boolean;
 export declare const PointerTypeMapping: Map<string, PointerType>;
+export declare const degToRad: (degrees: number) => number;
+export declare const coneToDeviation: (degrees: number) => number;

package/lib/typescript/web_hammer/NodeManager.d.ts

@@ -1,5 +1,5 @@
 import { ValueOf } from '../typeUtils';
-import { HammerGestures } from '../RNGestureHandlerModule.web';
+import { HammerGestures } from '../web/Gestures';
 export declare function getHandler(tag: number): import("./NativeViewGestureHandler").default | import("./PanGestureHandler").default | import("./TapGestureHandler").default | import("./LongPressGestureHandler").default | import("./PinchGestureHandler").default | import("./RotationGestureHandler").default | import("./FlingGestureHandler").default;
 export declare function createGestureHandler(handlerTag: number, handler: InstanceType<ValueOf<typeof HammerGestures>>): void;
 export declare function dropGestureHandler(handlerTag: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gesture-handler",
-  "version": "2.16.0-rc.0",
+  "version": "2.16.0",
   "description": "Experimental implementation of a new declarative API for gesture handling in react-native",
   "scripts": {
     "prepare": "bob build && husky install",
@@ -98,6 +98,7 @@
     "husky": "^8.0.1",
     "jest": "^26.6.3",
     "lint-staged": "^12.3.2",
+    "madge": "^6.1.0",
     "prettier": "^2.7.1",
     "react": "18.2.0",
     "react-dom": "^16.12.0",

package/src/Directions.ts

@@ -1,9 +1,26 @@
+const RIGHT = 1;
+const LEFT = 2;
+const UP = 4;
+const DOWN = 8;
+
+// public interface
 export const Directions = {
-  RIGHT: 1,
-  LEFT: 2,
-  UP: 4,
-  DOWN: 8,
+  RIGHT: RIGHT,
+  LEFT: LEFT,
+  UP: UP,
+  DOWN: DOWN,
+} as const;
+
+// internal interface
+export const DiagonalDirections = {
+  UP_RIGHT: UP | RIGHT,
+  DOWN_RIGHT: DOWN | RIGHT,
+  UP_LEFT: UP | LEFT,
+  DOWN_LEFT: DOWN | LEFT,
 } as const;
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value
 export type Directions = typeof Directions[keyof typeof Directions];
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type DiagonalDirections =
+  typeof DiagonalDirections[keyof typeof DiagonalDirections];

package/src/RNGestureHandlerModule.web.ts

@@ -1,55 +1,14 @@
 import React from 'react';
 
-import { ActionType } from './ActionType';
+import type { ActionType } from './ActionType';
 import { isNewWebImplementationEnabled } from './EnableNewWebImplementation';
-
-//GestureHandlers
+import { Gestures, HammerGestures } from './web/Gestures';
+import type { Config } from './web/interfaces';
 import InteractionManager from './web/tools/InteractionManager';
 import NodeManager from './web/tools/NodeManager';
-import PanGestureHandler from './web/handlers/PanGestureHandler';
-import TapGestureHandler from './web/handlers/TapGestureHandler';
-import LongPressGestureHandler from './web/handlers/LongPressGestureHandler';
-import PinchGestureHandler from './web/handlers/PinchGestureHandler';
-import RotationGestureHandler from './web/handlers/RotationGestureHandler';
-import FlingGestureHandler from './web/handlers/FlingGestureHandler';
-import NativeViewGestureHandler from './web/handlers/NativeViewGestureHandler';
-import ManualGestureHandler from './web/handlers/ManualGestureHandler';
-import HoverGestureHandler from './web/handlers/HoverGestureHandler';
-
-//Hammer Handlers
 import * as HammerNodeManager from './web_hammer/NodeManager';
-import HammerNativeViewGestureHandler from './web_hammer/NativeViewGestureHandler';
-import HammerPanGestureHandler from './web_hammer/PanGestureHandler';
-import HammerTapGestureHandler from './web_hammer/TapGestureHandler';
-import HammerLongPressGestureHandler from './web_hammer/LongPressGestureHandler';
-import HammerPinchGestureHandler from './web_hammer/PinchGestureHandler';
-import HammerRotationGestureHandler from './web_hammer/RotationGestureHandler';
-import HammerFlingGestureHandler from './web_hammer/FlingGestureHandler';
-import { Config } from './web/interfaces';
 import { GestureHandlerWebDelegate } from './web/tools/GestureHandlerWebDelegate';
 
-export const Gestures = {
-  NativeViewGestureHandler,
-  PanGestureHandler,
-  TapGestureHandler,
-  LongPressGestureHandler,
-  PinchGestureHandler,
-  RotationGestureHandler,
-  FlingGestureHandler,
-  ManualGestureHandler,
-  HoverGestureHandler,
-};
-
-export const HammerGestures = {
-  NativeViewGestureHandler: HammerNativeViewGestureHandler,
-  PanGestureHandler: HammerPanGestureHandler,
-  TapGestureHandler: HammerTapGestureHandler,
-  LongPressGestureHandler: HammerLongPressGestureHandler,
-  PinchGestureHandler: HammerPinchGestureHandler,
-  RotationGestureHandler: HammerRotationGestureHandler,
-  FlingGestureHandler: HammerFlingGestureHandler,
-};
-
 export default {
   handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
     console.warn('handleSetJSResponder: ', tag, blockNativeResponder);