react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -96,10 +96,15 @@ void RuntimeDecorator::decorateRuntime(
 
 void RuntimeDecorator::decorateUIRuntime(
     jsi::Runtime &rt,
-    const UpdaterFunction updater,
-    const RequestFrameFunction requestFrame,
+    const UpdatePropsFunction updateProps,
+    const MeasureFunction measure,
+#ifdef RCT_NEW_ARCH_ENABLED
+    const RemoveShadowNodeFromRegistryFunction removeShadowNodeFromRegistry,
+    const DispatchCommandFunction dispatchCommand,
+#else
     const ScrollToFunction scrollTo,
-    const MeasuringFunction measure,
+#endif
+    const RequestFrameFunction requestFrame,
     const TimeProviderFunction getCurrentTime,
     const RegisterSensorFunction registerSensor,
     const UnregisterSensorFunction unregisterSensor,
@@ -108,42 +113,79 @@ void RuntimeDecorator::decorateUIRuntime(
   RuntimeDecorator::decorateRuntime(rt, "UI");
   rt.global().setProperty(rt, "_UI", jsi::Value(true));
 
-  auto clb = [updater](
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto clb = [updateProps](
                  jsi::Runtime &rt,
                  const jsi::Value &thisValue,
                  const jsi::Value *args,
                  const size_t count) -> jsi::Value {
-    const auto viewTag = args[0].asNumber();
-    const jsi::Value *viewName = &args[1];
-    const auto params = args[2].asObject(rt);
-    updater(rt, viewTag, *viewName, params);
+    updateProps(rt, args[0], args[1]);
     return jsi::Value::undefined();
   };
-  jsi::Value updateProps = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_updateProps"), 2, clb);
-  rt.global().setProperty(rt, "_updateProps", updateProps);
+  jsi::Value updatePropsHostFunction = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_updatePropsFabric"), 2, clb);
+  rt.global().setProperty(rt, "_updatePropsFabric", updatePropsHostFunction);
 
-  auto clb2 = [requestFrame](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  const size_t count) -> jsi::Value {
-    auto fun =
-        std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
-    requestFrame([&rt, fun](double timestampMs) {
-      fun->call(rt, jsi::Value(timestampMs));
-    });
+  auto _removeShadowNodeFromRegistry = [removeShadowNodeFromRegistry](
+                                           jsi::Runtime &rt,
+                                           const jsi::Value &thisValue,
+                                           const jsi::Value *args,
+                                           const size_t count) -> jsi::Value {
+    removeShadowNodeFromRegistry(rt, args[0]);
     return jsi::Value::undefined();
   };
-  jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "requestAnimationFrame"), 1, clb2);
-  rt.global().setProperty(rt, "requestAnimationFrame", requestAnimationFrame);
+  jsi::Value removeShadowNodeFromRegistryHostFunction =
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "_removeShadowNodeFromRegistry"),
+          2,
+          _removeShadowNodeFromRegistry);
+  rt.global().setProperty(
+      rt,
+      "_removeShadowNodeFromRegistry",
+      removeShadowNodeFromRegistryHostFunction);
 
-  auto clb3 = [scrollTo](
+  auto clb3 = [dispatchCommand](
                   jsi::Runtime &rt,
                   const jsi::Value &thisValue,
                   const jsi::Value *args,
                   const size_t count) -> jsi::Value {
+    dispatchCommand(rt, args[0], args[1], args[2]);
+    return jsi::Value::undefined();
+  };
+  jsi::Value dispatchCommandHostFunction =
+      jsi::Function::createFromHostFunction(
+          rt, jsi::PropNameID::forAscii(rt, "_dispatchCommand"), 3, clb3);
+  rt.global().setProperty(rt, "_dispatchCommand", dispatchCommandHostFunction);
+
+  auto _measure = [measure](
+                      jsi::Runtime &rt,
+                      const jsi::Value &thisValue,
+                      const jsi::Value *args,
+                      const size_t count) -> jsi::Value {
+    return measure(rt, args[0]);
+  };
+#else
+  auto clb = [updateProps](
+                 jsi::Runtime &rt,
+                 const jsi::Value &thisValue,
+                 const jsi::Value *args,
+                 const size_t count) -> jsi::Value {
+    const auto viewTag = args[0].asNumber();
+    const jsi::Value *viewName = &args[1];
+    const auto params = args[2].asObject(rt);
+    updateProps(rt, viewTag, *viewName, params);
+    return jsi::Value::undefined();
+  };
+  jsi::Value updatePropsHostFunction = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "_updatePropsPaper"), 3, clb);
+  rt.global().setProperty(rt, "_updatePropsPaper", updatePropsHostFunction);
+
+  auto _scrollTo = [scrollTo](
+                       jsi::Runtime &rt,
+                       const jsi::Value &thisValue,
+                       const jsi::Value *args,
+                       const size_t count) -> jsi::Value {
     int viewTag = static_cast<int>(args[0].asNumber());
     double x = args[1].asNumber();
     double y = args[2].asNumber();
@@ -152,14 +194,14 @@ void RuntimeDecorator::decorateUIRuntime(
     return jsi::Value::undefined();
   };
   jsi::Value scrollToFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_scrollTo"), 4, clb3);
+      rt, jsi::PropNameID::forAscii(rt, "_scrollTo"), 4, _scrollTo);
   rt.global().setProperty(rt, "_scrollTo", scrollToFunction);
 
