react-native-gesture-handler 1.10.1 → 2.1.0

package/src/handlers/gestures/pinchGesture.ts

@@ -0,0 +1,12 @@
+import { ContinousBaseGesture } from './gesture';
+import { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';
+
+export class PinchGesture extends ContinousBaseGesture<PinchGestureHandlerEventPayload> {
+  constructor() {
+    super();
+
+    this.handlerName = 'PinchGestureHandler';
+  }
+}
+
+export type PinchGestureType = InstanceType<typeof PinchGesture>;

package/src/handlers/gestures/reanimatedWrapper.ts

@@ -0,0 +1,45 @@
+import { ComponentClass } from 'react';
+import {
+  GestureUpdateEvent,
+  GestureStateChangeEvent,
+} from '../gestureHandlerCommon';
+
+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');
+
+  if (!Reanimated.setGestureState) {
+    Reanimated.setGestureState = () => {
+      'worklet';
+      console.warn(
+        'Please use newer version of react-native-reanimated in order to control state of the gestures.'
+      );
+    };
+  }
+  // When 'react-native-reanimated' is not available we want to
+  // quietly continue
+  // eslint-disable-next-line no-empty
+} catch (e) {}
+
+export { Reanimated };

package/src/handlers/gestures/rotationGesture.ts

@@ -0,0 +1,12 @@
+import { ContinousBaseGesture } from './gesture';
+import { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';
+
+export class RotationGesture extends ContinousBaseGesture<RotationGestureHandlerEventPayload> {
+  constructor() {
+    super();
+
+    this.handlerName = 'RotationGestureHandler';
+  }
+}
+
+export type RotationGestureType = InstanceType<typeof RotationGesture>;

package/src/handlers/gestures/tapGesture.ts

@@ -0,0 +1,52 @@
+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';
+  }
+
+  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,22 @@
+import { GestureType } from './gestures/gesture';
+
+export const handlerIDToTag: Record<string, number> = {};
+const handlers = new Map<number, GestureType>();
+
+let handlerTag = 1;
+
+export function getNextHandlerTag(): number {
+  return handlerTag++;
+}
+
+export function registerHandler(handlerTag: number, handler: GestureType) {
+  handlers.set(handlerTag, handler);
+}
+
+export function unregisterHandler(handlerTag: number) {
+  handlers.delete(handlerTag);
+}
+
+export function findHandler(handlerTag: number) {
+  return handlers.get(handlerTag);
+}

package/src/index.ts

@@ -0,0 +1,156 @@
+import { initialize } from './init';
+
+export { Directions } from './Directions';
+export { State } from './State';
+export { default as gestureHandlerRootHOC } from './gestureHandlerRootHOC';
+export { default as GestureHandlerRootView } from './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 {
+  LongPressGestureHandlerEventPayload,
+  LongPressGestureHandlerProps,
+} from './handlers/LongPressGestureHandler';
+export type {
+  PanGestureHandlerEventPayload,
+  PanGestureHandlerProps,
+} from './handlers/PanGestureHandler';
+export type {
+  PinchGestureHandlerEventPayload,
+  PinchGestureHandlerProps,
+} from './handlers/PinchGestureHandler';
+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 { TapGestureType as TapGesture } from './handlers/gestures/tapGesture';
+export { PanGestureType as PanGesture } from './handlers/gestures/panGesture';
+export { FlingGestureType as FlingGesture } from './handlers/gestures/flingGesture';
+export { LongPressGestureType as LongPressGesture } from './handlers/gestures/longPressGesture';
+export { PinchGestureType as PinchGesture } from './handlers/gestures/pinchGesture';
+export { RotationGestureType as RotationGesture } from './handlers/gestures/rotationGesture';
+export { ForceTouchGestureType as ForceTouchGesture } from './handlers/gestures/forceTouchGesture';
+export { NativeGestureType as NativeGesture } from './handlers/gestures/nativeGesture';
+export { ManualGestureType as ManualGesture } from './handlers/gestures/manualGesture';
+export {
+  ComposedGestureType as ComposedGesture,
+  RaceGestureType as RaceGesture,
+  SimultaneousGestureType as SimultaneousGesture,
+  ExclusiveGestureType as ExclusiveGesture,
+} from './handlers/gestures/gestureComposition';
+export { 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,
+} from './components/GestureButtons';
+export {
+  TouchableHighlight,
+  TouchableNativeFeedback,
+  TouchableOpacity,
+  TouchableWithoutFeedback,
+} from './components/touchables';
+export {
+  ScrollView,
+  Switch,
+  TextInput,
+  DrawerLayoutAndroid,
+  FlatList,
+} from './components/GestureComponents';
+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 { default as Swipeable } from './components/Swipeable';
+export type {
+  DrawerLayoutProps,
+  DrawerPosition,
+  DrawerState,
+  DrawerType,
+  DrawerLockMode,
+  DrawerKeyboardDismissMode,
+} from './components/DrawerLayout';
+export { default as DrawerLayout } from './components/DrawerLayout';
+
+initialize();

