react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -6,11 +6,12 @@
  */
 
 #include "YogaLayoutableShadowNode.h"
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <logger/react_native_log.h>
 #include <react/debug/flags.h>
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/components/view/LayoutConformanceShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/ViewShadowNode.h>
 #include <react/renderer/components/view/conversions.h>
@@ -501,15 +502,13 @@ void YogaLayoutableShadowNode::configureYogaTree(
 }
 
 YGErrata YogaLayoutableShadowNode::resolveErrata(YGErrata defaultErrata) const {
-  if (auto viewShadowNode = dynamic_cast<const ViewShadowNode*>(this)) {
-    const auto& props = viewShadowNode->getConcreteProps();
-    switch (props.experimental_layoutConformance) {
-      case LayoutConformance::Classic:
-        return YGErrataAll;
+  if (auto layoutConformanceNode =
+          dynamic_cast<const LayoutConformanceShadowNode*>(this)) {
+    switch (layoutConformanceNode->getConcreteProps().mode) {
       case LayoutConformance::Strict:
         return YGErrataNone;
-      case LayoutConformance::Undefined:
-        return defaultErrata;
+      case LayoutConformance::Compatibility:
+        return YGErrataAll;
     }
   }
 
@@ -538,9 +537,9 @@ void YogaLayoutableShadowNode::setSize(Size size) const {
 
   auto style = yogaNode_.style();
   style.setDimension(
-      yoga::Dimension::Width, yoga::StyleLength::points(size.width));
+      yoga::Dimension::Width, yoga::StyleSizeLength::points(size.width));
   style.setDimension(
-      yoga::Dimension::Height, yoga::StyleLength::points(size.height));
+      yoga::Dimension::Height, yoga::StyleSizeLength::points(size.height));
   yogaNode_.setStyle(style);
   yogaNode_.setDirty(true);
 }
@@ -585,13 +584,13 @@ void YogaLayoutableShadowNode::layoutTree(
     LayoutConstraints layoutConstraints) {
   ensureUnsealed();
 
-  SystraceSection s1("YogaLayoutableShadowNode::layoutTree");
+  TraceSection s1("YogaLayoutableShadowNode::layoutTree");
 
   bool swapLeftAndRight = layoutContext.swapLeftAndRightInRTL &&
       layoutConstraints.layoutDirection == LayoutDirection::RightToLeft;
 
   {
-    SystraceSection s2("YogaLayoutableShadowNode::configureYogaTree");
+    TraceSection s2("YogaLayoutableShadowNode::configureYogaTree");
     configureYogaTree(
         layoutContext.pointScaleFactor,
         YGErrataAll /*defaultErrata*/,
@@ -631,16 +630,18 @@ void YogaLayoutableShadowNode::layoutTree(
   auto ownerHeight = yogaFloatFromFloat(maximumSize.height);
 
   yogaStyle.setMaxDimension(
-      yoga::Dimension::Width, yoga::StyleLength::points(maximumSize.width));
+      yoga::Dimension::Width, yoga::StyleSizeLength::points(maximumSize.width));
 
   yogaStyle.setMaxDimension(
-      yoga::Dimension::Height, yoga::StyleLength::points(maximumSize.height));
+      yoga::Dimension::Height,
+      yoga::StyleSizeLength::points(maximumSize.height));
 
   yogaStyle.setMinDimension(
-      yoga::Dimension::Width, yoga::StyleLength::points(minimumSize.width));
+      yoga::Dimension::Width, yoga::StyleSizeLength::points(minimumSize.width));
 
   yogaStyle.setMinDimension(
-      yoga::Dimension::Height, yoga::StyleLength::points(minimumSize.height));
+      yoga::Dimension::Height,
+      yoga::StyleSizeLength::points(minimumSize.height));
 
   auto direction =
       yogaDirectionFromLayoutDirection(layoutConstraints.layoutDirection);
@@ -648,7 +649,7 @@ void YogaLayoutableShadowNode::layoutTree(
   threadLocalLayoutContext = layoutContext;
 
   {
-    SystraceSection s3("YogaLayoutableShadowNode::YGNodeCalculateLayout");
+    TraceSection s3("YogaLayoutableShadowNode::YGNodeCalculateLayout");
     YGNodeCalculateLayout(&yogaNode_, ownerWidth, ownerHeight, direction);
   }
 
@@ -797,7 +798,7 @@ YGNodeRef YogaLayoutableShadowNode::yogaNodeCloneCallbackConnector(
     YGNodeConstRef /*oldYogaNode*/,
     YGNodeConstRef parentYogaNode,
     size_t childIndex) {
-  SystraceSection s("YogaLayoutableShadowNode::yogaNodeCloneCallbackConnector");
+  TraceSection s("YogaLayoutableShadowNode::yogaNodeCloneCallbackConnector");
 
   auto& parentNode = shadowNodeFromContext(parentYogaNode);
   return &parentNode.cloneChildInPlace(childIndex).yogaNode_;
@@ -809,8 +810,7 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector(
     YGMeasureMode widthMode,
     float height,
     YGMeasureMode heightMode) {
-  SystraceSection s(
-      "YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector");
+  TraceSection s("YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector");
 
   auto& shadowNode = shadowNodeFromContext(yogaNode);
 
@@ -854,8 +854,7 @@ float YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector(
     YGNodeConstRef yogaNode,
     float width,
     float height) {
-  SystraceSection s(
-      "YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector");
+  TraceSection s("YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector");
 
   auto& shadowNode = shadowNodeFromContext(yogaNode);
   auto baseline = shadowNode.baseline(

package/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp

@@ -18,9 +18,10 @@ namespace facebook::react {
 YogaStylableProps::YogaStylableProps(
     const PropsParserContext& context,
     const YogaStylableProps& sourceProps,
-    const RawProps& rawProps)
+    const RawProps& rawProps,
+    const std::function<bool(const std::string&)>& filterObjectKeys)
     : Props() {
-  initialize(context, sourceProps, rawProps);
+  initialize(context, sourceProps, rawProps, filterObjectKeys);
 
   yogaStyle.setDirection(convertRawProp(
       context,

package/ReactCommon/react/renderer/components/view/YogaStylableProps.h

@@ -21,7 +21,9 @@ class YogaStylableProps : public Props {
   YogaStylableProps(
       const PropsParserContext& context,
       const YogaStylableProps& sourceProps,
-      const RawProps& rawProps);
+      const RawProps& rawProps,
+      const std::function<bool(const std::string&)>& filterObjectKeys =
+          nullptr);
 
   void setProp(
       const PropsParserContext& context,

package/ReactCommon/react/renderer/components/view/conversions.h

@@ -7,8 +7,6 @@
 
 #pragma once
 
-#include <folly/Conv.h>
-#include <folly/dynamic.h>
 #include <glog/logging.h>
 #include <react/debug/react_native_expect.h>
 #include <react/renderer/components/view/primitives.h>
@@ -31,6 +29,7 @@
 #include <algorithm>
 #include <cmath>
 #include <optional>
+#include <string>
 #include <unordered_map>
 
 namespace facebook::react {
@@ -64,6 +63,25 @@ inline float yogaFloatFromFloat(Float value) {
   return (float)value;
 }
 
+/*
+ * Converts string to float only if the entire string is valid float.
+ */
+inline std::optional<float> stringToFloat(const std::string& string) {
+  try {
+    size_t pos = 0;
+    auto result = std::stof(string, &pos);
+    // Check if entire string was valid
+    if (pos == string.length()) {
+      return result;
+    }
+  } catch (...) {
+    // Ignore, caller falls back to default value.
+    return std::nullopt;
+  }
+
+  return std::nullopt;
+}
+
 /*
  * `yoga::FloatOptional` <-> React Native's `Float`
  *
@@ -93,18 +111,15 @@ inline yoga::FloatOptional yogaOptionalFloatFromFloat(Float value) {
 inline std::optional<Float> optionalFloatFromYogaValue(
     const yoga::Style::Length& length,
     std::optional<Float> base = {}) {
-  switch (length.unit()) {
-    case yoga::Unit::Undefined:
-      return {};
-    case yoga::Unit::Point:
-      return floatFromYogaOptionalFloat(length.value());
-    case yoga::Unit::Percent:
-      return base.has_value()
-          ? std::optional<Float>(
-                base.value() * floatFromYogaOptionalFloat(length.value()))
-          : std::optional<Float>();
-    case yoga::Unit::Auto:
-      return {};
+  if (length.isPoints()) {
+    return floatFromYogaOptionalFloat(length.value());
+  } else if (length.isPercent()) {
+    return base.has_value()
+        ? std::optional<Float>(
+              base.value() * floatFromYogaOptionalFloat(length.value()))
+        : std::optional<Float>();
+  } else {
+    return {};
   }
 }
 
@@ -447,6 +462,47 @@ inline void fromRawValue(
   LOG(ERROR) << "Could not parse yoga::Display: " << stringValue;
 }
 
+inline void fromRawValue(
+    const PropsParserContext& /*context*/,
+    const RawValue& value,
+    yoga::Style::SizeLength& result) {
+  if (value.hasType<Float>()) {
+    result = yoga::StyleSizeLength::points((float)value);
+    return;
+  } else if (value.hasType<std::string>()) {
+    const auto stringValue = (std::string)value;
+    if (stringValue == "auto") {
+      result = yoga::StyleSizeLength::ofAuto();
+      return;
+    } else if (stringValue == "max-content") {
+      result = yoga::StyleSizeLength::ofMaxContent();
+      return;
+    } else if (stringValue == "stretch") {
+      result = yoga::StyleSizeLength::ofStretch();
+      return;
+    } else if (stringValue == "fit-content") {
+      result = yoga::StyleSizeLength::ofFitContent();
+      return;
+    } else {
+      if (stringValue.back() == '%') {
+        auto tryValue =
+            stringToFloat(stringValue.substr(0, stringValue.length() - 1));
+        if (tryValue.has_value()) {
+          result = yoga::StyleSizeLength::percent(tryValue.value());
+          return;
+        }
+      } else {
+        auto tryValue = stringToFloat(stringValue);
+        if (tryValue.has_value()) {
+          result = yoga::StyleSizeLength::points(tryValue.value());
+          return;
+        }
+      }
+    }
+  }
+  result = yoga::StyleSizeLength::undefined();
+}
+
 inline void fromRawValue(
     const PropsParserContext& context,
     const RawValue& value,
@@ -461,15 +517,15 @@ inline void fromRawValue(
       return;
     } else {
       if (stringValue.back() == '%') {
-        auto tryValue = folly::tryTo<float>(
-            std::string_view(stringValue).substr(0, stringValue.length() - 1));
-        if (tryValue.hasValue()) {
+        auto tryValue =
+            stringToFloat(stringValue.substr(0, stringValue.length() - 1));
+        if (tryValue.has_value()) {
           result = yoga::StyleLength::percent(tryValue.value());
           return;
         }
       } else {
-        auto tryValue = folly::tryTo<float>(stringValue);
-        if (tryValue.hasValue()) {
+        auto tryValue = stringToFloat(stringValue);
+        if (tryValue.has_value()) {
           result = yoga::StyleLength::points(tryValue.value());
           return;
         }
@@ -535,9 +591,9 @@ inline void fromRawValue(
     const auto stringValue = (std::string)value;
 
     if (stringValue.back() == '%') {
-      auto tryValue = folly::tryTo<float>(
-          std::string_view(stringValue).substr(0, stringValue.length() - 1));
-      if (tryValue.hasValue()) {
+      auto tryValue =
+          stringToFloat(stringValue.substr(0, stringValue.length() - 1));
+      if (tryValue.has_value()) {
         valueUnit = ValueUnit(tryValue.value(), UnitType::Percent);
       }
     }
@@ -980,22 +1036,21 @@ inline void fromRawValue(
     const PropsParserContext& /*context*/,
     const RawValue& value,
     LayoutConformance& result) {
-  result = LayoutConformance::Classic;
   react_native_expect(value.hasType<std::string>());
+  result = LayoutConformance::Strict;
   if (!value.hasType<std::string>()) {
     return;
   }
+
   auto stringValue = (std::string)value;
-  if (stringValue == "classic") {
-    result = LayoutConformance::Classic;
-    return;
-  }
   if (stringValue == "strict") {
     result = LayoutConformance::Strict;
-    return;
+  } else if (stringValue == "compatibility") {
+    result = LayoutConformance::Compatibility;
+  } else {
+    LOG(ERROR) << "Unexpected LayoutConformance value:" << stringValue;
+    react_native_expect(false);
   }
-  LOG(ERROR) << "Could not parse LayoutConformance:" << stringValue;
-  react_native_expect(false);
 }
 
 inline void fromRawValue(
@@ -1376,15 +1431,36 @@ inline std::string toString(const yoga::Display& value) {
 }
 
 inline std::string toString(const yoga::Style::Length& length) {
-  switch (length.unit()) {
-    case yoga::Unit::Undefined:
-      return "undefined";
-    case yoga::Unit::Point:
-      return std::to_string(length.value().unwrap());
-    case yoga::Unit::Percent:
-      return std::to_string(length.value().unwrap()) + "%";
-    case yoga::Unit::Auto:
-      return "auto";
+  if (length.isUndefined()) {
+    return "undefined";
+  } else if (length.isAuto()) {
+    return "auto";
+  } else if (length.isPoints()) {
+    return std::to_string(length.value().unwrap());
+  } else if (length.isPercent()) {
+    return std::to_string(length.value().unwrap()) + "%";
+  } else {
+    return "unknown";
+  }
+}
+
+inline std::string toString(const yoga::Style::SizeLength& length) {
+  if (length.isUndefined()) {
+    return "undefined";
+  } else if (length.isAuto()) {
+    return "auto";
+  } else if (length.isPoints()) {
+    return std::to_string(length.value().unwrap());
+  } else if (length.isPercent()) {
+    return std::to_string(length.value().unwrap()) + "%";
+  } else if (length.isMaxContent()) {
+    return "max-content";
+  } else if (length.isFitContent()) {
+    return "fit-content";
+  } else if (length.isStretch()) {
+    return "stretch";
+  } else {
+    return "unknown";
   }
 }
 
@@ -1398,12 +1474,10 @@ inline std::string toString(const yoga::FloatOptional& value) {
 
 inline std::string toString(const LayoutConformance& value) {
   switch (value) {
-    case LayoutConformance::Undefined:
-      return "undefined";
-    case LayoutConformance::Classic:
-      return "classic";
     case LayoutConformance::Strict:
       return "strict";
+    case LayoutConformance::Compatibility:
+      return "compatibility";
   }
 }
 

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -20,8 +20,9 @@ namespace facebook::react {
 HostPlatformViewProps::HostPlatformViewProps(
     const PropsParserContext& context,
     const HostPlatformViewProps& sourceProps,
-    const RawProps& rawProps)
-    : BaseViewProps(context, sourceProps, rawProps),
+    const RawProps& rawProps,
+    const std::function<bool(const std::string&)>& filterObjectKeys)
+    : BaseViewProps(context, sourceProps, rawProps, filterObjectKeys),
       elevation(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.elevation

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.h

@@ -26,7 +26,9 @@ class HostPlatformViewProps : public BaseViewProps {
   HostPlatformViewProps(
       const PropsParserContext& context,
       const HostPlatformViewProps& sourceProps,
-      const RawProps& rawProps);
+      const RawProps& rawProps,
+      const std::function<bool(const std::string&)>& filterObjectKeys =
+          nullptr);
 
   void setProp(
       const PropsParserContext& context,

package/ReactCommon/react/renderer/components/view/primitives.h

@@ -140,7 +140,7 @@ enum class Cursor : uint8_t {
   ZoomOut,
 };
 
-enum class LayoutConformance : uint8_t { Undefined, Classic, Strict };
+enum class LayoutConformance : uint8_t { Strict, Compatibility };
 
 template <typename T>
 struct CascadedRectangleEdges {

package/ReactCommon/react/renderer/components/view/tests/LayoutTest.cpp

@@ -77,8 +77,8 @@ class LayoutTest : public ::testing::Test {
             auto &props = *sharedProps;
             props.layoutConstraints = LayoutConstraints{{0,0}, {500, 500}};
             auto &yogaStyle = props.yogaStyle;
-            yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(200));
-            yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(200));
+            yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(200));
+            yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(200));
             return sharedProps;
           })
           .children({
@@ -90,8 +90,8 @@ class LayoutTest : public ::testing::Test {
                 auto &props = *sharedProps;
                 auto &yogaStyle = props.yogaStyle;
                 yogaStyle.setPositionType(yoga::PositionType::Absolute);
-                yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(50));
-                yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(50));
+                yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(50));
+                yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(50));
                 return sharedProps;
               })
               .children({
@@ -105,8 +105,8 @@ class LayoutTest : public ::testing::Test {
                     yogaStyle.setPositionType(yoga::PositionType::Absolute);
                     yogaStyle.setPosition(yoga::Edge::Left, yoga::StyleLength::points(10));
                     yogaStyle.setPosition(yoga::Edge::Top, yoga::StyleLength::points(10));
-                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(30));
-                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(90));
+                    yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(30));
+                    yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(90));
 
                     if (testCase == TRANSFORM_SCALE) {
                       props.transform = props.transform * Transform::Scale(2, 2, 1);
@@ -138,8 +138,8 @@ class LayoutTest : public ::testing::Test {
                         yogaStyle.setPositionType(yoga::PositionType::Absolute);
                         yogaStyle.setPosition(yoga::Edge::Left, yoga::StyleLength::points(10));
                         yogaStyle.setPosition(yoga::Edge::Top, yoga::StyleLength::points(10));
-                        yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(110));
-                        yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(20));
+                        yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(110));
+                        yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(20));
                         return sharedProps;
                       })
                       .children({
@@ -153,8 +153,8 @@ class LayoutTest : public ::testing::Test {
                             yogaStyle.setPositionType(yoga::PositionType::Absolute);
                             yogaStyle.setPosition(yoga::Edge::Left, yoga::StyleLength::points(70));
                             yogaStyle.setPosition(yoga::Edge::Top, yoga::StyleLength::points(-50));
-                            yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(30));
-                            yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(60));
+                            yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(30));
+                            yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(60));
                             return sharedProps;
                           })
                       }),
@@ -168,8 +168,8 @@ class LayoutTest : public ::testing::Test {
                         yogaStyle.setPositionType(yoga::PositionType::Absolute);
                         yogaStyle.setPosition(yoga::Edge::Left, yoga::StyleLength::points(-60));
                         yogaStyle.setPosition(yoga::Edge::Top, yoga::StyleLength::points(50));
-                        yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleLength::points(70));
-                        yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleLength::points(20));
+                        yogaStyle.setDimension(yoga::Dimension::Width, yoga::StyleSizeLength::points(70));
+                        yogaStyle.setDimension(yoga::Dimension::Height, yoga::StyleSizeLength::points(20));
                         return sharedProps;
                       })
                   })

