Merge branch '@akwasniewski/logic-detector' into @akwasniewski/v3-examples

akwasniewski · akwasniewski · commit d00f1ef1bd0a · 2025-10-01T14:48:23.000+02:00
diff --git a/apps/basic-example/metro.config.js b/apps/basic-example/metro.config.js
@@ -2,7 +2,7 @@ const { getDefaultConfig } = require('@react-native/metro-config');
 const { mergeConfig } = require('metro-config');
 
 const path = require('path');
-const exclusionList = require('metro-config/private/defaults/exclusionList');
+const exclusionList = require('metro-config/private/defaults/exclusionList').default;
 const escape = require('escape-string-regexp');
 
 // Gesture handler tries to require 'react-native-reanimated' inside a try...catch
diff --git a/apps/expo-example/metro.config.js b/apps/expo-example/metro.config.js
@@ -1,7 +1,7 @@
 const { getDefaultConfig } = require('expo/metro-config');
 const path = require('path');
 
-const exclusionList = require('metro-config/private/defaults/exclusionList');
+const exclusionList = require('metro-config/private/defaults/exclusionList').default;
 const escape = require('escape-string-regexp');
 const pack = require('./package.json');
 
diff --git a/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonViewManager.kt b/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonViewManager.kt
@@ -262,13 +262,13 @@ class RNGestureHandlerButtonViewManager :
       }
     }
 
-    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-      if (super.onInterceptTouchEvent(ev)) {
+    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+      if (super.onInterceptTouchEvent(event)) {
         return true
       }
       // We call `onTouchEvent` and wait until button changes state to `pressed`, if it's pressed
       // we return true so that the gesture handler can activate.
-      onTouchEvent(ev)
+      onTouchEvent(event)
       return isPressed
     }
 
diff --git a/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt b/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt
@@ -115,12 +115,12 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
     }
   }
 
-  fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+  fun dispatchTouchEvent(event: MotionEvent): Boolean {
     // We mark `mPassingTouch` before we get into `mOrchestrator.onTouchEvent` so that we can tell
     // if `requestDisallow` has been called as a result of a normal gesture handling process or
     // as a result of one of the gesture handlers activating
     passingTouch = true
-    orchestrator!!.onTouchEvent(ev)
+    orchestrator!!.onTouchEvent(event)
     passingTouch = false
     return shouldIntercept
   }
diff --git a/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootView.kt b/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootView.kt
@@ -37,10 +37,10 @@ class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {
     rootHelper?.tearDown()
   }
 
-  override fun dispatchTouchEvent(ev: MotionEvent) = if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(ev)) {
+  override fun dispatchTouchEvent(event: MotionEvent) = if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(event)) {
     true
   } else {
-    super.dispatchTouchEvent(ev)
+    super.dispatchTouchEvent(event)
   }
 
   override fun dispatchGenericMotionEvent(event: MotionEvent) =
diff --git a/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/events/RNGestureHandlerEvent.kt b/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/events/RNGestureHandlerEvent.kt
@@ -60,7 +60,7 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
   }
 
   // Unfortunately getCoalescingKey is not considered when sending event to C++, therefore we have to disable coalescing in v3
-  override fun canCoalesce() = actionType != GestureHandler.ACTION_TYPE_NATIVE_DETECTOR
+  override fun canCoalesce() = !GestureHandler.usesNativeOrLogicDetector(actionType)
 
   override fun getCoalescingKey() = coalescingKey
 
diff --git a/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/events/RNGestureHandlerTouchEvent.kt b/packages/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/events/RNGestureHandlerTouchEvent.kt
@@ -39,7 +39,7 @@ class RNGestureHandlerTouchEvent private constructor() : Event<RNGestureHandlerT
     EVENT_NAME
   }
 
-  override fun canCoalesce() = true
+  override fun canCoalesce() = !GestureHandler.usesNativeOrLogicDetector(actionType)
 
   override fun getCoalescingKey() = coalescingKey
   override fun getEventData(): WritableMap? = extraData
