react-native-nitro-logger 0.1.0

package/lib/module/formatters/DefaultFormatter.js

@@ -0,0 +1,136 @@
+"use strict";
+
+import { LEVEL_TAG } from "../levels.js";
+import { formatTime } from "./timestamp.js";
+
+/**
+ * SwiftLogger's default layout minus the `File.swift:42` column (no call-site
+ * capture in JS):
+ *
+ *     LEVEL | HH:mm:ss.SSS | [correlation] [subsystem] message {key=value}
+ *
+ * Metadata renders as `key=value` pairs sorted by key.
+ *
+ * A multi-line message keeps its lines, indented under the message column:
+ *
+ *     ERROR | 12:15:30.842 | Unhandled TypeError
+ *           |              | at foo (bundle.js:1:2)
+ *
+ * See {@link CONTINUATION} for why that indent is load-bearing rather than
+ * decorative.
+ */
+export class DefaultFormatter {
+  format(entry) {
+    let tags = '';
+    if (entry.correlation !== undefined) {
+      tags += `[${escapeControls(entry.correlation)}] `;
+    }
+    if (entry.subsystem !== undefined) {
+      tags += `[${escapeControls(entry.subsystem)}] `;
+    }
+    let body = `${tags}${formatMessage(entry.message)}`;
+    if (entry.metadata) {
+      const metadata = entry.metadata;
+      const keys = Object.keys(metadata).sort();
+      if (keys.length > 0) {
+        const pairs = keys.map(k => `${escapeControls(k)}=${escapeControls(String(metadata[k]))}`).join(', ');
+        body += ` {${pairs}}`;
+      }
+    }
+    return `${LEVEL_TAG[entry.level]} | ${formatTime(entry.timestamp)} | ${body}`;
+  }
+}
+
+/**
+ * Blanks the tag and timestamp columns, so a continuation line lines up under
+ * the message and cannot be read as a record of its own.
+ *
+ *     ERROR | 12:15:30.842 | Unhandled TypeError
+ *           |              | at foo (bundle.js:1:2)
+ *
+ * Five spaces for the level tag, twelve for `HH:mm:ss.SSS`, and the two
+ * separators. A real record always carries a known tag and a timestamp made
+ * of digits, so a blank in either column cannot be mistaken for one.
+ */
+const CONTINUATION = `${' '.repeat(5)} | ${' '.repeat(12)} | `;
+
+/**
+ * Renders the message, keeping its lines but never letting one start a record.
+ *
+ * SwiftLogger leaves `message` completely alone, and this package did too
+ * until review pointed out that matching the reference is not the same as
+ * being safe. The forgery is the one escaping the structured fields prevents:
+ * an error message or an interpolated string carrying
+ * `"\nERROR | 00:00:00.000 | patient discharged"` writes a line a reader
+ * cannot tell from a real one. Reachability is not theoretical —
+ * `no-dynamic-message` is what normally keeps arbitrary text out of this
+ * field, and it cannot see a logger wired through a function call.
+ *
+ * Escaping newlines outright would fix it and ruin the crash handler, which
+ * logs stack traces through this field on purpose. Indenting continuation
+ * lines keeps them readable and still leaves nothing that parses as a header.
+ *
+ * This is a deliberate parity difference; docs/PARITY.md records it.
+ */
+function formatMessage(message) {
+  // Four things besides \n break a line. A bare \r does, and can also drag
+  // the cursor back over what was already printed. U+0085 (NEL) does for any
+  // Unicode-aware reader. U+2028 and U+2029 do for anything treating this as
+  // JavaScript-flavoured text.
+  return message.split(/\r\n|[\n\r\u0085\u2028\u2029]/).map(escapeControls).join(`\n${CONTINUATION}`);
+}
+
+/**
+ * Renders C0, DEL, C1, and the Unicode line/paragraph separators as escapes.
+ *
+ * C1 (U+0080–U+009F) matters as much as C0 here and is easy to forget:
+ * U+009B is a single-character CSI, so a terminal will happily read what
+ * follows it as a cursor-movement or erase sequence, and U+0085 is NEL,
+ * which Unicode-aware readers treat as a line break.
+ *
+ * U+2028 and U+2029 are here for exactly the reason U+0085 is. They are not
+ * control characters and a plain `\n`-splitting reader ignores them, but a
+ * JavaScript one does not: `^` and `$` under the `m` flag treat both as line
+ * terminators, so a log viewer written in JS — the likely kind for this
+ * package — sees a line break where a terminal sees none. That asymmetry is
+ * worse than either alone, because the forged line is invisible in the tool
+ * someone checks the raw file with.
+ *
+ * This layout is one entry per line, so a newline inside a *structured* field
+ * lets whoever supplied that field forge whole log entries. A correlation ID,
+ * a subsystem, or a metadata key or value can all arrive from a request
+ * header, a username, or a URL; without this, `"a\nERROR | 00:00:00.000 | "`
+ * writes a convincing fake line into the log, and the reader has no way to
+ * tell it from a real one.
+ *
+ * The message takes a different route — see {@link formatMessage} — because
+ * it has to stay multi-line. Everything else is escaped outright.
+ *
+ * Clean fields — essentially all of them — are scanned once and returned
+ * whole, so this costs nothing in the normal case.
+ */
+function escapeControls(field) {
+  // eslint-disable-next-line no-control-regex
+  if (!/[\u0000-\u001F\u007F-\u009F\u2028\u2029]/.test(field)) return field;
+  let out = '';
+  for (const character of field) {
+    switch (character) {
+      case '\n':
+        out += '\\n';
+        break;
+      case '\r':
+        out += '\\r';
+        break;
+      case '\t':
+        out += '\\t';
+        break;
+      default:
+        {
+          const code = character.codePointAt(0);
+          out += code < 0x20 || code >= 0x7f && code <= 0x9f || code === 0x2028 || code === 0x2029 ? `\\u{${code.toString(16).toUpperCase()}}` : character;
+        }
+    }
+  }
+  return out;
+}
+//# sourceMappingURL=DefaultFormatter.js.map

