@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/ios/RNGestureHandler.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

package/ios/RNGestureHandlerActionType.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNGestureHandlerActionType) {
+  RNGestureHandlerActionTypeReanimatedWorklet = 1, // Reanimated worklet
+  RNGestureHandlerActionTypeNativeAnimatedEvent, // Animated.event with useNativeDriver: true
+  RNGestureHandlerActionTypeJSFunctionOldAPI, // JS function or Animated.event with useNativeDriver: false using old
+                                              // RNGH API
+  RNGestureHandlerActionTypeJSFunctionNewAPI, // JS function or Animated.event with useNativeDriver: false using new
+                                              // RNGH API
+};

package/ios/RNGestureHandlerButton.h

@@ -0,0 +1,19 @@
+//
+//  RNGestureHandlerButton.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNGestureHandlerButton : UIControl
+
+/**
+ *  Insets used when hit testing inside this view.
+ */
+@property (nonatomic, assign) UIEdgeInsets hitTestEdgeInsets;
+@property (nonatomic) BOOL userEnabled;
+
+@end

package/ios/RNGestureHandlerButton.m

@@ -0,0 +1,77 @@
+//
+//  RNGestureHandlerButton.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandlerButton.h"
+
+#import <UIKit/UIKit.h>
+
+/**
+ * Gesture Handler Button components overrides standard mechanism used by RN
+ * to determine touch target, which normally would reurn the UIView that is placed
+ * as the deepest element in the view hierarchy.
+ * It's done this way as it allows for the actual target determination to run in JS
+ * where we can travers up the view ierarchy to find first element that want to became
+ * JS responder.
+ *
+ * Since we want to use native button (or actually a `UIControl`) we need to determine
+ * the target in native. This makes it impossible for JS responder based components to
+ * function as a subviews of the button component. Here we override `hitTest:withEvent:`
+ * method and we only determine the target to be either a subclass of `UIControl` or a
+ * view that has gesture recognizers registered.
+ *
+ * This "default" behaviour of target determinator should be sufficient in most of the
+ * cases as in fact it is not that common UI pattern to have many nested buttons (usually
+ * there are just two levels e.g. when you have clickable table cells with additional
+ * buttons). In cases when the default behaviour is insufficient it is recommended to use
+ * `TapGestureHandler` instead of a button which gives much better flexibility as far as
+ * controlling the touch flow.
+ */
+@implementation RNGestureHandlerButton
+
+- (instancetype)init
+{
+  self = [super init];
+  if (self) {
+    _hitTestEdgeInsets = UIEdgeInsetsZero;
+    _userEnabled = YES;
+#if !TARGET_OS_TV
+    [self setExclusiveTouch:YES];
+#endif
+  }
+  return self;
+}
+
+- (BOOL)shouldHandleTouch:(UIView *)view
+{
+  if ([view isKindOfClass:[RNGestureHandlerButton class]]) {
+    RNGestureHandlerButton *button = (RNGestureHandlerButton *)view;
+    return button.userEnabled;
+  }
+
+  return [view isKindOfClass:[UIControl class]] || [view.gestureRecognizers count] > 0;
+}
+
+- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
+{
+  if (UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero)) {
+    return [super pointInside:point withEvent:event];
+  }
+  CGRect hitFrame = UIEdgeInsetsInsetRect(self.bounds, self.hitTestEdgeInsets);
+  return CGRectContainsPoint(hitFrame, point);
+}
+
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  UIView *inner = [super hitTest:point withEvent:event];
+  while (inner && ![self shouldHandleTouch:inner]) {
+    inner = inner.superview;
+  }
+  return inner;
+}
+
+@end

package/ios/RNGestureHandlerButtonComponentView.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTViewComponentView.h>
+
+#import "RNGestureHandlerButton.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNGestureHandlerButtonComponentView : RCTViewComponentView
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNGestureHandlerButtonComponentView.mm

@@ -0,0 +1,64 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "RNGestureHandlerButtonComponentView.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rngesturehandler_codegen/ComponentDescriptors.h>
+#import <react/renderer/components/rngesturehandler_codegen/EventEmitters.h>
+#import <react/renderer/components/rngesturehandler_codegen/Props.h>
+#import <react/renderer/components/rngesturehandler_codegen/RCTComponentViewHelpers.h>
+
+#import "RNGestureHandlerButton.h"
+
+using namespace facebook::react;
+
+@interface RNGestureHandlerButtonComponentView () <RCTRNGestureHandlerButtonViewProtocol>
+@end
+
+@implementation RNGestureHandlerButtonComponentView {
+  RNGestureHandlerButton *_buttonView;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const RNGestureHandlerButtonProps>();
+    _props = defaultProps;
+    _buttonView = [[RNGestureHandlerButton alloc] initWithFrame:self.bounds];
+
+    self.contentView = _buttonView;
+  }
+
+  return self;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNGestureHandlerButtonComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<const RNGestureHandlerButtonProps>(props);
+
+  _buttonView.userEnabled = newProps.enabled;
+#if !TARGET_OS_TV
+  _buttonView.exclusiveTouch = newProps.exclusive;
+#endif
+  _buttonView.hitTestEdgeInsets = UIEdgeInsetsMake(
+      -newProps.hitSlop.top, -newProps.hitSlop.left, -newProps.hitSlop.bottom, -newProps.hitSlop.right);
+
+  [super updateProps:props oldProps:oldProps];
+}
+@end
+
+Class<RCTComponentViewProtocol> RNGestureHandlerButtonCls(void)
+{
+  return RNGestureHandlerButtonComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNGestureHandlerButtonManager.h

@@ -0,0 +1,5 @@
+#import <React/RCTViewManager.h>
+
+@interface RNGestureHandlerButtonManager : RCTViewManager
+
+@end

package/ios/RNGestureHandlerButtonManager.m

@@ -0,0 +1,34 @@
+#import "RNGestureHandlerButtonManager.h"
+#import "RNGestureHandlerButton.h"
+
+@implementation RNGestureHandlerButtonManager
+
+RCT_EXPORT_MODULE(RNGestureHandlerButton)
+
+RCT_CUSTOM_VIEW_PROPERTY(enabled, BOOL, RNGestureHandlerButton)
+{
+  view.userEnabled = json == nil ? YES : [RCTConvert BOOL:json];
+}
+#if !TARGET_OS_TV
+RCT_CUSTOM_VIEW_PROPERTY(exclusive, BOOL, RNGestureHandlerButton)
+{
+  [view setExclusiveTouch:json == nil ? YES : [RCTConvert BOOL:json]];
+}
+#endif
+RCT_CUSTOM_VIEW_PROPERTY(hitSlop, UIEdgeInsets, RNGestureHandlerButton)
+{
+  if (json) {
+    UIEdgeInsets hitSlopInsets = [RCTConvert UIEdgeInsets:json];
+    view.hitTestEdgeInsets =
+        UIEdgeInsetsMake(-hitSlopInsets.top, -hitSlopInsets.left, -hitSlopInsets.bottom, -hitSlopInsets.right);
+  } else {
+    view.hitTestEdgeInsets = defaultView.hitTestEdgeInsets;
+  }
+}
+
+- (UIView *)view
+{
+  return [RNGestureHandlerButton new];
+}
+
+@end

package/ios/RNGestureHandlerDirection.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNGestureHandlerDirection) {
+  RNGestureHandlerDirectionRight = 1,
+  RNGestureHandlerDirectionLeft = 2,
+  RNGestureHandlerDirectionUp = 4,
+  RNGestureHandlerDirectionDown = 8,
+};

package/ios/RNGestureHandlerEvents.h

