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

package/{ios → apple}/Handlers/RNForceTouchHandler.m

@@ -1,5 +1,6 @@
 #import "RNForceTouchHandler.h"
 
+#if !TARGET_OS_OSX
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
 #import <React/RCTConvert.h>
@@ -17,7 +18,7 @@
 
 @implementation RNForceTouchGestureRecognizer {
   __weak RNGestureHandler *_gestureHandler;
-  UITouch *_firstTouch;
+  RNGHUITouch *_firstTouch;
 }
 
 static const CGFloat defaultForce = 0;
@@ -37,8 +38,9 @@ static const BOOL defaultFeedbackOnActivation = NO;
   return self;
 }
 
-- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)touchesBegan:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
+  [_gestureHandler setCurrentPointerType:event];
   if (_firstTouch) {
     // ignore rest of fingers
     return;
@@ -51,7 +53,7 @@ static const BOOL defaultFeedbackOnActivation = NO;
   self.state = UIGestureRecognizerStatePossible;
 }
 
-- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   if (![touches containsObject:_firstTouch]) {
     // Considered only the very first touch
@@ -85,7 +87,7 @@ static const BOOL defaultFeedbackOnActivation = NO;
 
 - (void)performFeedbackIfRequired
 {
-#if !TARGET_OS_TV
+#if !TARGET_OS_TV && !TARGET_OS_VISION
   if (_feedbackOnActivation) {
     if (@available(iOS 10.0, *)) {
       [[[UIImpactFeedbackGenerator alloc] initWithStyle:(UIImpactFeedbackStyleMedium)] impactOccurred];
@@ -94,7 +96,7 @@ static const BOOL defaultFeedbackOnActivation = NO;
 #endif
 }
 
-- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   if (![touches containsObject:_firstTouch]) {
     // Considered only the very first touch
@@ -109,13 +111,13 @@ static const BOOL defaultFeedbackOnActivation = NO;
   }
 }
 
-- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   [super touchesCancelled:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
 }
 
-- (void)handleForceWithTouches:(NSSet<UITouch *> *)touches
+- (void)handleForceWithTouches:(NSSet<RNGHUITouch *> *)touches
 {
   _force = _firstTouch.force / _firstTouch.maximumPossibleForce;
 }
@@ -124,6 +126,7 @@ static const BOOL defaultFeedbackOnActivation = NO;
 {
   [_gestureHandler.pointerTracker reset];
   [super reset];
+  [_gestureHandler reset];
   _force = 0;
   _firstTouch = NULL;
 }
@@ -169,7 +172,25 @@ static const BOOL defaultFeedbackOnActivation = NO;
   return [RNGestureHandlerEventExtraData forForce:recognizer.force
                                       forPosition:[recognizer locationInView:recognizer.view]
                              withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
-                              withNumberOfTouches:recognizer.numberOfTouches];
+                              withNumberOfTouches:recognizer.numberOfTouches
+                                  withPointerType:_pointerType];
 }
 
 @end
+
+#else
+
+@implementation RNForceTouchHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  RCTLogWarn(@"ForceTouchHandler is not supported on macOS");
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [NSGestureRecognizer alloc];
+  }
+  return self;
+}
+
+@end
+
+#endif

package/{ios → apple}/Handlers/RNHoverHandler.m

@@ -6,18 +6,24 @@
 //
 
 #import "RNHoverHandler.h"
+#import <React/UIView+React.h>
+
+#if !TARGET_OS_OSX
 
 #import <React/RCTConvert.h>
 #import <UIKit/UIGestureRecognizerSubclass.h>
 
+#define CHECK_TARGET(__VERSION__)                                                \
+  defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_##__VERSION__) && \
+      __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_##__VERSION__ && !TARGET_OS_TV
+
 typedef NS_ENUM(NSInteger, RNGestureHandlerHoverEffect) {
   RNGestureHandlerHoverEffectNone = 0,
   RNGestureHandlerHoverEffectLift,
   RNGestureHandlerHoverEffectHightlight,
 };
 
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
 
 API_AVAILABLE(ios(13.4))
 @interface RNBetterHoverGestureRecognizer : UIHoverGestureRecognizer <UIPointerInteractionDelegate>
@@ -51,6 +57,12 @@ API_AVAILABLE(ios(13.4))
   self.enabled = NO;
 }
 
