@scalebun-release/react-native 2.5.0

package/lib/commonjs/features/replay/public/api.js

@@ -0,0 +1,336 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReplaySdk = void 0;
+var _validator = require("../core/config/validator");
+var _sessionOrchestrator = require("../replay/session/sessionOrchestrator");
+var _breadcrumbCollector = require("../replay/breadcrumbs/breadcrumbCollector");
+var _bridgeAdapter = require("../bridge/adapters/bridgeAdapter");
+var _batchManager = require("../pipeline/batching/batchManager");
+var _consoleIntegration = require("../integrations/logs/consoleIntegration");
+var _networkAdapter = require("../integrations/network/networkAdapter");
+var _logger = require("../core/logger/logger");
+var _safeCall = require("../core/errors/safeCall");
+var _environmentDetector = require("../core/env/environmentDetector");
+var _DesktopReplayTransport = require("../transport/DesktopReplayTransport");
+var _BackendReplayTransport = require("../transport/BackendReplayTransport");
+var _CompositeReplayTransport = require("../transport/CompositeReplayTransport");
+/**
+ * Session Replay SDK — Public API Facade
+ *
+ * This is the main entry point for SDK consumers.
+ * All methods are no-throw — errors are logged and silently handled.
+ *
+ * Usage (standalone):
+ *   import { ReplaySdk } from '@scalebun/replay-sdk';
+ *   ReplaySdk.init({ apiKey: '...', endpoint: '...' });
+ *
+ * Usage (via scalebun-sdk):
+ *   // Called internally by bootstrap.ts:
+ *   ReplaySdk.init(config, { debugTransport: transport });
+ */
+
+// Transport layer
+
+// ─── State ──────────────────────────────────────────────────────────────────
+
+let _initialized = false;
+let _config = null;
+let _transport = null;
+
+// ─── Init Options ───────────────────────────────────────────────────────────
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+const ReplaySdk = exports.ReplaySdk = {
+  // ─── Initialization ─────────────────────────────────────────────────
+
+  /**
+   * Initialize the Session Replay SDK.
+   *
+   * Must be called before any other SDK method.
+   * Safe to call multiple times — re-initializes with new config.
+   *
+   * @param partialConfig - SDK configuration (merged with defaults)
+   * @param opts - Optional init options (e.g. external debugTransport)
+   */
+  async init(partialConfig, opts) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.init', async () => {
+      const {
+        config,
+        warnings
+      } = (0, _validator.validateConfig)(partialConfig);
+      _config = config;
+
+      // Apply verbose logging
+      (0, _logger.setVerbose)(config.verboseLogging);
+
+      // Log validation warnings
+      for (const w of warnings) {
+        _logger.logger.warn(`Config: ${w}`);
+      }
+      if (!config.enabled) {
+        __DEV__ && _logger.logger.info('SDK disabled via config');
+        return;
+      }
+
+      // ── Build transport layer ───────────────────────────────────
+      const transports = [];
+
+      // Desktop transport (always, if debugTransport provided)
+      if (opts?.debugTransport) {
+        transports.push(new _DesktopReplayTransport.DesktopReplayTransport(opts.debugTransport));
+        __DEV__ && _logger.logger.info('Desktop replay transport enabled');
+      }
+
+      // Backend transport (flag-controlled + env check)
+      if (config.sendToBackend && config.endpoint && config.apiKey) {
+        const shouldSkip = (0, _environmentDetector.isDevOrEmulator)() && !config.forceBackendInDev;
+        if (!shouldSkip) {
+          transports.push(new _BackendReplayTransport.BackendReplayTransport({
+            endpoint: config.endpoint,
+            apiKey: config.apiKey,
+            batchSize: config.uploadBatchSize
+          }));
+          __DEV__ && _logger.logger.info('Backend replay transport enabled');
+        } else {
+          __DEV__ && _logger.logger.info('Backend replay transport skipped (dev/emulator mode)');
+        }
+      }
+
+      // Build composite transport
+      if (transports.length > 0) {
+        _transport = new _CompositeReplayTransport.CompositeReplayTransport(transports);
+      }
+
+      // ── Install integrations ────────────────────────────────────
+      if (config.sdkLogsEnabled) {
+        (0, _consoleIntegration.installConsoleIntegration)();
+      }
+      (0, _networkAdapter.setNetworkEnabled)(config.networkLogsEnabled);
+
+      // Configure batch manager
+      _batchManager.batchManager.configure(config.uploadBatchSize);
+
+      // Initialize native module + session orchestrator
+      // Native module may not be available (e.g. no native build yet).
+      // That's fine — transport + JS integrations still work.
+      try {
+        const success = await _sessionOrchestrator.sessionOrchestrator.initialize(config);
+        if (success) {
+          __DEV__ && _logger.logger.info('SDK initialized with native module');
+        } else {
+          _logger.logger.warn('Native module not available — transport-only mode');
+        }
+      } catch (nativeErr) {
+        _logger.logger.warn('Native module init failed (non-fatal):', nativeErr?.message);
+      }
+      _initialized = true;
+      __DEV__ && _logger.logger.info('SDK initialized successfully');
+    }, undefined);
+  },
+  // ─── Transport Access ───────────────────────────────────────────────
+
+  /** @internal Get the active transport (for integration with SessionManager) */
+  _getTransport() {
+    return _transport;
+  },
+  // ─── Session Lifecycle ──────────────────────────────────────────────
+
+  /** Start a new replay session */
+  async start() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.start', async () => {
+      if (!_initialized) {
+        _logger.logger.warn('SDK not initialized');
+        return;
+      }
+      await _sessionOrchestrator.sessionOrchestrator.start();
+    }, undefined);
+  },
+  /** Stop the current replay session and finalize */
+  async stop() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.stop', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.stop();
+    }, undefined);
+  },
+  /** Pause the current session (e.g. when app backgrounds) */
+  async pause() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.pause', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.pause();
+    }, undefined);
+  },
+  /** Resume a paused session */
+  async resume() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.resume', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.resume();
+    }, undefined);
+  },
+  // ─── Capture ────────────────────────────────────────────────────────
+
+  /** Manually trigger a frame capture */
+  async captureManualFrame() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.captureManualFrame', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.captureManualFrame();
+    }, undefined);
+  },
+  // ─── Configuration ──────────────────────────────────────────────────
+
+  /** Enable or disable the SDK at runtime */
+  async setEnabled(enabled) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setEnabled', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.setEnabled(enabled);
+    }, undefined);
+  },
+  /** Change the capture mode at runtime */
+  async setCapturingMode(mode) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setCapturingMode', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.setCapturingMode(mode);
+    }, undefined);
+  },
+  /** Change screenshot quality at runtime */
+  async setScreenshotQuality(quality) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setScreenshotQuality', async () => {
+      if (!_initialized) return;
+      await _bridgeAdapter.bridgeAdapter.setScreenshotQuality(quality);
+    }, undefined);
+  },
+  /** Change capture interval (frequency mode) */
+  async setScreenshotCaptureInterval(intervalMs) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setScreenshotCaptureInterval', async () => {
+      if (!_initialized) return;
+      await _bridgeAdapter.bridgeAdapter.setScreenshotCaptureInterval(intervalMs);
+    }, undefined);
+  },
+  /** Enable/disable user step tracking */
+  async setUserStepsEnabled(enabled) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setUserStepsEnabled', async () => {
+      if (!_initialized) return;
+      await _bridgeAdapter.bridgeAdapter.setEnabled(enabled);
+    }, undefined);
+  },
+  /** Enable/disable network log capture */
+  setNetworkLogsEnabled(enabled) {
+    (0, _safeCall.safeCall)('ReplaySdk.setNetworkLogsEnabled', () => {
+      (0, _networkAdapter.setNetworkEnabled)(enabled);
+    }, undefined);
+  },
+  /** Enable/disable SDK log capture */
+  setSdkLogsEnabled(enabled) {
+    (0, _safeCall.safeCall)('ReplaySdk.setSdkLogsEnabled', () => {
+      (0, _consoleIntegration.setConsoleEnabled)(enabled);
+    }, undefined);
+  },
+  // ─── Screen Tracking ────────────────────────────────────────────────
+
+  /** Set the current screen name for replay context */
+  async setCurrentScreen(screenName) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setCurrentScreen', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.setCurrentScreen(screenName);
+    }, undefined);
+  },
+  // ─── User Identity ──────────────────────────────────────────────────
+
+  /** Set user identity for the current session */
+  async setUser(user) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setUser', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.setUser(user);
+    }, undefined);
+  },
+  /** Clear user identity */
+  async clearUser() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.clearUser', async () => {
+      if (!_initialized) return;
+      await _sessionOrchestrator.sessionOrchestrator.clearUser();
+    }, undefined);
+  },
+  // ─── Privacy ────────────────────────────────────────────────────────
+
+  /** Update privacy options at runtime */
+  async setPrivacyOptions(options) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.setPrivacyOptions', async () => {
+      if (!_initialized || !_config) return;
+      _config.privacy = {
+        ..._config.privacy,
+        ...options
+      };
+      await _bridgeAdapter.bridgeAdapter.setPrivacyOptions(_config.privacy);
+    }, undefined);
+  },
+  // ─── Breadcrumbs ────────────────────────────────────────────────────
+
+  /** Add a custom breadcrumb to the session timeline */
+  async addBreadcrumb(breadcrumb) {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.addBreadcrumb', async () => {
+      await _breadcrumbCollector.breadcrumbCollector.addBreadcrumb(breadcrumb);
+    }, undefined);
+  },
+  // ─── Sync / Upload ──────────────────────────────────────────────────
+
+  /** Set a callback invoked before each upload batch. Return false to cancel. */
+  setSyncCallback(callback) {
+    (0, _safeCall.safeCall)('ReplaySdk.setSyncCallback', () => {
+      _sessionOrchestrator.sessionOrchestrator.setSyncCallback(callback);
+    }, undefined);
+  },
+  /** Force-flush pending data for upload */
+  async flush() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.flush', async () => {
+      if (!_initialized) return;
+      await _bridgeAdapter.bridgeAdapter.flushUpload();
+    }, undefined);
+  },
+  // ─── Query ──────────────────────────────────────────────────────────
+
+  /** Get a link to the current session replay (if available) */
+  async getSessionReplayLink() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.getSessionReplayLink', async () => {
+      if (!_initialized) return null;
+      const result = await _bridgeAdapter.bridgeAdapter.getSessionReplayLink();
+      if (!result) return null;
+      return {
+        url: result.url,
+        sessionId: result.sessionId,
+        uploaded: result.uploaded
+      };
+    }, null);
+  },
+  /** Get whether the SDK is currently recording */
+  get isRecording() {
+    return (0, _safeCall.safeCall)('ReplaySdk.isRecording', () => _sessionOrchestrator.sessionOrchestrator.isRecording, false);
+  },
+  /** Get the current session ID */
+  get sessionId() {
+    return (0, _safeCall.safeCall)('ReplaySdk.sessionId', () => _sessionOrchestrator.sessionOrchestrator.sessionId, null);
+  },
+  // ─── Cleanup ────────────────────────────────────────────────────────
+
+  /** Destroy the SDK and release all resources */
+  async destroy() {
+    return (0, _safeCall.safeCallAsync)('ReplaySdk.destroy', async () => {
+      (0, _consoleIntegration.uninstallConsoleIntegration)();
+      _batchManager.batchManager.reset();
+      _breadcrumbCollector.breadcrumbCollector.clear();
+      await _sessionOrchestrator.sessionOrchestrator.destroy();
+
+      // Destroy transport
+      if (_transport) {
+        _transport.destroy();
+        _transport = null;
+      }
+      _initialized = false;
+      _config = null;
+      __DEV__ && _logger.logger.info('SDK destroyed');
+    }, undefined);
+  }
+};
+//# sourceMappingURL=api.js.map

