react-native-tvos 0.85.3-1 → 0.86.0-0

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

@@ -0,0 +1,38 @@
+/*
+ * 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 "HostPlatformViewProps.h"
+
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook::react {
+
+HostPlatformViewProps::HostPlatformViewProps(
+    const PropsParserContext& context,
+    const HostPlatformViewProps& sourceProps,
+    const RawProps& rawProps)
+    : BaseViewProps(context, sourceProps, rawProps),
+      focusable(convertRawProp(
+          context,
+          rawProps,
+          "focusable",
+          sourceProps.focusable,
+          false)) {}
+
+void HostPlatformViewProps::setProp(
+    const PropsParserContext& context,
+    RawPropsPropNameHash hash,
+    const char* propName,
+    const RawValue& value) {
+  BaseViewProps::setProp(context, hash, propName, value);
+
+  static auto defaults = HostPlatformViewProps{};
+
+  switch (hash) { RAW_SET_PROP_SWITCH_CASE_BASIC(focusable); }
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,29 @@
+/*
+ * 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 <react/renderer/components/view/BaseViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+
+namespace facebook::react {
+
+class HostPlatformViewProps : public BaseViewProps {
+ public:
+  HostPlatformViewProps() = default;
+  HostPlatformViewProps(
+      const PropsParserContext &context,
+      const HostPlatformViewProps &sourceProps,
+      const RawProps &rawProps);
+
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, const RawValue &value);
+
+  bool focusable{false};
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/view/platform/tvos/react/renderer/components/view/HostPlatformViewTraitsInitializer.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 <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ShadowNodeTraits.h>
+
+namespace facebook::react::HostPlatformViewTraitsInitializer {
+
+inline bool formsStackingContext(const ViewProps &props)
+{
+  return false;
+}
+
+inline bool formsView(const ViewProps &props)
+{
+  return false;
+}
+
+inline bool isKeyboardFocusable(const ViewProps & /*props*/)
+{
+  return false;
+}
+
+} // namespace facebook::react::HostPlatformViewTraitsInitializer

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

@@ -356,8 +356,14 @@ convertRawProp(const PropsParserContext &context, const RawProps &rawProps, cons
       yoga::Dimension::Height,
       convertRawProp(context, rawProps, "maxHeight", sourceValue.maxDimension(yoga::Dimension::Height), {}));
 
-  yogaStyle.setAspectRatio(
-      convertRawProp(context, rawProps, "aspectRatio", sourceValue.aspectRatio(), yogaStyle.aspectRatio()));
+  {
+    const auto *rawValue = rawProps.at("aspectRatio", nullptr, nullptr);
+    if (rawValue != nullptr) {
+      yogaStyle.setAspectRatio(rawValue->hasValue() ? convertAspectRatio(context, *rawValue) : yogaStyle.aspectRatio());
+    } else {
+      yogaStyle.setAspectRatio(sourceValue.aspectRatio());
+    }
+  }
 
   yogaStyle.setBoxSizing(
       convertRawProp(context, rawProps, "boxSizing", sourceValue.boxSizing(), yogaStyle.boxSizing()));

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

@@ -7,6 +7,7 @@
 
 #include <gtest/gtest.h>
 
+#include <react/renderer/attributedstring/conversions.h>
 #include <react/renderer/components/view/BoxShadowPropsConversions.h>
 #include <react/renderer/components/view/FilterPropsConversions.h>
 #include <react/renderer/components/view/conversions.h>
@@ -454,4 +455,89 @@ TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string_with_z) {
   EXPECT_EQ(result.z, 15.0f);
 }
 
