first commit

node_modules/react-native/Libraries/LogBox/Data/LogBoxData.js

@@ -0,0 +1,517 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {ExtendedError} from '../../Core/ExtendedError';
+import type {LogLevel} from './LogBoxLog';
+import type {
+  Category,
+  ComponentStack,
+  ComponentStackType,
+  ExtendedExceptionData,
+  Message,
+} from './parseLogBoxLog';
+
+import DebuggerSessionObserver from '../../../src/private/devsupport/rndevtools/FuseboxSessionObserver';
+import parseErrorStack from '../../Core/Devtools/parseErrorStack';
+import NativeLogBox from '../../NativeModules/specs/NativeLogBox';
+import LogBoxLog from './LogBoxLog';
+import {parseLogBoxException} from './parseLogBoxLog';
+import * as React from 'react';
+
+export type LogBoxLogs = Set<LogBoxLog>;
+export type LogData = $ReadOnly<{
+  level: LogLevel,
+  message: Message,
+  category: Category,
+  componentStack: ComponentStack,
+  componentStackType: ComponentStackType | null,
+  stack?: string,
+}>;
+
+export type Observer = (
+  $ReadOnly<{
+    logs: LogBoxLogs,
+    isDisabled: boolean,
+    selectedLogIndex: number,
+  }>,
+) => void;
+
+export type IgnorePattern = string | RegExp;
+
+export type Subscription = $ReadOnly<{
+  unsubscribe: () => void,
+}>;
+
+export type WarningInfo = {
+  finalFormat: string,
+  forceDialogImmediately: boolean,
+  suppressDialog_LEGACY: boolean,
+  suppressCompletely: boolean,
+  monitorEvent: string | null,
+  monitorListVersion: number,
+  monitorSampleRate: number,
+};
+
+export type WarningFilter = (format: string) => WarningInfo;
+
+type AppInfo = $ReadOnly<{
+  appVersion: string,
+  engine: string,
+  onPress?: ?() => void,
+}>;
+
+const observers: Set<{observer: Observer, ...}> = new Set();
+const ignorePatterns: Set<IgnorePattern> = new Set();
+let appInfo: ?() => AppInfo = null;
+let logs: LogBoxLogs = new Set();
+let updateTimeout: $FlowFixMe | null = null;
+let _isDisabled = false;
+let _selectedIndex = -1;
+let hasShownFuseboxWarningsMigrationMessage = false;
+let hostTargetSessionObserverSubscription = null;
+
+let warningFilter: WarningFilter = function (format) {
+  return {
+    finalFormat: format,
+    forceDialogImmediately: false,
+    suppressDialog_LEGACY: false,
+    suppressCompletely: false,
+    monitorEvent: 'warning_unhandled',
+    monitorListVersion: 0,
+    monitorSampleRate: 1,
+  };
+};
+
+const LOGBOX_ERROR_MESSAGE =
+  'An error was thrown when attempting to render log messages via LogBox.';
+
+function getNextState() {
+  return {
+    logs,
+    isDisabled: _isDisabled,
+    selectedLogIndex: _selectedIndex,
+  };
+}
+
+export function reportLogBoxError(
+  error: ExtendedError,
+  componentStack?: string,
+): void {
+  const ExceptionsManager = require('../../Core/ExceptionsManager').default;
+
+  error.message = `${LOGBOX_ERROR_MESSAGE}\n\n${error.message}`;
+  if (componentStack != null) {
+    error.componentStack = componentStack;
+  }
+  ExceptionsManager.handleException(error, /* isFatal */ true);
+}
+
+export function isLogBoxErrorMessage(message: string): boolean {
+  return typeof message === 'string' && message.includes(LOGBOX_ERROR_MESSAGE);
+}
+
+export function isMessageIgnored(message: string): boolean {
+  for (const pattern of ignorePatterns) {
+    if (
+      (pattern instanceof RegExp && pattern.test(message)) ||
+      (typeof pattern === 'string' && message.includes(pattern))
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function handleUpdate(): void {
+  if (updateTimeout == null) {
+    updateTimeout = setImmediate(() => {
+      updateTimeout = null;
+      const nextState = getNextState();
+      observers.forEach(({observer}) => observer(nextState));
+    });
+  }
+}
+
+function appendNewLog(newLog: LogBoxLog) {
+  // Don't want store these logs because they trigger a
+  // state update when we add them to the store.
+  if (isMessageIgnored(newLog.message.content)) {
+    return;
+  }
+
+  // If the next log has the same category as the previous one
+  // then roll it up into the last log in the list by incrementing
+  // the count (similar to how Chrome does it).
+  const lastLog = Array.from(logs).pop();
+  if (lastLog && lastLog.category === newLog.category) {
+    lastLog.incrementCount();
+    handleUpdate();
+    return;
+  }
+
+  if (newLog.level === 'fatal') {
+    // If possible, to avoid jank, we don't want to open the error before
+    // it's symbolicated. To do that, we optimistically wait for
+    // symbolication for up to a second before adding the log.
+    const OPTIMISTIC_WAIT_TIME = 1000;
+
+    let addPendingLog: ?() => void = () => {
+      logs.add(newLog);
+      if (_selectedIndex < 0) {
+        setSelectedLog(logs.size - 1);
+      } else {
+        handleUpdate();
+      }
+      addPendingLog = null;
+    };
+
+    const optimisticTimeout = setTimeout(() => {
+      if (addPendingLog) {
+        addPendingLog();
+      }
+    }, OPTIMISTIC_WAIT_TIME);
+
+    newLog.symbolicate(status => {
+      if (addPendingLog && status !== 'PENDING') {
+        addPendingLog();
+        clearTimeout(optimisticTimeout);
+      } else if (status !== 'PENDING') {
+        // The log has already been added but we need to trigger a render.
+        handleUpdate();
+      }
+    });
+  } else if (newLog.level === 'syntax') {
+    logs.add(newLog);
+    setSelectedLog(logs.size - 1);
+  } else {
+    logs.add(newLog);
+    handleUpdate();
+  }
+}
+
+export function addLog(log: LogData): void {
+  if (hostTargetSessionObserverSubscription == null) {
+    hostTargetSessionObserverSubscription = DebuggerSessionObserver.subscribe(
+      hasActiveSession => {
+        if (hasActiveSession) {
+          clearWarnings();
+        } else {
+          // Reset the flag so that we can show the message again if new warning was emitted
+          hasShownFuseboxWarningsMigrationMessage = false;
+        }
+      },
+    );
+  }
+
+  // If Host has Fusebox support
+  if (log.level === 'warn' && global.__FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__) {
+    // And there is no active debugging session
+    if (!DebuggerSessionObserver.hasActiveSession()) {
+      showFuseboxWarningsMigrationMessageOnce();
+    }
+
+    // Don't show LogBox warnings when Host has active debugging session
+    return;
+  }
+
+  const errorForStackTrace = new Error();
+
+  // Parsing logs are expensive so we schedule this
+  // otherwise spammy logs would pause rendering.
+  setImmediate(() => {
+    try {
+      const stack = parseErrorStack(log.stack ?? errorForStackTrace?.stack);
+
+      appendNewLog(
+        new LogBoxLog({
+          level: log.level,
+          message: log.message,
+          isComponentError: false,
+          stack,
+          category: log.category,
+          componentStack: log.componentStack,
+          componentStackType: log.componentStackType || 'legacy',
+        }),
+      );
+    } catch (error) {
+      reportLogBoxError(error);
+    }
+  });
+}
+
+export function addException(error: ExtendedExceptionData): void {
+  // Parsing logs are expensive so we schedule this
+  // otherwise spammy logs would pause rendering.
+  setImmediate(() => {
+    try {
+      appendNewLog(new LogBoxLog(parseLogBoxException(error)));
+    } catch (loggingError) {
+      reportLogBoxError(loggingError);
+    }
+  });
+}
+
+export function symbolicateLogNow(log: LogBoxLog) {
+  log.symbolicate(() => {
+    handleUpdate();
+  });
+}
+
+export function retrySymbolicateLogNow(log: LogBoxLog) {
+  log.retrySymbolicate(() => {
+    handleUpdate();
+  });
+}
+
+export function symbolicateLogLazy(log: LogBoxLog) {
+  log.symbolicate();
+}
+
+export function clear(): void {
+  if (logs.size > 0) {
+    logs = new Set();
+    setSelectedLog(-1);
+  }
+}
+
+export function setSelectedLog(proposedNewIndex: number): void {
+  const oldIndex = _selectedIndex;
+  let newIndex = proposedNewIndex;
+
+  const logArray = Array.from(logs);
+  let index = logArray.length - 1;
+  while (index >= 0) {
+    // The latest syntax error is selected and displayed before all other logs.
+    if (logArray[index].level === 'syntax') {
+      newIndex = index;
+      break;
+    }
+    index -= 1;
+  }
+  _selectedIndex = newIndex;
+  handleUpdate();
+  if (NativeLogBox) {
+    setTimeout(() => {
+      if (oldIndex < 0 && newIndex >= 0) {
+        NativeLogBox.show();
+      } else if (oldIndex >= 0 && newIndex < 0) {
+        NativeLogBox.hide();
+      }
+    }, 0);
+  }
+}
+
+export function clearWarnings(): void {
+  const newLogs = Array.from(logs).filter(log => log.level !== 'warn');
+  if (newLogs.length !== logs.size) {
+    logs = new Set(newLogs);
+    setSelectedLog(-1);
+    handleUpdate();
+  }
+}
+
+export function clearErrors(): void {
+  const newLogs = Array.from(logs).filter(
+    log => log.level !== 'error' && log.level !== 'fatal',
+  );
+  if (newLogs.length !== logs.size) {
+    logs = new Set(newLogs);
+    setSelectedLog(-1);
+  }
+}
+
+export function dismiss(log: LogBoxLog): void {
+  if (logs.has(log)) {
+    logs.delete(log);
+    handleUpdate();
+  }
+}
+
+export function setWarningFilter(filter: WarningFilter): void {
+  warningFilter = filter;
+}
+
+export function setAppInfo(info: () => AppInfo): void {
+  appInfo = info;
+}
+
+export function getAppInfo(): ?AppInfo {
+  return appInfo != null ? appInfo() : null;
+}
+
+export function checkWarningFilter(format: string): WarningInfo {
+  return warningFilter(format);
+}
+
+export function getIgnorePatterns(): $ReadOnlyArray<IgnorePattern> {
+  return Array.from(ignorePatterns);
+}
+
+export function addIgnorePatterns(
+  patterns: $ReadOnlyArray<IgnorePattern>,
+): void {
+  const existingSize = ignorePatterns.size;
+  // The same pattern may be added multiple times, but adding a new pattern
+  // can be expensive so let's find only the ones that are new.
+  patterns.forEach((pattern: IgnorePattern) => {
+    if (pattern instanceof RegExp) {
+      for (const existingPattern of ignorePatterns) {
+        if (
+          existingPattern instanceof RegExp &&
+          existingPattern.toString() === pattern.toString()
+        ) {
+          return;
+        }
+      }
+      ignorePatterns.add(pattern);
+    }
+    ignorePatterns.add(pattern);
+  });
+  if (ignorePatterns.size === existingSize) {
+    return;
+  }
+  // We need to recheck all of the existing logs.
+  // This allows adding an ignore pattern anywhere in the codebase.
+  // Without this, if you ignore a pattern after the a log is created,
+  // then we would keep showing the log.
+  logs = new Set(
+    Array.from(logs).filter(log => !isMessageIgnored(log.message.content)),
+  );
+  handleUpdate();
+}
+
+export function setDisabled(value: boolean): void {
+  if (value === _isDisabled) {
+    return;
+  }
+  _isDisabled = value;
+  handleUpdate();
+}
+
+export function isDisabled(): boolean {
+  return _isDisabled;
+}
+
+export function observe(observer: Observer): Subscription {
+  const subscription = {observer};
+  observers.add(subscription);
+
+  observer(getNextState());
+
+  return {
+    unsubscribe(): void {
+      observers.delete(subscription);
+    },
+  };
+}
+
+type LogBoxStateSubscriptionProps = $ReadOnly<{}>;
+type LogBoxStateSubscriptionState = $ReadOnly<{
+  logs: LogBoxLogs,
+  isDisabled: boolean,
+  hasError: boolean,
+  selectedLogIndex: number,
+}>;
+
+type SubscribedComponent = React.ComponentType<
+  $ReadOnly<{
+    logs: $ReadOnlyArray<LogBoxLog>,
+    isDisabled: boolean,
+    selectedLogIndex: number,
+  }>,
+>;
+
+export function withSubscription(
+  WrappedComponent: SubscribedComponent,
+): React.ComponentType<{}> {
+  class LogBoxStateSubscription extends React.Component<
+    LogBoxStateSubscriptionProps,
+    LogBoxStateSubscriptionState,
+  > {
+    static getDerivedStateFromError(): {hasError: boolean} {
+      return {hasError: true};
+    }
+
+    componentDidCatch(err: Error, errorInfo: {componentStack: string, ...}) {
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      // $FlowFixMe[incompatible-type]
+      reportLogBoxError(err, errorInfo.componentStack);
+    }
+
+    _subscription: ?Subscription;
+
+    state: LogBoxStateSubscriptionState = {
+      logs: new Set(),
+      isDisabled: false,
+      hasError: false,
+      selectedLogIndex: -1,
+    };
+
+    render(): React.Node {
+      if (this.state.hasError) {
+        // This happens when the component failed to render, in which case we delegate to the native redbox.
+        // We can't show anyback fallback UI here, because the error may be with <View> or <Text>.
+        return null;
+      }
+
+      return (
+        <WrappedComponent
+          logs={Array.from(this.state.logs)}
+          isDisabled={this.state.isDisabled}
+          selectedLogIndex={this.state.selectedLogIndex}
+        />
+      );
+    }
+
+    componentDidMount(): void {
+      this._subscription = observe(data => {
+        this.setState(data);
+      });
+    }
+
+    componentWillUnmount(): void {
+      if (this._subscription != null) {
+        this._subscription.unsubscribe();
+      }
+    }
+  }
+
+  return LogBoxStateSubscription;
+}
+
+function showFuseboxWarningsMigrationMessageOnce() {
+  if (hasShownFuseboxWarningsMigrationMessage) {
+    return;
+  }
+  hasShownFuseboxWarningsMigrationMessage = true;
+
+  const NativeDevSettings =
+    require('../../NativeModules/specs/NativeDevSettings').default;
+
+  appendNewLog(
+    new LogBoxLog({
+      level: 'warn',
+      message: {
+        content: 'Open debugger to view warnings.',
+        substitutions: [],
+      },
+      isComponentError: false,
+      stack: [],
+      category: 'fusebox-warnings-migration',
+      componentStack: [],
+      onNotificationPress: () => {
+        if (NativeDevSettings.openDebugger) {
+          NativeDevSettings.openDebugger();
+        }
+      },
+    }),
+  );
+}

node_modules/react-native/Libraries/LogBox/Data/LogBoxLog.js

@@ -0,0 +1,279 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {Stack} from './LogBoxSymbolication';
+import type {
+  Category,
+  CodeFrame,
+  ComponentStack,
+  ComponentStackType,
+  Message,
+} from './parseLogBoxLog';
+
+import * as LogBoxSymbolication from './LogBoxSymbolication';
+
+type SymbolicationStatus = 'NONE' | 'PENDING' | 'COMPLETE' | 'FAILED';
+
+export type LogLevel = 'warn' | 'error' | 'fatal' | 'syntax';
+
+// TODO: once component stacks are fully supported, we can refactor
+// ComponentStack to just be Stack and remove these conversions fns.
+function convertComponentStateToStack(componentStack: ComponentStack): Stack {
+  return componentStack.map(frame => ({
+    column: frame?.location?.column,
+    file: frame.fileName,
+    lineNumber: frame?.location?.row,
+    methodName: frame.content,
+    collapse: false,
+  }));
+}
+
+function convertStackToComponentStack(stack: Stack): ComponentStack {
+  const componentStack = [];
+  for (let i = 0; i < stack.length; i++) {
+    const frame = stack[i];
+    // NOTE: Skip stack frames missing location.
+    if (frame.lineNumber != null && frame.column != null) {
+      componentStack.push({
+        fileName: frame?.file || '',
+        location: {
+          row: frame.lineNumber,
+          column: frame.column,
+        },
+        content: frame.methodName,
+        collapse: false,
+      });
+    }
+  }
+  return componentStack;
+}
+
+export type LogBoxLogData = $ReadOnly<{
+  level: LogLevel,
+  type?: ?string,
+  message: Message,
+  stack: Stack,
+  category: string,
+  componentStackType?: ComponentStackType,
+  componentStack: ComponentStack,
+  codeFrame?: ?CodeFrame,
+  isComponentError: boolean,
+  extraData?: mixed,
+  onNotificationPress?: ?() => void,
+}>;
+
+class LogBoxLog {
+  message: Message;
+  type: ?string;
+  category: Category;
+  componentStack: ComponentStack;
+  componentStackType: ComponentStackType;
+  stack: Stack;
+  count: number;
+  level: LogLevel;
+  codeFrame: ?CodeFrame;
+  componentCodeFrame: ?CodeFrame;
+  isComponentError: boolean;
+  extraData: mixed | void;
+  symbolicated:
+    | $ReadOnly<{error: null, stack: null, status: 'NONE'}>
+    | $ReadOnly<{error: null, stack: null, status: 'PENDING'}>
+    | $ReadOnly<{error: null, stack: Stack, status: 'COMPLETE'}>
+    | $ReadOnly<{error: Error, stack: null, status: 'FAILED'}> = {
+    error: null,
+    stack: null,
+    status: 'NONE',
+  };
+  symbolicatedComponentStack:
+    | $ReadOnly<{error: null, componentStack: null, status: 'NONE'}>
+    | $ReadOnly<{error: null, componentStack: null, status: 'PENDING'}>
+    | $ReadOnly<{
+        error: null,
+        componentStack: ComponentStack,
+        status: 'COMPLETE',
+      }>
+    | $ReadOnly<{error: Error, componentStack: null, status: 'FAILED'}> = {
+    error: null,
+    componentStack: null,
+    status: 'NONE',
+  };
+  onNotificationPress: ?() => void;
+
+  constructor(data: LogBoxLogData) {
+    this.level = data.level;
+    this.type = data.type;
+    this.message = data.message;
+    this.stack = data.stack;
+    this.category = data.category;
+    this.componentStack = data.componentStack;
+    this.componentStackType = data.componentStackType || 'legacy';
+    this.codeFrame = data.codeFrame;
+    this.isComponentError = data.isComponentError;
+    this.extraData = data.extraData;
+    this.count = 1;
+    this.onNotificationPress = data.onNotificationPress;
+  }
+
+  incrementCount(): void {
+    this.count += 1;
+  }
+
+  getAvailableStack(): Stack {
+    return this.symbolicated.status === 'COMPLETE'
+      ? this.symbolicated.stack
+      : this.stack;
+  }
+
+  getAvailableComponentStack(): ComponentStack {
+    if (this.componentStackType === 'legacy') {
+      return this.componentStack;
+    }
+    return this.symbolicatedComponentStack.status === 'COMPLETE'
+      ? this.symbolicatedComponentStack.componentStack
+      : this.componentStack;
+  }
+
+  retrySymbolicate(callback?: (status: SymbolicationStatus) => void): void {
+    let retry = false;
+    if (this.symbolicated.status !== 'COMPLETE') {
+      LogBoxSymbolication.deleteStack(this.stack);
+      retry = true;
+    }
+    if (this.symbolicatedComponentStack.status !== 'COMPLETE') {
+      LogBoxSymbolication.deleteStack(
+        convertComponentStateToStack(this.componentStack),
+      );
+      retry = true;
+    }
+    if (retry) {
+      this.handleSymbolicate(callback);
+    }
+  }
+
+  symbolicate(callback?: (status: SymbolicationStatus) => void): void {
+    if (this.symbolicated.status === 'NONE') {
+      this.handleSymbolicate(callback);
+    }
+  }
+
+  handleSymbolicate(callback?: (status: SymbolicationStatus) => void): void {
+    if (
+      this.symbolicated.status !== 'PENDING' &&
+      this.symbolicated.status !== 'COMPLETE'
+    ) {
+      this.updateStatus(null, null, null, callback);
+      LogBoxSymbolication.symbolicate(this.stack, this.extraData).then(
+        data => {
+          this.updateStatus(null, data?.stack, data?.codeFrame, callback);
+        },
+        error => {
+          this.updateStatus(error, null, null, callback);
+        },
+      );
+    }
+    if (
+      this.componentStack != null &&
+      this.componentStackType === 'stack' &&
+      this.symbolicatedComponentStack.status !== 'PENDING' &&
+      this.symbolicatedComponentStack.status !== 'COMPLETE'
+    ) {
+      this.updateComponentStackStatus(null, null, null, callback);
+      const componentStackFrames = convertComponentStateToStack(
+        this.componentStack,
+      );
+      LogBoxSymbolication.symbolicate(componentStackFrames, []).then(
+        data => {
+          this.updateComponentStackStatus(
+            null,
+            convertStackToComponentStack(data.stack),
+            data?.codeFrame,
+            callback,
+          );
+        },
+        error => {
+          this.updateComponentStackStatus(error, null, null, callback);
+        },
+      );
+    }
+  }
+
+  updateStatus(
+    error: ?Error,
+    stack: ?Stack,
+    codeFrame: ?CodeFrame,
+    callback?: (status: SymbolicationStatus) => void,
+  ): void {
+    const lastStatus = this.symbolicated.status;
+    if (error != null) {
+      this.symbolicated = {
+        error,
+        stack: null,
+        status: 'FAILED',
+      };
+    } else if (stack != null) {
+      if (codeFrame) {
+        this.codeFrame = codeFrame;
+      }
+
+      this.symbolicated = {
+        error: null,
+        stack,
+        status: 'COMPLETE',
+      };
+    } else {
+      this.symbolicated = {
+        error: null,
+        stack: null,
+        status: 'PENDING',
+      };
+    }
+
+    if (callback && lastStatus !== this.symbolicated.status) {
+      callback(this.symbolicated.status);
+    }
+  }
+
+  updateComponentStackStatus(
+    error: ?Error,
+    componentStack: ?ComponentStack,
+    codeFrame: ?CodeFrame,
+    callback?: (status: SymbolicationStatus) => void,
+  ): void {
+    const lastStatus = this.symbolicatedComponentStack.status;
+    if (error != null) {
+      this.symbolicatedComponentStack = {
+        error,
+        componentStack: null,
+        status: 'FAILED',
+      };
+    } else if (componentStack != null) {
+      if (codeFrame) {
+        this.componentCodeFrame = codeFrame;
+      }
+      this.symbolicatedComponentStack = {
+        error: null,
+        componentStack,
+        status: 'COMPLETE',
+      };
+    } else {
+      this.symbolicatedComponentStack = {
+        error: null,
+        componentStack: null,
+        status: 'PENDING',
+      };
+    }
+
+    if (callback && lastStatus !== this.symbolicatedComponentStack.status) {
+      callback(this.symbolicatedComponentStack.status);
+    }
+  }
+}
+
+export default LogBoxLog;

node_modules/react-native/Libraries/LogBox/Data/LogBoxSymbolication.js

@@ -0,0 +1,65 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {SymbolicatedStackTrace} from '../../Core/Devtools/symbolicateStackTrace';
+import type {StackFrame} from '../../Core/NativeExceptionsManager';
+
+import symbolicateStackTrace from '../../Core/Devtools/symbolicateStackTrace';
+
+export type Stack = Array<StackFrame>;
+
+const cache: Map<Stack, Promise<SymbolicatedStackTrace>> = new Map();
+
+/**
+ * Sanitize because sometimes, `symbolicateStackTrace` gives us invalid values.
+ */
+const sanitize = ({
+  stack: maybeStack,
+  codeFrame,
+}: SymbolicatedStackTrace): SymbolicatedStackTrace => {
+  if (!Array.isArray(maybeStack)) {
+    throw new Error('Expected stack to be an array.');
+  }
+  const stack: Array<StackFrame> = [];
+  for (const maybeFrame of maybeStack) {
+    let collapse = false;
+    if ('collapse' in maybeFrame) {
+      if (typeof maybeFrame.collapse !== 'boolean') {
+        throw new Error('Expected stack frame `collapse` to be a boolean.');
+      }
+      collapse = maybeFrame.collapse;
+    }
+    stack.push({
+      column: maybeFrame.column,
+      file: maybeFrame.file,
+      lineNumber: maybeFrame.lineNumber,
+      methodName: maybeFrame.methodName,
+      collapse,
+    });
+  }
+  return {stack, codeFrame};
+};
+
+export function deleteStack(stack: Stack): void {
+  cache.delete(stack);
+}
+
+export function symbolicate(
+  stack: Stack,
+  extraData?: mixed,
+): Promise<SymbolicatedStackTrace> {
+  let promise = cache.get(stack);
+  if (promise == null) {
+    promise = symbolicateStackTrace(stack, extraData).then(sanitize);
+    cache.set(stack, promise);
+  }
+
+  return promise;
+}

node_modules/react-native/Libraries/LogBox/Data/parseLogBoxLog.js

@@ -0,0 +1,516 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+import type {ExceptionData} from '../../Core/NativeExceptionsManager';
+import type {LogBoxLogData} from './LogBoxLog';
+
+import parseErrorStack from '../../Core/Devtools/parseErrorStack';
+import UTFSequence from '../../UTFSequence';
+import stringifySafe from '../../Utilities/stringifySafe';
+import ansiRegex from 'ansi-regex';
+
+const ANSI_REGEX = ansiRegex().source;
+
+const RE_TRANSFORM_ERROR = /^TransformError /;
+const RE_COMPONENT_STACK_LINE = /\n {4}(in|at) /;
+const RE_COMPONENT_STACK_LINE_GLOBAL = /\n {4}(in|at) /g;
+const RE_COMPONENT_STACK_LINE_OLD = / {4}in/;
+const RE_COMPONENT_STACK_LINE_NEW = / {4}at/;
+const RE_COMPONENT_STACK_LINE_STACK_FRAME = /@.*\n/;
+
+// "TransformError " (Optional) and either "SyntaxError: " or "ReferenceError: "
+// Capturing groups:
+// 1: error message
+// 2: file path
+// 3: line number
+// 4: column number
+// \n\n
+// 5: code frame
+const RE_BABEL_TRANSFORM_ERROR_FORMAT =
+  /^(?:TransformError )?(?:SyntaxError: |ReferenceError: )(.*): (.*) \((\d+):(\d+)\)\n\n([\s\S]+)/;
+
+// Capturing groups:
+// 1: component name
+// "at"
+// 2: file path including extension
+// 3: line number
+const RE_COMPONENT_STACK_WITH_SOURCE =
+  /(.*) \(at (.*\.(?:js|jsx|ts|tsx)):([\d]+)\)/;
+
+// Capturing groups:
+// 1: component name
+// "at"
+// 2: parent component name
+const RE_COMPONENT_STACK_NO_SOURCE = /(.*) \(created by .*\)/;
+
+// Capturing groups:
+// - non-capturing "TransformError " (optional)
+// - non-capturing Error message
+// 1: file path
+// 2: file name
+// 3: error message
+// 4: code frame, which includes code snippet indicators or terminal escape sequences for formatting.
+const RE_BABEL_CODE_FRAME_ERROR_FORMAT =
+  // eslint-disable-next-line no-control-regex
+  /^(?:TransformError )?(?:.*):? (?:.*?)(\/.*): ([\s\S]+?)\n([ >]{2}[\d\s]+ \|[\s\S]+|\u{001b}[\s\S]+)/u;
+
+// Capturing groups:
+// - non-capturing "InternalError Metro has encountered an error:"
+// 1: error title
+// 2: error message
+// 3: file path
+// 4: line number
+// 5: column number
+// 6: code frame, which includes code snippet indicators or terminal escape sequences for formatting.
+const RE_METRO_ERROR_FORMAT =
+  /^(?:InternalError Metro has encountered an error:) (.*): (.*) \((\d+):(\d+)\)\n\n([\s\S]+)/u;
+
+// https://github.com/babel/babel/blob/33dbb85e9e9fe36915273080ecc42aee62ed0ade/packages/babel-code-frame/src/index.ts#L183-L184
+const RE_BABEL_CODE_FRAME_MARKER_PATTERN = new RegExp(
+  [
+    // Beginning of a line (per 'm' flag)
+    '^',
+    // Optional ANSI escapes for colors
+    `(?:${ANSI_REGEX})*`,
+    // Marker
+    '>',
+    // Optional ANSI escapes for colors
+    `(?:${ANSI_REGEX})*`,
+    // Left padding for line number
+    ' +',
+    // Line number
+    '[0-9]+',
+    // Gutter
+    ' \\|',
+  ].join(''),
+  'm',
+);
+
+export function hasComponentStack(args: $ReadOnlyArray<mixed>): boolean {
+  for (const arg of args) {
+    if (typeof arg === 'string' && isComponentStack(arg)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export type ExtendedExceptionData = ExceptionData & {
+  isComponentError: boolean,
+  ...
+};
+export type Category = string;
+export type CodeFrame = $ReadOnly<{
+  content: string,
+  location: ?{
+    row: number,
+    column: number,
+    ...
+  },
+  fileName: string,
+
+  // TODO: When React switched to using call stack frames,
+  // we gained the ability to use the collapse flag, but
+  // it is not integrated into the LogBox UI.
+  collapse?: boolean,
+}>;
+export type Message = $ReadOnly<{
+  content: string,
+  substitutions: $ReadOnlyArray<
+    $ReadOnly<{
+      length: number,
+      offset: number,
+    }>,
+  >,
+}>;
+
+export type ComponentStack = $ReadOnlyArray<CodeFrame>;
+export type ComponentStackType = 'legacy' | 'stack';
+
+const SUBSTITUTION = UTFSequence.BOM + '%s';
+
+export function parseInterpolation(args: $ReadOnlyArray<mixed>): $ReadOnly<{
+  category: Category,
+  message: Message,
+}> {
+  const categoryParts = [];
+  const contentParts = [];
+  const substitutionOffsets = [];
+
+  const remaining = [...args];
+  if (typeof remaining[0] === 'string') {
+    const formatString = String(remaining.shift());
+    const formatStringParts = formatString.split('%s');
+    const substitutionCount = formatStringParts.length - 1;
+    const substitutions = remaining.splice(0, substitutionCount);
+
+    let categoryString = '';
+    let contentString = '';
+
+    let substitutionIndex = 0;
+    for (const formatStringPart of formatStringParts) {
+      categoryString += formatStringPart;
+      contentString += formatStringPart;
+
+      if (substitutionIndex < substitutionCount) {
+        if (substitutionIndex < substitutions.length) {
+          // Don't stringify a string type.
+          // It adds quotation mark wrappers around the string,
+          // which causes the LogBox to look odd.
+          const substitution =
+            typeof substitutions[substitutionIndex] === 'string'
+              ? substitutions[substitutionIndex]
+              : stringifySafe(substitutions[substitutionIndex]);
+          substitutionOffsets.push({
+            length: substitution.length,
+            offset: contentString.length,
+          });
+
+          categoryString += SUBSTITUTION;
+          contentString += substitution;
+        } else {
+          substitutionOffsets.push({
+            length: 2,
+            offset: contentString.length,
+          });
+
+          categoryString += '%s';
+          contentString += '%s';
+        }
+
+        substitutionIndex++;
+      }
+    }
+
+    categoryParts.push(categoryString);
+    contentParts.push(contentString);
+  }
+
+  const remainingArgs = remaining.map(arg => {
+    // Don't stringify a string type.
+    // It adds quotation mark wrappers around the string,
+    // which causes the LogBox to look odd.
+    return typeof arg === 'string' ? arg : stringifySafe(arg);
+  });
+  categoryParts.push(...remainingArgs);
+  contentParts.push(...remainingArgs);
+
+  return {
+    category: categoryParts.join(' '),
+    message: {
+      content: contentParts.join(' '),
+      substitutions: substitutionOffsets,
+    },
+  };
+}
+
+function isComponentStack(consoleArgument: string) {
+  const isOldComponentStackFormat =
+    RE_COMPONENT_STACK_LINE_OLD.test(consoleArgument);
+  const isNewComponentStackFormat =
+    RE_COMPONENT_STACK_LINE_NEW.test(consoleArgument);
+  const isNewJSCComponentStackFormat =
+    RE_COMPONENT_STACK_LINE_STACK_FRAME.test(consoleArgument);
+
+  return (
+    isOldComponentStackFormat ||
+    isNewComponentStackFormat ||
+    isNewJSCComponentStackFormat
+  );
+}
+
+export function parseComponentStack(message: string): {
+  type: ComponentStackType,
+  stack: ComponentStack,
+} {
+  // In newer versions of React, the component stack is formatted as a call stack frame.
+  // First try to parse the component stack as a call stack frame, and if that doesn't
+  // work then we'll fallback to the old custom component stack format parsing.
+  const stack = parseErrorStack(message);
+  if (stack && stack.length > 0) {
+    return {
+      type: 'stack',
+      stack: stack.map(frame => ({
+        content: frame.methodName,
+        collapse: frame.collapse || false,
+        fileName: frame.file == null ? 'unknown' : frame.file,
+        location: {
+          column: frame.column == null ? -1 : frame.column,
+          row: frame.lineNumber == null ? -1 : frame.lineNumber,
+        },
+      })),
+    };
+  }
+  const legacyStack = message
+    .split(RE_COMPONENT_STACK_LINE_GLOBAL)
+    .map(s => {
+      if (!s) {
+        return null;
+      }
+      const match = s.match(RE_COMPONENT_STACK_WITH_SOURCE);
+      if (match) {
+        let [content, fileName, row] = match.slice(1);
+        return {
+          content,
+          fileName,
+          location: {column: -1, row: parseInt(row, 10)},
+        };
+      }
+
+      // In some cases, the component stack doesn't have a source.
+      const matchWithoutSource = s.match(RE_COMPONENT_STACK_NO_SOURCE);
+      if (matchWithoutSource) {
+        return {
+          content: matchWithoutSource[1],
+          fileName: '',
+          location: null,
+        };
+      }
+
+      return null;
+    })
+    .filter(Boolean);
+
+  return {
+    type: 'legacy',
+    stack: legacyStack,
+  };
+}
+
+export function parseLogBoxException(
+  error: ExtendedExceptionData,
+): LogBoxLogData {
+  const message =
+    error.originalMessage != null ? error.originalMessage : 'Unknown';
+
+  const metroInternalError = message.match(RE_METRO_ERROR_FORMAT);
+  if (metroInternalError) {
+    const [content, fileName, row, column, codeFrame] =
+      metroInternalError.slice(1);
+
+    return {
+      level: 'fatal',
+      type: 'Metro Error',
+      stack: [],
+      isComponentError: false,
+      componentStackType: 'legacy',
+      componentStack: [],
+      codeFrame: {
+        fileName,
+        location: {
+          row: parseInt(row, 10),
+          column: parseInt(column, 10),
+        },
+        content: codeFrame,
+      },
+      message: {
+        content,
+        substitutions: [],
+      },
+      category: `${fileName}-${row}-${column}`,
+      extraData: error.extraData,
+    };
+  }
+
+  const babelTransformError = message.match(RE_BABEL_TRANSFORM_ERROR_FORMAT);
+  if (babelTransformError) {
+    // Transform errors are thrown from inside the Babel transformer.
+    const [fileName, content, row, column, codeFrame] =
+      babelTransformError.slice(1);
+
+    return {
+      level: 'syntax',
+      stack: [],
+      isComponentError: false,
+      componentStackType: 'legacy',
+      componentStack: [],
+      codeFrame: {
+        fileName,
+        location: {
+          row: parseInt(row, 10),
+          column: parseInt(column, 10),
+        },
+        content: codeFrame,
+      },
+      message: {
+        content,
+        substitutions: [],
+      },
+      category: `${fileName}-${row}-${column}`,
+      extraData: error.extraData,
+    };
+  }
+
+  // Perform a cheap match first before trying to parse the full message, which
+  // can get expensive for arbitrary input.
+  if (RE_BABEL_CODE_FRAME_MARKER_PATTERN.test(message)) {
+    const babelCodeFrameError = message.match(RE_BABEL_CODE_FRAME_ERROR_FORMAT);
+
+    if (babelCodeFrameError) {
+      // Codeframe errors are thrown from any use of buildCodeFrameError.
+      const [fileName, content, codeFrame] = babelCodeFrameError.slice(1);
+      return {
+        level: 'syntax',
+        stack: [],
+        isComponentError: false,
+        componentStackType: 'legacy',
+        componentStack: [],
+        codeFrame: {
+          fileName,
+          location: null, // We are not given the location.
+          content: codeFrame,
+        },
+        message: {
+          content,
+          substitutions: [],
+        },
+        category: `${fileName}-${1}-${1}`,
+        extraData: error.extraData,
+      };
+    }
+  }
+
+  if (message.match(RE_TRANSFORM_ERROR)) {
+    return {
+      level: 'syntax',
+      stack: error.stack,
+      isComponentError: error.isComponentError,
+      componentStackType: 'legacy',
+      componentStack: [],
+      message: {
+        content: message,
+        substitutions: [],
+      },
+      category: message,
+      extraData: error.extraData,
+    };
+  }
+
+  const componentStack = error.componentStack;
+  if (error.isFatal || error.isComponentError) {
+    if (componentStack != null) {
+      const {type, stack} = parseComponentStack(componentStack);
+      return {
+        level: 'fatal',
+        stack: error.stack,
+        isComponentError: error.isComponentError,
+        componentStackType: type,
+        componentStack: stack,
+        extraData: error.extraData,
+        ...parseInterpolation([message]),
+      };
+    } else {
+      return {
+        level: 'fatal',
+        stack: error.stack,
+        isComponentError: error.isComponentError,
+        componentStackType: 'legacy',
+        componentStack: [],
+        extraData: error.extraData,
+        ...parseInterpolation([message]),
+      };
+    }
+  }
+
+  if (componentStack != null) {
+    // It is possible that console errors have a componentStack.
+    const {type, stack} = parseComponentStack(componentStack);
+    return {
+      level: 'error',
+      stack: error.stack,
+      isComponentError: error.isComponentError,
+      componentStackType: type,
+      componentStack: stack,
+      extraData: error.extraData,
+      ...parseInterpolation([message]),
+    };
+  }
+
+  // Most `console.error` calls won't have a componentStack. We parse them like
+  // regular logs which have the component stack buried in the message.
+  return {
+    level: 'error',
+    stack: error.stack,
+    isComponentError: error.isComponentError,
+    extraData: error.extraData,
+    ...parseLogBoxLog([message]),
+  };
+}
+
+export function withoutANSIColorStyles(message: mixed): mixed {
+  if (typeof message !== 'string') {
+    return message;
+  }
+
+  return message.replace(
+    // eslint-disable-next-line no-control-regex
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    '',
+  );
+}
+
+export function parseLogBoxLog(args: $ReadOnlyArray<mixed>): {
+  componentStack: ComponentStack,
+  componentStackType: ComponentStackType,
+  category: Category,
+  message: Message,
+} {
+  const message = withoutANSIColorStyles(args[0]);
+  let argsWithoutComponentStack: Array<mixed> = [];
+  let componentStack: ComponentStack = [];
+  let componentStackType = 'legacy';
+
+  // Extract component stack from warnings like "Some warning%s".
+  if (
+    typeof message === 'string' &&
+    message.slice(-2) === '%s' &&
+    args.length > 0
+  ) {
+    const lastArg = args[args.length - 1];
+    if (typeof lastArg === 'string' && isComponentStack(lastArg)) {
+      argsWithoutComponentStack = args.slice(0, -1);
+      argsWithoutComponentStack[0] = message.slice(0, -2);
+      const {type, stack} = parseComponentStack(lastArg);
+      componentStack = stack;
+      componentStackType = type;
+    }
+  }
+
+  if (componentStack.length === 0 && argsWithoutComponentStack.length === 0) {
+    // Try finding the component stack elsewhere.
+    for (const arg of args) {
+      if (typeof arg === 'string' && isComponentStack(arg)) {
+        // Strip out any messages before the component stack.
+        let messageEndIndex = arg.search(RE_COMPONENT_STACK_LINE);
+        if (messageEndIndex < 0) {
+          // Handle JSC component stacks.
+          messageEndIndex = arg.search(/\n/);
+        }
+        if (messageEndIndex > 0) {
+          argsWithoutComponentStack.push(arg.slice(0, messageEndIndex));
+        }
+
+        const {type, stack} = parseComponentStack(arg);
+        componentStack = stack;
+        componentStackType = type;
+      } else {
+        argsWithoutComponentStack.push(arg);
+      }
+    }
+  }
+
+  return {
+    ...parseInterpolation(argsWithoutComponentStack),
+    componentStack,
+    /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
+     * https://fburl.com/workplace/6291gfvu */
+    componentStackType,
+  };
+}