react-native-gesture-handler 2.18.1 → 2.20.0

package/apple/Handlers/RNManualHandler.m

@@ -1,9 +1,10 @@
 #import "RNManualHandler.h"
 
 #if !TARGET_OS_OSX
-
 @interface RNManualRecognizer : UIGestureRecognizer
-
+#else
+@interface RNManualRecognizer : NSGestureRecognizer
+#endif
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
 
 @end
@@ -19,25 +20,27 @@
     _gestureHandler = gestureHandler;
     _shouldSendBeginEvent = YES;
   }
+
   return self;
 }
 
-- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsBegan:(NSSet *)touches withEvent:(UIEvent *)event
 {
-  [_gestureHandler setCurrentPointerType:event];
-  [super touchesBegan:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
 
   if (_shouldSendBeginEvent) {
     [_gestureHandler handleGesture:self];
+#if TARGET_OS_OSX
+    self.state = NSGestureRecognizerStateBegan;
+#endif
     _shouldSendBeginEvent = NO;
   }
 }
 
-- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsMoved:(NSSet *)touches withEvent:(UIEvent *)event
 {
-  [super touchesMoved:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+  [_gestureHandler handleGesture:self];
 
   if ([self shouldFail]) {
     self.state = (self.state == UIGestureRecognizerStatePossible) ? UIGestureRecognizerStateFailed
@@ -47,10 +50,31 @@
   }
 }
 
+- (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+  [_gestureHandler handleGesture:self];
+}
+
+#if !TARGET_OS_OSX
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler setCurrentPointerType:event];
+  [super touchesBegan:touches withEvent:event];
+
+  [self interactionsBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [self interactionsMoved:touches withEvent:event];
+}
+
 - (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   [super touchesEnded:touches withEvent:event];
-  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+  [self interactionsEnded:touches withEvent:event];
 }
 
 - (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
@@ -60,6 +84,26 @@
   [self reset];
 }
 
+#else
+
+- (void)mouseDown:(NSEvent *)event
+{
+  [_gestureHandler setCurrentPointerTypeToMouse];
+  [self interactionsBegan:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [self interactionsMoved:[NSSet setWithObject:event] withEvent:event];
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [self interactionsEnded:[NSSet setWithObject:event] withEvent:event];
+}
+
+#endif
+
 - (void)reset
 {
   [_gestureHandler.pointerTracker reset];
@@ -71,11 +115,7 @@
 
 - (BOOL)shouldFail
 {
-  if (_gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView]) {
-    return YES;
-  } else {
-    return NO;
-  }
+  return _gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView];
 }
 
 @end
@@ -87,24 +127,8 @@
   if ((self = [super initWithTag:tag])) {
     _recognizer = [[RNManualRecognizer alloc] initWithGestureHandler:self];
   }
-  return self;
-}
-
-@end
-
-#else
-
-@implementation RNManualGestureHandler
 
-- (instancetype)initWithTag:(NSNumber *)tag
-{
-  RCTLogWarn(@"ManualGestureHandler is not supported on macOS");
-  if ((self = [super initWithTag:tag])) {
-    _recognizer = [NSGestureRecognizer alloc];
-  }
   return self;
 }
 
 @end
-
-#endif

package/apple/Handlers/RNNativeViewHandler.mm

@@ -44,6 +44,7 @@
 
 - (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
+  [self updateStateIfScrollView];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
 }
 