@@ -0,0 +1,65 @@
+#import <React/RCTEventDispatcher.h>
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#import "RNGHTouchEventType.h"
+#import "RNGestureHandlerState.h"
+
+@interface RNGestureHandlerEventExtraData : NSObject
+
+@property (readonly) NSDictionary *data;
+
+- (instancetype)initWithData:(NSDictionary *)data;
+
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position withAbsolutePosition:(CGPoint)absolutePosition;
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
+                           withAbsolutePosition:(CGPoint)absolutePosition
+                            withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
+                           withAbsolutePosition:(CGPoint)absolutePosition
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+                                   withDuration:(NSUInteger)duration;
++ (RNGestureHandlerEventExtraData *)forPan:(CGPoint)position
+                      withAbsolutePosition:(CGPoint)absolutePosition
+                           withTranslation:(CGPoint)translation
+                              withVelocity:(CGPoint)velocity
+                       withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forForce:(CGFloat)force
+                                 forPosition:(CGPoint)position
+                        withAbsolutePosition:(CGPoint)absolutePosition
+                         withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forPinch:(CGFloat)scale
+                              withFocalPoint:(CGPoint)focalPoint
+                                withVelocity:(CGFloat)velocity
+                         withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forRotation:(CGFloat)rotation
+                                withAnchorPoint:(CGPoint)anchorPoint
+                                   withVelocity:(CGFloat)velocity
+                            withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forEventType:(RNGHTouchEventType)eventType
+                             withChangedPointers:(NSArray<NSDictionary *> *)changedPointers
+                                 withAllPointers:(NSArray<NSDictionary *> *)allPointers
+                             withNumberOfTouches:(NSUInteger)numberOfTouches;
++ (RNGestureHandlerEventExtraData *)forPointerInside:(BOOL)pointerInside;
+@end
+
+@interface RNGestureHandlerEvent : NSObject <RCTEvent>
+
+- (instancetype)initWithReactTag:(NSNumber *)reactTag
+                      handlerTag:(NSNumber *)handlerTag
+                           state:(RNGestureHandlerState)state
+                       extraData:(RNGestureHandlerEventExtraData *)extraData
+                   coalescingKey:(uint16_t)coalescingKey NS_DESIGNATED_INITIALIZER;
+
+@end
+
+@interface RNGestureHandlerStateChange : NSObject <RCTEvent>
+
+- (instancetype)initWithReactTag:(NSNumber *)reactTag
+                      handlerTag:(NSNumber *)handlerTag
+                           state:(RNGestureHandlerState)state
+                       prevState:(RNGestureHandlerState)prevState
+                       extraData:(RNGestureHandlerEventExtraData *)extraData NS_DESIGNATED_INITIALIZER;
+
+@end

package/ios/RNGestureHandlerEvents.m

