react-native-gesture-handler 1.10.3 → 2.1.2

package/ios/RNGestureHandlerManager.m

@@ -27,6 +27,7 @@
 #import "Handlers/RNPinchHandler.h"
 #import "Handlers/RNRotationHandler.h"
 #import "Handlers/RNForceTouchHandler.h"
+#import "Handlers/RNManualHandler.h"
 
 // We use the method below instead of RCTLog because we log out messages after the bridge gets
 // turned down in some cases. Which normally with RCTLog would cause a crash in DEBUG mode
@@ -40,7 +41,7 @@
 {
     RNGestureHandlerRegistry *_registry;
     RCTUIManager *_uiManager;
-    NSHashTable<UIView *> *_rootViews;
+    NSHashTable<RNRootViewGestureRecognizer *> *_rootViewGestureRecognizers;
     RCTEventDispatcher *_eventDispatcher;
 }
 
@@ -51,7 +52,7 @@
         _uiManager = uiManager;
         _eventDispatcher = eventDispatcher;
         _registry = [RNGestureHandlerRegistry new];
-        _rootViews = [NSHashTable hashTableWithOptions:NSPointerFunctionsWeakMemory];
+        _rootViewGestureRecognizers = [NSHashTable hashTableWithOptions:NSPointerFunctionsWeakMemory];
     }
     return self;
 }
@@ -72,6 +73,7 @@
                 @"PinchGestureHandler": [RNPinchGestureHandler class],
                 @"RotationGestureHandler": [RNRotationGestureHandler class],
                 @"ForceTouchGestureHandler": [RNForceTouchHandler class],
+                @"ManualGestureHandler": [RNManualGestureHandler class],
                 };
     });
     
@@ -97,8 +99,19 @@
 
     [_registry attachHandlerWithTag:handlerTag toView:view];
 
-    // register root view if not already there
-    [self registerRootViewIfNeeded:view];
+    // register view if not already there
+    [self registerViewWithGestureRecognizerAttachedIfNeeded:view];
+}
+
+- (void)attachGestureHandlerForDeviceEvents:(nonnull NSNumber *)handlerTag
+                              toViewWithTag:(nonnull NSNumber *)viewTag
+{
+    UIView *view = [_uiManager viewForReactTag:viewTag];
+
+    [_registry attachHandlerWithTagForDeviceEvents:handlerTag toView:view];
+
+    // register view if not already there
+    [self registerViewWithGestureRecognizerAttachedIfNeeded:view];
 }
 
 - (void)updateGestureHandler:(NSNumber *)handlerTag config:(NSDictionary *)config
@@ -115,12 +128,8 @@
 - (void)handleSetJSResponder:(NSNumber *)viewTag blockNativeResponder:(NSNumber *)blockNativeResponder
 {
     if ([blockNativeResponder boolValue]) {
-        for (RCTRootView *rootView in _rootViews) {
-            for (UIGestureRecognizer *recognizer in rootView.gestureRecognizers) {
-                if ([recognizer isKindOfClass:[RNRootViewGestureRecognizer class]]) {
-                    [(RNRootViewGestureRecognizer *)recognizer blockOtherRecognizers];
-                }
-            }
+        for (RNRootViewGestureRecognizer *recognizer in _rootViewGestureRecognizers) {
+            [recognizer blockOtherRecognizers];
         }
     }
 }
@@ -130,27 +139,43 @@
     // ignore...
 }
 
+- (id)handlerWithTag:(NSNumber *)handlerTag
+{
+  return [_registry handlerWithTag:handlerTag];
+}
+
+
 #pragma mark Root Views Management
 
