react-native-tvos 0.85.2-0 → 0.86.0-0rc2

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

@@ -101,7 +101,7 @@ void fromRawValue(const PropsParserContext &context, const RawValue &rawValue, T
 }
 
 template <typename T>
-void fromRawValue(const PropsParserContext &context, const RawValue &rawValue, T &result)
+void fromRawValue(const PropsParserContext & /* context */, const RawValue &rawValue, T &result)
 {
   result = (T)rawValue;
 }

package/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp

@@ -12,11 +12,13 @@
 #include <react/renderer/core/EventPipe.h>
 #include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/EventTarget.h>
+#include <react/renderer/core/InstanceHandle.h>
 #include <react/renderer/core/ShadowNodeFamily.h>
 #include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/ValueFactoryEventPayload.h>
 
 #include <memory>
+#include <stdexcept>
 #include <string_view>
 
 namespace facebook::react {
@@ -42,13 +44,14 @@ class EventQueueProcessorTest : public testing::Test {
                          const EventTarget* /*eventTarget*/,
                          const std::string& type,
                          ReactEventPriority priority,
-                         const EventPayload& /*payload*/) {
+                         const EventPayload& /*payload*/,
+                         HighResTimeStamp /*eventTimestamp*/) {
       eventTypes_.push_back(type);
       eventPriorities_.push_back(priority);
     };
 
-    auto dummyEventPipeConclusion = [](jsi::Runtime& runtime) {};
-    auto dummyStatePipe = [](const StateUpdate& stateUpdate) {};
+    auto dummyEventPipeConclusion = [](jsi::Runtime&) {};
+    auto dummyStatePipe = [](const StateUpdate&) {};
     auto mockEventLogger = std::make_shared<MockEventLogger>();
 
     eventProcessor_ = std::make_unique<EventQueueProcessor>(
@@ -156,4 +159,50 @@ TEST_F(EventQueueProcessorTest, alwaysDiscreteEvent) {
   EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
 }
 
+TEST_F(EventQueueProcessorTest, releasesEventTargetsWhenDispatchThrows) {
+  // Set up an enabled EventTarget so that flushEvents() will retain a strong
+  // JSI reference to its instance handle.
+  auto object = jsi::Object(*runtime_);
+  auto instanceHandle = std::make_shared<InstanceHandle>(
+      *runtime_, jsi::Value(*runtime_, object), 1);
+  auto eventTarget =
+      std::make_shared<EventTarget>(std::move(instanceHandle), 41);
+  eventTarget->setEnabled(true);
+
+  // An event pipe that throws, simulating a JS exception during dispatch.
+  auto throwingEventPipe = [](jsi::Runtime& /*runtime*/,
+                              const EventTarget* /*eventTarget*/,
+                              const std::string& /*type*/,
+                              ReactEventPriority /*priority*/,
+                              const EventPayload& /*payload*/,
+                              HighResTimeStamp /*eventTimestamp*/) {
+    throw std::runtime_error("dispatch failed");
+  };
+  auto dummyEventPipeConclusion = [](jsi::Runtime& /*runtime*/) {};
+  auto dummyStatePipe = [](const StateUpdate& /*stateUpdate*/) {};
+  auto mockEventLogger = std::make_shared<MockEventLogger>();
+
+  auto processor = EventQueueProcessor(
+      throwingEventPipe,
+      dummyEventPipeConclusion,
+      dummyStatePipe,
+      mockEventLogger);
+
+  EXPECT_THROW(
+      processor.flushEvents(
+          *runtime_,
+          {RawEvent(
+              "onThrow",
+              std::make_shared<ValueFactoryEventPayload>(dummyValueFactory_),
+              eventTarget,
+              {},
+              RawEvent::Category::Discrete)}),
+      std::runtime_error);
+
+  // The strong JSI reference acquired by retain() must have been released even
+  // though dispatch threw, so the instance handle is no longer reachable
+  // through the EventTarget.
+  EXPECT_TRUE(eventTarget->getInstanceHandle(*runtime_).isNull());
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/tests/EventTargetTests.cpp

@@ -43,3 +43,29 @@ TEST(EventTargetTests, getInstanceHandle) {
 
   EXPECT_TRUE(eventTarget.getInstanceHandle(*runtime).isNull());
 }
+
+TEST(EventTargetTests, releaseWhileDisabledDoesNotCorruptRetainCount) {
+  // retain() is a no-op while the target is disabled, but the matching
+  // release() still runs. release() must tolerate a zero retain count without
+  // underflowing, so that a later enable + retain still populates the strong
+  // instance handle.
+  auto runtime = facebook::hermes::makeHermesRuntime();
+  auto object = jsi::Object(*runtime);
+  auto instanceHandle = std::make_shared<InstanceHandle>(
+      *runtime, jsi::Value(*runtime, object), 1);
+
+  auto eventTarget = EventTarget(std::move(instanceHandle), 41);
+
+  // Disabled by default: retain is a no-op, release sees a zero count.
+  eventTarget.retain(*runtime);
+  eventTarget.release(*runtime);
+
+  // After enabling, a fresh retain must succeed in acquiring the handle.
+  eventTarget.setEnabled(true);
+  eventTarget.retain(*runtime);
+  EXPECT_FALSE(eventTarget.getInstanceHandle(*runtime).isNull());
+
+  // And the matching release must drop it again.
+  eventTarget.release(*runtime);
+  EXPECT_TRUE(eventTarget.getInstanceHandle(*runtime).isNull());
+}

package/ReactCommon/react/renderer/css/tests/CSSValueParserTest.cpp

@@ -33,7 +33,7 @@ struct CSSDataTypeParser<ConsumeDataType> {
 
 static_assert(CSSDataType<ConsumeDataType>);
 
-TEST(CSSValueParser, consume_multiple_with_delimeter) {
+TEST(CSSValueParser, consume_multiple_with_delimiter) {
   CSSSyntaxParser syntaxParser{"1 2, 3, 4 / 5"};
   CSSValueParser parser{syntaxParser};
 

package/ReactCommon/react/renderer/debug/DebugStringConvertible.cpp

@@ -7,11 +7,10 @@
 
 #include "DebugStringConvertible.h"
 
-#include <array>
-#include <cinttypes>
-#include <cstdio>
-
-#include <double-conversion/double-conversion.h>
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <sstream>
 
 namespace facebook::react {
 
@@ -125,37 +124,54 @@ SharedDebugStringConvertibleList DebugStringConvertible::getDebugProps() const {
   return {};
 }
 
+#endif
+
 /*
  * `toString`-family implementation.
  */
 std::string toString(const double& value) {
-  // Format taken from folly's toString
-  static double_conversion::DoubleToStringConverter conv(
-      0,
-      "Infinity",
-      "NaN",
-      'E',
-      -6, // detail::kConvMaxDecimalInShortestLow,
-      21, // detail::kConvMaxDecimalInShortestHigh,
-      6, // max leading padding zeros
-      1); // max trailing padding zeros
-  std::array<char, 256> buffer{};
-  double_conversion::StringBuilder builder(buffer.data(), buffer.size());
-  conv.ToShortest(value, &builder);
-  return builder.Finalize();
+  // Handle special floating-point values with prettier output
+  if (std::isnan(value)) {
+    return "NaN";
+  }
+  if (std::isinf(value)) {
+    return value < 0 ? "-Infinity" : "Infinity";
+  }
+
+  std::ostringstream stream;
+  stream << std::fixed << std::setprecision(4) << value;
+  std::string result = stream.str();
+
+  // Strip trailing zeros and unnecessary decimal point
+  if (auto dotPos = result.find('.'); dotPos != std::string::npos) {
+    auto lastNonZero = result.find_last_not_of('0');
+    if (lastNonZero == dotPos) {
+      result.erase(dotPos);
+    } else {
+      result.erase(lastNonZero + 1);
+    }
+  }
+  return result;
+}
+
+std::string toString(const double doubleValue, char suffix) {
+  auto result = toString(doubleValue);
+  if (suffix != '\0') {
+    result += suffix;
+  }
+  return result;
 }
 
+#if RN_DEBUG_STRING_CONVERTIBLE
+
 std::string toString(const void* value) {
   if (value == nullptr) {
     return "null";
   }
-  std::array<char, 20> buffer{};
-  std::snprintf(
-      buffer.data(),
-      buffer.size(),
-      "0x%" PRIXPTR,
-      reinterpret_cast<uintptr_t>(value));
-  return buffer.data();
+  std::ostringstream stream;
+  stream << "0x" << std::uppercase << std::hex
+         << reinterpret_cast<uintptr_t>(value);
+  return stream.str();
 }
 
 #endif

package/ReactCommon/react/renderer/debug/DebugStringConvertible.h

@@ -81,13 +81,15 @@ class DebugStringConvertible {};
 
 #endif
 
-#if RN_DEBUG_STRING_CONVERTIBLE
-
 /*
  * Set of particular-format-opinionated functions that convert base types to
  * `std::string`
  */
 std::string toString(const double &value);
+std::string toString(double doubleValue, char suffix);
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+
 std::string toString(const void *value);
 
 inline std::string toString(const std::string &value)

package/ReactCommon/react/renderer/debug/tests/DebugStringConvertibleTest.cpp

@@ -5,14 +5,44 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#if RN_DEBUG_STRING_CONVERTIBLE
-#include <memory>
+#include <limits>
 
 #include <gtest/gtest.h>
-#include <react/renderer/debug/DebugStringConvertibleItem.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
 
 using namespace facebook::react;
 
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffix) {
+  EXPECT_EQ(toString(3.14, '%'), "3.14%");
+  EXPECT_EQ(toString(100.0, 'x'), "100x");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithNullSuffix) {
+  auto result = toString(42.0, '\0');
+  EXPECT_EQ(result, "42");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixZeroValue) {
+  EXPECT_EQ(toString(0.0, '%'), "0%");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixNegativeValue) {
+  EXPECT_EQ(toString(-2.75, '%'), "-2.75%");
+}
+
+TEST(DebugStringConvertibleTest, toStringDoubleWithSuffixSpecialValues) {
+  EXPECT_EQ(
+      toString(std::numeric_limits<double>::infinity(), '%'), "Infinity%");
+  EXPECT_EQ(
+      toString(-std::numeric_limits<double>::infinity(), '%'), "-Infinity%");
+  EXPECT_EQ(toString(std::numeric_limits<double>::quiet_NaN(), 'x'), "NaNx");
+}
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+#include <memory>
+
+#include <react/renderer/debug/DebugStringConvertibleItem.h>
+
 TEST(DebugStringConvertibleTest, handleSimpleNode) {
   SharedDebugStringConvertibleList empty;
   auto item = std::make_shared<DebugStringConvertibleItem>(
@@ -83,4 +113,5 @@ TEST(DebugStringConvertibleTest, handleNodeWithComplexProps) {
       item->getDebugDescription().c_str(),
       "<View=hello x=1(height=100 width=200)/>");
 }
+
 #endif

package/ReactCommon/react/renderer/graphics/BlendMode.h

@@ -29,6 +29,7 @@ enum class BlendMode {
   Saturation,
   Color,
   Luminosity,
+  PlusLighter,
 };
 
 inline std::optional<BlendMode> blendModeFromString(std::string_view blendModeName)
@@ -65,6 +66,8 @@ inline std::optional<BlendMode> blendModeFromString(std::string_view blendModeNa
     return BlendMode::Color;
   } else if (blendModeName == "luminosity") {
     return BlendMode::Luminosity;
+  } else if (blendModeName == "plus-lighter") {
+    return BlendMode::PlusLighter;
   } else {
     return std::nullopt;
   }
@@ -105,6 +108,8 @@ inline std::string toString(const BlendMode &blendMode)
       return "color";
     case BlendMode::Luminosity:
       return "luminosity";
+    case BlendMode::PlusLighter:
+      return "plus-lighter";
     default:
       abort();
   }

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

@@ -30,6 +30,7 @@ target_link_libraries(react_renderer_graphics
         ${fbjni}
         folly_runtime
         react_debug
+        react_renderer_debug
         react_utils
 )
 target_compile_reactnative_options(react_renderer_graphics PRIVATE)

package/ReactCommon/react/renderer/graphics/ColorStop.h

@@ -12,7 +12,10 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 #include <optional>
+
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/graphics/LinearGradient.h

@@ -12,7 +12,10 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
+
 #include <variant>
 #include <vector>
 

package/ReactCommon/react/renderer/graphics/RadialGradient.h

@@ -12,7 +12,11 @@
 #include <react/renderer/graphics/Float.h>
 #include <react/renderer/graphics/ValueUnit.h>
 #include <optional>
+
+#if RN_DEBUG_STRING_CONVERTIBLE
 #include <sstream>
+#endif
+
 #include <variant>
 #include <vector>
 

package/ReactCommon/react/renderer/graphics/React-graphics.podspec

@@ -49,6 +49,7 @@ Pod::Spec.new do |s|
   s.dependency "React-jsiexecutor"
   s.dependency "React-featureflags"
   s.dependency "React-utils"
+  s.dependency "React-rendererdebug"
 
   depend_on_js_engine(s)
   add_rn_third_party_dependencies(s)

package/ReactCommon/react/renderer/graphics/ValueUnit.cpp

@@ -7,7 +7,7 @@
 
 #include "ValueUnit.h"
 
-#include "DoubleConversions.h"
+#include <react/renderer/debug/DebugStringConvertible.h>
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/imagemanager/platform/android/react/renderer/imagemanager/ImageFetcher.cpp

@@ -8,7 +8,6 @@
 #include "ImageFetcher.h"
 
 #include <react/common/mapbuffer/JReadableMapBuffer.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/imagemanager/conversions.h>
 
 namespace facebook::react {
@@ -35,10 +34,6 @@ ImageRequest ImageFetcher::requestImage(
 
   auto telemetry = std::make_shared<ImageTelemetry>(surfaceId);
 
-  if (!ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
-    flushImageRequests();
-  }
-
   return ImageRequest{imageSource, telemetry};
 }
 

package/ReactCommon/react/renderer/imagemanager/platform/android/react/renderer/imagemanager/ImageManager.cpp

@@ -25,7 +25,7 @@ ImageManager::ImageManager(
     : contextContainer_(contextContainer),
       self_(new std::shared_ptr<ImageFetcher>(
           std::make_shared<ImageFetcher>(contextContainer))) {
-  if (ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
     std::weak_ptr<ImageFetcher> weakImageFetcher =
         *static_cast<std::shared_ptr<ImageFetcher>*>(self_);
     contextContainer->insert(ImageFetcherKey, weakImageFetcher);
@@ -33,7 +33,7 @@ ImageManager::ImageManager(
 }
 
 ImageManager::~ImageManager() {
-  if (ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
     contextContainer_->erase(ImageFetcherKey);
   }
   delete static_cast<std::shared_ptr<ImageFetcher>*>(self_);

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTImagePrimitivesConversions.h

@@ -55,16 +55,12 @@ inline static NSURLRequestCachePolicy NSURLRequestCachePolicyFromImageSource(
   switch (imageSource.cache) {
     case facebook::react::ImageSource::CacheStategy::Reload:
       return NSURLRequestReloadIgnoringLocalCacheData;
-      break;
     case facebook::react::ImageSource::CacheStategy::ForceCache:
       return NSURLRequestReturnCacheDataElseLoad;
-      break;
     case facebook::react::ImageSource::CacheStategy::OnlyIfCached:
       return NSURLRequestReturnCacheDataDontLoad;
-      break;
     default:
       return NSURLRequestUseProtocolCachePolicy;
-      break;
   }
 }
 

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTSyncImageManager.mm

@@ -92,7 +92,11 @@ using namespace facebook::react;
 
   auto result = dispatch_group_wait(imageWaitGroup, dispatch_time(DISPATCH_TIME_NOW, 20 * NSEC_PER_SEC));
   if (result != 0) {
-    RCTLogError(@"Image timed out in test environment for url: %@", loaderRequest.imageURL);
+    // Downgraded from RCTLogError to RCTLogWarn: image timeouts in test
+    // environments are transient infrastructure issues, not fatal app errors.
+    // RCTLogError triggers a native redbox that blocks the entire UI and cannot
+    // be dismissed on iOS, causing E2E test failures.
+    RCTLogWarn(@"Image timed out in test environment for url: %@", loaderRequest.imageURL);
   }
   return imageRequest;
 }

package/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp

@@ -84,11 +84,16 @@ void MapBufferBuilder::putLong(MapBuffer::Key key, int64_t value) {
 }
 
 void MapBufferBuilder::putString(MapBuffer::Key key, const std::string& value) {
-  auto strSize = value.size();
+  // The wire format encodes lengths and offsets as int32_t (see
+  // MapBuffer::getString). Without an explicit narrowing cast, `auto` deduces
+  // size_t (8 bytes on 64-bit) and `memcpy(&x, ..., INT_SIZE)` then copies only
+  // the first 4 bytes of an 8-byte value: silent truncation on little-endian,
+  // wrong (high) bytes on big-endian.
+  auto strSize = static_cast<int32_t>(value.size());
   const char* strData = value.data();
 
   // format [length of string (int)] + [Array of Characters in the string]
-  auto offset = dynamicData_.size();
+  auto offset = static_cast<int32_t>(dynamicData_.size());
   dynamicData_.resize(offset + INT_SIZE + strSize, 0);
   memcpy(dynamicData_.data() + offset, &strSize, INT_SIZE);
   memcpy(dynamicData_.data() + offset + INT_SIZE, strData, strSize);
@@ -102,9 +107,12 @@ void MapBufferBuilder::putString(MapBuffer::Key key, const std::string& value) {
 }
 
 void MapBufferBuilder::putMapBuffer(MapBuffer::Key key, const MapBuffer& map) {
-  auto mapBufferSize = map.size();
+  // Wire format encodes lengths and offsets as int32_t (see
+  // MapBuffer::getMapBuffer). Cast explicitly so memcpy(&x, ..., INT_SIZE)
+  // copies the full value, not the first 4 bytes of an 8-byte size_t.
+  auto mapBufferSize = static_cast<int32_t>(map.size());
 
-  auto offset = dynamicData_.size();
+  auto offset = static_cast<int32_t>(dynamicData_.size());
 
   // format [length of buffer (int)] + [bytes of MapBuffer]
   dynamicData_.resize(offset + INT_SIZE + mapBufferSize, 0);

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

@@ -22,6 +22,7 @@ target_link_libraries(react_renderer_mounting
         glog
         glog_init
         jsi
+        jsinspector_tracing
         react_debug
         react_renderer_core
         react_renderer_debug