@scalebun-release/react-native 2.5.0

package/lib/commonjs/features/replay/core/ids/sessionId.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateBatchId = generateBatchId;
+exports.generateEventId = generateEventId;
+exports.generateFrameId = generateFrameId;
+exports.generateSessionId = generateSessionId;
+/**
+ * Session Replay SDK — Session ID Generator
+ *
+ * Generates unique session and event identifiers.
+ * Uses timestamp + random suffix for uniqueness without external deps.
+ */
+
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+function randomString(length) {
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+  }
+  return result;
+}
+
+/** Generate a unique session ID: "rs-{timestamp}-{random}" */
+function generateSessionId() {
+  const ts = Date.now().toString(36);
+  const rand = randomString(8);
+  return `rs-${ts}-${rand}`;
+}
+
+/** Generate a unique event ID: "re-{timestamp}-{random}" */
+function generateEventId() {
+  const ts = Date.now().toString(36);
+  const rand = randomString(6);
+  return `re-${ts}-${rand}`;
+}
+
+/** Generate a unique frame ID: "rf-{timestamp}-{random}" */
+function generateFrameId() {
+  const ts = Date.now().toString(36);
+  const rand = randomString(6);
+  return `rf-${ts}-${rand}`;
+}
+
+/** Generate a unique batch ID: "rb-{timestamp}-{random}" */
+function generateBatchId() {
+  const ts = Date.now().toString(36);
+  const rand = randomString(4);
+  return `rb-${ts}-${rand}`;
+}
+//# sourceMappingURL=sessionId.js.map

package/lib/commonjs/features/replay/core/logger/logger.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+exports.setVerbose = setVerbose;
+/**
+ * Session Replay SDK — Internal Logger
+ *
+ * Leveled logger with optional verbose mode.
+ * All SDK internal logging goes through this.
+ */
+
+const LOG_PREFIX = '[ReplaySdk]';
+let _verbose = false;
+function setVerbose(enabled) {
+  _verbose = enabled;
+}
+const logger = exports.logger = {
+  debug(message, ...args) {
+    if (_verbose) {
+      console.debug(`${LOG_PREFIX} ${message}`, ...args);
+    }
+  },
+  info(message, ...args) {
+    console.info(`${LOG_PREFIX} ${message}`, ...args);
+  },
+  warn(message, ...args) {
+    console.warn(`${LOG_PREFIX} ${message}`, ...args);
+  },
+  error(message, ...args) {
+    console.error(`${LOG_PREFIX} ${message}`, ...args);
+  }
+};
+//# sourceMappingURL=logger.js.map

package/lib/commonjs/features/replay/core/privacy/privacyTypes.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolvePrivacy = resolvePrivacy;
+exports.shouldMaskElement = shouldMaskElement;
+/**
+ * Session Replay SDK — Privacy Types (Core)
+ *
+ * Internal privacy processing types used by native and JS layers.
+ */
+
+/** Privacy configuration resolved for a specific screen */
+
+/** Resolve privacy options for a specific screen name */
+function resolvePrivacy(options, screenName) {
+  const skipCapture = options.disableScreenshots || options.ignoredScreens.includes(screenName);
+  return {
+    skipCapture,
+    maskTextInputs: options.maskTextInputs,
+    maskImages: options.maskImages,
+    maskedElementIds: new Set(options.maskedElementIds),
+    customPredicate: options.customMaskPredicate ?? null
+  };
+}
+
+/** Check if a specific element should be masked */
+function shouldMaskElement(privacy, elementId) {
+  if (privacy.maskedElementIds.has(elementId)) return true;
+  if (privacy.customPredicate && privacy.customPredicate(elementId)) return true;
+  return false;
+}
+//# sourceMappingURL=privacyTypes.js.map

