react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -50,15 +50,8 @@ UIManager::UIManager(
       contextContainer_(std::move(contextContainer)),
       leakChecker_(constructLeakCheckerIfNeeded(runtimeExecutor)),
       lazyShadowTreeRevisionConsistencyManager_(
-          ReactNativeFeatureFlags::enableUIConsistency()
-              ? std::make_unique<LazyShadowTreeRevisionConsistencyManager>(
-                    shadowTreeRegistry_)
-              : nullptr),
-      latestShadowTreeRevisionProvider_(
-          ReactNativeFeatureFlags::enableUIConsistency()
-              ? nullptr
-              : std::make_unique<LatestShadowTreeRevisionProvider>(
-                    shadowTreeRegistry_)) {}
+          std::make_unique<LazyShadowTreeRevisionConsistencyManager>(
+              shadowTreeRegistry_)) {}
 
 UIManager::~UIManager() {
   LOG(WARNING) << "UIManager::~UIManager() was called (address: " << this
@@ -205,8 +198,7 @@ void UIManager::completeSurface(
         },
         commitOptions);
 
-    if (result == ShadowTree::CommitStatus::Succeeded &&
-        lazyShadowTreeRevisionConsistencyManager_ != nullptr) {
+    if (result == ShadowTree::CommitStatus::Succeeded) {
       // It's safe to update the visible revision of the shadow tree immediately
       // after we commit a specific one.
       lazyShadowTreeRevisionConsistencyManager_->updateCurrentRevision(
@@ -235,6 +227,13 @@ void UIManager::startSurface(
   auto surfaceId = shadowTree->getSurfaceId();
   shadowTreeRegistry_.add(std::move(shadowTree));
 
+  shadowTreeRegistry_.visit(
+      surfaceId, [delegate = delegate_](const ShadowTree& shadowTree) {
+        if (delegate != nullptr) {
+          delegate->uiManagerDidStartSurface(shadowTree);
+        }
+      });
+
   runtimeExecutor_([=](jsi::Runtime& runtime) {
     TraceSection s("UIManager::startSurface::onRuntime");
     AppRegistryBinding::startSurface(
@@ -325,16 +324,7 @@ UIManager::getShadowTreeRevisionConsistencyManager() {
 }
 
 ShadowTreeRevisionProvider* UIManager::getShadowTreeRevisionProvider() {
-  if (lazyShadowTreeRevisionConsistencyManager_ != nullptr) {
-    return lazyShadowTreeRevisionConsistencyManager_.get();
-  } else if (latestShadowTreeRevisionProvider_ != nullptr) {
-    return latestShadowTreeRevisionProvider_.get();
-  }
-
-  LOG(ERROR) << "Unexpected state found in UIManager where both "
-             << "lazyShadowTreeRevisionConsistencyManager_ and "
-             << "latestShadowTreeRevisionProvider_ were null";
-  return nullptr;
+  return lazyShadowTreeRevisionConsistencyManager_.get();
 }
 
 ShadowNode::Shared UIManager::findNodeAtPoint(
@@ -619,7 +609,8 @@ void UIManager::unregisterMountHook(UIManagerMountHook& mountHook) {
 RootShadowNode::Unshared UIManager::shadowTreeWillCommit(
     const ShadowTree& shadowTree,
     const RootShadowNode::Shared& oldRootShadowNode,
-    const RootShadowNode::Unshared& newRootShadowNode) const {
+    const RootShadowNode::Unshared& newRootShadowNode,
+    const ShadowTree::CommitOptions& commitOptions) const {
   TraceSection s("UIManager::shadowTreeWillCommit");
 
   std::shared_lock lock(commitHookMutex_);
@@ -627,7 +618,7 @@ RootShadowNode::Unshared UIManager::shadowTreeWillCommit(
   auto resultRootShadowNode = newRootShadowNode;
   for (auto* commitHook : commitHooks_) {
     resultRootShadowNode = commitHook->shadowTreeWillCommit(
-        shadowTree, oldRootShadowNode, resultRootShadowNode);
+        shadowTree, oldRootShadowNode, resultRootShadowNode, commitOptions);
   }
 
   return resultRootShadowNode;
@@ -680,6 +671,11 @@ void UIManager::stopSurfaceForAnimationDelegate(SurfaceId surfaceId) const {
   }
 }
 
+void UIManager::setNativeAnimatedDelegate(
+    std::weak_ptr<UIManagerNativeAnimatedDelegate> delegate) {
+  nativeAnimatedDelegate_ = delegate;
+}
+
 void UIManager::animationTick() const {
   if (animationDelegate_ != nullptr &&
       animationDelegate_->shouldAnimateFrame()) {
@@ -687,6 +683,41 @@ void UIManager::animationTick() const {
       shadowTree.notifyDelegatesOfUpdates();
     });
   }
+
+  if (auto nativeAnimatedDelegate = nativeAnimatedDelegate_.lock()) {
+    nativeAnimatedDelegate->runAnimationFrame();
+  }
+}
+
+void UIManager::synchronouslyUpdateViewOnUIThread(
+    Tag tag,
+    const folly::dynamic& props) {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerShouldSynchronouslyUpdateViewOnUIThread(tag, props);
+  }
+}
+
+#pragma mark - Add & Remove event listener
+
+void UIManager::addEventListener(
+    std::shared_ptr<const EventListener> listener) {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerShouldAddEventListener(listener);
+  }
+}
+
+void UIManager::removeEventListener(
+    const std::shared_ptr<const EventListener>& listener) {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerShouldRemoveEventListener(listener);
+  }
+}
+
+void UIManager::setOnSurfaceStartCallback(
+    UIManagerDelegate::OnSurfaceStartCallback&& callback) {
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerShouldSetOnSurfaceStartCallback(std::move(callback));
+  }
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -25,7 +25,7 @@
 #include <react/renderer/mounting/ShadowTreeRegistry.h>
 #include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 #include <react/renderer/uimanager/UIManagerDelegate.h>
-#include <react/renderer/uimanager/consistency/LatestShadowTreeRevisionProvider.h>
+#include <react/renderer/uimanager/UIManagerNativeAnimatedDelegate.h>
 #include <react/renderer/uimanager/consistency/LazyShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/uimanager/consistency/ShadowTreeRevisionProvider.h>
 #include <react/renderer/uimanager/primitives.h>
@@ -68,8 +68,13 @@ class UIManager final : public ShadowTreeDelegate {
    */
   void stopSurfaceForAnimationDelegate(SurfaceId surfaceId) const;
 
+  void setNativeAnimatedDelegate(
+      std::weak_ptr<UIManagerNativeAnimatedDelegate> delegate);
+
   void animationTick() const;
 
+  void synchronouslyUpdateViewOnUIThread(Tag tag, const folly::dynamic& props);
+
   /*
    * Provides access to a UIManagerBindging.
    * The `callback` methods will not be called if the internal pointer to
@@ -127,7 +132,8 @@ class UIManager final : public ShadowTreeDelegate {
   RootShadowNode::Unshared shadowTreeWillCommit(
       const ShadowTree& shadowTree,
       const RootShadowNode::Shared& oldRootShadowNode,
-      const RootShadowNode::Unshared& newRootShadowNode) const override;
+      const RootShadowNode::Unshared& newRootShadowNode,
+      const ShadowTree::CommitOptions& commitOptions) const override;
 
   std::shared_ptr<ShadowNode> createNode(
       Tag tag,
@@ -190,9 +196,9 @@ class UIManager final : public ShadowTreeDelegate {
 
   /*
    * Iterates over all shadow nodes which are parts of all registered surfaces
-   * and find the one that has given `tag`. Returns `nullptr` if the node wasn't
-   * found. This is a temporary workaround that should not be used in any core
-   * functionality.
+   * and find the one that has given `tag`. Returns `nullptr` if the node
+   * wasn't found. This is a temporary workaround that should not be used in
+   * any core functionality.
    */
   ShadowNode::Shared findShadowNodeByTag_DEPRECATED(Tag tag) const;
 
@@ -200,6 +206,20 @@ class UIManager final : public ShadowTreeDelegate {
 
   void reportMount(SurfaceId surfaceId) const;
 
+  void updateShadowTree(
+      const std::unordered_map<Tag, folly::dynamic>& tagToProps);
+
+#pragma mark - Add & Remove event listener
+
+  void addEventListener(std::shared_ptr<const EventListener> listener);
+
+  void removeEventListener(
+      const std::shared_ptr<const EventListener>& listener);
+
+#pragma mark - Set on surface start callback
+  void setOnSurfaceStartCallback(
+      UIManagerDelegate::OnSurfaceStartCallback&& callback);
+
  private:
   friend class UIManagerBinding;
   friend class Scheduler;
@@ -222,6 +242,8 @@ class UIManager final : public ShadowTreeDelegate {
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   UIManagerDelegate* delegate_{};
   UIManagerAnimationDelegate* animationDelegate_{nullptr};
+  std::weak_ptr<UIManagerNativeAnimatedDelegate> nativeAnimatedDelegate_;
+
   const RuntimeExecutor runtimeExecutor_{};
   ShadowTreeRegistry shadowTreeRegistry_{};
   ContextContainer::Shared contextContainer_;
@@ -236,8 +258,6 @@ class UIManager final : public ShadowTreeDelegate {
 
   std::unique_ptr<LazyShadowTreeRevisionConsistencyManager>
       lazyShadowTreeRevisionConsistencyManager_;
-  std::unique_ptr<LatestShadowTreeRevisionProvider>
-      latestShadowTreeRevisionProvider_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.cpp

@@ -454,7 +454,9 @@ jsi::Value UIManagerBinding::get(
           uiManager->completeSurface(
               surfaceId,
               shadowNodeList,
-              {.enableStateReconciliation = true, .mountSynchronously = false});
+              {.enableStateReconciliation = true,
+               .mountSynchronously = false,
+               .source = ShadowTree::CommitSource::React});
 
           return jsi::Value::undefined();
         });
@@ -745,6 +747,14 @@ jsi::Value UIManagerBinding::get(
     return {serialize(ReactEventPriority::Discrete)};
   }
 
+  if (methodName == "unstable_ContinuousEventPriority") {
+    return {serialize(ReactEventPriority::Continuous)};
+  }
+
+  if (methodName == "unstable_IdleEventPriority") {
+    return {serialize(ReactEventPriority::Idle)};
+  }
+
   if (methodName == "findShadowNodeByTag_DEPRECATED") {
     auto paramCount = 1;
     return jsi::Function::createFromHostFunction(

package/ReactCommon/react/renderer/uimanager/UIManagerCommitHook.h

@@ -12,6 +12,7 @@
 namespace facebook::react {
 
 class ShadowTree;
+struct ShadowTreeCommitOptions;
 class UIManager;
 
 /*
@@ -34,7 +35,24 @@ class UIManagerCommitHook {
   virtual RootShadowNode::Unshared shadowTreeWillCommit(
       const ShadowTree& shadowTree,
       const RootShadowNode::Shared& oldRootShadowNode,
-      const RootShadowNode::Unshared& newRootShadowNode) noexcept = 0;
+      const RootShadowNode::Unshared& newRootShadowNode,
+      const ShadowTreeCommitOptions& /*commitOptions*/) noexcept {
+    return shadowTreeWillCommit(
+        shadowTree, oldRootShadowNode, newRootShadowNode);
+  }
+
+  /*
+   * This is a version of `shadowTreeWillCommit` without `commitOptions` for
+   * backward compatibility.
+   */
+  virtual RootShadowNode::Unshared shadowTreeWillCommit(
+      const ShadowTree& /*shadowTree*/,
+      const RootShadowNode::Shared& /*oldRootShadowNode*/,
+      const RootShadowNode::Unshared& newRootShadowNode) noexcept {
+    // No longer a pure method as subclasses are expected to implement the other
+    // flavor instead.
+    return newRootShadowNode;
+  }
 
   virtual ~UIManagerCommitHook() noexcept = default;
 };

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -10,6 +10,7 @@
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/mounting/MountingCoordinator.h>
+#include <react/renderer/mounting/ShadowTree.h>
 
 namespace facebook::react {
 
@@ -58,6 +59,35 @@ class UIManagerDelegate {
       bool isJSResponder,
       bool blockNativeResponder) = 0;
 
+  /*
+   * Synchronous view update.
+   */
+  virtual void uiManagerShouldSynchronouslyUpdateViewOnUIThread(
+      Tag tag,
+      const folly::dynamic& props) = 0;
+
+  /*
+   * Add event listener.
+   */
+  virtual void uiManagerShouldAddEventListener(
+      std::shared_ptr<const EventListener> listener) = 0;
+
+  /*
+   * Remove event listener.
+   */
+  virtual void uiManagerShouldRemoveEventListener(
+      const std::shared_ptr<const EventListener>& listener) = 0;
+
+  /*
+   * Start surface.
+   */
+  virtual void uiManagerDidStartSurface(const ShadowTree& shadowTree) = 0;
+
+  using OnSurfaceStartCallback =
+      std::function<void(const ShadowTree& shadowTree)>;
+  virtual void uiManagerShouldSetOnSurfaceStartCallback(
+      OnSurfaceStartCallback&& callback) = 0;
+
   virtual ~UIManagerDelegate() noexcept = default;
 };
 

package/ReactCommon/react/renderer/uimanager/UIManagerNativeAnimatedDelegate.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/core/RawValue.h>
+
+namespace facebook::react {
+
+class UIManagerNativeAnimatedDelegate {
+ public:
+  virtual ~UIManagerNativeAnimatedDelegate() = default;
+
+  virtual void runAnimationFrame() = 0;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManagerUpdateShadowTree.cpp

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "UIManager.h"
+
+#include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <deque>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <vector>
+
+namespace facebook::react {
+
+namespace {
+
+struct ShadowNodeUpdateInfo {
+  Tag tag;
+  int depth;
+  std::weak_ptr<const ShadowNode> node;
+  // populate for node that needs props update
+  std::optional<folly::dynamic> changedProps;
+  // populate for node that's also a ancestor node for updated nodes
+  std::vector<int> updatedChildrenIndices{};
+};
+
+void addAncestorsToUpdateList(
+    std::shared_ptr<const ShadowNode>& shadowNode,
+    std::shared_ptr<const RootShadowNode>& rootShadowNode,
+    std::vector<ShadowNodeUpdateInfo>& shadowNodesToUpdate) {
+  // list of ancestors from root ShadowNode to current ShadowNode's parent
+  auto ancestors = shadowNode->getFamily().getAncestors(*rootShadowNode);
+
+  std::vector<std::shared_ptr<const ShadowNode>> ancestorShadowNodesShared{};
+  ancestorShadowNodesShared.resize(ancestors.size());
+  std::shared_ptr<const ShadowNode> currentShadowNode = rootShadowNode;
+  auto ancestorIndex = 0;
+  while (!currentShadowNode->getChildren().empty() &&
+         currentShadowNode->getTag() != shadowNode->getTag()) {
+    ancestorShadowNodesShared[ancestorIndex] = currentShadowNode;
+    auto children = currentShadowNode->getChildren();
+    auto childIndex = ancestors[ancestorIndex].second;
+    currentShadowNode = children[childIndex];
+    ancestorIndex++;
+  }
+
+  int ancestorDepth = static_cast<int>(ancestors.size() - 1);
+  // iterate from current ShadowNode's parent to root ShadowNode
+  for (auto iter = ancestors.rbegin(); iter != ancestors.rend(); ++iter) {
+    auto& ancestorShadowNode = iter->first.get();
+    auto ancestorTag = ancestorShadowNode.getTag();
+    auto ancestorAddedToUpdateList = std::find_if(
+        shadowNodesToUpdate.begin(),
+        shadowNodesToUpdate.end(),
+        [ancestorTag](const auto& elem) { return elem.tag == ancestorTag; });
+    if (ancestorAddedToUpdateList == shadowNodesToUpdate.end()) {
+      react_native_assert(
+          ancestorShadowNodesShared[ancestorDepth]->getTag() ==
+          ancestorShadowNode.getTag());
+      shadowNodesToUpdate.push_back({
+          .tag = ancestorShadowNode.getTag(),
+          .depth = ancestorDepth,
+          .node = ancestorShadowNodesShared[ancestorDepth],
+          .updatedChildrenIndices = {iter->second},
+      });
+    } else {
+      ancestorAddedToUpdateList->updatedChildrenIndices.push_back(iter->second);
+    }
+    ancestorDepth--;
+  }
+}
+
+} // namespace
+
+/* Commit a map of ShadowNode props to ShadowTree, with guarantee that each
+ * ShadowNode is cloned only once in the commit.
+ * The tree cloning algorithm is inspired by `cloneShadowTreeWithNewProps` in
+ * https://github.com/software-mansion/react-native-reanimated/ (under MIT
+ * license).
+ */
+void UIManager::updateShadowTree(
+    const std::unordered_map<Tag, folly::dynamic>& tagToProps) {
+  const auto& contextContainer = *contextContainer_;
+
+  std::unordered_map<Tag, folly::dynamic> remainingTagToProps = tagToProps;
+  getShadowTreeRegistry().enumerate([&](const ShadowTree& shadowTree,
+                                        bool& stop) {
+    if (remainingTagToProps.empty()) {
+      stop = true;
+      return;
+    }
+
+    auto rootShadowNode = shadowTree.getCurrentRevision().rootShadowNode;
+    auto surfaceId = rootShadowNode->getSurfaceId();
+    std::vector<ShadowNodeUpdateInfo> shadowNodesToUpdate;
+
+    // Step 1: Create a list of shadow nodes to update
+    // which includes all the ShadowNodes of tags in input map, plus all
+    // their ancestors
+
+    std::deque<std::shared_ptr<const ShadowNode>> deque{rootShadowNode};
+
+    int depth = 0;
+    while (!deque.empty()) {
+      auto size = deque.size();
+      for (auto i = 0; i < size; i++) {
+        auto shadowNode = std::move(deque.front());
+        deque.pop_front();
+
+        if (auto nodesPropsIt = remainingTagToProps.find(shadowNode->getTag());
+            nodesPropsIt != remainingTagToProps.end()) {
+          auto shadowNodeTag = shadowNode->getTag();
+          auto shadowNodeAddedToUpdateList = std::find_if(
+              shadowNodesToUpdate.begin(),
+              shadowNodesToUpdate.end(),
+              [shadowNodeTag](const auto& elem) {
+                return elem.tag == shadowNodeTag;
+              });
+          if (shadowNodeAddedToUpdateList == shadowNodesToUpdate.end()) {
+            shadowNodesToUpdate.push_back(
+                {.tag = shadowNodeTag,
+                 .depth = depth,
+                 .node = shadowNode,
+                 .changedProps = nodesPropsIt->second});
+          } else {
+            shadowNodeAddedToUpdateList->changedProps = nodesPropsIt->second;
+          }
+          remainingTagToProps.erase(nodesPropsIt->first);
+
+          // Add all its ancestors to shadowNodesToUpdate list
+          addAncestorsToUpdateList(
+              shadowNode, rootShadowNode, shadowNodesToUpdate);
+        }
+        for (const auto& child : shadowNode->getChildren()) {
+          deque.push_back(child);
+        }
+      }
+      depth++;
+    }
+
+    if (shadowNodesToUpdate.empty()) {
+      return;
+    }
+
+    // Step 2: Clone nodes from children to ancestors
+
+    std::sort(
+        shadowNodesToUpdate.begin(),
+        shadowNodesToUpdate.end(),
+        [](const auto& a, const auto& b) { return a.depth > b.depth; });
+
+    std::unordered_map<Tag, std::shared_ptr<ShadowNode>> clonedShadowNodes;
+
+    for (auto& nodeUpdateInfo : shadowNodesToUpdate) {
+      if (auto oldShadowNode = nodeUpdateInfo.node.lock()) {
+        Props::Shared newProps;
+        if (nodeUpdateInfo.changedProps) {
+          PropsParserContext propsParserContext{surfaceId, contextContainer};
+          auto componentDescriptor =
+              componentDescriptorRegistry_
+                  ->findComponentDescriptorByHandle_DO_NOT_USE_THIS_IS_BROKEN(
+                      oldShadowNode->getComponentHandle());
+          newProps = componentDescriptor->cloneProps(
+              propsParserContext,
+              oldShadowNode->getProps(),
+              RawProps(nodeUpdateInfo.changedProps.value()));
+        } else {
+          newProps = oldShadowNode->getProps();
+        }
+
+        ShadowNodeFragment fragment;
+        auto children = oldShadowNode->getChildren();
+
+        // If children are previously updated (children should be cloned and
+        // updated before parents), add it to the children list of ShadowNode
+        for (auto& updatedChildIndex : nodeUpdateInfo.updatedChildrenIndices) {
+          if (updatedChildIndex < children.size()) {
+            auto childTag = children[updatedChildIndex]->getTag();
+            auto clonedShadowNodesIt = clonedShadowNodes.find(childTag);
+            if (clonedShadowNodesIt != clonedShadowNodes.end()) {
+              children[updatedChildIndex] = clonedShadowNodesIt->second;
+            } else {
+              LOG(ERROR) << "Child ShadowNode has not been cloned";
+            }
+          } else {
+            LOG(WARNING) << "Child no longer exits";
+          }
+        }
+
+        auto cloned = oldShadowNode->clone(
+            {.props = newProps,
+             .children = std::make_shared<ShadowNode::ListOfShared>(children)});
+        clonedShadowNodes.insert({oldShadowNode->getTag(), std::move(cloned)});
+      } else {
+        LOG(ERROR) << "oldShadowNode is null";
+        continue;
+      }
+    }
+
+    // Step 3: Commit ShadowTree
+
+    if (auto it = clonedShadowNodes.find(rootShadowNode->getTag());
+        it != clonedShadowNodes.end()) {
+      shadowTree.commit(
+          [rootNode =
+               it->second](const RootShadowNode&) -> RootShadowNode::Unshared {
+            return std::static_pointer_cast<RootShadowNode>(rootNode);
+          },
+          {});
+    } else {
+      LOG(ERROR) << "Root ShadowNode has not been cloned";
+    }
+  });
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/consistency/CMakeLists.txt

@@ -6,13 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"Fabric\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB react_renderer_uimanager_consistency_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(react_renderer_uimanager_consistency OBJECT ${react_renderer_uimanager_consistency_SRC})
@@ -24,3 +18,5 @@ target_link_libraries(react_renderer_uimanager_consistency
         rrc_root
         react_renderer_consistency
         react_renderer_mounting)
+target_compile_reactnative_options(react_renderer_uimanager_consistency PRIVATE "Fabric")
+target_compile_options(react_renderer_uimanager_consistency PRIVATE -Wpedantic)

package/ReactCommon/react/renderer/uimanager/consistency/tests/LazyShadowTreeRevisionConsistencyManagerTest.cpp

@@ -19,7 +19,8 @@ class FakeShadowTreeDelegate : public ShadowTreeDelegate {
   RootShadowNode::Unshared shadowTreeWillCommit(
       const ShadowTree& /*shadowTree*/,
       const RootShadowNode::Shared& /*oldRootShadowNode*/,
-      const RootShadowNode::Unshared& newRootShadowNode) const override {
+      const RootShadowNode::Unshared& newRootShadowNode,
+      const ShadowTree::CommitOptions& /*commitOptions*/) const override {
     return newRootShadowNode;
   };
 

package/ReactCommon/react/runtime/CMakeLists.txt

@@ -6,19 +6,16 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
 file(GLOB bridgeless_SRC "*.cpp")
 
 add_library(bridgeless
         OBJECT
         ${bridgeless_SRC}
 )
-target_compile_options(
-        bridgeless
-        PRIVATE
-        $<$<CONFIG:Debug>:-DHERMES_ENABLE_DEBUGGER=1>
-        -std=c++20
-        -fexceptions
-)
+target_compile_reactnative_options(bridgeless PRIVATE)
+target_compile_options(bridgeless PRIVATE $<$<CONFIG:Debug>:-DHERMES_ENABLE_DEBUGGER=1>)
 target_include_directories(bridgeless PUBLIC .)
 
 target_link_libraries(

package/ReactCommon/react/runtime/React-RuntimeCore.podspec

@@ -16,14 +16,6 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-folly_dep_name = folly_config[:dep_name]
-
-boost_config = get_boost_config()
-boost_compiler_flags = boost_config[:compiler_flags] 
-
 Pod::Spec.new do |s|
   s.name                   = "React-RuntimeCore"
   s.version                = version
@@ -36,32 +28,31 @@ Pod::Spec.new do |s|
   s.source_files           = "*.{cpp,h}", "nativeviewconfig/*.{cpp,h}"
   s.exclude_files          = "iostests/*", "tests/**/*.{cpp,h}"
   s.header_dir             = "react/runtime"
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/Headers/Private/React-Core\" \"${PODS_TARGET_SRCROOT}/../..\"",
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/Headers/Private/React-Core\" \"${PODS_TARGET_SRCROOT}/../..\"",
                                 "USE_HEADERMAP" => "YES",
                                 "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
-  s.compiler_flags       = folly_compiler_flags + ' ' + boost_compiler_flags
 
   if ENV['USE_FRAMEWORKS']
     s.header_mappings_dir     = '../../'
     s.module_name             = 'React_RuntimeCore'
   end
 
-  s.dependency folly_dep_name, folly_version
   s.dependency "React-jsiexecutor"
   s.dependency "React-cxxreact"
   s.dependency "React-runtimeexecutor"
-  s.dependency "glog"
   s.dependency "React-jsi"
   s.dependency "React-jserrorhandler"
   s.dependency "React-performancetimeline"
   s.dependency "React-runtimescheduler"
   s.dependency "React-utils"
   s.dependency "React-featureflags"
-  
+
   add_dependency(s, "React-Fabric")
 
   depend_on_js_engine(s)
+  add_rn_third_party_dependencies(s)
+
   s.dependency "React-jsinspector"
   add_dependency(s, "React-jsitooling", :framework_name => "JSITooling")
 end