package/ReactCommon/react/renderer/core/CMakeLists.txt

@@ -23,7 +23,6 @@ target_link_libraries(react_render_core
         glog
         jsi
         logger
-        react_config
         react_debug
         react_featureflags
         react_render_debug

package/ReactCommon/react/renderer/core/ComponentDescriptor.cpp

@@ -11,10 +11,12 @@
 namespace facebook::react {
 
 ComponentDescriptor::ComponentDescriptor(
-    const ComponentDescriptorParameters& parameters)
+    const ComponentDescriptorParameters& parameters,
+    RawPropsParser&& rawPropsParser)
     : eventDispatcher_(parameters.eventDispatcher),
       contextContainer_(parameters.contextContainer),
-      flavor_(parameters.flavor) {}
+      flavor_(parameters.flavor),
+      rawPropsParser_(std::move(rawPropsParser)) {}
 
 const std::shared_ptr<const ContextContainer>&
 ComponentDescriptor::getContextContainer() const {

package/ReactCommon/react/renderer/core/ComponentDescriptor.h

@@ -46,7 +46,9 @@ class ComponentDescriptor {
    */
   using Flavor = std::shared_ptr<const void>;
 
-  ComponentDescriptor(const ComponentDescriptorParameters& parameters);
+  explicit ComponentDescriptor(
+      const ComponentDescriptorParameters& parameters,
+      RawPropsParser&& rawPropsParser = {});
 
   virtual ~ComponentDescriptor() = default;
 
@@ -133,8 +135,8 @@ class ComponentDescriptor {
 
   EventDispatcher::Weak eventDispatcher_;
   std::shared_ptr<const ContextContainer> contextContainer_;
-  RawPropsParser rawPropsParser_{};
   Flavor flavor_;
+  RawPropsParser rawPropsParser_;
 
   /*
    * Called immediately after `ShadowNode` is created, cloned or state is

package/ReactCommon/react/renderer/core/ConcreteComponentDescriptor.h

@@ -46,8 +46,10 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   using ConcreteState = typename ShadowNodeT::ConcreteState;
   using ConcreteStateData = typename ShadowNodeT::ConcreteState::Data;
 
-  ConcreteComponentDescriptor(const ComponentDescriptorParameters& parameters)
-      : ComponentDescriptor(parameters) {
+  explicit ConcreteComponentDescriptor(
+      const ComponentDescriptorParameters& parameters,
+      RawPropsParser&& rawPropsParser = {})
+      : ComponentDescriptor(parameters, std::move(rawPropsParser)) {
     rawPropsParser_.prepare<ConcreteProps>();
   }
 
@@ -184,4 +186,17 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 };
 
+template <typename TManager>
+std::shared_ptr<TManager> getManagerByName(
+    std::shared_ptr<const ContextContainer>& contextContainer,
+    const char name[]) {
+  if (contextContainer) {
+    if (auto manager = contextContainer->find<std::shared_ptr<TManager>>(name);
+        manager.has_value()) {
+      return manager.value();
+    }
+  }
+  return std::make_shared<TManager>(contextContainer);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/DynamicPropsUtilities.cpp

@@ -36,4 +36,30 @@ folly::dynamic mergeDynamicProps(
   return result;
 }
 
+folly::dynamic diffDynamicProps(
+    const folly::dynamic& oldProps,
+    const folly::dynamic& newProps) {
+  folly::dynamic result = folly::dynamic::object();
+  if (!oldProps.isObject() || !newProps.isObject()) {
+    return result;
+  }
+  for (const auto& oldPair : oldProps.items()) {
+    const auto& newIterator = newProps.find(oldPair.first);
+    if (newIterator == newProps.items().end()) {
+      // Prop removed.
+      result[oldPair.first] = nullptr;
+    } else if (oldPair.second != newIterator->second) {
+      // Prop changed.
+      result[oldPair.first] = newIterator->second;
+    }
+  }
+  for (const auto& newIterator : newProps.items()) {
+    if (oldProps.find(newIterator.first) == oldProps.items().end()) {
+      // Prop added.
+      result[newIterator.first] = newIterator.second;
+    }
+  }
+  return result;
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/DynamicPropsUtilities.h

@@ -48,4 +48,8 @@ folly::dynamic mergeDynamicProps(
     const folly::dynamic& patch,
     NullValueStrategy nullValueStrategy);
 
+folly::dynamic diffDynamicProps(
+    const folly::dynamic& oldProps,
+    const folly::dynamic& newProps);
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/EventEmitter.cpp

@@ -7,7 +7,7 @@
 
 #include "EventEmitter.h"
 
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
@@ -89,7 +89,7 @@ void EventEmitter::dispatchEvent(
     std::string type,
     SharedEventPayload payload,
     RawEvent::Category category) const {
-  SystraceSection s("EventEmitter::dispatchEvent", "type", type);
+  TraceSection s("EventEmitter::dispatchEvent", "type", type);
 
   auto eventDispatcher = eventDispatcher_.lock();
   if (!eventDispatcher) {
@@ -114,7 +114,7 @@ void EventEmitter::dispatchUniqueEvent(
 void EventEmitter::dispatchUniqueEvent(
     std::string type,
     SharedEventPayload payload) const {
-  SystraceSection s("EventEmitter::dispatchUniqueEvent");
+  TraceSection s("EventEmitter::dispatchUniqueEvent");
 
   auto eventDispatcher = eventDispatcher_.lock();
   if (!eventDispatcher) {