package/lib/commonjs/features/replay/public/enums.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimelineEventType = exports.SessionState = exports.ScreenshotQuality = exports.InteractionType = exports.CapturingMode = exports.CaptureTrigger = void 0;
+/**
+ * Session Replay SDK — Public Enums
+ *
+ * All user-facing enumerations for the replay SDK.
+ * These are the canonical values used across JS, Android, and iOS.
+ */
+/** How frames are captured */
+let CapturingMode = exports.CapturingMode = /*#__PURE__*/function (CapturingMode) {
+  /** Capture only on screen/route navigation changes */
+  CapturingMode["Navigation"] = "navigation";
+  /** Capture on navigation + user interactions (tap, scroll, input) with throttling */
+  CapturingMode["Interactions"] = "interactions";
+  /** Capture at a fixed time interval + on navigation changes */
+  CapturingMode["Frequency"] = "frequency";
+  return CapturingMode;
+}({});
+/** Screenshot compression quality */
+let ScreenshotQuality = exports.ScreenshotQuality = /*#__PURE__*/function (ScreenshotQuality) {
+  ScreenshotQuality["High"] = "high";
+  ScreenshotQuality["Normal"] = "normal";
+  ScreenshotQuality["Low"] = "low";
+  ScreenshotQuality["Grayscale"] = "grayscale";
+  return ScreenshotQuality;
+}({});
+/** Session lifecycle state */
+let SessionState = exports.SessionState = /*#__PURE__*/function (SessionState) {
+  SessionState["Idle"] = "idle";
+  SessionState["Recording"] = "recording";
+  SessionState["Paused"] = "paused";
+  SessionState["Finalizing"] = "finalizing";
+  SessionState["Uploading"] = "uploading";
+  SessionState["Completed"] = "completed";
+  SessionState["Failed"] = "failed";
+  return SessionState;
+}({});
+/** Timeline event categories */
+let TimelineEventType = exports.TimelineEventType = /*#__PURE__*/function (TimelineEventType) {
+  TimelineEventType["SessionStart"] = "session_start";
+  TimelineEventType["SessionEnd"] = "session_end";
+  TimelineEventType["ScreenViewed"] = "screen_viewed";
+  TimelineEventType["UserTap"] = "user_tap";
+  TimelineEventType["UserLongPress"] = "user_long_press";
+  TimelineEventType["UserScroll"] = "user_scroll";
+  TimelineEventType["UserSwipe"] = "user_swipe";
+  TimelineEventType["TextInputChange"] = "text_input_change";
+  TimelineEventType["KeyboardShown"] = "keyboard_shown";
+  TimelineEventType["KeyboardHidden"] = "keyboard_hidden";
+  TimelineEventType["AppForeground"] = "app_foreground";
+  TimelineEventType["AppBackground"] = "app_background";
+  TimelineEventType["ConsoleLog"] = "console_log";
+  TimelineEventType["NetworkRequest"] = "network_request";
+  TimelineEventType["CustomBreadcrumb"] = "custom_breadcrumb";
+  TimelineEventType["ErrorCaptured"] = "error_captured";
+  TimelineEventType["CrashCaptured"] = "crash_captured";
+  TimelineEventType["ManualCapture"] = "manual_capture";
+  TimelineEventType["FrameCaptured"] = "frame_captured";
+  return TimelineEventType;
+}({});
+/** Interaction tracking granularity */
+let InteractionType = exports.InteractionType = /*#__PURE__*/function (InteractionType) {
+  InteractionType["Tap"] = "tap";
+  InteractionType["LongPress"] = "long_press";
+  InteractionType["Scroll"] = "scroll";
+  InteractionType["Swipe"] = "swipe";
+  InteractionType["TextInput"] = "text_input";
+  InteractionType["Custom"] = "custom";
+  return InteractionType;
+}({});
+/** Frame capture trigger source */
+let CaptureTrigger = exports.CaptureTrigger = /*#__PURE__*/function (CaptureTrigger) {
+  CaptureTrigger["Navigation"] = "navigation";
+  CaptureTrigger["Interaction"] = "interaction";
+  CaptureTrigger["Timer"] = "timer";
+  CaptureTrigger["Manual"] = "manual";
+  CaptureTrigger["Lifecycle"] = "lifecycle";
+  CaptureTrigger["Error"] = "error";
+  return CaptureTrigger;
+}({});
+//# sourceMappingURL=enums.js.map

