@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp

@@ -0,0 +1,155 @@
+/*
+ * 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 <memory>
+#include <queue>
+#include <utility>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <hermes/hermes.h>
+#include <jserrorhandler/JsErrorHandler.h>
+#include <jsi/jsi.h>
+#include <react/runtime/ReactInstance.h>
+
+namespace facebook::react {
+
+namespace {
+
+class MockTimerRegistry : public PlatformTimerRegistry {
+ public:
+  MOCK_METHOD(void, createTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, createRecurringTimer, (uint32_t, double), (override));
+  MOCK_METHOD(void, deleteTimer, (uint32_t), (override));
+};
+
+class MockMessageQueueThread : public MessageQueueThread {
+ public:
+  void runOnQueue(std::function<void()>&& func) override {
+    callbackQueue_.push(std::move(func));
+  }
+
+  void runOnQueueSync(std::function<void()>&& /*unused*/) override {}
+  void quitSynchronous() override {}
+
+  void tick() {
+    while (!callbackQueue_.empty()) {
+      auto callback = std::move(callbackQueue_.front());
+      callbackQueue_.pop();
+      callback();
+    }
+  }
+
+  size_t size() const {
+    return callbackQueue_.size();
+  }
+
+ private:
+  std::queue<std::function<void()>> callbackQueue_;
+};
+
+} // namespace
+
+class RuntimeExecutorShutdownTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    auto runtime =
+        std::make_unique<JSIRuntimeHolder>(hermes::makeHermesRuntime());
+    messageQueueThread_ = std::make_shared<MockMessageQueueThread>();
+    auto mockRegistry = std::make_unique<MockTimerRegistry>();
+    auto timerManager = std::make_shared<TimerManager>(std::move(mockRegistry));
+    auto onJsError =
+        [](jsi::Runtime& /*runtime*/,
+           const JsErrorHandler::ProcessedError& /*error*/) noexcept {};
+
+    instance_ = std::make_unique<ReactInstance>(
+        std::move(runtime),
+        messageQueueThread_,
+        timerManager,
+        std::move(onJsError));
+
+    // ReactInstance construction defers registering the RuntimeScheduler as the
+    // Hermes IEventLoopControl onto the runtime executor, which enqueues a
+    // callback on messageQueueThread_. Drain it so each shutdown scenario
+    // starts from an empty queue.
+    messageQueueThread_->tick();
+  }
+
+  std::shared_ptr<MockMessageQueueThread> messageQueueThread_;
+  std::unique_ptr<ReactInstance> instance_;
+};
+
+// Calling a held RuntimeExecutor after ReactInstance has been destroyed
+// must silently drop the callback. Use a shared_ptr captured into the
+// callback to also prove the callback itself is destroyed (not retained
+// somewhere indefinitely).
+TEST_F(
+    RuntimeExecutorShutdownTest,
+    heldExecutorCallAfterShutdownDropsCallback) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  instance_.reset();
+
+  auto tracker = std::make_shared<int>(0);
+  std::weak_ptr<int> weakTracker = tracker;
+  executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) {
+    FAIL() << "Callback should never run after shutdown";
+  });
+
+  EXPECT_EQ(messageQueueThread_->size(), 0u);
+  EXPECT_TRUE(weakTracker.expired())
+      << "Rejected callback (and its captures) should be destroyed";
+  messageQueueThread_->tick();
+}
+
+// Repeated post-shutdown invocations must remain memory-safe. This guards
+// against future refactors that swap the weak_ptr capture for a raw pointer
+// or shared_ptr.
+TEST_F(RuntimeExecutorShutdownTest, heldExecutorCallAfterShutdownDoesNotCrash) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  instance_.reset();
+
+  for (int i = 0; i < 100; ++i) {
+    executor([](jsi::Runtime& /*runtime*/) {
+      FAIL() << "Callback should never run after shutdown";
+    });
+  }
+  messageQueueThread_->tick();
+}
+
+// Work scheduled through the buffered executor sits in the internal buffer
+// until flush() (which only happens via loadScript). If the ReactInstance
+// is destroyed before flush, the buffered work must be dropped — never
+// surfaced on the JS queue and never retained past instance destruction.
+// A shared_ptr captured into the callback, watched via weak_ptr from
+// outside, proves the buffered queue actually releases its contents.
+TEST_F(
+    RuntimeExecutorShutdownTest,
+    pendingCallbackShutdownBeforeTickDropsCallback) {
+  RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor();
+
+  auto tracker = std::make_shared<int>(0);
+  std::weak_ptr<int> weakTracker = tracker;
+  executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) {
+    FAIL() << "Buffered callback should never run after shutdown";
+  });
+
+  EXPECT_EQ(messageQueueThread_->size(), 0u);
+  EXPECT_FALSE(weakTracker.expired())
+      << "Callback should still be alive in BufferedRuntimeExecutor's queue";
+
+  instance_.reset();
+
+  EXPECT_TRUE(weakTracker.expired())
+      << "Buffered callback should be destroyed when ReactInstance is";
+  messageQueueThread_->tick();
+}
+
+} // namespace facebook::react

