react-native-tvos 0.75.4-0 → 0.76.0-0

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

@@ -13,8 +13,12 @@
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/Props.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/graphics/BackgroundImage.h>
+#include <react/renderer/graphics/BlendMode.h>
+#include <react/renderer/graphics/BoxShadow.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Filter.h>
+#include <react/renderer/graphics/Isolation.h>
 #include <react/renderer/graphics/Transform.h>
 
 #include <optional>
@@ -70,8 +74,20 @@ class BaseViewProps : public YogaStylableProps, public AccessibilityProps {
 
   Cursor cursor{};
 
+  // Box shadow
+  std::vector<BoxShadow> boxShadow{};
+
   // Filter
-  std::vector<FilterPrimitive> filter{};
+  std::vector<FilterFunction> filter{};
+
+  // Gradient
+  std::vector<GradientValue> backgroundImage{};
+
+  // MixBlendMode
+  BlendMode mixBlendMode{BlendMode::Normal};
+
+  // Isolate
+  Isolation isolation{Isolation::Auto};
 
   // Transform
   Transform transform{};
@@ -103,6 +119,7 @@ class BaseViewProps : public YogaStylableProps, public AccessibilityProps {
 
 #pragma mark - Convenience Methods
 
+  CascadedBorderWidths getBorderWidths() const;
   BorderMetrics resolveBorderMetrics(const LayoutMetrics& layoutMetrics) const;
   Transform resolveTransform(const LayoutMetrics& layoutMetrics) const;
   bool getClipsContentToBounds() const;

package/ReactCommon/react/renderer/components/view/CMakeLists.txt

@@ -18,7 +18,7 @@ file(GLOB rrc_view_SRC CONFIGURE_DEPENDS
         *.cpp
         platform/android/react/renderer/components/view/*.cpp)
 
-add_library(rrc_view SHARED ${rrc_view_SRC})
+add_library(rrc_view OBJECT ${rrc_view_SRC})
 
 target_include_directories(rrc_view
         PUBLIC

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

@@ -62,11 +62,14 @@ void ViewShadowNode::initialize() noexcept {
       viewProps.importantForAccessibility != ImportantForAccessibility::Auto ||
       viewProps.removeClippedSubviews || viewProps.cursor != Cursor::Auto ||
       !viewProps.filter.empty() ||
+      viewProps.mixBlendMode != BlendMode::Normal ||
+      viewProps.isolation == Isolation::Isolate ||
       HostPlatformViewTraitsInitializer::formsStackingContext(viewProps);
 
   bool formsView = formsStackingContext ||
       isColorMeaningful(viewProps.backgroundColor) || hasBorder() ||
-      !viewProps.testId.empty() ||
+      !viewProps.testId.empty() || !viewProps.boxShadow.empty() ||
+      !viewProps.backgroundImage.empty() ||
       HostPlatformViewTraitsInitializer::formsView(viewProps);
 
   if (formsView) {

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

@@ -81,6 +81,11 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
         YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector);
   }
 
+  if (getTraits().check(ShadowNodeTraits::Trait::BaselineYogaNode)) {
+    yogaNode_.setBaselineFunc(
+        YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector);
+  }
+
   updateYogaProps();
   updateYogaChildren();
 
@@ -845,6 +850,22 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector(
       yogaFloatFromFloat(size.width), yogaFloatFromFloat(size.height)};
 }
 
+float YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector(
+    YGNodeConstRef yogaNode,
+    float width,
+    float height) {
+  SystraceSection s(
+      "YogaLayoutableShadowNode::yogaNodeBaselineCallbackConnector");
+
+  auto& shadowNode = shadowNodeFromContext(yogaNode);
+  auto baseline = shadowNode.baseline(
+      threadLocalLayoutContext,
+      {.width = floatFromYogaFloat(width),
+       .height = floatFromYogaFloat(height)});
+
+  return yogaFloatFromFloat(baseline);
+}
+
 YogaLayoutableShadowNode& YogaLayoutableShadowNode::shadowNodeFromContext(
     YGNodeConstRef yogaNode) {
   return dynamic_cast<YogaLayoutableShadowNode&>(

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

@@ -164,6 +164,10 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode {
       YGMeasureMode widthMode,
       float height,
       YGMeasureMode heightMode);
+  static float yogaNodeBaselineCallbackConnector(
+      YGNodeConstRef yogaNode,
+      float width,
+      float height);
   static YogaLayoutableShadowNode& shadowNodeFromContext(
       YGNodeConstRef yogaNode);
 

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

@@ -15,7 +15,13 @@
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/graphics/BackgroundImage.h>
+#include <react/renderer/graphics/BlendMode.h>
+#include <react/renderer/graphics/BoxShadow.h>
 #include <react/renderer/graphics/Filter.h>
+#include <react/renderer/graphics/Isolation.h>
+#include <react/renderer/graphics/PlatformColorParser.h>
 #include <react/renderer/graphics/Transform.h>
 #include <react/renderer/graphics/ValueUnit.h>
 #include <stdlib.h>
@@ -188,8 +194,7 @@ inline void fromRawValue(
     result = yoga::Direction::RTL;
     return;
   }
-  LOG(ERROR) << "Could not parse Direction:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::Direction: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -218,8 +223,7 @@ inline void fromRawValue(
     result = yoga::FlexDirection::RowReverse;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::FlexDirection:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::FlexDirection: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -256,8 +260,7 @@ inline void fromRawValue(
     result = yoga::Justify::SpaceEvenly;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::Justify:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::Justify: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -306,7 +309,7 @@ inline void fromRawValue(
     result = yoga::Align::SpaceEvenly;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::Align:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Align: " << stringValue;
   react_native_expect(false);
 }
 
@@ -332,8 +335,7 @@ inline void fromRawValue(
     result = yoga::PositionType::Absolute;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::PositionType:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::PositionType: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -358,8 +360,7 @@ inline void fromRawValue(
     result = yoga::Wrap::WrapReverse;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::Wrap:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::Wrap: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -406,8 +407,7 @@ inline void fromRawValue(
     result = yoga::Display::None;
     return;
   }
-  LOG(ERROR) << "Could not parse yoga::Display:" << stringValue;
-  react_native_expect(false);
+  LOG(ERROR) << "Could not parse yoga::Display: " << stringValue;
 }
 
 inline void fromRawValue(
@@ -936,16 +936,112 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext& /*context*/,
+    const PropsParserContext& context,
+    const RawValue& value,
+    std::vector<BoxShadow>& result) {
+  react_native_expect(value.hasType<std::vector<RawValue>>());
+  if (!value.hasType<std::vector<RawValue>>()) {
+    result = {};
+    return;
+  }
+
+  std::vector<BoxShadow> boxShadows{};
+  auto rawBoxShadows = static_cast<std::vector<RawValue>>(value);
+  for (const auto& rawBoxShadow : rawBoxShadows) {
+    bool isMap =
+        rawBoxShadow.hasType<std::unordered_map<std::string, RawValue>>();
+    react_native_expect(isMap);
+    if (!isMap) {
+      // If any box shadow is malformed then we should not apply any of them
+      // which is the web behavior.
+      result = {};
+      return;
+    }
+
+    auto rawBoxShadowMap =
+        static_cast<std::unordered_map<std::string, RawValue>>(rawBoxShadow);
+    BoxShadow boxShadow{};
+    auto offsetX = rawBoxShadowMap.find("offsetX");
+    react_native_expect(offsetX != rawBoxShadowMap.end());
+    if (offsetX == rawBoxShadowMap.end()) {
+      result = {};
+      return;
+    }
+    react_native_expect(offsetX->second.hasType<Float>());
+    if (!offsetX->second.hasType<Float>()) {
+      result = {};
+      return;
+    }
+    boxShadow.offsetX = (Float)offsetX->second;
+
+    auto offsetY = rawBoxShadowMap.find("offsetY");
+    react_native_expect(offsetY != rawBoxShadowMap.end());
+    if (offsetY == rawBoxShadowMap.end()) {
+      result = {};
+      return;
+    }
+    react_native_expect(offsetY->second.hasType<Float>());
+    if (!offsetY->second.hasType<Float>()) {
+      result = {};
+      return;
+    }
+    boxShadow.offsetY = (Float)offsetY->second;
+
+    auto blurRadius = rawBoxShadowMap.find("blurRadius");
+    if (blurRadius != rawBoxShadowMap.end()) {
+      react_native_expect(blurRadius->second.hasType<Float>());
+      if (!blurRadius->second.hasType<Float>()) {
+        result = {};
+        return;
+      }
+      boxShadow.blurRadius = (Float)blurRadius->second;
+    }
+
+    auto spreadDistance = rawBoxShadowMap.find("spreadDistance");
+    if (spreadDistance != rawBoxShadowMap.end()) {
+      react_native_expect(spreadDistance->second.hasType<Float>());
+      if (!spreadDistance->second.hasType<Float>()) {
+        result = {};
+        return;
+      }
+      boxShadow.spreadDistance = (Float)spreadDistance->second;
+    }
+
+    auto inset = rawBoxShadowMap.find("inset");
+    if (inset != rawBoxShadowMap.end()) {
+      react_native_expect(inset->second.hasType<bool>());
+      if (!inset->second.hasType<bool>()) {
+        result = {};
+        return;
+      }
+      boxShadow.inset = (bool)inset->second;
+    }
+
+    auto color = rawBoxShadowMap.find("color");
+    if (color != rawBoxShadowMap.end()) {
+      fromRawValue(
+          context.contextContainer,
+          context.surfaceId,
+          color->second,
+          boxShadow.color);
+    }
+
+    boxShadows.push_back(boxShadow);
+  }
+
+  result = boxShadows;
+}
+inline void fromRawValue(
+    const PropsParserContext& context,
     const RawValue& value,
-    std::vector<FilterPrimitive>& result) {
+    std::vector<FilterFunction>& result) {
   react_native_expect(value.hasType<std::vector<RawValue>>());
   if (!value.hasType<std::vector<RawValue>>()) {
     result = {};
     return;
   }
 
-  std::vector<FilterPrimitive> filter{};
+  std::vector<FilterFunction> filter{};
   auto rawFilter = static_cast<std::vector<RawValue>>(value);
   for (const auto& rawFilterPrimitive : rawFilter) {
     bool isMap =
@@ -958,17 +1054,72 @@ inline void fromRawValue(
       return;
     }
 
-    auto rawFilterPrimitiveMap =
+    auto rawFilterFunction =
         static_cast<std::unordered_map<std::string, RawValue>>(
             rawFilterPrimitive);
-    FilterPrimitive filterPrimitive{};
+    FilterFunction filterFunction{};
     try {
-      filterPrimitive.type =
-          filterTypeFromString(rawFilterPrimitiveMap.begin()->first);
-      filterPrimitive.amount = (float)rawFilterPrimitiveMap.begin()->second;
-      filter.push_back(filterPrimitive);
+      filterFunction.type =
+          filterTypeFromString(rawFilterFunction.begin()->first);
+      if (filterFunction.type == FilterType::DropShadow) {
+        auto rawDropShadow =
+            static_cast<std::unordered_map<std::string, RawValue>>(
+                rawFilterFunction.begin()->second);
+        DropShadowParams dropShadowParams{};
+
+        auto offsetX = rawDropShadow.find("offsetX");
+        react_native_expect(offsetX != rawDropShadow.end());
+        if (offsetX == rawDropShadow.end()) {
+          result = {};
+          return;
+        }
+
+        react_native_expect(offsetX->second.hasType<Float>());
+        if (!offsetX->second.hasType<Float>()) {
+          result = {};
+          return;
+        }
+        dropShadowParams.offsetX = (Float)offsetX->second;
+
+        auto offsetY = rawDropShadow.find("offsetY");
+        react_native_expect(offsetY != rawDropShadow.end());
+        if (offsetY == rawDropShadow.end()) {
+          result = {};
+          return;
+        }
+        react_native_expect(offsetY->second.hasType<Float>());
+        if (!offsetY->second.hasType<Float>()) {
+          result = {};
+          return;
+        }
+        dropShadowParams.offsetY = (Float)offsetY->second;
+
+        auto standardDeviation = rawDropShadow.find("standardDeviation");
+        if (standardDeviation != rawDropShadow.end()) {
+          react_native_expect(standardDeviation->second.hasType<Float>());
+          if (!standardDeviation->second.hasType<Float>()) {
+            result = {};
+            return;
+          }
+          dropShadowParams.standardDeviation = (Float)standardDeviation->second;
+        }
+
+        auto color = rawDropShadow.find("color");
+        if (color != rawDropShadow.end()) {
+          fromRawValue(
+              context.contextContainer,
+              context.surfaceId,
+              color->second,
+              dropShadowParams.color);
+        }
+
+        filterFunction.parameters = dropShadowParams;
+      } else {
+        filterFunction.parameters = (float)rawFilterFunction.begin()->second;
+      }
+      filter.push_back(std::move(filterFunction));
     } catch (const std::exception& e) {
-      LOG(ERROR) << "Could not parse FilterPrimitive: " << e.what();
+      LOG(ERROR) << "Could not parse FilterFunction: " << e.what();
       result = {};
       return;
     }
@@ -977,6 +1128,139 @@ inline void fromRawValue(
   result = filter;
 }
 
+inline void fromRawValue(
+    const PropsParserContext& /*context*/,
+    const RawValue& value,
+    BlendMode& result) {
+  react_native_expect(value.hasType<std::string>());
+  result = BlendMode::Normal;
+  if (!value.hasType<std::string>()) {
+    return;
+  }
+
+  auto rawBlendMode = static_cast<std::string>(value);
+  std::optional<BlendMode> blendMode = blendModeFromString(rawBlendMode);
+
+  if (!blendMode) {
+    LOG(ERROR) << "Could not parse blend mode: " << rawBlendMode;
+    return;
+  }
+
+  result = blendMode.value();
+}
+
+inline void fromRawValue(
+    const PropsParserContext& context,
+    const RawValue& value,
+    std::vector<GradientValue>& result) {
+  react_native_expect(value.hasType<std::vector<RawValue>>());
+  if (!value.hasType<std::vector<RawValue>>()) {
+    result = {};
+    return;
+  }
+
+  std::vector<GradientValue> backgroundImage{};
+  auto rawBackgroundImage = static_cast<std::vector<RawValue>>(value);
+  for (const auto& rawGradientValue : rawBackgroundImage) {
+    bool isMap =
+        rawGradientValue.hasType<std::unordered_map<std::string, RawValue>>();
+    react_native_expect(isMap);
+    if (!isMap) {
+      result = {};
+      return;
+    }
+
+    auto rawGradientValueMap =
+        static_cast<std::unordered_map<std::string, RawValue>>(
+            rawGradientValue);
+    GradientValue gradientValue{};
+
+    auto typeIt = rawGradientValueMap.find("type");
+    if (typeIt != rawGradientValueMap.end() &&
+        typeIt->second.hasType<std::string>()) {
+      gradientValue.type =
+          gradientTypeFromString((std::string)(typeIt->second));
+    }
+
+    auto startIt = rawGradientValueMap.find("start");
+    if (startIt != rawGradientValueMap.end() &&
+        startIt->second.hasType<std::unordered_map<std::string, RawValue>>()) {
+      auto startPoints = static_cast<std::unordered_map<std::string, RawValue>>(
+          startIt->second);
+      auto xIt = startPoints.find("x");
+      auto yIt = startPoints.find("y");
+      if (xIt != startPoints.end() && yIt != startPoints.end() &&
+          xIt->second.hasType<Float>() && yIt->second.hasType<Float>()) {
+        gradientValue.startX = (Float)(xIt->second);
+        gradientValue.startY = (Float)(yIt->second);
+      }
+    }
+
+    auto endIt = rawGradientValueMap.find("end");
+    if (endIt != rawGradientValueMap.end() &&
+        endIt->second.hasType<std::unordered_map<std::string, RawValue>>()) {
+      auto endPoints =
+          static_cast<std::unordered_map<std::string, RawValue>>(endIt->second);
+      auto xIt = endPoints.find("x");
+      auto yIt = endPoints.find("y");
+      if (xIt != endPoints.end() && yIt != endPoints.end() &&
+          xIt->second.hasType<Float>() && yIt->second.hasType<Float>()) {
+        gradientValue.endX = (Float)(xIt->second);
+        gradientValue.endY = (Float)(yIt->second);
+      }
+    }
+
+    auto colorStopsIt = rawGradientValueMap.find("colorStops");
+    if (colorStopsIt != rawGradientValueMap.end() &&
+        colorStopsIt->second.hasType<std::vector<RawValue>>()) {
+      auto rawColorStops =
+          static_cast<std::vector<RawValue>>(colorStopsIt->second);
+
+      for (const auto& stop : rawColorStops) {
+        if (stop.hasType<std::unordered_map<std::string, RawValue>>()) {
+          auto stopMap =
+              static_cast<std::unordered_map<std::string, RawValue>>(stop);
+          auto positionIt = stopMap.find("position");
+          auto colorIt = stopMap.find("color");
+
+          if (positionIt != stopMap.end() && colorIt != stopMap.end() &&
+              positionIt->second.hasType<Float>()) {
+            ColorStop colorStop{};
+            colorStop.position = (Float)(positionIt->second);
+            fromRawValue(context, colorIt->second, colorStop.color);
+            gradientValue.colorStops.push_back(colorStop);
+          }
+        }
+      }
+    }
+
+    backgroundImage.push_back(gradientValue);
+  }
+
+  result = backgroundImage;
+}
+
+inline void fromRawValue(
+    const PropsParserContext& /*context*/,
+    const RawValue& value,
+    Isolation& result) {
+  react_native_expect(value.hasType<std::string>());
+  result = Isolation::Auto;
+  if (!value.hasType<std::string>()) {
+    return;
+  }
+
+  auto rawIsolation = static_cast<std::string>(value);
+  std::optional<Isolation> isolation = isolationFromString(rawIsolation);
+
+  if (!isolation) {
+    LOG(ERROR) << "Could not parse isolation: " << rawIsolation;
+    return;
+  }
+
+  result = isolation.value();
+}
+
 template <size_t N>
 inline std::string toString(const std::array<float, N> vec) {
   std::string s;

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

@@ -92,6 +92,13 @@ enum class BorderCurve : uint8_t { Circular, Continuous };
 
 enum class BorderStyle : uint8_t { Solid, Dotted, Dashed };
 
+struct CornerRadii {
+  float vertical{0.0f};
+  float horizontal{0.0f};
+
+  bool operator==(const CornerRadii& other) const = default;
+};
+
 enum class Cursor : uint8_t {
   Auto,
   Alias,
@@ -289,7 +296,7 @@ using BorderWidths = RectangleEdges<Float>;
 using BorderCurves = RectangleCorners<BorderCurve>;
 using BorderStyles = RectangleEdges<BorderStyle>;
 using BorderColors = RectangleEdges<SharedColor>;
-using BorderRadii = RectangleCorners<Float>;
+using BorderRadii = RectangleCorners<CornerRadii>;
 
 using CascadedBorderWidths = CascadedRectangleEdges<Float>;
 using CascadedBorderCurves = CascadedRectangleCorners<BorderCurve>;

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

@@ -15,6 +15,6 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_consistency_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_consistency SHARED ${react_render_consistency_SRC})
+add_library(react_render_consistency OBJECT ${react_render_consistency_SRC})
 
 target_include_directories(react_render_consistency PUBLIC ${REACT_COMMON_DIR})

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_core_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_core SHARED ${react_render_core_SRC})
+add_library(react_render_core OBJECT ${react_render_core_SRC})
 
 target_include_directories(react_render_core PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_render_core

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

@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <functional>
 #include <memory>
+#include <vector>
 
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ComponentDescriptor.h>
@@ -112,21 +112,29 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
 
     rawProps.parse(rawPropsParser_);
 
-    // Call old-style constructor
-    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
-
     // Use the new-style iterator
     // Note that we just check if `Props` has this flag set, no matter
     // the type of ShadowNode; it acts as the single global flag.
     if (CoreFeatures::enablePropIteratorSetter) {
-      rawProps.iterateOverValues([&](RawPropsPropNameHash hash,
-                                     const char* propName,
-                                     const RawValue& fn) {
-        shadowNodeProps.get()->setProp(context, hash, propName, fn);
-      });
+      auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
+#ifdef ANDROID
+      const auto& dynamic = shadowNodeProps->rawProps;
+#else
+      const auto& dynamic = static_cast<folly::dynamic>(rawProps);
+#endif
+      for (const auto& pair : dynamic.items()) {
+        const auto& name = pair.first.getString();
+        shadowNodeProps->setProp(
+            context,
+            RAW_PROPS_KEY_HASH(name),
+            name.c_str(),
+            RawValue(pair.second));
+      }
+      return shadowNodeProps;
+    } else {
+      // Call old-style constructor
+      return ShadowNodeT::Props(context, rawProps, props);
     }
-
-    return shadowNodeProps;
   };
 
   virtual State::Shared createInitialState(
@@ -161,7 +169,8 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   ShadowNodeFamily::Shared createFamily(
       const ShadowNodeFamilyFragment& fragment) const override {
     auto eventEmitter = std::make_shared<const ConcreteEventEmitter>(
-        std::make_shared<EventTarget>(fragment.instanceHandle),
+        std::make_shared<EventTarget>(
+            fragment.instanceHandle, fragment.surfaceId),
         eventDispatcher_);
     return std::make_shared<ShadowNodeFamily>(
         fragment, std::move(eventEmitter), eventDispatcher_, *this);

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

@@ -37,7 +37,8 @@ void EventDispatcher::dispatchEvent(RawEvent&& rawEvent) const {
 
   auto eventLogger = eventLogger_.lock();
   if (eventLogger != nullptr) {
-    rawEvent.loggingTag = eventLogger->onEventStart(rawEvent.type);
+    rawEvent.loggingTag =
+        eventLogger->onEventStart(rawEvent.type, rawEvent.eventTarget);
   }
   eventQueue_.enqueueEvent(std::move(rawEvent));
 }
@@ -59,12 +60,13 @@ void EventDispatcher::dispatchUniqueEvent(RawEvent&& rawEvent) const {
   if (eventListeners_.willDispatchEvent(rawEvent)) {
     return;
   }
+
   eventQueue_.enqueueUniqueEvent(std::move(rawEvent));
 }
 
 void EventDispatcher::addListener(
-    const std::shared_ptr<const EventListener>& listener) const {
-  eventListeners_.addListener(listener);
+    std::shared_ptr<const EventListener> listener) const {
+  eventListeners_.addListener(std::move(listener));
 }
 
 /*

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

@@ -64,7 +64,7 @@ class EventDispatcher {
   /*
    * Adds provided event listener to the event dispatcher.
    */
-  void addListener(const std::shared_ptr<const EventListener>& listener) const;
+  void addListener(std::shared_ptr<const EventListener> listener) const;
 
   /*
    * Removes provided event listener to the event dispatcher.

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

@@ -26,7 +26,7 @@ static bool hasPrefix(const std::string& str, const std::string& prefix) {
  * "top" prefix. E.g. "eventName" becomes "topEventName", "onEventName" also
  * becomes "topEventName".
  */
-static std::string normalizeEventType(std::string type) {
+/* static */ std::string EventEmitter::normalizeEventType(std::string type) {
   auto prefixedType = std::move(type);
   if (facebook::react::hasPrefix(prefixedType, "top")) {
     return prefixedType;