@v-tilt/browser 1.1.5 → 1.3.0

package/lib/extensions/replay/session-recording-wrapper.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Session Recording Wrapper
+ *
+ * Lightweight wrapper that handles the decision of WHEN to load recording.
+ * The actual recording logic is in LazyLoadedSessionRecording which is
+ * loaded on demand.
+ *
+ * Based on PostHog's sessionrecording-wrapper.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRecordingWrapper = exports.LAZY_LOADING = void 0;
+const globals_1 = require("../../utils/globals");
+const LOGGER_PREFIX = "[SessionRecording]";
+/** Status when lazy loading is in progress */
+exports.LAZY_LOADING = "lazy_loading";
+/**
+ * Session Recording Wrapper
+ *
+ * This is the lightweight class that lives in the main bundle.
+ * It handles:
+ * - Deciding if recording should be enabled
+ * - Lazy loading the actual recording code
+ * - Delegating to LazyLoadedSessionRecording
+ */
+class SessionRecordingWrapper {
+    constructor(_instance, config = {}) {
+        this._instance = _instance;
+        this._config = config;
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    get started() {
+        var _a;
+        return !!((_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.isStarted);
+    }
+    get status() {
+        var _a;
+        return (((_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.status) ||
+            exports.LAZY_LOADING);
+    }
+    get sessionId() {
+        var _a;
+        return ((_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.sessionId) || "";
+    }
+    /**
+     * Start recording if enabled, otherwise stop
+     */
+    startIfEnabledOrStop(startReason) {
+        var _a;
+        if (this._isRecordingEnabled && ((_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.isStarted)) {
+            return;
+        }
+        // Check browser compatibility
+        const canRunReplay = typeof Object.assign !== "undefined" && typeof Array.from !== "undefined";
+        if (this._isRecordingEnabled && canRunReplay) {
+            this._lazyLoadAndStart(startReason);
+            console.info(`${LOGGER_PREFIX} starting`);
+        }
+        else {
+            this.stopRecording();
+        }
+    }
+    /**
+     * Stop recording
+     */
+    stopRecording() {
+        var _a;
+        (_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.stop();
+    }
+    /**
+     * Log a message to the recording
+     */
+    log(message, level = "log") {
+        var _a;
+        if ((_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.log) {
+            this._lazyLoadedRecording.log(message, level);
+        }
+        else {
+            console.warn(`${LOGGER_PREFIX} log called before recorder was ready`);
+        }
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        var _a;
+        this._config = { ...this._config, ...config };
+        (_a = this._lazyLoadedRecording) === null || _a === void 0 ? void 0 : _a.updateConfig(this._config);
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    get _isRecordingEnabled() {
+        var _a;
+        const config = this._instance.getConfig();
+        const enabled = (_a = this._config.enabled) !== null && _a !== void 0 ? _a : false;
+        const notDisabled = !config.disable_session_recording;
+        return !!globals_1.window && enabled && notDisabled;
+    }
+    get _scriptName() {
+        return "recorder";
+    }
+    /**
+     * Lazy load the recording script and start
+     */
+    _lazyLoadAndStart(startReason) {
+        var _a, _b, _c, _d;
+        if (!this._isRecordingEnabled) {
+            return;
+        }
+        // Check if already loaded
+        if (((_b = (_a = globals_1.assignableWindow === null || globals_1.assignableWindow === void 0 ? void 0 : globals_1.assignableWindow.__VTiltExtensions__) === null || _a === void 0 ? void 0 : _a.rrweb) === null || _b === void 0 ? void 0 : _b.record) &&
+            ((_c = globals_1.assignableWindow.__VTiltExtensions__) === null || _c === void 0 ? void 0 : _c.initSessionRecording)) {
+            this._onScriptLoaded(startReason);
+            return;
+        }
+        // Load the recorder script
+        const loadExternalDependency = (_d = globals_1.assignableWindow.__VTiltExtensions__) === null || _d === void 0 ? void 0 : _d.loadExternalDependency;
+        if (!loadExternalDependency) {
+            console.error(`${LOGGER_PREFIX} loadExternalDependency not available. Session recording cannot start.`);
+            return;
+        }
+        loadExternalDependency(this._instance, this._scriptName, (err) => {
+            if (err) {
+                console.error(`${LOGGER_PREFIX} could not load recorder:`, err);
+                return;
+            }
+            this._onScriptLoaded(startReason);
+        });
+    }
+    /**
+     * Called after the recording script is loaded
+     */
+    _onScriptLoaded(startReason) {
+        var _a;
+        const initSessionRecording = (_a = globals_1.assignableWindow.__VTiltExtensions__) === null || _a === void 0 ? void 0 : _a.initSessionRecording;
+        if (!initSessionRecording) {
+            console.error(`${LOGGER_PREFIX} initSessionRecording not available after script load`);
+            return;
+        }
+        if (!this._lazyLoadedRecording) {
+            this._lazyLoadedRecording = initSessionRecording(this._instance, this._config);
+        }
+        this._lazyLoadedRecording.start(startReason);
+    }
+}
+exports.SessionRecordingWrapper = SessionRecordingWrapper;

package/lib/extensions/replay/session-recording.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Lazy Loaded Session Recording
+ *
+ * The actual rrweb session recording implementation.
+ * This is loaded on demand when recording is enabled.
+ *
+ * Based on PostHog's lazy-loaded-session-recorder.ts
+ */
+import { type eventWithTime } from "@rrweb/types";
+import type { VTilt } from "../../vtilt";
+import { LazyLoadedSessionRecordingInterface } from "../../utils/globals";
+import type { SessionRecordingConfig, SessionRecordingStatus } from "./types";
+export declare const SESSION_RECORDING_BATCH_KEY = "recordings";
+export declare class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInterface {
+    private _instance;
+    private _endpoint;
+    private _flushBufferTimer?;
+    private _fullSnapshotTimer?;
+    private _captureStarted;
+    private _stopRrweb?;
+    private _isIdle;
+    private _lastActivityTimestamp;
+    private _lastHref?;
+    private _sessionId;
+    private _windowId;
+    private _buffer;
+    private _queuedRRWebEvents;
+    private _config;
+    constructor(instance: VTilt, config?: SessionRecordingConfig);
+    get isStarted(): boolean;
+    /** @deprecated Use isStarted instead */
+    get started(): boolean;
+    get sessionId(): string;
+    get status(): SessionRecordingStatus;
+    /**
+     * Start session recording (interface method)
+     */
+    start(startReason?: string): void;
+    /**
+     * Stop session recording (interface method)
+     */
+    stop(): void;
+    /** @deprecated Use stop() instead */
+    stopRecording(): void;
+    /**
+     * Add a custom event to the recording
+     */
+    addCustomEvent(tag: string, payload: unknown): boolean;
+    /**
+     * Take a full snapshot
+     */
+    takeFullSnapshot(): boolean;
+    /**
+     * Log a message to the recording
+     */
+    log(message: string, level?: "log" | "warn" | "error"): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<SessionRecordingConfig>): void;
+    private _onBeforeUnload;
+    private _onOffline;
+    private _onOnline;
+    private _onVisibilityChange;
+    private _isRecordingEnabled;
+    private _startCapture;
+    private _loadRecorder;
+    private _onScriptLoaded;
+    private _gatherRRWebPlugins;
+    onRRwebEmit(rawEvent: eventWithTime): void;
+    private _processQueuedEvents;
+    private _updateWindowAndSessionIds;
+    private _clearBuffer;
+    private _flushBuffer;
+    private _captureSnapshotBuffered;
+    private _captureSnapshot;
+    private _sendSnapshot;
+    /**
+     * Fetch with exponential backoff retry (PostHog-style)
+     * Retries on network errors and 5xx server errors
+     */
+    private _fetchWithRetry;
+    /**
+     * Schedule a retry with exponential backoff and jitter
+     */
+    private _scheduleRetry;
+    private _scheduleFullSnapshot;
+    private _tryRRWebMethod;
+    private _tryAddCustomEvent;
+    private _tryTakeFullSnapshot;
+    private _getCanvasConfig;
+    private _getMaskingConfig;
+    private _generateId;
+    private _reportStarted;
+}