@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/src/handlers/gestures/reanimatedWrapper.ts

@@ -0,0 +1,56 @@
+import { ComponentClass } from 'react';
+import {
+  GestureUpdateEvent,
+  GestureStateChangeEvent,
+} from '../gestureHandlerCommon';
+import { tagMessage } from '../../utils';
+
+export interface SharedValue<T> {
+  value: T;
+}
+
+let Reanimated: {
+  default: {
+    // Slightly modified definition copied from 'react-native-reanimated'
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    createAnimatedComponent<P extends object>(
+      component: ComponentClass<P>,
+      options?: unknown
+    ): ComponentClass<P>;
+  };
+  useEvent: (
+    callback: (event: GestureUpdateEvent | GestureStateChangeEvent) => void,
+    events: string[],
+    rebuild: boolean
+  ) => unknown;
+  useSharedValue: <T>(value: T) => SharedValue<T>;
+  setGestureState: (handlerTag: number, newState: number) => void;
+};
+
+try {
+  Reanimated = require('react-native-reanimated');
+} catch (e) {
+  // When 'react-native-reanimated' is not available we want to quietly continue
+  // @ts-ignore TS demands the variable to be initialized
+  Reanimated = undefined;
+}
+
+if (!Reanimated?.useSharedValue) {
+  // @ts-ignore Make sure the loaded module is actually Reanimated, if it's not
+  // reset the module to undefined so we can fallback to the default implementation
+  Reanimated = undefined;
+}
+
+if (Reanimated !== undefined && !Reanimated.setGestureState) {
+  // The loaded module is Reanimated but it doesn't have the setGestureState defined
+  Reanimated.setGestureState = () => {
+    'worklet';
+    console.warn(
+      tagMessage(
+        'Please use newer version of react-native-reanimated in order to control state of the gestures.'
+      )
+    );
+  };
+}
+
+export { Reanimated };

package/src/handlers/gestures/rotationGesture.ts

@@ -0,0 +1,51 @@
+import { ContinousBaseGesture } from './gesture';
+import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
+import { GestureUpdateEvent } from '../gestureHandlerCommon';
+
+type RotationGestureChangeEventPayload = {
+  rotationChange: number;
+};
+
+function changeEventCalculator(
+  current: GestureUpdateEvent<RotationGestureHandlerEventPayload>,
+  previous?: GestureUpdateEvent<RotationGestureHandlerEventPayload>
+) {
+  'worklet';
+  let changePayload: RotationGestureChangeEventPayload;
+  if (previous === undefined) {
+    changePayload = {
+      rotationChange: current.rotation,
+    };
+  } else {
+    changePayload = {
+      rotationChange: current.rotation - previous.rotation,
+    };
+  }
+
+  return { ...current, ...changePayload };
+}
+
+export class RotationGesture extends ContinousBaseGesture<
+  RotationGestureHandlerEventPayload,
+  RotationGestureChangeEventPayload
+> {
+  constructor() {
+    super();
+
+    this.handlerName = 'RotationGestureHandler';
+  }
+
+  onChange(
+    callback: (
+      event: GestureUpdateEvent<
+        RotationGestureHandlerEventPayload & RotationGestureChangeEventPayload
+      >
+    ) => void
+  ) {
+    // @ts-ignore TS being overprotective, RotationGestureHandlerEventPayload is Record
+    this.handlers.changeEventCalculator = changeEventCalculator;
+    return super.onChange(callback);
+  }
+}
+
+export type RotationGestureType = InstanceType<typeof RotationGesture>;

package/src/handlers/gestures/tapGesture.ts

@@ -0,0 +1,53 @@
+import { BaseGestureConfig, BaseGesture } from './gesture';
+import {
+  TapGestureConfig,
+  TapGestureHandlerEventPayload,
+} from '../TapGestureHandler';
+
+export class TapGesture extends BaseGesture<TapGestureHandlerEventPayload> {
+  public config: BaseGestureConfig & TapGestureConfig = {};
+
+  constructor() {
+    super();
+
+    this.handlerName = 'TapGestureHandler';
+    this.shouldCancelWhenOutside(true);
+  }
+
+  minPointers(minPointers: number) {
+    this.config.minPointers = minPointers;
+    return this;
+  }
+
+  numberOfTaps(count: number) {
+    this.config.numberOfTaps = count;
+    return this;
+  }
+
+  maxDistance(maxDist: number) {
+    this.config.maxDist = maxDist;
+    return this;
+  }
+
+  maxDuration(duration: number) {
+    this.config.maxDurationMs = duration;
+    return this;
+  }
+
+  maxDelay(delay: number) {
+    this.config.maxDelayMs = delay;
+    return this;
+  }
+
+  maxDeltaX(delta: number) {
+    this.config.maxDeltaX = delta;
+    return this;
+  }
+
+  maxDeltaY(delta: number) {
+    this.config.maxDeltaY = delta;
+    return this;
+  }
+}
+
+export type TapGestureType = InstanceType<typeof TapGesture>;

package/src/handlers/handlersRegistry.ts