-  auto clb4 = [measure](
-                  jsi::Runtime &rt,
-                  const jsi::Value &thisValue,
-                  const jsi::Value *args,
-                  const size_t count) -> jsi::Value {
+  auto _measure = [measure](
+                      jsi::Runtime &rt,
+                      const jsi::Value &thisValue,
+                      const jsi::Value *args,
+                      const size_t count) -> jsi::Value {
     int viewTag = static_cast<int>(args[0].asNumber());
     auto result = measure(viewTag);
     jsi::Object resultObject(rt);
@@ -168,10 +210,28 @@ void RuntimeDecorator::decorateUIRuntime(
     }
     return resultObject;
   };
+#endif // RCT_NEW_ARCH_ENABLED
+
   jsi::Value measureFunction = jsi::Function::createFromHostFunction(
-      rt, jsi::PropNameID::forAscii(rt, "_measure"), 1, clb4);
+      rt, jsi::PropNameID::forAscii(rt, "_measure"), 1, _measure);
   rt.global().setProperty(rt, "_measure", measureFunction);
 
+  auto clb2 = [requestFrame](
+                  jsi::Runtime &rt,
+                  const jsi::Value &thisValue,
+                  const jsi::Value *args,
+                  const size_t count) -> jsi::Value {
+    auto fun =
+        std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
+    requestFrame([&rt, fun](double timestampMs) {
+      fun->call(rt, jsi::Value(timestampMs));
+    });
+    return jsi::Value::undefined();
+  };
+  jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "requestAnimationFrame"), 1, clb2);
+  rt.global().setProperty(rt, "requestAnimationFrame", requestAnimationFrame);
+
   auto clb6 = [getCurrentTime](
                   jsi::Runtime &rt,
                   const jsi::Value &thisValue,

package/Common/cpp/Tools/Scheduler.cpp

@@ -1,4 +1,8 @@
+#ifdef __APPLE__
+#include <RNReanimated/Scheduler.h>
+#else
 #include "Scheduler.h"
+#endif
 
 namespace reanimated {
 

package/Common/cpp/headers/Fabric/FabricUtils.h

@@ -0,0 +1,79 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#ifdef ANDROID
+#include <Binding.h>
+#include <fbjni/fbjni.h>
+#endif
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+struct UIManagerBindingPublic {
+  void *vtable;
+  std::shared_ptr<UIManager> uiManager_;
+  std::unique_ptr<EventHandler const> eventHandler_;
+};
+
+struct UIManagerPublic {
+  void *vtable;
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  UIManagerDelegate *delegate_;
+  UIManagerAnimationDelegate *animationDelegate_{nullptr};
+  RuntimeExecutor const runtimeExecutor_{};
+  ShadowTreeRegistry shadowTreeRegistry_{};
+  BackgroundExecutor const backgroundExecutor_{};
+  ContextContainer::Shared contextContainer_;
+};
+
+#ifdef ANDROID
+struct BindingPublic : public jni::HybridClass<Binding>,
+                       public SchedulerDelegate,
+                       public LayoutAnimationStatusDelegate {
+  butter::shared_mutex installMutex_;
+  std::shared_ptr<FabricMountingManager> mountingManager_;
+  std::shared_ptr<facebook::react::Scheduler> scheduler_;
+};
+
+struct SchedulerPublic : public UIManagerDelegate {
+  SchedulerDelegate *delegate_;
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  RuntimeExecutor runtimeExecutor_;
+};
+
+RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding);
+#endif
+
+std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
+    const UIManager *uiManager);
+
+void UIManager_dispatchCommand(
+    const std::shared_ptr<UIManager> &uiManager,
+    const ShadowNode::Shared &shadowNode,
+    std::string const &commandName,
+    folly::dynamic const &args);
+
+LayoutMetrics UIManager_getRelativeLayoutMetrics(
+    const std::shared_ptr<UIManager> &uiManager,
+    ShadowNode const &shadowNode,
+    ShadowNode const *ancestorShadowNode,
+    LayoutableShadowNode::LayoutInspectingPolicy policy);
+
+ShadowNode::Shared UIManager_cloneNode(
+    const UIManager *uiManager,
+    const ShadowNode::Shared &shadowNode,
+    const ShadowNode::SharedListOfShared &children = nullptr,
+    const RawProps *rawProps = nullptr);
+
+void UIManager_appendChild(
+    const ShadowNode::Shared &parentShadowNode,
+    const ShadowNode::Shared &childShadowNode);
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/headers/Fabric/ReanimatedUIManagerBinding.h

