react-native-reanimated 2.6.0 → 3.0.0-rc.0

package/ios/native/NativeProxy.mm

@@ -1,22 +1,32 @@
-#if TARGET_IPHONE_SIMULATOR
-#import <dlfcn.h>
+#import <RNReanimated/LayoutAnimationsProxy.h>
+#import <RNReanimated/NativeMethods.h>
+#import <RNReanimated/NativeProxy.h>
+#import <RNReanimated/REAAnimationsManager.h>
+#import <RNReanimated/REAIOSErrorHandler.h>
+#import <RNReanimated/REAIOSScheduler.h>
+#import <RNReanimated/REAModule.h>
+#import <RNReanimated/REANodesManager.h>
+#import <RNReanimated/REAUIManager.h>
+#import <RNReanimated/RNGestureHandlerStateManager.h>
+#import <RNReanimated/ReanimatedSensorContainer.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNReanimated/ReanimatedUIManagerBinding.h>
+#import <React-Fabric/react/renderer/core/ShadowNode.h>
+#import <React-Fabric/react/renderer/uimanager/primitives.h>
+#import <React/RCTBridge+Private.h>
+#import <React/RCTScheduler.h>
+#import <React/RCTSurfacePresenter.h>
+#else
+#import <folly/json.h>
 #endif
 
 #import <React/RCTFollyConvert.h>
 #import <React/RCTUIManager.h>
-#import <folly/json.h>
 
