react-native-reanimated 2.3.0-alpha.3 → 2.3.0-beta.4

package/ios/Transitioning/REATransition.h

@@ -1,6 +1,6 @@
-#import <UIKit/UIKit.h>
 #import <QuartzCore/QuartzCore.h>
 #import <React/RCTView.h>
+#import <UIKit/UIKit.h>
 
 #import "REATransitionAnimation.h"
 #import "REATransitionValues.h"
@@ -53,12 +53,13 @@ typedef NS_ENUM(NSInteger, REATransitionPropagationType) {
 - (void)playInRoot:(UIView *)root;
 - (REATransitionValues *)findStartValuesForKey:(NSNumber *)key;
 - (REATransitionValues *)findEndValuesForKey:(NSNumber *)key;
-- (REATransitionAnimation *)animationForTransitioning:(REATransitionValues*)startValues
-                                               endValues:(REATransitionValues*)endValues
-                                                 forRoot:(UIView *)root;
-- (NSArray<REATransitionAnimation*> *)animationsForTransitioning:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)startValues
-                                                          endValues:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)endValues
-                                                            forRoot:(UIView *)root;
+- (REATransitionAnimation *)animationForTransitioning:(REATransitionValues *)startValues
+                                            endValues:(REATransitionValues *)endValues
+                                              forRoot:(UIView *)root;
+- (NSArray<REATransitionAnimation *> *)
+    animationsForTransitioning:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)startValues
+                     endValues:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)endValues
+                       forRoot:(UIView *)root;
 
 + (REATransition *)inflate:(NSDictionary *)config;
 @end

package/ios/Transitioning/REATransition.m

@@ -1,11 +1,11 @@
-#import <UIKit/UIKit.h>
 #import <QuartzCore/QuartzCore.h>
 #import <React/RCTConvert.h>
 #import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
 
+#import "RCTConvert+REATransition.h"
 #import "REATransition.h"
 #import "REATransitionValues.h"
-#import "RCTConvert+REATransition.h"
 
 #define DEFAULT_PROPAGATION_SPEED 3
 
@@ -17,8 +17,8 @@
 
 @interface REAVisibilityTransition : REATransition
 @property (nonatomic) REATransitionAnimationType animationType;
-- (REATransitionAnimation *)appearView:(UIView*)view inParent:(UIView*)parent;
-- (REATransitionAnimation *)disappearView:(UIView*)view fromParent:(UIView*)parent;
+- (REATransitionAnimation *)appearView:(UIView *)view inParent:(UIView *)parent;
+- (REATransitionAnimation *)disappearView:(UIView *)view fromParent:(UIView *)parent;
 - (instancetype)initWithConfig:(NSDictionary *)config;
 @end
 
@@ -36,8 +36,8 @@
 
 @implementation REATransition {
   __weak UIView *_root;
-  NSMutableDictionary<NSNumber*, REATransitionValues*> *_startValues;
-  NSMutableDictionary<NSNumber*, REATransitionValues*> *_endValues;
+  NSMutableDictionary<NSNumber *, REATransitionValues *> *_startValues;
+  NSMutableDictionary<NSNumber *, REATransitionValues *> *_endValues;
 }
 
 + (REATransition *)inflate:(NSDictionary *)config
@@ -70,7 +70,9 @@
   return self;
 }
 
