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

package/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -25,7 +25,12 @@ void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
 void EventHandlerRegistry::processEvent(
     jsi::Runtime &rt,
     std::string eventName,
-    std::string eventPayload) {
+#ifdef RCT_NEW_ARCH_ENABLED
+    jsi::Value &eventPayload
+#else
+    std::string eventPayload
+#endif
+    /**/) {
   std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
   {
     const std::lock_guard<std::mutex> lock(instanceMutex);
@@ -36,6 +41,13 @@ void EventHandlerRegistry::processEvent(
       }
     }
   }
+#ifdef RCT_NEW_ARCH_ENABLED
+  eventPayload.asObject(rt).setProperty(
+      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  for (auto handler : handlersForEvent) {
+    handler->process(rt, eventPayload);
+  }
+#else
   // We receive here a JS Map with JSON as a value of NativeMap key
   // { NativeMap: { "jsonProp": "json value" } }
   // So we need to extract only JSON part
@@ -57,6 +69,7 @@ void EventHandlerRegistry::processEvent(
   for (auto handler : handlersForEvent) {
     handler->process(rt, eventObject);
   }
+#endif
 }
 
 bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {

package/Common/cpp/Registries/NewestShadowNodesRegistry.cpp

@@ -0,0 +1,68 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "NewestShadowNodesRegistry.h"
+
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+void NewestShadowNodesRegistry::set(
+    ShadowNode::Shared shadowNode,
+    Tag parentTag) {
+  map_[shadowNode->getTag()] = std::make_pair(shadowNode, parentTag);
+}
+
+bool NewestShadowNodesRegistry::has(
+    const ShadowNode::Shared &shadowNode) const {
+  return map_.find(shadowNode->getTag()) != map_.cend();
+}
+
+ShadowNode::Shared NewestShadowNodesRegistry::get(Tag tag) const {
+  const auto it = map_.find(tag);
+  return it != map_.cend() ? it->second.first : nullptr;
+}
+
+void NewestShadowNodesRegistry::update(ShadowNode::Shared shadowNode) {
+  const auto it = map_.find(shadowNode->getTag());
+  react_native_assert(it != map_.cend());
+  it->second.first = shadowNode;
+}
+
+void NewestShadowNodesRegistry::remove(Tag tag) {
+  if (map_.find(tag) == map_.cend()) {
+    return;
+  }
+
+  auto shadowNode = map_[tag].first;
+
+  while (shadowNode != nullptr) {
+    bool hasAnyChildInMap = false;
+    for (const auto &child : shadowNode->getChildren()) {
+      if (has(child)) {
+        hasAnyChildInMap = true;
+        break;
+      }
+    }
+
+    if (hasAnyChildInMap) {
+      break;
+    }
+
+    auto it = map_.find(shadowNode->getTag());
+    Tag parentTag = it->second.second;
+    map_.erase(it);
+
+    shadowNode = map_[parentTag].first;
+  }
+}
+
+std::lock_guard<std::mutex> NewestShadowNodesRegistry::createLock() const {
+  return std::lock_guard<std::mutex>(mutex_);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/SharedItems/ShareableValue.cpp

@@ -1,4 +1,9 @@
 #include <cxxabi.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/primitives.h>
+#endif
+
 #include "FrozenObject.h"
 #include "MutableValue.h"
 #include "MutableValueSetterProxy.h"
@@ -157,6 +162,13 @@ void ShareableValue::adapt(
       valueContainer =
           std::make_unique<RemoteObjectWrapper>(std::make_shared<RemoteObject>(
               rt, object, runtimeManager, runtimeManager->scheduler));
+#ifdef RCT_NEW_ARCH_ENABLED
+    } else if (object.isHostObject<ShadowNodeWrapper>(rt)) {
+      type = ValueType::ShadowNodeType;
+      auto shadowNode = object.getHostObject<ShadowNodeWrapper>(rt)->shadowNode;
+      valueContainer = std::make_unique<ShadowNodeValueWrapper>(shadowNode);
+      adaptCache(rt, value);
+#endif
     } else {
       // create frozen object based on a copy of a given object
       type = ValueType::FrozenObjectType;
@@ -278,6 +290,12 @@ jsi::Value ShareableValue::toJSValue(jsi::Runtime &rt) {
       auto &mutableObject = ValueWrapper::asMutableValue(valueContainer);
       return createHost(rt, mutableObject);
     }
+#ifdef RCT_NEW_ARCH_ENABLED
+    case ValueType::ShadowNodeType: {
+      auto &shadowNode = ValueWrapper::asShadowNode(valueContainer);
+      return createHost(rt, std::make_shared<ShadowNodeWrapper>(shadowNode));
+    }
+#endif
     case ValueType::HostFunctionType: {
       auto hostFunctionWrapper =
           ValueWrapper::asHostFunctionWrapper(valueContainer);

package/Common/cpp/Tools/Mapper.cpp

@@ -25,7 +25,11 @@ void Mapper::execute(jsi::Runtime &rt) {
   if (optimalizationLvl == 0) {
     mapper->callWithThis(rt, *mapper); // call styleUpdater
   } else {
+#ifdef RCT_NEW_ARCH_ENABLED
+    jsi::Value newStyle = userUpdater->call(rt).asObject(rt);
+#else
     jsi::Object newStyle = userUpdater->call(rt).asObject(rt);
+#endif
     auto jsViewDescriptorArray = viewDescriptors->getValue(rt)
                                      .getObject(rt)
                                      .getProperty(rt, "value")
@@ -34,11 +38,16 @@ void Mapper::execute(jsi::Runtime &rt) {
     for (int i = 0; i < jsViewDescriptorArray.length(rt); ++i) {
       auto jsViewDescriptor =
           jsViewDescriptorArray.getValueAtIndex(rt, i).getObject(rt);
-      (*updateProps)(
+#ifdef RCT_NEW_ARCH_ENABLED
+      updateProps(
+          rt, jsViewDescriptor.getProperty(rt, "shadowNodeWrapper"), newStyle);
+#else
+      updateProps(
           rt,
           static_cast<int>(jsViewDescriptor.getProperty(rt, "tag").asNumber()),
           jsViewDescriptor.getProperty(rt, "name"),
           newStyle);
+#endif
     }
   }
 }
@@ -52,10 +61,20 @@ void Mapper::enableFastMode(
   }
   viewDescriptors = jsViewDescriptors;
   this->optimalizationLvl = optimalizationLvl;
-  updateProps = &module->updaterFunction;
-  jsi::Runtime *rt = module->runtime.get();
+#ifdef RCT_NEW_ARCH_ENABLED
+  updateProps = [this](
+                    jsi::Runtime &rt,
+                    const jsi::Value &shadowNodeValue,
+                    const jsi::Value &props) {
+    this->module->updateProps(rt, shadowNodeValue, props);
+  };
+#else
+  // TODO: don't get public field, instead call this->module->updateProps
+  updateProps = module->updatePropsFunction;
+#endif
+  jsi::Runtime &rt = *module->runtime;
   userUpdater = std::make_shared<jsi::Function>(
-      updater->getValue(*rt).asObject(*rt).asFunction(*rt));
+      updater->getValue(rt).asObject(rt).asFunction(rt));
 }
 
 Mapper::~Mapper() {

package/Common/cpp/Tools/RuntimeDecorator.cpp

@@ -90,10 +90,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,
@@ -102,42 +107,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();
@@ -146,14 +188,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);
@@ -162,10 +204,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,78 @@
+#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_;
+};
+
+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);
+
+SharedShadowNode UIManager_cloneNode(
+    const UIManager *uiManager,
+    const ShadowNode::Shared &shadowNode,
+    const SharedShadowNodeSharedList &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,46 @@
+#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::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/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,
@@ -91,6 +138,10 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
   void unregisterSensor(jsi::Runtime &rt, const jsi::Value &sensorId) 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 +154,25 @@ 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
 };
 
 } // namespace reanimated

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;