@@ -0,0 +1,47 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <jsi/jsi.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <memory>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ReanimatedUIManagerBinding : public UIManagerBinding {
+ public:
+  static void createAndInstallIfNeeded(
+      jsi::Runtime &runtime,
+      RuntimeExecutor const &runtimeExecutor,
+      std::shared_ptr<UIManager> const &uiManager,
+      std::shared_ptr<NewestShadowNodesRegistry> const
+          &newestShadowNodesRegistry);
+
+  ReanimatedUIManagerBinding(
+      std::shared_ptr<UIManager> uiManager,
+      RuntimeExecutor runtimeExecutor,
+      std::unique_ptr<EventHandler const> eventHandler,
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry);
+
+  ~ReanimatedUIManagerBinding();
+
+  void invalidate() const;
+
+  jsi::Value get(jsi::Runtime &runtime, jsi::PropNameID const &name) override;
+
+ private:
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/headers/Fabric/ShadowTreeCloner.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <set>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ShadowTreeCloner {
+ public:
+  ShadowTreeCloner(
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+      std::shared_ptr<UIManager> uiManager,
+      SurfaceId surfaceId);
+
+  ~ShadowTreeCloner();
+
+  ShadowNode::Unshared cloneWithNewProps(
+      const ShadowNode::Shared &oldRootNode,
+      const ShadowNodeFamily &family,
+      RawProps &&rawProps);
+
+  void updateYogaChildren();
+
+ private:
+  PropsParserContext propsParserContext_;
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+  std::set<ShadowNode *> yogaChildrenUpdates_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/headers/NativeModules/NativeReanimatedModule.h

@@ -1,8 +1,14 @@
 #pragma once
 
-#include <unistd.h>
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/UIManager.h>
+#include "NewestShadowNodesRegistry.h"
+#endif
+
 #include <memory>
 #include <string>
+#include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "AnimatedSensorModule.h"
@@ -34,8 +40,12 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       std::shared_ptr<Scheduler> scheduler,
       std::shared_ptr<jsi::Runtime> rt,
       std::shared_ptr<ErrorHandler> errorHandler,
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
       std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
           propObtainer,
+#endif
       std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
       PlatformDepMethodsHolder platformDepMethodsHolder);
 
@@ -77,11 +87,48 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       const jsi::Value &nativeProps) override;
 
   void onRender(double timestampMs);
+#ifdef RCT_NEW_ARCH_ENABLED
+  void onEvent(std::string eventName, jsi::Value &&eventAsString);
+#else
   void onEvent(std::string eventName, std::string eventAsString);
+#endif
   bool isAnyHandlerWaitingForEvent(std::string eventName);
 
   void maybeRequestRender();