@@ -0,0 +1,60 @@
+import { isJestEnv } from '../utils';
+import { GestureType } from './gestures/gesture';
+import { GestureEvent, HandlerStateChangeEvent } from './gestureHandlerCommon';
+
+export const handlerIDToTag: Record<string, number> = {};
+const gestures = new Map<number, GestureType>();
+const oldHandlers = new Map<number, GestureHandlerCallbacks>();
+const testIDs = new Map<string, number>();
+
+let handlerTag = 1;
+
+export function getNextHandlerTag(): number {
+  return handlerTag++;
+}
+
+export function registerHandler(
+  handlerTag: number,
+  handler: GestureType,
+  testID?: string
+) {
+  gestures.set(handlerTag, handler);
+  if (isJestEnv() && testID) {
+    testIDs.set(testID, handlerTag);
+  }
+}
+
+export function registerOldGestureHandler(
+  handlerTag: number,
+  handler: GestureHandlerCallbacks
+) {
+  oldHandlers.set(handlerTag, handler);
+}
+
+export function unregisterHandler(handlerTag: number, testID?: string) {
+  gestures.delete(handlerTag);
+  if (isJestEnv() && testID) {
+    testIDs.delete(testID);
+  }
+}
+
+export function findHandler(handlerTag: number) {
+  return gestures.get(handlerTag);
+}
+
+export function findOldGestureHandler(handlerTag: number) {
+  return oldHandlers.get(handlerTag);
+}
+
+export function findHandlerByTestID(testID: string) {
+  const handlerTag = testIDs.get(testID);
+  if (handlerTag !== undefined) {
+    return findHandler(handlerTag) ?? null;
+  }
+  return null;
+}
+
+export interface GestureHandlerCallbacks {
+  onGestureEvent: (event: GestureEvent<any>) => void;
+  onGestureStateChange: (event: HandlerStateChangeEvent<any>) => void;
+}

package/src/index.ts