package/lib/commonjs/features/replay/core/queue/boundedQueue.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BoundedQueue = void 0;
+/**
+ * Session Replay SDK — Bounded Queue
+ *
+ * Thread-safe bounded queue with backpressure.
+ * Used for frame capture requests, event buffering, and upload batching.
+ */
+
+class BoundedQueue {
+  _items = [];
+  _dropped = 0;
+  constructor(maxSize) {
+    this._maxSize = Math.max(1, maxSize);
+  }
+
+  /** Enqueue an item. Returns false if item was dropped due to capacity. */
+  enqueue(item) {
+    if (this._items.length >= this._maxSize) {
+      this._dropped++;
+      return false;
+    }
+    this._items.push(item);
+    return true;
+  }
+
+  /** Dequeue the oldest item. Returns undefined if empty. */
+  dequeue() {
+    return this._items.shift();
+  }
+
+  /** Dequeue up to `count` items at once */
+  dequeueBatch(count) {
+    const batch = this._items.splice(0, Math.min(count, this._items.length));
+    return batch;
+  }
+
+  /** Peek at the oldest item without removing */
+  peek() {
+    return this._items[0];
+  }
+  get size() {
+    return this._items.length;
+  }
+  get capacity() {
+    return this._maxSize;
+  }
+  get droppedCount() {
+    return this._dropped;
+  }
+  get isEmpty() {
+    return this._items.length === 0;
+  }
+  get isFull() {
+    return this._items.length >= this._maxSize;
+  }
+  clear() {
+    this._items.length = 0;
+  }
+
+  /** Get all items as a snapshot (does not remove) */
+  snapshot() {
+    return [...this._items];
+  }
+}
+exports.BoundedQueue = BoundedQueue;
+//# sourceMappingURL=boundedQueue.js.map

