react-native-tvos 0.83.4-2 → 0.83.9-0

package/ReactCommon/jsinspector-modern/tracing/tests/TimeWindowedBufferTest.cpp

@@ -0,0 +1,352 @@
+/*
+ * 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 <jsinspector-modern/tracing/TimeWindowedBuffer.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+// Test structure with timestamp field
+struct TestEvent {
+  int value;
+  HighResTimeStamp timestamp;
+
+  bool operator==(const TestEvent& other) const {
+    return value == other.value;
+  }
+};
+
+// ============================================================================
+// Tests for unbounded buffer (no timestamp accessor)
+// ============================================================================
+
+TEST(TimeWindowedBufferTest, DefaultConstructorCreatesEmptyBuffer) {
+  TimeWindowedBuffer<int> buffer;
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 0u);
+}
+
+TEST(TimeWindowedBufferTest, PushAddsElementsToUnboundedBuffer) {
+  TimeWindowedBuffer<int> buffer;
+  buffer.push(1);
+  buffer.push(2);
+  buffer.push(3);
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 3u);
+  EXPECT_EQ(result[0], 1);
+  EXPECT_EQ(result[1], 2);
+  EXPECT_EQ(result[2], 3);
+}
+
+TEST(TimeWindowedBufferTest, UnboundedBufferPreservesAllElements) {
+  TimeWindowedBuffer<int> buffer;
+  for (int i = 0; i < 100; ++i) {
+    buffer.push(i);
+  }
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 100u);
+  for (int i = 0; i < 100; ++i) {
+    EXPECT_EQ(result[i], i);
+  }
+}
+
+TEST(TimeWindowedBufferTest, ClearEmptiesBuffer) {
+  TimeWindowedBuffer<int> buffer;
+  buffer.push(1);
+  buffer.push(2);
+  buffer.push(3);
+
+  buffer.clear();
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 0u);
+}
+
+TEST(TimeWindowedBufferTest, PushRvalueReference) {
+  TimeWindowedBuffer<std::string> buffer;
+  std::string str = "test";
+  buffer.push(std::move(str));
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0], "test");
+}
+
+// ============================================================================
+// Tests for time-windowed buffer (with timestamp accessor)
+// ============================================================================
+
+TEST(TimeWindowedBufferTest, TimeWindowedBufferCreation) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(100);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 0u);
+}
+
+TEST(TimeWindowedBufferTest, TimeWindowedBufferAddsElements) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(1000);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(100)});
+
+  auto result = buffer.pruneExpiredAndExtract(baseTime + windowSize);
+  EXPECT_EQ(result.size(), 2u);
+  EXPECT_EQ(result[0].value, 1);
+  EXPECT_EQ(result[1].value, 2);
+}
+
+TEST(TimeWindowedBufferTest, ElementsWithinWindowArePreserved) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(500);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(100)});
+  buffer.push(
+      TestEvent{
+          .value = 3,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(200)});
+  buffer.push(
+      TestEvent{
+          .value = 4,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(300)});
+
+  // Extract with window [300ms, 800ms] - only event at 300ms should be included
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(800));
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0].value, 4);
+}
+
+TEST(TimeWindowedBufferTest, BufferSwitchingWhenWindowExceeded) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(100);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+
+  // Add events within first window
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(50)});
+
+  // Add event that exceeds the window - should trigger buffer switch
+  buffer.push(
+      TestEvent{
+          .value = 3,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(150)});
+
+  // Extract events within the window using reference point at 250ms
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(250));
+
+  // Events from 150ms should be in the window (250 - 100 = 150)
+  EXPECT_GE(result.size(), 1u);
+}
+
+TEST(TimeWindowedBufferTest, PruneExpiredFiltersOldElements) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(100);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+
+  // Add events in first window
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(50)});
+
+  // Move to second window
+  buffer.push(
+      TestEvent{
+          .value = 3,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(150)});
+
+  // Move to third window
+  buffer.push(
+      TestEvent{
+          .value = 4,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(300)});
+
+  // Extract with reference at 300ms: window is [200ms, 300ms]
+  // Only event 4 at 300ms should be within window
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(300));
+
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0].value, 4);
+}
+
+TEST(TimeWindowedBufferTest, OutOfOrderTimestampsAreHandled) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(10000);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+
+  // Add events out of order (by timestamp)
+  buffer.push(
+      TestEvent{
+          .value = 1,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(100)});
+  buffer.push(
+      TestEvent{.value = 2, .timestamp = baseTime}); // Earlier timestamp
+  buffer.push(
+      TestEvent{
+          .value = 3,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(200)});
+
+  // Extract with window [200ms, 10200ms] - only event at 200ms should be
+  // included
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(10200));
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0].value, 3);
+}
+
+TEST(TimeWindowedBufferTest, ClearResetsTimeWindowedBuffer) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(100);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(200)});
+
+  buffer.clear();
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 0u);
+}
+
+// ============================================================================
+// Tests for edge cases
+// ============================================================================
+
+TEST(TimeWindowedBufferTest, SingleElementBuffer) {
+  TimeWindowedBuffer<int> buffer;
+  buffer.push(42);
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0], 42);
+}
+
+TEST(TimeWindowedBufferTest, LargeNumberOfElements) {
+  TimeWindowedBuffer<int> buffer;
+
+  const int count = 10000;
+  for (int i = 0; i < count; ++i) {
+    buffer.push(i);
+  }
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), static_cast<size_t>(count));
+  EXPECT_EQ(result[0], 0);
+  EXPECT_EQ(result[count - 1], count - 1);
+}
+
+TEST(TimeWindowedBufferTest, VerySmallTimeWindow) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromNanoseconds(1000);
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+  buffer.push(TestEvent{.value = 1, .timestamp = baseTime});
+
+  // Next event with significant time difference should trigger switch
+  buffer.push(
+      TestEvent{
+          .value = 2,
+          .timestamp = baseTime + HighResDuration::fromMilliseconds(1)});
+
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(1));
+  EXPECT_GE(result.size(), 1u);
+}
+
+TEST(TimeWindowedBufferTest, VeryLargeTimeWindow) {
+  auto timestampAccessor = [](const TestEvent& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(3600000); // 1 hour
+
+  TimeWindowedBuffer<TestEvent> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+
+  // Add many events spread over time
+  for (int i = 0; i < 100; ++i) {
+    buffer.push(
+        TestEvent{
+            .value = i,
+            .timestamp =
+                baseTime + HighResDuration::fromMilliseconds(i * 10000)});
+  }
+
+  // All events should still be in the window
+  auto result = buffer.pruneExpiredAndExtract(
+      baseTime + HighResDuration::fromMilliseconds(100 * 10000));
+  EXPECT_EQ(result.size(), 100u);
+}
+
+// ============================================================================
+// Tests for complex types
+// ============================================================================
+
+TEST(TimeWindowedBufferTest, WorksWithComplexTypes) {
+  struct ComplexType {
+    std::string name;
+    std::vector<int> data;
+    HighResTimeStamp timestamp;
+  };
+
+  auto timestampAccessor = [](const ComplexType& e) { return e.timestamp; };
+  auto windowSize = HighResDuration::fromMilliseconds(1000);
+
+  TimeWindowedBuffer<ComplexType> buffer(timestampAccessor, windowSize);
+
+  auto baseTime = HighResTimeStamp::now();
+  buffer.push(
+      ComplexType{.name = "test", .data = {1, 2, 3}, .timestamp = baseTime});
+
+  auto result = buffer.pruneExpiredAndExtract();
+  EXPECT_EQ(result.size(), 1u);
+  EXPECT_EQ(result[0].name, "test");
+  EXPECT_EQ(result[0].data.size(), 3u);
+}
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/react/debug/CMakeLists.txt

@@ -9,7 +9,8 @@ set(CMAKE_VERBOSE_MAKEFILE on)
 include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB react_debug_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_debug OBJECT ${react_debug_SRC})
+file(GLOB react_debug_redbox_SRC CONFIGURE_DEPENDS redbox/*.cpp)
+add_library(react_debug OBJECT ${react_debug_SRC} ${react_debug_redbox_SRC})
 
 target_include_directories(react_debug PUBLIC ${REACT_COMMON_DIR})
 

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

@@ -25,10 +25,16 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = podspec_sources("**/*.{cpp,h}", "**/*.h")
+  s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
   s.header_dir             = "react/debug"
   s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "DEFINES_MODULE" => "YES" }
 
   resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_debug")
+
+  s.subspec "redbox" do |ss|
+    ss.source_files         = podspec_sources("redbox/*.{cpp,h}", "redbox/*.h")
+    ss.exclude_files        = "redbox/tests/**/*.{cpp,h}"
+    ss.header_dir           = "react/debug/redbox"
+  end
 end

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