@@ -51,7 +52,12 @@
 {
   [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
   self.state = UIGestureRecognizerStateFailed;
-  [self reset];
+
+  // For now, we are handling only the scroll view case.
+  // If more views need special treatment, then we can switch to a delegate pattern
+  if ([_gestureHandler retrieveScrollView:self.view] == nil) {
+    [self reset];
+  }
 }
 
 - (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
@@ -92,6 +98,19 @@
   [_gestureHandler reset];
 }
 
+- (void)updateStateIfScrollView
+{
+  RNGHUIScrollView *scrollView = [_gestureHandler retrieveScrollView:self.view];
+  if (!scrollView) {
+    return;
+  }
+  for (UIGestureRecognizer *scrollViewGestureRecognizer in scrollView.gestureRecognizers) {
+    if ([_gestureHandler isUIScrollViewPanGestureRecognizer:scrollViewGestureRecognizer]) {
+      self.state = scrollViewGestureRecognizer.state;
+    }
+  }
+}
+
 @end
 
 #pragma mark RNNativeViewGestureHandler
@@ -141,20 +160,8 @@
   // We can restore default scrollview behaviour to delay touches to scrollview's children
   // because gesture handler system can handle cancellation of scroll recognizer when JS responder
   // is set
-#ifdef RCT_NEW_ARCH_ENABLED
-  if ([view isKindOfClass:[RCTScrollViewComponentView class]]) {
-    UIScrollView *scrollView = ((RCTScrollViewComponentView *)view).scrollView;
-    scrollView.delaysContentTouches = YES;
-  }
-#else
-  if ([view isKindOfClass:[RCTScrollView class]]) {
-    // This part of the code is coupled with RN implementation of ScrollView native wrapper and
-    // we expect for RCTScrollView component to contain a subclass of UIScrollview as the only
-    // subview
-    UIScrollView *scrollView = [view.subviews objectAtIndex:0];
-    scrollView.delaysContentTouches = YES;
-  }
-#endif // RCT_NEW_ARCH_ENABLED
+  UIScrollView *scrollView = [self retrieveScrollView:view];
+  scrollView.delaysContentTouches = YES;
 }
 
 - (void)handleTouchDown:(UIView *)sender forEvent:(UIEvent *)event

package/apple/Handlers/RNPanHandler.m

@@ -7,6 +7,7 @@
 //
 
 #import "RNPanHandler.h"
+#import "RNGHStylusData.h"
 
 #if TARGET_OS_OSX
 
@@ -31,6 +32,10 @@
 @property (nonatomic) CGFloat failOffsetYEnd;
 @property (nonatomic) CGFloat activateAfterLongPress;
 
+#if !TARGET_OS_OSX && !TARGET_OS_TV
+@property (atomic, readonly, strong) RNGHStylusData *stylusData;
+#endif
+
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
 
 @end
@@ -80,6 +85,28 @@
 }
 #endif
 
+#if !TARGET_OS_OSX && !TARGET_OS_TV
+- (void)tryUpdateStylusData:(UIEvent *)event
+{
+  UITouch *touch = [[event allTouches] anyObject];
+
+  if (touch.type != UITouchTypePencil) {
+    return;
+  } else if (_stylusData == nil) {
+    _stylusData = [[RNGHStylusData alloc] init];
+  }
+
+  _stylusData.altitudeAngle = touch.altitudeAngle;
+  _stylusData.azimuthAngle = [touch azimuthAngleInView:nil];
+  _stylusData.pressure = touch.force / touch.maximumPossibleForce;
+
+  CGPoint tilts = ghSpherical2tilt(_stylusData.altitudeAngle, _stylusData.azimuthAngle);
+
+  _stylusData.tiltX = tilts.x;
+  _stylusData.tiltY = tilts.y;
+}
+#endif
+
 - (void)activateAfterLongPress
 {
   self.state = UIGestureRecognizerStateBegan;
@@ -102,6 +129,8 @@
   } else {
     super.minimumNumberOfTouches = _realMinimumNumberOfTouches;
   }
+
+  [self tryUpdateStylusData:event];
 #endif
 
 #if TARGET_OS_OSX
@@ -150,17 +179,28 @@
       [self setTranslation:CGPointMake(0, 0) inView:self.view];
     }
   }
+
+  [self tryUpdateStylusData:event];
 #endif
 }
 
 - (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  [self tryUpdateStylusData:event];
+#endif
 }
 
 - (void)interactionsCancelled:(NSSet *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  [self tryUpdateStylusData:event];
+#endif
+
   [self reset];
 }
 
@@ -224,6 +264,10 @@
   self.enabled = YES;
   [super reset];
   [_gestureHandler reset];
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
+  _stylusData = nil;
+#endif
 }
 
 - (void)updateHasCustomActivationCriteria
@@ -405,17 +449,23 @@
                                 withTranslation:[recognizer translationInView:recognizer.view.window.contentView]
                                    withVelocity:[recognizer velocityInView:recognizer.view.window.contentView]
                             withNumberOfTouches:1
