react-native-tvos 0.83.6-0 → 0.83.10-0

package/ReactCommon/react/debug/redbox/RedBoxErrorParser.cpp

@@ -0,0 +1,171 @@
+/*
+ * 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 "RedBoxErrorParser.h"
+
+#include <regex> // NOLINT(facebook-hte-BadInclude-regex)
+#include <unordered_set>
+
+// @lint-ignore-every CLANGTIDY facebook-hte-StdRegexIsAwful
+namespace facebook::react::unstable_redbox {
+
+namespace {
+
+const std::regex& metroErrorRegex() {
+  static const std::regex re(
+      R"(^(?:InternalError Metro has encountered an error:) (.*): (.*) \((\d+):(\d+)\)\n\n([\s\S]+))");
+  return re;
+}
+
+const std::regex& babelTransformErrorRegex() {
+  static const std::regex re(
+      R"(^(?:TransformError )?(?:SyntaxError: |ReferenceError: )(.*): (.*) \((\d+):(\d+)\)\n\n([\s\S]+))");
+  return re;
+}
+
+const std::regex& bundleLoadErrorRegex() {
+  static const std::regex re(R"(^(\w+) in (\S+): (.+) \((\d+):(\d+)\))");
+  return re;
+}
+
+const std::regex& babelCodeFrameErrorRegex() {
+  static const std::regex re(
+      R"(^(?:TransformError )?(?:.*):? (?:.*?)(\/.*): ([\s\S]+?)\n([ >]{2}[\d\s]+ \|[\s\S]+|\x1b[\s\S]+))");
+  return re;
+}
+
+bool startsWithTransformError(const std::string& msg) {
+  return msg.rfind("TransformError ", 0) == 0;
+}
+
+const std::unordered_set<std::string>& knownBundleLoadErrorTypes() {
+  static const std::unordered_set<std::string> types{
+      "SyntaxError", "ReferenceError", "TypeError", "UnableToResolveError"};
+  return types;
+}
+
+} // namespace
+
+ParsedError parseErrorMessage(
+    const std::string& message,
+    const std::string& name,
+    const std::string& componentStack,
+    bool isFatal) {
+  std::smatch match;
+
+  if (message.empty()) {
+    return ParsedError{
+        .title = isFatal ? "Uncaught Error" : "Error",
+        .message = "",
+        .codeFrame = std::nullopt,
+        .isCompileError = false,
+    };
+  }
+
+  // 1. Metro internal error
+  if (std::regex_search(message, match, metroErrorRegex())) {
+    return ParsedError{
+        .title = match[1].str().empty() ? "Metro Error" : match[1].str(),
+        .message = match[2].str(),
+        .codeFrame =
+            CodeFrame{
+                .content = match[5].str(),
+                .fileName = "",
+                .row = std::stoi(match[3].str()),
+                .column = std::stoi(match[4].str()),
+            },
+        .isCompileError = true,
+    };
+  }
+
+  // 2. Babel transform error
+  if (std::regex_search(message, match, babelTransformErrorRegex())) {
+    return ParsedError{
+        .title = "Syntax Error",
+        .message = match[2].str(),
+        .codeFrame =
+            CodeFrame{
+                .content = match[5].str(),
+                .fileName = match[1].str(),
+                .row = std::stoi(match[3].str()),
+                .column = std::stoi(match[4].str()),
+            },
+        .isCompileError = true,
+    };
+  }
+
+  // 3. Bundle loading error: "ErrorType in /path: message (line:col)"
+  if (std::regex_search(message, match, bundleLoadErrorRegex())) {
+    const auto& errorType = match[1].str();
+    if (knownBundleLoadErrorTypes().count(errorType) > 0) {
+      std::string title = errorType == "UnableToResolveError"
+          ? "Module Not Found"
+          : "Syntax Error";
+      std::optional<std::string> codeFrameContent;
+      auto newlinePos = message.find('\n');
+      if (newlinePos != std::string::npos) {
+        codeFrameContent = message.substr(newlinePos + 1);
+      }
+      return ParsedError{
+          .title = title,
+          .message = match[3].str(),
+          .codeFrame =
+              CodeFrame{
+                  .content = codeFrameContent.value_or(""),
+                  .fileName = match[2].str(),
+                  .row = std::stoi(match[4].str()),
+                  .column = std::stoi(match[5].str()),
+              },
+          .isCompileError = true,
+      };
+    }
+  }
+
+  // 4. Babel code frame error
+  if (std::regex_search(message, match, babelCodeFrameErrorRegex())) {
+    return ParsedError{
+        .title = "Syntax Error",
+        .message = match[2].str(),
+        .codeFrame =
+            CodeFrame{
+                .content = match[3].str(),
+                .fileName = match[1].str(),
+            },
+        .isCompileError = true,
+    };
+  }
+
+  // 5. Generic transform error (no code frame)
+  if (startsWithTransformError(message)) {
+    return ParsedError{
+        .title = "Syntax Error",
+        .message = message,
+        .codeFrame = std::nullopt,
+        .isCompileError = true,
+    };
+  }
+
+  // 6. Determine title from context (matching LogBoxInspectorHeader title map)
+  std::string title;
+  if (!name.empty()) {
+    title = name;
+  } else if (!componentStack.empty()) {
+    title = "Render Error";
+  } else if (isFatal) {
+    title = "Uncaught Error";
+  } else {
+    title = "Error";
+  }
+  return ParsedError{
+      .title = title,
+      .message = message,
+      .codeFrame = std::nullopt,
+      .isCompileError = false,
+  };
+}
+
+} // namespace facebook::react::unstable_redbox

package/ReactCommon/react/debug/redbox/RedBoxErrorParser.h

@@ -0,0 +1,40 @@
+/*
+ * 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 <optional>
+#include <string>
+
+namespace facebook::react::unstable_redbox {
+
+struct CodeFrame {
+  std::string content;
+  std::string fileName;
+  int row = 0;
+  int column = 0;
+};
+
+struct ParsedError {
+  std::string title;
+  std::string message;
+  std::optional<CodeFrame> codeFrame;
+  bool isCompileError = false;
+  bool isRetryable = true;
+};
+
+/**
+ * Parse a raw error message into structured components.
+ * C++ port of parseLogBoxException from parseLogBoxLog.js.
+ */
+ParsedError parseErrorMessage(
+    const std::string &message,
+    const std::string &name = "",
+    const std::string &componentStack = "",
+    bool isFatal = true);
+
+} // namespace facebook::react::unstable_redbox