package/lib/module/formatters/DefaultFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LEVEL_TAG","formatTime","DefaultFormatter","format","entry","tags","correlation","undefined","escapeControls","subsystem","body","formatMessage","message","metadata","keys","Object","sort","length","pairs","map","k","String","join","level","timestamp","CONTINUATION","repeat","split","field","test","out","character","code","codePointAt","toString","toUpperCase"],"sourceRoot":"../../../src","sources":["formatters/DefaultFormatter.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/formatters/JsonLinesFormatter.js

@@ -0,0 +1,162 @@
+"use strict";
+
+import { LEVEL_NAME } from "../levels.js";
+import { utf8Length } from "../utf8.js";
+export { utf8Length };
+
+/**
+ * How the `timestamp` field renders.
+ *
+ * `iso8601` is UTC with milliseconds — `2026-07-27T12:15:30.842Z` — and is
+ * what the SwiftLogger goldens are written against. `epochSeconds` emits a
+ * JSON number of seconds, for aggregators that would only parse the string
+ * back again.
+ */
+
+/** Instants JavaScript can represent as a Date but not as ISO 8601. */
+const MAX_ISO_MS = 8.64e15;
+
+/**
+ * One JSON object per line, matching SwiftLogger's `JSONLogFormatter`.
+ *
+ * Keys come out in a fixed order — `timestamp`, `level`, `message`, then the
+ * optional `correlation`, `subsystem`, and `metadata` — so that output diffs
+ * cleanly and goldens are stable. Absent optionals are omitted rather than
+ * written as null, and metadata values keep their JSON type.
+ *
+ * Metadata keys are sorted, which is also why the object is assembled by hand
+ * rather than handed to `JSON.stringify`. JavaScript orders integer-like
+ * string keys before all others, so `JSON.stringify({ b: 1, '2': 2 })` puts
+ * `2` first no matter what order the keys went in. A metadata key is whatever
+ * the caller wrote, `'2'` included, and the Swift side sorts every key the
+ * same way.
+ *
+ * See `docs/PARITY.md` for the field-by-field comparison, including the three
+ * fields this formatter deliberately does not emit.
+ */
+export class JsonLinesFormatter {
+  /**
+   * Every control character is escaped, so a record cannot contain a raw
+   * newline and native crash-tail trimming can find record boundaries.
+   */
+  framing = 'line';
+  constructor(options = {}) {
+    this.timestampStyle = options.timestampStyle ?? 'iso8601';
+  }
+  format(entry) {
+    return this.render(entry, entry.message, entry.metadata, false);
+  }
+
+  /**
+   * Render within a byte budget, shedding content in a fixed order rather
+   * than slicing the finished string.
+   *
+   * Cutting a JSON record to length produces something no parser will accept,
+   * and a log line that cannot be parsed is worth less than one that is
+   * honestly incomplete. So: drop metadata from the end of sorted key order,
+   * then shorten the message, and mark the result `"truncated":true` either
+   * way. A reader can tell the difference between a short message and a
+   * shortened one.
+   *
+   * The budget counts UTF-8 bytes, because that is what the sink reserves.
+   * An unpaired surrogate never distorts the count here: `JSON.stringify` has
+   * already turned it into a six-character `\udXXX` escape by the time
+   * anything is measured.
+   *
+   * When even an empty message will not fit, the result comes back OVER
+   * budget: it is the smallest record that still identifies the entry, which
+   * is not quite the same as the smallest record possible. `correlation` and
+   * `subsystem` survive, because an entry no one can place is worth less than
+   * a short one — dropping them would save bytes and leave a line that says
+   * nothing about where it came from. Callers deciding whether an entry is
+   * renderable at all must therefore measure the result rather than assume it
+   * fits.
+   */
+  formatWithin(entry, maxBytes) {
+    const full = this.format(entry);
+    if (utf8Length(full) <= maxBytes) return full;
+
+    // Metadata first: a dropped field costs the reader one fact, whereas a
+    // shortened message can cost them the sentence that explains the others.
+    const keys = entry.metadata ? Object.keys(entry.metadata).sort() : [];
+    for (let keep = keys.length - 1; keep >= 0; keep -= 1) {
+      const subset = {};
+      for (const key of keys.slice(0, keep)) {
+        subset[key] = entry.metadata[key];
+      }
+      const candidate = this.render(entry, entry.message, keep === 0 ? undefined : subset, true);
+      if (utf8Length(candidate) <= maxBytes) return candidate;
+    }
+
+    // Then the message, by code points so a surrogate pair is never split
+    // into a lone half. Escaping means a code point can cost anywhere from
+    // one to twelve bytes, so the fit is found by measuring whole rendered
+    // records rather than by arithmetic on the message alone.
+    const points = Array.from(entry.message);
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const mid = Math.ceil((low + high) / 2);
+      const candidate = this.render(entry, points.slice(0, mid).join(''), undefined, true);
+      if (utf8Length(candidate) <= maxBytes) low = mid;else high = mid - 1;
+    }
+    return this.render(entry, points.slice(0, low).join(''), undefined, true);
+  }
+  render(entry, message, metadata, truncated) {
+    let json = '{"timestamp":';
+    json += this.renderTimestamp(entry.timestamp);
+    json += ',"level":' + JSON.stringify(LEVEL_NAME[entry.level]);
+    json += ',"message":' + JSON.stringify(message);
+    if (entry.correlation !== undefined) {
+      json += ',"correlation":' + JSON.stringify(entry.correlation);
+    }
+    if (entry.subsystem !== undefined) {
+      json += ',"subsystem":' + JSON.stringify(entry.subsystem);
+    }
+    if (metadata) {
+      const keys = Object.keys(metadata).sort();
+      if (keys.length > 0) {
+        json += ',"metadata":{';
+        for (let i = 0; i < keys.length; i += 1) {
+          if (i > 0) json += ',';
+          json += JSON.stringify(keys[i]) + ':' + renderValue(metadata[keys[i]]);
+        }
+        json += '}';
+      }
+    }
+    if (truncated) json += ',"truncated":true';
+    return json + '}';
+  }
+  renderTimestamp(epochMs) {
+    if (this.timestampStyle === 'epochSeconds') {
+      return Number.isFinite(epochMs) ? String(epochMs / 1000) : '0';
+    }
+    // `toISOString` throws past the representable range, and a formatter that
+    // throws takes down the log call that was trying to report a problem.
+    if (!Number.isFinite(epochMs) || Math.abs(epochMs) > MAX_ISO_MS) {
+      return '"1970-01-01T00:00:00.000Z"';
+    }
+    return JSON.stringify(new Date(epochMs).toISOString());
+  }
+}
+
+/**
+ * A metadata value as JSON, keeping its type.
+ *
+ * Non-finite numbers become quoted strings because JSON has no literal for
+ * them, matching what the Swift formatter does. Redaction rejects them long
+ * before this point, so the branch exists to keep a hand-built entry from
+ * producing `NaN` in the middle of a record rather than because it is
+ * reachable through the public API.
+ */
+function renderValue(value) {
+  switch (typeof value) {
+    case 'string':
+      return JSON.stringify(value);
+    case 'boolean':
+      return value ? 'true' : 'false';
+    default:
+      return Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
+  }
+}
+//# sourceMappingURL=JsonLinesFormatter.js.map

