@amazon-devices/react-native-gesture-handler 2.0.1758683737 → 4.0.0

package/apple/RNGestureHandlerButton.mm

@@ -0,0 +1,214 @@
+//
+//  RNGestureHandlerButton.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandlerButton.h"
+
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <React/RCTUIKit.h>
+#endif
+
+#if RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#endif
+
+/**
+ * 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 && !TARGET_OS_OSX
+    [self setExclusiveTouch:YES];
+#endif
+  }
+  return self;
+}
+
+- (BOOL)shouldHandleTouch:(RNGHUIView *)view
+{
+  if ([view isKindOfClass:[RNGestureHandlerButton class]]) {
+    RNGestureHandlerButton *button = (RNGestureHandlerButton *)view;
+    return button.userEnabled;
+  }
+
+  // Certain subviews such as RCTViewComponentView have been observed to have disabled
+  // accessibility gesture recognizers such as _UIAccessibilityHUDGateGestureRecognizer,
+  // ostensibly set by iOS. Such gesture recognizers cause this function to return YES
+  // even when the passed view is static text and does not respond to touches. This in
+  // turn prevents the button from receiving touches, breaking functionality. To handle
+  // such case, we can count only the enabled gesture recognizers when determining
+  // whether a view should receive touches.
+  NSPredicate *isEnabledPredicate = [NSPredicate predicateWithFormat:@"isEnabled == YES"];
+  NSArray *enabledGestureRecognizers = [view.gestureRecognizers filteredArrayUsingPredicate:isEnabledPredicate];
+
+#if !TARGET_OS_OSX
+  return [view isKindOfClass:[UIControl class]] || [enabledGestureRecognizers count] > 0;
+#else
+  return [view isKindOfClass:[NSControl class]] || [enabledGestureRecognizers count] > 0;
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (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);
+}
+
+- (RNGHUIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
+{
+  RNGHUIView *inner = [super hitTest:point withEvent:event];
+  while (inner && ![self shouldHandleTouch:inner]) {
+    inner = inner.superview;
+  }
+  return inner;
+}
+
+- (void)setBorderRadius:(CGFloat)radius
+{
+  if (_borderRadius == radius) {
+    return;
+  }
+
+  _borderRadius = radius;
+  [self.layer setNeedsDisplay];
+}
+
+- (void)displayLayer:(CALayer *)layer
+{
+  if (CGSizeEqualToSize(layer.bounds.size, CGSizeZero)) {
+    return;
+  }
+
+  const CGFloat radius = MAX(0, _borderRadius);
+  const CGSize size = self.bounds.size;
+  const CGFloat scaleFactor = RCTZeroIfNaN(MIN(1, size.width / (2 * radius)));
+  const CGFloat currentBorderRadius = radius * scaleFactor;
+  layer.cornerRadius = currentBorderRadius;
+}
+
+- (NSString *)accessibilityLabel
+{
+  NSString *label = super.accessibilityLabel;
+  if (label) {
+    return label;
+  }
+  return RNGHRecursiveAccessibilityLabel(self);
+}
+
+// Vendored from RCTView.m to infer accessibility label from children
+static NSString *RNGHRecursiveAccessibilityLabel(UIView *view)
+{
+  NSMutableString *str = nil;
+  for (UIView *subview in view.subviews) {
+    NSString *label = subview.accessibilityLabel;
+    if (!label) {
+      label = RNGHRecursiveAccessibilityLabel(subview);
+    }
+    if (label && label.length > 0) {
+      if (str == nil) {
+        str = [NSMutableString string];
+      }
+      if (str.length > 0) {
+        [str appendString:@" "];
+      }
+      [str appendString:label];
+    }
+  }
+
+  return str;
+}
+#endif
+
+#if TARGET_OS_OSX && RCT_NEW_ARCH_ENABLED
+- (void)mountChildComponentView:(RNGHUIView *)childComponentView index:(NSInteger)index
+{
+  if (childComponentView.superview != nil) {
+    return;
+  }
+
+  if (index < [[self subviews] count]) {
+    // Get the view currently at your desired index
+    NSView *existingView = [[self subviews] objectAtIndex:index];
+
+    // Now use this to insert your new view above the existing one
+    [self addSubview:childComponentView positioned:NSWindowAbove relativeTo:existingView];
+  } else {
+    // if the index is out of bounds, add the new subview at the end
+    [self addSubview:childComponentView];
+  }
+}
+
+- (void)unmountChildComponentView:(RNGHUIView *)childComponentView index:(NSInteger)index
+{
+  [childComponentView removeFromSuperview];
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics
+{
+  bool forceUpdate = oldLayoutMetrics == facebook::react::EmptyLayoutMetrics;
+
+  if (forceUpdate || (layoutMetrics.frame != oldLayoutMetrics.frame)) {
+    CGRect frame = RCTCGRectFromRect(layoutMetrics.frame);
+
+    if (!std::isfinite(frame.origin.x) || !std::isfinite(frame.origin.y) || !std::isfinite(frame.size.width) ||
+        !std::isfinite(frame.size.height)) {
+      // CALayer will crash if we pass NaN or Inf values.
+      // It's unclear how to detect this case on cross-platform manner holistically, so we have to do it on the mounting
+      // layer as well. NaN/Inf is a kinda valid result of some math operations. Even if we can (and should) detect (and
+      // report early) incorrect (NaN and Inf) values which come from JavaScript side, we sometimes cannot backtrace the
+      // sources of a calculation that produced an incorrect/useless result.
+      RCTLogWarn(
+          @"-[UIView(ComponentViewProtocol) updateLayoutMetrics:oldLayoutMetrics:]: Received invalid layout metrics (%@) for a view (%@).",
+          NSStringFromCGRect(frame),
+          self);
+    } else {
+      self.frame = frame;
+      self.bounds = CGRect{CGPointZero, frame.size};
+    }
+  }
+
+  if (forceUpdate || (layoutMetrics.displayType != oldLayoutMetrics.displayType)) {
+    self.hidden = layoutMetrics.displayType == facebook::react::DisplayType::None;
+  }
+}
+#endif
+
+@end

package/{ios → apple}/RNGestureHandlerButtonComponentView.h

@@ -1,6 +1,10 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
+#if !TARGET_OS_OSX
 #import <UIKit/UIKit.h>
+#else
+#import <React/RCTUIKit.h>
+#endif
 
 #import <React/RCTViewComponentView.h>
 
@@ -9,7 +13,8 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @interface RNGestureHandlerButtonComponentView : RCTViewComponentView
-
+- (void)setAccessibilityProps:(const facebook::react::Props::Shared &)props
+                     oldProps:(const facebook::react::Props::Shared &)oldProps;
 @end
 
 NS_ASSUME_NONNULL_END

package/apple/RNGestureHandlerButtonComponentView.mm

@@ -0,0 +1,219 @@
+#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;
+}
+
+#if TARGET_OS_OSX
+// Here we want to disable view recycling on buttons. Listeners are not removed from views when they're being unmounted,
+// therefore after navigating through other screens buttons may have different actions then they are supposed to have.
++ (BOOL)shouldBeRecycled
+{
+  return NO;
+}
+#endif
+
+// 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]) {
+    static const auto defaultProps = std::make_shared<const RNGestureHandlerButtonProps>();
+    _props = defaultProps;
+    _buttonView = [[RNGestureHandlerButton alloc] initWithFrame:self.bounds];
+
+    self.contentView = _buttonView;
+  }
+
+  return self;
+}
+
+- (void)mountChildComponentView:(RNGHUIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_buttonView mountChildComponentView:childComponentView index:index];
+}
+
+- (void)unmountChildComponentView:(RNGHUIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+  [_buttonView unmountChildComponentView:childComponentView index:index];
+}
+
+- (LayoutMetrics)buildWrapperMetrics:(const LayoutMetrics &)metrics
+{
+  LayoutMetrics result = metrics;
+  result.borderWidth = EdgeInsets::ZERO;
+  result.contentInsets = EdgeInsets::ZERO;
+  return result;
+}
+
+- (LayoutMetrics)buildButtonMetrics:(const LayoutMetrics &)metrics
+{
+  LayoutMetrics result = metrics;
+  result.frame.origin = {0, 0};
+  return result;
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics
+{
+  // due to nested structure of Button and ComponentView, layout metrics for both
+  // need to be modified:
+  // - wrapper shouldn't have any insets as they should be applied to the button
+  //   so that it can intercept touches on padding and borders, applying them
+  //   twice breaks expected layout
+  // - frame origin needs to be zeroes on metrics of the button as it should fill
+  //   the entirety of the wrapper component
+  const LayoutMetrics wrapperMetrics = [self buildWrapperMetrics:layoutMetrics];
+  const LayoutMetrics oldWrapperMetrics = [self buildWrapperMetrics:oldLayoutMetrics];
+
+  const LayoutMetrics buttonMetrics = [self buildButtonMetrics:layoutMetrics];
+  const LayoutMetrics oldbuttonMetrics = [self buildButtonMetrics:oldLayoutMetrics];
+
+  [super updateLayoutMetrics:wrapperMetrics oldLayoutMetrics:oldWrapperMetrics];
+  [_buttonView updateLayoutMetrics:buttonMetrics oldLayoutMetrics:oldbuttonMetrics];
+}
+
+#pragma mark - RCTComponentViewProtocol
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RNGestureHandlerButtonComponentDescriptor>();
+}
+
+#if TARGET_OS_IOS
+// Taken from
+// https://github.com/facebook/react-native/blob/b226049a4a28ea3f7f32266269fb76340c324d42/packages/react-native/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm#L343
+- (void)setAccessibilityProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &oldButtonProps = *std::static_pointer_cast<const RNGestureHandlerButtonProps>(oldProps);
+  const auto &newButtonProps = *std::static_pointer_cast<const RNGestureHandlerButtonProps>(props);
+
+  if (!oldProps || oldButtonProps.accessible != newButtonProps.accessible) {
+    _buttonView.isAccessibilityElement = newButtonProps.accessible;
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityLabel != newButtonProps.accessibilityLabel) {
+    _buttonView.accessibilityLabel = RCTNSStringFromStringNilIfEmpty(newButtonProps.accessibilityLabel);
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityLanguage != newButtonProps.accessibilityLanguage) {
+    _buttonView.accessibilityLanguage = RCTNSStringFromStringNilIfEmpty(newButtonProps.accessibilityLanguage);
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityHint != newButtonProps.accessibilityHint) {
+    _buttonView.accessibilityHint = RCTNSStringFromStringNilIfEmpty(newButtonProps.accessibilityHint);
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityViewIsModal != newButtonProps.accessibilityViewIsModal) {
+    _buttonView.accessibilityViewIsModal = newButtonProps.accessibilityViewIsModal;
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityElementsHidden != newButtonProps.accessibilityElementsHidden) {
+    _buttonView.accessibilityElementsHidden = newButtonProps.accessibilityElementsHidden;
+  }
+
+  if (!oldProps ||
+      oldButtonProps.accessibilityShowsLargeContentViewer != newButtonProps.accessibilityShowsLargeContentViewer) {
+    if (@available(iOS 13.0, *)) {
+      if (newButtonProps.accessibilityShowsLargeContentViewer) {
+        _buttonView.showsLargeContentViewer = YES;
+        UILargeContentViewerInteraction *interaction = [[UILargeContentViewerInteraction alloc] init];
+        [_buttonView addInteraction:interaction];
+      } else {
+        _buttonView.showsLargeContentViewer = NO;
+      }
+    }
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityLargeContentTitle != newButtonProps.accessibilityLargeContentTitle) {
+    if (@available(iOS 13.0, *)) {
+      _buttonView.largeContentTitle = RCTNSStringFromStringNilIfEmpty(newButtonProps.accessibilityLargeContentTitle);
+    }
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityTraits != newButtonProps.accessibilityTraits) {
+    _buttonView.accessibilityTraits =
+        RCTUIAccessibilityTraitsFromAccessibilityTraits(newButtonProps.accessibilityTraits);
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityState != newButtonProps.accessibilityState) {
+    _buttonView.accessibilityTraits &= ~(UIAccessibilityTraitNotEnabled | UIAccessibilityTraitSelected);
+    const auto accessibilityState = newButtonProps.accessibilityState.value_or(AccessibilityState{});
+    if (accessibilityState.selected) {
+      _buttonView.accessibilityTraits |= UIAccessibilityTraitSelected;
+    }
+    if (accessibilityState.disabled) {
+      _buttonView.accessibilityTraits |= UIAccessibilityTraitNotEnabled;
+    }
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityIgnoresInvertColors != newButtonProps.accessibilityIgnoresInvertColors) {
+    _buttonView.accessibilityIgnoresInvertColors = newButtonProps.accessibilityIgnoresInvertColors;
+  }
+
+  if (!oldProps || oldButtonProps.accessibilityValue != newButtonProps.accessibilityValue) {
+    if (newButtonProps.accessibilityValue.text.has_value()) {
+      _buttonView.accessibilityValue = RCTNSStringFromStringNilIfEmpty(newButtonProps.accessibilityValue.text.value());
+    } else if (
+        newButtonProps.accessibilityValue.now.has_value() && newButtonProps.accessibilityValue.min.has_value() &&
+        newButtonProps.accessibilityValue.max.has_value()) {
+      CGFloat val = (CGFloat)(newButtonProps.accessibilityValue.now.value()) /
+          (newButtonProps.accessibilityValue.max.value() - newButtonProps.accessibilityValue.min.value());
+      _buttonView.accessibilityValue = [NSNumberFormatter localizedStringFromNumber:@(val)
+                                                                        numberStyle:NSNumberFormatterPercentStyle];
+      ;
+    } else {
+      _buttonView.accessibilityValue = nil;
+    }
+  }
+
+  if (!oldProps || oldButtonProps.testId != newButtonProps.testId) {
+    UIView *accessibilityView = (UIView *)_buttonView;
+    accessibilityView.accessibilityIdentifier = RCTNSStringFromString(newButtonProps.testId);
+  }
+}
+#endif
+
+- (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 && !TARGET_OS_OSX
+  _buttonView.exclusiveTouch = newProps.exclusive;
+  [self setAccessibilityProps:props oldProps:oldProps];
+#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.m → apple/RNGestureHandlerButtonManager.mm}

@@ -9,12 +9,14 @@ RCT_CUSTOM_VIEW_PROPERTY(enabled, BOOL, RNGestureHandlerButton)
 {
   view.userEnabled = json == nil ? YES : [RCTConvert BOOL:json];
 }
-#if !TARGET_OS_TV
+
+#if !TARGET_OS_TV && !TARGET_OS_OSX
 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) {
@@ -26,9 +28,9 @@ RCT_CUSTOM_VIEW_PROPERTY(hitSlop, UIEdgeInsets, RNGestureHandlerButton)
   }
 }
 
-- (UIView *)view
+- (RNGHUIView *)view
 {
-  return [RNGestureHandlerButton new];
+  return (RNGHUIView *)[RNGestureHandlerButton new];
 }
 
 @end

package/apple/RNGestureHandlerDirection.h

@@ -0,0 +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/{ios → apple}/RNGestureHandlerEvents.h

@@ -1,9 +1,10 @@
 #import <React/RCTEventDispatcher.h>
 
 #import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
 
+#import "RNGHStylusData.h"
 #import "RNGHTouchEventType.h"
+#import "RNGHUIKit.h"
 #import "RNGestureHandlerState.h"
 
 @interface RNGestureHandlerEventExtraData : NSObject
@@ -12,36 +13,46 @@
 
 - (instancetype)initWithData:(NSDictionary *)data;
 
-+ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position withAbsolutePosition:(CGPoint)absolutePosition;
 + (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
                            withAbsolutePosition:(CGPoint)absolutePosition
-                            withNumberOfTouches:(NSUInteger)numberOfTouches;
+                                withPointerType:(NSInteger)pointerType;
 + (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
                            withAbsolutePosition:(CGPoint)absolutePosition
                             withNumberOfTouches:(NSUInteger)numberOfTouches
-                                   withDuration:(NSUInteger)duration;
+                                withPointerType:(NSInteger)pointerType;
++ (RNGestureHandlerEventExtraData *)forPosition:(CGPoint)position
+                           withAbsolutePosition:(CGPoint)absolutePosition
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+                                   withDuration:(NSUInteger)duration
+                                withPointerType:(NSInteger)pointerType;
 + (RNGestureHandlerEventExtraData *)forPan:(CGPoint)position
                       withAbsolutePosition:(CGPoint)absolutePosition
                            withTranslation:(CGPoint)translation
                               withVelocity:(CGPoint)velocity
-                       withNumberOfTouches:(NSUInteger)numberOfTouches;
+                       withNumberOfTouches:(NSUInteger)numberOfTouches
+                           withPointerType:(NSInteger)pointerType
+                            withStylusData:(NSDictionary *)stylusData;
 + (RNGestureHandlerEventExtraData *)forForce:(CGFloat)force
                                  forPosition:(CGPoint)position
                         withAbsolutePosition:(CGPoint)absolutePosition
-                         withNumberOfTouches:(NSUInteger)numberOfTouches;
+                         withNumberOfTouches:(NSUInteger)numberOfTouches
+                             withPointerType:(NSInteger)pointerType;
 + (RNGestureHandlerEventExtraData *)forPinch:(CGFloat)scale
                               withFocalPoint:(CGPoint)focalPoint
                                 withVelocity:(CGFloat)velocity
-                         withNumberOfTouches:(NSUInteger)numberOfTouches;
+                         withNumberOfTouches:(NSUInteger)numberOfTouches
+                             withPointerType:(NSInteger)pointerType;
 + (RNGestureHandlerEventExtraData *)forRotation:(CGFloat)rotation
                                 withAnchorPoint:(CGPoint)anchorPoint
                                    withVelocity:(CGFloat)velocity
-                            withNumberOfTouches:(NSUInteger)numberOfTouches;
+                            withNumberOfTouches:(NSUInteger)numberOfTouches
+                                withPointerType:(NSInteger)pointerType;
 + (RNGestureHandlerEventExtraData *)forEventType:(RNGHTouchEventType)eventType
                              withChangedPointers:(NSArray<NSDictionary *> *)changedPointers
                                  withAllPointers:(NSArray<NSDictionary *> *)allPointers
-                             withNumberOfTouches:(NSUInteger)numberOfTouches;
-+ (RNGestureHandlerEventExtraData *)forPointerInside:(BOOL)pointerInside;
+                             withNumberOfTouches:(NSUInteger)numberOfTouches
+                                 withPointerType:(NSInteger)pointerType;
++ (RNGestureHandlerEventExtraData *)forPointerInside:(BOOL)pointerInside withPointerType:(NSInteger)pointerType;
 @end
 
 @interface RNGestureHandlerEvent : NSObject <RCTEvent>