-#import <RNGestureHandlerStateManager.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 "ReanimatedSensorContainer.h"
+#if TARGET_IPHONE_SIMULATOR
+#import <dlfcn.h>
+#endif
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>
@@ -126,6 +136,74 @@ static id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &v
   throw std::runtime_error("Unsupported jsi::jsi::Value kind");
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+/**
+ * All static helper functions are ObjC++ specific.
+ */
+static jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value((bool)[value boolValue]);
+}
+
+static jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value([value doubleValue]);
+}
+
+static jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value)
+{
+  return jsi::String::createFromUtf8(runtime, [value UTF8String] ?: "");
+}
+
+static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+static jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value)
+{
+  jsi::Object result = jsi::Object(runtime);
+  for (NSString *k in value) {
+    result.setProperty(runtime, [k UTF8String], convertObjCObjectToJSIValue(runtime, value[k]));
+  }
+  return result;
+}
+
+static jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value)
+{
+  jsi::Array result = jsi::Array(runtime, value.count);
+  for (size_t i = 0; i < value.count; i++) {
+    result.setValueAtIndex(runtime, i, convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+static std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray *value)
+{
+  std::vector<jsi::Value> result;
+  for (size_t i = 0; i < value.count; i++) {
+    result.emplace_back(convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
+{
+  if ([value isKindOfClass:[NSString class]]) {
+    return convertNSStringToJSIString(runtime, (NSString *)value);
+  } else if ([value isKindOfClass:[NSNumber class]]) {
+    if ([value isKindOfClass:[@YES class]]) {
+      return convertNSNumberToJSIBoolean(runtime, (NSNumber *)value);
+    }
+    return convertNSNumberToJSINumber(runtime, (NSNumber *)value);
+  } else if ([value isKindOfClass:[NSDictionary class]]) {
+    return convertNSDictionaryToJSIObject(runtime, (NSDictionary *)value);
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    return convertNSArrayToJSIArray(runtime, (NSArray *)value);
+  } else if (value == (id)kCFNull) {
+    return jsi::Value::null();
+  }
+  return jsi::Value::undefined();
+}
+// COPIED FROM RCTTurboModule.mm END
+#endif // RCT_NEW_ARCH_ENABLED
+
 static NSSet *convertProps(jsi::Runtime &rt, const jsi::Value &props)
 {
   NSMutableSet *propsSet = [[NSMutableSet alloc] init];
@@ -143,8 +221,12 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 {
   REAModule *reanimatedModule = [bridge moduleForClass:[REAModule class]];
 
-  auto propUpdater = [reanimatedModule](
-                         jsi::Runtime &rt, int viewTag, const jsi::Value &viewName, const jsi::Object &props) -> void {
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  RCTUIManager *uiManager = reanimatedModule.nodesManager.uiManager;
+  auto updatePropsFunction =
+      [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]];
 
@@ -154,20 +236,27 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
                                       withName:nsViewName];
   };
 
-  RCTUIManager *uiManager = reanimatedModule.nodesManager.uiManager;
-  auto measuringFunction = [uiManager](int viewTag) -> std::vector<std::pair<std::string, double>> {
+  auto measureFunction = [uiManager](int viewTag) -> std::vector<std::pair<std::string, double>> {
     return measure(viewTag, uiManager);
   };
 
   auto scrollToFunction = [uiManager](int viewTag, double x, double y, bool animated) {
     scrollTo(viewTag, uiManager, x, y, animated);
   };
+#endif
+
+  id<RNGestureHandlerStateManager> gestureHandlerStateManager = nil;
+  auto setGestureStateFunction = [gestureHandlerStateManager, bridge](int handlerTag, int newState) mutable {
+    if (gestureHandlerStateManager == nil) {
+      gestureHandlerStateManager = [bridge moduleForName:@"RNGestureHandlerModule"];
+    }
 
-  id<RNGestureHandlerStateManager> gestureHandlerStateManager = [bridge moduleForName:@"RNGestureHandlerModule"];
-  auto setGestureStateFunction = [gestureHandlerStateManager](int handlerTag, int newState) {
     setGestureState(gestureHandlerStateManager, handlerTag, newState);
   };
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
   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()];
@@ -176,6 +265,7 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     jsi::Value val = jsi::String::createFromUtf8(rt, resultStr);
     return val;
   };
+#endif
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
   std::shared_ptr<jsi::Runtime> animatedRuntime = facebook::hermes::makeHermesRuntime();
@@ -189,14 +279,6 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
   std::shared_ptr<ErrorHandler> errorHandler = std::make_shared<REAIOSErrorHandler>(scheduler);
   std::shared_ptr<NativeReanimatedModule> module;
 
-  __block std::weak_ptr<Scheduler> weakScheduler = scheduler;
-  ((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 = calculateTimestampWithSlowAnimations(displayLink.targetTimestamp) * 1000;
@@ -208,9 +290,25 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     }];
   };
 
-  auto getCurrentTime = []() { return calculateTimestampWithSlowAnimations(CACurrentMediaTime()) * 1000; };
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto synchronouslyUpdateUIPropsFunction = [reanimatedModule](jsi::Runtime &rt, Tag tag, const jsi::Value &props) {
+    NSNumber *viewTag = @(tag);
+    NSDictionary *uiProps = convertJSIObjectToNSDictionary(rt, props.asObject(rt));
+    [reanimatedModule.nodesManager synchronouslyUpdateViewOnUIThread:viewTag props:uiProps];
+  };
 
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy =
+      std::make_shared<LayoutAnimationsProxy>([](int tag, jsi::Object newStyle) {}, [](int tag, bool isCancelled) {});
+#else
   // Layout Animations start
+  __block std::weak_ptr<Scheduler> weakScheduler = scheduler;
+  ((REAUIManager *)uiManager).flushUiOperations = ^void() {
+    std::shared_ptr<Scheduler> scheduler = weakScheduler.lock();
+    if (scheduler != nullptr) {
+      scheduler->triggerUI();
+    }
+  };
+
   REAUIManager *reaUiManagerNoCast = [bridge moduleForClass:[REAUIManager class]];
   RCTUIManager *reaUiManager = reaUiManagerNoCast;
   REAAnimationsManager *animationsManager = [[REAAnimationsManager alloc] initWithUIManager:reaUiManager];
@@ -280,6 +378,9 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
   }];
 
   // Layout Animations end
+#endif
+
+  auto getCurrentTime = []() { return calculateTimestampWithSlowAnimations(CACurrentMediaTime()) * 1000; };
 
   // sensors
   ReanimatedSensorContainer *reanimatedSensorContainer = [[ReanimatedSensorContainer alloc] init];
@@ -296,26 +397,46 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 
   PlatformDepMethodsHolder platformDepMethodsHolder = {
       requestRender,
-      propUpdater,
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction,
+#else
+      updatePropsFunction,
       scrollToFunction,
-      measuringFunction,
+      measureFunction,
+      configurePropsFunction,
+#endif
       getCurrentTime,
       registerSensorFunction,
       unregisterSensorFunction,
       setGestureStateFunction,
-      configurePropsFunction};
+  };
 
   module = std::make_shared<NativeReanimatedModule>(
       jsInvoker,
       scheduler,
       animatedRuntime,
       errorHandler,
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
       propObtainer,
+#endif
       layoutAnimationsProxy,
       platformDepMethodsHolder);
 
   scheduler->setRuntimeManager(module);
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  [reanimatedModule.nodesManager registerEventHandler:^(NSString *eventNameNSString, id<RCTEvent> event) {
+    // handles RCTEvents from RNGestureHandler
+
+    std::string eventName = [eventNameNSString UTF8String];
+    jsi::Runtime &rt = *module->runtime;
+    jsi::Value payload = convertNSDictionaryToJSIObject(rt, [event arguments][2]);
+
+    module->handleEvent(eventName, std::move(payload), CACurrentMediaTime() * 1000);
+  }];
+#else
   [reanimatedModule.nodesManager registerEventHandler:^(NSString *eventName, id<RCTEvent> event) {
     std::string eventNameString([eventName UTF8String]);
 
@@ -335,7 +456,16 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     module->onEvent(eventNameString, eventAsString);
     global.setProperty(*module->runtime, eventTimestampName, jsi::Value::undefined());
   }];
+#endif
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  std::weak_ptr<NativeReanimatedModule> weakModule = module; // to avoid retain cycle
+  [reanimatedModule.nodesManager registerPerformOperations:^() {
+    if (auto module = weakModule.lock()) {
+      module->performOperations();
+    }
+  }];
+#endif
   return module;
 }
 