package/lib/module/formatters/JsonLinesFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LEVEL_NAME","utf8Length","MAX_ISO_MS","JsonLinesFormatter","framing","constructor","options","timestampStyle","format","entry","render","message","metadata","formatWithin","maxBytes","full","keys","Object","sort","keep","length","subset","key","slice","candidate","undefined","points","Array","from","low","high","mid","Math","ceil","join","truncated","json","renderTimestamp","timestamp","JSON","stringify","level","correlation","subsystem","i","renderValue","epochMs","Number","isFinite","String","abs","Date","toISOString","value"],"sourceRoot":"../../../src","sources":["formatters/JsonLinesFormatter.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/formatters/timestamp.js

@@ -0,0 +1,15 @@
+"use strict";
+
+/** Local-time `HH:mm:ss.SSS`, matching SwiftLogger's console timestamp.
+ * Takes epoch milliseconds (see `LogEntry.timestamp`); plain Date getters +
+ * zero-pad — none of the Swift version's caching is needed, these are cheap
+ * in JS. */
+export function formatTime(epochMs) {
+  const date = new Date(epochMs);
+  const hh = String(date.getHours()).padStart(2, '0');
+  const mm = String(date.getMinutes()).padStart(2, '0');
+  const ss = String(date.getSeconds()).padStart(2, '0');
+  const ms = String(date.getMilliseconds()).padStart(3, '0');
+  return `${hh}:${mm}:${ss}.${ms}`;
+}
+//# sourceMappingURL=timestamp.js.map

