react-native-tvos 0.77.0-0rc5 → 0.78.0-0

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();

package/ReactCommon/jserrorhandler/StackTraceParser.cpp

@@ -37,12 +37,12 @@ std::optional<int> toInt(std::string_view input) {
   return out;
 }
 
-JsErrorHandler::ParsedError::StackFrame parseStackFrame(
+JsErrorHandler::ProcessedError::StackFrame parseStackFrame(
     std::string_view file,
     std::string_view methodName,
     std::string_view lineStr,
     std::string_view columnStr) {
-  JsErrorHandler::ParsedError::StackFrame frame;
+  JsErrorHandler::ProcessedError::StackFrame frame;
   frame.file = file.empty() ? std::nullopt : std::optional(file);
   frame.methodName = !methodName.empty() ? methodName : UNKNOWN_FUNCTION;
   frame.lineNumber = !lineStr.empty() ? toInt(lineStr) : std::nullopt;
@@ -51,7 +51,7 @@ JsErrorHandler::ParsedError::StackFrame parseStackFrame(
   return frame;
 }
 
-std::optional<JsErrorHandler::ParsedError::StackFrame> parseChrome(
+std::optional<JsErrorHandler::ProcessedError::StackFrame> parseChrome(
     const std::string& line) {
   static const std::regex chromeRe(
       R"(^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$)",
@@ -84,7 +84,7 @@ std::optional<JsErrorHandler::ParsedError::StackFrame> parseChrome(
   return parseStackFrame(actualFile, methodName, lineStr, columnStr);
 }
 
-std::optional<JsErrorHandler::ParsedError::StackFrame> parseWinjs(
+std::optional<JsErrorHandler::ProcessedError::StackFrame> parseWinjs(
     const std::string& line) {
   static const std::regex winjsRe(
       R"(^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$)",
@@ -100,7 +100,7 @@ std::optional<JsErrorHandler::ParsedError::StackFrame> parseWinjs(
   return parseStackFrame(file, methodName, lineStr, columnStr);
 }
 
-std::optional<JsErrorHandler::ParsedError::StackFrame> parseGecko(
+std::optional<JsErrorHandler::ProcessedError::StackFrame> parseGecko(
     const std::string& line) {
   static const std::regex geckoRe(
       R"(^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$)",
@@ -129,7 +129,7 @@ std::optional<JsErrorHandler::ParsedError::StackFrame> parseGecko(
   return parseStackFrame(file, methodName, lineStr, columnStr);
 }
 
-std::optional<JsErrorHandler::ParsedError::StackFrame> parseJSC(
+std::optional<JsErrorHandler::ProcessedError::StackFrame> parseJSC(
     const std::string& line) {
   static const std::regex javaScriptCoreRe(
       R"(^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$)",
@@ -147,7 +147,7 @@ std::optional<JsErrorHandler::ParsedError::StackFrame> parseJSC(
   return parseStackFrame(file, methodName, lineStr, columnStr);
 }
 
-std::optional<JsErrorHandler::ParsedError::StackFrame> parseNode(
+std::optional<JsErrorHandler::ProcessedError::StackFrame> parseNode(
     const std::string& line) {
   static const std::regex nodeRe(
       R"(^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$)",
@@ -163,14 +163,14 @@ std::optional<JsErrorHandler::ParsedError::StackFrame> parseNode(
   return parseStackFrame(file, methodName, lineStr, columnStr);
 }
 
-std::vector<JsErrorHandler::ParsedError::StackFrame> parseOthers(
+std::vector<JsErrorHandler::ProcessedError::StackFrame> parseOthers(
     const std::string& stackString) {
-  std::vector<JsErrorHandler::ParsedError::StackFrame> stack;
+  std::vector<JsErrorHandler::ProcessedError::StackFrame> stack;
   std::istringstream iss(stackString);
   std::string line;
 
   while (std::getline(iss, line)) {
-    std::optional<JsErrorHandler::ParsedError::StackFrame> frame =
+    std::optional<JsErrorHandler::ProcessedError::StackFrame> frame =
         parseChrome(line);
 
     if (!frame) {
@@ -219,9 +219,9 @@ bool isInternalBytecodeSourceUrl(const std::string& sourceUrl) {
   return sourceUrl == "InternalBytecode.js";
 }
 
-std::vector<JsErrorHandler::ParsedError::StackFrame> convertHermesStack(
+std::vector<JsErrorHandler::ProcessedError::StackFrame> convertHermesStack(
     const std::vector<HermesStackEntry>& stack) {
-  std::vector<JsErrorHandler::ParsedError::StackFrame> frames;
+  std::vector<JsErrorHandler::ProcessedError::StackFrame> frames;
   for (const auto& entry : stack) {
     if (entry.type != "FRAME") {
       continue;
@@ -230,7 +230,7 @@ std::vector<JsErrorHandler::ParsedError::StackFrame> convertHermesStack(
         entry.location.type == "INTERNAL_BYTECODE") {
       continue;
     }
-    JsErrorHandler::ParsedError::StackFrame frame;
+    JsErrorHandler::ProcessedError::StackFrame frame;
     frame.methodName = entry.functionName;
     frame.file = entry.location.sourceUrl;
     frame.lineNumber = entry.location.line1Based;
@@ -282,7 +282,7 @@ HermesStackEntry parseLine(const std::string& line) {
   return entry;
 }
 
-std::vector<JsErrorHandler::ParsedError::StackFrame> parseHermes(
+std::vector<JsErrorHandler::ProcessedError::StackFrame> parseHermes(
     const std::string& stack) {
   static const std::regex RE_COMPONENT_NO_STACK(R"(^ {4}at .*?$)");
   std::istringstream stream(stack);
@@ -308,10 +308,10 @@ std::vector<JsErrorHandler::ParsedError::StackFrame> parseHermes(
 }
 } // namespace
 
-std::vector<JsErrorHandler::ParsedError::StackFrame> StackTraceParser::parse(
+std::vector<JsErrorHandler::ProcessedError::StackFrame> StackTraceParser::parse(
     const bool isHermes,
     const std::string& stackString) {
-  std::vector<JsErrorHandler::ParsedError::StackFrame> stackFrames =
+  std::vector<JsErrorHandler::ProcessedError::StackFrame> stackFrames =
       isHermes ? parseHermes(stackString) : parseOthers(stackString);
   return stackFrames;
 }

package/ReactCommon/jserrorhandler/StackTraceParser.h

@@ -15,7 +15,7 @@ namespace facebook::react {
 
 class StackTraceParser {
  public:
-  static std::vector<JsErrorHandler::ParsedError::StackFrame> parse(
+  static std::vector<JsErrorHandler::ProcessedError::StackFrame> parse(
       bool isHermes,
       const std::string& stackString);
 };