-  UpdaterFunction updaterFunction;
+  UpdatePropsFunction updatePropsFunction;
+
+  bool handleEvent(
+      const std::string &eventName,
+      jsi::Value &&payload,
+      double currentTime);
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  bool handleRawEvent(const RawEvent &rawEvent, double currentTime);
+
+  void updateProps(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeValue,
+      const jsi::Value &props);
+
+  void removeShadowNodeFromRegistry(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeValue);
+
+  void performOperations();
+
+  void dispatchCommand(
+      jsi::Runtime &rt,
+      const jsi::Value &shadowNodeValue,
+      const jsi::Value &commandNameValue,
+      const jsi::Value &argsValue);
+
+  jsi::Value measure(jsi::Runtime &rt, const jsi::Value &shadowNodeValue);
+
+  void setUIManager(std::shared_ptr<UIManager> uiManager);
+
+  void setNewestShadowNodesRegistry(
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry);
+#endif
 
   jsi::Value registerSensor(
       jsi::Runtime &rt,
@@ -89,8 +136,18 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       const jsi::Value &interval,
       const jsi::Value &sensorDataContainer) override;
   void unregisterSensor(jsi::Runtime &rt, const jsi::Value &sensorId) override;
+  jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer) override;
+  void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) override;
 
  private:
+#ifdef RCT_NEW_ARCH_ENABLED
+  bool isThereAnyLayoutProp(jsi::Runtime &rt, const jsi::Value &props);
+#endif // RCT_NEW_ARCH_ENABLED
+
   std::shared_ptr<MapperRegistry> mapperRegistry;
   std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
   std::function<void(FrameCallback &, jsi::Runtime &)> requestRender;
@@ -103,6 +160,28 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy;
   AnimatedSensorModule animatedSensorModule;
   ConfigurePropsFunction configurePropsPlatformFunction;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  SynchronouslyUpdateUIPropsFunction synchronouslyUpdateUIPropsFunction;
+
+  std::shared_ptr<UIManager> uiManager_;
+
+  // After app reload, surfaceId on iOS is still 1 but on Android it's 11.
+  // We can store surfaceId of the most recent ShadowNode as a workaround.
+  SurfaceId surfaceId_ = -1;
+
+  std::vector<std::pair<ShadowNode::Shared, std::unique_ptr<jsi::Value>>>
+      operationsInBatch_; // TODO: refactor std::pair to custom struct
+
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+
+  std::vector<Tag> tagsToRemove_; // from newestShadowNodesRegistry_
+#endif
+
+  std::unordered_set<std::string> nativePropNames_; // filled by configureProps
+
+  KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction;
+  KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction;
 };
 
 } // namespace reanimated

package/Common/cpp/headers/NativeModules/NativeReanimatedModuleSpec.h

@@ -69,6 +69,14 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       jsi::Runtime &rt,
       const jsi::Value &sensorId) = 0;
 
