react-native-gesture-handler 2.32.0 → 2.33.0

package/apple/Handlers/RNFlingHandler.m

@@ -95,7 +95,8 @@
 #else
 
 @interface RNBetterSwipeGestureRecognizer : NSGestureRecognizer {
-  dispatch_block_t failFlingAction;
+  // scheduled on mouseDown; fails the gesture if the fling doesn't complete within maxDuration
+  dispatch_block_t maxDurationTimeout;
   int maxDuration;
   int minVelocity;
   double defaultAlignmentCone;
@@ -137,18 +138,34 @@
   [_gestureHandler handleGesture:self];
 }
 
+- (void)triggerAction
+{
+  [_gestureHandler handleGesture:self fromReset:NO];
+}
+
+- (void)triggerActionFromReset
+{
+  [_gestureHandler handleGesture:self fromReset:YES];
+}
+
 - (void)mouseDown:(NSEvent *)event
 {
+  [_gestureHandler setCurrentPointerTypeToMouse];
+  [_gestureHandler reset];
   [super mouseDown:event];
 
   startPosition = [self locationInView:self.view];
   startTime = CACurrentMediaTime();
 
+  [_gestureHandler.pointerTracker touchesBegan:[NSSet setWithObject:event] withEvent:event];
+  // Send the BEGAN event, mirroring what the iOS recognizer does in touchesBegan.
+  [self triggerAction];
+
   self.state = NSGestureRecognizerStatePossible;
 
   __weak typeof(self) weakSelf = self;
 
-  failFlingAction = dispatch_block_create(0, ^{
+  maxDurationTimeout = dispatch_block_create(0, ^{
     __strong typeof(self) strongSelf = weakSelf;
 
     if (strongSelf) {
@@ -159,13 +176,15 @@
   dispatch_after(
       dispatch_time(DISPATCH_TIME_NOW, (int64_t)(maxDuration * NSEC_PER_SEC)),
       dispatch_get_main_queue(),
-      failFlingAction);
+      maxDurationTimeout);
 }
 
 - (void)mouseDragged:(NSEvent *)event
 {
   [super mouseDragged:event];
 
+  [_gestureHandler.pointerTracker touchesMoved:[NSSet setWithObject:event] withEvent:event];
+
   NSPoint currentPosition = [self locationInView:self.view];
   double currentTime = CACurrentMediaTime();
 
@@ -180,16 +199,37 @@
   [self tryActivate:velocityVector];
 }
 
+- (void)cancelMaxDurationTimeout
+{
+  if (maxDurationTimeout != nil) {
+    dispatch_block_cancel(maxDurationTimeout);
+    maxDurationTimeout = nil;
+  }
+}
+
 - (void)mouseUp:(NSEvent *)event
 {
   [super mouseUp:event];
 
-  dispatch_block_cancel(failFlingAction);
+  [_gestureHandler.pointerTracker touchesEnded:[NSSet setWithObject:event] withEvent:event];
+
+  [self cancelMaxDurationTimeout];
 
   self.state =
       self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateEnded : NSGestureRecognizerStateFailed;
 }
 
+- (void)reset
+{
+  [self triggerActionFromReset];
+  [_gestureHandler.pointerTracker reset];
+  // The gesture may end without a mouse-up (view unmount, cancellation) — a still-scheduled
+  // timeout would fire later and set the state to Failed during the next gesture.
+  [self cancelMaxDurationTimeout];
+  [super reset];
+  [_gestureHandler reset];
+}
+
 - (void)tryActivate:(Vector *)velocityVector
 {
   bool isAligned = NO;

package/apple/Handlers/RNHoverHandler.m

@@ -132,8 +132,9 @@ API_AVAILABLE(ios(13.4))
 {
 #if CHECK_TARGET(13_4)
   if (@available(iOS 13.4, *)) {
-    [super unbindFromView];
+    // Remove the interaction before [super unbindFromView] detaches the recognizer and nils recognizer.view.
     [self.recognizer.view removeInteraction:_pointerInteraction];
+    [super unbindFromView];
   }
 #endif
 }
@@ -218,33 +219,30 @@ API_AVAILABLE(ios(13.4))
   _view = nil;
 }
 
+- (RNGestureHandlerEventExtraData *)extraDataForEvent:(NSEvent *)event
+{
+  CGPoint windowLocation = [event locationInWindow];
+  CGPoint relativePos = [_view convertPoint:windowLocation fromView:nil];
+  CGPoint absolutePos = [_view.window.contentView convertPoint:windowLocation fromView:nil];
+
+  return [RNGestureHandlerEventExtraData forPosition:relativePos
+                                withAbsolutePosition:absolutePos
+                                 withNumberOfTouches:1
+                                     withPointerType:_pointerType];
+}
+
 - (void)mouseEntered:(NSEvent *)event
 {
-  [self sendEventsInState:RNGestureHandlerStateBegan
-           forViewWithTag:_view.reactTag
-            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES
-                                                       withNumberOfTouches:1
-                                                           withPointerType:_pointerType]];
-  [self sendEventsInState:RNGestureHandlerStateActive
-           forViewWithTag:_view.reactTag
-            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES
-                                                       withNumberOfTouches:1
-                                                           withPointerType:_pointerType]];
-}
-
-- (void)mouseExited:(NSEvent *)theEvent
-{
-  [self sendEventsInState:RNGestureHandlerStateEnd
-           forViewWithTag:_view.reactTag
-            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO
-                                                       withNumberOfTouches:1
-                                                           withPointerType:_pointerType]];
-
-  [self sendEventsInState:RNGestureHandlerStateUndetermined
-           forViewWithTag:_view.reactTag
-            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:NO
-                                                       withNumberOfTouches:1
-                                                           withPointerType:_pointerType]];
+  RNGestureHandlerEventExtraData *extraData = [self extraDataForEvent:event];
+  [self sendEventsInState:RNGestureHandlerStateBegan forViewWithTag:_view.reactTag withExtraData:extraData];
+  [self sendEventsInState:RNGestureHandlerStateActive forViewWithTag:_view.reactTag withExtraData:extraData];
+}
+
+- (void)mouseExited:(NSEvent *)event
+{
+  RNGestureHandlerEventExtraData *extraData = [self extraDataForEvent:event];
+  [self sendEventsInState:RNGestureHandlerStateEnd forViewWithTag:_view.reactTag withExtraData:extraData];
+  [self sendEventsInState:RNGestureHandlerStateUndetermined forViewWithTag:_view.reactTag withExtraData:extraData];
 }
 
 @end