@@ -0,0 +1,139 @@
+/*
+ * 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 "AnsiParser.h"
+
+#include <optional>
+
+#include <regex> // NOLINT(facebook-hte-BadInclude-regex)
+
+// @lint-ignore-every CLANGTIDY facebook-hte-StdRegexIsAwful
+namespace facebook::react::unstable_redbox {
+
+namespace {
+
+// Afterglow theme colors (matching AnsiHighlight.js)
+std::optional<AnsiColor> ansiColor(int code) {
+  switch (code) {
+    case 30:
+      return AnsiColor{.r = 27, .g = 27, .b = 27}; // black
+    case 31:
+      return AnsiColor{.r = 187, .g = 86, .b = 83}; // red
+    case 32:
+      return AnsiColor{.r = 144, .g = 157, .b = 98}; // green
+    case 33:
+      return AnsiColor{.r = 234, .g = 193, .b = 121}; // yellow
+    case 34:
+      return AnsiColor{.r = 125, .g = 169, .b = 199}; // blue
+    case 35:
+      return AnsiColor{.r = 176, .g = 101, .b = 151}; // magenta
+    case 36:
+      return AnsiColor{.r = 140, .g = 220, .b = 216}; // cyan
+    case 37:
+      return std::nullopt; // white = default
+    case 90:
+      return AnsiColor{.r = 98, .g = 98, .b = 98}; // bright black
+    case 91:
+      return AnsiColor{.r = 187, .g = 86, .b = 83}; // bright red
+    case 92:
+      return AnsiColor{.r = 144, .g = 157, .b = 98}; // bright green
+    case 93:
+      return AnsiColor{.r = 234, .g = 193, .b = 121}; // bright yellow
+    case 94:
+      return AnsiColor{.r = 125, .g = 169, .b = 199}; // bright blue
+    case 95:
+      return AnsiColor{.r = 176, .g = 101, .b = 151}; // bright magenta
+    case 96:
+      return AnsiColor{.r = 140, .g = 220, .b = 216}; // bright cyan
+    case 97:
+      return AnsiColor{.r = 247, .g = 247, .b = 247}; // bright white
+    default:
+      return std::nullopt;
+  }
+}
+
+const std::regex& ansiRegex() {
+  static const std::regex re(R"(\x1b\[([0-9;]*)m)");
+  return re;
+}
+
+int parseSgrCode(const std::string& params, size_t& pos) {
+  size_t next = params.find(';', pos);
+  if (next == std::string::npos) {
+    next = params.size();
+  }
+  int code = 0;
+  for (size_t i = pos; i < next; ++i) {
+    code = code * 10 + (params[i] - '0');
+  }
+  pos = next + 1;
+  return code;
+}
+
+} // namespace
+
+std::vector<AnsiSpan> parseAnsi(const std::string& text) {
+  std::vector<AnsiSpan> spans;
+  std::optional<AnsiColor> currentFg;
+  std::optional<AnsiColor> currentBg;
+  auto it = std::sregex_iterator(text.begin(), text.end(), ansiRegex());
+  auto end = std::sregex_iterator();
+  size_t lastEnd = 0;
+
+  for (; it != end; ++it) {
+    const auto& match = *it;
+    auto matchStart = static_cast<size_t>(match.position());
+
+    if (matchStart > lastEnd) {
+      spans.push_back(
+          AnsiSpan{
+              .text = text.substr(lastEnd, matchStart - lastEnd),
+              .foregroundColor = currentFg,
+              .backgroundColor = currentBg});
+    }
+    lastEnd = matchStart + match.length();
+
+    std::string params = match[1].str();
+    // ESC[m (no params) is equivalent to ESC[0m (reset all attributes)
+    if (params.empty()) {
+      currentFg = std::nullopt;
+      currentBg = std::nullopt;
+    }
+    size_t pos = 0;
+    while (pos < params.size()) {
+      int code = parseSgrCode(params, pos);
+      if (code == 0) {
+        currentFg = std::nullopt;
+        currentBg = std::nullopt;
+      } else if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97)) {
+        currentFg = ansiColor(code);
+      } else if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107)) {
+        currentBg = ansiColor(code - 10);
+      } else if (code == 39) {
+        currentFg = std::nullopt;
+      } else if (code == 49) {
+        currentBg = std::nullopt;
+      }
+    }
+  }
+
+  if (lastEnd < text.size()) {
+    spans.push_back(
+        AnsiSpan{
+            .text = text.substr(lastEnd),
+            .foregroundColor = currentFg,
+            .backgroundColor = currentBg});
+  }
+
+  return spans;
+}
+
+std::string stripAnsi(const std::string& text) {
+  return std::regex_replace(text, ansiRegex(), "");
+}
+
+} // namespace facebook::react::unstable_redbox

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

@@ -0,0 +1,35 @@
+/*
+ * 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>
+#include <vector>
+
+namespace facebook::react::unstable_redbox {
+
+struct AnsiColor {
+  uint8_t r, g, b;
+};
+
+struct AnsiSpan {
+  std::string text;
+  std::optional<AnsiColor> foregroundColor;
+  std::optional<AnsiColor> backgroundColor;
+};
+
+/**
+ * Parse ANSI escape sequences in text and produce a list of styled spans.
+ * Uses the Afterglow color theme (matching LogBox's AnsiHighlight.js).
+ */
+std::vector<AnsiSpan> parseAnsi(const std::string &text);
+
+/** Strip all ANSI escape sequences from text. */
+std::string stripAnsi(const std::string &text);
+
+} // namespace facebook::react::unstable_redbox