-                                withPointerType:RNGestureHandlerMouse];
+                                withPointerType:RNGestureHandlerMouse
+                                 withStylusData:nil];
 }
 #else
 - (RNGestureHandlerEventExtraData *)eventExtraData:(UIPanGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forPan:[recognizer locationInView:recognizer.view]
-                           withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
-                                withTranslation:[recognizer translationInView:recognizer.view.window]
-                                   withVelocity:[recognizer velocityInView:recognizer.view.window]
-                            withNumberOfTouches:recognizer.numberOfTouches
-                                withPointerType:_pointerType];
+  RNBetterPanGestureRecognizer *panRecognizer = (RNBetterPanGestureRecognizer *)recognizer;
+
+  return [RNGestureHandlerEventExtraData
+                    forPan:[recognizer locationInView:recognizer.view]
+      withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+           withTranslation:[recognizer translationInView:recognizer.view.window]
+              withVelocity:[recognizer velocityInView:recognizer.view.window]
+       withNumberOfTouches:recognizer.numberOfTouches
+           withPointerType:_pointerType
+            withStylusData:[panRecognizer.stylusData toDictionary]]; // In Objective-C calling method on nil returns
+                                                                     // nil, therefore this line does not crash.
 }
 #endif
 

package/apple/Handlers/RNRotationHandler.m