+TEST(ConversionsTest, unprocessed_font_variant_string_single) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString("small-caps", result);
+
+  EXPECT_EQ((int)result, (int)FontVariant::SmallCaps);
+}
+
+TEST(ConversionsTest, unprocessed_font_variant_string_multiple) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString(
+      "small-caps oldstyle-nums tabular-nums", result);
+
+  EXPECT_EQ(
+      (int)result,
+      (int)FontVariant::SmallCaps | (int)FontVariant::OldstyleNums |
+          (int)FontVariant::TabularNums);
+}
+
+TEST(ConversionsTest, unprocessed_font_variant_string_invalid) {
+  FontVariant result{};
+  parseUnprocessedFontVariantString("not-a-variant", result);
+
+  EXPECT_EQ((int)result, (int)FontVariant::Default);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_float) {
+  RawValue value{folly::dynamic(1.5)};
+  auto result =
+      convertAspectRatio(PropsParserContext{-1, ContextContainer{}}, value);
+
+  EXPECT_FALSE(result.isUndefined());
+  EXPECT_EQ(result.unwrap(), 1.5f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_ratio_string) {
+  // CSSRatio parses "16/9" as {numerator: 16, denominator: 9}
+  auto ratio = parseCSSProperty<CSSRatio>("16/9");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  auto r = std::get<CSSRatio>(ratio);
+  EXPECT_FALSE(r.isDegenerate());
+  EXPECT_NEAR(r.numerator / r.denominator, 16.0f / 9.0f, 0.001f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_number_string) {
+  // CSSRatio parses "1.5" as {numerator: 1.5, denominator: 1.0}
+  auto ratio = parseCSSProperty<CSSRatio>("1.5");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  auto r = std::get<CSSRatio>(ratio);
+  EXPECT_FALSE(r.isDegenerate());
+  EXPECT_EQ(r.numerator / r.denominator, 1.5f);
+}
+
+TEST(ConversionsTest, convert_aspect_ratio_degenerate) {
+  auto ratio = parseCSSProperty<CSSRatio>("0/0");
+  ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
+  EXPECT_TRUE(std::get<CSSRatio>(ratio).isDegenerate());
+}
+
+TEST(ConversionsTest, float_optional_from_rawvalue_float) {
+  RawValue value{folly::dynamic(1.5)};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_FALSE(result.isUndefined());
+  EXPECT_EQ(result.unwrap(), 1.5f);
+}
+
+TEST(ConversionsTest, float_optional_undefined_for_non_float) {
+  RawValue value{folly::dynamic(nullptr)};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_TRUE(result.isUndefined());
+}
+
+TEST(ConversionsTest, float_optional_undefined_for_string) {
+  // fromRawValue for FloatOptional does not parse strings —
+  // that is handled by convertAspectRatio specifically.
+  RawValue value{folly::dynamic("16/9")};
+  yoga::FloatOptional result;
+  fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
+
+  EXPECT_TRUE(result.isUndefined());
+}
+
 } // namespace facebook::react

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

@@ -19,6 +19,7 @@
 
 #include <react/renderer/element/Element.h>
 #include <react/renderer/element/testUtils.h>
+#include <yoga/numeric/FloatOptional.h>
 
 namespace facebook::react {
 
@@ -229,4 +230,37 @@ TEST_F(YogaDirtyFlagTest, updatingStateForScrollViewMistNotDirtyYogaNode) {
       static_cast<RootShadowNode&>(*newRootShadowNode).layoutIfNeeded());
 }
 
+TEST_F(YogaDirtyFlagTest, clonedPropsPreserveAspectRatio) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  /*
+   * Cloning props with empty RawProps must preserve aspectRatio set on the
+   * source props.
+   */
+  auto newRootShadowNode = rootShadowNode_->cloneTree(
+      innerShadowNode_->getFamily(), [&](const ShadowNode& oldShadowNode) {
+        // First clone: set aspectRatio to 1.5
+        auto viewProps = std::make_shared<ViewShadowNodeProps>();
+        viewProps->yogaStyle.setAspectRatio(yoga::FloatOptional(1.5f));
+        auto nodeWithAspectRatio =
+            oldShadowNode.clone(ShadowNodeFragment{.props = viewProps});
+
+        // Second clone: clone props with empty RawProps (simulating a prop
+        // update that does not touch aspectRatio)
+        auto& componentDescriptor =
+            nodeWithAspectRatio->getComponentDescriptor();
+        auto clonedProps = componentDescriptor.cloneProps(
+            parserContext, nodeWithAspectRatio->getProps(), RawProps());
+
+        auto& clonedViewProps =
+            static_cast<const ViewShadowNodeProps&>(*clonedProps);
+        EXPECT_TRUE(clonedViewProps.yogaStyle.aspectRatio().isDefined());
+        EXPECT_EQ(clonedViewProps.yogaStyle.aspectRatio().unwrap(), 1.5f);
+
+        return nodeWithAspectRatio->clone(
+            ShadowNodeFragment{.props = clonedProps});
+      });
+}
+
 } // namespace facebook::react

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

@@ -63,6 +63,18 @@ void EventEmitter::dispatchEvent(
       category);
 }
 
