react-native-reanimated 2.3.0-beta.2 → 2.3.1

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.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.mm

@@ -5,20 +5,24 @@ namespace reanimated {
 
 std::unique_ptr<LoggerInterface> Logger::instance = std::make_unique<REAIOSLogger>();
 
-void REAIOSLogger::log(const char* str) {
+void REAIOSLogger::log(const char *str)
+{
   NSLog(@"%@", [NSString stringWithCString:str encoding:[NSString defaultCStringEncoding]]);
 }
 
-void REAIOSLogger::log(double d) {
+void REAIOSLogger::log(double d)
+{
   NSLog(@"%lf", d);
 }
 
-void REAIOSLogger::log(int i) {
-   NSLog(@"%i", i);
+void REAIOSLogger::log(int i)
+{
+  NSLog(@"%i", i);
 }
 
-void REAIOSLogger::log(bool b) {
-  const char* str = (b)? "true" : "false";
+void REAIOSLogger::log(bool b)
+{
+  const char *str = (b) ? "true" : "false";
   NSLog(@"%@", [NSString stringWithCString:str encoding:[NSString defaultCStringEncoding]]);
 }
 

package/ios/native/REAIOSScheduler.mm

@@ -6,36 +6,43 @@ namespace reanimated {
 using namespace facebook;
 using namespace react;
 
-REAIOSScheduler::REAIOSScheduler(std::shared_ptr<CallInvoker> jsInvoker) {
+REAIOSScheduler::REAIOSScheduler(std::shared_ptr<CallInvoker> jsInvoker)
+{
   this->jsCallInvoker_ = jsInvoker;
 }
 
-void REAIOSScheduler::scheduleOnUI(std::function<void()> job) {
+void REAIOSScheduler::scheduleOnUI(std::function<void()> job)
+{
   if (runtimeManager.lock() == nullptr) {
     return;
   }
 
-  if([NSThread isMainThread]) {
-    if (runtimeManager.lock()) job();
+  if ([NSThread isMainThread]) {
+    if (runtimeManager.lock()) {
+      job();
+    }
     return;
   }
 
   Scheduler::scheduleOnUI(job);
-  if([NSThread isMainThread]) {
-    if (runtimeManager.lock()) triggerUI();
+  if ([NSThread isMainThread]) {
+    if (runtimeManager.lock()) {
+      triggerUI();
+    }
     return;
   }
-  
+
   if (!this->scheduledOnUI) {
     __block std::weak_ptr<RuntimeManager> blockRuntimeManager = runtimeManager;
 
     dispatch_async(dispatch_get_main_queue(), ^{
-      if (blockRuntimeManager.lock()) triggerUI();
+      if (blockRuntimeManager.lock()) {
+        triggerUI();
+      }
     });
   }
 }
 
-REAIOSScheduler::~REAIOSScheduler(){
-}
+REAIOSScheduler::~REAIOSScheduler() {}
 
 }

package/ios/native/REAInitializer.mm

@@ -1,9 +1,9 @@
 #import "REAInitializer.h"
 #import "REAUIManager.h"
 
-@interface RCTEventDispatcher(Reanimated)
+@interface RCTEventDispatcher (Reanimated)
 
-- (void)setBridge:(RCTBridge*)bridge;
+- (void)setBridge:(RCTBridge *)bridge;
 
 @end
 
@@ -13,51 +13,53 @@ using namespace facebook;
 using namespace react;
 
 JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
-    RCTBridge* bridge,
+    RCTBridge *bridge,
     JSIExecutor::RuntimeInstaller runtimeInstallerToWrap)
 {
-    [bridge moduleForClass:[RCTUIManager class]];
-    REAUIManager* reaUiManager = [REAUIManager new];
-    [reaUiManager setBridge:bridge];
-    RCTUIManager* uiManager = reaUiManager;
-    [bridge updateModuleWithInstance:uiManager];
-  
-    [bridge moduleForClass:[RCTEventDispatcher class]];
-    RCTEventDispatcher *eventDispatcher = [REAEventDispatcher new];
+  [bridge moduleForClass:[RCTUIManager class]];
+  REAUIManager *reaUiManager = [REAUIManager new];
+  [reaUiManager setBridge:bridge];
+  RCTUIManager *uiManager = reaUiManager;
+  [bridge updateModuleWithInstance:uiManager];
+
+  [bridge moduleForClass:[RCTEventDispatcher class]];
+  RCTEventDispatcher *eventDispatcher = [REAEventDispatcher new];
 #if RNVERSION >= 66
-    RCTCallableJSModules *callableJSModules = [RCTCallableJSModules new];
-    [bridge setValue:callableJSModules forKey:@"_callableJSModules"];
-    [callableJSModules setBridge:bridge];
-    [eventDispatcher setValue:callableJSModules forKey:@"_callableJSModules"];
-    [eventDispatcher setValue:bridge forKey:@"_bridge"];
-    [eventDispatcher initialize];
+  RCTCallableJSModules *callableJSModules = [RCTCallableJSModules new];
+  [bridge setValue:callableJSModules forKey:@"_callableJSModules"];
+  [callableJSModules setBridge:bridge];
+  [eventDispatcher setValue:callableJSModules forKey:@"_callableJSModules"];
+  [eventDispatcher setValue:bridge forKey:@"_bridge"];
+  [eventDispatcher initialize];
 #else
-    [eventDispatcher setBridge:bridge];
+  [eventDispatcher setBridge:bridge];
 #endif
-    [bridge updateModuleWithInstance:eventDispatcher];
-    _bridge_reanimated = bridge;
-    const auto runtimeInstaller = [bridge, runtimeInstallerToWrap](facebook::jsi::Runtime &runtime) {
-      if (!bridge) {
-        return;
-      }
+  [bridge updateModuleWithInstance:eventDispatcher];
+  const auto runtimeInstaller = [bridge, runtimeInstallerToWrap](facebook::jsi::Runtime &runtime) {
+    if (!bridge) {
+      return;
+    }
 #if RNVERSION >= 63
-    auto reanimatedModule = reanimated::createReanimatedModule(bridge.jsCallInvoker);
+    auto reanimatedModule = reanimated::createReanimatedModule(bridge, bridge.jsCallInvoker);
 #else
     auto callInvoker = std::make_shared<react::BridgeJSCallInvoker>(bridge.reactInstance);
-    auto reanimatedModule = reanimated::createReanimatedModule(callInvoker);
+    auto reanimatedModule = reanimated::createReanimatedModule(bridge, callInvoker);
 #endif
-    runtime.global().setProperty(runtime,
-                                 jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),
-                                 jsi::Object::createFromHostObject(runtime, reanimatedModule));
-        
-        if (runtimeInstallerToWrap) {
-            runtimeInstallerToWrap(runtime);
-        }
-    };
-    return runtimeInstaller;
-}
+    runtime.global().setProperty(
+        runtime,
+        "_WORKLET_RUNTIME",
+        static_cast<double>(reinterpret_cast<std::uintptr_t>(reanimatedModule->runtime.get())));
 
+    runtime.global().setProperty(
+        runtime,
+        jsi::PropNameID::forAscii(runtime, "__reanimatedModuleProxy"),
+        jsi::Object::createFromHostObject(runtime, reanimatedModule));
 
+    if (runtimeInstallerToWrap) {
+      runtimeInstallerToWrap(runtime);
+    }
+  };
+  return runtimeInstaller;
 }
 
-
+}

package/ios/native/UIResponder+Reanimated.mm

@@ -1,6 +1,6 @@
-#import "UIResponder+Reanimated.h"
-#import "REAUIManager.h"
 #import "REAInitializer.h"
+#import "REAUIManager.h"
+#import "UIResponder+Reanimated.h"
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>

package/lib/Animated.js

@@ -1,17 +1,15 @@
-import { Image, ScrollView, Text, View } from 'react-native';
+import { LogBox } from 'react-native';
 import createAnimatedComponent from './createAnimatedComponent';
 import {
   addWhitelistedNativeProps,
   addWhitelistedUIProps,
 } from './ConfigHelper';
 import * as reanimated1 from './reanimated1';
+import ReanimatedComponents from './reanimated2/component';
 
 const Animated = {
   // components
-  View: createAnimatedComponent(View),
-  Text: createAnimatedComponent(Text),
-  Image: createAnimatedComponent(Image),
-  ScrollView: createAnimatedComponent(ScrollView),
+  ...ReanimatedComponents,
   createAnimatedComponent,
   // configuration
   addWhitelistedNativeProps,
@@ -23,3 +21,11 @@ const Animated = {
 export * from './reanimated2';
 export * from './reanimated1';
 export default Animated;
+
+// I think we can ignore this message as long as Gesture Handler doesn't
+// try to load the Reanimated module. I figured it should be here instead of
+// RNGH because this prevents the message from being displayed for all
+// versions of RNGH.
+LogBox.ignoreLogs([
+  'RCTBridge required dispatch_sync to load RNGestureHandlerModule. This may lead to deadlocks',
+]);