@@ -149,7 +149,7 @@
 #if TARGET_OS_OSX
 - (RNGestureHandlerEventExtraData *)eventExtraData:(NSRotationGestureRecognizer *)recognizer
 {
-  return [RNGestureHandlerEventExtraData forRotation:recognizer.rotation
+  return [RNGestureHandlerEventExtraData forRotation:-recognizer.rotation
                                      withAnchorPoint:[recognizer locationInView:recognizer.view]
                                         withVelocity:((RNBetterRotationRecognizer *)recognizer).velocity
                                  withNumberOfTouches:2

package/apple/RNGHStylusData.h

@@ -0,0 +1,77 @@
+//
+//  RNGHStylusData.h
+//  Pods
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#ifndef RNGHStylusData_h
+#define RNGHStylusData_h
+
+@interface RNGHStylusData : NSObject
+
+@property (atomic, assign) double tiltX;
+@property (atomic, assign) double tiltY;
+@property (atomic, assign) double altitudeAngle;
+@property (atomic, assign) double azimuthAngle;
+@property (atomic, assign) double pressure;
+
+- (NSDictionary *)toDictionary;
+
+@end
+
+static CGPoint ghSpherical2tilt(double altitudeAngle, double azimuthAngle)
+{
+  CGPoint tilts = {.x = 0.0, .y = 0.0};
+
+  const double radToDeg = 180 / M_PI;
+  const double eps = 0.000000001;
+
+  if (altitudeAngle < eps) {
+    // the pen is in the X-Y plane
+    if (azimuthAngle < eps || fabs(azimuthAngle - 2 * M_PI) < eps) {
+      // pen is on positive X axis
+      tilts.x = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) < eps) {
+      // pen is on positive Y axis
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI) < eps) {
+      // pen is on negative X axis
+      tilts.x = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      // pen is on negative Y axis
+      tilts.y = -M_PI_2;
+    }
+    if (azimuthAngle > eps && fabs(azimuthAngle - M_PI_2) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (fabs(azimuthAngle - M_PI_2) > eps && fabs(azimuthAngle - M_PI) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = M_PI_2;
+    }
+    if (azimuthAngle - M_PI > eps && fabs(azimuthAngle - 3 * M_PI_2) < eps) {
+      tilts.x = -M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+    if (fabs(azimuthAngle - 3 * M_PI_2) > eps && fabs(azimuthAngle - 2 * M_PI) < eps) {
+      tilts.x = M_PI_2;
+      tilts.y = -M_PI_2;
+    }
+  } else {
+    const double tanAlt = tan(altitudeAngle);
+
+    tilts.x = atan(cos(azimuthAngle) / tanAlt);
+    tilts.y = atan(sin(azimuthAngle) / tanAlt);
+  }
+
+  tilts.x = round(tilts.x * radToDeg);
+  tilts.y = round(tilts.y * radToDeg);
+
+  return tilts;
+}
+
+#endif /* RNGHStylusData_h */

package/apple/RNGHStylusData.m

@@ -0,0 +1,37 @@
+//
+//  RNGHStylusData.m
+//  DoubleConversion
+//
+//  Created by Michał Bert on 18/09/2024.
+//
+
+#import "RNGHStylusData.h"
+#import <Foundation/Foundation.h>
+
+@implementation RNGHStylusData
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.tiltX = 0;
+    self.tiltY = 0;
+    self.altitudeAngle = M_PI_2;
+    self.azimuthAngle = 0;
+    self.pressure = 0;
+  }
+
+  return self;
+}
+
+- (NSDictionary *)toDictionary
+{
+  return @{
+    @"tiltX" : @(_tiltX),
+    @"tiltY" : @(_tiltY),
+    @"altitudeAngle" : @(_altitudeAngle),
+    @"azimuthAngle" : @(_azimuthAngle),
+    @"pressure" : @(_pressure),
+  };
+}
+
+@end

package/apple/RNGHUIKit.h

@@ -4,6 +4,7 @@
 
 typedef UIView RNGHUIView;
 typedef UITouch RNGHUITouch;
+typedef UIScrollView RNGHUIScrollView;
 
 #define RNGHGestureRecognizerStateFailed UIGestureRecognizerStateFailed;
 #define RNGHGestureRecognizerStatePossible UIGestureRecognizerStatePossible;
@@ -17,6 +18,7 @@ typedef UITouch RNGHUITouch;
 
 typedef RCTUIView RNGHUIView;
 typedef RCTUITouch RNGHUITouch;
+typedef NSScrollView RNGHUIScrollView;
 
 #define RNGHGestureRecognizerStateFailed NSGestureRecognizerStateFailed;
 #define RNGHGestureRecognizerStatePossible NSGestureRecognizerStatePossible;

package/apple/RNGHVector.h

@@ -0,0 +1,31 @@
+//
+//  RNGHVector.h
+//  Pods
+//
+//  Created by Michał Bert on 05/08/2024.
+//
+
+#import "RNGestureHandlerDirection.h"
+
+#ifndef RNGHVector_h
+#define RNGHVector_h
+
+@interface Vector : NSObject
+
+@property (atomic, readonly, assign) double x;
+@property (atomic, readonly, assign) double y;
+@property (atomic, readonly, assign) double unitX;
+@property (atomic, readonly, assign) double unitY;
+@property (atomic, readonly, assign) double magnitude;
+
++ (Vector *_Nonnull)fromDirection:(RNGestureHandlerDirection)direction;
++ (Vector *_Nonnull)fromVelocityX:(double)vx withVelocityY:(double)vy;
+- (nonnull instancetype)initWithX:(double)x withY:(double)y;
+- (double)computeSimilarity:(Vector *_Nonnull)other;
+- (BOOL)isSimilar:(Vector *_Nonnull)other withThreshold:(double)threshold;
+
+@end
+
+static double MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;
+
+#endif /* RNGHVector_h */

package/apple/RNGHVector.m

@@ -0,0 +1,67 @@
+//
+//  RNGHVector.m
+//  DoubleConversion
+//
+//  Created by Michał Bert on 05/08/2024.
+//
+
+#import "RNGHVector.h"
+#import <Foundation/Foundation.h>
+
+@implementation Vector
+
+- (id)initWithX:(double)x withY:(double)y
+{
+  if (self = [super init]) {
+    _x = x;
+    _y = y;
+
+    _magnitude = hypot(x, y);
+
+    _unitX = self.magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE ? x / self.magnitude : 0;
+    _unitY = self.magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE ? y / self.magnitude : 0;
+  }
+
+  return self;
+}
+
++ (Vector *)fromDirection:(RNGestureHandlerDirection)direction
+{
+  switch (direction) {
+    case RNGestureHandlerDirectionRight:
+      return [[Vector alloc] initWithX:1 withY:0];
+    case RNGestureHandlerDirectionLeft:
+      return [[Vector alloc] initWithX:-1 withY:0];
+    case RNGestureHandlerDirectionUp:
+      return [[Vector alloc] initWithX:0 withY:1];
+    case RNGestureHandlerDirectionDown:
+      return [[Vector alloc] initWithX:0 withY:-1];
+    case RNGestureHandlerDirectionUpLeft:
+      return [[Vector alloc] initWithX:-1 withY:1];
+    case RNGestureHandlerDirectionUpRight:
+      return [[Vector alloc] initWithX:1 withY:1];
+    case RNGestureHandlerDirectionDownLeft:
+      return [[Vector alloc] initWithX:-1 withY:-1];
+    case RNGestureHandlerDirectionDownRight:
+      return [[Vector alloc] initWithX:1 withY:-1];
+    default:
+      return [[Vector alloc] initWithX:0 withY:0];
+  }
+}
+
++ (Vector *)fromVelocityX:(double)vx withVelocityY:(double)vy;
+{
+  return [[Vector alloc] initWithX:vx withY:vy];
+}
+
+- (double)computeSimilarity:(Vector *)other
+{
+  return self.unitX * other.unitX + self.unitY * other.unitY;
+}
+
+- (BOOL)isSimilar:(Vector *)other withThreshold:(double)threshold
+{
+  return [self computeSimilarity:other] > threshold;
+}
+
+@end

package/apple/RNGestureHandler.h

@@ -89,6 +89,13 @@
             withExtraData:(nonnull RNGestureHandlerEventExtraData *)extraData;
 - (void)sendEvent:(nonnull RNGestureHandlerStateChange *)event;
 - (void)sendTouchEventInState:(RNGestureHandlerState)state forViewWithTag:(nonnull NSNumber *)reactTag;
+- (nullable RNGHUIScrollView *)retrieveScrollView:(nonnull RNGHUIView *)view;
+
+#if !TARGET_OS_OSX
+- (BOOL)isUIScrollViewPanGestureRecognizer:(nonnull UIGestureRecognizer *)gestureRecognizer;
+#else
+- (BOOL)isUIScrollViewPanGestureRecognizer:(nonnull NSGestureRecognizer *)gestureRecognizer;
+#endif
 
 #if !TARGET_OS_OSX
 - (void)setCurrentPointerType:(nonnull UIEvent *)event;

package/apple/{RNGestureHandler.m → RNGestureHandler.mm}

@@ -5,10 +5,17 @@
 
 #if !TARGET_OS_OSX
 #import <UIKit/UIGestureRecognizerSubclass.h>
+#import <UIKit/UIPanGestureRecognizer.h>
 #endif
 
 #import <React/UIView+React.h>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTScrollViewComponentView.h>
+#else
+#import <React/RCTScrollView.h>
+#endif
+
 @interface UIGestureRecognizer (GestureHandler)
 @property (nonatomic, readonly) RNGestureHandler *gestureHandler;
 @end
@@ -205,7 +212,7 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
 
 - (UITouchType)getPointerType
 {
-  return _pointerType;
+  return (UITouchType)_pointerType;
 }
 
 - (void)bindToView:(RNGHUIView *)view
@@ -474,6 +481,10 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
     return YES;
   }
 