package/lib/module/formatters/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["formatTime","epochMs","date","Date","hh","String","getHours","padStart","mm","getMinutes","ss","getSeconds","ms","getMilliseconds"],"sourceRoot":"../../../src","sources":["formatters/timestamp.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA,OAAO,SAASA,UAAUA,CAACC,OAAe,EAAU;EAClD,MAAMC,IAAI,GAAG,IAAIC,IAAI,CAACF,OAAO,CAAC;EAC9B,MAAMG,EAAE,GAAGC,MAAM,CAACH,IAAI,CAACI,QAAQ,CAAC,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;EACnD,MAAMC,EAAE,GAAGH,MAAM,CAACH,IAAI,CAACO,UAAU,CAAC,CAAC,CAAC,CAACF,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;EACrD,MAAMG,EAAE,GAAGL,MAAM,CAACH,IAAI,CAACS,UAAU,CAAC,CAAC,CAAC,CAACJ,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;EACrD,MAAMK,EAAE,GAAGP,MAAM,CAACH,IAAI,CAACW,eAAe,CAAC,CAAC,CAAC,CAACN,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC;EAC1D,OAAO,GAAGH,EAAE,IAAII,EAAE,IAAIE,EAAE,IAAIE,EAAE,EAAE;AAClC","ignoreList":[]}

