react-native-gesture-handler 2.18.0 → 2.19.0

package/apple/Handlers/RNLongPressHandler.m

@@ -7,22 +7,37 @@
 //
 
 #import "RNLongPressHandler.h"
+#import <React/RCTConvert.h>
 
 #if !TARGET_OS_OSX
 
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
-#import <React/RCTConvert.h>
-
 @interface RNBetterLongPressGestureRecognizer : UILongPressGestureRecognizer {
+#else
+@interface RNBetterLongPressGestureRecognizer : NSGestureRecognizer {
+  dispatch_block_t block;
+#endif
+
   CFTimeInterval startTime;
   CFTimeInterval previousTime;
 }
 
+#if TARGET_OS_OSX
+@property (nonatomic, assign) double minimumPressDuration;
+@property (nonatomic, assign) double allowableMovement;
+@property (nonatomic, assign) double numberOfTouchesRequired;
+#endif
+
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
-- (void)handleGesture:(UIGestureRecognizer *)recognizer;
 - (NSUInteger)getDuration;
 
+#if !TARGET_OS_OSX
+- (void)handleGesture:(UIGestureRecognizer *)recognizer;
+#else
+- (void)handleGesture:(NSGestureRecognizer *)recognizer;
+#endif
+
 @end
 
 @implementation RNBetterLongPressGestureRecognizer {
@@ -55,12 +70,16 @@
   return CGPointMake(currentPosition.x - _initPosition.x, currentPosition.y - _initPosition.y);
 }
 
+#if !TARGET_OS_OSX
+
 - (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   [_gestureHandler setCurrentPointerType:event];
   [super touchesBegan:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
 
+  self.state = UIGestureRecognizerStatePossible;
+
   _initPosition = [self locationInView:self.view];
   startTime = CACurrentMediaTime();
   [_gestureHandler reset];
@@ -72,10 +91,8 @@
   [super touchesMoved:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
 
-  CGPoint trans = [self translationInView];
-  if ((_gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView]) ||
-      (TEST_MAX_IF_NOT_NAN(
-          fabs(trans.y * trans.y + trans.x * trans.x), self.allowableMovement * self.allowableMovement))) {
+  if ([self shouldCancelGesture]) {
+    self.state = UIGestureRecognizerStateFailed;
     self.enabled = NO;
     self.enabled = YES;
   }
@@ -94,6 +111,75 @@
   [self reset];
 }
 
+#else
+- (void)mouseDown:(NSEvent *)event
+{
+  self.state = NSGestureRecognizerStateBegan;
+  startTime = CACurrentMediaTime();
+
+  [_gestureHandler.pointerTracker touchesBegan:[NSSet setWithObject:event] withEvent:event];
+
+  _initPosition = [self locationInView:self.view];
+
+  __weak typeof(self) weakSelf = self;
+
+  block = dispatch_block_create(0, ^{
+    __strong typeof(self) strongSelf = weakSelf;
+
+    if (strongSelf) {
+      strongSelf.state = NSGestureRecognizerStateChanged;
+    }
+  });
+
+  dispatch_after(
+      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(self.minimumPressDuration * NSEC_PER_SEC)),
+      dispatch_get_main_queue(),
+      block);
+}
+
+- (void)mouseDragged:(NSEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesMoved:[NSSet setWithObject:event] withEvent:event];
+
+  if (block == nil) {
+    return;
+  }
+
+  if ([self shouldCancelGesture]) {
+    dispatch_block_cancel(block);
+    block = nil;
+
+    self.state = self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateCancelled
+                                                               : NSGestureRecognizerStateFailed;
+  }
+}
+
+- (void)mouseUp:(NSEvent *)event
+{
+  [_gestureHandler.pointerTracker touchesEnded:[NSSet setWithObject:event] withEvent:event];
+
+  if (block) {
+    dispatch_block_cancel(block);
+    block = nil;
+  }
+
+  self.state =
+      self.state == NSGestureRecognizerStateChanged ? NSGestureRecognizerStateEnded : NSGestureRecognizerStateFailed;
+}
+
+#endif
+
+- (BOOL)shouldCancelGesture
+{
+  CGPoint trans = [self translationInView];
+
+  BOOL shouldBeCancelledOutside = _gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView];
+  BOOL distanceExceeded =
+      TEST_MAX_IF_NOT_NAN(fabs(trans.y * trans.y + trans.x * trans.x), self.allowableMovement * self.allowableMovement);
+
+  return shouldBeCancelledOutside || distanceExceeded;
+}
+
 - (void)reset
 {
   if (self.state == UIGestureRecognizerStateFailed) {
@@ -126,7 +212,7 @@
 - (void)resetConfig
 {
   [super resetConfig];
-  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
 
   recognizer.minimumPressDuration = 0.5;
   recognizer.allowableMovement = 10;
@@ -135,7 +221,7 @@
 - (void)configure:(NSDictionary *)config
 {
   [super configure:config];
-  UILongPressGestureRecognizer *recognizer = (UILongPressGestureRecognizer *)_recognizer;
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
 
   id prop = config[@"minDurationMs"];
   if (prop != nil) {
@@ -146,8 +232,15 @@
   if (prop != nil) {
     recognizer.allowableMovement = [RCTConvert CGFloat:prop];
   }
+
+  prop = config[@"numberOfPointers"];
+  if (prop != nil) {
+    recognizer.numberOfTouchesRequired = [RCTConvert CGFloat:prop];
+  }
 }
 
+#if !TARGET_OS_OSX
+
 - (RNGestureHandlerState)state
 {
   // For long press recognizer we treat "Began" state as "active"
@@ -178,21 +271,17 @@
                                         withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
                                      withPointerType:_pointerType];
 }
-@end
 
 #else
 
-@implementation RNLongPressGestureHandler
-
-- (instancetype)initWithTag:(NSNumber *)tag
+- (RNGestureHandlerEventExtraData *)eventExtraData:(NSGestureRecognizer *)recognizer
 {
-  RCTLogWarn(@"LongPressGestureHandler is not supported on macOS");
-  if ((self = [super initWithTag:tag])) {
-    _recognizer = [NSGestureRecognizer alloc];
-  }
-  return self;
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window.contentView]
+                                 withNumberOfTouches:1
+                                        withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
+                                     withPointerType:RNGestureHandlerMouse];
 }
 
-@end
-
 #endif
+@end

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/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

package/apple/RNGestureHandlerButtonComponentView.mm

@@ -21,6 +21,12 @@ using namespace facebook::react;
   RNGestureHandlerButton *_buttonView;
 }
 