package/lib/commonjs/features/replay/public/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/lib/commonjs/features/replay/replay/breadcrumbs/breadcrumbCollector.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.breadcrumbCollector = void 0;
+var _bridgeAdapter = require("../../bridge/adapters/bridgeAdapter");
+var _boundedQueue = require("../../core/queue/boundedQueue");
+var _defaults = require("../../core/config/defaults");
+/**
+ * Session Replay SDK — Breadcrumb Collector
+ *
+ * Collects and buffers breadcrumbs from various sources
+ * (user, network, console, custom) and forwards them to native.
+ */
+
+class BreadcrumbCollector {
+  _queue = new _boundedQueue.BoundedQueue(1000);
+  _enabled = true;
+  setEnabled(enabled) {
+    this._enabled = enabled;
+  }
+
+  /** Add a custom breadcrumb */
+  async addBreadcrumb(breadcrumb) {
+    if (!this._enabled) return;
+
+    // Validate and truncate
+    const bc = {
+      category: breadcrumb.category || 'custom',
+      message: (breadcrumb.message || '').slice(0, _defaults.SESSION_LIMITS.MAX_BREADCRUMB_MESSAGE_LENGTH),
+      level: breadcrumb.level || 'info',
+      timestamp: breadcrumb.timestamp ?? Date.now(),
+      data: breadcrumb.data ? truncateData(breadcrumb.data) : undefined
+    };
+    this._queue.enqueue(bc);
+    await _bridgeAdapter.bridgeAdapter.addBreadcrumb(bc);
+  }
+
+  /** Add a network request breadcrumb */
+  async addNetworkBreadcrumb(request) {
+    if (!this._enabled) return;
+    const bc = {
+      category: 'network',
+      message: `${request.method} ${request.url} → ${request.statusCode}`,
+      level: request.error ? 'error' : 'info',
+      timestamp: request.startTimestamp,
+      data: {
+        method: request.method,
+        url: request.url,
+        statusCode: request.statusCode,
+        durationMs: request.durationMs,
+        requestSizeBytes: request.requestSizeBytes,
+        responseSizeBytes: request.responseSizeBytes,
+        error: request.error
+      }
+    };
+    this._queue.enqueue(bc);
+    await _bridgeAdapter.bridgeAdapter.addNetworkBreadcrumb(request);
+  }
+
+  /** Add a console log breadcrumb */
+  async addConsoleBreadcrumb(level, message, args) {
+    if (!this._enabled) return;
+    const bc = {
+      category: 'console',
+      message: message.slice(0, _defaults.SESSION_LIMITS.MAX_BREADCRUMB_MESSAGE_LENGTH),
+      level: mapConsoleLevel(level),
+      timestamp: Date.now(),
+      data: args ? {
+        args: JSON.stringify(args).slice(0, _defaults.SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE)
+      } : undefined
+    };
+    this._queue.enqueue(bc);
+    await _bridgeAdapter.bridgeAdapter.addBreadcrumb(bc);
+  }
+
+  /** Get all collected breadcrumbs */
+  getAll() {
+    return this._queue.snapshot();
+  }
+
+  /** Clear all breadcrumbs */
+  clear() {
+    this._queue.clear();
+  }
+  get count() {
+    return this._queue.size;
+  }
+}
+function mapConsoleLevel(level) {
+  switch (level) {
+    case 'debug':
+      return 'debug';
+    case 'info':
+    case 'log':
+      return 'info';
+    case 'warn':
+      return 'warning';
+    case 'error':
+      return 'error';
+    default:
+      return 'info';
+  }
+}
+function truncateData(data) {
+  const json = JSON.stringify(data);
+  if (json.length <= _defaults.SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE) return data;
+  // Truncate — return a subset
+  try {
+    return JSON.parse(json.slice(0, _defaults.SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE));
+  } catch {
+    return {
+      _truncated: true
+    };
+  }
+}
+const breadcrumbCollector = exports.breadcrumbCollector = new BreadcrumbCollector();
+//# sourceMappingURL=breadcrumbCollector.js.map

package/lib/commonjs/features/replay/replay/frames/frameModels.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFrameMetadata = createFrameMetadata;
+exports.estimateFrameMemoryBytes = estimateFrameMemoryBytes;
+var _sessionId = require("../../core/ids/sessionId");
+var clock = _interopRequireWildcard(require("../../core/clock/clock"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Session Replay SDK — Frame Models
+ *
+ * Internal frame representation and helpers.
+ */
+
+/** Create a new frame metadata entry */
+function createFrameMetadata(params) {
+  return {
+    frameId: (0, _sessionId.generateFrameId)(),
+    sessionId: params.sessionId,
+    timestamp: clock.now(),
+    sequenceNumber: params.sequenceNumber,
+    screenName: params.screenName,
+    trigger: params.trigger,
+    format: params.format,
+    sizeBytes: params.sizeBytes,
+    width: params.width,
+    height: params.height,
+    quality: params.quality,
+    masked: params.masked
+  };
+}
+
+/** Estimate decoded frame size in memory (for backpressure) */
+function estimateFrameMemoryBytes(width, height) {
+  // 4 bytes per pixel (RGBA)
+  return width * height * 4;
+}
+//# sourceMappingURL=frameModels.js.map