@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,85 @@
+/**
+ * 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 */
+export let 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 */
+export let ScreenshotQuality = /*#__PURE__*/function (ScreenshotQuality) {
+  ScreenshotQuality["High"] = "high";
+  ScreenshotQuality["Normal"] = "normal";
+  ScreenshotQuality["Low"] = "low";
+  ScreenshotQuality["Grayscale"] = "grayscale";
+  return ScreenshotQuality;
+}({});
+
+/** Session lifecycle state */
+export let 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 */
+export let 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 */
+export let 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 */
+export let 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/module/features/replay/public/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,113 @@
+/**
+ * Session Replay SDK — Breadcrumb Collector
+ *
+ * Collects and buffers breadcrumbs from various sources
+ * (user, network, console, custom) and forwards them to native.
+ */
+
+import { bridgeAdapter } from '../../bridge/adapters/bridgeAdapter';
+import { BoundedQueue } from '../../core/queue/boundedQueue';
+import { SESSION_LIMITS } from '../../core/config/defaults';
+class BreadcrumbCollector {
+  _queue = new 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, 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.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.addNetworkBreadcrumb(request);
+  }
+
+  /** Add a console log breadcrumb */
+  async addConsoleBreadcrumb(level, message, args) {
+    if (!this._enabled) return;
+    const bc = {
+      category: 'console',
+      message: message.slice(0, SESSION_LIMITS.MAX_BREADCRUMB_MESSAGE_LENGTH),
+      level: mapConsoleLevel(level),
+      timestamp: Date.now(),
+      data: args ? {
+        args: JSON.stringify(args).slice(0, SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE)
+      } : undefined
+    };
+    this._queue.enqueue(bc);
+    await 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 <= SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE) return data;
+  // Truncate — return a subset
+  try {
+    return JSON.parse(json.slice(0, SESSION_LIMITS.MAX_BREADCRUMB_DATA_SIZE));
+  } catch {
+    return {
+      _truncated: true
+    };
+  }
+}
+export const breadcrumbCollector = new BreadcrumbCollector();
+//# sourceMappingURL=breadcrumbCollector.js.map

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