package/lib/commonjs/features/replay/integrations/alert/alertInstrumentation.js

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installAlertInstrumentation = installAlertInstrumentation;
+exports.isAlertInstrumentationInstalled = isAlertInstrumentationInstalled;
+exports.uninstallAlertInstrumentation = uninstallAlertInstrumentation;
+var _reactNative = require("react-native");
+var _logger = require("../../core/logger/logger");
+/**
+ * Session Replay SDK — Native Alert Instrumentation
+ *
+ * Why this exists
+ * ---------------
+ * React Native `Alert.alert` / `Alert.prompt` render a NATIVE dialog:
+ *   - iOS   → a `UIAlertController` in a separate `.alert`-level `UIWindow`.
+ *   - Android → an `AlertDialog` in its own dialog `Window`.
+ *
+ * Neither surface is part of the React view tree, so:
+ *   1. The JS touch responder in `ReplayRoot`/`ScaleBunDebugRoot` never sees the
+ *      OK/Cancel taps (the responder only covers the app's React root view).
+ *   2. The native touch trackers attach to the app/activity window, not the
+ *      alert/dialog window, so they miss those taps too.
+ *
+ * The frame-level visibility of the alert is solved natively (Android already
+ * composites extra windows; iOS now composites all windows in
+ * ScreenshotCaptureManager). This module solves the INTERACTION + LIFECYCLE
+ * half in one cross-platform place by wrapping the `Alert` API:
+ *   - records `alert_shown` when an alert is presented,
+ *   - records `alert_action` (with the pressed button label) at press time,
+ *   - records `alert_dismissed` after the dialog closes,
+ *   - triggers frames so the timeline shows the screen with the alert visible
+ *     and the screen right after it is dismissed.
+ *
+ * Everything routes through the unified `SessionManager` (the same pipeline all
+ * other gestures use). `SessionManager.onUserAction` / `captureManualFrame`
+ * already no-op when recording is OFF, so this is inert outside an active
+ * session. Install is reversible and idempotent.
+ *
+ * OS limitation (documented): exact touch COORDINATES inside the native dialog
+ * are not available to JS or to the app-window touch tracker. We record the
+ * semantic button identity (text + style) instead, which is more accurate for
+ * the timeline than a guessed coordinate would be. Alerts presented purely from
+ * native code (not via RN `Alert`) are out of scope.
+ */
+
+/**
+ * Delay before capturing the "settled" frame for a present/dismiss transition.
+ *
+ * This is NOT arbitrary timing magic: a native alert is presented and dismissed
+ * with an enter/exit animation (UIAlertController ~0.4s, Android Dialog ~0.3s).
+ * Capturing immediately would snapshot a mid-animation / pre-present frame. We
+ * wait one animation's worth so the captured frame reflects the settled UI —
+ * the alert fully on screen, or the screen fully restored after dismissal.
+ */
+const ALERT_SETTLE_MS = 350;
+let installed = false;
+let debugLogs = false;
+let originalAlert = null;
+let originalPrompt = null;
+
+/**
+ * Lazily resolve the unified SessionManager. Lazy require avoids pulling native
+ * module dependencies in at module-load time (matches ScaleBunDebugRoot's pattern)
+ * and keeps this integration decoupled from the session feature.
+ */
+function getSessionManager() {
+  try {
+    const {
+      SessionManager
+    } = require('../../../session/SessionManager');
+    return SessionManager.getExistingInstance?.() ?? null;
+  } catch {
+    return null;
+  }
+}
+function record(subtype, payload) {
+  const enriched = {
+    ...payload,
+    platform: _reactNative.Platform.OS,
+    timestamp: Date.now(),
+    source: 'native-alert'
+  };
+  const sm = getSessionManager();
+  try {
+    // onUserAction records the event AND triggers a composited frame; it is a
+    // no-op when no session is recording.
+    sm?.onUserAction?.(subtype, enriched);
+  } catch {
+    /* no-throw: instrumentation must never break the host app */
+  }
+  if (debugLogs) {
+    try {
+      _logger.logger.debug?.(`[AlertCapture] ${subtype} ${safeJson(enriched)}`);
+    } catch {/* no-throw */}
+  }
+}
+
+/** Capture a frame once the present/dismiss animation has settled. */
+function captureSettledFrame() {
+  setTimeout(() => {
+    const sm = getSessionManager();
+    try {
+      sm?.captureManualFrame?.();
+    } catch {/* no-throw */}
+  }, ALERT_SETTLE_MS);
+}
+
+/** Record an event once the dismiss animation has settled. */
+function recordSettled(subtype, payload) {
+  setTimeout(() => record(subtype, payload), ALERT_SETTLE_MS);
+}
+function buttonLabels(buttons) {
+  return (buttons ?? []).map(b => b?.text ?? '').filter(t => t.length > 0);
+}
+/**
+ * Wrap a single button's `onPress`. Records `alert_button_press` with the full
+ * semantic identity (text, index, style, alert title/message, platform), runs
+ * the app's original handler unchanged, then records `alert_dismissed` once the
+ * native dialog has closed. The original callback is always invoked exactly once
+ * and its exceptions are NOT swallowed.
+ */
+function wrapOnPress(ctx, text, index, style, original) {
+  return value => {
+    record('alert_button_press', {
+      buttonText: text,
+      buttonIndex: index,
+      buttonStyle: style,
+      alertTitle: ctx.title,
+      alertMessage: ctx.message,
+      value
+    });
+    try {
+      original?.(value);
+    } finally {
+      // The button handler dismisses the dialog; capture the settled
+      // post-dismiss screen and mark the dismissal.
+      recordSettled('alert_dismissed', {
+        alertTitle: ctx.title,
+        buttonText: text,
+        buttonIndex: index,
+        reason: 'button'
+      });
+    }
+  };
+}
+function wrapButtons(ctx, buttons) {
+  // RN normalizes a missing button list to a single default "OK". Synthesize
+  // the same so the dismiss is still captured. Button ORDER is preserved.
+  if (!buttons || buttons.length === 0) {
+    return [{
+      text: 'OK',
+      onPress: wrapOnPress(ctx, 'OK', 0, 'default', undefined)
+    }];
+  }
+  return buttons.map((b, i) => ({
+    ...b,
+    onPress: wrapOnPress(ctx, b?.text ?? '', i, b?.style, b?.onPress)
+  }));
+}
+
+/**
+ * Wrap `options.onDismiss` (Android cancelable alerts dismissed via back button
+ * or outside tap — no button press fires). Records `alert_dismissed` and runs
+ * the app's original handler.
+ */
+function wrapOptions(ctx, options) {
+  if (!options || typeof options !== 'object') return options;
+  const originalOnDismiss = options.onDismiss;
+  if (typeof originalOnDismiss !== 'function') return options;
+  return {
+    ...options,
+    onDismiss: () => {
+      recordSettled('alert_dismissed', {
+        alertTitle: ctx.title,
+        reason: 'cancelable'
+      });
+      originalOnDismiss();
+    }
+  };
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return '[unserializable]';
+  }
+}
+
+/**
+ * Patch `Alert.alert` / `Alert.prompt`. Idempotent and reversible.
+ */
+function installAlertInstrumentation(opts = {}) {
+  if (installed) return;
+  debugLogs = opts.debug === true;
+
+  // Keep the exact original reference (no bind) so uninstall restores it
+  // identically. RN's Alert.alert/prompt are static and do not depend on `this`.
+  originalAlert = _reactNative.Alert.alert;
+  _reactNative.Alert.alert = (title, message, buttons, options) => {
+    const ctx = {
+      title,
+      message
+    };
+    try {
+      record('alert_shown', {
+        alertTitle: title,
+        alertMessage: message,
+        buttons: buttonLabels(buttons)
+      });
+      captureSettledFrame();
+    } catch {/* no-throw */}
+    const wrapped = wrapButtons(ctx, buttons);
+    return originalAlert(title, message, wrapped, wrapOptions(ctx, options));
+  };
+  if (typeof _reactNative.Alert.prompt === 'function') {
+    originalPrompt = _reactNative.Alert.prompt;
+    _reactNative.Alert.prompt = (title, message, callbackOrButtons, ...rest) => {
+      const ctx = {
+        title,
+        message
+      };
+      try {
+        record('alert_shown', {
+          alertTitle: title,
+          alertMessage: message,
+          prompt: true
+        });
+        captureSettledFrame();
+      } catch {/* no-throw */}
+      // prompt accepts either a single callback or an array of buttons.
+      // Only the array form carries per-button onPress handlers to wrap;
+      // the callback form is passed through untouched.
+      const handled = Array.isArray(callbackOrButtons) ? wrapButtons(ctx, callbackOrButtons) : callbackOrButtons;
+      return originalPrompt(title, message, handled, ...rest);
+    };
+  }
+  installed = true;
+  if (debugLogs) {
+    try {
+      _logger.logger.debug?.('[AlertCapture] installed');
+    } catch {/* no-throw */}
+  }
+}
+
+/** Restore the original `Alert` API. Safe to call when not installed. */
+function uninstallAlertInstrumentation() {
+  if (!installed) return;
+  if (originalAlert) _reactNative.Alert.alert = originalAlert;
+  if (originalPrompt) _reactNative.Alert.prompt = originalPrompt;
+  originalAlert = null;
+  originalPrompt = null;
+  installed = false;
+}
+function isAlertInstrumentationInstalled() {
+  return installed;
+}
+//# sourceMappingURL=alertInstrumentation.js.map

