react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactCommon/cxxreact/JSExecutor.cpp

@@ -11,7 +11,9 @@
 
 #include <folly/Conv.h>
 #include <jsinspector-modern/ReactCdp.h>
-#include <reactperflogger/ReactPerfLogger.h>
+#include <react/timing/primitives.h>
+
+#include <chrono>
 
 namespace facebook::react {
 
@@ -25,7 +27,7 @@ std::string JSExecutor::getSyntheticBundlePath(
 }
 
 double JSExecutor::performanceNow() {
-  return ReactPerfLogger::performanceNow();
+  return chronoToDOMHighResTimeStamp(std::chrono::steady_clock::now());
 }
 
 jsinspector_modern::RuntimeTargetDelegate&

package/ReactCommon/cxxreact/ModuleRegistry.cpp

@@ -11,7 +11,7 @@
 #include <reactperflogger/BridgeNativeModulePerfLogger.h>
 
 #include "NativeModule.h"
-#include "SystraceSection.h"
+#include "TraceSection.h"
 
 namespace facebook::react {
 
@@ -46,7 +46,7 @@ void ModuleRegistry::updateModuleNamesFromIndex(size_t index) {
 
 void ModuleRegistry::registerModules(
     std::vector<std::unique_ptr<NativeModule>> modules) {
-  SystraceSection s_("ModuleRegistry::registerModules");
+  TraceSection s_("ModuleRegistry::registerModules");
   // Noop if there are no NativeModules to add
   if (modules.empty()) {
     return;
@@ -81,7 +81,7 @@ void ModuleRegistry::registerModules(
 }
 
 std::vector<std::string> ModuleRegistry::moduleNames() {
-  SystraceSection s_("ModuleRegistry::moduleNames");
+  TraceSection s_("ModuleRegistry::moduleNames");
   std::vector<std::string> names;
   for (size_t i = 0; i < modules_.size(); i++) {
     std::string name = normalizeName(modules_[i]->getName());
@@ -92,7 +92,7 @@ std::vector<std::string> ModuleRegistry::moduleNames() {
 }
 
 std::optional<ModuleConfig> ModuleRegistry::getConfig(const std::string& name) {
-  SystraceSection s("ModuleRegistry::getConfig", "module", name);
+  TraceSection s("ModuleRegistry::getConfig", "module", name);
 
   // Initialize modulesByName_
   if (modulesByName_.empty() && !modules_.empty()) {
@@ -144,7 +144,7 @@ std::optional<ModuleConfig> ModuleRegistry::getConfig(const std::string& name) {
   folly::dynamic config = folly::dynamic::array(name);
 
   {
-    SystraceSection s_("ModuleRegistry::getConstants", "module", name);
+    TraceSection s_("ModuleRegistry::getConstants", "module", name);
     /**
      * In the case that there are constants, we'll initialize the NativeModule,
      * and signal moduleJSRequireEndingStart. Otherwise, we'll simply signal the
@@ -155,7 +155,7 @@ std::optional<ModuleConfig> ModuleRegistry::getConfig(const std::string& name) {
   }
 
   {
-    SystraceSection s_("ModuleRegistry::getMethods", "module", name);
+    TraceSection s_("ModuleRegistry::getMethods", "module", name);
     std::vector<MethodDescriptor> methods = module->getMethods();
 
     folly::dynamic methodNames = folly::dynamic::array;

package/ReactCommon/cxxreact/NativeToJsBridge.cpp

@@ -21,7 +21,7 @@
 #include "ModuleRegistry.h"
 #include "MoveWrapper.h"
 #include "RAMBundleRegistry.h"
-#include "SystraceSection.h"
+#include "TraceSection.h"
 
 #include <memory>
 
@@ -194,7 +194,7 @@ void NativeToJsBridge::callFunction(
 #ifdef WITH_FBSYSTRACE
     FbSystraceAsyncFlow::end(
         TRACE_TAG_REACT_CXX_BRIDGE, "JSCall", systraceCookie);
-    SystraceSection s(
+    TraceSection s(
         "NativeToJsBridge::callFunction", "module", module, "method", method);
 #else
     (void)(systraceCookie);
@@ -229,7 +229,7 @@ void NativeToJsBridge::invokeCallback(
 #ifdef WITH_FBSYSTRACE
         FbSystraceAsyncFlow::end(
             TRACE_TAG_REACT_CXX_BRIDGE, "<callback>", systraceCookie);
-        SystraceSection s("NativeToJsBridge::invokeCallback");
+        TraceSection s("NativeToJsBridge::invokeCallback");
 #else
         (void)(systraceCookie);
 #endif

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -16,8 +16,8 @@ namespace facebook::react {
 
 constexpr struct {
   int32_t Major = 0;
-  int32_t Minor = 77;
-  int32_t Patch = 1;
+  int32_t Minor = 78;
+  int32_t Patch = 0;
   std::string_view Prerelease = "0";
 } ReactNativeVersion;
 

package/ReactCommon/cxxreact/SystraceSection.h

@@ -7,155 +7,22 @@
 
 #pragma once
 
-#ifdef WITH_FBSYSTRACE
-#include <fbsystrace.h>
-#endif
-
-#if defined(__APPLE__)
-// This is required so that OS_LOG_TARGET_HAS_10_15_FEATURES will be set.
-#include <os/trace_base.h>
-
-#if OS_LOG_TARGET_HAS_10_15_FEATURES && !defined(WITH_LOOM_TRACE)
-#include <os/log.h>
-#include <os/signpost.h>
-#include <sstream>
-#endif
-
-#endif
+#include "TraceSection.h"
 
+// NOTE: This is here for a backwards compatibility and should be removed once
+// all of the external references to `facebook::react::SystraceSection` are
+// gone.
 namespace facebook::react {
 
-/**
- * Allow providing an fbsystrace implementation that can short-circuit out
- * quickly and can throttle too frequent events so we can get useful traces even
- * if rendering etc. is spinning. For throttling we'll need file/line info so we
- * use a macro.
- */
 #if defined(WITH_LOOM_TRACE)
-#define SystraceSectionUnwrapped                                \
-  static constexpr const char systraceSectionFile[] = __FILE__; \
-  fbsystrace::FbSystraceSection<systraceSectionFile, __LINE__>
-/**
- * This is a convenience class to avoid lots of verbose profiling
- * #ifdefs.  If WITH_FBSYSTRACE is not defined, the optimizer will
- * remove this completely.  If it is defined, it will behave as
- * FbSystraceSection, with the right tag provided. Use two separate classes to
- * to ensure that the ODR rule isn't violated, that is, if WITH_FBSYSTRACE has
- * different values in different files, there is no inconsistency in the sizes
- * of defined symbols.
- */
-#elif defined(WITH_FBSYSTRACE)
-struct ConcreteSystraceSection {
- public:
-  template <typename... ConvertsToStringPiece>
-  explicit ConcreteSystraceSection(
-      const char* name,
-      ConvertsToStringPiece&&... args)
-      : m_section(TRACE_TAG_REACT_CXX_BRIDGE, name, args...) {}
-
- private:
-  fbsystrace::FbSystraceSection m_section;
-};
-using SystraceSectionUnwrapped = ConcreteSystraceSection;
+#define SystraceSection TraceSection
 #else
-struct DummySystraceSection {
- public:
-  template <typename... ConvertsToStringPiece>
-  explicit DummySystraceSection(
-      const __unused char* name,
-      __unused ConvertsToStringPiece&&... args) {}
-};
-using SystraceSectionUnwrapped = DummySystraceSection;
-#endif
-
-/**
- * On recent Apple platforms we want to leverage the Instruments signposts APIs.
- * To not break the other SystraceSection implementations above we wrap them.
- * In the case of WITH_LOOM_TRACE we don't use the signposts APIs because of the
- * templated type for SystraceSection.
- */
-#if defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
-    !defined(WITH_LOOM_TRACE)
-
-namespace systrace {
-
-template <typename T, typename = void>
-struct renderer {
-  static std::string render(const T& t) {
-    std::ostringstream oss;
-    oss << t;
-    return oss.str();
-  }
-};
-
-template <typename T>
-static auto render(const T& t)
-    -> decltype(renderer<T>::render(std::declval<const T&>())) {
-  return renderer<T>::render(t);
-}
-
-inline os_log_t instrumentsLogHandle = nullptr;
-
-static inline os_log_t getOrCreateInstrumentsLogHandle() {
-  if (!instrumentsLogHandle) {
-    instrumentsLogHandle = os_log_create(
-        "dev.reactnative.instruments", OS_LOG_CATEGORY_DYNAMIC_TRACING);
-  }
-  return instrumentsLogHandle;
-}
-
-} // namespace systrace
-
-struct SystraceSection {
- public:
+struct [[deprecated("Use TraceSection")]] SystraceSection
+    : public TraceSection {
   template <typename... ConvertsToStringPiece>
   explicit SystraceSection(const char* name, ConvertsToStringPiece&&... args)
-      : systraceSectionUnwrapped_(name, args...) {
-    os_log_t instrumentsLogHandle = systrace::getOrCreateInstrumentsLogHandle();
-
-    // If the log isn't enabled, we don't want the performance overhead of the
-    // rest of the code below.
-    if (!os_signpost_enabled(instrumentsLogHandle)) {
-      return;
-    }
-
-    name_ = name;
-
-    const auto argsVector = std::vector<std::string>{systrace::render(args)...};
-    std::string argsString = "";
-    for (size_t i = 0; i < argsVector.size(); i += 2) {
-      argsString += argsVector[i] + "=" + argsVector[i + 1] + ";";
-    }
-
-    signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
-
-    os_signpost_interval_begin(
-        instrumentsLogHandle,
-        signpostID_,
-        "Systrace",
-        "%s begin: %s",
-        name,
-        argsString.c_str());
-  }
-
-  ~SystraceSection() {
-    // We don't need to gate on os_signpost_enabled here because it's already
-    // checked in os_signpost_interval_end.
-    os_signpost_interval_end(
-        systrace::instrumentsLogHandle,
-        signpostID_,
-        "Systrace",
-        "%s end",
-        name_.data());
-  }
-
- private:
-  os_signpost_id_t signpostID_ = OS_SIGNPOST_ID_INVALID;
-  std::string_view name_;
-  SystraceSectionUnwrapped systraceSectionUnwrapped_;
+      : TraceSection(name, args...) {}
 };
-#else
-#define SystraceSection SystraceSectionUnwrapped
 #endif
 
 } // namespace facebook::react

package/ReactCommon/cxxreact/TraceSection.h

@@ -0,0 +1,181 @@
+/*
+ * 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
+
+#ifdef WITH_FBSYSTRACE
+#include <fbsystrace.h>
+#endif
+
+#ifdef WITH_PERFETTO
+#include <perfetto.h>
+#include <reactperflogger/ReactPerfettoCategories.h>
+#endif
+
+#if defined(__APPLE__)
+// This is required so that OS_LOG_TARGET_HAS_10_15_FEATURES will be set.
+#include <os/trace_base.h>
+
+#if OS_LOG_TARGET_HAS_10_15_FEATURES && !defined(WITH_LOOM_TRACE)
+#include <os/log.h>
+#include <os/signpost.h>
+#include <sstream>
+#endif
+
+#endif
+
+namespace facebook::react {
+
+/**
+ * Allow providing an fbsystrace implementation that can short-circuit out
+ * quickly and can throttle too frequent events so we can get useful traces even
+ * if rendering etc. is spinning. For throttling we'll need file/line info so we
+ * use a macro.
+ */
+#if defined(WITH_LOOM_TRACE)
+#define TraceSectionUnwrapped                                   \
+  static constexpr const char systraceSectionFile[] = __FILE__; \
+  fbsystrace::FbSystraceSection<systraceSectionFile, __LINE__>
+/**
+ * This is a convenience class to avoid lots of verbose profiling
+ * #ifdefs.  If WITH_FBSYSTRACE is not defined, the optimizer will
+ * remove this completely.  If it is defined, it will behave as
+ * FbSystraceSection, with the right tag provided. Use two separate classes to
+ * to ensure that the ODR rule isn't violated, that is, if WITH_FBSYSTRACE has
+ * different values in different files, there is no inconsistency in the sizes
+ * of defined symbols.
+ */
+#elif defined(WITH_PERFETTO)
+struct TraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit TraceSection(
+      const __unused char* name,
+      __unused ConvertsToStringPiece&&... args) {
+    TRACE_EVENT_BEGIN("react-native", perfetto::DynamicString{name}, args...);
+  }
+
+  ~TraceSection() {
+    TRACE_EVENT_END("react-native");
+  }
+};
+using TraceSectionUnwrapped = TraceSection;
+#elif defined(WITH_FBSYSTRACE)
+struct ConcreteTraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit ConcreteTraceSection(
+      const char* name,
+      ConvertsToStringPiece&&... args)
+      : m_section(TRACE_TAG_REACT_CXX_BRIDGE, name, args...) {}
+
+ private:
+  fbsystrace::FbSystraceSection m_section;
+};
+using TraceSectionUnwrapped = ConcreteTraceSection;
+#else
+struct DummyTraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit DummyTraceSection(
+      const __unused char* name,
+      __unused ConvertsToStringPiece&&... args) {}
+};
+using TraceSectionUnwrapped = DummyTraceSection;
+#endif
+
+/**
+ * On recent Apple platforms we want to leverage the Instruments signposts APIs.
+ * To not break the other TraceSection implementations above we wrap them.
+ * In the case of WITH_LOOM_TRACE we don't use the signposts APIs because of the
+ * templated type for TraceSection.
+ */
+#if defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
+    !defined(WITH_LOOM_TRACE)
+
+namespace systrace {
+
+template <typename T, typename = void>
+struct renderer {
+  static std::string render(const T& t) {
+    std::ostringstream oss;
+    oss << t;
+    return oss.str();
+  }
+};
+
+template <typename T>
+static auto render(const T& t)
+    -> decltype(renderer<T>::render(std::declval<const T&>())) {
+  return renderer<T>::render(t);
+}
+
+inline os_log_t instrumentsLogHandle = nullptr;
+
+static inline os_log_t getOrCreateInstrumentsLogHandle() {
+  if (!instrumentsLogHandle) {
+    instrumentsLogHandle = os_log_create(
+        "dev.reactnative.instruments", OS_LOG_CATEGORY_DYNAMIC_TRACING);
+  }
+  return instrumentsLogHandle;
+}
+
+} // namespace systrace
+
+struct TraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit TraceSection(const char* name, ConvertsToStringPiece&&... args)
+      : systraceSectionUnwrapped_(name, args...) {
+    os_log_t instrumentsLogHandle = systrace::getOrCreateInstrumentsLogHandle();
+
+    // If the log isn't enabled, we don't want the performance overhead of the
+    // rest of the code below.
+    if (!os_signpost_enabled(instrumentsLogHandle)) {
+      return;
+    }
+
+    name_ = name;
+
+    const auto argsVector = std::vector<std::string>{systrace::render(args)...};
+    std::string argsString = "";
+    for (size_t i = 0; i < argsVector.size(); i += 2) {
+      argsString += argsVector[i] + "=" + argsVector[i + 1] + ";";
+    }
+
+    signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
+
+    os_signpost_interval_begin(
+        instrumentsLogHandle,
+        signpostID_,
+        "Systrace",
+        "%s begin: %s",
+        name,
+        argsString.c_str());
+  }
+
+  ~TraceSection() {
+    // We don't need to gate on os_signpost_enabled here because it's already
+    // checked in os_signpost_interval_end.
+    os_signpost_interval_end(
+        systrace::instrumentsLogHandle,
+        signpostID_,
+        "Systrace",
+        "%s end",
+        name_.data());
+  }
+
+ private:
+  os_signpost_id_t signpostID_ = OS_SIGNPOST_ID_INVALID;
+  std::string_view name_;
+  TraceSectionUnwrapped systraceSectionUnwrapped_;
+};
+#else
+#define TraceSection TraceSectionUnwrapped
+#endif
+
+} // namespace facebook::react

package/ReactCommon/cxxreact/tests/jsbigstring.cpp

@@ -60,3 +60,22 @@ TEST(JSBigFileString, MapPartTest) {
     EXPECT_EQ(needle[i], bigStr.c_str()[i]);
   }
 }
+
+TEST(JSBigFileString, MapPartAtLargeOffsetTest) {
+  std::string data(8 * 4096, 'X');
+  data += "Hello World!";
+
+  // Sub-string to actually map
+  std::string needle{"or"};
+  off_t offset = data.find(needle);
+
+  // Initialise Big String
+  int fd = tempFileFromString(data);
+  JSBigFileString bigStr{fd, needle.size(), offset};
+
+  // Test
+  EXPECT_EQ(needle.length(), bigStr.size());
+  for (unsigned int i = 0; i < needle.length(); ++i) {
+    EXPECT_EQ(needle[i], bigStr.c_str()[i]);
+  }
+}

package/ReactCommon/hermes/executor/HermesExecutorFactory.cpp

@@ -8,7 +8,7 @@
 #include "HermesExecutorFactory.h"
 
 #include <cxxreact/MessageQueueThread.h>
-#include <cxxreact/SystraceSection.h>
+#include <cxxreact/TraceSection.h>
 #include <hermes/hermes.h>
 #include <jsi/decorator.h>
 #include <jsinspector-modern/InspectorFlags.h>
@@ -197,7 +197,7 @@ std::unique_ptr<JSExecutor> HermesExecutorFactory::createJSExecutor(
     std::shared_ptr<MessageQueueThread> jsQueue) {
   std::unique_ptr<HermesRuntime> hermesRuntime;
   {
-    SystraceSection s("makeHermesRuntime");
+    TraceSection s("makeHermesRuntime");
     hermesRuntime = hermes::makeHermesRuntime(runtimeConfig_);
   }
 

package/ReactCommon/jsc/JSCRuntime.cpp

@@ -382,13 +382,11 @@ JSCRuntime::JSCRuntime(JSGlobalContextRef ctx)
 {
 #ifndef NDEBUG
 #ifdef _JSC_HAS_INSPECTABLE
-#if (__OSX_AVAILABLE_STARTING(MAC_NA, IPHONE_16_4))
   if (__builtin_available(macOS 13.3, iOS 16.4, tvOS 16.4, *)) {
     JSGlobalContextSetInspectable(ctx_, true);
   }
 #endif
 #endif
-#endif
 }
 
 JSCRuntime::~JSCRuntime() {

package/ReactCommon/jsc/React-jsc.podspec

@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files           = "JSCRuntime.{cpp,h}"
   s.exclude_files          = "**/test/*"
-  s.framework              = "JavaScriptCore"
+  s.weak_framework         = "JavaScriptCore"
 
   s.dependency "React-jsi", version
 

package/ReactCommon/jserrorhandler/JsErrorHandler.cpp

@@ -29,9 +29,12 @@ bool isLooselyNull(const jsi::Value& value) {
   return value.isNull() || value.isUndefined();
 }
 
-bool isEmptyString(jsi::Runtime& runtime, const jsi::Value& value) {
+bool isEqualTo(
+    jsi::Runtime& runtime,
+    const jsi::Value& value,
+    const std::string& str) {
   return jsi::Value::strictEquals(
-      runtime, value, jsi::String::createFromUtf8(runtime, ""));
+      runtime, value, jsi::String::createFromUtf8(runtime, str));
 }
 
 std::string stringifyToCpp(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -121,10 +124,10 @@ jsi::Value getBundleMetadata(jsi::Runtime& runtime, jsi::JSError& error) {
 namespace facebook::react {
 
 template <>
-struct Bridging<JsErrorHandler::ParsedError::StackFrame> {
+struct Bridging<JsErrorHandler::ProcessedError::StackFrame> {
   static jsi::Value toJs(
       jsi::Runtime& runtime,
-      const JsErrorHandler::ParsedError::StackFrame& frame) {
+      const JsErrorHandler::ProcessedError::StackFrame& frame) {
     auto stackFrame = jsi::Object(runtime);
     auto file = bridging::toJs(runtime, frame.file, nullptr);
     auto lineNumber = bridging::toJs(runtime, frame.lineNumber, nullptr);
@@ -139,10 +142,10 @@ struct Bridging<JsErrorHandler::ParsedError::StackFrame> {
 };
 
 template <>
-struct Bridging<JsErrorHandler::ParsedError> {
+struct Bridging<JsErrorHandler::ProcessedError> {
   static jsi::Value toJs(
       jsi::Runtime& runtime,
-      const JsErrorHandler::ParsedError& error) {
+      const JsErrorHandler::ProcessedError& error) {
     auto data = jsi::Object(runtime);
     data.setProperty(runtime, "message", error.message);
     data.setProperty(
@@ -172,7 +175,7 @@ struct Bridging<JsErrorHandler::ParsedError> {
 
 std::ostream& operator<<(
     std::ostream& os,
-    const JsErrorHandler::ParsedError::StackFrame& frame) {
+    const JsErrorHandler::ProcessedError::StackFrame& frame) {
   auto file = frame.file ? quote(*frame.file) : "nil";
   auto methodName = quote(frame.methodName);
   auto lineNumber =
@@ -185,7 +188,7 @@ std::ostream& operator<<(
 }
 std::ostream& operator<<(
     std::ostream& os,
-    const JsErrorHandler::ParsedError& error) {
+    const JsErrorHandler::ProcessedError& error) {
   auto message = quote(error.message);
   auto originalMessage =
       error.originalMessage ? quote(*error.originalMessage) : "nil";
@@ -196,7 +199,7 @@ std::ostream& operator<<(
   auto isFatal = std::to_string(static_cast<int>(error.isFatal));
   auto extraData = "jsi::Object{ <omitted> } ";
 
-  os << "ParsedError {\n"
+  os << "ProcessedError {\n"
      << "  .message = " << message << "\n"
      << "  .originalMessage = " << originalMessage << "\n"
      << "  .name = " << name << "\n"
@@ -265,7 +268,7 @@ void JsErrorHandler::handleErrorWithCppPipeline(
   }
 
   auto nameValue = errorObj.getProperty(runtime, "name");
-  auto name = (isLooselyNull(nameValue) || isEmptyString(runtime, nameValue))
+  auto name = (isLooselyNull(nameValue) || isEqualTo(runtime, nameValue, ""))
       ? std::nullopt
       : std::optional(stringifyToCpp(runtime, nameValue));
 
@@ -326,7 +329,7 @@ void JsErrorHandler::handleErrorWithCppPipeline(
 
   auto id = nextExceptionId();
 
-  ParsedError parsedError = {
+  ProcessedError processedError = {
       .message =
           _isRuntimeReady ? message : ("[runtime not ready]: " + message),
       .originalMessage = originalMessage,
@@ -338,7 +341,7 @@ void JsErrorHandler::handleErrorWithCppPipeline(
       .extraData = std::move(extraData),
   };
 
-  auto data = bridging::toJs(runtime, parsedError).asObject(runtime);
+  auto data = bridging::toJs(runtime, processedError).asObject(runtime);
 
   auto isComponentError =
       isTruthy(runtime, errorObj.getProperty(runtime, "isComponentError"));
@@ -348,7 +351,7 @@ void JsErrorHandler::handleErrorWithCppPipeline(
     auto console = runtime.global().getPropertyAsObject(runtime, "console");
     auto errorFn = console.getPropertyAsFunction(runtime, "error");
     auto finalMessage =
-        jsi::String::createFromUtf8(runtime, parsedError.message);
+        jsi::String::createFromUtf8(runtime, processedError.message);
     errorFn.callWithThis(runtime, console, finalMessage);
   }
 
@@ -383,14 +386,19 @@ void JsErrorHandler::handleErrorWithCppPipeline(
     return;
   }
 
-  if (isFatal) {
-    if (_hasHandledFatalError) {
-      return;
+  auto errorType = errorObj.getProperty(runtime, "type");
+  auto isWarn = isEqualTo(runtime, errorType, "warn");
+
+  if (isFatal || !isWarn) {
+    if (isFatal) {
+      if (_hasHandledFatalError) {
+        return;
+      }
+      _hasHandledFatalError = true;
     }
-    _hasHandledFatalError = true;
-  }
 
-  _onJsError(runtime, parsedError);
+    _onJsError(runtime, processedError);
+  }
 }
 
 void JsErrorHandler::registerErrorListener(

package/ReactCommon/jserrorhandler/JsErrorHandler.h

@@ -15,7 +15,7 @@ namespace facebook::react {
 
 class JsErrorHandler {
  public:
-  struct ParsedError {
+  struct ProcessedError {
     struct StackFrame {
       std::optional<std::string> file;
       std::string methodName;
@@ -34,11 +34,13 @@ class JsErrorHandler {
     int id;
     bool isFatal;
     jsi::Object extraData;
-    friend std::ostream& operator<<(std::ostream& os, const ParsedError& error);
+    friend std::ostream& operator<<(
+        std::ostream& os,
+        const ProcessedError& error);
   };
 
   using OnJsError =
-      std::function<void(jsi::Runtime& runtime, const ParsedError& error)>;
+      std::function<void(jsi::Runtime& runtime, const ProcessedError& error)>;
 
   explicit JsErrorHandler(OnJsError onJsError);
   ~JsErrorHandler();