+void EventEmitter::dispatchEvent(
+    std::string type,
+    folly::dynamic&& payload,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchEvent(
+      std::move(type),
+      DynamicEventPayload::create(std::move(payload)),
+      category,
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchUniqueEvent(
     std::string type,
     folly::dynamic&& payload) const {
@@ -70,6 +82,16 @@ void EventEmitter::dispatchUniqueEvent(
       std::move(type), DynamicEventPayload::create(std::move(payload)));
 }
 
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    folly::dynamic&& payload,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchUniqueEvent(
+      std::move(type),
+      DynamicEventPayload::create(std::move(payload)),
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchEvent(
     std::string type,
     const ValueFactory& payloadFactory,
@@ -80,10 +102,31 @@ void EventEmitter::dispatchEvent(
       category);
 }
 
+void EventEmitter::dispatchEvent(
+    std::string type,
+    const ValueFactory& payloadFactory,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchEvent(
+      std::move(type),
+      std::make_shared<ValueFactoryEventPayload>(payloadFactory),
+      category,
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchEvent(
     std::string type,
     SharedEventPayload payload,
     RawEvent::Category category) const {
+  dispatchEvent(
+      std::move(type), std::move(payload), category, HighResTimeStamp::now());
+}
+
+void EventEmitter::dispatchEvent(
+    std::string type,
+    SharedEventPayload payload,
+    RawEvent::Category category,
+    HighResTimeStamp eventTimestamp) const {
   TraceSection s("EventEmitter::dispatchEvent", "type", type);
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -96,7 +139,9 @@ void EventEmitter::dispatchEvent(
       std::move(payload),
       eventTarget_,
       shadowNodeFamily_,
-      category));
+      category,
+      false,
+      eventTimestamp));
 }
 
 void EventEmitter::dispatchUniqueEvent(
@@ -107,9 +152,27 @@ void EventEmitter::dispatchUniqueEvent(
       std::make_shared<ValueFactoryEventPayload>(payloadFactory));
 }
 
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    const ValueFactory& payloadFactory,
+    HighResTimeStamp eventTimestamp) const {
+  dispatchUniqueEvent(
+      std::move(type),
+      std::make_shared<ValueFactoryEventPayload>(payloadFactory),
+      eventTimestamp);
+}
+
 void EventEmitter::dispatchUniqueEvent(
     std::string type,
     SharedEventPayload payload) const {
+  dispatchUniqueEvent(
+      std::move(type), std::move(payload), HighResTimeStamp::now());
+}
+
+void EventEmitter::dispatchUniqueEvent(
+    std::string type,
+    SharedEventPayload payload,
+    HighResTimeStamp eventTimestamp) const {
   TraceSection s("EventEmitter::dispatchUniqueEvent");
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -122,7 +185,9 @@ void EventEmitter::dispatchUniqueEvent(
       std::move(payload),
       eventTarget_,
       shadowNodeFamily_,
-      RawEvent::Category::Continuous));
+      RawEvent::Category::Continuous,
+      true,
+      eventTimestamp));
 }
 
 void EventEmitter::setEnabled(bool enabled) {

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

@@ -16,6 +16,7 @@
 #include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/ValueFactoryEventPayload.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -86,6 +87,12 @@ class EventEmitter {
       const ValueFactory &payloadFactory = EventEmitter::defaultPayloadFactory(),
       RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
+  void dispatchEvent(
+      std::string type,
+      const ValueFactory &payloadFactory,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
   void dispatchEvent(
       std::string type,
       folly::dynamic &&payload,
@@ -96,13 +103,31 @@ class EventEmitter {
       SharedEventPayload payload,
       RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
+  void dispatchEvent(
+      std::string type,
+      folly::dynamic &&payload,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
+  void dispatchEvent(
+      std::string type,
+      SharedEventPayload payload,
+      RawEvent::Category category,
+      HighResTimeStamp eventTimestamp) const;
+
   void dispatchUniqueEvent(std::string type, folly::dynamic &&payload) const;
 
   void dispatchUniqueEvent(std::string type, const ValueFactory &payloadFactory = EventEmitter::defaultPayloadFactory())
       const;
 
+  void dispatchUniqueEvent(std::string type, const ValueFactory &payloadFactory, HighResTimeStamp eventTimestamp) const;
+
   void dispatchUniqueEvent(std::string type, SharedEventPayload payload) const;
 
+  void dispatchUniqueEvent(std::string type, folly::dynamic &&payload, HighResTimeStamp eventTimestamp) const;
+
+  void dispatchUniqueEvent(std::string type, SharedEventPayload payload, HighResTimeStamp eventTimestamp) const;
+
  private:
   friend class UIManagerBinding;
 

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

@@ -15,6 +15,7 @@
 #include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/ReactEventPriority.h>
 #include <react/renderer/core/ValueFactory.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -23,7 +24,8 @@ using EventPipe = std::function<void(
     EventTarget *eventTarget,
     const std::string &type,
     ReactEventPriority priority,
-    const EventPayload &payload)>;
+    const EventPayload &payload,
+    HighResTimeStamp eventTimestamp)>;
 
 using EventPipeConclusion = std::function<void(jsi::Runtime &runtime)>;
 

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

@@ -7,6 +7,7 @@
 
 #include "EventQueueProcessor.h"
 
+#include <folly/ScopeGuard.h>
 #include <logger/react_native_log.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 
@@ -38,6 +39,20 @@ void EventQueueProcessor::flushEvents(
     }
   }
 
+  // RAII guard for the matching release() pass. If event dispatch throws (a JS
+  // exception from eventPipe_, or eventPipeConclusion_), the previous code
+  // skipped the release loop entirely, leaking JSI strong references. The
+  // guard destructor runs on every exit path. No DispatchMutex needed for
+  // release: we hold a strong pointer to each EventTarget via `events`, and
+  // release() only touches runtime-thread-confined state.
+  SCOPE_EXIT {
+    for (const auto& event : events) {
+      if (event.eventTarget) {
+        event.eventTarget->release(runtime);
+      }
+    }
+  };
+
   for (const auto& event : events) {
     auto reactPriority = ReactEventPriority::Default;
 
@@ -96,7 +111,8 @@ void EventQueueProcessor::flushEvents(
         event.eventTarget.get(),
         event.type,
         reactPriority,
-        *event.eventPayload);
+        *event.eventPayload,
+        event.eventStartTimeStamp);
 
     if (eventLogger != nullptr) {
       eventLogger->onEventProcessingEnd(event.loggingTag);
@@ -110,15 +126,7 @@ void EventQueueProcessor::flushEvents(
   // We only run the "Conclusion" once per event group when batched.
   eventPipeConclusion_(runtime);
 
-  // No need to lock `EventEmitter::DispatchMutex()` here.
-  // The mutex protects from a situation when the `instanceHandle` can be
-  // deallocated during accessing, but that's impossible at this point because
-  // we have a strong pointer to it.
-  for (const auto& event : events) {
-    if (event.eventTarget) {
-      event.eventTarget->release(runtime);
-    }
-  }
+  // EventTarget release happens in the SCOPE_EXIT above.
 }
 
 void EventQueueProcessor::flushStateUpdates(

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

@@ -7,8 +7,6 @@
 
 #include "EventTarget.h"
 
-#include <react/debug/react_native_assert.h>
-
 namespace facebook::react {
 
 using Tag = EventTarget::Tag;
@@ -51,11 +49,16 @@ void EventTarget::release(jsi::Runtime& /*runtime*/) {
   // It takes it only to ensure thread-safety (if the caller has the reference,
   // we are on a proper thread).
 
-  if (--retainCount_ == 0) {
+  // retainCount_ is unsigned. retain() early-returns when the target is
+  // disabled but the matching release() still runs, so we can land here with
+  // a zero count; an unconditional decrement would wrap to SIZE_MAX and the
+  // strong handle would never be cleared again.
+  if (retainCount_ > 0) {
+    --retainCount_;
+  }
+  if (retainCount_ == 0) {
     strongInstanceHandle_ = jsi::Value::null();
   }
-
-  react_native_assert(retainCount_ >= 0);
 }
 
 jsi::Value EventTarget::getInstanceHandle(jsi::Runtime& runtime) const {

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

@@ -59,6 +59,11 @@ struct LayoutContext {
    * If React Native takes up entire screen, it will be {0, 0}.
    */
   Point viewportOffset{};
+
+  /*
+   * Viewport size is size of the React Native's root view.
+   */
+  Size viewportSize{};
 };
 
 inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
@@ -68,13 +73,15 @@ inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
              lhs.affectedNodes,
              lhs.swapLeftAndRightInRTL,
              lhs.fontSizeMultiplier,
-             lhs.viewportOffset) ==
+             lhs.viewportOffset,
+             lhs.viewportSize) ==
       std::tie(
              rhs.pointScaleFactor,
              rhs.affectedNodes,
              rhs.swapLeftAndRightInRTL,
              rhs.fontSizeMultiplier,
-             rhs.viewportOffset);
+             rhs.viewportOffset,
+             rhs.viewportSize);
 }
 
 } // namespace facebook::react

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

@@ -44,9 +44,11 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
            ",bottom:" + getDebugDescription(object.overflowInset.bottom, {}) +
            ",left:" + getDebugDescription(object.overflowInset.left, {}) + "}"},
       {.name = "displayType",
-       .value = object.displayType == DisplayType::None
-           ? "None"
-           : (object.displayType == DisplayType::Flex ? "Flex" : "Inline")},
+       .value = object.displayType == DisplayType::None  ? "None"
+           : object.displayType == DisplayType::Flex     ? "Flex"
+           : object.displayType == DisplayType::Grid     ? "Grid"
+           : object.displayType == DisplayType::Contents ? "Contents"
+                                                         : "Unknown"},
       {.name = "layoutDirection",
        .value = object.layoutDirection == LayoutDirection::Undefined
            ? "Undefined"

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

@@ -20,6 +20,7 @@ enum class DisplayType {
   None = 0,
   Flex = 1,
   Contents = 2,
+  Grid = 3,
 };
 
 enum class PositionType {

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

@@ -32,6 +32,20 @@ void Props::initialize(
   nativeId = ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
       ? sourceProps.nativeId
       : convertRawProp(context, rawProps, "nativeID", sourceProps.nativeId, {});
+
+  if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
+    if (ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
+      // id -> nativeId
+      auto* idValue = rawProps.at("id", nullptr, nullptr);
+      if (idValue != nullptr) {
+        if (idValue->hasValue()) {
+          fromRawValue(context, *idValue, nativeId);
+        } else {
+          nativeId = {};
+        }
+      }
+    }
+  }
 #ifdef RN_SERIALIZABLE_STATE
   if (!ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid()) {
     initializeDynamicProps(sourceProps, rawProps, filterObjectKeys);
@@ -48,6 +62,12 @@ void Props::setProp(
     case CONSTEXPR_RAW_PROPS_KEY_HASH("nativeID"):
       fromRawValue(context, value, nativeId, {});
       return;
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("id"):
+      if (!ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
+        return;
+      }
+      fromRawValue(context, value, nativeId, {});
+      return;
   }
 }
 

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

@@ -15,12 +15,14 @@ RawEvent::RawEvent(
     SharedEventTarget eventTarget,
     std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
     Category category,
-    bool isUnique)
+    bool isUnique,
+    HighResTimeStamp eventStartTimeStamp)
     : type(std::move(type)),
       eventPayload(std::move(eventPayload)),
       eventTarget(std::move(eventTarget)),
       shadowNodeFamily(std::move(shadowNodeFamily)),
       category(category),
-      isUnique(isUnique) {}
+      isUnique(isUnique),
+      eventStartTimeStamp(eventStartTimeStamp) {}
 
 } // namespace facebook::react

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

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <memory>
-#include <optional>
 #include <string>
 
 #include <react/renderer/core/EventLogger.h>
@@ -74,7 +73,8 @@ struct RawEvent {
       SharedEventTarget eventTarget,
       std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
       Category category = Category::Unspecified,
-      bool isUnique = false);
+      bool isUnique = false,
+      HighResTimeStamp eventStartTimeStamp = HighResTimeStamp::now());
 
   std::string type;
   SharedEventPayload eventPayload;
@@ -84,10 +84,10 @@ struct RawEvent {
   EventTag loggingTag{0};
   bool isUnique{false};
 
-  // The client may specify a platform-specific timestamp for the event start
-  // time, for example when MotionEvent was triggered on the Android native
-  // side.
-  std::optional<HighResTimeStamp> eventStartTimeStamp = std::nullopt;
+  // The timestamp for the event start time. This defaults to the current
+  // time if not specified by the client (e.g., when MotionEvent was triggered
+  // on the Android native side).
+  HighResTimeStamp eventStartTimeStamp;
 };
 
 } // namespace facebook::react