@@ -0,0 +1,260 @@
+#import "RNGestureHandlerEvents.h"
+
+#define SAFE_VELOCITY(velocity) @(isnan(velocity) ? 0 : velocity)
+
+@implementation RNGestureHandlerEventExtraData
+
+- (instancetype)initWithData:(NSDictionary *)data;
+{
+  if ((self = [super init])) {
+    _data = data;
+  }
+  return self;
+}
+
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position withAbsolutePosition:(CGPoint)absolutePosition
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"x" : @(position.x),
+    @"y" : @(position.y),
+    @"absoluteX" : @(absolutePosition.x),
+    @"absoluteY" : @(absolutePosition.y)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
+                           withAbsolutePosition:(CGPoint)absolutePosition
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"x" : @(position.x),
+    @"y" : @(position.y),
+    @"absoluteX" : @(absolutePosition.x),
+    @"absoluteY" : @(absolutePosition.y),
+    @"numberOfPointers" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
+                           withAbsolutePosition:(CGPoint)absolutePosition
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+                                   withDuration:(NSUInteger)duration
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"x" : @(position.x),
+    @"y" : @(position.y),
+    @"absoluteX" : @(absolutePosition.x),
+    @"absoluteY" : @(absolutePosition.y),
+    @"numberOfPointers" : @(numberOfTouches),
+    @"duration" : @(duration)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forPan:(CGPoint)position
+                      withAbsolutePosition:(CGPoint)absolutePosition
+                           withTranslation:(CGPoint)translation
+                              withVelocity:(CGPoint)velocity
+                       withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"x" : @(position.x),
+    @"y" : @(position.y),
+    @"absoluteX" : @(absolutePosition.x),
+    @"absoluteY" : @(absolutePosition.y),
+    @"translationX" : @(translation.x),
+    @"translationY" : @(translation.y),
+    @"velocityX" : SAFE_VELOCITY(velocity.x),
+    @"velocityY" : SAFE_VELOCITY(velocity.y),
+    @"numberOfPointers" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forForce:(CGFloat)force
+                                 forPosition:(CGPoint)position
+                        withAbsolutePosition:(CGPoint)absolutePosition
+                         withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"x" : @(position.x),
+    @"y" : @(position.y),
+    @"absoluteX" : @(absolutePosition.x),
+    @"absoluteY" : @(absolutePosition.y),
+    @"force" : @(force),
+    @"numberOfPointers" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forPinch:(CGFloat)scale
+                              withFocalPoint:(CGPoint)focalPoint
+                                withVelocity:(CGFloat)velocity
+                         withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"scale" : @(scale),
+    @"focalX" : @(focalPoint.x),
+    @"focalY" : @(focalPoint.y),
+    @"velocity" : SAFE_VELOCITY(velocity),
+    @"numberOfPointers" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forRotation:(CGFloat)rotation
+                                withAnchorPoint:(CGPoint)anchorPoint
+                                   withVelocity:(CGFloat)velocity
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"rotation" : @(rotation),
+    @"anchorX" : @(anchorPoint.x),
+    @"anchorY" : @(anchorPoint.y),
+    @"velocity" : SAFE_VELOCITY(velocity),
+    @"numberOfPointers" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forEventType:(RNGHTouchEventType)eventType
+                             withChangedPointers:(NSArray<NSDictionary *> *)changedPointers
+                                 withAllPointers:(NSArray<NSDictionary *> *)allPointers
+                             withNumberOfTouches:(NSUInteger)numberOfTouches
+{
+  if (changedPointers == nil || allPointers == nil) {
+    changedPointers = @[];
+    allPointers = @[];
+    eventType = RNGHTouchEventTypeUndetermined;
+  }
+
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{
+    @"eventType" : @(eventType),
+    @"changedTouches" : changedPointers,
+    @"allTouches" : allPointers,
+    @"numberOfTouches" : @(numberOfTouches)
+  }];
+}
+
++ (RNGestureHandlerEventExtraData *)forPointerInside:(BOOL)pointerInside
+{
+  return [[RNGestureHandlerEventExtraData alloc] initWithData:@{@"pointerInside" : @(pointerInside)}];
+}
+
+@end
+
+@implementation RNGestureHandlerEvent {
+  NSNumber *_handlerTag;
+  RNGestureHandlerState _state;
+  RNGestureHandlerEventExtraData *_extraData;
+}
+
+@synthesize viewTag = _viewTag;
+@synthesize coalescingKey = _coalescingKey;
+
+- (instancetype)initWithReactTag:(NSNumber *)reactTag
+                      handlerTag:(NSNumber *)handlerTag
+                           state:(RNGestureHandlerState)state
+                       extraData:(RNGestureHandlerEventExtraData *)extraData
+                   coalescingKey:(uint16_t)coalescingKey
+{
+  if ((self = [super init])) {
+    _viewTag = reactTag;
+    _handlerTag = handlerTag;
+    _state = state;
+    _extraData = extraData;
+    _coalescingKey = coalescingKey;
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (NSString *)eventName
+{
+  return @"onGestureHandlerEvent";
+}
+
+- (BOOL)canCoalesce
+{
+  return YES;
+}
+
+- (id<RCTEvent>)coalesceWithEvent:(id<RCTEvent>)newEvent;
+{
+  return newEvent;
+}
+
++ (NSString *)moduleDotMethod
+{
+  return @"RCTEventEmitter.receiveEvent";
+}
+
+- (NSArray *)arguments
+{
+  NSMutableDictionary *body = [NSMutableDictionary dictionaryWithDictionary:_extraData.data];
+  [body setObject:_viewTag forKey:@"target"];
+  [body setObject:_handlerTag forKey:@"handlerTag"];
+  [body setObject:@(_state) forKey:@"state"];
+  return @[ self.viewTag, @"onGestureHandlerEvent", body ];
+}
+
+@end
+
+@implementation RNGestureHandlerStateChange {
+  NSNumber *_handlerTag;
+  RNGestureHandlerState _state;
+  RNGestureHandlerState _prevState;
+  RNGestureHandlerEventExtraData *_extraData;
+}
+
+@synthesize viewTag = _viewTag;
+@synthesize coalescingKey = _coalescingKey;
+
+- (instancetype)initWithReactTag:(NSNumber *)reactTag
+                      handlerTag:(NSNumber *)handlerTag
+                           state:(RNGestureHandlerState)state
+                       prevState:(RNGestureHandlerState)prevState
+                       extraData:(RNGestureHandlerEventExtraData *)extraData
+{
+  static uint16_t coalescingKey = 0;
+  if ((self = [super init])) {
+    _viewTag = reactTag;
+    _handlerTag = handlerTag;
+    _state = state;
+    _prevState = prevState;
+    _extraData = extraData;
+    _coalescingKey = coalescingKey++;
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (NSString *)eventName
+{
+  return @"onGestureHandlerStateChange";
+}
+
+- (BOOL)canCoalesce
+{
+  // TODO: event coalescing
+  return NO;
+}
+
+- (id<RCTEvent>)coalesceWithEvent:(id<RCTEvent>)newEvent;
+{
+  return newEvent;
+}
+
++ (NSString *)moduleDotMethod
+{
+  return @"RCTEventEmitter.receiveEvent";
+}
+
+- (NSArray *)arguments
+{
+  NSMutableDictionary *body = [NSMutableDictionary dictionaryWithDictionary:_extraData.data];
+  [body setObject:_viewTag forKey:@"target"];
+  [body setObject:_handlerTag forKey:@"handlerTag"];
+  [body setObject:@(_state) forKey:@"state"];
+  [body setObject:@(_prevState) forKey:@"oldState"];
+  return @[ self.viewTag, @"onGestureHandlerStateChange", body ];
+}
+
+@end

package/ios/RNGestureHandlerManager.h

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+
+#import "RNGestureHandler.h"
+
+@class RCTUIManager;
+@class RCTEventDispatcher;
+
+@interface RNGestureHandlerManager : NSObject
+
+- (nonnull instancetype)initWithUIManager:(nonnull RCTUIManager *)uiManager
+                          eventDispatcher:(nonnull RCTEventDispatcher *)eventDispatcher;
+
+- (void)createGestureHandler:(nonnull NSString *)handlerName
+                         tag:(nonnull NSNumber *)handlerTag
+                      config:(nonnull NSDictionary *)config;
+
+- (void)attachGestureHandler:(nonnull NSNumber *)handlerTag
+               toViewWithTag:(nonnull NSNumber *)viewTag
+              withActionType:(RNGestureHandlerActionType)actionType;
+
+- (void)updateGestureHandler:(nonnull NSNumber *)handlerTag config:(nonnull NSDictionary *)config;
+
+- (void)dropGestureHandler:(nonnull NSNumber *)handlerTag;
+
+- (void)dropAllGestureHandlers;
+
+- (void)handleSetJSResponder:(nonnull NSNumber *)viewTag blockNativeResponder:(nonnull NSNumber *)blockNativeResponder;
+
+- (void)handleClearJSResponder;
+
+- (nullable RNGestureHandler *)handlerWithTag:(nonnull NSNumber *)handlerTag;
+
+@end