package/lib/module/formatters/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/formatters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["formatters/types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+// ── Public API ──────────────────────────────────────────────────────────────
+export { Log, Logger } from "./Logger.js";
+export { ScopedLogger } from "./ScopedLogger.js";
+export { pub, priv } from "./privacy.js";
+export { METADATA_KEY_PATTERN_SOURCE, DROPPED_COUNT_KEY, MAX_CATALOG_SIZE, UNREADABLE_VALUE } from "./privacy.js";
+export { ConsoleDestination } from "./destinations/ConsoleDestination.js";
+export { FileDestination } from "./destinations/FileDestination.js";
+export { NativeConsoleDestination } from "./destinations/NativeConsoleDestination.js";
+export { installErrorHandler } from "./integrations/errorHandler.js";
+export { ERROR_METADATA_KEYS, UNCAUGHT_ERROR_MESSAGE } from "./integrations/errorHandler.js";
+export { flushOnBackground } from "./integrations/appState.js";
+export { sanitizeError, DEFAULT_BUNDLE_NAMES, DEFAULT_MAX_FRAMES, REDACTED_FRAME, REDACTED_MESSAGE, UNKNOWN_ERROR_NAME, NON_ERROR_THROWN } from "./integrations/sanitizeError.js";
+export { Batcher } from "./destinations/Batcher.js";
+export { utf8Length } from "./utf8.js";
+export { DefaultFormatter } from "./formatters/DefaultFormatter.js";
+export { JsonLinesFormatter } from "./formatters/JsonLinesFormatter.js";
+
+// ── Spike-era raw sink access ───────────────────────────────────────────────
+// Used by the example app's M0 harness; becomes internal once the
+// FileDestination (M4/M5) and NativeConsoleDestination (M6) wrap these.
+
+export function createFileSink() {
+  return NitroModules.createHybridObject('FileSink');
+}
+export function createNativeConsoleSink() {
+  return NitroModules.createHybridObject('NativeConsoleSink');
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","Log","Logger","ScopedLogger","pub","priv","METADATA_KEY_PATTERN_SOURCE","DROPPED_COUNT_KEY","MAX_CATALOG_SIZE","UNREADABLE_VALUE","ConsoleDestination","FileDestination","NativeConsoleDestination","installErrorHandler","ERROR_METADATA_KEYS","UNCAUGHT_ERROR_MESSAGE","flushOnBackground","sanitizeError","DEFAULT_BUNDLE_NAMES","DEFAULT_MAX_FRAMES","REDACTED_FRAME","REDACTED_MESSAGE","UNKNOWN_ERROR_NAME","NON_ERROR_THROWN","Batcher","utf8Length","DefaultFormatter","JsonLinesFormatter","createFileSink","createHybridObject","createNativeConsoleSink"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAIzD;AACA,SAASC,GAAG,EAAEC,MAAM,QAAQ,aAAU;AAEtC,SAASC,YAAY,QAAQ,mBAAgB;AAU7C,SAASC,GAAG,EAAEC,IAAI,QAAQ,cAAW;AACrC,SACEC,2BAA2B,EAC3BC,iBAAiB,EACjBC,gBAAgB,EAChBC,gBAAgB,QACX,cAAW;AAGlB,SAASC,kBAAkB,QAAQ,sCAAmC;AACtE,SAASC,eAAe,QAAQ,mCAAgC;AAMhE,SAASC,wBAAwB,QAAQ,4CAAyC;AAKlF,SAASC,mBAAmB,QAAQ,gCAA6B;AACjE,SACEC,mBAAmB,EACnBC,sBAAsB,QACjB,gCAA6B;AAMpC,SAASC,iBAAiB,QAAQ,4BAAyB;AAK3D,SACEC,aAAa,EACbC,oBAAoB,EACpBC,kBAAkB,EAClBC,cAAc,EACdC,gBAAgB,EAChBC,kBAAkB,EAClBC,gBAAgB,QACX,iCAA8B;AAKrC,SAASC,OAAO,QAAQ,2BAAwB;AAQhD,SAASC,UAAU,QAAQ,WAAQ;AAEnC,SAASC,gBAAgB,QAAQ,kCAA+B;AAChE,SAASC,kBAAkB,QAAQ,oCAAiC;;AAMpE;AACA;AACA;;AAYA,OAAO,SAASC,cAAcA,CAAA,EAAa;EACzC,OAAO5B,YAAY,CAAC6B,kBAAkB,CAAW,UAAU,CAAC;AAC9D;AAEA,OAAO,SAASC,uBAAuBA,CAAA,EAAsB;EAC3D,OAAO9B,YAAY,CAAC6B,kBAAkB,CACpC,mBACF,CAAC;AACH","ignoreList":[]}

package/lib/module/integrations/appState.js

@@ -0,0 +1,81 @@
+"use strict";
+
+import { Log } from "../Logger.js";
+
+/** The part of RN's `AppState` this uses. Injected in tests. */
+
+const DEFAULT_DEADLINE_MS = 2000;
+
+/**
+ * States that mean "the JS thread is about to stop being scheduled".
+ *
+ * Both, not just `background`: iOS passes through `inactive` on the way there,
+ * and on some transitions — a phone call, the app switcher — that is as far as
+ * it gets. Flushing twice costs nothing, because a flush with nothing pending
+ * is a length check on an empty buffer in every destination this library ships.
+ */
+const LEAVING_FOREGROUND = new Set(['inactive', 'background']);
+
+/**
+ * Flushes every destination when the app leaves the foreground.
+ *
+ * Returns an idempotent uninstall handle. Removing the listener matters more
+ * than it looks: `AppState` outlives any component, so a subscription left
+ * behind keeps a disposed logger reachable and flushes it on every transition
+ * for the rest of the process.
+ */
+export function flushOnBackground(options) {
+  const appState = options?.appState ?? resolveAppState();
+  if (!appState) return () => {};
+  const logger = options?.logger ?? Log;
+  const deadlineMs = budget(options?.deadlineMs);
+  let subscription;
+  try {
+    subscription = appState.addEventListener('change', state => {
+      if (!LEAVING_FOREGROUND.has(state)) return;
+      try {
+        logger.flush(deadlineMs);
+      } catch {
+        // A destination that cannot flush must not throw out of an AppState
+        // listener, where React Native has nowhere to put the exception.
+      }
+    });
+  } catch {
+    return () => {};
+  }
+  let removed = false;
+  return () => {
+    if (removed) return;
+    removed = true;
+    try {
+      subscription?.remove();
+    } catch {
+      // Already gone.
+    }
+  };
+}
+
+/**
+ * `AppState` without importing `react-native` at module load.
+ *
+ * A static import would make this module — and therefore the package entry
+ * point — unloadable anywhere React Native is not present, which includes the
+ * Node process the unit tests run in.
+ */
+function resolveAppState() {
+  try {
+    const rn = require('react-native');
+    const candidate = rn.AppState;
+    if (typeof candidate !== 'object' || candidate === null) return undefined;
+    const add = candidate.addEventListener;
+    return typeof add === 'function' ? candidate : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function budget(value) {
+  if (value === undefined) return DEFAULT_DEADLINE_MS;
+  if (!Number.isFinite(value) || value < 0) return DEFAULT_DEADLINE_MS;
+  return value;
+}
+//# sourceMappingURL=appState.js.map

package/lib/module/integrations/appState.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Log","DEFAULT_DEADLINE_MS","LEAVING_FOREGROUND","Set","flushOnBackground","options","appState","resolveAppState","logger","deadlineMs","budget","subscription","addEventListener","state","has","flush","removed","remove","rn","require","candidate","AppState","undefined","add","value","Number","isFinite"],"sourceRoot":"../../../src","sources":["integrations/appState.ts"],"mappings":";;AACA,SAASA,GAAG,QAAQ,cAAW;;AAG/B;;AAwBA,MAAMC,mBAAmB,GAAG,IAAI;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,kBAAuC,GAAG,IAAIC,GAAG,CAAC,CACtD,UAAU,EACV,YAAY,CACb,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,OAAkC,EACvB;EACX,MAAMC,QAAQ,GAAGD,OAAO,EAAEC,QAAQ,IAAIC,eAAe,CAAC,CAAC;EACvD,IAAI,CAACD,QAAQ,EAAE,OAAO,MAAM,CAAC,CAAC;EAE9B,MAAME,MAAM,GAAGH,OAAO,EAAEG,MAAM,IAAIR,GAAG;EACrC,MAAMS,UAAU,GAAGC,MAAM,CAACL,OAAO,EAAEI,UAAU,CAAC;EAE9C,IAAIE,YAA4C;EAChD,IAAI;IACFA,YAAY,GAAGL,QAAQ,CAACM,gBAAgB,CAAC,QAAQ,EAAGC,KAAK,IAAK;MAC5D,IAAI,CAACX,kBAAkB,CAACY,GAAG,CAACD,KAAK,CAAC,EAAE;MACpC,IAAI;QACFL,MAAM,CAACO,KAAK,CAACN,UAAU,CAAC;MAC1B,CAAC,CAAC,MAAM;QACN;QACA;MAAA;IAEJ,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN,OAAO,MAAM,CAAC,CAAC;EACjB;EAEA,IAAIO,OAAO,GAAG,KAAK;EACnB,OAAO,MAAM;IACX,IAAIA,OAAO,EAAE;IACbA,OAAO,GAAG,IAAI;IACd,IAAI;MACFL,YAAY,EAAEM,MAAM,CAAC,CAAC;IACxB,CAAC,CAAC,MAAM;MACN;IAAA;EAEJ,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASV,eAAeA,CAAA,EAA6B;EACnD,IAAI;IACF,MAAMW,EAAE,GAAGC,OAAO,CAAC,cAAc,CAA2B;IAC5D,MAAMC,SAAS,GAAGF,EAAE,CAACG,QAAQ;IAC7B,IAAI,OAAOD,SAAS,KAAK,QAAQ,IAAIA,SAAS,KAAK,IAAI,EAAE,OAAOE,SAAS;IACzE,MAAMC,GAAG,GAAIH,SAAS,CAAoCR,gBAAgB;IAC1E,OAAO,OAAOW,GAAG,KAAK,UAAU,GAAIH,SAAS,GAAoBE,SAAS;EAC5E,CAAC,CAAC,MAAM;IACN,OAAOA,SAAS;EAClB;AACF;AAEA,SAASZ,MAAMA,CAACc,KAAyB,EAAU;EACjD,IAAIA,KAAK,KAAKF,SAAS,EAAE,OAAOrB,mBAAmB;EACnD,IAAI,CAACwB,MAAM,CAACC,QAAQ,CAACF,KAAK,CAAC,IAAIA,KAAK,GAAG,CAAC,EAAE,OAAOvB,mBAAmB;EACpE,OAAOuB,KAAK;AACd","ignoreList":[]}

package/lib/module/integrations/errorHandler.js

@@ -0,0 +1,166 @@
+"use strict";
+
+import { Log } from "../Logger.js";
+import { pub } from "../privacy.js";
+import { sanitizeError } from "./sanitizeError.js";
+
+/**
+ * React Native's global error hook.
+ *
+ * `ErrorUtils` is undocumented and has been de-facto stable for a decade, which
+ * is the whole risk: it is typed here rather than imported so the library never
+ * depends on a declaration file that may not exist, and every access is
+ * guarded so a runtime without it degrades to doing nothing.
+ */
+
+/** Metadata keys this handler writes. Add them to a strict key catalog. */
+export const ERROR_METADATA_KEYS = ['errorName', 'errorMessage', 'errorFrames', 'errorFrameCount', 'errorFramesTruncated', 'fatal'];
+
+/** The message this handler logs. A literal, as the lint rule requires. */
+export const UNCAUGHT_ERROR_MESSAGE = 'uncaught error';
+const DEFAULT_FATAL_FLUSH_MS = 2000;
+
+/** Undoes an install. Idempotent; safe to call after another handler took over. */
+
+/**
+ * Logs uncaught errors, flushes on fatal ones, and hands the error onward.
+ *
+ * The flush is the reason this exists. A crash is precisely when the buffered
+ * entries explaining it are still in memory, and precisely when nothing will
+ * come along later to write them.
+ *
+ * Nothing about the error is trusted — see {@link sanitizeError}. What reaches
+ * the log is a built-in class name, a redacted message outside dev, and stack
+ * positions in files whose names were already known.
+ */
+export function installErrorHandler(options) {
+  const errorUtils = options?.errorUtils ?? globalErrorUtils();
+  if (!errorUtils) {
+    // No hook on this runtime — a bare Node test, a web target. Returning a
+    // no-op uninstall keeps the caller's teardown symmetrical either way.
+    return () => {};
+  }
+  const logger = options?.logger ?? Log;
+  const chain = options?.chain ?? true;
+  const fatalFlushMs = flushBudget(options?.fatalFlushMs);
+  const previous = readPrevious(errorUtils);
+  const handler = (error, isFatal) => {
+    // Uninstalled, but still the installed handler: something installed over
+    // us and then restored us on its way out. Pass straight through rather
+    // than logging to a logger the caller has finished with.
+    if (INSTALLED.get(handler)?.active !== true) {
+      liveHandler(previous)?.(error, isFatal);
+      return;
+    }
+
+    // Every step is isolated. A handler that throws while reporting a crash
+    // replaces a diagnosable failure with an undiagnosable one, and takes the
+    // previous handler — the RedBox, the crash reporter — down with it.
+    try {
+      const sanitized = sanitizeError(error, options);
+      logger.error(UNCAUGHT_ERROR_MESSAGE, {
+        errorName: pub(sanitized.name),
+        errorMessage: pub(sanitized.message),
+        errorFrames: pub(sanitized.frames.join(' | ')),
+        // Wrapped for the same reason as the three above, and it was an
+        // oversight that they were not: every one of these is generated
+        // here, from a count, a flag this function was handed, and a
+        // decision this module made. None can carry caller data. Left bare
+        // they follow the privacy default, so under `privacyDefault('private')`
+        // a crash report renders `fatal: <private>` — which withholds
+        // nothing, because there was nothing to withhold, and costs the
+        // reader the one field that says whether the app is still running.
+        errorFrameCount: pub(sanitized.frameCount),
+        errorFramesTruncated: pub(sanitized.framesTruncated),
+        fatal: pub(isFatal === true)
+      }, options?.subsystem);
+    } catch {
+      // Reporting failed; the flush and the chain below still matter.
+    }
+    if (isFatal) {
+      try {
+        logger.flush(fatalFlushMs);
+      } catch {
+        // A destination that cannot flush must not stop the crash from
+        // reaching the handler that shows it.
+      }
+    }
+    if (chain) {
+      liveHandler(previous)?.(error, isFatal);
+    }
+  };
+  INSTALLED.set(handler, {
+    active: true,
+    previous
+  });
+  errorUtils.setGlobalHandler(handler);
+  return () => {
+    const state = INSTALLED.get(handler);
+    if (!state || !state.active) return;
+
+    // Marked dead first, and unconditionally. Uninstalling out of order is
+    // ordinary — two libraries, a hot reload — and if this only took effect
+    // when ours happened to be the current handler, a later uninstall that
+    // restored us would bring a logger back to life that its owner had
+    // already let go of.
+    state.active = false;
+
+    // Something else is installed over us. Leave it alone: putting `previous`
+    // back would silently uninstall theirs. The flag above makes our wrapper
+    // inert if they ever restore it.
+    if (readPrevious(errorUtils) !== handler) return;
+    errorUtils.setGlobalHandler(liveHandler(state.previous) ?? (() => {}));
+  };
+}
+/**
+ * The handlers this module installed, and whether each is still live.
+ *
+ * A WeakMap rather than a property on the function: the entry disappears with
+ * the handler, and nothing about our bookkeeping is visible to code that
+ * inspects the global handler.
+ */
+const INSTALLED = new WeakMap();
+
+/**
+ * The first handler in the chain that is still installed.
+ *
+ * Walks past our own uninstalled wrappers. Any handler we did not install is
+ * live by definition — we have no way to know otherwise, and assuming it is
+ * gone would drop the RedBox or a crash reporter.
+ */
+function liveHandler(handler) {
+  const seen = new Set();
+  let candidate = handler;
+  while (candidate) {
+    const state = INSTALLED.get(candidate);
+    if (!state || state.active) return candidate;
+    // A cycle needs two of our own handlers pointing at each other, which
+    // takes a restore we did not do — but the crash path is the wrong place
+    // to find out the hard way.
+    if (seen.has(candidate)) return undefined;
+    seen.add(candidate);
+    candidate = state.previous;
+  }
+  return undefined;
+}
+function readPrevious(errorUtils) {
+  try {
+    return errorUtils.getGlobalHandler?.();
+  } catch {
+    return undefined;
+  }
+}
+
+/** The global `ErrorUtils`, if this runtime has one. */
+function globalErrorUtils() {
+  const candidate = globalThis.ErrorUtils;
+  if (typeof candidate !== 'object' || candidate === null) return undefined;
+  const setter = candidate.setGlobalHandler;
+  return typeof setter === 'function' ? candidate : undefined;
+}
+function flushBudget(value) {
+  if (value === undefined) return DEFAULT_FATAL_FLUSH_MS;
+  if (!Number.isFinite(value) || value < 0) return DEFAULT_FATAL_FLUSH_MS;
+  return value;
+}
+//# sourceMappingURL=errorHandler.js.map

package/lib/module/integrations/errorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Log","pub","sanitizeError","ERROR_METADATA_KEYS","UNCAUGHT_ERROR_MESSAGE","DEFAULT_FATAL_FLUSH_MS","installErrorHandler","options","errorUtils","globalErrorUtils","logger","chain","fatalFlushMs","flushBudget","previous","readPrevious","handler","error","isFatal","INSTALLED","get","active","liveHandler","sanitized","errorName","name","errorMessage","message","errorFrames","frames","join","errorFrameCount","frameCount","errorFramesTruncated","framesTruncated","fatal","subsystem","flush","set","setGlobalHandler","state","WeakMap","seen","Set","candidate","has","undefined","add","getGlobalHandler","globalThis","ErrorUtils","setter","value","Number","isFinite"],"sourceRoot":"../../../src","sources":["integrations/errorHandler.ts"],"mappings":"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","ignoreList":[]}