package/lib/commonjs/features/replay/integrations/logs/consoleIntegration.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installConsoleIntegration = installConsoleIntegration;
+exports.setConsoleEnabled = setConsoleEnabled;
+exports.uninstallConsoleIntegration = uninstallConsoleIntegration;
+var _breadcrumbCollector = require("../../replay/breadcrumbs/breadcrumbCollector");
+var _SessionManager = require("../../../session/SessionManager");
+/**
+ * Session Replay SDK — Console Log Integration
+ *
+ * Patches console.log/warn/error to capture log breadcrumbs.
+ * Can be enabled/disabled at runtime.
+ */
+
+let _installed = false;
+let _enabled = true;
+
+/**
+ * Map a patched console method to the neutral log `level` carried on the
+ * platform-agnostic logs lane. console.info collapses to 'info'; everything else maps
+ * 1:1. Kept here (the JS producer) so the lane/backend never learn console method names.
+ */
+const CONSOLE_LEVEL = {
+  log: 'log',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+  debug: 'debug'
+};
+
+/**
+ * Prefixes that identify a log line as SDK-internal. These still print to the real
+ * console (developers may want to see them in dev), but they must NEVER be routed
+ * into the customer-facing logs lane or replay breadcrumbs — otherwise SDK self-noise
+ * (e.g. one [TapDiag] per tap, or internal [ScaleBun:*]/[perf.*] diagnostics) buries
+ * the customer's own logs in Diagnose → Logs. `[ReplaySdk]` is handled separately and
+ * suppressed entirely (it also trips the RN/Expo error overlay).
+ */
+const SDK_INTERNAL_LOG_PREFIXES = ['[TapDiag]', '[TapAccuracy]', '[ScaleBun', '[perf.'];
+
+/** True when a console line is an SDK-internal diagnostic that must not reach customer surfaces. */
+function isSdkInternalLog(firstArg) {
+  return typeof firstArg === 'string' && SDK_INTERNAL_LOG_PREFIXES.some(prefix => firstArg.startsWith(prefix));
+}
+
+/**
+ * First producer into the logs lane: forward this console call to the backend logs
+ * queue (source='console', platform='js'). Additive to the existing breadcrumb capture
+ * — never throws, no-ops cleanly when no SaaS backend transport is attached. A future
+ * native producer feeds the SAME queue with its own source/platform.
+ */
+function forwardToLogsLane(method, message) {
+  try {
+    const transport = _SessionManager.SessionManager.getExistingInstance()?.getBackendTransport();
+    if (!transport) return;
+    transport.queueLog({
+      level: CONSOLE_LEVEL[method] ?? method,
+      message,
+      source: 'console',
+      platform: 'js',
+      timestamp: new Date().toISOString()
+    });
+  } catch {
+    // Never crash in console interceptor.
+  }
+}
+const _originals = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+
+/**
+ * Install console interceptors.
+ * Safe to call multiple times — only installs once.
+ */
+function installConsoleIntegration() {
+  if (_installed) return;
+  _installed = true;
+  const methods = ['log', 'info', 'warn', 'error', 'debug'];
+  for (const method of methods) {
+    const original = _originals[method];
+    console[method] = (...args) => {
+      // Skip SDK-internal logs before calling original to prevent the
+      // Expo/RN error overlay from triggering on SDK-internal errors.
+      const firstArg = args[0];
+      if (typeof firstArg === 'string' && firstArg.startsWith('[ReplaySdk]')) return;
+
+      // Always call original for non-SDK logs
+      original.apply(console, args);
+
+      // Print SDK-internal diagnostics to the console (dev visibility) but never
+      // forward them to the customer-facing logs lane / breadcrumbs.
+      if (isSdkInternalLog(firstArg)) return;
+      if (_enabled) {
+        try {
+          const message = args.map(a => {
+            if (typeof a === 'string') return a;
+            try {
+              return JSON.stringify(a);
+            } catch {
+              return String(a);
+            }
+          }).join(' ');
+          const truncated = message.slice(0, 1024);
+          _breadcrumbCollector.breadcrumbCollector.addConsoleBreadcrumb(method, truncated).catch(() => {});
+          // Additive: same tap also feeds the platform-agnostic logs lane.
+          forwardToLogsLane(method, truncated);
+        } catch {
+          // Never crash in console interceptor
+        }
+      }
+    };
+  }
+}
+
+/**
+ * Remove console interceptors and restore originals.
+ */
+function uninstallConsoleIntegration() {
+  if (!_installed) return;
+  _installed = false;
+  console.log = _originals.log;
+  console.info = _originals.info;
+  console.warn = _originals.warn;
+  console.error = _originals.error;
+  console.debug = _originals.debug;
+}
+
+/** Enable/disable console breadcrumb capture at runtime */
+function setConsoleEnabled(enabled) {
+  _enabled = enabled;
+}
+//# sourceMappingURL=consoleIntegration.js.map