+// Needed because of this: https://github.com/facebook/react-native/pull/37274
++ (void)load
+{
+  [super load];
+}
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {

package/apple/RNGestureHandlerDirection.h

@@ -1,8 +1,33 @@
 #import <Foundation/Foundation.h>
 
+#ifndef RNGestureHandlerDirection_h
+#define RNGestureHandlerDirection_h
+
 typedef NS_ENUM(NSInteger, RNGestureHandlerDirection) {
   RNGestureHandlerDirectionRight = 1,
   RNGestureHandlerDirectionLeft = 2,
   RNGestureHandlerDirectionUp = 4,
   RNGestureHandlerDirectionDown = 8,
+  RNGestureHandlerDirectionUpLeft = RNGestureHandlerDirectionUp | RNGestureHandlerDirectionLeft,
+  RNGestureHandlerDirectionUpRight = RNGestureHandlerDirectionUp | RNGestureHandlerDirectionRight,
+  RNGestureHandlerDirectionDownLeft = RNGestureHandlerDirectionDown | RNGestureHandlerDirectionLeft,
+  RNGestureHandlerDirectionDownRight = RNGestureHandlerDirectionDown | RNGestureHandlerDirectionRight,
+};
+
+static NSInteger axialDirections[] = {
+    RNGestureHandlerDirectionRight,
+    RNGestureHandlerDirectionLeft,
+    RNGestureHandlerDirectionUp,
+    RNGestureHandlerDirectionDown,
 };
+
+static NSInteger diagonalDirections[] = {
+    RNGestureHandlerDirectionUpLeft,
+    RNGestureHandlerDirectionUpRight,
+    RNGestureHandlerDirectionDownLeft,
+    RNGestureHandlerDirectionDownRight,
+};
+
+static NSInteger directionsSize = 4;
+
+#endif

package/apple/RNGestureHandlerModule.mm

@@ -99,10 +99,8 @@ void decorateRuntime(jsi::Runtime &runtime)
         if (!arguments[0].isObject()) {
           return jsi::Value::null();
         }
-
-        auto shadowNodeWrapper = arguments[0].asObject(runtime).getNativeState<ShadowNodeWrapper>(runtime);
-        bool isFormsStackingContext =
-            shadowNodeWrapper->shadowNode->getTraits().check(ShadowNodeTraits::FormsStackingContext);
+        auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
+        bool isFormsStackingContext = shadowNode->getTraits().check(ShadowNodeTraits::FormsStackingContext);
         return jsi::Value(isFormsStackingContext);
       });
   runtime.global().setProperty(runtime, "isFormsStackingContext", std::move(isFormsStackingContext));