+  // keyboard
+  virtual jsi::Value subscribeForKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &keyboardEventContainer) = 0;
+  virtual void unsubscribeFromKeyboardEvents(
+      jsi::Runtime &rt,
+      const jsi::Value &listenerId) = 0;
+
   // other
   virtual jsi::Value enableLayoutAnimations(
       jsi::Runtime &rt,

package/Common/cpp/headers/Registries/EventHandlerRegistry.h

@@ -27,10 +27,18 @@ class EventHandlerRegistry {
   void registerEventHandler(std::shared_ptr<WorkletEventHandler> eventHandler);
   void unregisterEventHandler(unsigned long id);
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  void processEvent(
+      jsi::Runtime &rt,
+      std::string eventName,
+      jsi::Value &eventPayload);
+#else
   void processEvent(
       jsi::Runtime &rt,
       std::string eventName,
       std::string eventPayload);
+#endif
+
   bool isAnyHandlerWaitingForEvent(std::string eventName);
 };
 

package/Common/cpp/headers/Registries/NewestShadowNodesRegistry.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/ShadowNode.h>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+class NewestShadowNodesRegistry {
+ public:
+  std::lock_guard<std::mutex> createLock() const;
+  // returns a lock you need to hold when calling any of the methods below
+
+  void set(ShadowNode::Shared shadowNode, Tag parentTag);
+  // updates ShadowNode and sets parent tag, to be called from Reanimated
+
+  bool has(const ShadowNode::Shared &shadowNode) const;
+  // checks if ShadowNode exists in the registry
+
+  ShadowNode::Shared get(Tag tag) const;
+  // returns the most recent version of ShadowNode or nullptr if not found
+
+  void update(ShadowNode::Shared shadowNode);
+  // updates ShadowNode that already exists in registry, to be called from RN
+
+  void remove(Tag tag);
+  // removes ShadowNode from map along with its ancestors
+
+ private:
+  std::unordered_map<Tag, std::pair<ShadowNode::Shared, Tag>> map_;
+  // tag -> (most recent clone of shadow node, parent tag)
+  mutable std::mutex mutex_; // Protects `map_`.
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/headers/SharedItems/SharedParent.h

@@ -17,6 +17,9 @@ enum class ValueType {
   WorkletFunctionType, // function that gets run on the UI thread
   FrozenObjectType, // frozen object, can only be set and never modified
   FrozenArrayType, // frozen array, can only be set and never modified
+#ifdef RCT_NEW_ARCH_ENABLED
+  ShadowNodeType, // ShadowNode::Shared
+#endif // RCT_NEW_ARCH_ENABLED
 };
 
 class ShareableValue;

package/Common/cpp/headers/SharedItems/ValueWrapper.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/core/ShadowNode.h>
+#endif
 #include <memory>
 #include <string>
 #include <vector>
@@ -9,6 +12,8 @@
 #include "SharedParent.h"
 #include "WorkletsCache.h"
 
+using namespace facebook::react;
+
 namespace reanimated {
 
 class HostFunctionWrapper;
@@ -42,6 +47,10 @@ class ValueWrapper {
       const std::unique_ptr<ValueWrapper> &valueContainer);
   static inline const std::shared_ptr<MutableValue> &asMutableValue(
       const std::unique_ptr<ValueWrapper> &valueContainer);
+#ifdef RCT_NEW_ARCH_ENABLED
+  static inline const ShadowNode::Shared &asShadowNode(
+      const std::unique_ptr<ValueWrapper> &valueContainer);
+#endif
 
   static const HostFunctionWrapper *asHostFunctionWrapper(
       const std::unique_ptr<ValueWrapper> &valueContainer);
@@ -109,6 +118,15 @@ class MutableValueWrapper : public ValueWrapper {
   std::shared_ptr<MutableValue> value;
 };
 
+#ifdef RCT_NEW_ARCH_ENABLED
+class ShadowNodeValueWrapper : public ValueWrapper {
+ public:
+  explicit ShadowNodeValueWrapper(const ShadowNode::Shared &_value)
+      : ValueWrapper(ValueType::ShadowNodeType), value(_value) {}
+  ShadowNode::Shared value;
+};
+#endif
+
 inline bool ValueWrapper::asBoolean(
     const std::unique_ptr<ValueWrapper> &valueContainer) {
   return static_cast<BooleanValueWrapper *>(valueContainer.get())->value;
@@ -150,6 +168,13 @@ inline const std::shared_ptr<MutableValue> &ValueWrapper::asMutableValue(
   return static_cast<MutableValueWrapper *>(valueContainer.get())->value;
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+inline const ShadowNode::Shared &ValueWrapper::asShadowNode(
+    const std::unique_ptr<ValueWrapper> &valueContainer) {
+  return static_cast<ShadowNodeValueWrapper *>(valueContainer.get())->value;
+}
+#endif
+
 inline const HostFunctionWrapper *ValueWrapper::asHostFunctionWrapper(
     const std::unique_ptr<ValueWrapper> &valueContainer) {
   return static_cast<HostFunctionWrapper *>(valueContainer.get());

package/Common/cpp/headers/SpecTools/ErrorHandler.h

@@ -2,7 +2,12 @@
 
 #include <memory>
 #include <string>
+
+#ifdef __APPLE__
+#include "RNReanimated/Scheduler.h"
+#else
 #include "Scheduler.h"
+#endif
 
 namespace reanimated {
 

package/Common/cpp/headers/Tools/Mapper.h

@@ -29,7 +29,7 @@ class Mapper : public std::enable_shared_from_this<Mapper> {
   std::vector<std::shared_ptr<MutableValue>> outputs;
   bool dirty = true;
   std::shared_ptr<jsi::Function> userUpdater;
-  UpdaterFunction *updateProps;
+  UpdatePropsFunction updateProps;
   int optimalizationLvl = 0;
   std::shared_ptr<ShareableValue> viewDescriptors;