@@ -0,0 +1,174 @@
+import { initialize } from './init';
+
+export { Directions } from './Directions';
+export { State } from './State';
+export { default as gestureHandlerRootHOC } from './components/gestureHandlerRootHOC';
+export { default as GestureHandlerRootView } from './components/GestureHandlerRootView';
+export type {
+  // event types
+  GestureEvent,
+  HandlerStateChangeEvent,
+  // event payloads types
+  GestureEventPayload,
+  HandlerStateChangeEventPayload,
+  // pointer events
+  GestureTouchEvent,
+  TouchData,
+  // new api event types
+  GestureUpdateEvent,
+  GestureStateChangeEvent,
+} from './handlers/gestureHandlerCommon';
+export type { GestureType } from './handlers/gestures/gesture';
+export type {
+  TapGestureHandlerEventPayload,
+  TapGestureHandlerProps,
+} from './handlers/TapGestureHandler';
+export type {
+  ForceTouchGestureHandlerEventPayload,
+  ForceTouchGestureHandlerProps,
+} from './handlers/ForceTouchGestureHandler';
+export type { ForceTouchGestureChangeEventPayload } from './handlers/gestures/forceTouchGesture';
+export type {
+  LongPressGestureHandlerEventPayload,
+  LongPressGestureHandlerProps,
+} from './handlers/LongPressGestureHandler';
+export type {
+  PanGestureHandlerEventPayload,
+  PanGestureHandlerProps,
+} from './handlers/PanGestureHandler';
+export type { PanGestureChangeEventPayload } from './handlers/gestures/panGesture';
+export type {
+  PinchGestureHandlerEventPayload,
+  PinchGestureHandlerProps,
+} from './handlers/PinchGestureHandler';
+export type { PinchGestureChangeEventPayload } from './handlers/gestures/pinchGesture';
+export type {
+  RotationGestureHandlerEventPayload,
+  RotationGestureHandlerProps,
+} from './handlers/RotationGestureHandler';
+export type {
+  FlingGestureHandlerEventPayload,
+  FlingGestureHandlerProps,
+} from './handlers/FlingGestureHandler';
+export { TapGestureHandler } from './handlers/TapGestureHandler';
+export { ForceTouchGestureHandler } from './handlers/ForceTouchGestureHandler';
+export { LongPressGestureHandler } from './handlers/LongPressGestureHandler';
+export { PanGestureHandler } from './handlers/PanGestureHandler';
+export { PinchGestureHandler } from './handlers/PinchGestureHandler';
+export { RotationGestureHandler } from './handlers/RotationGestureHandler';
+export { FlingGestureHandler } from './handlers/FlingGestureHandler';
+export { default as createNativeWrapper } from './handlers/createNativeWrapper';
+export type {
+  NativeViewGestureHandlerPayload,
+  NativeViewGestureHandlerProps,
+} from './handlers/NativeViewGestureHandler';
+export { GestureDetector } from './handlers/gestures/GestureDetector';
+export { GestureObjects as Gesture } from './handlers/gestures/gestureObjects';
+export type { TapGestureType as TapGesture } from './handlers/gestures/tapGesture';
+export type { PanGestureType as PanGesture } from './handlers/gestures/panGesture';
+export type { FlingGestureType as FlingGesture } from './handlers/gestures/flingGesture';
+export type { LongPressGestureType as LongPressGesture } from './handlers/gestures/longPressGesture';
+export type { PinchGestureType as PinchGesture } from './handlers/gestures/pinchGesture';
+export type { RotationGestureType as RotationGesture } from './handlers/gestures/rotationGesture';
+export type { ForceTouchGestureType as ForceTouchGesture } from './handlers/gestures/forceTouchGesture';
+export type { NativeGestureType as NativeGesture } from './handlers/gestures/nativeGesture';
+export type { ManualGestureType as ManualGesture } from './handlers/gestures/manualGesture';
+export type { HoverGestureType as HoverGesture } from './handlers/gestures/hoverGesture';
+export type {
+  ComposedGestureType as ComposedGesture,
+  RaceGestureType as RaceGesture,
+  SimultaneousGestureType as SimultaneousGesture,
+  ExclusiveGestureType as ExclusiveGesture,
+} from './handlers/gestures/gestureComposition';
+export type { GestureStateManagerType as GestureStateManager } from './handlers/gestures/gestureStateManager';
+export { NativeViewGestureHandler } from './handlers/NativeViewGestureHandler';
+export type {
+  RawButtonProps,
+  BaseButtonProps,
+  RectButtonProps,
+  BorderlessButtonProps,
+} from './components/GestureButtons';
+export {
+  RawButton,
+  BaseButton,
+  RectButton,
+  BorderlessButton,
+  PureNativeButton,
+} from './components/GestureButtons';
+export type {
+  TouchableHighlightProps,
+  TouchableOpacityProps,
+  TouchableWithoutFeedbackProps,
+} from './components/touchables';
+export {
+  TouchableHighlight,
+  TouchableNativeFeedback,
+  TouchableOpacity,
+  TouchableWithoutFeedback,
+} from './components/touchables';
+export {
+  ScrollView,
+  Switch,
+  TextInput,
+  DrawerLayoutAndroid,
+  FlatList,
+  RefreshControl,
+} from './components/GestureComponents';
+export { HoverEffect } from './handlers/gestures/hoverGesture';
+export type {
+  //events
+  GestureHandlerGestureEvent,
+  GestureHandlerStateChangeEvent,
+  //event payloads
+  GestureHandlerGestureEventNativeEvent,
+  GestureHandlerStateChangeNativeEvent,
+  NativeViewGestureHandlerGestureEvent,
+  NativeViewGestureHandlerStateChangeEvent,
+  TapGestureHandlerGestureEvent,
+  TapGestureHandlerStateChangeEvent,
+  ForceTouchGestureHandlerGestureEvent,
+  ForceTouchGestureHandlerStateChangeEvent,
+  LongPressGestureHandlerGestureEvent,
+  LongPressGestureHandlerStateChangeEvent,
+  PanGestureHandlerGestureEvent,
+  PanGestureHandlerStateChangeEvent,
+  PinchGestureHandlerGestureEvent,
+  PinchGestureHandlerStateChangeEvent,
+  RotationGestureHandlerGestureEvent,
+  RotationGestureHandlerStateChangeEvent,
+  FlingGestureHandlerGestureEvent,
+  FlingGestureHandlerStateChangeEvent,
+  // handlers props
+  NativeViewGestureHandlerProperties,
+  TapGestureHandlerProperties,
+  LongPressGestureHandlerProperties,
+  PanGestureHandlerProperties,
+  PinchGestureHandlerProperties,
+  RotationGestureHandlerProperties,
+  FlingGestureHandlerProperties,
+  ForceTouchGestureHandlerProperties,
+  // buttons props
+  RawButtonProperties,
+  BaseButtonProperties,
+  RectButtonProperties,
+  BorderlessButtonProperties,
+} from './handlers/gestureHandlerTypesCompat';
+
+export type { SwipeableProps } from './components/Swipeable';
+export { default as Swipeable } from './components/Swipeable';
+export type {
+  DrawerLayoutProps,
+  DrawerPosition,
+  DrawerState,
+  DrawerType,
+  DrawerLockMode,
+  DrawerKeyboardDismissMode,
+} from './components/DrawerLayout';
+export { default as DrawerLayout } from './components/DrawerLayout';
+
+export {
+  enableExperimentalWebImplementation,
+  enableLegacyWebImplementation,
+} from './EnableNewWebImplementation';
+
+initialize();

package/src/init.ts

@@ -0,0 +1,18 @@
+import { startListening } from './handlers/gestures/eventReceiver';
+import RNGestureHandlerModule from './RNGestureHandlerModule';
+import { isFabric } from './utils';
+
+let fabricInitialized = false;
+
+export function initialize() {
+  startListening();
+}
+
+// since isFabric() may give wrong results before the first render, we call this
+// method during render of GestureHandlerRootView
+export function maybeInitializeFabric() {
+  if (isFabric() && !fabricInitialized) {
+    RNGestureHandlerModule.install();
+    fabricInitialized = true;
+  }
+}

package/src/jestUtils/index.ts

@@ -0,0 +1 @@
+export { getByGestureTestId, fireGestureHandler } from './jestUtils';