-- (void)registerRootViewIfNeeded:(UIView*)childView
+- (void)registerViewWithGestureRecognizerAttachedIfNeeded:(UIView *)childView
 {
     UIView *parent = childView;
-    while (parent != nil && ![parent isKindOfClass:[RCTRootView class]]) parent = parent.superview;
-    
-    RCTRootView *rootView = (RCTRootView *)parent;
-    UIView *rootContentView = rootView.contentView;
-    if (rootContentView != nil && ![_rootViews containsObject:rootContentView]) {
-        RCTLifecycleLog(@"[GESTURE HANDLER] Initialize gesture handler for root view %@", rootContentView);
-        [_rootViews addObject:rootContentView];
-        RNRootViewGestureRecognizer *recognizer = [RNRootViewGestureRecognizer new];
-        recognizer.delegate = self;
-        rootContentView.userInteractionEnabled = YES;
-        [rootContentView addGestureRecognizer:recognizer];
+    while (parent != nil && ![parent respondsToSelector:@selector(touchHandler)]) parent = parent.superview;
+
+    // Many views can return the same touchHandler so we check if the one we want to register
+    // is not already present in the set.
+    UIView *touchHandlerView = [[parent performSelector:@selector(touchHandler)] view];
+  
+    if (touchHandlerView == nil) {
+      return;
+    }
+  
+    for (UIGestureRecognizer *recognizer in touchHandlerView.gestureRecognizers) {
+      if ([recognizer isKindOfClass:[RNRootViewGestureRecognizer class]]) {
+        return;
+      }
     }
+  
+    RCTLifecycleLog(@"[GESTURE HANDLER] Initialize gesture handler for view %@", touchHandlerView);
+    RNRootViewGestureRecognizer *recognizer = [RNRootViewGestureRecognizer new];
+    recognizer.delegate = self;
+    touchHandlerView.userInteractionEnabled = YES;
+    [touchHandlerView addGestureRecognizer:recognizer];
+    [_rootViewGestureRecognizers addObject:recognizer];
 }
 
 - (void)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
-    didActivateInRootView:(UIView *)rootContentView
+    didActivateInViewWithTouchHandler:(UIView *)viewWithTouchHandler
 {
     // Cancel touches in RN's root view in order to cancel all in-js recognizers
 
@@ -165,17 +190,8 @@
     // Once the upstream fix lands the line below along with this comment can be removed
     if ([gestureRecognizer.view isKindOfClass:[UIScrollView class]]) return;
 
-    UIView *parent = rootContentView.superview;
-    if ([parent isKindOfClass:[RCTRootView class]]) {
-        [((RCTRootContentView*)rootContentView).touchHandler cancel];
-    }
-}
-
-- (void)dealloc
-{
-    if ([_rootViews count] > 0) {
-        RCTLifecycleLog(@"[GESTURE HANDLER] Tearing down gesture handler registered for views %@", _rootViews);
-    }
+    RCTTouchHandler *touchHandler = [viewWithTouchHandler performSelector:@selector(touchHandler)];
+    [touchHandler cancel];
 }
 
 #pragma mark Events
@@ -190,4 +206,16 @@
     [_eventDispatcher sendEvent:event];
 }
 
+- (void)sendTouchDeviceEvent:(RNGestureHandlerEvent *)event
+{
+    NSMutableDictionary *body = [[event arguments] objectAtIndex:2];
+    [_eventDispatcher sendDeviceEventWithName:@"onGestureHandlerEvent" body:body];
+}
+
+- (void)sendStateChangeDeviceEvent:(RNGestureHandlerStateChange *)event
+{
+    NSMutableDictionary *body = [[event arguments] objectAtIndex:2];
+    [_eventDispatcher sendDeviceEventWithName:@"onGestureHandlerStateChange" body:body];
+}
+
 @end

package/ios/RNGestureHandlerModule.m

@@ -13,8 +13,9 @@
 #import "RNGestureHandlerManager.h"
 
 #import "RNGestureHandlerButton.h"
+#import "RNGestureHandlerStateManager.h"
 
-@interface RNGestureHandlerModule () <RCTUIManagerObserver>
+@interface RNGestureHandlerModule () <RCTUIManagerObserver, RNGestureHandlerStateManager>
 
 @end
 
@@ -102,10 +103,14 @@ RCT_EXPORT_METHOD(createGestureHandler:(nonnull NSString *)handlerName tag:(nonn
     }];
 }
 
-RCT_EXPORT_METHOD(attachGestureHandler:(nonnull NSNumber *)handlerTag toViewWithTag:(nonnull NSNumber *)viewTag)
+RCT_EXPORT_METHOD(attachGestureHandler:(nonnull NSNumber *)handlerTag toViewWithTag:(nonnull NSNumber *)viewTag useDeviceEvents: (BOOL)useDeviceEvents)
 {
     [self addOperationBlock:^(RNGestureHandlerManager *manager) {
-        [manager attachGestureHandler:handlerTag toViewWithTag:viewTag];
+        if (useDeviceEvents) {
+            [manager attachGestureHandlerForDeviceEvents:handlerTag toViewWithTag:viewTag];
+        } else {
+            [manager attachGestureHandler:handlerTag toViewWithTag:viewTag];
+        }
     }];
 }
 
@@ -137,6 +142,37 @@ RCT_EXPORT_METHOD(handleClearJSResponder)
     }];
 }
 