package/lib/commonjs/features/replay/integrations/network/networkAdapter.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reportNetworkRequest = reportNetworkRequest;
+exports.setNetworkEnabled = setNetworkEnabled;
+var _breadcrumbCollector = require("../../replay/breadcrumbs/breadcrumbCollector");
+var _logger = require("../../core/logger/logger");
+/**
+ * Session Replay SDK — Network Adapter
+ *
+ * Provides network breadcrumb integration via adapter pattern.
+ * Does NOT monkey-patch XMLHttpRequest or fetch.
+ * Instead, provides a report function that users or other interceptors can call.
+ *
+ * Usage:
+ *   import { reportNetworkRequest } from '@scalebun/replay-sdk';
+ *
+ *   // After your network request completes:
+ *   reportNetworkRequest({
+ *       method: 'GET',
+ *       url: 'https://api.example.com/data',
+ *       statusCode: 200,
+ *       durationMs: 150,
+ *       requestSizeBytes: 0,
+ *       responseSizeBytes: 1024,
+ *       error: false,
+ *       startTimestamp: Date.now() - 150,
+ *   });
+ */
+
+let _enabled = true;
+let _urlFilter = null;
+
+/**
+ * Report a completed network request as a replay breadcrumb.
+ * Safe to call from anywhere — no-throw.
+ */
+function reportNetworkRequest(request) {
+  if (!_enabled) return;
+  try {
+    // Apply URL filter
+    if (_urlFilter && !_urlFilter(request.url)) return;
+
+    // Sanitize URL (strip query params with sensitive data patterns)
+    const sanitized = {
+      ...request,
+      url: sanitizeUrl(request.url)
+    };
+    _breadcrumbCollector.breadcrumbCollector.addNetworkBreadcrumb(sanitized).catch(() => {});
+  } catch (err) {
+    __DEV__ && _logger.logger.debug(`Network breadcrumb failed: ${err?.message}`);
+  }
+}
+
+/** Enable/disable network breadcrumb collection */
+function setNetworkEnabled(enabled) {
+  _enabled = enabled;
+}
+
+/** Basic URL sanitization: mask tokens/keys in query params */
+function sanitizeUrl(url) {
+  try {
+    const u = new URL(url);
+    const sensitiveKeys = ['token', 'key', 'apikey', 'api_key', 'secret', 'password', 'auth'];
+    for (const key of u.searchParams.keys()) {
+      if (sensitiveKeys.some(s => key.toLowerCase().includes(s))) {
+        u.searchParams.set(key, '***');
+      }
+    }
+    return u.toString();
+  } catch {
+    return url.slice(0, 2048);
+  }
+}
+//# sourceMappingURL=networkAdapter.js.map