react-native-tvos 0.79.3-0 → 0.80.0-0

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <react/renderer/components/view/HostPlatformViewTraitsInitializer.h>
 #include <react/renderer/components/view/ViewEventEmitter.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/YogaLayoutableShadowNode.h>
@@ -15,6 +16,7 @@
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/debug/DebugStringConvertibleItem.h>
+#include <type_traits>
 
 namespace facebook::react {
 
@@ -27,15 +29,14 @@ template <
     const char* concreteComponentName,
     typename ViewPropsT = ViewProps,
     typename ViewEventEmitterT = ViewEventEmitter,
-    typename StateDataT = StateData,
-    bool usesMapBufferForStateData = false>
+    typename StateDataT = StateData>
+  requires(std::is_base_of_v<ViewProps, ViewPropsT>)
 class ConcreteViewShadowNode : public ConcreteShadowNode<
                                    concreteComponentName,
                                    YogaLayoutableShadowNode,
                                    ViewPropsT,
                                    ViewEventEmitterT,
-                                   StateDataT,
-                                   usesMapBufferForStateData> {
+                                   StateDataT> {
   static_assert(
       std::is_base_of<ViewProps, ViewPropsT>::value,
       "ViewPropsT must be a descendant of ViewProps");
@@ -52,8 +53,7 @@ class ConcreteViewShadowNode : public ConcreteShadowNode<
       YogaLayoutableShadowNode,
       ViewPropsT,
       ViewEventEmitterT,
-      StateDataT,
-      usesMapBufferForStateData>;
+      StateDataT>;
 
   ConcreteViewShadowNode(
       const ShadowNodeFragment& fragment,
@@ -117,6 +117,16 @@ class ConcreteViewShadowNode : public ConcreteShadowNode<
     } else {
       BaseShadowNode::orderIndex_ = 0;
     }
+
+    bool isKeyboardFocusable =
+        HostPlatformViewTraitsInitializer::isKeyboardFocusable(props) ||
+        props.accessible;
+
+    if (isKeyboardFocusable) {
+      BaseShadowNode::traits_.set(ShadowNodeTraits::Trait::KeyboardFocusable);
+    } else {
+      BaseShadowNode::traits_.unset(ShadowNodeTraits::Trait::KeyboardFocusable);
+    }
   }
 };
 

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

@@ -62,7 +62,8 @@ void ViewShadowNode::initialize() noexcept {
       !viewProps.filter.empty() ||
       viewProps.mixBlendMode != BlendMode::Normal ||
       viewProps.isolation == Isolation::Isolate ||
-      HostPlatformViewTraitsInitializer::formsStackingContext(viewProps);
+      HostPlatformViewTraitsInitializer::formsStackingContext(viewProps) ||
+      !viewProps.accessibilityOrder.empty();
 
   bool formsView = formsStackingContext ||
       isColorMeaningful(viewProps.backgroundColor) || hasBorder() ||

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

@@ -25,8 +25,6 @@
 
 namespace facebook::react {
 
-static_assert(RawPropsFilterable<YogaLayoutableShadowNode>);
-
 static int FabricDefaultYogaLog(
     const YGConfigConstRef /*unused*/,
     const YGNodeConstRef /*unused*/,
@@ -785,13 +783,6 @@ Rect YogaLayoutableShadowNode::getContentBounds() const {
   return contentBounds;
 }
 
-/*static*/ void YogaLayoutableShadowNode::filterRawProps(RawProps& rawProps) {
-  if (ReactNativeFeatureFlags::excludeYogaFromRawProps()) {
-    // TODO: this shouldn't live in RawProps
-    rawProps.filterYogaStylePropsInDynamicConversion();
-  }
-}
-
 #pragma mark - Yoga Connectors
 
 YGNodeRef YogaLayoutableShadowNode::yogaNodeCloneCallbackConnector(
@@ -1002,7 +993,7 @@ void YogaLayoutableShadowNode::ensureConsistency() const {
 }
 
 void YogaLayoutableShadowNode::ensureYogaChildrenLookFine() const {
-#if defined(REACT_NATIVE_DEBUG) && defined(WITH_FBSYSTRACE)
+#if defined(REACT_NATIVE_DEBUG)
   // Checking that the shapes of Yoga node children object look fine.
   // This is the only heuristic that might produce false-positive results
   // (really broken dangled nodes might look fine). This is useful as an early
@@ -1020,7 +1011,7 @@ void YogaLayoutableShadowNode::ensureYogaChildrenLookFine() const {
 }
 
 void YogaLayoutableShadowNode::ensureYogaChildrenAlignment() const {
-#if defined(REACT_NATIVE_DEBUG) && defined(WITH_FBSYSTRACE)
+#if defined(REACT_NATIVE_DEBUG)
   // If the node is not a leaf node, checking that:
   // - All children are `YogaLayoutableShadowNode` subclasses.
   // - All Yoga children are owned/connected to corresponding children of

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

@@ -85,8 +85,6 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode {
 
   Rect getContentBounds() const;
 
-  static void filterRawProps(RawProps& rawProps);
-
  protected:
   /*
    * Yoga config associated (only) with this particular node.

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

@@ -15,6 +15,7 @@
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/css/CSSAngle.h>
+#include <react/renderer/css/CSSNumber.h>
 #include <react/renderer/css/CSSPercentage.h>
 #include <react/renderer/css/CSSValueParser.h>
 #include <react/renderer/graphics/BackgroundImage.h>
@@ -62,25 +63,6 @@ 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`
  *
@@ -483,19 +465,15 @@ inline void fromRawValue(
       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;
-        }
+      auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
+      if (std::holds_alternative<CSSPercentage>(parsed)) {
+        result = yoga::StyleSizeLength::percent(
+            std::get<CSSPercentage>(parsed).value);
+        return;
+      } else if (std::holds_alternative<CSSNumber>(parsed)) {
+        result =
+            yoga::StyleSizeLength::points(std::get<CSSNumber>(parsed).value);
+        return;
       }
     }
   }
@@ -515,19 +493,14 @@ inline void fromRawValue(
       result = yoga::StyleLength::ofAuto();
       return;
     } else {
-      if (stringValue.back() == '%') {
-        auto tryValue =
-            stringToFloat(stringValue.substr(0, stringValue.length() - 1));
-        if (tryValue.has_value()) {
-          result = yoga::StyleLength::percent(tryValue.value());
-          return;
-        }
-      } else {
-        auto tryValue = stringToFloat(stringValue);
-        if (tryValue.has_value()) {
-          result = yoga::StyleLength::points(tryValue.value());
-          return;
-        }
+      auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
+      if (std::holds_alternative<CSSPercentage>(parsed)) {
+        result =
+            yoga::StyleLength::percent(std::get<CSSPercentage>(parsed).value);
+        return;
+      } else if (std::holds_alternative<CSSNumber>(parsed)) {
+        result = yoga::StyleLength::points(std::get<CSSNumber>(parsed).value);
+        return;
       }
     }
   }
@@ -1207,7 +1180,45 @@ inline void fromRawValue(
     }
 
     std::string type = (std::string)(typeIt->second);
-    if (type == "linearGradient") {
+    std::vector<ColorStop> colorStops;
+    auto colorStopsIt = rawBackgroundImageMap.find("colorStops");
+
+    if (colorStopsIt != rawBackgroundImageMap.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()) {
+            ColorStop colorStop;
+            if (positionIt->second.hasValue()) {
+              auto valueUnit = toValueUnit(positionIt->second);
+              if (!valueUnit) {
+                result = {};
+                return;
+              }
+              colorStop.position = valueUnit;
+            }
+            if (colorIt->second.hasValue()) {
+              fromRawValue(
+                  context.contextContainer,
+                  context.surfaceId,
+                  colorIt->second,
+                  colorStop.color);
+            }
+            colorStops.push_back(colorStop);
+          }
+        }
+      }
+    }
+
+    if (type == "linear-gradient") {
       LinearGradient linearGradient;
 
       auto directionIt = rawBackgroundImageMap.find("direction");
@@ -1240,43 +1251,88 @@ inline void fromRawValue(
         }
       }
 
-      auto colorStopsIt = rawBackgroundImageMap.find("colorStops");
-      if (colorStopsIt != rawBackgroundImageMap.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()) {
-              ColorStop colorStop;
-              if (positionIt->second.hasValue()) {
-                auto valueUnit = toValueUnit(positionIt->second);
-                if (!valueUnit) {
-                  result = {};
-                  return;
-                }
-                colorStop.position = valueUnit;
-              }
-              if (colorIt->second.hasValue()) {
-                fromRawValue(
-                    context.contextContainer,
-                    context.surfaceId,
-                    colorIt->second,
-                    colorStop.color);
-              }
-              linearGradient.colorStops.push_back(colorStop);
-            }
+      if (!colorStops.empty()) {
+        linearGradient.colorStops = colorStops;
+      }
+
+      backgroundImage.emplace_back(std::move(linearGradient));
+    } else if (type == "radial-gradient") {
+      RadialGradient radialGradient;
+      auto shapeIt = rawBackgroundImageMap.find("shape");
+      if (shapeIt != rawBackgroundImageMap.end() &&
+          shapeIt->second.hasType<std::string>()) {
+        auto shape = (std::string)(shapeIt->second);
+        radialGradient.shape = shape == "circle" ? RadialGradientShape::Circle
+                                                 : RadialGradientShape::Ellipse;
+      }
+
+      auto sizeIt = rawBackgroundImageMap.find("size");
+      if (sizeIt != rawBackgroundImageMap.end()) {
+        if (sizeIt->second.hasType<std::string>()) {
+          auto sizeStr = (std::string)(sizeIt->second);
+          if (sizeStr == "closest-side") {
+            radialGradient.size.value =
+                RadialGradientSize::SizeKeyword::ClosestSide;
+          } else if (sizeStr == "farthest-side") {
+            radialGradient.size.value =
+                RadialGradientSize::SizeKeyword::FarthestSide;
+          } else if (sizeStr == "closest-corner") {
+            radialGradient.size.value =
+                RadialGradientSize::SizeKeyword::ClosestCorner;
+          } else if (sizeStr == "farthest-corner") {
+            radialGradient.size.value =
+                RadialGradientSize::SizeKeyword::FarthestCorner;
+          }
+        } else if (sizeIt->second
+                       .hasType<std::unordered_map<std::string, RawValue>>()) {
+          auto sizeMap = static_cast<std::unordered_map<std::string, RawValue>>(
+              sizeIt->second);
+          auto xIt = sizeMap.find("x");
+          auto yIt = sizeMap.find("y");
+          if (xIt != sizeMap.end() && yIt != sizeMap.end()) {
+            RadialGradientSize sizeObj;
+            sizeObj.value = RadialGradientSize::Dimensions{
+                toValueUnit(xIt->second), toValueUnit(yIt->second)};
+            radialGradient.size = sizeObj;
           }
         }
+
+        auto positionIt = rawBackgroundImageMap.find("position");
+        if (positionIt != rawBackgroundImageMap.end() &&
+            positionIt->second
+                .hasType<std::unordered_map<std::string, RawValue>>()) {
+          auto positionMap =
+              static_cast<std::unordered_map<std::string, RawValue>>(
+                  positionIt->second);
+
+          auto topIt = positionMap.find("top");
+          auto bottomIt = positionMap.find("bottom");
+          auto leftIt = positionMap.find("left");
+          auto rightIt = positionMap.find("right");
+
+          if (topIt != positionMap.end()) {
+            auto topValue = toValueUnit(topIt->second);
+            radialGradient.position.top = topValue;
+          } else if (bottomIt != positionMap.end()) {
+            auto bottomValue = toValueUnit(bottomIt->second);
+            radialGradient.position.bottom = bottomValue;
+          }
+
+          if (leftIt != positionMap.end()) {
+            auto leftValue = toValueUnit(leftIt->second);
+            radialGradient.position.left = leftValue;
+          } else if (rightIt != positionMap.end()) {
+            auto rightValue = toValueUnit(rightIt->second);
+            radialGradient.position.right = rightValue;
+          }
+        }
+      }
+
+      if (!colorStops.empty()) {
+        radialGradient.colorStops = colorStops;
       }
 
-      backgroundImage.push_back(std::move(linearGradient));
+      backgroundImage.emplace_back(std::move(radialGradient));
     }
   }
 

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

@@ -115,6 +115,15 @@ HostPlatformViewProps::HostPlatformViewProps(
                     rawProps,
                     "renderToHardwareTextureAndroid",
                     sourceProps.renderToHardwareTextureAndroid,
+                    {})),
+      screenReaderFocusable(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.screenReaderFocusable
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "screenReaderFocusable",
+                    sourceProps.screenReaderFocusable,
                     {})) {}
 #define VIEW_EVENT_CASE(eventType)                      \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): { \
@@ -148,6 +157,7 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(hasTVPreferredFocus);
     RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing);
     RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(screenReaderFocusable);
   }
 }
 
@@ -852,6 +862,14 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
     result["accessibilityLabelledBy"] = accessibilityLabelledByValues;
   }
 
+  if (accessibilityOrder != oldProps->accessibilityOrder) {
+    auto accessibilityChildrenIds = folly::dynamic::array();
+    for (const auto& accessibilityChildId : accessibilityOrder) {
+      accessibilityChildrenIds.push_back(accessibilityChildId);
+    }
+    result["experimental_accessibilityOrder"] = accessibilityChildrenIds;
+  }
+
   if (accessibilityLiveRegion != oldProps->accessibilityLiveRegion) {
     switch (accessibilityLiveRegion) {
       case AccessibilityLiveRegion::Assertive:

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

@@ -54,6 +54,7 @@ class HostPlatformViewProps : public BaseViewProps {
 
   bool needsOffscreenAlphaCompositing{false};
   bool renderToHardwareTextureAndroid{false};
+  bool screenReaderFocusable{false};
 
 #pragma mark - Convenience Methods
 

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

@@ -21,7 +21,12 @@ inline bool formsView(const ViewProps& viewProps) {
       viewProps.nativeForeground.has_value() || viewProps.focusable ||
       viewProps.hasTVPreferredFocus ||
       viewProps.needsOffscreenAlphaCompositing ||
-      viewProps.renderToHardwareTextureAndroid;
+      viewProps.renderToHardwareTextureAndroid ||
+      viewProps.screenReaderFocusable;
+}
+
+inline bool isKeyboardFocusable(const ViewProps& viewProps) {
+  return (viewProps.focusable || viewProps.hasTVPreferredFocus);
 }
 
 } // namespace facebook::react::HostPlatformViewTraitsInitializer

package/ReactCommon/react/renderer/components/view/platform/cxx/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -20,4 +20,8 @@ inline bool formsView(const ViewProps& props) {
   return false;
 }
 
+inline bool isKeyboardFocusable(const ViewProps& /*props*/) {
+  return false;
+}
+
 } // namespace facebook::react::HostPlatformViewTraitsInitializer

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

@@ -6,15 +6,11 @@
 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_consistency_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(react_renderer_consistency OBJECT ${react_renderer_consistency_SRC})
 
 target_include_directories(react_renderer_consistency PUBLIC ${REACT_COMMON_DIR})
+target_compile_reactnative_options(react_renderer_consistency PRIVATE "Fabric")
+target_compile_options(react_renderer_consistency PRIVATE -Wpedantic)

package/ReactCommon/react/renderer/core/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_core_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(react_renderer_core OBJECT ${react_renderer_core_SRC})
@@ -31,3 +25,5 @@ target_link_libraries(react_renderer_core
         react_renderer_runtimescheduler
         react_utils
         runtimeexecutor)
+target_compile_reactnative_options(react_renderer_core PRIVATE "Fabric")
+target_compile_options(react_renderer_core PRIVATE -Wpedantic)

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

@@ -29,8 +29,7 @@ template <
     typename BaseShadowNodeT,
     typename PropsT,
     typename EventEmitterT = EventEmitter,
-    typename StateDataT = StateData,
-    bool usesMapBufferForStateData = false>
+    typename StateDataT = StateData>
 class ConcreteShadowNode : public BaseShadowNodeT {
   static_assert(
       std::is_base_of<ShadowNode, BaseShadowNodeT>::value,
@@ -52,7 +51,7 @@ class ConcreteShadowNode : public BaseShadowNodeT {
   using ConcreteEventEmitter = EventEmitterT;
   using SharedConcreteEventEmitter = std::shared_ptr<const EventEmitterT>;
   using SharedConcreteShadowNode = std::shared_ptr<const ConcreteShadowNode>;
-  using ConcreteState = ConcreteState<StateDataT, usesMapBufferForStateData>;
+  using ConcreteState = ConcreteState<StateDataT>;
   using ConcreteStateData = StateDataT;
 
   static ComponentName Name() {

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

@@ -14,19 +14,32 @@
 #include <react/renderer/core/State.h>
 
 #ifdef ANDROID
+#include <fbjni/fbjni.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
 
 namespace facebook::react {
 
+#ifdef ANDROID
+template <typename StateDataT>
+concept StateDataWithMapBuffer = requires(StateDataT stateData) {
+  { stateData.getMapBuffer() } -> std::same_as<MapBuffer>;
+};
+
+template <typename StateDataT>
+concept StateDataWithJNIReference = requires(StateDataT stateData) {
+  { stateData.getJNIReference() } -> std::same_as<jni::local_ref<jobject>>;
+};
+#endif
+
 /*
  * Concrete and only template implementation of State interface.
  * State wraps an arbitrary data type and provides an interface to initiate a
  * state update transaction. A data object does not need to be copyable but
  * needs to be moveable.
  */
-template <typename DataT, bool usesMapBufferForStateData = false>
+template <typename DataT>
 class ConcreteState : public State {
  public:
   using Shared = std::shared_ptr<const ConcreteState>;
@@ -106,12 +119,20 @@ class ConcreteState : public State {
   }
 
   MapBuffer getMapBuffer() const override {
-    if constexpr (usesMapBufferForStateData) {
+    if constexpr (StateDataWithMapBuffer<DataT>) {
       return getData().getMapBuffer();
     } else {
       return MapBufferBuilder::EMPTY();
     }
   }
+
+  jni::local_ref<jobject> getJNIReference() const override {
+    if constexpr (StateDataWithJNIReference<DataT>) {
+      return getData().getJNIReference();
+    } else {
+      return nullptr;
+    }
+  }
 #endif
 };
 

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

@@ -0,0 +1,44 @@
+/*
+ * 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 "DynamicEventPayload.h"
+
+#include <jsi/JSIDynamic.h>
+
+namespace facebook::react {
+
+DynamicEventPayload::DynamicEventPayload(folly::dynamic&& payload)
+    : payload_(std::move(payload)) {}
+
+jsi::Value DynamicEventPayload::asJSIValue(jsi::Runtime& runtime) const {
+  return jsi::valueFromDynamic(runtime, payload_);
+}
+
+EventPayloadType DynamicEventPayload::getType() const {
+  return EventPayloadType::ValueFactory;
+}
+
+std::optional<double> DynamicEventPayload::extractValue(
+    const std::vector<std::string>& path) const {
+  auto dynamic = payload_;
+  for (auto& key : path) {
+    auto type = dynamic.type();
+    if ((type == folly::dynamic::Type::OBJECT ||
+         type == folly::dynamic::Type::ARRAY) &&
+        !dynamic.empty()) {
+      dynamic = folly::dynamic(dynamic[key]);
+    }
+  }
+  if (dynamic.type() == folly::dynamic::Type::DOUBLE) {
+    return dynamic.asDouble();
+  } else if (dynamic.type() == folly::dynamic::Type::INT64) {
+    return dynamic.asInt();
+  }
+  return std::nullopt;
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,30 @@
+/*
+ * 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 <folly/dynamic.h>
+#include <react/renderer/core/EventPayload.h>
+
+namespace facebook::react {
+
+struct DynamicEventPayload : public EventPayload {
+  explicit DynamicEventPayload(folly::dynamic&& payload);
+
+  /*
+   * EventPayload implementations
+   */
+  jsi::Value asJSIValue(jsi::Runtime& runtime) const override;
+  EventPayloadType getType() const override;
+  std::optional<double> extractValue(
+      const std::vector<std::string>& path) const override;
+
+ private:
+  folly::dynamic payload_;
+};
+
+} // namespace facebook::react