diff --git a/packages/react-native-gesture-handler/apple/RNGestureHandlerManager.mm b/packages/react-native-gesture-handler/apple/RNGestureHandlerManager.mm
@@ -312,36 +312,17 @@ - (void)sendEvent:(RNGestureHandlerStateChange *)event
     case RNGestureHandlerActionTypeLogicDetector: {
       NSNumber *hostDetectorTag = [_registry handlerWithTag:event.handlerTag].hostDetectorTag;
       detectorView = [self viewForReactTag:hostDetectorTag];
-      // intentionally fall through to RNGestureHandlerActionTypeNativeDetector
+      [self sendNativeOrLogicEvent:event
+                    withActionType:actionType
+                    forHandlerType:eventHandlerType
+                           forView:detectorView];
+      break;
     }
     case RNGestureHandlerActionTypeNativeDetector: {
-      if ([event isKindOfClass:[RNGestureHandlerEvent class]]) {
-        switch (eventHandlerType) {
-          case RNGestureHandlerEventHandlerTypeAnimated:
-            [self sendEventForNativeAnimatedEvent:event];
-            break;
-          case RNGestureHandlerEventHandlerTypeReanimated: {
-            RNGestureHandlerEvent *gestureEvent = (RNGestureHandlerEvent *)event;
-            auto nativeEvent = [gestureEvent getReanimatedNativeEvent];
-            [(RNGestureHandlerDetector *)detectorView dispatchReanimatedGestureEvent:nativeEvent];
-            break;
-          }
-          case RNGestureHandlerEventHandlerTypeJS: {
-            RNGestureHandlerEvent *gestureEvent = (RNGestureHandlerEvent *)event;
-            auto nativeEvent = [gestureEvent getNativeEvent];
-            [(RNGestureHandlerDetector *)detectorView dispatchGestureEvent:nativeEvent];
-            break;
-          }
-        }
-      } else {
-        if (eventHandlerType == RNGestureHandlerEventHandlerTypeReanimated) {
-          auto nativeEvent = [event getReanimatedNativeEvent];
-          [(RNGestureHandlerDetector *)detectorView dispatchReanimatedStateChangeEvent:nativeEvent];
-        } else {
-          auto nativeEvent = [event getNativeEvent];
-          [(RNGestureHandlerDetector *)detectorView dispatchStateChangeEvent:nativeEvent];
-        }
-      }
+      [self sendNativeOrLogicEvent:event
+                    withActionType:actionType
+                    forHandlerType:eventHandlerType
+                           forView:detectorView];
       break;
     }
 
@@ -488,6 +469,40 @@ - (void)sendEventForDeviceEvent:(RNGestureHandlerStateChange *)event
   [_eventDispatcher sendDeviceEventWithName:@"onGestureHandlerStateChange" body:body];
 }
 
+- (void)sendNativeOrLogicEvent:(RNGestureHandlerStateChange *)event
+                withActionType:(RNGestureHandlerActionType)actionType
+                forHandlerType:(RNGestureHandlerEventHandlerType)eventHandlerType
+                       forView:(RNGHUIView *)detectorView
+{
+  if ([event isKindOfClass:[RNGestureHandlerEvent class]]) {
+    switch (eventHandlerType) {
+      case RNGestureHandlerEventHandlerTypeAnimated:
+        [self sendEventForNativeAnimatedEvent:event];
+        break;
+      case RNGestureHandlerEventHandlerTypeReanimated: {
+        RNGestureHandlerEvent *gestureEvent = (RNGestureHandlerEvent *)event;
+        auto nativeEvent = [gestureEvent getReanimatedNativeEvent];
+        [(RNGestureHandlerDetector *)detectorView dispatchReanimatedGestureEvent:nativeEvent];
+        break;
+      }
+      case RNGestureHandlerEventHandlerTypeJS: {
+        RNGestureHandlerEvent *gestureEvent = (RNGestureHandlerEvent *)event;
+        auto nativeEvent = [gestureEvent getNativeEvent];
+        [(RNGestureHandlerDetector *)detectorView dispatchGestureEvent:nativeEvent];
+        break;
+      }
+    }
+  } else {
+    if (eventHandlerType == RNGestureHandlerEventHandlerTypeReanimated) {
+      auto nativeEvent = [event getReanimatedNativeEvent];
+      [(RNGestureHandlerDetector *)detectorView dispatchReanimatedStateChangeEvent:nativeEvent];
+    } else {
+      auto nativeEvent = [event getNativeEvent];
+      [(RNGestureHandlerDetector *)detectorView dispatchStateChangeEvent:nativeEvent];
+    }
+  }
+}
+
 - (RNGHUIView *)viewForReactTag:(NSNumber *)reactTag
 {
   return [_viewRegistry viewForReactTag:reactTag];
diff --git a/packages/react-native-gesture-handler/src/components/Pressable/Pressable.tsx b/packages/react-native-gesture-handler/src/components/Pressable/Pressable.tsx
@@ -270,9 +270,13 @@ const Pressable = (props: PressableProps) => {
           stateMachine.reset();
           handlePressOut(pressableEvent, false);
         })