package/src/init.ts

@@ -0,0 +1,5 @@
+import { startListening } from './handlers/gestures/eventReceiver';
+
+export function initialize() {
+  startListening();
+}

package/src/mocks.ts

@@ -0,0 +1,65 @@
+import {
+  TouchableHighlight,
+  TouchableNativeFeedback,
+  TouchableOpacity,
+  TouchableWithoutFeedback,
+  ScrollView,
+  FlatList,
+  Switch,
+  TextInput,
+  DrawerLayoutAndroid,
+  View,
+} from 'react-native';
+import { State } from './State';
+import { Directions } from './Directions';
+
+const NOOP = () => {
+  // do nothing
+};
+const PanGestureHandler = View;
+const attachGestureHandler = NOOP;
+const createGestureHandler = NOOP;
+const dropGestureHandler = NOOP;
+const updateGestureHandler = NOOP;
+const NativeViewGestureHandler = View;
+const TapGestureHandler = View;
+const ForceTouchGestureHandler = View;
+const LongPressGestureHandler = View;
+const PinchGestureHandler = View;
+const RotationGestureHandler = View;
+const FlingGestureHandler = View;
+const RawButton = TouchableNativeFeedback;
+const BaseButton = TouchableNativeFeedback;
+const RectButton = TouchableNativeFeedback;
+const BorderlessButton = TouchableNativeFeedback;
+
+export default {
+  TouchableHighlight,
+  TouchableNativeFeedback,
+  TouchableOpacity,
+  TouchableWithoutFeedback,
+  ScrollView,
+  FlatList,
+  Switch,
+  TextInput,
+  DrawerLayoutAndroid,
+  NativeViewGestureHandler,
+  TapGestureHandler,
+  ForceTouchGestureHandler,
+  LongPressGestureHandler,
+  PinchGestureHandler,
+  RotationGestureHandler,
+  FlingGestureHandler,
+  RawButton,
+  BaseButton,
+  RectButton,
+  BorderlessButton,
+  PanGestureHandler,
+  attachGestureHandler,
+  createGestureHandler,
+  dropGestureHandler,
+  updateGestureHandler,
+  // probably can be removed
+  Directions,
+  State,
+} as const;

package/src/utils.ts

@@ -0,0 +1,7 @@
+export function toArray<T>(object: T | T[]): T[] {
+  if (!Array.isArray(object)) {
+    return [object];
+  }
+
+  return object;
+}

package/src/web/GestureHandler.ts

