@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,279 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sessionOrchestrator = void 0;
+var _reactNative = require("react-native");
+var _enums = require("../../public/enums");
+var _bridgeAdapter = require("../../bridge/adapters/bridgeAdapter");
+var _eventEmitter = require("../../bridge/eventEmitter");
+var _AutoScreenDetector = require("../../../navigation/AutoScreenDetector");
+var _logger = require("../../core/logger/logger");
+var _sessionId = require("../../core/ids/sessionId");
+var clock = _interopRequireWildcard(require("../../core/clock/clock"));
+var _safeCall = require("../../core/errors/safeCall");
+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 — 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.
+ */
+
+class SessionOrchestrator {
+  _config = null;
+  _state = _enums.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.logger.warn('SessionOrchestrator already initialized');
+      return true;
+    }
+    this._config = config;
+
+    // Initialize native module (non-fatal if unavailable)
+    try {
+      const success = await _bridgeAdapter.bridgeAdapter.initialize(config);
+      if (!success) {
+        __DEV__ && _logger.logger.info('Native replay module not available — running in transport-only mode');
+      }
+    } catch (nativeErr) {
+      __DEV__ && _logger.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 = _reactNative.AppState.addEventListener('change', this._onAppStateChange);
+    this._initialized = true;
+    __DEV__ && _logger.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 === _enums.SessionState.Recording) return;
+    this._sessionId = (0, _sessionId.generateSessionId)();
+    this._startedAt = clock.now();
+    clock.markSessionStart();
+
+    // Try native start — non-fatal if unavailable
+    await _bridgeAdapter.bridgeAdapter.startSession();
+    this._state = _enums.SessionState.Recording;
+    this._startDurationTimer();
+    this._startFrequencyTimerIfNeeded();
+    __DEV__ && _logger.logger.info(`Session started: ${this._sessionId}`);
+  }
+  async stop() {
+    if (this._state === _enums.SessionState.Idle) return;
+    this._state = _enums.SessionState.Finalizing;
+    this._stopTimers();
+    await _bridgeAdapter.bridgeAdapter.stopSession();
+    this._state = _enums.SessionState.Idle;
+    clock.resetClock();
+    __DEV__ && _logger.logger.info(`Session stopped: ${this._sessionId}`);
+    this._sessionId = null;
+    this._startedAt = 0;
+  }
+  async pause() {
+    if (this._state !== _enums.SessionState.Recording) return;
+    this._state = _enums.SessionState.Paused;
+    this._stopTimers();
+    await _bridgeAdapter.bridgeAdapter.pauseSession();
+    __DEV__ && _logger.logger.debug('Session paused');
+  }
+  async resume() {
+    if (this._state !== _enums.SessionState.Paused) return;
+    this._state = _enums.SessionState.Recording;
+    this._startDurationTimer();
+    this._startFrequencyTimerIfNeeded();
+    await _bridgeAdapter.bridgeAdapter.resumeSession();
+    __DEV__ && _logger.logger.debug('Session resumed');
+  }
+
+  // ─── Capture ────────────────────────────────────────────────────────
+
+  async captureManualFrame() {
+    if (this._state !== _enums.SessionState.Recording) return;
+    await _bridgeAdapter.bridgeAdapter.captureManualFrame();
+  }
+
+  // ─── Screen Tracking ────────────────────────────────────────────────
+
+  async setCurrentScreen(screenName) {
+    this._currentScreen = screenName;
+    if (this._state === _enums.SessionState.Recording) {
+      await _bridgeAdapter.bridgeAdapter.setCurrentScreen(screenName);
+    }
+  }
+
+  // ─── User ───────────────────────────────────────────────────────────
+
+  async setUser(user) {
+    this._user = user;
+    await _bridgeAdapter.bridgeAdapter.setUser(user);
+  }
+  async clearUser() {
+    this._user = null;
+    await _bridgeAdapter.bridgeAdapter.clearUser();
+  }
+
+  // ─── Sync Callback ─────────────────────────────────────────────────
+
+  setSyncCallback(callback) {
+    this._syncCallback = callback;
+  }
+
+  // ─── Configuration Updates ──────────────────────────────────────────
+
+  async setEnabled(enabled) {
+    if (this._config) this._config.enabled = enabled;
+    await _bridgeAdapter.bridgeAdapter.setEnabled(enabled);
+    if (!enabled && this._state === _enums.SessionState.Recording) {
+      await this.stop();
+    }
+  }
+  async setCapturingMode(mode) {
+    if (this._config) this._config.captureMode = mode;
+    await _bridgeAdapter.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.logger.warn(`Session max duration reached (${maxDuration}ms)`);
+      (0, _safeCall.fireAndForget)('auto-stop', () => this.stop());
+    }, maxDuration);
+  }
+  _startFrequencyTimerIfNeeded() {
+    if (this._config?.captureMode !== _enums.CapturingMode.Frequency) return;
+    const interval = this._config.screenshotCaptureIntervalMs;
+    this._frequencyTimer = setInterval(() => {
+      if (this._state === _enums.SessionState.Recording) {
+        (0, _safeCall.fireAndForget)('frequency-capture', async () => {
+          await _bridgeAdapter.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 === _enums.SessionState.Recording) {
+      (0, _safeCall.fireAndForget)('background-pause', () => this.pause());
+    } else if (nextState === 'active' && this._state === _enums.SessionState.Paused) {
+      (0, _safeCall.fireAndForget)('foreground-resume', () => this.resume());
+    }
+  };
+
+  // ─── Internal: Native Event Listeners ───────────────────────────────
+
+  _setupNativeEventListeners() {
+    _eventEmitter.replayEventEmitter.onSessionStateChanged(event => {
+      __DEV__ && _logger.logger.debug(`Native state: ${event.previousState} → ${event.newState}`);
+    });
+    _eventEmitter.replayEventEmitter.onSessionLimitReached(event => {
+      _logger.logger.warn(`Session limit reached: ${event.limitType} (${event.currentValue}/${event.maxValue})`);
+      if (event.limitType === 'duration' || event.limitType === 'frames') {
+        (0, _safeCall.fireAndForget)('limit-stop', () => this.stop());
+      }
+    });
+    _eventEmitter.replayEventEmitter.onError(event => {
+      _logger.logger.error(`Native error [${event.code}]: ${event.message}`);
+      if (event.fatal) {
+        (0, _safeCall.fireAndForget)('fatal-stop', () => this.stop());
+      }
+    });
+    _eventEmitter.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.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 === _enums.SessionState.Recording;
+  }
+
+  // ─── Destroy ────────────────────────────────────────────────────────
+
+  async destroy() {
+    this._stopTimers();
+    this._appStateSubscription?.remove();
+    _eventEmitter.replayEventEmitter.destroy();
+    await _bridgeAdapter.bridgeAdapter.destroy();
+    this._initialized = false;
+    this._state = _enums.SessionState.Idle;
+    this._sessionId = null;
+    this._config = null;
+    __DEV__ && _logger.logger.info('SessionOrchestrator destroyed');
+  }
+}
+
+/** Singleton orchestrator */
+const sessionOrchestrator = exports.sessionOrchestrator = new SessionOrchestrator();
+//# sourceMappingURL=sessionOrchestrator.js.map

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

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.breadcrumbEvent = breadcrumbEvent;
+exports.createTimelineEvent = createTimelineEvent;
+exports.errorEvent = errorEvent;
+exports.interactionEvent = interactionEvent;
+exports.lifecycleEvent = lifecycleEvent;
+exports.networkEvent = networkEvent;
+exports.screenViewedEvent = screenViewedEvent;
+var _enums = require("../../public/enums");
+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 — Timeline Models
+ *
+ * Internal timeline event representation and factory.
+ */
+
+/** Create a timeline event */
+function createTimelineEvent(params) {
+  return {
+    eventId: (0, _sessionId.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 */
+function screenViewedEvent(sessionId, screenName) {
+  return createTimelineEvent({
+    sessionId,
+    type: _enums.TimelineEventType.ScreenViewed,
+    screenName,
+    label: `Viewed: ${screenName}`
+  });
+}
+
+/** Create a user interaction event */
+function interactionEvent(sessionId, screenName, interactionType, target) {
+  const typeMap = {
+    tap: _enums.TimelineEventType.UserTap,
+    long_press: _enums.TimelineEventType.UserLongPress,
+    scroll: _enums.TimelineEventType.UserScroll,
+    swipe: _enums.TimelineEventType.UserSwipe,
+    text_input: _enums.TimelineEventType.TextInputChange
+  };
+  return createTimelineEvent({
+    sessionId,
+    type: typeMap[interactionType] ?? _enums.TimelineEventType.UserTap,
+    screenName,
+    label: `${interactionType}${target ? ` on ${target}` : ''}`,
+    data: {
+      interactionType,
+      target
+    }
+  });
+}
+
+/** Create a network request event */
+function networkEvent(sessionId, screenName, method, url, statusCode, durationMs) {
+  return createTimelineEvent({
+    sessionId,
+    type: _enums.TimelineEventType.NetworkRequest,
+    screenName,
+    label: `${method} ${url} → ${statusCode} (${durationMs}ms)`,
+    data: {
+      method,
+      url,
+      statusCode,
+      durationMs
+    }
+  });
+}
+
+/** Create a breadcrumb event */
+function breadcrumbEvent(sessionId, screenName, category, message, data) {
+  return createTimelineEvent({
+    sessionId,
+    type: _enums.TimelineEventType.CustomBreadcrumb,
+    screenName,
+    label: `[${category}] ${message}`,
+    data: {
+      category,
+      ...data
+    }
+  });
+}
+
+/** Create an error event */
+function errorEvent(sessionId, screenName, errorMessage, fatal = false) {
+  return createTimelineEvent({
+    sessionId,
+    type: fatal ? _enums.TimelineEventType.CrashCaptured : _enums.TimelineEventType.ErrorCaptured,
+    screenName,
+    label: errorMessage,
+    data: {
+      fatal
+    }
+  });
+}
+
+/** Create an app lifecycle event */
+function lifecycleEvent(sessionId, screenName, foreground) {
+  return createTimelineEvent({
+    sessionId,
+    type: foreground ? _enums.TimelineEventType.AppForeground : _enums.TimelineEventType.AppBackground,
+    screenName,
+    label: foreground ? 'App entered foreground' : 'App entered background'
+  });
+}
+//# sourceMappingURL=timelineModels.js.map

package/lib/commonjs/features/replay/transport/BackendReplayTransport.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BackendReplayTransport = void 0;
+var _retryPolicy = require("../pipeline/retry/retryPolicy");
+/**
+ * Session Replay SDK — Backend Replay Transport
+ *
+ * Uploads replay data to a backend API via HTTP.
+ * Uses batching for frames/events and retry with exponential backoff.
+ *
+ * Design:
+ * - sendSessionStart → POST /v1/replay/sessions
+ * - sendFrame → buffered, flushed in batches to POST /v1/replay/sessions/:id/frames
+ * - sendEvent → buffered, flushed in batches to POST /v1/replay/sessions/:id/events
+ * - sendSessionEnd → flushes pending + POST /v1/replay/sessions/:id/finalize
+ *
+ * Never throws — all errors are caught and logged.
+ */
+
+// ─── Config ─────────────────────────────────────────────────────────────────
+
+// ─── Implementation ─────────────────────────────────────────────────────────
+
+class BackendReplayTransport {
+  _pendingFrames = [];
+  _pendingEvents = [];
+  _flushTimer = null;
+  _currentSessionId = null;
+  _destroyed = false;
+  constructor(config) {
+    this._config = {
+      batchSize: 5,
+      flushIntervalMs: 3000,
+      timeoutMs: 30_000,
+      ...config
+    };
+  }
+  sendSessionStart(payload) {
+    this._currentSessionId = payload.sessionId;
+
+    // Start auto-flush timer
+    this._startFlushTimer();
+
+    // POST session manifest
+    this._post(`/v1/replay/sessions`, {
+      sessionId: payload.sessionId,
+      startedAt: payload.startedAt,
+      device: payload.device,
+      config: payload.config
+    }).catch(() => {/* logged in _post */});
+  }
+  sendFrame(frame, imageData) {
+    if (this._destroyed) return;
+    this._pendingFrames.push({
+      frame,
+      imageData
+    });
+    if (this._pendingFrames.length >= this._config.batchSize) {
+      this._flushFrames().catch(() => {/* logged */});
+    }
+  }
+  sendEvent(event) {
+    if (this._destroyed) return;
+    this._pendingEvents.push(event);
+
+    // Flush events in batches of 20
+    if (this._pendingEvents.length >= 20) {
+      this._flushEvents().catch(() => {/* logged */});
+    }
+  }
+  sendSessionEnd(payload) {
+    // Flush all pending data first
+    Promise.all([this._flushFrames(), this._flushEvents()]).then(() => {
+      return this._post(`/v1/replay/sessions/${payload.sessionId}/finalize`, {
+        endedAt: payload.endedAt,
+        durationMs: payload.durationMs,
+        totalFrames: payload.totalFrames,
+        totalEvents: payload.totalEvents,
+        finalState: payload.finalState
+      });
+    }).catch(() => {/* logged */}).finally(() => {
+      this._stopFlushTimer();
+    });
+  }
+  destroy() {
+    this._destroyed = true;
+    this._stopFlushTimer();
+    this._pendingFrames = [];
+    this._pendingEvents = [];
+    this._currentSessionId = null;
+  }
+
+  // ─── Internal: Flush ────────────────────────────────────────────────
+
+  async _flushFrames() {
+    if (this._pendingFrames.length === 0 || !this._currentSessionId) return;
+    const batch = this._pendingFrames.splice(0, this._config.batchSize);
+    const frames = batch.map(b => b.frame);
+    const images = {};
+    for (const b of batch) {
+      images[b.frame.frameId] = b.imageData;
+    }
+    try {
+      await this._post(`/v1/replay/sessions/${this._currentSessionId}/frames`, {
+        frames,
+        images
+      });
+    } catch {
+      // Re-queue failed frames at the front
+      this._pendingFrames.unshift(...batch);
+    }
+  }
+  async _flushEvents() {
+    if (this._pendingEvents.length === 0 || !this._currentSessionId) return;
+    const batch = this._pendingEvents.splice(0, 20);
+    try {
+      await this._post(`/v1/replay/sessions/${this._currentSessionId}/events`, {
+        events: batch
+      });
+    } catch {
+      // Re-queue failed events at the front
+      this._pendingEvents.unshift(...batch);
+    }
+  }
+
+  // ─── Internal: Timer ────────────────────────────────────────────────
+
+  _startFlushTimer() {
+    this._stopFlushTimer();
+    this._flushTimer = setInterval(() => {
+      this._flushFrames().catch(() => {/* logged */});
+      this._flushEvents().catch(() => {/* logged */});
+    }, this._config.flushIntervalMs);
+  }
+  _stopFlushTimer() {
+    if (this._flushTimer) {
+      clearInterval(this._flushTimer);
+      this._flushTimer = null;
+    }
+  }
+
+  // ─── Internal: HTTP ─────────────────────────────────────────────────
+
+  async _post(path, body) {
+    const url = `${this._config.endpoint}${path}`;
+    await (0, _retryPolicy.withRetry)(`BackendTransport ${path}`, async () => {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this._config.timeoutMs);
+      try {
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-API-Key': this._config.apiKey
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const err = new Error(`HTTP ${response.status}`);
+          err.status = response.status;
+          err.retryable = response.status >= 500 || response.status === 429;
+          throw err;
+        }
+      } finally {
+        clearTimeout(timeout);
+      }
+    }, err => err?.retryable !== false, _retryPolicy.DEFAULT_RETRY_CONFIG);
+  }
+}
+exports.BackendReplayTransport = BackendReplayTransport;
+//# sourceMappingURL=BackendReplayTransport.js.map

package/lib/commonjs/features/replay/transport/CompositeReplayTransport.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompositeReplayTransport = void 0;
+var _logger = require("../core/logger/logger");
+/**
+ * Session Replay SDK — Composite Replay Transport
+ *
+ * Fans out replay data to 1+ child transports (e.g. desktop + backend).
+ * Each child transport handles its own errors independently.
+ * A failure in one transport never blocks another.
+ *
+ * Never throws — all errors are caught and logged.
+ */
+
+class CompositeReplayTransport {
+  constructor(transports) {
+    this._transports = transports;
+  }
+  sendSessionStart(payload) {
+    for (const t of this._transports) {
+      try {
+        t.sendSessionStart(payload);
+      } catch (err) {
+        _logger.logger.error('[CompositeTransport] sendSessionStart failed on child:', err);
+      }
+    }
+  }
+  sendFrame(frame, imageData) {
+    for (const t of this._transports) {
+      try {
+        t.sendFrame(frame, imageData);
+      } catch (err) {
+        _logger.logger.error('[CompositeTransport] sendFrame failed on child:', err);
+      }
+    }
+  }
+  sendEvent(event) {
+    for (const t of this._transports) {
+      try {
+        t.sendEvent(event);
+      } catch (err) {
+        _logger.logger.error('[CompositeTransport] sendEvent failed on child:', err);
+      }
+    }
+  }
+  sendSessionEnd(payload) {
+    for (const t of this._transports) {
+      try {
+        t.sendSessionEnd(payload);
+      } catch (err) {
+        _logger.logger.error('[CompositeTransport] sendSessionEnd failed on child:', err);
+      }
+    }
+  }
+  destroy() {
+    for (const t of this._transports) {
+      try {
+        t.destroy();
+      } catch (err) {
+        _logger.logger.error('[CompositeTransport] destroy failed on child:', err);
+      }
+    }
+    this._transports = [];
+  }
+
+  /** Number of active child transports */
+  get transportCount() {
+    return this._transports.length;
+  }
+}
+exports.CompositeReplayTransport = CompositeReplayTransport;
+//# sourceMappingURL=CompositeReplayTransport.js.map