package/apple/Handlers/RNLongPressHandler.m

@@ -225,6 +225,10 @@
 
   recognizer.minimumPressDuration = 0.5;
   recognizer.allowableMovement = 10;
+
+#if !TARGET_OS_TV
+  recognizer.numberOfTouchesRequired = 1;
+#endif
 }
 
 - (void)configure:(NSDictionary *)config

package/apple/Handlers/RNPanHandler.m

@@ -42,7 +42,9 @@
 
 @implementation RNBetterPanGestureRecognizer {
   __weak RNGestureHandler *_gestureHandler;
-#if !TARGET_OS_OSX
+#if TARGET_OS_OSX
+  BOOL _blockAutomaticActivation;
+#else
   NSUInteger _realMinimumNumberOfTouches;
 #endif
   BOOL _hasCustomActivationCriteria;
@@ -114,6 +116,9 @@
 
 - (void)activateAfterLongPress
 {
+#if TARGET_OS_OSX
+  _blockAutomaticActivation = NO;
+#endif
   self.state = UIGestureRecognizerStateBegan;
   // Send event in ACTIVE state because UIGestureRecognizerStateBegan is mapped to RNGestureHandlerStateBegan
   [_gestureHandler handleGesture:self inState:RNGestureHandlerStateActive];
@@ -139,6 +144,11 @@
 #endif
 
 #if TARGET_OS_OSX
+  // NSPanGestureRecognizer transitions to the Began state on mouse-down, without any
+  // built-in movement hysteresis. To honor the custom activation criteria (minDist,
+  // activeOffsets, minVelocity) we hold the recognizer in the Possible state until
+  // they are met in interactionsMoved.
+  _blockAutomaticActivation = _hasCustomActivationCriteria;
   [super mouseDown:event];
 #else
   [super touchesBegan:touches withEvent:event];
@@ -176,7 +186,14 @@
     }
   }
 
