react-native-gesture-handler 3.0.0-beta.2 → 3.0.0-beta.4

package/src/v3/index.ts

@@ -1,78 +1,83 @@
+export type {
+  BaseButtonProps,
+  BorderlessButtonProps,
+  RawButtonProps,
+  RectButtonProps,
+  TouchableProps,
+} from './components';
+export {
+  BaseButton,
+  BorderlessButton,
+  FlatList,
+  Pressable,
+  RawButton,
+  RectButton,
+  RefreshControl,
+  ScrollView,
+  Switch,
+  TextInput,
+  Touchable,
+} from './components';
 export type { GestureDetectorProps } from './detectors';
 export {
   GestureDetector,
-  VirtualGestureDetector,
-  InterceptingGestureDetector,
   GestureDetectorType,
+  InterceptingGestureDetector,
+  VirtualGestureDetector,
 } from './detectors';
-
+export { GestureStateManager } from './gestureStateManager';
 export type {
-  TapGesture,
-  TapGestureConfig,
-  TapGestureEvent,
   FlingGesture,
+  FlingGestureActiveEvent,
   FlingGestureConfig,
   FlingGestureEvent,
-  LongPressGesture,
-  LongPressGestureConfig,
-  LongPressGestureEvent,
-  PinchGesture,
-  PinchGestureConfig,
-  PinchGestureEvent,
-  RotationGesture,
-  RotationGestureConfig,
-  RotationGestureEvent,
   HoverGesture,
+  HoverGestureActiveEvent,
   HoverGestureConfig,
   HoverGestureEvent,
+  LongPressGesture,
+  LongPressGestureActiveEvent,
+  LongPressGestureConfig,
+  LongPressGestureEvent,
   ManualGesture,
+  ManualGestureActiveEvent,
   ManualGestureConfig,
   ManualGestureEvent,
   NativeGesture,
-  NativeViewGestureConfig,
+  NativeGestureActiveEvent,
+  NativeGestureConfig,
   NativeGestureEvent,
   PanGesture,
+  PanGestureActiveEvent,
   PanGestureConfig,
   PanGestureEvent,
+  PinchGesture,
+  PinchGestureActiveEvent,
+  PinchGestureConfig,
+  PinchGestureEvent,
+  RotationGesture,
+  RotationGestureActiveEvent,
+  RotationGestureConfig,
+  RotationGestureEvent,
   SingleGesture,
   SingleGestureEvent,
+  TapGesture,
+  TapGestureActiveEvent,
+  TapGestureConfig,
+  TapGestureEvent,
 } from './hooks';
 export {
-  useSimultaneousGestures,
-  useExclusiveGestures,
   useCompetingGestures,
-  useTapGesture,
+  useExclusiveGestures,
   useFlingGesture,
-  useLongPressGesture,
-  usePinchGesture,
-  useRotationGesture,
   useHoverGesture,
+  useLongPressGesture,
   useManualGesture,
   useNativeGesture,
   usePanGesture,
+  usePinchGesture,
+  useRotationGesture,
+  useSimultaneousGestures,
+  useTapGesture,
 } from './hooks';
-
-export type {
-  RawButtonProps,
-  BaseButtonProps,
-  RectButtonProps,
-  BorderlessButtonProps,
-} from './components';
-export {
-  RawButton,
-  BaseButton,
-  RectButton,
-  BorderlessButton,
-  Pressable,
-  ScrollView,
-  Switch,
-  TextInput,
-  FlatList,
-  RefreshControl,
-} from './components';
-
 export type { ComposedGesture } from './types';
-
-export { GestureStateManager } from './gestureStateManager';
-
-export { default as createNativeWrapper } from './createNativeWrapper';

package/src/v3/types/ConfigTypes.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ActiveCursor,
   GestureTouchEvent,
   HitSlop,
@@ -6,34 +6,40 @@ import {
   TouchAction,
   UserSelect,
 } from '../../handlers/gestureHandlerCommon';