-        .onFinalize(() => {
+        .onFinalize((_event, success) => {
           if (Platform.OS === 'web') {
-            stateMachine.handleEvent(StateMachineEvent.FINALIZE);
+            if (success) {
+              stateMachine.handleEvent(StateMachineEvent.FINALIZE);
+            } else {
+              stateMachine.handleEvent(StateMachineEvent.CANCEL);
+            }
             handleFinalize();
           }
         }),
@@ -301,11 +305,15 @@ const Pressable = (props: PressableProps) => {
             stateMachine.handleEvent(StateMachineEvent.NATIVE_START);
           }
         })
-        .onFinalize(() => {
+        .onFinalize((_event, success) => {
           if (Platform.OS !== 'web') {
             // On Web we use LongPress().onFinalize() instead of Native().onFinalize(),
             // as Native cancels on mouse move, and LongPress does not.
-            stateMachine.handleEvent(StateMachineEvent.FINALIZE);
+            if (success) {
+              stateMachine.handleEvent(StateMachineEvent.FINALIZE);
+            } else {
+              stateMachine.handleEvent(StateMachineEvent.CANCEL);
+            }
             handleFinalize();
           }
         }),
diff --git a/packages/react-native-gesture-handler/src/components/Pressable/stateDefinitions.ts b/packages/react-native-gesture-handler/src/components/Pressable/stateDefinitions.ts
@@ -7,6 +7,7 @@ export enum StateMachineEvent {
   NATIVE_START = 'nativeStart',
   FINALIZE = 'finalize',
   LONG_PRESS_TOUCHES_DOWN = 'longPressTouchesDown',
+  CANCEL = 'cancel',
 }
 
 function getAndroidStatesConfig(
diff --git a/packages/react-native-gesture-handler/src/components/ReanimatedSwipeable/ReanimatedSwipeable.tsx b/packages/react-native-gesture-handler/src/components/ReanimatedSwipeable/ReanimatedSwipeable.tsx
@@ -11,7 +11,11 @@ import Animated, {
   runOnUI,
   useAnimatedStyle,
 } from 'react-native-reanimated';
-import { SwipeableProps, SwipeableMethods, SwipeDirection } from '.';
+import {
+  SwipeableProps,
+  SwipeableMethods,
+  SwipeDirection,
+} from './ReanimatedSwipeableProps';
 import { Gesture } from '../..';
 import {
   GestureStateChangeEvent,
diff --git a/packages/react-native-gesture-handler/src/handlers/createHandler.tsx b/packages/react-native-gesture-handler/src/handlers/createHandler.tsx
@@ -406,7 +406,14 @@ export default function createHandler<
         newConfig
       );
 
-      RNGestureHandlerModule.configureRelations(this.handlerTag, newConfig);
+      RNGestureHandlerModule.configureRelations(
+        this.handlerTag,
+        filterConfig(this.config, [
+          'waitFor',
+          'simultaneousHandlers',
+          'blocksHandlers',
+        ])
+      );
 
       scheduleFlushOperations();
     };
diff --git a/packages/react-native-gesture-handler/src/handlers/gestures/GestureDetector/attachHandlers.ts b/packages/react-native-gesture-handler/src/handlers/gestures/GestureDetector/attachHandlers.ts
@@ -63,11 +63,12 @@ export function attachHandlers({
     for (const handler of gesturesToAttach) {
       RNGestureHandlerModule.setGestureHandlerConfig(
         handler.handlerTag,
-        filterConfig(
-          handler.config,
-          ALLOWED_PROPS,
-          extractGestureRelations(handler)
-        )
+        filterConfig(handler.config, ALLOWED_PROPS)
+      );
+
+      RNGestureHandlerModule.configureRelations(
+        handler.handlerTag,
+        extractGestureRelations(handler)
       );
 
       RNGestureHandlerModule.configureRelations(
diff --git a/packages/react-native-gesture-handler/src/handlers/gestures/GestureDetector/updateHandlers.ts b/packages/react-native-gesture-handler/src/handlers/gestures/GestureDetector/updateHandlers.ts
@@ -67,11 +67,12 @@ export function updateHandlers(
 
       RNGestureHandlerModule.setGestureHandlerConfig(
         handler.handlerTag,
-        filterConfig(
-          handler.config,
-          ALLOWED_PROPS,
-          extractGestureRelations(handler)
-        )
+        filterConfig(handler.config, ALLOWED_PROPS)
+      );
+
+      RNGestureHandlerModule.configureRelations(
+        handler.handlerTag,
+        extractGestureRelations(handler)
       );
 
       RNGestureHandlerModule.configureRelations(
diff --git a/packages/react-native-gesture-handler/src/v3/LogicDetector.tsx b/packages/react-native-gesture-handler/src/v3/LogicDetector.tsx
@@ -49,21 +49,16 @@ export function LogicDetector<THandlerData, TConfig>(
       return;
     }
 
-    const logicProps =
-      Platform.OS === 'web'
-        ? {
-            viewRef,
-            viewTag,
-            handlerTags: isComposedGesture(props.gesture)
-              ? props.gesture.tags
-              : [props.gesture.tag],
-          }
-        : {
-            viewTag,
-            handlerTags: isComposedGesture(props.gesture)
-              ? props.gesture.tags
-              : [props.gesture.tag],
-          };
+    const logicProps = {
+      viewTag,
+      handlerTags: isComposedGesture(props.gesture)
+        ? props.gesture.tags
+        : [props.gesture.tag],
+    };
+
+    if (Platform.OS === 'web') {
+      Object.assign(logicProps, { viewRef });
+    }
 
     register(logicProps, logicMethods as RefObject<GestureEvents<unknown>>);
 
diff --git a/packages/react-native-gesture-handler/src/v3/NativeDetector/HostGestureDetector.web.tsx b/packages/react-native-gesture-handler/src/v3/NativeDetector/HostGestureDetector.web.tsx
@@ -4,6 +4,7 @@ import { ActionType } from '../../ActionType';
 import { PropsRef } from '../../web/interfaces';
 import { View } from 'react-native';
 import { tagMessage } from '../../utils';
+import { EMPTY_SET } from './utils';
 
 export interface GestureHandlerDetectorProps extends PropsRef {
   handlerTags: number[];
@@ -26,7 +27,6 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
   const attachedHandlers = useRef<Set<number>>(new Set<number>());
   const attachedNativeHandlers = useRef<Set<number>>(new Set<number>());
   const attachedLogicHandlers = useRef<Map<number, Set<number>>>(new Map());
-  const emptySet = new Set<number>();
 
   const detachHandlers = (
     currentHandlerTags: Set<number>,
@@ -74,11 +74,8 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
   };
 
   useEffect(() => {
-    attachedHandlers.current = attachedHandlers.current.difference(
-      attachedNativeHandlers.current
-    );
-    detachHandlers(attachedHandlers.current, attachedNativeHandlers.current);
-  }, [children]);
+    propsRef.current = props;
+  }, [props]);
 
   useEffect(() => {
     if (React.Children.count(children) !== 1) {
@@ -97,6 +94,13 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
       attachedHandlers.current,
       ActionType.NATIVE_DETECTOR
     );
+
+    return () => {
+      detachHandlers(EMPTY_SET, attachedHandlers.current);
+      attachedLogicHandlers?.current.forEach((childHandlerTags) => {
+        detachHandlers(EMPTY_SET, childHandlerTags);
+      });
+    };
   }, [handlerTags, children]);
 
   useEffect(() => {
@@ -126,19 +130,10 @@ const HostGestureDetector = (props: GestureHandlerDetectorProps) => {
     });
 
     logicChildrenToDetach.forEach((tag) => {
-      detachHandlers(emptySet, attachedLogicHandlers.current.get(tag)!);
+      detachHandlers(EMPTY_SET, attachedLogicHandlers.current.get(tag)!);
     });
   }, [props.logicChildren]);
 
-  useEffect(() => {
-    return () => {
-      detachHandlers(emptySet, attachedHandlers.current);
-      attachedLogicHandlers?.current.forEach((childHandlerTags) => {
-        detachHandlers(emptySet, childHandlerTags);
-      });
-    };
-  }, []);
-
   return (
     <View style={{ display: 'contents' }} ref={viewRef as Ref<View>}>
       {children}
diff --git a/packages/react-native-gesture-handler/src/v3/NativeDetector/utils.ts b/packages/react-native-gesture-handler/src/v3/NativeDetector/utils.ts
@@ -146,4 +146,8 @@ export function configureRelations<THandlerData, TConfig>(
       gesture.gestureRelations
     );
   }
+
+  RNGestureHandlerModule.flushOperations();
 }
+
+export const EMPTY_SET = new Set<number>();
diff --git a/packages/react-native-gesture-handler/src/v3/hooks/useGesture.ts b/packages/react-native-gesture-handler/src/v3/hooks/useGesture.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -262,13 +262,13 @@ class RNGestureHandlerButtonViewManager :`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`- override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {`
`266`		`- if (super.onInterceptTouchEvent(ev)) {`
	`265`	`+ override fun onInterceptTouchEvent(event: MotionEvent): Boolean {`
	`266`	`+ if (super.onInterceptTouchEvent(event)) {`
`267`	`267`	`return true`
`268`	`268`	`}`
`269`	`269`	// We call `onTouchEvent` and wait until button changes state to `pressed`, if it's pressed
`270`	`270`	`// we return true so that the gesture handler can activate.`
`271`		`- onTouchEvent(ev)`
	`271`	`+ onTouchEvent(event)`
`272`	`272`	`return isPressed`
`273`	`273`	`}`
`274`	`274`
Original file line number	Diff line number	Diff line change
`@@ -115,12 +115,12 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- fun dispatchTouchEvent(ev: MotionEvent): Boolean {`
	`118`	`+ fun dispatchTouchEvent(event: MotionEvent): Boolean {`
`119`	`119`	// We mark `mPassingTouch` before we get into `mOrchestrator.onTouchEvent` so that we can tell
`120`	`120`	// if `requestDisallow` has been called as a result of a normal gesture handling process or
`121`	`121`	`// as a result of one of the gesture handlers activating`
`122`	`122`	`passingTouch = true`
`123`		`- orchestrator!!.onTouchEvent(ev)`
	`123`	`+ orchestrator!!.onTouchEvent(event)`
`124`	`124`	`passingTouch = false`
`125`	`125`	`return shouldIntercept`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,10 +37,10 @@ class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {`
`37`	`37`	`rootHelper?.tearDown()`
`38`	`38`	`}`
`39`	`39`
`40`		`- override fun dispatchTouchEvent(ev: MotionEvent) = if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(ev)) {`
	`40`	`+ override fun dispatchTouchEvent(event: MotionEvent) = if (rootViewEnabled && rootHelper!!.dispatchTouchEvent(event)) {`
`41`	`41`	`true`
`42`	`42`	`} else {`
`43`		`- super.dispatchTouchEvent(ev)`
	`43`	`+ super.dispatchTouchEvent(event)`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`override fun dispatchGenericMotionEvent(event: MotionEvent) =`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`// Unfortunately getCoalescingKey is not considered when sending event to C++, therefore we have to disable coalescing in v3`
`63`		`- override fun canCoalesce() = actionType != GestureHandler.ACTION_TYPE_NATIVE_DETECTOR`
	`63`	`+ override fun canCoalesce() = !GestureHandler.usesNativeOrLogicDetector(actionType)`
`64`	`64`
`65`	`65`	`override fun getCoalescingKey() = coalescingKey`
`66`	`66`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class RNGestureHandlerTouchEvent private constructor() : Event<RNGestureHandlerT`
`39`	`39`	`EVENT_NAME`
`40`	`40`	`}`
`41`	`41`
`42`		`- override fun canCoalesce() = true`
	`42`	`+ override fun canCoalesce() = !GestureHandler.usesNativeOrLogicDetector(actionType)`
`43`	`43`
`44`	`44`	`override fun getCoalescingKey() = coalescingKey`
`45`	`45`	`override fun getEventData(): WritableMap? = extraData`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ export enum StateMachineEvent {`
`7`	`7`	`NATIVE_START = 'nativeStart',`
`8`	`8`	`FINALIZE = 'finalize',`
`9`	`9`	`LONG_PRESS_TOUCHES_DOWN = 'longPressTouchesDown',`
	`10`	`+ CANCEL = 'cancel',`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`function getAndroidStatesConfig(`