@@ -0,0 +1,33 @@
+/**
+ * Session Replay SDK — Frame Models
+ *
+ * Internal frame representation and helpers.
+ */
+
+import { generateFrameId } from '../../core/ids/sessionId';
+import * as clock from '../../core/clock/clock';
+
+/** Create a new frame metadata entry */
+export function createFrameMetadata(params) {
+  return {
+    frameId: 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) */
+export function estimateFrameMemoryBytes(width, height) {
+  // 4 bytes per pixel (RGBA)
+  return width * height * 4;
+}
+//# sourceMappingURL=frameModels.js.map

package/lib/module/features/replay/replay/session/sessionOrchestrator.js

@@ -0,0 +1,272 @@
+/**
+ * Session Replay SDK — Session Orchestrator
+ *
+ * JS-side session lifecycle coordination.
+ * Manages state transitions, connects integrations to native module,
+ * and handles session timers/limits.
+ *
+ * This is the main coordinator — it does NOT own capture logic
+ * (that's native). It manages JS-side state, event subscriptions,
+ * and integration wiring.
+ */
+
+import { AppState } from 'react-native';
+import { SessionState, CapturingMode } from '../../public/enums';
+import { bridgeAdapter } from '../../bridge/adapters/bridgeAdapter';
+import { replayEventEmitter } from '../../bridge/eventEmitter';
+import { AutoScreenDetector } from '../../../navigation/AutoScreenDetector';
+import { logger } from '../../core/logger/logger';
+import { generateSessionId } from '../../core/ids/sessionId';
+import * as clock from '../../core/clock/clock';
+import { fireAndForget } from '../../core/errors/safeCall';
+class SessionOrchestrator {
+  _config = null;
+  _state = SessionState.Idle;
+  _sessionId = null;
+  _user = null;
+  _syncCallback = null;
+  _currentScreen = 'unknown';
+  _durationTimer = null;
+  _frequencyTimer = null;
+  _appStateSubscription = null;
+  _initialized = false;
+  _startedAt = 0;
+
+  // ─── Initialization ─────────────────────────────────────────────────
+
+  async initialize(config) {
+    if (this._initialized) {
+      logger.warn('SessionOrchestrator already initialized');
+      return true;
+    }
+    this._config = config;
+
+    // Initialize native module (non-fatal if unavailable)
+    try {
+      const success = await bridgeAdapter.initialize(config);
+      if (!success) {
+        __DEV__ && logger.info('Native replay module not available — running in transport-only mode');
+      }
+    } catch (nativeErr) {
+      __DEV__ && logger.info('Native replay module not available:', nativeErr?.message);
+    }
+
+    // Listen to native events (no-ops if native not available)
+    try {
+      this._setupNativeEventListeners();
+    } catch {/* ignore */}
+
+    // Listen to app state changes
+    this._appStateSubscription = AppState.addEventListener('change', this._onAppStateChange);
+    this._initialized = true;
+    __DEV__ && logger.info('SessionOrchestrator initialized');
+
+    // Auto-start if configured
+    if (config.autoStart && config.enabled) {
+      try {
+        await this.start();
+      } catch {/* ignore if native unavailable */}
+    }
+    return true;
+  }
+
+  // ─── Session Lifecycle ──────────────────────────────────────────────
+
+  async start() {
+    if (!this._initialized || !this._config?.enabled) return;
+    if (this._state === SessionState.Recording) return;
+    this._sessionId = generateSessionId();
+    this._startedAt = clock.now();
+    clock.markSessionStart();
+
+    // Try native start — non-fatal if unavailable
+    await bridgeAdapter.startSession();
+    this._state = SessionState.Recording;
+    this._startDurationTimer();
+    this._startFrequencyTimerIfNeeded();
+    __DEV__ && logger.info(`Session started: ${this._sessionId}`);
+  }
+  async stop() {
+    if (this._state === SessionState.Idle) return;
+    this._state = SessionState.Finalizing;
+    this._stopTimers();
+    await bridgeAdapter.stopSession();
+    this._state = SessionState.Idle;
+    clock.resetClock();
+    __DEV__ && logger.info(`Session stopped: ${this._sessionId}`);
+    this._sessionId = null;
+    this._startedAt = 0;
+  }
+  async pause() {
+    if (this._state !== SessionState.Recording) return;
+    this._state = SessionState.Paused;
+    this._stopTimers();
+    await bridgeAdapter.pauseSession();
+    __DEV__ && logger.debug('Session paused');
+  }
+  async resume() {
+    if (this._state !== SessionState.Paused) return;
+    this._state = SessionState.Recording;
+    this._startDurationTimer();
+    this._startFrequencyTimerIfNeeded();
+    await bridgeAdapter.resumeSession();
+    __DEV__ && logger.debug('Session resumed');
+  }
+
+  // ─── Capture ────────────────────────────────────────────────────────
+
+  async captureManualFrame() {
+    if (this._state !== SessionState.Recording) return;
+    await bridgeAdapter.captureManualFrame();
+  }
+
+  // ─── Screen Tracking ────────────────────────────────────────────────
+
+  async setCurrentScreen(screenName) {
+    this._currentScreen = screenName;
+    if (this._state === SessionState.Recording) {
+      await bridgeAdapter.setCurrentScreen(screenName);
+    }
+  }
+
+  // ─── User ───────────────────────────────────────────────────────────
+
+  async setUser(user) {
+    this._user = user;
+    await bridgeAdapter.setUser(user);
+  }
+  async clearUser() {
+    this._user = null;
+    await bridgeAdapter.clearUser();
+  }
+
+  // ─── Sync Callback ─────────────────────────────────────────────────
+
+  setSyncCallback(callback) {
+    this._syncCallback = callback;
+  }
+
+  // ─── Configuration Updates ──────────────────────────────────────────
+
+  async setEnabled(enabled) {
+    if (this._config) this._config.enabled = enabled;
+    await bridgeAdapter.setEnabled(enabled);
+    if (!enabled && this._state === SessionState.Recording) {
+      await this.stop();
+    }
+  }
+  async setCapturingMode(mode) {
+    if (this._config) this._config.captureMode = mode;
+    await bridgeAdapter.setCapturingMode(mode);
+    // Restart frequency timer if mode changed
+    this._stopFrequencyTimer();
+    this._startFrequencyTimerIfNeeded();
+  }
+
+  // ─── Internal: Timers ───────────────────────────────────────────────
+
+  _startDurationTimer() {
+    const maxDuration = this._config?.maxSessionDurationMs ?? 300_000;
+    this._durationTimer = setTimeout(() => {
+      logger.warn(`Session max duration reached (${maxDuration}ms)`);
+      fireAndForget('auto-stop', () => this.stop());
+    }, maxDuration);
+  }
+  _startFrequencyTimerIfNeeded() {
+    if (this._config?.captureMode !== CapturingMode.Frequency) return;
+    const interval = this._config.screenshotCaptureIntervalMs;
+    this._frequencyTimer = setInterval(() => {
+      if (this._state === SessionState.Recording) {
+        fireAndForget('frequency-capture', async () => {
+          await bridgeAdapter.captureFrame('timer');
+        });
+      }
+    }, interval);
+  }
+  _stopTimers() {
+    if (this._durationTimer) {
+      clearTimeout(this._durationTimer);
+      this._durationTimer = null;
+    }
+    this._stopFrequencyTimer();
+  }
+  _stopFrequencyTimer() {
+    if (this._frequencyTimer) {
+      clearInterval(this._frequencyTimer);
+      this._frequencyTimer = null;
+    }
+  }
+
+  // ─── Internal: App State ────────────────────────────────────────────
+
+  _onAppStateChange = nextState => {
+    if (nextState === 'background' && this._state === SessionState.Recording) {
+      fireAndForget('background-pause', () => this.pause());
+    } else if (nextState === 'active' && this._state === SessionState.Paused) {
+      fireAndForget('foreground-resume', () => this.resume());
+    }
+  };
+
+  // ─── Internal: Native Event Listeners ───────────────────────────────
+
+  _setupNativeEventListeners() {
+    replayEventEmitter.onSessionStateChanged(event => {
+      __DEV__ && logger.debug(`Native state: ${event.previousState} → ${event.newState}`);
+    });
+    replayEventEmitter.onSessionLimitReached(event => {
+      logger.warn(`Session limit reached: ${event.limitType} (${event.currentValue}/${event.maxValue})`);
+      if (event.limitType === 'duration' || event.limitType === 'frames') {
+        fireAndForget('limit-stop', () => this.stop());
+      }
+    });
+    replayEventEmitter.onError(event => {
+      logger.error(`Native error [${event.code}]: ${event.message}`);
+      if (event.fatal) {
+        fireAndForget('fatal-stop', () => this.stop());
+      }
+    });
+    replayEventEmitter.onScreenChanged(event => {
+      const name = event?.screenName;
+      if (!name || name === 'unknown') return;
+      // Update replay orchestrator's local screen state
+      this._currentScreen = name;
+      // Feed into AutoScreenDetector so SessionManager emits SCREEN_VIEW → backend
+      try {
+        AutoScreenDetector.getInstance().setNativeScreen(name);
+      } catch {/* no-throw */}
+    });
+  }
+
+  // ─── Query ──────────────────────────────────────────────────────────
+
+  get state() {
+    return this._state;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get currentScreen() {
+    return this._currentScreen;
+  }
+  get isRecording() {
+    return this._state === SessionState.Recording;
+  }
+
+  // ─── Destroy ────────────────────────────────────────────────────────
+
+  async destroy() {
+    this._stopTimers();
+    this._appStateSubscription?.remove();
+    replayEventEmitter.destroy();
+    await bridgeAdapter.destroy();
+    this._initialized = false;
+    this._state = SessionState.Idle;
+    this._sessionId = null;
+    this._config = null;
+    __DEV__ && logger.info('SessionOrchestrator destroyed');
+  }
+}
+
+/** Singleton orchestrator */
+export const sessionOrchestrator = new SessionOrchestrator();
+//# sourceMappingURL=sessionOrchestrator.js.map

package/lib/module/features/replay/replay/timeline/timelineModels.js

@@ -0,0 +1,108 @@
+/**
+ * Session Replay SDK — Timeline Models
+ *
+ * Internal timeline event representation and factory.
+ */
+
+import { TimelineEventType } from '../../public/enums';
+import { generateEventId } from '../../core/ids/sessionId';
+import * as clock from '../../core/clock/clock';
+
+/** Create a timeline event */
+export function createTimelineEvent(params) {
+  return {
+    eventId: generateEventId(),
+    sessionId: params.sessionId,
+    type: params.type,
+    timestamp: clock.now(),
+    screenName: params.screenName,
+    label: params.label,
+    frameId: params.frameId,
+    data: params.data
+  };
+}
+
+/** Create a screen viewed event */
+export function screenViewedEvent(sessionId, screenName) {
+  return createTimelineEvent({
+    sessionId,
+    type: TimelineEventType.ScreenViewed,
+    screenName,
+    label: `Viewed: ${screenName}`
+  });
+}
+
+/** Create a user interaction event */
+export function interactionEvent(sessionId, screenName, interactionType, target) {
+  const typeMap = {
+    tap: TimelineEventType.UserTap,
+    long_press: TimelineEventType.UserLongPress,
+    scroll: TimelineEventType.UserScroll,
+    swipe: TimelineEventType.UserSwipe,
+    text_input: TimelineEventType.TextInputChange
+  };
+  return createTimelineEvent({
+    sessionId,
+    type: typeMap[interactionType] ?? TimelineEventType.UserTap,
+    screenName,
+    label: `${interactionType}${target ? ` on ${target}` : ''}`,
+    data: {
+      interactionType,
+      target
+    }
+  });
+}
+
+/** Create a network request event */
+export function networkEvent(sessionId, screenName, method, url, statusCode, durationMs) {
+  return createTimelineEvent({
+    sessionId,
+    type: TimelineEventType.NetworkRequest,
+    screenName,
+    label: `${method} ${url} → ${statusCode} (${durationMs}ms)`,
+    data: {
+      method,
+      url,
+      statusCode,
+      durationMs
+    }
+  });
+}
+
+/** Create a breadcrumb event */
+export function breadcrumbEvent(sessionId, screenName, category, message, data) {
+  return createTimelineEvent({
+    sessionId,
+    type: TimelineEventType.CustomBreadcrumb,
+    screenName,
+    label: `[${category}] ${message}`,
+    data: {
+      category,
+      ...data
+    }
+  });
+}
+
+/** Create an error event */
+export function errorEvent(sessionId, screenName, errorMessage, fatal = false) {
+  return createTimelineEvent({
+    sessionId,
+    type: fatal ? TimelineEventType.CrashCaptured : TimelineEventType.ErrorCaptured,
+    screenName,
+    label: errorMessage,
+    data: {
+      fatal
+    }
+  });
+}
+
+/** Create an app lifecycle event */
+export function lifecycleEvent(sessionId, screenName, foreground) {
+  return createTimelineEvent({
+    sessionId,
+    type: foreground ? TimelineEventType.AppForeground : TimelineEventType.AppBackground,
+    screenName,
+    label: foreground ? 'App entered foreground' : 'App entered background'
+  });
+}
+//# sourceMappingURL=timelineModels.js.map