-- (void)captureRecursiveIn:(UIView *)view to:(NSMutableDictionary<NSNumber*, REATransitionValues*> *)map forRoot:(UIView *)root
+- (void)captureRecursiveIn:(UIView *)view
+                        to:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)map
+                   forRoot:(UIView *)root
 {
   NSNumber *tag = view.reactTag;
   if (tag != nil) {
@@ -91,9 +93,7 @@
 {
   _endValues = [NSMutableDictionary new];
   [self captureRecursiveIn:root to:_endValues forRoot:root];
-  NSArray *animations = [self animationsForTransitioning:_startValues
-                                               endValues:_endValues
-                                                 forRoot:root];
+  NSArray *animations = [self animationsForTransitioning:_startValues endValues:_endValues forRoot:root];
   for (REATransitionAnimation *animation in animations) {
     [animation play];
   }
@@ -164,15 +164,16 @@
 }
 
 - (REATransitionAnimation *)animationForTransitioning:(REATransitionValues *)startValues
-                                               endValues:(REATransitionValues *)endValues
-                                                 forRoot:(UIView *)root
+                                            endValues:(REATransitionValues *)endValues
+                                              forRoot:(UIView *)root
 {
   return nil;
 }
 
-- (NSArray<REATransitionAnimation*> *)animationsForTransitioning:(NSMutableDictionary<NSNumber *,REATransitionValues *> *)startValues
-                                                          endValues:(NSMutableDictionary<NSNumber *,REATransitionValues *> *)endValues
-                                                            forRoot:(UIView *)root
+- (NSArray<REATransitionAnimation *> *)
+    animationsForTransitioning:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)startValues
+                     endValues:(NSMutableDictionary<NSNumber *, REATransitionValues *> *)endValues
+                       forRoot:(UIView *)root
 {
   NSMutableArray *animations = [NSMutableArray new];
   [startValues enumerateKeysAndObjectsUsingBlock:^(NSNumber *key, REATransitionValues *startValue, BOOL *stop) {
@@ -182,7 +183,9 @@
       animation.animation.timingFunction = self.mediaTiming;
       animation.animation.duration = self.duration;
       [animation delayBy:self.delay];
-      CFTimeInterval propagationDelay = [self propagationDelayForTransitioning:startValue endValues:endValue forRoot:root];
+      CFTimeInterval propagationDelay = [self propagationDelayForTransitioning:startValue
+                                                                     endValues:endValue
+                                                                       forRoot:root];
       [animation delayBy:propagationDelay];
       //      animation.animation.duration -= propagationDelay;
       [animations addObject:animation];

package/ios/Transitioning/REATransitionAnimation.h

@@ -8,7 +8,7 @@
 
 + (REATransitionAnimation *)transitionWithAnimation:(CAAnimation *)animation
                                               layer:(CALayer *)layer
-                                         andKeyPath:(NSString*)keyPath;
+                                         andKeyPath:(NSString *)keyPath;
 - (void)play;
 - (void)delayBy:(CFTimeInterval)delay;
 - (CFTimeInterval)finishTime;

package/ios/Transitioning/REATransitionAnimation.m

@@ -2,7 +2,6 @@
 
 #import "REATransitionAnimation.h"
 
-
 #define DEFAULT_DURATION 0.25
 
 #if TARGET_IPHONE_SIMULATOR
@@ -31,7 +30,7 @@ CGFloat SimAnimationDragCoefficient()
 
 + (REATransitionAnimation *)transitionWithAnimation:(CAAnimation *)animation
                                               layer:(CALayer *)layer
-                                         andKeyPath:(NSString*)keyPath;
+                                         andKeyPath:(NSString *)keyPath;
 {
   REATransitionAnimation *anim = [REATransitionAnimation new];
   anim.animation = animation;
@@ -47,7 +46,7 @@ CGFloat SimAnimationDragCoefficient()
   it calls mach_absolute_time() which is based on the last time the device booted
   which might cause the delay
   */
-  if (_delay > 0){
+  if (_delay > 0) {
     _animation.beginTime = CACurrentMediaTime() + _delay * SimAnimationDragCoefficient();
   }
   _animation.duration = self.duration * SimAnimationDragCoefficient();

package/ios/Transitioning/REATransitionManager.m

@@ -35,7 +35,7 @@
 
 - (void)uiManagerWillPerformMounting:(RCTUIManager *)manager
 {
-  [manager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [manager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     [_pendingTransition playInRoot:_pendingTransitionRoot];
     _pendingTransitionRoot = nil;
     _pendingTransition = nil;
@@ -45,7 +45,7 @@
 - (void)animateNextTransitionInRoot:(NSNumber *)reactTag withConfig:(NSDictionary *)config
 {
   [_uiManager.observerCoordinator addObserver:self];
-  [_uiManager prependUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [_uiManager prependUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     UIView *view = viewRegistry[reactTag];
     NSArray *transitionConfigs = [RCTConvert NSArray:config[@"transitions"]];
     for (id transitionConfig in transitionConfigs) {
@@ -54,7 +54,7 @@
     }
   }];
   __weak id weakSelf = self;
-  [_uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+  [_uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
     [uiManager.observerCoordinator removeObserver:weakSelf];
   }];
 }

package/ios/native/NativeMethods.h

@@ -1,11 +1,26 @@
 #import <Foundation/Foundation.h>
-#import <vector>
-#import <string>
 #import <React/RCTUIManager.h>
+#include <string>
+#import <string>
+#include <utility>
+#include <vector>
+#import <vector>
+#import "RNGestureHandlerStateManager.h"
 
 namespace reanimated {
 
-std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *uiManager);
-void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated);
+std::vector<std::pair<std::string, double>> measure(
+    int viewTag,
+    RCTUIManager *uiManager);
+void scrollTo(
+    int scrollViewTag,
+    RCTUIManager *uiManager,
+    double x,
+    double y,
+    bool animated);
+void setGestureState(
+    id<RNGestureHandlerStateManager> gestureHandlerStateManager,
+    int handlerTag,
+    int newState);
 
-}
+} // namespace reanimated

package/ios/native/NativeMethods.mm

@@ -1,10 +1,11 @@
 #import "NativeMethods.h"
-#import <React/RCTScrollView.h>
 #import <React/RCTEventDispatcher.h>
+#import <React/RCTScrollView.h>
 
 namespace reanimated {
 
-std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *uiManager) {
+std::vector<std::pair<std::string, double>> measure(int viewTag, RCTUIManager *uiManager)
+{
   UIView *view = [uiManager viewForReactTag:@(viewTag)];
 
   UIView *rootView = view;
@@ -17,7 +18,7 @@ std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *ui
     rootView = rootView.superview;
   }
 
-  if (rootView == nil || (![rootView isReactRootView])) {
+  if (rootView == nil) {
     return std::vector<std::pair<std::string, double>>(1, std::make_pair("x", -1234567.0));
   }
 
@@ -36,11 +37,18 @@ std::vector<std::pair<std::string,double>> measure(int viewTag, RCTUIManager *ui
   return result;
 }
 
-
-void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated) {
+void scrollTo(int scrollViewTag, RCTUIManager *uiManager, double x, double y, bool animated)
+{
   UIView *view = [uiManager viewForReactTag:@(scrollViewTag)];
-  RCTScrollView *scrollView = (RCTScrollView *) view;
+  RCTScrollView *scrollView = (RCTScrollView *)view;
   [scrollView scrollToOffset:(CGPoint){(CGFloat)x, (CGFloat)y} animated:animated];
 }
 
+void setGestureState(id<RNGestureHandlerStateManager> gestureHandlerStateManager, int handlerTag, int newState)
+{
+  if (gestureHandlerStateManager != nil) {
+    [gestureHandlerStateManager setGestureState:newState forHandler:handlerTag];
+  }
+}
+
 }

package/ios/native/NativeProxy.h

@@ -1,12 +1,14 @@
 #import <React/RCTEventDispatcher.h>
 
 #if __cplusplus
-
 #import <RNReanimated/NativeReanimatedModule.h>
+#include <memory>
 
 namespace reanimated {
 
-std::shared_ptr<reanimated::NativeReanimatedModule> createReanimatedModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+std::shared_ptr<reanimated::NativeReanimatedModule> createReanimatedModule(
+    RCTBridge *bridge,
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
 
 }
 

package/ios/native/NativeProxy.mm

@@ -1,15 +1,18 @@
-#import "NativeProxy.h"
-#import "REAIOSScheduler.h"
-#import "REAIOSErrorHandler.h"
-#import "REAModule.h"
-#import "REANodesManager.h"
-#import "NativeMethods.h"
-#import <folly/json.h>
+
 #import <React/RCTFollyConvert.h>
 #import <React/RCTUIManager.h>
+#import <folly/json.h>
+
 #import "LayoutAnimationsProxy.h"
+#import "NativeMethods.h"
+#import "NativeProxy.h"
 #import "REAAnimationsManager.h"
+#import "REAIOSErrorHandler.h"
+#import "REAIOSScheduler.h"
+#import "REAModule.h"
+#import "REANodesManager.h"
 #import "REAUIManager.h"
+#import "RNGestureHandlerStateManager.h"
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>
@@ -24,7 +27,6 @@ namespace reanimated {
 using namespace facebook;
 using namespace react;
 
-
 // COPIED FROM RCTTurboModule.mm
 static id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value);
 
@@ -49,15 +51,13 @@ static NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const
   return [result copy];
 }
 
-static NSArray *
-convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value)
+static NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value)
 {
   size_t size = value.size(runtime);
   NSMutableArray *result = [NSMutableArray new];
   for (size_t i = 0; i < size; i++) {
     // Insert kCFNull when it's `undefined` value to preserve the indices.
-    [result
-        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i)) ?: (id)kCFNull];
+    [result addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i)) ?: (id)kCFNull];
   }
   return [result copy];
 }
@@ -87,18 +87,23 @@ static id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &v
   throw std::runtime_error("Unsupported jsi::jsi::Value kind");
 }
 