+  if ([self areScrollViewRecognizersCompatible:gestureRecognizer otherRecognizer:otherGestureRecognizer]) {
+    return YES;
+  }
+
   RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
   if (handler != nil) {
     if ([_simultaneousHandlers count]) {
@@ -495,6 +506,57 @@ static NSHashTable<RNGestureHandler *> *allGestureHandlers;
   return NO;
 }
 
+- (BOOL)areScrollViewRecognizersCompatible:(UIGestureRecognizer *)gestureRecognizer
+                           otherRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  if ([self isUIScrollViewPanGestureRecognizer:otherGestureRecognizer] &&
+      [gestureRecognizer isKindOfClass:[RNDummyGestureRecognizer class]]) {
+    RNGHUIScrollView *scrollView = [self retrieveScrollView:gestureRecognizer.view];
+    if (scrollView && scrollView == otherGestureRecognizer.view) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
+#if !TARGET_OS_OSX
+// is UIPanGestureRecognizer and has scrollView property
+- (BOOL)isUIScrollViewPanGestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+{
+  return [gestureRecognizer isKindOfClass:[UIPanGestureRecognizer class]] &&
+      [gestureRecognizer respondsToSelector:@selector(scrollView)];
+}
+
+#else
+
+- (BOOL)isUIScrollViewPanGestureRecognizer:(NSGestureRecognizer *)gestureRecognizer
+{
+  return NO;
+}
+
+#endif
+
+- (RNGHUIScrollView *)retrieveScrollView:(RNGHUIView *)view
+{
+#ifdef RCT_NEW_ARCH_ENABLED
+  if ([view isKindOfClass:[RCTScrollViewComponentView class]]) {
+    RNGHUIScrollView *scrollView = ((RCTScrollViewComponentView *)view).scrollView;
+    return scrollView;
+  }
+#else
+  if ([view isKindOfClass:[RCTScrollView class]]) {
+    // This part of the code is coupled with RN implementation of ScrollView native wrapper and
+    // we expect for RCTScrollView component to contain a subclass of UIScrollview as the only
+    // subview
+    RNGHUIScrollView *scrollView = [view.subviews objectAtIndex:0];
+    return scrollView;
+  }
+#endif
+
+  return nil;
+}
+
 - (void)reset
 {
   // do not reset states while gesture is tracking pointers, as gestureRecognizerShouldBegin