-#if !TARGET_OS_TV && !TARGET_OS_OSX
+#if TARGET_OS_OSX
+  if (_hasCustomActivationCriteria && self.state == UIGestureRecognizerStatePossible &&
+      [self shouldActivateUnderCustomCriteria]) {
+    _blockAutomaticActivation = NO;
+    self.state = UIGestureRecognizerStateBegan;
+    [self setTranslation:CGPointMake(0, 0) inView:self.view];
+  }
+#elif !TARGET_OS_TV
   if (_hasCustomActivationCriteria && self.state == UIGestureRecognizerStatePossible &&
       [self shouldActivateUnderCustomCriteria]) {
     super.minimumNumberOfTouches = _realMinimumNumberOfTouches;
@@ -209,6 +226,23 @@
 
 #if TARGET_OS_OSX
 
+- (void)setState:(NSGestureRecognizerState)state
+{
+  if (_blockAutomaticActivation) {
+    if (state == NSGestureRecognizerStateBegan || state == NSGestureRecognizerStateChanged) {
+      // Hold the recognizer in the Possible state until the custom activation criteria
+      // are met — the superclass keeps tracking the mouse regardless, so translation
+      // and velocity stay valid for the criteria checks.
+      return;
+    }
+    if (state == NSGestureRecognizerStateEnded) {
+      // Mouse released before the activation criteria were met — the gesture failed.
+      state = NSGestureRecognizerStateFailed;
+    }
+  }
+  [super setState:state];
+}
+
 - (void)mouseDown:(NSEvent *)event
 {
   [_gestureHandler setCurrentPointerTypeToMouse];
@@ -265,6 +299,9 @@
   [_gestureHandler.pointerTracker reset];
   [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(activateAfterLongPress) object:nil];
   self.enabled = YES;
+#if TARGET_OS_OSX
+  _blockAutomaticActivation = NO;
+#endif
   [super reset];
   [_gestureHandler reset];
 
@@ -333,10 +370,10 @@
   }
 
   CGPoint velocity = [self velocityInView:self.view];
-  if (TEST_MIN_IF_NOT_NAN(velocity.x, _minVelocityX)) {
+  if (TEST_ABS_MIN_IF_NOT_NAN(velocity.x, _minVelocityX)) {
     return YES;
   }
-  if (TEST_MIN_IF_NOT_NAN(velocity.y, _minVelocityY)) {
+  if (TEST_ABS_MIN_IF_NOT_NAN(velocity.y, _minVelocityY)) {
     return YES;
   }
   if (TEST_MIN_IF_NOT_NAN(VEC_LEN_SQ(velocity), _minVelocitySq)) {
@@ -405,9 +442,9 @@
 
 #if !TARGET_OS_OSX && !TARGET_OS_TV && __IPHONE_OS_VERSION_MAX_ALLOWED >= 130400
   if (@available(iOS 13.4, *)) {
-    bool enableTrackpadTwoFingerGesture = [RCTConvert BOOL:config[@"enableTrackpadTwoFingerGesture"]];
-    if (enableTrackpadTwoFingerGesture) {
-      recognizer.allowedScrollTypesMask = UIScrollTypeMaskAll;
+    id enableTrackpadTwoFingerGesture = config[@"enableTrackpadTwoFingerGesture"];
+    if (enableTrackpadTwoFingerGesture != nil) {
+      recognizer.allowedScrollTypesMask = [RCTConvert BOOL:enableTrackpadTwoFingerGesture] ? UIScrollTypeMaskAll : 0;
     }
   }
 

package/apple/Handlers/RNTapHandler.m

@@ -38,6 +38,12 @@
   NSUInteger _tapsSoFar;
   CGPoint _initPosition;
   NSInteger _maxNumberOfTouches;
+  // Pending `cancel` invocations scheduled via dispatch_after. We use dispatch blocks instead of
+  // performSelector:afterDelay: because the latter schedules its timer in NSDefaultRunLoopMode only,
+  // which means it is starved while a sibling UIScrollView keeps the run loop in UITrackingRunLoopMode
+  // (during a drag or momentum deceleration). dispatch_after fires regardless of run loop mode, so the
+  // tap can still fail/finalize on time while a list is scrolling. See issue #3471.
+  NSMutableArray<dispatch_block_t> *_pendingCancellations;
 }
 
 static const NSUInteger defaultNumberOfTaps = 1;
@@ -57,10 +63,33 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
     _maxDeltaX = NAN;
     _maxDeltaY = NAN;
     _maxDistSq = NAN;
+    _pendingCancellations = [NSMutableArray array];
   }
   return self;
 }
 
+- (void)scheduleCancelAfterDelay:(NSTimeInterval)delay
+{
+  __weak typeof(self) weakSelf = self;
+
+  dispatch_block_t block = dispatch_block_create(0, ^{
+    [weakSelf cancel];
+  });
+
+  [_pendingCancellations addObject:block];
+
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_main_queue(), block);
+}
+
+- (void)cancelPendingCancellations
+{
+  for (dispatch_block_t block in _pendingCancellations) {
+    dispatch_block_cancel(block);
+  }
+
+  [_pendingCancellations removeAllObjects];
+}
+
 - (void)triggerAction
 {
   [_gestureHandler handleGesture:self fromReset:NO];
@@ -93,14 +122,14 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
   }
   _tapsSoFar++;
   if (_tapsSoFar) {
-    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(cancel) object:nil];
+    [self cancelPendingCancellations];
   }
   NSInteger numberOfTouches = [touches count];
   if (numberOfTouches > _maxNumberOfTouches) {
     _maxNumberOfTouches = numberOfTouches;
   }
   if (!isnan(_maxDuration)) {
-    [self performSelector:@selector(cancel) withObject:nil afterDelay:_maxDuration];
+    [self scheduleCancelAfterDelay:_maxDuration];
   }
   self.state = UIGestureRecognizerStatePossible;
   [self triggerAction];