-std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<CallInvoker> jsInvoker) {
-  RCTBridge *bridge = _bridge_reanimated;
+std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
+    RCTBridge *bridge,
+    std::shared_ptr<CallInvoker> jsInvoker)
+{
   REAModule *reanimatedModule = [bridge moduleForClass:[REAModule class]];
 
-  auto propUpdater = [reanimatedModule](jsi::Runtime &rt, int viewTag, const jsi::Value& viewName, const jsi::Object &props) -> void {
-    NSString *nsViewName = [NSString stringWithCString:viewName.asString(rt).utf8(rt).c_str() encoding:[NSString defaultCStringEncoding]];
+  auto propUpdater = [reanimatedModule](
+                         jsi::Runtime &rt, int viewTag, const jsi::Value &viewName, const jsi::Object &props) -> void {
+    NSString *nsViewName = [NSString stringWithCString:viewName.asString(rt).utf8(rt).c_str()
+                                              encoding:[NSString defaultCStringEncoding]];
 
     NSDictionary *propsDict = convertJSIObjectToNSDictionary(rt, props);
-    [reanimatedModule.nodesManager updateProps:propsDict ofViewWithTag:[NSNumber numberWithInt:viewTag] withName:nsViewName];
+    [reanimatedModule.nodesManager updateProps:propsDict
+                                 ofViewWithTag:[NSNumber numberWithInt:viewTag]
+                                      withName:nsViewName];
   };
 
-
   RCTUIManager *uiManager = reanimatedModule.nodesManager.uiManager;
   auto measuringFunction = [uiManager](int viewTag) -> std::vector<std::pair<std::string, double>> {
     return measure(viewTag, uiManager);
@@ -108,11 +113,18 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
     scrollTo(viewTag, uiManager, x, y, animated);
   };
 
-  auto propObtainer = [reanimatedModule](jsi::Runtime &rt, const int viewTag, const jsi::String &propName) -> jsi::Value {
-    NSString* propNameConverted = [NSString stringWithFormat:@"%s",propName.utf8(rt).c_str()];
-      std::string resultStr = std::string([[reanimatedModule.nodesManager obtainProp:[NSNumber numberWithInt:viewTag] propName:propNameConverted] UTF8String]);
-      jsi::Value val = jsi::String::createFromUtf8(rt, resultStr);
-      return val;
+  id<RNGestureHandlerStateManager> gestureHandlerStateManager = [bridge moduleForName:@"RNGestureHandlerModule"];
+  auto setGestureStateFunction = [gestureHandlerStateManager](int handlerTag, int newState) {
+    setGestureState(gestureHandlerStateManager, handlerTag, newState);
+  };
+
+  auto propObtainer = [reanimatedModule](
+                          jsi::Runtime &rt, const int viewTag, const jsi::String &propName) -> jsi::Value {
+    NSString *propNameConverted = [NSString stringWithFormat:@"%s", propName.utf8(rt).c_str()];
+    std::string resultStr = std::string([[reanimatedModule.nodesManager obtainProp:[NSNumber numberWithInt:viewTag]
+                                                                          propName:propNameConverted] UTF8String]);
+    jsi::Value val = jsi::String::createFromUtf8(rt, resultStr);
+    return val;
   };
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
@@ -128,13 +140,13 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
   std::shared_ptr<NativeReanimatedModule> module;
 
   __block std::weak_ptr<Scheduler> weakScheduler = scheduler;
-  ((REAUIManager*)uiManager).flushUiOperations = ^void() {
+  ((REAUIManager *)uiManager).flushUiOperations = ^void() {
     std::shared_ptr<Scheduler> scheduler = weakScheduler.lock();
     if (scheduler != nullptr) {
       scheduler->triggerUI();
     }
   };
-  
+
   auto requestRender = [reanimatedModule, &module](std::function<void(double)> onRender, jsi::Runtime &rt) {
     [reanimatedModule.nodesManager postOnAnimation:^(CADisplayLink *displayLink) {
       double frameTimestamp = displayLink.targetTimestamp * 1000;
@@ -146,80 +158,89 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
     }];
   };
 
-  auto getCurrentTime = []() {
-    return CACurrentMediaTime() * 1000;
-  };
-  
+  auto getCurrentTime = []() { return CACurrentMediaTime() * 1000; };
+
   // Layout Animations start
-  REAUIManager* reaUiManagerNoCast = [bridge moduleForClass:[REAUIManager class]];
-  RCTUIManager* reaUiManager = reaUiManagerNoCast;
+  REAUIManager *reaUiManagerNoCast = [bridge moduleForClass:[REAUIManager class]];
+  RCTUIManager *reaUiManager = reaUiManagerNoCast;
   REAAnimationsManager *animationsManager = [[REAAnimationsManager alloc] initWithUIManager:reaUiManager];
   [reaUiManagerNoCast setUp:animationsManager];
-  
+
   auto notifyAboutProgress = [=](int tag, jsi::Object newStyle) {
     if (animationsManager) {
       NSDictionary *propsDict = convertJSIObjectToNSDictionary(*animatedRuntime, newStyle);
-      [animationsManager notifyAboutProgress:propsDict tag:[NSNumber numberWithInt: tag]];
+      [animationsManager notifyAboutProgress:propsDict tag:[NSNumber numberWithInt:tag]];
     }
   };
-  
+
   auto notifyAboutEnd = [=](int tag, bool isCancelled) {
     if (animationsManager) {
-      [animationsManager notifyAboutEnd:[NSNumber numberWithInt: tag] cancelled:isCancelled];
+      [animationsManager notifyAboutEnd:[NSNumber numberWithInt:tag] cancelled:isCancelled];
     }
   };
-  
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy = std::make_shared<LayoutAnimationsProxy>(notifyAboutProgress, notifyAboutEnd);
+
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy =
+      std::make_shared<LayoutAnimationsProxy>(notifyAboutProgress, notifyAboutEnd);
   std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
-  [animationsManager setAnimationStartingBlock:^(NSNumber * _Nonnull tag, NSString * type,  NSDictionary* _Nonnull values, NSNumber* depth) {
+  [animationsManager setAnimationStartingBlock:^(
+                         NSNumber *_Nonnull tag, NSString *type, NSDictionary *_Nonnull values, NSNumber *depth) {
     std::shared_ptr<jsi::Runtime> rt = wrt.lock();
     if (wrt.expired()) {
       return;
     }
     jsi::Object yogaValues(*rt);
     for (NSString *key in values.allKeys) {
-      NSNumber* value = values[key];
+      NSNumber *value = values[key];
       yogaValues.setProperty(*rt, [key UTF8String], [value doubleValue]);
     }
-    
-    jsi::Value layoutAnimationRepositoryAsValue = rt->global().getPropertyAsObject(*rt, "global").getProperty(*rt, "LayoutAnimationRepository");
+
+    jsi::Value layoutAnimationRepositoryAsValue =
+        rt->global().getPropertyAsObject(*rt, "global").getProperty(*rt, "LayoutAnimationRepository");
     if (!layoutAnimationRepositoryAsValue.isUndefined()) {
-      jsi::Function startAnimationForTag = layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(*rt, "startAnimationForTag");
-      startAnimationForTag.call(*rt, jsi::Value([tag intValue]), jsi::String::createFromAscii(*rt, std::string([type UTF8String])), yogaValues, jsi::Value([depth intValue]));
+      jsi::Function startAnimationForTag =
+          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(*rt, "startAnimationForTag");
+      startAnimationForTag.call(
+          *rt,
+          jsi::Value([tag intValue]),
+          jsi::String::createFromAscii(*rt, std::string([type UTF8String])),
+          yogaValues,
+          jsi::Value([depth intValue]));
     }
   }];
 
-  
-  [animationsManager setRemovingConfigBlock:^(NSNumber* _Nonnull tag) {
+  [animationsManager setRemovingConfigBlock:^(NSNumber *_Nonnull tag) {
     std::shared_ptr<jsi::Runtime> rt = wrt.lock();
     if (wrt.expired()) {
       return;
     }
-    jsi::Value layoutAnimationRepositoryAsValue = rt->global().getPropertyAsObject(*rt, "global").getProperty(*rt, "LayoutAnimationRepository");
+    jsi::Value layoutAnimationRepositoryAsValue =
+        rt->global().getPropertyAsObject(*rt, "global").getProperty(*rt, "LayoutAnimationRepository");
     if (!layoutAnimationRepositoryAsValue.isUndefined()) {
-      jsi::Function removeConfig = layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(*rt, "removeConfig");
+      jsi::Function removeConfig =
+          layoutAnimationRepositoryAsValue.getObject(*rt).getPropertyAsFunction(*rt, "removeConfig");
       removeConfig.call(*rt, jsi::Value([tag intValue]));
     }
   }];
-  
+
   // Layout Animations end
-  
+
   PlatformDepMethodsHolder platformDepMethodsHolder = {
-    requestRender,
-    propUpdater,
-    scrollToFunction,
-    measuringFunction,
-    getCurrentTime,
+      requestRender,
+      propUpdater,
+      scrollToFunction,
+      measuringFunction,
+      getCurrentTime,
+      setGestureStateFunction,
   };
 
-  module = std::make_shared<NativeReanimatedModule>(jsInvoker,
-                                                    scheduler,
-                                                    animatedRuntime,
-                                                    errorHandler,
-                                                    propObtainer,
-                                                    layoutAnimationsProxy,
-                                                    platformDepMethodsHolder
-                                                    );
+  module = std::make_shared<NativeReanimatedModule>(
+      jsInvoker,
+      scheduler,
+      animatedRuntime,
+      errorHandler,
+      propObtainer,
+      layoutAnimationsProxy,
+      platformDepMethodsHolder);
 
   scheduler->setRuntimeManager(module);
 
@@ -227,7 +248,7 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(std::shared_ptr<C
     std::string eventNameString([eventName UTF8String]);
     std::string eventAsString = folly::toJson(convertIdToFollyDynamic([event arguments][2]));
 
-    eventAsString = "{ NativeMap:"  + eventAsString + "}";
+    eventAsString = "{ NativeMap:" + eventAsString + "}";
     jsi::Object global = module->runtime->global();
     jsi::String eventTimestampName = jsi::String::createFromAscii(*module->runtime, "_eventTimestamp");
     global.setProperty(*module->runtime, eventTimestampName, CACurrentMediaTime() * 1000);

package/ios/native/REAIOSErrorHandler.h

@@ -1,20 +1,23 @@
 #pragma once
 
+#include <memory>
+#include <string>
 #include "ErrorHandler.h"
 #include "Scheduler.h"
 
 namespace reanimated {
 
 class REAIOSErrorHandler : public ErrorHandler {
-    std::shared_ptr<Scheduler> scheduler;
-    void raiseSpec() override;
-    std::shared_ptr<ErrorWrapper> error;
-    public:
-      REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler);
-      std::shared_ptr<Scheduler> getScheduler() override;
-      std::shared_ptr<ErrorWrapper> getError() override;
-      void setError(std::string message) override;
-      virtual ~REAIOSErrorHandler() {}
+  std::shared_ptr<Scheduler> scheduler;
+  void raiseSpec() override;
+  std::shared_ptr<ErrorWrapper> error;
+
+ public:
+  REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler);
+  std::shared_ptr<Scheduler> getScheduler() override;
+  std::shared_ptr<ErrorWrapper> getError() override;
+  void setError(std::string message) override;
+  virtual ~REAIOSErrorHandler() {}
 };
 
-}
+} // namespace reanimated

package/ios/native/REAIOSErrorHandler.mm

@@ -2,31 +2,35 @@
 #import <Foundation/Foundation.h>
 #import <React/RCTLog.h>
 
-
 namespace reanimated {
 
-REAIOSErrorHandler::REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler) {
-    this->scheduler = scheduler;
-    error = std::make_shared<ErrorWrapper>();
+REAIOSErrorHandler::REAIOSErrorHandler(std::shared_ptr<Scheduler> scheduler)
+{
+  this->scheduler = scheduler;
+  error = std::make_shared<ErrorWrapper>();
 }
 
-void REAIOSErrorHandler::raiseSpec() {
-    if (error->handled) {
-        return;
-    }
-    RCTLogError(@(error->message.c_str()));
-    this->error->handled = true;
+void REAIOSErrorHandler::raiseSpec()
+{
+  if (error->handled) {
+    return;
+  }
+  RCTLogError(@(error->message.c_str()));
+  this->error->handled = true;
 }
 
-std::shared_ptr<Scheduler> REAIOSErrorHandler::getScheduler() {
-    return this->scheduler;
+std::shared_ptr<Scheduler> REAIOSErrorHandler::getScheduler()
+{
+  return this->scheduler;
 }
 
-std::shared_ptr<ErrorWrapper> REAIOSErrorHandler::getError() {
-    return this->error;
+std::shared_ptr<ErrorWrapper> REAIOSErrorHandler::getError()
+{
+  return this->error;
 }
 
-void REAIOSErrorHandler::setError(std::string message) {
+void REAIOSErrorHandler::setError(std::string message)
+{
   if (error->handled) {
     error->message = message;
     error->handled = false;

package/ios/native/REAIOSLogger.h

@@ -1,17 +1,17 @@
 #pragma once
 
-#include "ReanimatedHiddenHeaders.h"
 #include <stdio.h>
+#include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
 
 class REAIOSLogger : public LoggerInterface {
-  public:
-    void log(const char* str) override;
-    void log(double d) override;
-    void log(int i) override;
-    void log(bool b) override;
-    virtual ~REAIOSLogger() {}
+ public:
+  void log(const char *str) override;
+  void log(double d) override;
+  void log(int i) override;
+  void log(bool b) override;
+  virtual ~REAIOSLogger() {}
 };
 
-}
+} // namespace reanimated