-import {
+import type {
   AnimatedEvent,
   ChangeCalculatorType,
+  GestureEndEvent,
   GestureEvent,
 } from './EventTypes';
-import { WithSharedValue } from './ReanimatedTypes';
+import type { WithSharedValue } from './ReanimatedTypes';
 
 export type GestureEventCallback<THandlerData> = (
   event: GestureEvent<THandlerData>
 ) => void;
 
-export type GestureEventCallbackWithDidSucceed<THandlerData> = (
-  event: GestureEvent<THandlerData>,
-  didSucceed: boolean
+export type GestureEndEventCallback<THandlerData> = (
+  event: GestureEndEvent<THandlerData>
 ) => void;
 
 export type GestureTouchEventCallback = (event: GestureTouchEvent) => void;
 
-export type GestureCallbacks<THandlerData> = {
-  onBegin?: GestureEventCallback<THandlerData>;
-  onActivate?: GestureEventCallback<THandlerData>;
-  onDeactivate?: GestureEventCallbackWithDidSucceed<THandlerData>;
-  onFinalize?: GestureEventCallbackWithDidSucceed<THandlerData>;
-  onUpdate?: GestureEventCallback<THandlerData> | AnimatedEvent;
-  onTouchesDown?: GestureTouchEventCallback;
-  onTouchesMove?: GestureTouchEventCallback;
-  onTouchesUp?: GestureTouchEventCallback;
-  onTouchesCancel?: GestureTouchEventCallback;
+export type GestureCallbacks<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
+  onBegin?: GestureEventCallback<THandlerData> | undefined;
+  onActivate?: GestureEventCallback<TExtendedHandlerData> | undefined;
+  onUpdate?:
+    | GestureEventCallback<TExtendedHandlerData>
+    | AnimatedEvent
+    | undefined;
+  onDeactivate?: GestureEndEventCallback<TExtendedHandlerData> | undefined;
+  onFinalize?: GestureEndEventCallback<THandlerData> | undefined;
+  onTouchesDown?: GestureTouchEventCallback | undefined;
+  onTouchesMove?: GestureTouchEventCallback | undefined;
+  onTouchesUp?: GestureTouchEventCallback | undefined;
+  onTouchesCancel?: GestureTouchEventCallback | undefined;
 };
 
 export type GestureRelations = {
@@ -42,31 +48,37 @@ export type GestureRelations = {
   blocksHandlers: number[];
 };
 
-export type InternalConfigProps<THandlerData> = {
-  shouldUseReanimatedDetector?: boolean;
-  dispatchesReanimatedEvents?: boolean;
-  dispatchesAnimatedEvents?: boolean;
-  needsPointerData?: boolean;
-  userSelect?: UserSelect;
-  touchAction?: TouchAction;
-  enableContextMenu?: boolean;
-  changeEventCalculator?: ChangeCalculatorType<THandlerData>;
+export type InternalConfigProps<TExtendedHandlerData> = {
+  shouldUseReanimatedDetector?: boolean | undefined;
+  dispatchesReanimatedEvents?: boolean | undefined;
+  dispatchesAnimatedEvents?: boolean | undefined;
+  needsPointerData?: boolean | undefined;
+  userSelect?: UserSelect | undefined;
+  touchAction?: TouchAction | undefined;
+  enableContextMenu?: boolean | undefined;
+  changeEventCalculator?:
+    | ChangeCalculatorType<TExtendedHandlerData>
+    | undefined;
+  fillInDefaultValues?:
+    | ((event: GestureEvent<TExtendedHandlerData>) => void)
+    | undefined;
 };
 
 export type CommonGestureConfig = {
-  disableReanimated?: boolean;
-  useAnimated?: boolean;
-  testID?: string;
+  disableReanimated?: boolean | undefined;
+  useAnimated?: boolean | undefined;
+  testID?: string | undefined;
 } & WithSharedValue<
   {
-    runOnJS?: boolean;
-    enabled?: boolean;
-    shouldCancelWhenOutside?: boolean;
-    hitSlop?: HitSlop;
-    activeCursor?: ActiveCursor;
-    mouseButton?: MouseButton;
-    cancelsTouchesInView?: boolean;
-    manualActivation?: boolean;
+    runOnJS?: boolean | undefined;
+    enabled?: boolean | undefined;
+    shouldCancelWhenOutside?: boolean | undefined;
+    hitSlop?: HitSlop | undefined;
+    activeCursor?: ActiveCursor | undefined;
+    mouseButton?: MouseButton | undefined;
+    cancelsTouchesInView?: boolean | undefined;
+    cancelsJSResponder?: boolean | undefined;
+    manualActivation?: boolean | undefined;
   },
   ActiveCursor | MouseButton
 >;

package/src/v3/types/DetectorTypes.ts

@@ -1,27 +1,49 @@
-import {
+import type {
+  TouchAction,
+  UserSelect,
+} from '../../handlers/gestureHandlerCommon';
+import type {
   AnimatedEvent,
-  GestureUpdateEventWithHandlerData,
   GestureHandlerEventWithHandlerData,
+  GestureUpdateEventWithHandlerData,
 } from './EventTypes';
 
-export type DetectorCallbacks<THandlerData> = {
+export type DetectorCallbacks<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
   jsEventHandler:
     | undefined
-    | ((event: GestureHandlerEventWithHandlerData<THandlerData>) => void);
+    | ((
+        event: GestureHandlerEventWithHandlerData<
+          THandlerData,
+          TExtendedHandlerData
+        >
+      ) => void);
   reanimatedEventHandler:
     | undefined
-    | ((event: GestureHandlerEventWithHandlerData<THandlerData>) => void);
+    | ((
+        event: GestureHandlerEventWithHandlerData<
+          THandlerData,
+          TExtendedHandlerData
+        >
+      ) => void);
   animatedEventHandler:
     | undefined
     | AnimatedEvent
-    | ((event: GestureUpdateEventWithHandlerData<THandlerData>) => void);
+    | ((
+        event: GestureUpdateEventWithHandlerData<TExtendedHandlerData>
+      ) => void);
 };
 
 export type VirtualChild = {
   viewTag: number;
   handlerTags: number[];
-  methods: DetectorCallbacks<unknown>;
+  methods: DetectorCallbacks<unknown, unknown>;
 
   // only set on web
   viewRef: unknown;
+  userSelect?: UserSelect | undefined;
+  touchAction?: TouchAction | undefined;
+  enableContextMenu?: boolean | undefined;
 };

package/src/v3/types/EventTypes.ts

@@ -1,7 +1,8 @@
-import { Animated, NativeSyntheticEvent } from 'react-native';
-import { GestureTouchEvent } from '../../handlers/gestureHandlerCommon';
-import { PointerType } from '../../PointerType';
-import { State } from '../../State';
+import type { Animated, NativeSyntheticEvent } from 'react-native';
+
+import type { GestureTouchEvent } from '../../handlers/gestureHandlerCommon';
+import type { PointerType } from '../../PointerType';
+import type { State } from '../../State';
 
 type EventPayload = {
   handlerTag: number;
@@ -27,13 +28,19 @@ export type GestureStateChangeEventWithHandlerData<T> =
     handlerData: HandlerData<T>;
   };
 
-export type GestureHandlerEventWithHandlerData<THandlerData> =
-  | UpdateEventWithHandlerData<THandlerData>
+export type GestureHandlerEventWithHandlerData<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | UpdateEventWithHandlerData<TExtendedHandlerData>
   | StateChangeEventWithHandlerData<THandlerData>
   | TouchEvent;
 
-export type UnpackedGestureHandlerEventWithHandlerData<THandlerData> =
-  | GestureUpdateEventWithHandlerData<THandlerData>
+export type UnpackedGestureHandlerEventWithHandlerData<
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | GestureUpdateEventWithHandlerData<TExtendedHandlerData>
   | GestureStateChangeEventWithHandlerData<THandlerData>
   | GestureTouchEvent;
 
@@ -53,6 +60,10 @@ export type GestureEvent<THandlerData> = {
   handlerTag: number;
 } & HandlerData<THandlerData>;
 
+export type GestureEndEvent<THandlerData> = {
+  canceled: boolean;
+} & GestureEvent<THandlerData>;
+
 export type UnpackedGestureHandlerEvent<THandlerData> =
   | GestureEvent<THandlerData>
   | GestureTouchEvent;
@@ -64,12 +75,12 @@ export type AnimatedEvent = {
   _argMapping: (Animated.Mapping | null)[];
 };
 
-export type ChangeCalculatorType<THandlerData> = (
-  current: GestureUpdateEventWithHandlerData<THandlerData>,
-  previous?: GestureUpdateEventWithHandlerData<THandlerData>
-) => GestureUpdateEventWithHandlerData<THandlerData>;
+export type ChangeCalculatorType<TExtendedHandlerData> = (
+  current: GestureUpdateEventWithHandlerData<TExtendedHandlerData>,
+  previous?: GestureUpdateEventWithHandlerData<TExtendedHandlerData>
+) => GestureUpdateEventWithHandlerData<TExtendedHandlerData>;
 
-export type DiffCalculatorType<THandlerData> = (
-  current: HandlerData<THandlerData>,
-  previous: HandlerData<THandlerData> | null
-) => Partial<HandlerData<THandlerData>>;
+export type DiffCalculatorType<TExtendedHandlerData> = (
+  current: HandlerData<TExtendedHandlerData>,
+  previous: HandlerData<TExtendedHandlerData> | null
+) => Partial<HandlerData<TExtendedHandlerData>>;

package/src/v3/types/GestureTypes.ts

@@ -1,61 +1,88 @@
-import { DetectorCallbacks } from './DetectorTypes';
-import {
+import type {
   CommonGestureConfig,
   ComposedGestureConfig,
   GestureCallbacks,
   GestureRelations,
   InternalConfigProps,
 } from './ConfigTypes';
-import { FilterNeverProperties } from './UtilityTypes';
+import type { DetectorCallbacks } from './DetectorTypes';
+import type { FilterNeverProperties } from './UtilityTypes';
 
 // Unfortunately, this type cannot be moved into ConfigTypes.ts because of circular dependency
 export type ExternalRelations = {
-  simultaneousWith?: AnyGesture | AnyGesture[];
-  requireToFail?: AnyGesture | AnyGesture[];
-  block?: AnyGesture | AnyGesture[];
+  simultaneousWith?: AnyGesture | AnyGesture[] | undefined;
+  requireToFail?: AnyGesture | AnyGesture[] | undefined;
+  block?: AnyGesture | AnyGesture[] | undefined;
 };
 
 // Similarly, this type cannot be moved into ConfigTypes.ts because it depends on `ExternalRelations`
-export type BaseGestureConfig<THandlerData, TConfig> = ExternalRelations &
-  GestureCallbacks<THandlerData> &
+export type BaseGestureConfig<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = ExternalRelations &
+  GestureCallbacks<THandlerData, TExtendedHandlerData> &
   FilterNeverProperties<TConfig> &
-  InternalConfigProps<THandlerData> &
+  InternalConfigProps<TExtendedHandlerData> &
   CommonGestureConfig;
 
-export type BaseDiscreteGestureConfig<THandlerData, TConfig> = Omit<
-  BaseGestureConfig<THandlerData, TConfig>,
+export type BaseDiscreteGestureConfig<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = Omit<
+  BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>,
   'onUpdate'
 >;
 
-export type SingleGesture<THandlerData, TConfig> = {
+export type SingleGesture<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
   handlerTag: number;
   type: SingleGestureName;
-  config: BaseGestureConfig<THandlerData, TConfig>;
-  detectorCallbacks: DetectorCallbacks<THandlerData>;
+  config: BaseGestureConfig<TConfig, THandlerData, TExtendedHandlerData>;
+  detectorCallbacks: DetectorCallbacks<THandlerData, TExtendedHandlerData>;
   gestureRelations: GestureRelations;
 };
 
-export type DiscreteSingleGesture<THandlerData, TConfig> = {
-  [K in keyof SingleGesture<THandlerData, TConfig>]: K extends 'config'
-    ? Omit<SingleGesture<THandlerData, TConfig>[K], 'onUpdate'>
-    : SingleGesture<THandlerData, TConfig>[K];
+export type DiscreteSingleGesture<
+  TConfig,
+  THandlerData,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> = {
+  [K in keyof SingleGesture<
+    TConfig,
+    THandlerData,
+    TExtendedHandlerData
+  >]: K extends 'config'
+    ? Omit<
+        SingleGesture<TConfig, THandlerData, TExtendedHandlerData>[K],
+        'onUpdate'
+      >
+    : SingleGesture<TConfig, THandlerData, TExtendedHandlerData>[K];
 };
 
 export type ComposedGesture = {
   handlerTags: number[];
   type: ComposedGestureName;
   config: ComposedGestureConfig;
-  detectorCallbacks: DetectorCallbacks<unknown>;
+  detectorCallbacks: DetectorCallbacks<unknown, unknown>;
   externalSimultaneousHandlers: number[];
   gestures: Gesture[];
 };
 
-export type Gesture<THandlerData = unknown, TConfig = unknown> =
-  | SingleGesture<THandlerData, TConfig>
+export type Gesture<
+  TConfig = unknown,
+  THandlerData = unknown,
+  TExtendedHandlerData extends THandlerData = THandlerData,
+> =
+  | SingleGesture<TConfig, THandlerData, TExtendedHandlerData>
   | ComposedGesture;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyGesture = Gesture<any, unknown>;
+export type AnyGesture = Gesture<unknown, any>;
 
 export enum SingleGestureName {
   Tap = 'TapGestureHandler',

package/src/v3/types/NativeWrapperType.ts

@@ -1,8 +1,23 @@
-import { CommonGestureConfig, ExternalRelations, GestureCallbacks } from '.';
-import { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeProperties';
-import { NativeViewHandlerData } from '../hooks/gestures/native/useNativeGesture';
+import type {
+  NativeGesture,
+  NativeGestureNativeProperties,
+  NativeHandlerData,
+} from '../hooks/gestures/native/NativeTypes';
+import type {
+  CommonGestureConfig,
+  ExternalRelations,
+  GestureCallbacks,
+} from '.';
 
-export type NativeWrapperProperties = CommonGestureConfig &
-  GestureCallbacks<NativeViewHandlerData> &
+export type WrapperSpecificProperties<T = unknown> = {
+  ref?: React.Ref<T> | undefined;
+  onGestureUpdate_CAN_CAUSE_INFINITE_RERENDER?: (
+    gesture: NativeGesture
+  ) => void;
+};
+
+export type NativeWrapperProperties<T = unknown> = CommonGestureConfig &
+  GestureCallbacks<NativeHandlerData> &
   NativeGestureNativeProperties &
-  ExternalRelations;
+  ExternalRelations &
+  WrapperSpecificProperties<T>;

package/src/v3/types/ReanimatedTypes.ts

@@ -37,7 +37,7 @@ type WithSharedValueRecursive<T extends object, P> = {
     ? Simplify<SharedValueOrT<T[K], P>>
     : // Special case for boolean as passing `boolean` as P doesn't look ok.
       boolean extends T[K]
-      ? boolean | SharedValue<boolean>
+      ? boolean | SharedValue<boolean> | Extract<T[K], undefined>
       : // Special handling for tuples [number, number].
         T[K] extends [number, number]
         ? [WithSharedValue<number, P>, WithSharedValue<number, P>]

package/src/v3/types/UtilityTypes.ts

@@ -1,10 +1,10 @@
-import { PanGestureNativeProperties } from '../hooks/gestures/pan/PanProperties';
-import { FlingGestureNativeProperties } from '../hooks/gestures/fling/FlingProperties';
-import { HoverGestureNativeProperties } from '../hooks/gestures/hover/HoverProperties';
-import { LongPressGestureNativeProperties } from '../hooks/gestures/longPress/LongPressProperties';
-import { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeProperties';
-import { TapGestureNativeConfig } from '../hooks/gestures/tap/TapProperties';
-import { InternalConfigProps } from './ConfigTypes';
+import type { FlingGestureNativeProperties } from '../hooks/gestures/fling/FlingTypes';
+import type { HoverGestureNativeProperties } from '../hooks/gestures/hover/HoverTypes';
+import type { LongPressGestureNativeProperties } from '../hooks/gestures/longPress/LongPressTypes';
+import type { NativeGestureNativeProperties } from '../hooks/gestures/native/NativeTypes';
+import type { PanGestureNativeProperties } from '../hooks/gestures/pan/PanTypes';
+import type { TapGestureNativeConfig } from '../hooks/gestures/tap/TapTypes';
+import type { InternalConfigProps } from './ConfigTypes';
 
 export type HandlersPropsWhiteList =
   | Set<keyof PanGestureNativeProperties>

package/src/v3/types/index.ts

@@ -1,52 +1,48 @@
 export type {
-  SharedValue,
-  SharedValueOrT,
-  WithSharedValue,
-} from './ReanimatedTypes';
-
-export type {
-  HandlerData,
-  GestureUpdateEventWithHandlerData,
-  GestureStateChangeEventWithHandlerData,
-  GestureHandlerEventWithHandlerData,
-  UnpackedGestureHandlerEventWithHandlerData,
-  UnpackedGestureHandlerEvent,
-  UpdateEventWithHandlerData,
-  StateChangeEventWithHandlerData,
-  TouchEvent,
-  GestureEvent,
-  AnimatedEvent,
-  ChangeCalculatorType,
-  DiffCalculatorType,
-} from './EventTypes';
-
-export type {
+  CommonGestureConfig,
+  ComposedGestureConfig,
   GestureCallbacks,
+  GestureEndEventCallback,
   GestureEventCallback,
-  GestureEventCallbackWithDidSucceed,
-  GestureTouchEventCallback,
   GestureRelations,
+  GestureTouchEventCallback,
   InternalConfigProps,
-  CommonGestureConfig,
-  ComposedGestureConfig,
 } from './ConfigTypes';
-
 export type { DetectorCallbacks, VirtualChild } from './DetectorTypes';
-
-export { SingleGestureName, ComposedGestureName } from './GestureTypes';
 export type {
-  ExternalRelations,
+  AnimatedEvent,
+  ChangeCalculatorType,
+  DiffCalculatorType,
+  GestureEndEvent,
+  GestureEvent,
+  GestureHandlerEventWithHandlerData,
+  GestureStateChangeEventWithHandlerData,
+  GestureUpdateEventWithHandlerData,
+  HandlerData,
+  StateChangeEventWithHandlerData,
+  TouchEvent,
+  UnpackedGestureHandlerEvent,
+  UnpackedGestureHandlerEventWithHandlerData,
+  UpdateEventWithHandlerData,
+} from './EventTypes';
+export type {
+  AnyGesture,
   BaseDiscreteGestureConfig,
   BaseGestureConfig,
-  SingleGesture,
-  DiscreteSingleGesture,
   ComposedGesture,
+  DiscreteSingleGesture,
+  ExternalRelations,
   Gesture,
-  AnyGesture,
+  SingleGesture,
 } from './GestureTypes';
-
+export { ComposedGestureName, SingleGestureName } from './GestureTypes';
+export type {
+  SharedValue,
+  SharedValueOrT,
+  WithSharedValue,
+} from './ReanimatedTypes';
 export type {
-  HandlersPropsWhiteList,
-  FilterNeverProperties,
   ExcludeInternalConfigProps,
+  FilterNeverProperties,
+  HandlersPropsWhiteList,
 } from './UtilityTypes';

package/src/web/Gestures.ts

@@ -1,13 +1,13 @@
 // Gesture Handlers
-import PanGestureHandler from './handlers/PanGestureHandler';
-import TapGestureHandler from './handlers/TapGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
 import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import PanGestureHandler from './handlers/PanGestureHandler';
 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 TapGestureHandler from './handlers/TapGestureHandler';
 
 export const Gestures = {
   NativeViewGestureHandler,

package/src/web/constants.ts

@@ -1,2 +1,3 @@
 export const DEFAULT_TOUCH_SLOP = 15;
 export const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;
+export const NATIVE_GESTURE_ROLE_ATTRIBUTE = 'rngh-role';