@@ -466,8 +466,7 @@ function invokeNullableMethod(
         if ('__nodeConfig' in method) {
           const { argMapping } = method.__nodeConfig;
           if (Array.isArray(argMapping)) {
-            for (const index in argMapping) {
-              const [key, value] = argMapping[index];
+            for (const [index, [key, value]] of argMapping.entries()) {
               if (key in event.nativeEvent) {
                 // @ts-ignore fix method type
                 const nativeValue = event.nativeEvent[key];
@@ -509,7 +508,7 @@ function ensureConfig(config: Config): Required<Config> {
       .map(({ handlerTag }: { handlerTag: number }) =>
         NodeManager.getHandler(handlerTag)
       )
-      .filter(v => v);
+      .filter((v) => v);
   } else {
     props.waitFor = null;
   }

package/src/web/NativeViewGestureHandler.ts

@@ -1,5 +1,3 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
 import DiscreteGestureHandler from './DiscreteGestureHandler';
 import { HammerInputExt } from './GestureHandler';
 import * as NodeManager from './NodeManager';
@@ -15,7 +13,7 @@ class NativeViewGestureHandler extends PressGestureHandler {
         // @ts-ignore FIXME(TS) config type
         if (this.config.disallowInterruption) {
           const gestures = Object.values(NodeManager.getNodes()).filter(
-            gesture => {
+            (gesture) => {
               const { handlerTag, view, isGestureRunning } = gesture;
               return (
                 // Check if this gesture isn't self

package/src/web/NodeManager.ts

@@ -22,6 +22,11 @@ export function createGestureHandler(
 }
 
 export function dropGestureHandler(handlerTag: number) {
+  // Since React 18, there are cases where componentWillUnmount gets called twice in a row
+  // so skip this if the tag was already removed.
+  if (!(handlerTag in gestures)) {
+    return;
+  }
   getHandler(handlerTag).destroy();
   // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
   delete gestures[handlerTag];

package/android/lib/src/main/java/com/swmansion/gesturehandler/BaseGestureHandlerInteractionController.java

@@ -1,23 +0,0 @@
-package com.swmansion.gesturehandler;
-
-public abstract class BaseGestureHandlerInteractionController
-        implements GestureHandlerInteractionController {
-
-  @Override
-  public boolean shouldWaitForHandlerFailure(GestureHandler handler,
-                                             GestureHandler otherHandler) {
-    return false;
-  }
-
-  @Override
-  public boolean shouldRequireHandlerToWaitForFailure(GestureHandler handler,
-                                                      GestureHandler otherHandler) {
-    return false;
-  }
-
-  @Override
-  public boolean shouldRecognizeSimultaneously(GestureHandler handler,
-                                               GestureHandler otherHandler) {
-    return false;
-  }
-}

package/android/lib/src/main/java/com/swmansion/gesturehandler/FlingGestureHandler.java

@@ -1,110 +0,0 @@
-package com.swmansion.gesturehandler;
-
-import android.os.Handler;
-import android.view.MotionEvent;
-
-public class FlingGestureHandler extends GestureHandler<FlingGestureHandler> {
-  private static final long DEFAULT_MAX_DURATION_MS = 800;
-  private static final long DEFAULT_MIN_ACCEPTABLE_DELTA = 160;
-  private static final int DEFAULT_DIRECTION = DIRECTION_RIGHT;
-  private static final int DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
-  
-  private long mMaxDurationMs = DEFAULT_MAX_DURATION_MS;
-  private long mMinAcceptableDelta = DEFAULT_MIN_ACCEPTABLE_DELTA;
-  private int mDirection = DEFAULT_DIRECTION;
-  private int mNumberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED;
-  private float mStartX, mStartY;
-
-  private Handler mHandler;
-  private int mMaxNumberOfPointersSimultaneously;
-
-  private final Runnable mFailDelayed = new Runnable() {
-    @Override
-    public void run() {
-      fail();
-    }
-  };
-
-  public void setNumberOfPointersRequired(int numberOfPointersRequired) {
-    mNumberOfPointersRequired = numberOfPointersRequired;
-  }
-
-  public void setDirection(int direction) {
-    mDirection = direction;
-  }
-
-  private void startFling(MotionEvent event) {
-    mStartX = event.getRawX();
-    mStartY = event.getRawY();
-    begin();
-    mMaxNumberOfPointersSimultaneously = 1;
-    if (mHandler == null) {
-      mHandler = new Handler();
-    } else {
-      mHandler.removeCallbacksAndMessages(null);
-    }
-    mHandler.postDelayed(mFailDelayed, mMaxDurationMs);
-  }
-
-  private boolean tryEndFling(MotionEvent event) {
-    if (mMaxNumberOfPointersSimultaneously == mNumberOfPointersRequired &&
-            (((mDirection & DIRECTION_RIGHT) != 0 &&
-                    event.getRawX() - mStartX > mMinAcceptableDelta) ||
-                    ((mDirection & DIRECTION_LEFT) !=0 &&
-                            mStartX - event.getRawX() > mMinAcceptableDelta) ||
-                    ((mDirection & DIRECTION_UP) !=0 &&
-                            mStartY - event.getRawY() > mMinAcceptableDelta) ||
-                    ((mDirection & DIRECTION_DOWN) !=0 &&
-                            event.getRawY() - mStartY > mMinAcceptableDelta))) {
-      mHandler.removeCallbacksAndMessages(null);
-      activate();
-      end();
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  private void endFling(MotionEvent event) {
-    if (!tryEndFling(event)) {
-      fail();
-    }
-
-  }
-
-  @Override
-  protected void onHandle(MotionEvent event) {
-    int state = getState();
-
-    if (state == STATE_UNDETERMINED) {
-      startFling(event);
-    }
-
-
-    if (state == STATE_BEGAN) {
-      tryEndFling(event);
-      if (event.getPointerCount() > mMaxNumberOfPointersSimultaneously) {
-        mMaxNumberOfPointersSimultaneously = event.getPointerCount();
-      }
-
-      int action = event.getActionMasked();
-      if (action == MotionEvent.ACTION_UP) {
-        endFling(event);
-      }
-    }
-  }
-
-  @Override
-  protected void onCancel() {
-    if (mHandler != null) {
-      mHandler.removeCallbacksAndMessages(null);
-    }
-  }
-
-  @Override
-  protected void onReset() {
-    if (mHandler != null) {
-      mHandler.removeCallbacksAndMessages(null);
-    }
-  }
-}