+- (void)setGestureState:(int)state forHandler:(int)handlerTag
+{
+  RNGestureHandler *handler = [_manager handlerWithTag:@(handlerTag)];
+
+  if (handler != nil) {
+    if (state == 1) { // FAILED
+      handler.recognizer.state = UIGestureRecognizerStateFailed;
+    } else if (state == 2) { // BEGAN
+      handler.recognizer.state = UIGestureRecognizerStatePossible;
+    } else if (state == 3) { // CANCELLED
+      handler.recognizer.state = UIGestureRecognizerStateCancelled;
+    } else if (state == 4) { // ACTIVE
+      [handler stopActivationBlocker];
+      handler.recognizer.state = UIGestureRecognizerStateBegan;
+    } else if (state == 5) { // ENDED
+      handler.recognizer.state = UIGestureRecognizerStateEnded;
+    }
+  }
+  
+  // if the gesture was set to finish, cancel all pointers it was tracking
+  if (state == 1 || state == 3 || state == 5) {
+    [handler.pointerTracker cancelPointers];
+  }
+  
+  // do not send state change event when activating because it bypasses
+  // shouldRequireFailureOfGestureRecognizer
+  if (state != 4) {
+    [handler handleGesture:handler.recognizer];
+  }
+}
+
 #pragma mark -- Batch handling
 
 - (void)addOperationBlock:(GestureHandlerOperation)operation

package/ios/RNGestureHandlerPointerTracker.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+
+#import "RNTouchEventType.h"
+
+#define MAX_POINTERS_COUNT 12
+
+@class RNGestureHandler;
+
+@interface RNGestureHandlerPointerTracker : NSObject
+
+@property (nonatomic) RNTouchEventType eventType;
+@property (nonatomic) NSArray<NSDictionary *> *changedPointersData;
+@property (nonatomic) NSArray<NSDictionary *> *allPointersData;
+@property (nonatomic) int trackedPointersCount;
+
+- (id)initWithGestureHandler:(RNGestureHandler*)gestureHandler;
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)reset;
+- (void)cancelPointers;
+
+@end

package/ios/RNGestureHandlerPointerTracker.m