package/ReactCommon/react/utils/Telemetry.h

@@ -81,19 +81,6 @@ DestinationTimePointT clockCast(SourceTimePointT timePoint)
       timePoint - sourseClockNow + destinationClockNow);
 }
 
-/*
- * Returns a number of seconds that passed from the UNIX Epoch starting time
- * point to a given time point.
- * Also known as POSIX time or UNIX Timestamp.
- */
-static inline double telemetryTimePointToSecondsSinceEpoch(TelemetryTimePoint timePoint)
-{
-  auto systemClockTimePoint = clockCast<std::chrono::system_clock::time_point, TelemetryTimePoint>(timePoint);
-  return (double)std::chrono::duration_cast<std::chrono::microseconds>(systemClockTimePoint.time_since_epoch())
-             .count() /
-      1000000.0;
-}
-
 /*
  * Returns a number of milliseconds that represents the given duration object.
  */

package/ReactCommon/react/utils/tests/Base64Tests.cpp

@@ -0,0 +1,36 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <react/utils/Base64.h>
+#include <string>
+
+namespace facebook::react {
+
+TEST(Base64Tests, encodesAsciiString) {
+  EXPECT_EQ(base64Encode("hello"), "aGVsbG8=");
+}
+
+TEST(Base64Tests, encodesEmptyString) {
+  EXPECT_EQ(base64Encode(""), "");
+}
+
+// Padding depends on input length modulo 3.
+TEST(Base64Tests, encodesWithCorrectPadding) {
+  EXPECT_EQ(base64Encode("a"), "YQ==");
+  EXPECT_EQ(base64Encode("ab"), "YWI=");
+  EXPECT_EQ(base64Encode("abc"), "YWJj");
+}
+
+// Binary safety: bytes that are invalid UTF-8 / contain NULs must round-trip.
+// This is the case that matters for binary ('base64'/arraybuffer) response
+// bodies in the NetworkingModule -- sending such bytes verbatim corrupts them.
+TEST(Base64Tests, encodesBinaryBytes) {
+  EXPECT_EQ(base64Encode(std::string("\x00\xff", 2)), "AP8=");
+}
+
+} // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfettoLogger.cpp

@@ -20,7 +20,6 @@ namespace {
 #if defined(WITH_PERFETTO)
 const HighResTimeStamp PROGRAM_INIT_TIME = HighResTimeStamp::now();
 const std::string PERFETTO_DEFAULT_TRACK_NAME = "# Web Performance";
-const std::string PERFETTO_TRACK_NAME_PREFIX = "# Web Performance: ";
 
 std::string toPerfettoTrackName(
     const std::optional<std::string_view>& trackName,

package/ReactCommon/runtimeexecutor/platform/ios/ReactCommon/RuntimeExecutorSyncUIThreadUtils.mm

@@ -9,9 +9,7 @@
 
 #import <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
 #import <react/debug/react_native_assert.h>
-#import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/utils/OnScopeExit.h>
-#import <algorithm>
 #import <functional>
 #import <future>
 #import <mutex>
@@ -111,8 +109,8 @@ void runUITask(UITask &uiTask)
 }
 
 /**
- * This method is resilient to multiple javascript threads.
- * This can happen when multiple react instances interleave.
+ * Coordinator-style implementation that is resilient to multiple javascript
+ * threads. This can happen when multiple react instances interleave.
  *
  * The extension from 1 js thread to n: All js threads race to
  * get a ticket to post a ui task. The first one to get the ticket
@@ -122,10 +120,13 @@ void runUITask(UITask &uiTask)
  *
  * For simplicity, we will just use this algorithm for all bg threads.
  * Not just the js thread.
+ *
+ * Requires the caller to be on the main thread, because the wait loop pumps
+ * UI tasks that are dispatched to the main queue.
  */
-void saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
+void coordinatedExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
-    std::function<void(jsi::Runtime &runtime)> &&runtimeWork)
+    std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
   react_native_assert([[NSThread currentThread] isMainThread] && !g_isRunningUITask);
 