package/ReactCommon/react/debug/redbox/tests/AnsiParserTest.cpp

@@ -0,0 +1,97 @@
+/*
+ * 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/debug/redbox/AnsiParser.h>
+
+using namespace facebook::react::unstable_redbox;
+
+TEST(AnsiParserTest, ParsesPlainText) {
+  auto spans = parseAnsi("hello world");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "hello world");
+  EXPECT_FALSE(spans[0].foregroundColor.has_value());
+  EXPECT_FALSE(spans[0].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ParsesRedForeground) {
+  auto spans = parseAnsi("\x1b[31mred text\x1b[0m normal");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "red text");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 187);
+  EXPECT_EQ(spans[0].foregroundColor->g, 86);
+  EXPECT_EQ(spans[0].foregroundColor->b, 83);
+
+  EXPECT_EQ(spans[1].text, " normal");
+  EXPECT_FALSE(spans[1].foregroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ParsesMultipleColors) {
+  auto spans = parseAnsi("\x1b[32mgreen\x1b[34mblue\x1b[0m");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "green");
+  EXPECT_EQ(spans[0].foregroundColor->r, 144);
+  EXPECT_EQ(spans[1].text, "blue");
+  EXPECT_EQ(spans[1].foregroundColor->r, 125);
+}
+
+TEST(AnsiParserTest, ParsesBrightColors) {
+  auto spans = parseAnsi("\x1b[93myellow\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "yellow");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 234);
+}
+
+TEST(AnsiParserTest, ParsesBackgroundColor) {
+  auto spans = parseAnsi("\x1b[41mred bg\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "red bg");
+  EXPECT_FALSE(spans[0].foregroundColor.has_value());
+  ASSERT_TRUE(spans[0].backgroundColor.has_value());
+  EXPECT_EQ(spans[0].backgroundColor->r, 187);
+  EXPECT_EQ(spans[0].backgroundColor->g, 86);
+  EXPECT_EQ(spans[0].backgroundColor->b, 83);
+}
+
+TEST(AnsiParserTest, ResetClearsBackground) {
+  auto spans = parseAnsi("\x1b[31;42mcolored\x1b[49mfg only\x1b[0m");
+  ASSERT_EQ(spans.size(), 2);
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  ASSERT_TRUE(spans[0].backgroundColor.has_value());
+  ASSERT_TRUE(spans[1].foregroundColor.has_value());
+  EXPECT_FALSE(spans[1].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, ResetShorthandClearsColors) {
+  auto spans = parseAnsi("\x1b[31mred\x1b[mplain");
+  ASSERT_EQ(spans.size(), 2);
+  EXPECT_EQ(spans[0].text, "red");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[1].text, "plain");
+  EXPECT_FALSE(spans[1].foregroundColor.has_value());
+  EXPECT_FALSE(spans[1].backgroundColor.has_value());
+}
+
+TEST(AnsiParserTest, StripsAnsi) {
+  auto result = stripAnsi("\x1b[31mred\x1b[0m and \x1b[32mgreen\x1b[0m");
+  EXPECT_EQ(result, "red and green");
+}
+
+TEST(AnsiParserTest, HandlesEmptyString) {
+  auto spans = parseAnsi("");
+  EXPECT_TRUE(spans.empty());
+}
+
+TEST(AnsiParserTest, HandlesSemicolonSeparatedCodes) {
+  auto spans = parseAnsi("\x1b[1;31mtext\x1b[0m");
+  ASSERT_EQ(spans.size(), 1);
+  EXPECT_EQ(spans[0].text, "text");
+  ASSERT_TRUE(spans[0].foregroundColor.has_value());
+  EXPECT_EQ(spans[0].foregroundColor->r, 187);
+}

package/ReactCommon/react/debug/redbox/tests/JscSafeUrlTest.cpp

@@ -0,0 +1,173 @@
+/*
+ * 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/debug/redbox/JscSafeUrl.h>
+
+using namespace facebook::react::unstable_redbox;
+
+// --- toNormalUrl ---
+
+// Rewrites urls treating //& in paths as ?
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInAbsolutePath) {
+  EXPECT_EQ(
+      toNormalUrl("/path1/path2//&foo=bar?bar=baz#frag?"),
+      "/path1/path2?foo=bar&bar=baz#frag?");
+  // Idempotent
+  EXPECT_EQ(
+      toNormalUrl("/path1/path2?foo=bar&bar=baz#frag?"),
+      "/path1/path2?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInRelativePathWithEncoding) {
+  EXPECT_EQ(
+      toNormalUrl("relative/path/with%3B%26/encoded//&foo=bar?bar=baz#frag?"),
+      "relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?");
+  EXPECT_EQ(
+      toNormalUrl("relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?"),
+      "relative/path/with%3B%26/encoded?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerInFullUrl) {
+  EXPECT_EQ(
+      toNormalUrl(
+          "https://user:password@mydomain.com:8080/path1/path2//&foo=bar?bar=baz#frag?"),
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?");
+  EXPECT_EQ(
+      toNormalUrl(
+          "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?"),
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=baz#frag?");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_RewritesMarkerWithoutFragment) {
+  EXPECT_EQ(
+      toNormalUrl("http://127.0.0.1/path1/path2//&foo=bar&bar=baz"),
+      "http://127.0.0.1/path1/path2?foo=bar&bar=baz");
+  EXPECT_EQ(
+      toNormalUrl("http://127.0.0.1/path1/path2?foo=bar&bar=baz"),
+      "http://127.0.0.1/path1/path2?foo=bar&bar=baz");
+}
+
+// Returns other strings exactly as given
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForQueryWithMarkerAfter) {
+  auto url = "http://user:password/@mydomain.com/foo?bar=zoo?baz=quux//&";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForSimpleQuery) {
+  auto url = "/foo?bar=zoo?baz=quux";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForOpaqueUri) {
+  auto url = "proto:arbitrary_bad_url";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForStar) {
+  EXPECT_EQ(toNormalUrl("*"), "*");
+}
+
+TEST(JscSafeUrlTest, ToNormalUrl_PassthroughForRelativePath) {
+  auto url = "relative/path";
+  EXPECT_EQ(toNormalUrl(url), url);
+}
+
+// --- toJscSafeUrl ---
+
+// Replaces the first ? with a JSC-friendly delimiter, url-encodes subsequent
+// ?, and is idempotent
+TEST(JscSafeUrlTest, ToJscSafeUrl_FullUrlWithEncodedQuestionMark) {
+  auto input =
+      "https://user:password@mydomain.com:8080/path1/path2?foo=bar&bar=question?#frag?";
+  auto output =
+      "https://user:password@mydomain.com:8080/path1/path2//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_SimpleUrl) {
+  auto input = "http://127.0.0.1/path1/path2?foo=bar";
+  auto output = "http://127.0.0.1/path1/path2//&foo=bar";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForStar) {
+  EXPECT_EQ(toJscSafeUrl("*"), "*");
+  EXPECT_EQ(toJscSafeUrl("*"), "*");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForAbsolutePath) {
+  EXPECT_EQ(toJscSafeUrl("/absolute/path"), "/absolute/path");
+  EXPECT_EQ(toJscSafeUrl("/absolute/path"), "/absolute/path");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForRelativePath) {
+  EXPECT_EQ(toJscSafeUrl("relative/path"), "relative/path");
+  EXPECT_EQ(toJscSafeUrl("relative/path"), "relative/path");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_EmptyQueryDropped) {
+  EXPECT_EQ(toJscSafeUrl("/?"), "/");
+  EXPECT_EQ(toJscSafeUrl("/"), "/");
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_PassthroughForUrlWithoutQuery) {
+  auto url = "http://127.0.0.1/path1/path";
+  EXPECT_EQ(toJscSafeUrl(url), url);
+  EXPECT_EQ(toJscSafeUrl(url), url);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_AbsolutePathWithEncodedQuestionMark) {
+  auto input = "/path1/path2?foo=bar&bar=question?#frag?";
+  auto output = "/path1/path2//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_RelativePathWithEncodedQuestionMark) {
+  auto input = "relative/path?foo=bar&bar=question?#frag?";
+  auto output = "relative/path//&foo=bar&bar=question%3F#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+TEST(JscSafeUrlTest, ToJscSafeUrl_AlreadySafeWithExtraQuery) {
+  auto input = "/path1/path2//&foo=bar&bar=question%3F?extra=query#frag?";
+  auto output = "/path1/path2//&foo=bar&bar=question%3F&extra=query#frag?";
+  EXPECT_EQ(toJscSafeUrl(input), output);
+  EXPECT_EQ(toJscSafeUrl(output), output);
+}
+
+// Throws on a URL with an empty path and a query string
+TEST(JscSafeUrlTest, ToJscSafeUrl_ThrowsForEmptyPathWithQuery) {
+  EXPECT_THROW(toJscSafeUrl("http://127.0.0.1?foo=bar"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("http://127.0.0.1?q#hash"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("?foo=bar"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("?foo=/bar#hash"), std::invalid_argument);
+  EXPECT_THROW(toJscSafeUrl("/?bar=baz/"), std::invalid_argument);
+}
+
+// --- isJscSafeUrl ---
+
+TEST(JscSafeUrlTest, IsJscSafeUrl_TrueForSafeUrls) {
+  EXPECT_TRUE(isJscSafeUrl("http://example.com//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("http://example.com/with/path//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("//&foo=bar//#frag=//"));
+  EXPECT_TRUE(isJscSafeUrl("relative/path///&foo=bar//&#frag=//&"));
+  EXPECT_TRUE(isJscSafeUrl("/absolute/path//&foo=bar//&#frag=//&"));
+}
+
+TEST(JscSafeUrlTest, IsJscSafeUrl_FalseForNormalUrls) {
+  EXPECT_FALSE(isJscSafeUrl("http://example.com?foo=bar//&#frag=//"));
+  EXPECT_FALSE(
+      isJscSafeUrl("http://example.com/with/path/?foo=bar//&#frag=//"));
+  EXPECT_FALSE(isJscSafeUrl("?foo=bar//&#frag=//&"));
+  EXPECT_FALSE(isJscSafeUrl("relative/path/?foo=bar//#frag=//"));
+  EXPECT_FALSE(isJscSafeUrl("/absolute/path/?foo=bar//&#frag=//"));
+}

package/ReactCommon/react/debug/redbox/tests/RedBoxErrorParserTest.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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/debug/redbox/RedBoxErrorParser.h>
+
+using namespace facebook::react::unstable_redbox;
+
+TEST(RedBoxErrorParserTest, ParsesBabelTransformError) {
+  auto result = parseErrorMessage(
+      "SyntaxError: /path/to/file.js: Unexpected token (10:5)\n\n"
+      "> 10 |   const x = {\n"
+      "     |              ^");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "Unexpected token");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->fileName, "/path/to/file.js");
+  EXPECT_EQ(result.codeFrame->row, 10);
+  EXPECT_EQ(result.codeFrame->column, 5);
+  EXPECT_TRUE(result.isCompileError);
+  EXPECT_TRUE(result.isRetryable);
+}
+
+TEST(RedBoxErrorParserTest, ParsesMetroError) {
+  auto result = parseErrorMessage(
+      "InternalError Metro has encountered an error: "
+      "BundleError: Unable to resolve module (1:0)\n\n"
+      "code frame here");
+
+  EXPECT_EQ(result.title, "BundleError");
+  EXPECT_EQ(result.message, "Unable to resolve module");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->row, 1);
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesBundleLoadError_SyntaxError) {
+  auto result = parseErrorMessage(
+      "SyntaxError in /app/index.js: Unexpected token (3:10)\ncode frame");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "Unexpected token");
+  ASSERT_TRUE(result.codeFrame.has_value());
+  EXPECT_EQ(result.codeFrame->fileName, "/app/index.js");
+  EXPECT_EQ(result.codeFrame->row, 3);
+  EXPECT_EQ(result.codeFrame->column, 10);
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesBundleLoadError_UnableToResolve) {
+  auto result = parseErrorMessage(
+      "UnableToResolveError in /app/index.js: Cannot find module (1:0)");
+
+  EXPECT_EQ(result.title, "Module Not Found");
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, ParsesGenericTransformError) {
+  auto result = parseErrorMessage("TransformError some error message");
+
+  EXPECT_EQ(result.title, "Syntax Error");
+  EXPECT_EQ(result.message, "TransformError some error message");
+  EXPECT_FALSE(result.codeFrame.has_value());
+  EXPECT_TRUE(result.isCompileError);
+}
+
+TEST(RedBoxErrorParserTest, DefaultsToUncaughtError) {
+  auto result = parseErrorMessage("TypeError: undefined is not a function");
+
+  EXPECT_EQ(result.title, "Uncaught Error");
+  EXPECT_EQ(result.message, "TypeError: undefined is not a function");
+  EXPECT_FALSE(result.codeFrame.has_value());
+  EXPECT_FALSE(result.isCompileError);
+  EXPECT_TRUE(result.isRetryable);
+}
+
+TEST(RedBoxErrorParserTest, UsesNameForTitle) {
+  auto result = parseErrorMessage("something broke", "CustomError");
+
+  EXPECT_EQ(result.title, "CustomError");
+}
+
+TEST(RedBoxErrorParserTest, UsesRenderErrorForComponentStack) {
+  auto result =
+      parseErrorMessage("something broke", "", "in MyComponent\nin App");
+
+  EXPECT_EQ(result.title, "Render Error");
+}
+
+TEST(RedBoxErrorParserTest, NonFatalDefaultsToError) {
+  auto result = parseErrorMessage("warning message", "", "", false);
+
+  EXPECT_EQ(result.title, "Error");
+}
+
+TEST(RedBoxErrorParserTest, HandlesEmptyMessage) {
+  auto result = parseErrorMessage("");
+
+  EXPECT_EQ(result.title, "Uncaught Error");
+  EXPECT_EQ(result.message, "");
+  EXPECT_FALSE(result.codeFrame.has_value());
+}

package/ReactCommon/react/featureflags/React-featureflags.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/facebook/react-native.git' }
+source = { :git => 'https://github.com/react/react-native.git' }
 if version == '1000.0.0'
   # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
   source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<20973c91d9d7e791598083c0cee5b934>>
+ * @generated SignedSource<<c7d08e6d97766cbb68db8772611530b5>>
  */
 
 /**
@@ -170,6 +170,10 @@ bool ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS() {
   return getAccessor().enableModuleArgumentNSNullConversionIOS();
 }
 
+bool ReactNativeFeatureFlags::enableMutationObserverByDefault() {
+  return getAccessor().enableMutationObserverByDefault();
+}
+
 bool ReactNativeFeatureFlags::enableNativeCSSParsing() {
   return getAccessor().enableNativeCSSParsing();
 }
@@ -290,6 +294,14 @@ bool ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion() {
   return getAccessor().preventShadowTreeCommitExhaustion();
 }
 
+bool ReactNativeFeatureFlags::redBoxV2Android() {
+  return getAccessor().redBoxV2Android();
+}
+
+bool ReactNativeFeatureFlags::redBoxV2IOS() {
+  return getAccessor().redBoxV2IOS();
+}
+
 bool ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover() {
   return getAccessor().shouldPressibilityUseW3CPointerEventsForHover();
 }

package/ReactCommon/react/featureflags/ReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<ec187a2009bd901f242bf65034357e5f>>
+ * @generated SignedSource<<f8bd95ee62cd377756a0ca08caf3027a>>
  */
 
 /**
@@ -219,6 +219,11 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool enableModuleArgumentNSNullConversionIOS();
 
+  /**
+   * Enables the MutationObserver Web API in React Native.
+   */
+  RN_EXPORT static bool enableMutationObserverByDefault();
+
   /**
    * Parse CSS strings using the Fabric CSS parser instead of ViewConfig processing
    */
@@ -369,6 +374,16 @@ class ReactNativeFeatureFlags {
    */
   RN_EXPORT static bool preventShadowTreeCommitExhaustion();
 
+  /**
+   * Use the redesigned RedBox error overlay on Android, styled to match the LogBox visual language.
+   */
+  RN_EXPORT static bool redBoxV2Android();
+
+  /**
+   * Use the redesigned RedBox error overlay on iOS, styled to match the LogBox visual language.
+   */
+  RN_EXPORT static bool redBoxV2IOS();
+
   /**
    * Function used to enable / disable Pressibility from using W3C Pointer Events for its hover callbacks
    */