package/ios/native/REAIOSErrorHandler.h

@@ -1,9 +1,7 @@
-#pragma once
-
+#import <RNReanimated/ErrorHandler.h>
+#import <RNReanimated/Scheduler.h>
 #include <memory>
 #include <string>
-#include "ErrorHandler.h"
-#include "Scheduler.h"
 
 namespace reanimated {
 

package/ios/native/REAIOSErrorHandler.mm

@@ -1,5 +1,5 @@
-#include "REAIOSErrorHandler.h"
 #import <Foundation/Foundation.h>
+#import <RNReanimated/REAIOSErrorHandler.h>
 #import <React/RCTLog.h>
 
 namespace reanimated {

package/ios/native/REAIOSLogger.h

@@ -1,7 +1,5 @@
-#pragma once
-
+#import <RNReanimated/ReanimatedHiddenHeaders.h>
 #include <stdio.h>
-#include "ReanimatedHiddenHeaders.h"
 
 namespace reanimated {
 

package/ios/native/REAIOSLogger.mm

@@ -1,5 +1,5 @@
-#include "REAIOSLogger.h"
 #import <Foundation/Foundation.h>
+#import <RNReanimated/REAIOSLogger.h>
 
 namespace reanimated {
 

package/ios/native/REAIOSScheduler.h

@@ -1,10 +1,8 @@
-#pragma once
-
+#import <RNReanimated/Scheduler.h>
 #import <React/RCTUIManager.h>
 #import <ReactCommon/CallInvoker.h>
 #include <stdio.h>
 #include <memory>
-#include "Scheduler.h"
 
 namespace reanimated {
 

package/ios/native/REAIOSScheduler.mm

@@ -1,5 +1,5 @@
-#include "REAIOSScheduler.h"
-#include "RuntimeManager.h"
+#import <RNReanimated/REAIOSScheduler.h>
+#import <RNReanimated/RuntimeManager.h>
 
 namespace reanimated {
 

package/ios/native/REAInitializer.h

@@ -1,10 +1,3 @@
-//
-//  REAInitializer.h
-//  RNReanimated
-//
-//  Created by Szymon Kapala on 27/07/2021.
-//
-
 #import <Foundation/Foundation.h>
 #import <RNReanimated/NativeProxy.h>
 #import <RNReanimated/REAEventDispatcher.h>

package/ios/native/REAInitializer.mm

@@ -1,5 +1,5 @@
-#import "REAInitializer.h"
-#import "REAUIManager.h"
+#import <RNReanimated/REAInitializer.h>
+#import <RNReanimated/REAUIManager.h>
 
 @interface RCTEventDispatcher (Reanimated)
 
@@ -45,10 +45,18 @@ JSIExecutor::RuntimeInstaller REAJSIExecutorRuntimeInstaller(
     auto callInvoker = std::make_shared<react::BridgeJSCallInvoker>(bridge.reactInstance);
     auto reanimatedModule = reanimated::createReanimatedModule(bridge, callInvoker);
 #endif
-    runtime.global().setProperty(
-        runtime,
-        "_WORKLET_RUNTIME",
-        static_cast<double>(reinterpret_cast<std::uintptr_t>(reanimatedModule->runtime.get())));
+    auto workletRuntimeValue = runtime.global()
+                                   .getProperty(runtime, "ArrayBuffer")
+                                   .asObject(runtime)
+                                   .asFunction(runtime)
+                                   .callAsConstructor(runtime, {static_cast<double>(sizeof(void *))});
+    uintptr_t *workletRuntimeData =
+        reinterpret_cast<uintptr_t *>(workletRuntimeValue.getObject(runtime).getArrayBuffer(runtime).data(runtime));
+    workletRuntimeData[0] = reinterpret_cast<uintptr_t>(reanimatedModule->runtime.get());
+
+    runtime.global().setProperty(runtime, "_WORKLET_RUNTIME", workletRuntimeValue);
+
+    runtime.global().setProperty(runtime, "_IS_FABRIC", false);
 
     runtime.global().setProperty(
         runtime,

package/ios/native/UIResponder+Reanimated.h

@@ -1,10 +1,12 @@
 #import <Foundation/Foundation.h>
 #import <React/RCTCxxBridgeDelegate.h>
 
+#ifndef RCT_NEW_ARCH_ENABLED
 #ifndef DONT_AUTOINSTALL_REANIMATED
 
 @interface UIResponder (Reanimated) <RCTCxxBridgeDelegate>
 
 @end
 
-#endif
+#endif // DONT_AUTOINSTALL_REANIMATED
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/native/UIResponder+Reanimated.mm

@@ -1,6 +1,6 @@
-#import "REAInitializer.h"
-#import "REAUIManager.h"
-#import "UIResponder+Reanimated.h"
+#import <RNReanimated/REAInitializer.h>
+#import <RNReanimated/REAUIManager.h>
+#import <RNReanimated/UIResponder+Reanimated.h>
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>
@@ -13,6 +13,7 @@ typedef HermesExecutorFactory ExecutorFactory;
 typedef JSCExecutorFactory ExecutorFactory;
 #endif
 
+#ifndef RCT_NEW_ARCH_ENABLED
 #ifndef DONT_AUTOINSTALL_REANIMATED
 
 @implementation UIResponder (Reanimated)
@@ -30,4 +31,5 @@ typedef JSCExecutorFactory ExecutorFactory;
 
 @end
 
-#endif
+#endif // DONT_AUTOINSTALL_REANIMATED
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/sensor/ReanimatedSensor.h

@@ -1,7 +1,7 @@
 #if __has_include(<CoreMotion/CoreMotion.h>)
 #import <CoreMotion/CoreMotion.h>
 #endif
-#import "ReanimatedSensorType.h"
+#import <RNReanimated/ReanimatedSensorType.h>
 
 @interface ReanimatedSensor : NSObject {
   ReanimatedSensorType _sensorType;

package/ios/sensor/ReanimatedSensor.m

@@ -1,4 +1,4 @@
-#import "ReanimatedSensor.h"
+#import <RNReanimated/ReanimatedSensor.h>
 
 #if __has_include(<CoreMotion/CoreMotion.h>)
 @implementation ReanimatedSensor

package/ios/sensor/ReanimatedSensorContainer.h

@@ -1,4 +1,4 @@
-#import "ReanimatedSensorType.h"
+#import <RNReanimated/ReanimatedSensorType.h>
 
 @interface ReanimatedSensorContainer : NSObject {
   NSNumber *_nextSensorId;

package/ios/sensor/ReanimatedSensorContainer.m

@@ -1,6 +1,6 @@
-#import "ReanimatedSensorContainer.h"
 #import <Foundation/Foundation.h>
-#import "ReanimatedSensor.h"
+#import <RNReanimated/ReanimatedSensor.h>
+#import <RNReanimated/ReanimatedSensorContainer.h>
 
 static NSNumber *_nextSensorId = nil;
 

package/lib/Animated.js

@@ -1,10 +1,8 @@
-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 = {
@@ -14,18 +12,7 @@ const Animated = {
   // configuration
   addWhitelistedNativeProps,
   addWhitelistedUIProps,
-  // reanimated 1
-  ...reanimated1,
 };
 
 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',
-]);

package/lib/ConfigHelper.js

@@ -76,7 +76,6 @@ let NATIVE_THREAD_PROPS_WHITELIST = {
     borderTopLeftRadius: true,
     borderTopRightRadius: true,
     borderTopStartRadius: true,
-    opacity: true,
     elevation: true,
     fontSize: true,
     lineHeight: true,