@@ -159,52 +160,34 @@ void saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
   runtimeWork(*runtime);
 }
 
-/*
+/**
  * Schedules `runtimeWork` to be executed on the same thread using the
- * `RuntimeExecutor`, and blocks on its completion.
- *
- * Example:
- * - [UI thread] Schedule `runtimeCaptureBlock` on js thread
- * - [UI thread] Wait for runtime capture: await(runtime)
- * - [JS thread] Capture runtime for ui thread: resolve(runtime, &rt);
- * - [JS thread] Wait until runtimeWork done: await(runtimeWorkDone)
- * - [UI thread] Call runtimeWork: runtimeWork(*runtimePrt);
- * - [UI thread] Signal runtimeWork done: resolve(runtimeWorkDone)
- * - [UI thread] Wait until runtime capture block finished:
- *               await(runtimeCaptureBlockDone);
- * - [JS thread] Signal runtime capture block is finished:
- *               resolve(runtimeCaptureBlockDone);
+ * `RuntimeExecutor`, and blocks on its completion. Used when the caller is
+ * not on the main thread (the coordinator implementation requires main).
  */
-void legacyExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
+void simpleExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
     std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
   std::promise<jsi::Runtime *> runtime;
-  std::promise<void> runtimeCaptureBlockDone;
   std::promise<void> runtimeWorkDone;
 
   auto callingThread = std::this_thread::get_id();
 
-  auto runtimeCaptureBlock = [&](jsi::Runtime &rt) {
+  runtimeExecutor([&](jsi::Runtime &rt) {
     runtime.set_value(&rt);
 
-    auto runtimeThread = std::this_thread::get_id();
-    if (callingThread != runtimeThread) {
-      // Block `runtimeThread` on execution of `runtimeWork` on `callingThread`.
+    if (callingThread != std::this_thread::get_id()) {
+      // Block the runtime thread on execution of `runtimeWork` on the calling thread.
       runtimeWorkDone.get_future().wait();
     }
-
-    // TODO(T225331233): This is likely unnecessary. Remove it.
-    runtimeCaptureBlockDone.set_value();
-  };
-  runtimeExecutor(std::move(runtimeCaptureBlock));
+  });
 
   jsi::Runtime *runtimePtr = runtime.get_future().get();
-  runtimeWork(*runtimePtr);
-  runtimeWorkDone.set_value();
 
-  // TODO(T225331233): This is likely unnecessary. Remove it.
-  runtimeCaptureBlockDone.get_future().wait();
+  OnScopeExit onScopeExit([&]() { runtimeWorkDone.set_value(); });
+  // Calls into runtime scheduler, which takes care of error handling
+  runtimeWork(*runtimePtr);
 }
 
 } // namespace