@@ -0,0 +1,237 @@
+#import "RNGestureHandlerPointerTracker.h"
+#import "RNGestureHandler.h"
+
+#import <React/UIView+React.h>
+
+@implementation RNGestureHandlerPointerTracker {
+  __weak RNGestureHandler *_gestureHandler;
+  UITouch *_trackedPointers[MAX_POINTERS_COUNT];
+  int _trackedPointersCount;
+}
+
+- (id)initWithGestureHandler:(id)gestureHandler
+{
+  _gestureHandler = gestureHandler;
+  _trackedPointersCount = 0;
+  _changedPointersData = nil;
+  _allPointersData = nil;
+  
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    _trackedPointers[i] = nil;
+  }
+  
+  return self;
+}
+
+- (int)registerTouch:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == nil) {
+      _trackedPointers[index] = touch;
+      return index;
+    }
+  }
+  
+  return -1;
+}
+
+- (int)unregisterTouch:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == touch) {
+      _trackedPointers[index] = nil;
+      return index;
+    }
+  }
+  
+  return -1;
+}
+
+- (int)findTouchIndex:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == touch) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+- (int)registeredTouchesCount
+{
+  int count = 0;
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    if (_trackedPointers[i] != nil) {
+      count++;
+    }
+  }
+  return count;
+}
+
+- (NSDictionary *)extractPointerData:(int)index
+                            forTouch:(UITouch *)touch
+{
+  CGPoint relativePos = [touch locationInView:_gestureHandler.recognizer.view];
+  CGPoint absolutePos = [touch locationInView:_gestureHandler.recognizer.view.window];
+  
+  return @{@"id": @(index),
+              @"x": @(relativePos.x),
+              @"y": @(relativePos.y),
+              @"absoluteX": @(absolutePos.x),
+              @"absoluteY": @(absolutePos.y)};
+}
+
+- (void)extractAllTouches {
+  int registeredTouches = [self registeredTouchesCount];
+
+  NSDictionary *data[registeredTouches];
+  int nextIndex = 0;
+  
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    UITouch *touch = _trackedPointers[i];
+    if (touch != nil) {
+      data[nextIndex++] = [self extractPointerData:i forTouch:touch];
+    }
+  }
+  
+  _allPointersData = [[NSArray alloc] initWithObjects:data count:registeredTouches];
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  _eventType = RNTouchEventTypePointerDown;
+  
+  NSDictionary *data[touches.count];
+  
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self registerTouch:touch];
+    if (index >= 0) {
+      _trackedPointersCount++;
+    }
+
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+  
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  // extract all touches last to include the ones that were just added
+  [self extractAllTouches];
+  [self sendEvent];
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  _eventType = RNTouchEventTypePointerMove;
+  
+  NSDictionary *data[touches.count];
+  
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self findTouchIndex:touch];
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+  
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  [self extractAllTouches];
+  [self sendEvent];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  // extract all touches first to include the ones that were just lifted
+  [self extractAllTouches];
+  
+  _eventType = RNTouchEventTypePointerUp;
+  
+  NSDictionary *data[touches.count];
+  
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self unregisterTouch:touch];
+    if (index >= 0) {
+      _trackedPointersCount--;
+    }
+
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+  
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  [self sendEvent];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  [self reset];
+}
+
+- (void)reset
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  if (_trackedPointersCount == 0) {
+    // gesture has finished because all pointers were lifted, reset event type to send state change event
+    _eventType = RNTouchEventTypeUndetermined;
+  } else {
+    // turns out that the gesture may be made to fail without calling touchesCancelled in that case there
+    // are still tracked pointers but the recognizer state is already set to UIGestureRecognizerStateFailed
+    // we need to clear the pointers and send info about their cancellation
+    [self cancelPointers];
+  }
+  
+  [_gestureHandler reset];
+}
+
+- (void)cancelPointers
+{
+  // extract all touches first to include the ones that were just cancelled
+  [self extractAllTouches];
+  
+  int registeredTouches = [self registeredTouchesCount];
+  
+  if (registeredTouches > 0) {
+    int nextIndex = 0;
+    NSDictionary *data[registeredTouches];
+    
+    for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+      UITouch *touch = _trackedPointers[i];
+      if (touch != nil) {
+        data[nextIndex++] = [self extractPointerData:i forTouch:touch];
+        [self unregisterTouch:touch];
+      }
+    }
+    
+    _eventType = RNTouchEventTypeCancelled;
+    _changedPointersData = [[NSArray alloc] initWithObjects:data count:registeredTouches];
+    [self sendEvent];
+    _trackedPointersCount = 0;
+  }
+}
+
+- (void)sendEvent
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+  
+  [_gestureHandler sendTouchEventInState:[_gestureHandler state] forViewWithTag:_gestureHandler.recognizer.view.reactTag];
+}
+
+@end

package/ios/RNGestureHandlerRegistry.h

@@ -13,6 +13,7 @@
 - (nullable RNGestureHandler *)handlerWithTag:(nonnull NSNumber *)handlerTag;
 - (void)registerGestureHandler:(nonnull RNGestureHandler *)gestureHandler;
 - (void)attachHandlerWithTag:(nonnull NSNumber *)handlerTag toView:(nonnull UIView *)view;
+- (void)attachHandlerWithTagForDeviceEvents:(nonnull NSNumber *)handlerTag toView:(nonnull UIView *)view;
 - (void)dropHandlerWithTag:(nonnull NSNumber *)handlerTag;
 
 @end

package/ios/RNGestureHandlerRegistry.m

@@ -37,6 +37,16 @@
     RNGestureHandler *handler = _handlers[handlerTag];
     RCTAssert(handler != nil, @"Handler for tag %@ does not exists", handlerTag);
     [handler unbindFromView];
+    handler.usesDeviceEvents = NO;
+    [handler bindToView:view];
+}
+
+- (void)attachHandlerWithTagForDeviceEvents:(NSNumber *)handlerTag toView:(UIView *)view
+{
+    RNGestureHandler *handler = _handlers[handlerTag];
+    RCTAssert(handler != nil, @"Handler for tag %@ does not exists", handlerTag);
+    [handler unbindFromView];
+    handler.usesDeviceEvents = YES;
     [handler bindToView:view];
 }
 

package/ios/RNGestureHandlerStateManager.h

@@ -0,0 +1,5 @@
+@protocol RNGestureHandlerStateManager
+
+-(void) setGestureState:(int)state forHandler:(int)handlerTag;
+
+@end

package/ios/RNManualActivationRecognizer.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+@class RNGestureHandler;
+
+@interface RNManualActivationRecognizer : UIGestureRecognizer <UIGestureRecognizerDelegate>
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+- (void)fail;
+
+@end

package/ios/RNManualActivationRecognizer.m