@@ -132,10 +161,12 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
 {
   [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
 
+  [self cancelPendingCancellations];
+
   if (_numberOfTaps == _tapsSoFar && _maxNumberOfTouches >= _minPointers) {
     self.state = UIGestureRecognizerStateEnded;
   } else {
-    [self performSelector:@selector(cancel) withObject:nil afterDelay:_maxDelay];
+    [self scheduleCancelAfterDelay:_maxDelay];
   }
 }
 
@@ -250,7 +281,7 @@ static const NSTimeInterval defaultMaxDuration = 0.5;
 
   [_gestureHandler.pointerTracker reset];
 
-  [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(cancel) object:nil];
+  [self cancelPendingCancellations];
   _tapsSoFar = 0;
   _maxNumberOfTouches = 0;
   self.enabled = YES;

package/apple/RNGHUIKit.h

@@ -6,11 +6,11 @@ typedef UIView RNGHUIView;
 typedef UITouch RNGHUITouch;
 typedef UIScrollView RNGHUIScrollView;
 
-#define RNGHGestureRecognizerStateFailed UIGestureRecognizerStateFailed;
-#define RNGHGestureRecognizerStatePossible UIGestureRecognizerStatePossible;
-#define RNGHGestureRecognizerStateCancelled UIGestureRecognizerStateCancelled;
-#define RNGHGestureRecognizerStateBegan UIGestureRecognizerStateBegan;
-#define RNGHGestureRecognizerStateEnded UIGestureRecognizerStateEnded;
+#define RNGHGestureRecognizerStateFailed UIGestureRecognizerStateFailed
+#define RNGHGestureRecognizerStatePossible UIGestureRecognizerStatePossible
+#define RNGHGestureRecognizerStateCancelled UIGestureRecognizerStateCancelled
+#define RNGHGestureRecognizerStateBegan UIGestureRecognizerStateBegan
+#define RNGHGestureRecognizerStateEnded UIGestureRecognizerStateEnded
 
 #else // TARGET_OS_OSX [
 
@@ -20,10 +20,10 @@ typedef RCTUIView RNGHUIView;
 typedef RCTUITouch RNGHUITouch;
 typedef NSScrollView RNGHUIScrollView;
 
-#define RNGHGestureRecognizerStateFailed NSGestureRecognizerStateFailed;
-#define RNGHGestureRecognizerStatePossible NSGestureRecognizerStatePossible;
-#define RNGHGestureRecognizerStateCancelled NSGestureRecognizerStateCancelled;
-#define RNGHGestureRecognizerStateBegan NSGestureRecognizerStateBegan;
-#define RNGHGestureRecognizerStateEnded NSGestureRecognizerStateEnded;
+#define RNGHGestureRecognizerStateFailed NSGestureRecognizerStateFailed
+#define RNGHGestureRecognizerStatePossible NSGestureRecognizerStatePossible
+#define RNGHGestureRecognizerStateCancelled NSGestureRecognizerStateCancelled
+#define RNGHGestureRecognizerStateBegan NSGestureRecognizerStateBegan
+#define RNGHGestureRecognizerStateEnded NSGestureRecognizerStateEnded
 
 #endif // ] TARGET_OS_OSX

package/apple/RNGestureHandler.h

@@ -14,6 +14,8 @@
 #define TEST_MIN_IF_NOT_NAN(value, limit) \
   (!isnan(limit) && ((limit < 0 && value <= limit) || (limit >= 0 && value >= limit)))
 
+#define TEST_ABS_MIN_IF_NOT_NAN(value, limit) (!isnan(limit) && fabs(value) >= fabs(limit))
+
 #define TEST_MAX_IF_NOT_NAN(value, max) (!isnan(max) && ((max < 0 && value < max) || (max >= 0 && value > max)))
 
 #define APPLY_PROP(recognizer, config, type, prop, propName) \

package/apple/RNGestureHandler.mm

@@ -253,6 +253,24 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
 
 - (void)unbindFromView
 {
+  // If the gesture is still in flight - e.g. the view is being unmounted mid-gesture - deliver
+  // the final event now, while the recognizer is still attached and the target view is known.
+  // Otherwise the onBegin/onFinalize and onActivate/onDeactivate guarantees would be broken
+  // and `_lastState` would never be cleared by `reset`.
+  if (self.recognizer.view != nil &&
+      (_lastState == RNGestureHandlerStateBegan || _lastState == RNGestureHandlerStateActive)) {
+    if ([self eventTagForRecognizer:self.recognizer] != nil) {
+      [self handleGesture:self.recognizer
+                  inState:_lastState == RNGestureHandlerStateActive ? RNGestureHandlerStateCancelled
+                                                                    : RNGestureHandlerStateFailed];
+    } else {
+      // The event has no tag to be dispatched with, so it cannot be delivered on any path - reset
+      // the bookkeeping so the handler doesn't stay in-flight forever.
+      _lastState = RNGestureHandlerStateUndetermined;
+      _state = RNGestureHandlerStateBegan;
+    }
+  }
+
   [self.recognizer.view removeGestureRecognizer:self.recognizer];
   self.recognizer.delegate = nil;
   self.viewTag = nil;
@@ -314,21 +332,38 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
   //
   // While this solution is not great, we decided to check whether sending events was triggered from `reset` method.
   // This way we can detect double Began mapping by checking previous sent state and current state of recognizer.
-  if (fromReset && _lastState == RNGestureHandlerStateBegan &&
-      self.recognizer.state == UIGestureRecognizerStatePossible) {
-    _state = RNGestureHandlerStateFailed;
+  //
+  // The same applies to gestures interrupted mid-flight, e.g. when the view is unmounted during an active
+  // gesture the recognizer may be reset without its cancel action ever firing.
+  // If the last sent state is not final, synthesize the missing final event so that the
+  // `onBegin`/`onFinalize` and `onActivate`/`onDeactivate` guarantees hold.
+  if (fromReset && self.recognizer.state == UIGestureRecognizerStatePossible) {
+    if (_lastState == RNGestureHandlerStateBegan) {
+      _state = RNGestureHandlerStateFailed;
+    } else if (_lastState == RNGestureHandlerStateActive) {
+      _state = RNGestureHandlerStateCancelled;
+    } else {
+      // The final event was already delivered; mapping Possible to Began here would emit a stray
+      // BEGAN event after the gesture has finished.
+      return;
+    }
   }
 
   [self handleGesture:recognizer inState:_state];
 }
 
+- (nullable NSNumber *)eventTagForRecognizer:(UIGestureRecognizer *)recognizer
+{
+  return [self chooseViewForInteraction:recognizer].reactTag;
+}
+
 - (void)handleGesture:(UIGestureRecognizer *)recognizer inState:(RNGestureHandlerState)state
 {
   _state = state;
   RNGestureHandlerEventExtraData *eventData = [self eventExtraData:recognizer];
-  RNGHUIView *view = [self chooseViewForInteraction:recognizer];
+  NSNumber *tag = [self eventTagForRecognizer:recognizer];
 
-  [self sendEventsInState:self.state forViewWithTag:view.reactTag withExtraData:eventData];
+  [self sendEventsInState:self.state forViewWithTag:tag withExtraData:eventData];
 }
 
 - (void)sendEventsInState:(RNGestureHandlerState)state
@@ -636,7 +671,13 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
   // might be called after some pointers are down, and after state manipulation by the user.
   // Pointer tracker calls this method when it resets, and in that case it no longer tracks
   // any pointers, thus entering this if
-  if (!_needsPointerData || _pointerTracker.trackedPointersCount == 0) {
+  //
+  // Also do not clear _lastState while the gesture is in flight (BEGAN/ACTIVE) - the final
+  // state-change event hasn't been dispatched yet. When the view is removed mid-gesture,
+  // the pointer tracker resets before the recognizer's cancel action fires; clearing _lastState
+  // here would corrupt the prevState of the outgoing CANCELLED event and break the onActivate/onDeactivate guarantee.
+  if ((!_needsPointerData || _pointerTracker.trackedPointersCount == 0) && _lastState != RNGestureHandlerStateBegan &&
+      _lastState != RNGestureHandlerStateActive) {
     _lastState = RNGestureHandlerStateUndetermined;
     _state = RNGestureHandlerStateBegan;
   }

package/apple/RNGestureHandlerButton.mm

@@ -62,7 +62,8 @@
 {
   if ([view isKindOfClass:[RNGestureHandlerButton class]]) {
     RNGestureHandlerButton *button = (RNGestureHandlerButton *)view;
-    return button.userEnabled;
+    return button.userEnabled && button.pointerEvents != RNGestureHandlerPointerEventsBoxNone &&
+        button.pointerEvents != RNGestureHandlerPointerEventsNone;
   }
 
   // Certain subviews such as RCTViewComponentView have been observed to have disabled
@@ -105,7 +106,8 @@
       if (!subview.isHidden && subview.alpha > 0) {
         CGPoint convertedPoint = [subview convertPoint:point fromView:self];
         UIView *hitView = [subview hitTest:convertedPoint withEvent:event];
-        if (hitView != nil && [self shouldHandleTouch:hitView]) {
+        if (hitView != nil &&
+            ([hitView isKindOfClass:[RNGestureHandlerButton class]] || [self shouldHandleTouch:hitView])) {
           return hitView;
         }
       }
@@ -118,7 +120,7 @@
   }
 
   RNGHUIView *inner = [super hitTest:point withEvent:event];
-  while (inner && ![self shouldHandleTouch:inner]) {
+  while (inner && inner != self && ![self shouldHandleTouch:inner]) {
     inner = inner.superview;
   }
   return inner;

package/apple/RNGestureHandlerManager.mm

@@ -4,7 +4,6 @@
 #import <React/RCTEventDispatcherProtocol.h>
 #import <React/RCTLog.h>
 #import <React/RCTModalHostViewController.h>
-#import <React/RCTRootContentView.h>
 #import <React/RCTRootView.h>
 #import <React/RCTUIManager.h>
 #import <React/RCTViewManager.h>
@@ -275,20 +274,50 @@ constexpr int NEW_ARCH_NUMBER_OF_ATTACH_RETRIES = 25;
 
 #pragma mark Root Views Management
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#if !TARGET_OS_OSX
+static BOOL RNGHIsScreensTouchHandlerHost(RNGHUIView *view)
+{
+  static Class fullWindowOverlayContainerClass;
+  static Class screenViewClass;
+  static SEL isModalSelector;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    fullWindowOverlayContainerClass = NSClassFromString(@"RNSFullWindowOverlayContainer");
+    screenViewClass = NSClassFromString(@"RNSScreenView");
+    isModalSelector = NSSelectorFromString(@"isModal");
+  });
+
+  if (fullWindowOverlayContainerClass != nil && [view isKindOfClass:fullWindowOverlayContainerClass]) {
+    return YES;
+  }
+
+  if (screenViewClass != nil && [view isKindOfClass:screenViewClass]) {
+    // For now we consider only modals
+    return [view respondsToSelector:isModalSelector] && [[view valueForKey:@"isModal"] boolValue];
+  }
+
+  return NO;
+}
+#endif // !TARGET_OS_OSX
+#endif // RCT_NEW_ARCH_ENABLED
+
 - (void)registerViewWithGestureRecognizerAttachedIfNeeded:(RNGHUIView *)childView
+{
+  [self registerViewWithGestureRecognizerAttachedIfNeeded:childView isRetry:NO];
+}
+
+- (void)registerViewWithGestureRecognizerAttachedIfNeeded:(RNGHUIView *)childView isRetry:(BOOL)isRetry
 {
 #ifdef RCT_NEW_ARCH_ENABLED
   RNGHUIView *touchHandlerView = childView;
 
 #if !TARGET_OS_OSX
-  Class fullWindowOverlayContainerClass = NSClassFromString(@"RNSFullWindowOverlayContainer");
-
   if ([[childView reactViewController] isKindOfClass:[RCTFabricModalHostViewController class]]) {
     touchHandlerView = [childView reactViewController].view;
   } else {
-    while (
-        touchHandlerView != nil && ![touchHandlerView isKindOfClass:[RCTSurfaceView class]] &&
-        (fullWindowOverlayContainerClass == nil || ![touchHandlerView isKindOfClass:fullWindowOverlayContainerClass])) {
+    while (touchHandlerView != nil && ![touchHandlerView isKindOfClass:[RCTSurfaceView class]] &&
+           !RNGHIsScreensTouchHandlerHost(touchHandlerView)) {
       touchHandlerView = touchHandlerView.superview;
     }
   }
@@ -324,6 +353,19 @@ constexpr int NEW_ARCH_NUMBER_OF_ATTACH_RETRIES = 25;
 #endif // RCT_NEW_ARCH_ENABLED
 
   if (touchHandlerView == nil) {
+#ifdef RCT_NEW_ARCH_ENABLED
+#if !TARGET_OS_OSX
+    // Handlers are attached while the mounting transaction is still in progress — the view's
+    // ancestor chain may not be assembled yet (Fabric connects subtrees children-first), in
+    // which case the walk above dead-ends before reaching any touch-handling root. Retry once
+    // on the next run loop turn, when mounting has finished and the hierarchy is connected.
+    if (!isRetry) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [self registerViewWithGestureRecognizerAttachedIfNeeded:childView isRetry:YES];
+      });
+    }
+#endif // !TARGET_OS_OSX
+#endif // RCT_NEW_ARCH_ENABLED
     return;
   }
 
@@ -382,6 +424,21 @@ constexpr int NEW_ARCH_NUMBER_OF_ATTACH_RETRIES = 25;
       break;
     }
   }
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#if !TARGET_OS_OSX
+  if (touchHandler == nil && [viewWithTouchHandler respondsToSelector:NSSelectorFromString(@"touchHandler")]) {
+    // An RNSScreenView may not have the touch handler attached directly (e.g. touches on it are
+    // still driven by an ancestor's touch handler) — ask react-native-screens for the one
+    // responsible for this screen.
+    id screenTouchHandler = [viewWithTouchHandler valueForKey:@"touchHandler"];
+    if ([screenTouchHandler isKindOfClass:[RCTSurfaceTouchHandler class]]) {
+      touchHandler = screenTouchHandler;
+    }
+  }
+#endif // !TARGET_OS_OSX
+#endif // RCT_NEW_ARCH_ENABLED
+
   [touchHandler setEnabled:NO];
   [touchHandler setEnabled:YES];
 }