@v-tilt/browser 1.1.4 → 1.2.0

package/lib/utils/globals.d.ts

@@ -1,6 +1,48 @@
 declare const win: (Window & typeof globalThis) | undefined;
+/**
+ * Extension kinds that can be lazy loaded
+ */
+export type VTiltExtensionKind = "recorder" | "web-vitals";
+/**
+ * Interface for lazy-loaded session recording (set by recorder.ts)
+ * Matches LazyLoadedSessionRecordingInterface in session-recording-wrapper.ts
+ */
+export interface LazyLoadedSessionRecordingInterface {
+    start: (startReason?: string) => void;
+    stop: () => void;
+    sessionId: string;
+    status: string;
+    isStarted: boolean;
+    onRemoteConfig?: (response: any) => void;
+    log: (message: string, level: "log" | "warn" | "error") => void;
+    updateConfig: (config: any) => void;
+}
+/**
+ * VTilt Extensions interface for dynamically loaded modules
+ * This is the contract between lazily loaded extensions and the SDK
+ */
+export interface VTiltExtensions {
+    /** Load an external dependency script */
+    loadExternalDependency?: (instance: any, // VTilt instance - using any to avoid circular imports
+    kind: VTiltExtensionKind, callback: (error?: string | Event, event?: Event) => void) => void;
+    /** rrweb record function (set by recorder.ts) */
+    rrweb?: {
+        record: any;
+        version?: string;
+    };
+    /** rrweb plugins (set by recorder.ts) */
+    rrwebPlugins?: {
+        getRecordConsolePlugin?: () => any;
+        getRecordNetworkPlugin?: (options: any) => any;
+    };
+    /** Factory to create LazyLoadedSessionRecording (set by recorder.ts) */
+    initSessionRecording?: (instance: any, config?: any) => LazyLoadedSessionRecordingInterface;
+}
 export type AssignableWindow = Window & typeof globalThis & {
+    /** Main VTilt instance */
     vt: any;
+    /** VTilt Extensions for dynamically loaded modules */
+    __VTiltExtensions__?: VTiltExtensions;
 };
 export declare const ArrayProto: any[];
 export declare const nativeForEach: (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;

package/lib/utils/globals.js

@@ -10,6 +10,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.window = exports.assignableWindow = exports.userAgent = exports.AbortController = exports.XMLHttpRequest = exports.fetch = exports.location = exports.document = exports.navigator = exports.nativeIndexOf = exports.nativeForEach = exports.ArrayProto = void 0;
+// Note: We use 'any' for VTilt to avoid circular imports
+// The actual type checking happens in the external-scripts-loader.ts
 const win = typeof window !== "undefined" ? window : undefined;
 exports.window = win;
 const global = typeof globalThis !== "undefined" ? globalThis : win;

package/lib/vtilt.d.ts

@@ -1,7 +1,9 @@
 import { VTiltConfig, EventPayload } from "./types";
 import { HistoryAutocapture } from "./extensions/history-autocapture";
+import { SessionRecordingWrapper } from "./extensions/replay";
 import { type QueuedRequest } from "./request-queue";
 export declare class VTilt {
+    readonly version = "1.1.5";
     private configManager;
     private sessionManager;
     private userManager;
@@ -10,6 +12,7 @@ export declare class VTilt {
     private retryQueue;
     private rateLimiter;
     historyAutocapture?: HistoryAutocapture;
+    sessionRecording?: SessionRecordingWrapper;
     __loaded: boolean;
     private _initial_pageview_captured;
     private _visibility_state_listener;
@@ -236,10 +239,43 @@ export declare class VTilt {
      * Get current session ID
      */
     getSessionId(): string | null;
+    /**
+     * Get current distinct ID
+     */
+    getDistinctId(): string;
+    /**
+     * Get anonymous ID
+     */
+    getAnonymousId(): string;
     /**
      * Update configuration
      */
     updateConfig(config: Partial<VTiltConfig>): void;
+    /**
+     * Initialize session recording
+     */
+    private _initSessionRecording;
+    /**
+     * Build session recording config from VTiltConfig
+     */
+    private _buildSessionRecordingConfig;
+    /**
+     * Start session recording
+     * Call this to manually start recording if it wasn't enabled initially
+     */
+    startSessionRecording(): void;
+    /**
+     * Stop session recording
+     */
+    stopSessionRecording(): void;
+    /**
+     * Check if session recording is active
+     */
+    isSessionRecordingActive(): boolean;
+    /**
+     * Get session recording ID
+     */
+    getSessionRecordingId(): string | null;
     /**
      * _execute_array() deals with processing any vTilt function
      * calls that were called before the vTilt library was loaded

package/lib/vtilt.js

@@ -8,6 +8,7 @@ const session_1 = require("./session");
 const user_manager_1 = require("./user-manager");
 const web_vitals_1 = require("./web-vitals");
 const history_autocapture_1 = require("./extensions/history-autocapture");
+const replay_1 = require("./extensions/replay");
 const request_1 = require("./request");
 const request_queue_1 = require("./request-queue");
 const retry_queue_1 = require("./retry-queue");
@@ -31,6 +32,8 @@ Use TypeScript accessibility modifiers (private/protected) for non-public member
 const isArray = Array.isArray;
 class VTilt {
     constructor(config = {}) {
+        // SDK version - injected at build time or defaults to package version
+        this.version = "1.1.5";
         this.__loaded = false; // Matches snippet's window.vt.__loaded check
         this._initial_pageview_captured = false;
         this._visibility_state_listener = null;
@@ -39,13 +42,8 @@ class VTilt {
         this._set_once_properties_sent = false; // Track if $set_once with initial props has been sent (only send once per page load)
         this.configManager = new config_1.ConfigManager(config);
         const fullConfig = this.configManager.getConfig();
-        // Auto-detect domain from location if not provided
-        let domain = fullConfig.domain;
-        if (!domain && globals_1.location) {
-            domain = this.getCurrentDomain();
-        }
-        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
-        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", fullConfig.cross_subdomain_cookie);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", fullConfig.cross_subdomain_cookie);
         this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
         // Initialize rate limiter to prevent flooding
         // Default: 10 events/second with burst of 100
@@ -137,6 +135,8 @@ class VTilt {
         // Initialize history autocapture
         this.historyAutocapture = new history_autocapture_1.HistoryAutocapture(this);
         this.historyAutocapture.startIfEnabled();
+        // Initialize session recording if enabled
+        this._initSessionRecording();
         // Set up page unload handler to flush queued events
         this._setup_unload_handler();
         // Enable the request queue for batched sending (PostHog pattern)
@@ -453,7 +453,6 @@ class VTilt {
             timestamp: new Date().toISOString(),
             event: name,
             project_id: config.projectId || "",
-            domain: config.domain || this.getCurrentDomain(), // Use config domain or current domain
             payload: processedPayload,
             distinct_id: distinct_id,
             // Always include anonymous_id in the event for identity linking
@@ -725,6 +724,18 @@ class VTilt {
     getSessionId() {
         return this.sessionManager.getSessionId();
     }
+    /**
+     * Get current distinct ID
+     */
+    getDistinctId() {
+        return (this.userManager.getDistinctId() || this.userManager.getAnonymousId());
+    }
+    /**
+     * Get anonymous ID
+     */
+    getAnonymousId() {
+        return this.userManager.getAnonymousId();
+    }
     /**
      * Update configuration
      */
@@ -732,13 +743,98 @@ class VTilt {
         this.configManager.updateConfig(config);
         const fullConfig = this.configManager.getConfig();
         // Recreate managers with new config
-        let domain = fullConfig.domain;
-        if (!domain && globals_1.location) {
-            domain = this.getCurrentDomain();
-        }
-        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
-        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", fullConfig.cross_subdomain_cookie);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", fullConfig.cross_subdomain_cookie);
         this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
+        // Update session recording config if it exists
+        if (this.sessionRecording && fullConfig.session_recording) {
+            this.sessionRecording.updateConfig(this._buildSessionRecordingConfig(fullConfig));
+        }
+    }
+    // ============================================================================
+    // Session Recording
+    // ============================================================================
+    /**
+     * Initialize session recording
+     */
+    _initSessionRecording() {
+        const config = this.configManager.getConfig();
+        // Don't initialize if explicitly disabled
+        if (config.disable_session_recording) {
+            return;
+        }
+        // Build session recording config
+        const sessionRecordingConfig = this._buildSessionRecordingConfig(config);
+        // Create session recording wrapper (lightweight - actual recorder is lazy-loaded)
+        this.sessionRecording = new replay_1.SessionRecordingWrapper(this, sessionRecordingConfig);
+        // Start recording if enabled (this will lazy-load the recorder script)
+        if (sessionRecordingConfig.enabled) {
+            this.sessionRecording.startIfEnabledOrStop("recording_initialized");
+        }
+    }
+    /**
+     * Build session recording config from VTiltConfig
+     */
+    _buildSessionRecordingConfig(config) {
+        var _a, _b, _c;
+        const sessionRecording = config.session_recording || {};
+        return {
+            enabled: (_a = sessionRecording.enabled) !== null && _a !== void 0 ? _a : false,
+            sampleRate: sessionRecording.sampleRate,
+            minimumDurationMs: sessionRecording.minimumDurationMs,
+            sessionIdleThresholdMs: sessionRecording.sessionIdleThresholdMs,
+            fullSnapshotIntervalMs: sessionRecording.fullSnapshotIntervalMs,
+            captureConsole: (_b = sessionRecording.captureConsole) !== null && _b !== void 0 ? _b : false,
+            captureNetwork: (_c = sessionRecording.captureNetwork) !== null && _c !== void 0 ? _c : false,
+            captureCanvas: sessionRecording.captureCanvas,
+            blockClass: sessionRecording.blockClass,
+            blockSelector: sessionRecording.blockSelector,
+            ignoreClass: sessionRecording.ignoreClass,
+            maskTextClass: sessionRecording.maskTextClass,
+            maskTextSelector: sessionRecording.maskTextSelector,
+            maskAllInputs: sessionRecording.maskAllInputs,
+            maskInputOptions: sessionRecording.maskInputOptions,
+            masking: sessionRecording.masking,
+            recordHeaders: sessionRecording.recordHeaders,
+            recordBody: sessionRecording.recordBody,
+            compressEvents: sessionRecording.compressEvents,
+            __mutationThrottlerRefillRate: sessionRecording.__mutationThrottlerRefillRate,
+            __mutationThrottlerBucketSize: sessionRecording.__mutationThrottlerBucketSize,
+        };
+    }
+    /**
+     * Start session recording
+     * Call this to manually start recording if it wasn't enabled initially
+     */
+    startSessionRecording() {
+        if (!this.sessionRecording) {
+            const config = this.configManager.getConfig();
+            const sessionRecordingConfig = this._buildSessionRecordingConfig(config);
+            sessionRecordingConfig.enabled = true;
+            this.sessionRecording = new replay_1.SessionRecordingWrapper(this, sessionRecordingConfig);
+        }
+        this.sessionRecording.startIfEnabledOrStop("recording_initialized");
+    }
+    /**
+     * Stop session recording
+     */
+    stopSessionRecording() {
+        var _a;
+        (_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.stopRecording();
+    }
+    /**
+     * Check if session recording is active
+     */
+    isSessionRecordingActive() {
+        var _a;
+        return ((_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.status) === "active";
+    }
+    /**
+     * Get session recording ID
+     */
+    getSessionRecordingId() {
+        var _a;
+        return ((_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.sessionId) || null;
     }
     /**
      * _execute_array() deals with processing any vTilt function

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v-tilt/browser",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "vTilt browser tracking library",
   "main": "dist/main.js",
   "module": "dist/module.js",
@@ -48,6 +48,9 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@rrweb/record": "2.0.0-alpha.17",
+    "@rrweb/rrweb-plugin-console-record": "2.0.0-alpha.17",
+    "@rrweb/types": "2.0.0-alpha.17",
     "fflate": "^0.8.2",
     "web-vitals": "^3.5.0"
   },