@@ -0,0 +1,80 @@
+#import "RNManualActivationRecognizer.h"
+#import "RNGestureHandler.h"
+
+@implementation RNManualActivationRecognizer {
+  RNGestureHandler *_handler;
+  int _activePointers;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:nil])) {
+    _handler = gestureHandler;
+    self.delegate = self;
+    _activePointers = 0;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+
+  _activePointers += touches.count;
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  
+  _activePointers -= touches.count;
+  
+  if (_activePointers == 0) {
+    [self fail];
+    [self reset];
+  }
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  
+  _activePointers = 0;
+  [self reset];
+}
+
+- (void)reset
+{
+  self.enabled = YES;
+  [super reset];
+}
+
+- (void)fail
+{
+  self.enabled = NO;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  return YES;
+}
+
+- (BOOL)shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+  if (handler != nil) {
+    if (handler.tag == _handler.tag) {
+      return YES;
+    }
+  }
+  
+  return NO;
+}
+
+@end

package/ios/RNRootViewGestureRecognizer.m

@@ -50,7 +50,7 @@
 {
     // When this method is called it means that one of handlers has activated, in this case we want
     // to send an info to JS so that it cancells all JS responders
-    [self.delegate gestureRecognizer:preventingGestureRecognizer didActivateInRootView:self.view];
+    [self.delegate gestureRecognizer:preventingGestureRecognizer didActivateInViewWithTouchHandler:self.view];
     return [super canBePreventedByGestureRecognizer:preventingGestureRecognizer];
 }
 

package/ios/RNTouchEventType.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNTouchEventType) {
+  RNTouchEventTypeUndetermined = 0,
+  RNTouchEventTypePointerDown,
+  RNTouchEventTypePointerMove,
+  RNTouchEventTypePointerUp,
+  RNTouchEventTypeCancelled,
+};

package/lib/commonjs/EventType.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventType = void 0;
+const EventType = {
+  UNDETERMINED: 0,
+  TOUCHES_DOWN: 1,
+  TOUCHES_MOVE: 2,
+  TOUCHES_UP: 3,
+  TOUCHES_CANCELLED: 4
+}; // eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value
+
+exports.EventType = EventType;
+//# sourceMappingURL=EventType.js.map

package/lib/commonjs/EventType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["EventType.ts"],"names":["EventType","UNDETERMINED","TOUCHES_DOWN","TOUCHES_MOVE","TOUCHES_UP","TOUCHES_CANCELLED"],"mappings":";;;;;;AAAO,MAAMA,SAAS,GAAG;AACvBC,EAAAA,YAAY,EAAE,CADS;AAEvBC,EAAAA,YAAY,EAAE,CAFS;AAGvBC,EAAAA,YAAY,EAAE,CAHS;AAIvBC,EAAAA,UAAU,EAAE,CAJW;AAKvBC,EAAAA,iBAAiB,EAAE;AALI,CAAlB,C,CAQP","sourcesContent":["export const EventType = {\n  UNDETERMINED: 0,\n  TOUCHES_DOWN: 1,\n  TOUCHES_MOVE: 2,\n  TOUCHES_UP: 3,\n  TOUCHES_CANCELLED: 4,\n} as const;\n\n// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value\nexport type EventType = typeof EventType[keyof typeof EventType];\n"]}

package/lib/commonjs/GestureHandlerRootView.android.js

@@ -14,23 +14,11 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 const GestureHandlerRootViewNative = (0, _reactNative.requireNativeComponent)('GestureHandlerRootView');
-const GestureHandlerRootViewContext = /*#__PURE__*/React.createContext(false);
 
 function GestureHandlerRootView({
   children,
   ...rest
 }) {
-  return /*#__PURE__*/React.createElement(GestureHandlerRootViewContext.Consumer, null, available => {
-    if (available) {
-      // If we already have a parent wrapped in the gesture handler root view,
-      // We don't need to wrap it again in root view
-      // We still wrap it in a normal view so our styling stays the same
-      return /*#__PURE__*/React.createElement(_reactNative.View, rest, children);
-    }
-
-    return /*#__PURE__*/React.createElement(GestureHandlerRootViewContext.Provider, {
-      value: true
-    }, /*#__PURE__*/React.createElement(GestureHandlerRootViewNative, rest, children));
-  });
+  return /*#__PURE__*/React.createElement(GestureHandlerRootViewNative, rest, children);
 }
 //# sourceMappingURL=GestureHandlerRootView.android.js.map