+- (void)reset
+{
+  [super reset];
+  [_gestureHandler reset];
+}
+
 - (UIPointerStyle *)pointerInteraction:(UIPointerInteraction *)interaction styleForRegion:(UIPointerRegion *)region
 {
   if (interaction.view != nil && _hoverEffect != RNGestureHandlerHoverEffectNone) {
@@ -74,17 +86,19 @@ API_AVAILABLE(ios(13.4))
 #endif
 
 @implementation RNHoverGestureHandler {
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
   UIPointerInteraction *_pointerInteraction;
 #endif
 }
 
 - (instancetype)initWithTag:(NSNumber *)tag
 {
+#if TARGET_OS_TV
+  RCTLogWarn(@"HoverGestureHandler is not supported on tvOS");
+#endif
+
   if ((self = [super initWithTag:tag])) {
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
     if (@available(iOS 13.4, *)) {
       _recognizer = [[RNBetterHoverGestureRecognizer alloc] initWithGestureHandler:self];
       _pointerInteraction =
@@ -97,8 +111,7 @@ API_AVAILABLE(ios(13.4))
 
 - (void)bindToView:(UIView *)view
 {
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
   if (@available(iOS 13.4, *)) {
     [super bindToView:view];
     [view addInteraction:_pointerInteraction];
@@ -108,8 +121,7 @@ API_AVAILABLE(ios(13.4))
 
 - (void)unbindFromView
 {
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
   if (@available(iOS 13.4, *)) {
     [super unbindFromView];
     [self.recognizer.view removeInteraction:_pointerInteraction];
@@ -121,8 +133,7 @@ API_AVAILABLE(ios(13.4))
 {
   [super resetConfig];
 
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
   if (@available(iOS 13.4, *)) {
     RNBetterHoverGestureRecognizer *recognizer = (RNBetterHoverGestureRecognizer *)_recognizer;
     recognizer.hoverEffect = RNGestureHandlerHoverEffectNone;
@@ -134,8 +145,7 @@ API_AVAILABLE(ios(13.4))
 {
   [super configure:config];
 
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && defined(__IPHONE_13_4) && \
-    __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_13_4
+#if CHECK_TARGET(13_4)
   if (@available(iOS 13.4, *)) {
     RNBetterHoverGestureRecognizer *recognizer = (RNBetterHoverGestureRecognizer *)_recognizer;
     APPLY_INT_PROP(hoverEffect);
@@ -146,7 +156,66 @@ API_AVAILABLE(ios(13.4))
 - (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
 {
   return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
-                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window]];
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+                                     withPointerType:UITouchTypePencil];
 }
 
 @end
+
+#else
+
+@implementation RNHoverGestureHandler {
+  NSTrackingArea *trackingArea;
+  RNGHUIView *_view;
+}
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [NSGestureRecognizer alloc];
+  }
+
+  return self;
+}
+
+- (void)bindToView:(RNGHUIView *)view
+{
+  _view = view;
+
+  NSTrackingAreaOptions options =
+      NSTrackingMouseEnteredAndExited | NSTrackingActiveInActiveApp | NSTrackingInVisibleRect;
+
+  trackingArea = [[NSTrackingArea alloc] initWithRect:_view.bounds options:options owner:self userInfo:nil];
+  [_view addTrackingArea:trackingArea];
+}
+
+- (void)unbindFromView
+{
+  [_view removeTrackingArea:trackingArea];
+  _view = nil;
+}
+
+- (void)mouseEntered:(NSEvent *)event
+{
+  [self sendEventsInState:RNGestureHandlerStateBegan
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+  [self sendEventsInState:RNGestureHandlerStateActive
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+}
+
+- (void)mouseExited:(NSEvent *)theEvent
+{
+  [self sendEventsInState:RNGestureHandlerStateEnd
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+
+  [self sendEventsInState:RNGestureHandlerStateUndetermined
+           forViewWithTag:_view.reactTag
+            withExtraData:[RNGestureHandlerEventExtraData forPointerInside:YES withPointerType:_pointerType]];
+}
+
+@end
+
+#endif

package/apple/Handlers/RNLongPressHandler.m

@@ -0,0 +1,290 @@
+//
+//  RNLongPressHandler.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNLongPressHandler.h"
+#import <React/RCTConvert.h>
+
+#if !TARGET_OS_OSX
+
+#import <UIKit/UIGestureRecognizerSubclass.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;
+- (NSUInteger)getDuration;
+
+#if !TARGET_OS_OSX
+- (void)handleGesture:(UIGestureRecognizer *)recognizer;
+#else
+- (void)handleGesture:(NSGestureRecognizer *)recognizer;
+#endif
+
+@end
+
+@implementation RNBetterLongPressGestureRecognizer {
+  __weak RNGestureHandler *_gestureHandler;
+  CGPoint _initPosition;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+  return self;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+  previousTime = CACurrentMediaTime();
+  [_gestureHandler handleGesture:recognizer];
+}
+
+- (void)triggerAction
+{
+  [self handleGesture:self];
+}
+
+- (CGPoint)translationInView
+{
+  CGPoint currentPosition = [self locationInView:self.view];
+  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];
+  [self triggerAction];
+}
+
+- (void)touchesMoved:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+
+  if ([self shouldCancelGesture]) {
+    self.state = UIGestureRecognizerStateFailed;
+    self.enabled = NO;
+    self.enabled = YES;
+
+    [self triggerAction];
+  }
+}
+
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+
+  [self triggerAction];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+
+  [self triggerAction];
+}
+
+#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
+{
+  [_gestureHandler.pointerTracker reset];
+
+  [super reset];
+  [_gestureHandler reset];
+}
+
+- (NSUInteger)getDuration
+{
+  return (previousTime - startTime) * 1000;
+}
+
+@end
+
+@implementation RNLongPressGestureHandler
+
+- (instancetype)initWithTag:(NSNumber *)tag
+{
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNBetterLongPressGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+
+- (void)resetConfig
+{
+  [super resetConfig];
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
+
+  recognizer.minimumPressDuration = 0.5;
+  recognizer.allowableMovement = 10;
+}
+
+- (void)configure:(NSDictionary *)config
+{
+  [super configure:config];
+  RNBetterLongPressGestureRecognizer *recognizer = (RNBetterLongPressGestureRecognizer *)_recognizer;
+
+  id prop = config[@"minDurationMs"];
+  if (prop != nil) {
+    recognizer.minimumPressDuration = [RCTConvert CGFloat:prop] / 1000.0;
+  }
+
+  prop = config[@"maxDist"];
+  if (prop != nil) {
+    recognizer.allowableMovement = [RCTConvert CGFloat:prop];
+  }
+
+#if !TARGET_OS_TV
+  prop = config[@"numberOfPointers"];
+  if (prop != nil) {
+    recognizer.numberOfTouchesRequired = [RCTConvert CGFloat:prop];
+  }
+#endif
+}
+
+#if !TARGET_OS_OSX
+
+- (RNGestureHandlerState)state
+{
+  // For long press recognizer we treat "Began" state as "active"
+  // as it changes its state to "Began" as soon as the the minimum
+  // hold duration timeout is reached, whereas state "Changed" is
+  // only set after "Began" phase if there is some movement.
+  if (_recognizer.state == UIGestureRecognizerStateBegan) {
+    return RNGestureHandlerStateActive;
+  }
+  return [super state];
+}
+
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+  // same as TapGH, this needs to be unified when all handlers are updated
+  RNGestureHandlerState savedState = _lastState;
+  BOOL shouldBegin = [super gestureRecognizerShouldBegin:gestureRecognizer];
+  _lastState = savedState;
+
+  return shouldBegin;
+}
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(UIGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window]
+                                 withNumberOfTouches:recognizer.numberOfTouches
+                                        withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
+                                     withPointerType:_pointerType];
+}
+
+#else
+
+- (RNGestureHandlerEventExtraData *)eventExtraData:(NSGestureRecognizer *)recognizer
+{
+  return [RNGestureHandlerEventExtraData forPosition:[recognizer locationInView:recognizer.view]
+                                withAbsolutePosition:[recognizer locationInView:recognizer.view.window.contentView]
+                                 withNumberOfTouches:1
+                                        withDuration:[(RNBetterLongPressGestureRecognizer *)recognizer getDuration]
+                                     withPointerType:RNGestureHandlerMouse];
+}
+
+#endif
+@end

package/{ios → apple}/Handlers/RNManualHandler.m

@@ -1,7 +1,10 @@
 #import "RNManualHandler.h"
 
+#if !TARGET_OS_OSX
 @interface RNManualRecognizer : UIGestureRecognizer
-
+#else
+@interface RNManualRecognizer : NSGestureRecognizer
+#endif
 - (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
 
 @end
@@ -17,24 +20,27 @@
     _gestureHandler = gestureHandler;
     _shouldSendBeginEvent = YES;
   }
+
   return self;
 }
 
-- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsBegan:(NSSet *)touches withEvent:(UIEvent *)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<UITouch *> *)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
@@ -44,33 +50,71 @@
   }
 }
 
-- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)interactionsEnded:(NSSet *)touches withEvent:(UIEvent *)event
 {
-  [super touchesEnded:touches withEvent: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)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+- (void)touchesEnded:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [self interactionsEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<RNGHUITouch *> *)touches withEvent:(UIEvent *)event
 {
   [super touchesCancelled:touches withEvent:event];
   [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
 }
 
+#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];
   [super reset];
+  [_gestureHandler reset];
 
   _shouldSendBeginEvent = YES;
 }
 
 - (BOOL)shouldFail
 {
-  if (_gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView]) {
-    return YES;
-  } else {
-    return NO;
-  }
+  return _gestureHandler.shouldCancelWhenOutside && ![_gestureHandler containsPointInView];
 }
 
 @end
@@ -82,6 +126,7 @@
   if ((self = [super initWithTag:tag])) {
     _recognizer = [[RNManualRecognizer alloc] initWithGestureHandler:self];
   }
+
   return self;
 }