@@ -213,10 +196,10 @@ void executeSynchronouslyOnSameThread_CAN_DEADLOCK(
     const RuntimeExecutor &runtimeExecutor,
     std::function<void(jsi::Runtime &)> &&runtimeWork)
 {
-  if (ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS()) {
-    saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
+  if ([[NSThread currentThread] isMainThread] && !g_isRunningUITask) {
+    coordinatedExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
   } else {
-    legacyExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
+    simpleExecuteSynchronouslyOnSameThread_CAN_DEADLOCK(runtimeExecutor, std::move(runtimeWork));
   }
 }
 

package/ReactCommon/yoga/Yoga.podspec

@@ -61,6 +61,6 @@ Pod::Spec.new do |spec|
   # Fabric must be able to access private headers (which should not be included in the umbrella header)
   all_header_files = 'yoga/**/*.h'
   all_header_files = File.join('ReactCommon/yoga', all_header_files) if ENV['INSTALL_YOGA_WITHOUT_PATH_OPTION']
-  spec.private_header_files = Dir.glob(all_header_files) - Dir.glob(public_header_files)
+  spec.private_header_files = Dir.glob(all_header_files).sort - Dir.glob(public_header_files).sort
   spec.preserve_paths = [all_header_files]
 end

package/ReactCommon/yoga/yoga/YGEnums.cpp

@@ -117,6 +117,8 @@ const char* YGErrataToString(const YGErrata value) {
       return "absolute-position-without-insets-excludes-padding";
     case YGErrataAbsolutePercentAgainstInnerSize:
       return "absolute-percent-against-inner-size";
+    case YGErrataMinSizeUndefinedInsteadOfAuto:
+      return "min-size-undefined-instead-of-auto";
     case YGErrataAll:
       return "all";
     case YGErrataClassic:

package/ReactCommon/yoga/yoga/YGEnums.h

@@ -67,6 +67,7 @@ YG_ENUM_DECL(
     YGErrataStretchFlexBasis = 1,
     YGErrataAbsolutePositionWithoutInsetsExcludesPadding = 2,
     YGErrataAbsolutePercentAgainstInnerSize = 4,
+    YGErrataMinSizeUndefinedInsteadOfAuto = 8,
     YGErrataAll = 2147483647,
     YGErrataClassic = 2147483646)
 YG_DEFINE_ENUM_FLAG_OPERATORS(YGErrata)

package/ReactCommon/yoga/yoga/YGNode.cpp

@@ -44,6 +44,7 @@ void YGNodeFree(const YGNodeRef nodeRef) {
   if (auto owner = node->getOwner()) {
     owner->removeChild(node);
     node->setOwner(nullptr);
+    owner->markDirtyAndPropagate();
   }
 
   const size_t childCount = node->getChildCount();
@@ -309,6 +310,32 @@ bool YGNodeHasMeasureFunc(YGNodeConstRef node) {
   return resolveRef(node)->hasMeasureFunc();
 }
 
+void YGNodeSetMinContentMeasureFunc(
+    YGNodeRef node,
+    YGMinContentMeasureFunc minContentMeasureFunc) {
+  resolveRef(node)->setMinContentMeasureFunc(minContentMeasureFunc);
+}
+
+bool YGNodeHasMinContentMeasureFunc(YGNodeConstRef node) {
+  return resolveRef(node)->hasMinContentMeasureFunc();
+}
+
+void YGNodeSetMinContentWidth(YGNodeRef node, float minContentWidth) {
+  resolveRef(node)->setMinContentWidth(FloatOptional{minContentWidth});
+}
+
+void YGNodeSetMinContentHeight(YGNodeRef node, float minContentHeight) {
+  resolveRef(node)->setMinContentHeight(FloatOptional{minContentHeight});
+}
+
+float YGNodeGetMinContentWidth(YGNodeConstRef node) {
+  return resolveRef(node)->getMinContentWidth().unwrapOrDefault(YGUndefined);
+}
+
+float YGNodeGetMinContentHeight(YGNodeConstRef node) {
+  return resolveRef(node)->getMinContentHeight().unwrapOrDefault(YGUndefined);
+}
+
 void YGNodeSetBaselineFunc(YGNodeRef node, YGBaselineFunc baselineFunc) {
   resolveRef(node)->setBaselineFunc(baselineFunc);
 }

package/ReactCommon/yoga/yoga/YGNode.h

@@ -220,6 +220,75 @@ YG_EXPORT void YGNodeSetMeasureFunc(YGNodeRef node, YGMeasureFunc measureFunc);
  */
 YG_EXPORT bool YGNodeHasMeasureFunc(YGNodeConstRef node);
 
+/**
+ * Optional companion to `YGMeasureFunc` invoked by the CSS Flexbox §4.5
+ * automatic minimum sizing path when probing this node for its min-content
+ * size along the main axis.
+ *
+ * The signature mirrors `YGMeasureFunc`. The algorithm calls this with
+ * `AtMost 0` along the probed axis and `Undefined` on the other. A
+ * min-content-aware Primitive can return its true minimum (e.g., `Image`
+ * and `Collection` along the scroll axis can return 0; text returns its
+ * longest-word width; etc.) without doing a full measure pass.
+ *
+ * When unset, the algorithm falls back to the regular `YGMeasureFunc`
+ * invoked with the same `AtMost 0` constraint — preserving today's
+ * behavior. Setting this is a perf opt-in for Primitives whose min-content
+ * size is cheap to compute or differs from what the regular measure would
+ * return.
+ */
+typedef YGSize (*YGMinContentMeasureFunc)(
+    YGNodeConstRef node,
+    float width,
+    YGMeasureMode widthMode,
+    float height,
+    YGMeasureMode heightMode);
+
+/**
+ * Provides a measure function specialised for min-content probes. See
+ * `YGMinContentMeasureFunc`.
+ */
+YG_EXPORT void YGNodeSetMinContentMeasureFunc(
+    YGNodeRef node,
+    YGMinContentMeasureFunc minContentMeasureFunc);
+
+/**
+ * Whether a min-content measure function is set.
+ */
+YG_EXPORT bool YGNodeHasMinContentMeasureFunc(YGNodeConstRef node);
+
+/**
+ * Static per-axis min-content size used by the CSS Flexbox §4.5 automatic
+ * minimum sizing probe. Pass `YGUndefined` to clear.
+ *
+ * When set, the algorithm's probe short-circuits at this node along the
+ * matching axis — skipping both the regular `YGMeasureFunc` / `YGMinContent
+ * MeasureFunc` callback path AND any container recursion. The most common
+ * use is declaring "0" for axes that have no min-content contribution per
+ * spec (e.g., images on both axes; scroll containers along their scroll
+ * axis).
+ *
+ * Precedence inside the probe is:
+ *   1. Static value via `YGNodeSetMinContentWidth/Height` (this API)
+ *   2. Dynamic callback via `YGNodeSetMinContentMeasureFunc`
+ *   3. Regular `YGMeasureFunc` with `AtMost 0` (today's default)
+ *   4. Container recursion (sum on main axis, max on cross)
+ *
+ * Static is preferred for known-constant values because it skips the JNI
+ * round-trip / native callback dispatch entirely.
+ */
+YG_EXPORT void YGNodeSetMinContentWidth(YGNodeRef node, float minContentWidth);
+YG_EXPORT void YGNodeSetMinContentHeight(
+    YGNodeRef node,
+    float minContentHeight);
+
+/**
+ * Returns the static min-content size along the requested axis, or
+ * `YGUndefined` if not set.
+ */
+YG_EXPORT float YGNodeGetMinContentWidth(YGNodeConstRef node);
+YG_EXPORT float YGNodeGetMinContentHeight(YGNodeConstRef node);
+
 /**
  * @returns a defined offset to baseline (ascent).
  */

package/ReactCommon/yoga/yoga/YGNodeLayout.h

@@ -7,8 +7,6 @@
 
 #pragma once
 
-#include <stdbool.h>
-
 #include <yoga/YGConfig.h>
 #include <yoga/YGEnums.h>
 #include <yoga/YGMacros.h>

package/ReactCommon/yoga/yoga/algorithm/AbsoluteLayout.cpp

@@ -558,7 +558,6 @@ bool layoutAbsoluteDescendants(
       // we need to mutate these descendents. Make sure the path of
       // nodes to them is mutable before positioning.
       child->cloneChildrenIfNeeded();
-      cleanupContentsNodesRecursively(child);
       const Direction childDirection =
           child->resolveDirection(currentNodeDirection);
       // By now all descendants of the containing block that are not absolute
@@ -584,6 +583,8 @@ bool layoutAbsoluteDescendants(
                          containingNodeAvailableInnerHeight) ||
           hasNewLayout;
 
+      cleanupContentsNodesRecursively(
+          child, /* didPerformLayout */ hasNewLayout);
       if (hasNewLayout) {
         child->setHasNewLayout(hasNewLayout);
       }