userlens-session-recorder 1.2.2 → 2.0.1

package/dist/types/index.d.ts

@@ -1,39 +1,20 @@
-import { eventWithTime } from 'rrweb';
-
 type MaskingOption = "passwords" | "all";
-type RecorderMode = "auto" | "manual";
 interface SessionRecordingOptions {
     TIMEOUT?: number;
     BUFFER_SIZE?: number;
     maskingOptions?: MaskingOption[];
     recordCrossOriginIframes?: boolean;
 }
-interface EventBatch {
-    sessionId: string;
-    events: eventWithTime[];
-    chunkTimestamp: number;
-}
-type OnEventsCallback = (batch: EventBatch) => void;
-interface AutoModeConfig {
-    mode?: "auto";
+interface SessionRecorderConfig {
     WRITE_CODE: string;
     userId: string;
     recordingOptions?: SessionRecordingOptions;
     debug?: boolean;
 }
-interface ManualModeConfig {
-    mode: "manual";
-    onEvents: OnEventsCallback;
-    recordingOptions?: SessionRecordingOptions;
-    debug?: boolean;
-}
-type SessionRecorderConfig = AutoModeConfig | ManualModeConfig;
 
 declare class SessionRecorder {
     #private;
-    private mode;
     private userId?;
-    private onEvents?;
     private TIMEOUT;
     private BUFFER_SIZE;
     private maskingOptions;
@@ -48,4 +29,4 @@ declare class SessionRecorder {
 }
 
 export { SessionRecorder as default };
-export type { AutoModeConfig, EventBatch, ManualModeConfig, MaskingOption, OnEventsCallback, RecorderMode, SessionRecorderConfig };
+export type { MaskingOption, SessionRecorderConfig };

package/dist/userlens-session-recorder.umd.js

@@ -20611,48 +20611,71 @@
             return null;
         }
     };
+    const STATE_KEY = "userlensSessionRec";
+    function readSessionState() {
+        try {
+            const raw = window.sessionStorage.getItem(STATE_KEY);
+            if (!raw)
+                return null;
+            const parsed = JSON.parse(raw);
+            if (typeof parsed !== "object" || parsed === null ||
+                typeof parsed.session_uuid !== "string" ||
+                typeof parsed.last_active !== "number" ||
+                typeof parsed.chunk_seq !== "number" ||
+                typeof parsed.initial_url !== "string")
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    function writeSessionState(state) {
+        try {
+            window.sessionStorage.setItem(STATE_KEY, JSON.stringify(state));
+        }
+        catch { }
+    }
+    function clearSessionState() {
+        try {
+            window.sessionStorage.removeItem(STATE_KEY);
+        }
+        catch { }
+    }
 
-    const SESSIONS_BASE_URL = "https://sessions.userlens.io";
-    // Gzip + base64 encode payload
-    async function compressAndEncode(data) {
-        const jsonStr = JSON.stringify(data);
-        const stream = new Blob([new TextEncoder().encode(jsonStr)])
-            .stream()
-            .pipeThrough(new CompressionStream("gzip"));
-        const buffer = await new Response(stream).arrayBuffer();
-        const bytes = new Uint8Array(buffer);
-        let binary = "";
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    const uploadSessionEvents = async (userId, sessionUuid, events, chunkTimestamp) => {
+    const INGEST_BASE_URL = "https://ul-ingest.userlens.io";
+    const uploadSessionEvents = async (args) => {
+        var _a;
         const writeCode = getWriteCode();
         if (!writeCode) {
             return;
         }
-        // Encode the entire payload - no readable data in request
-        const data = {
-            userId: userId,
-            chunk_timestamp: chunkTimestamp,
-            events: events,
+        const body = {
+            session_uuid: args.session_uuid,
+            chunk_seq: args.chunk_seq,
+            chunk_start_ts: args.chunk_start_ts,
+            chunk_end_ts: args.chunk_end_ts,
+            user_id: args.user_id,
+            events: args.events,
         };
-        const encodedPayload = await compressAndEncode(data);
-        const res = await fetch(`${SESSIONS_BASE_URL}/session/${sessionUuid}`, {
+        if (args.initial_url !== undefined) {
+            body.initial_url = args.initial_url;
+        }
+        const res = await fetch(`${INGEST_BASE_URL}/session-recording`, {
             method: "POST",
             headers: {
-                "Content-Type": "text/plain",
+                "Content-Type": "application/json",
                 Authorization: `Basic ${writeCode}`,
             },
-            body: encodedPayload,
+            body: JSON.stringify(body),
+            keepalive: (_a = args.keepalive) !== null && _a !== void 0 ? _a : false,
         });
         if (!res.ok)
             throw new Error("Userlens HTTP error: failed to track");
         return "ok";
     };
 
-    var _SessionRecorder_instances, _SessionRecorder_trackEventsThrottled, _SessionRecorder_log, _SessionRecorder_initRecorder, _SessionRecorder_isUserInteraction, _SessionRecorder_handleEvent, _SessionRecorder_resetSession, _SessionRecorder_createSession, _SessionRecorder_handleVisibilityChange, _SessionRecorder_initFocusListener, _SessionRecorder_throttle, _SessionRecorder_trackEvents, _SessionRecorder_clearEvents, _SessionRecorder_removeLocalSessionData;
+    var _SessionRecorder_instances, _SessionRecorder_trackEventsThrottled, _SessionRecorder_uploading, _SessionRecorder_uploadingMaxTs, _SessionRecorder_log, _SessionRecorder_initRecorder, _SessionRecorder_isUserInteraction, _SessionRecorder_handleEvent, _SessionRecorder_resetSession, _SessionRecorder_createSession, _SessionRecorder_handlePageHide, _SessionRecorder_initListeners, _SessionRecorder_throttle, _SessionRecorder_trackEvents, _SessionRecorder_clearEvents;
     class SessionRecorder {
         constructor(config) {
             var _a, _b, _c;
@@ -20661,65 +20684,88 @@
             this.rrwebStop = null;
             this.debug = false;
             _SessionRecorder_trackEventsThrottled.set(this, void 0);
-            _SessionRecorder_handleVisibilityChange.set(this, () => {
+            _SessionRecorder_uploading.set(this, false);
+            _SessionRecorder_uploadingMaxTs.set(this, 0);
+            _SessionRecorder_handlePageHide.set(this, () => {
                 try {
-                    if (document.visibilityState === "visible") {
-                        if (!this.rrwebStop)
-                            return;
-                        const now = Date.now();
-                        const lastActive = Number(localStorage.getItem("userlensSessionLastActive"));
-                        if (lastActive && now - lastActive > this.TIMEOUT) {
-                            __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_resetSession).call(this);
+                    if (this.sessionEvents.length === 0)
+                        return;
+                    let toUpload;
+                    if (__classPrivateFieldGet(this, _SessionRecorder_uploading, "f") && __classPrivateFieldGet(this, _SessionRecorder_uploadingMaxTs, "f") > 0) {
+                        toUpload = this.sessionEvents.filter((e) => e.timestamp > __classPrivateFieldGet(this, _SessionRecorder_uploadingMaxTs, "f"));
+                    }
+                    else {
+                        toUpload = [...this.sessionEvents];
+                    }
+                    if (toUpload.length === 0)
+                        return;
+                    let events;
+                    if (toUpload[0].type !== 4) {
+                        let snapshotPair = [];
+                        for (let i = this.sessionEvents.length - 2; i >= 0; i--) {
+                            if (this.sessionEvents[i].type === 4 &&
+                                this.sessionEvents[i + 1].type === 2) {
+                                snapshotPair = [
+                                    this.sessionEvents[i],
+                                    this.sessionEvents[i + 1],
+                                ];
+                                break;
+                            }
                         }
-                        takeFullSnapshot(true);
+                        events = [...snapshotPair, ...toUpload];
+                    }
+                    else {
+                        events = toUpload;
                     }
+                    const state = readSessionState();
+                    if (!state)
+                        return;
+                    const chunk_seq = __classPrivateFieldGet(this, _SessionRecorder_uploading, "f") ? state.chunk_seq + 1 : state.chunk_seq;
+                    writeSessionState({ ...state, chunk_seq: chunk_seq + 1 });
+                    const start_ts_ms = toUpload[0].timestamp;
+                    const end_ts_ms = toUpload[toUpload.length - 1].timestamp;
+                    uploadSessionEvents({
+                        user_id: this.userId,
+                        session_uuid: this.sessionUuid,
+                        chunk_seq,
+                        chunk_start_ts: new Date(start_ts_ms).toISOString(),
+                        chunk_end_ts: new Date(end_ts_ms).toISOString(),
+                        initial_url: chunk_seq === 0 ? state.initial_url : undefined,
+                        events,
+                        keepalive: true,
+                    }).catch(() => { });
+                    this.sessionEvents = [];
                 }
                 catch (err) {
-                    __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Visibility change handling failed", err);
+                    __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Page hide handling failed", err);
                 }
             });
             try {
-                // Check for browser environment
                 if (typeof window === "undefined")
                     return;
                 if (typeof document === "undefined")
                     return;
                 if (typeof localStorage === "undefined")
                     return;
-                // Check for required APIs
-                if (typeof CompressionStream === "undefined")
+                if (typeof sessionStorage === "undefined")
                     return;
                 if (typeof MutationObserver === "undefined")
                     return;
-                if (typeof TextEncoder === "undefined")
-                    return;
                 if (typeof fetch === "undefined")
                     return;
-                if (typeof Blob === "undefined")
-                    return;
                 if (typeof crypto === "undefined" || !crypto.getRandomValues)
                     return;
-                // Check localStorage actually works (can be blocked even if defined)
                 const testKey = "__userlens_test__";
                 localStorage.setItem(testKey, "1");
                 localStorage.removeItem(testKey);
-                // Set debug mode early so it's available for error logging
+                sessionStorage.setItem(testKey, "1");
+                sessionStorage.removeItem(testKey);
                 this.debug = (_a = config.debug) !== null && _a !== void 0 ? _a : false;
-                if (config.mode === "manual") {
-                    this.mode = "manual";
-                    if (!config.onEvents || typeof config.onEvents !== "function") {
-                        return;
-                    }
-                    this.onEvents = config.onEvents;
-                }
-                else {
-                    this.mode = "auto";
-                    if (!((_b = config.WRITE_CODE) === null || _b === void 0 ? void 0 : _b.trim()) || !((_c = config.userId) === null || _c === void 0 ? void 0 : _c.trim())) {
-                        return;
-                    }
-                    saveWriteCode(config.WRITE_CODE);
-                    this.userId = config.userId;
+                if (!((_b = config.WRITE_CODE) === null || _b === void 0 ? void 0 : _b.trim()) || !((_c = config.userId) === null || _c === void 0 ? void 0 : _c.trim())) {
+                    return;
                 }
+                saveWriteCode(config.WRITE_CODE);
+                this.userId = config.userId;
                 const { recordingOptions = {} } = config;
                 const { TIMEOUT = 30 * 60 * 1000, BUFFER_SIZE = 10, maskingOptions = ["passwords"], recordCrossOriginIframes = false, } = recordingOptions;
                 this.TIMEOUT = TIMEOUT;
@@ -20748,15 +20794,15 @@
                 this.rrwebStop();
                 this.rrwebStop = null;
                 __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_clearEvents).call(this);
-                __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_removeLocalSessionData).call(this);
-                window.removeEventListener("visibilitychange", __classPrivateFieldGet(this, _SessionRecorder_handleVisibilityChange, "f"));
+                clearSessionState();
+                window.removeEventListener("pagehide", __classPrivateFieldGet(this, _SessionRecorder_handlePageHide, "f"));
             }
             catch (err) {
                 __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Stop failed", err);
             }
         }
     }
-    _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_handleVisibilityChange = new WeakMap(), _SessionRecorder_instances = new WeakSet(), _SessionRecorder_log = function _SessionRecorder_log(message, error) {
+    _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_uploading = new WeakMap(), _SessionRecorder_uploadingMaxTs = new WeakMap(), _SessionRecorder_handlePageHide = new WeakMap(), _SessionRecorder_instances = new WeakSet(), _SessionRecorder_log = function _SessionRecorder_log(message, error) {
         if (!this.debug)
             return;
         if (error) {
@@ -20779,9 +20825,8 @@
             },
             recordCrossOriginIframes: this.recordCrossOriginIframes,
             plugins: [getRecordConsolePlugin()],
-            checkoutEveryNth: 100,
         });
-        __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_initFocusListener).call(this);
+        __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_initListeners).call(this);
     }, _SessionRecorder_isUserInteraction = function _SessionRecorder_isUserInteraction(event) {
         var _a;
         if (event.type === 3) {
@@ -20793,15 +20838,16 @@
         var _a;
         try {
             const now = Date.now();
-            const lastActive = Number(localStorage.getItem("userlensSessionLastActive"));
-            // check inactivity timeout
-            if (lastActive && now - lastActive > this.TIMEOUT) {
+            const state = readSessionState();
+            if (state && now - state.last_active > this.TIMEOUT) {
                 __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_resetSession).call(this);
                 takeFullSnapshot(true);
             }
-            // only update lastActive on actual user interactions, not DOM mutations
             if (__classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_isUserInteraction).call(this, event)) {
-                localStorage.setItem("userlensSessionLastActive", now.toString());
+                const latest = readSessionState();
+                if (latest) {
+                    writeSessionState({ ...latest, last_active: now });
+                }
             }
             this.sessionEvents.push(event);
             if (this.sessionEvents.length >= this.BUFFER_SIZE) {
@@ -20812,24 +20858,29 @@
             __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Event handling failed", err);
         }
     }, _SessionRecorder_resetSession = function _SessionRecorder_resetSession() {
-        __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_removeLocalSessionData).call(this);
+        clearSessionState();
         __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_clearEvents).call(this);
         __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_createSession).call(this);
     }, _SessionRecorder_createSession = function _SessionRecorder_createSession() {
         const now = Date.now();
-        const lastActive = Number(localStorage.getItem("userlensSessionLastActive"));
-        const storedUuid = localStorage.getItem("userlensSessionUuid");
-        const isExpired = !lastActive || now - lastActive > this.TIMEOUT;
-        if (!storedUuid || isExpired) {
+        const state = readSessionState();
+        const isExpired = !state || now - state.last_active > this.TIMEOUT;
+        if (!state || isExpired) {
             this.sessionUuid = generateUuid();
-            localStorage.setItem("userlensSessionUuid", this.sessionUuid);
+            const initial_url = typeof window !== "undefined" ? window.location.href : "";
+            writeSessionState({
+                session_uuid: this.sessionUuid,
+                last_active: now,
+                chunk_seq: 0,
+                initial_url,
+            });
         }
         else {
-            this.sessionUuid = storedUuid;
+            this.sessionUuid = state.session_uuid;
+            writeSessionState({ ...state, last_active: now });
         }
-        localStorage.setItem("userlensSessionLastActive", now.toString());
-    }, _SessionRecorder_initFocusListener = function _SessionRecorder_initFocusListener() {
-        window.addEventListener("visibilitychange", __classPrivateFieldGet(this, _SessionRecorder_handleVisibilityChange, "f"));
+    }, _SessionRecorder_initListeners = function _SessionRecorder_initListeners() {
+        window.addEventListener("pagehide", __classPrivateFieldGet(this, _SessionRecorder_handlePageHide, "f"));
     }, _SessionRecorder_throttle = function _SessionRecorder_throttle(func, delay) {
         let lastCall = 0;
         return (...args) => {
@@ -20840,34 +20891,59 @@
             }
         };
     }, _SessionRecorder_trackEvents = async function _SessionRecorder_trackEvents() {
+        if (__classPrivateFieldGet(this, _SessionRecorder_uploading, "f"))
+            return;
+        if (this.sessionEvents.length === 0)
+            return;
+        __classPrivateFieldSet(this, _SessionRecorder_uploading, true, "f");
         try {
-            if (this.sessionEvents.length === 0) {
+            const events = [...this.sessionEvents];
+            const snapshot_count = events.length;
+            __classPrivateFieldSet(this, _SessionRecorder_uploadingMaxTs, events[events.length - 1].timestamp, "f");
+            const start_ts_ms = events[0].timestamp;
+            const end_ts_ms = events[events.length - 1].timestamp;
+            const state = readSessionState();
+            if (!state) {
+                __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "No session state during upload — skipping chunk");
                 return;
             }
-            const chunkTimestamp = this.sessionEvents[this.sessionEvents.length - 1].timestamp;
-            const events = [...this.sessionEvents];
-            __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_clearEvents).call(this);
-            if (this.mode === "manual") {
-                if (this.onEvents) {
-                    this.onEvents({
-                        sessionId: this.sessionUuid,
-                        events,
-                        chunkTimestamp,
-                    });
-                }
+            const chunk_seq = state.chunk_seq;
+            await uploadSessionEvents({
+                user_id: this.userId,
+                session_uuid: this.sessionUuid,
+                chunk_seq,
+                chunk_start_ts: new Date(start_ts_ms).toISOString(),
+                chunk_end_ts: new Date(end_ts_ms).toISOString(),
+                initial_url: chunk_seq === 0 ? state.initial_url : undefined,
+                events,
+            });
+            const remaining = this.sessionEvents.slice(snapshot_count);
+            this.sessionEvents = [];
+            try {
+                takeFullSnapshot(true);
+            }
+            catch (err) {
+                __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "takeFullSnapshot failed", err);
+            }
+            if (remaining.length > 0) {
+                this.sessionEvents.push(...remaining);
             }
-            else {
-                await uploadSessionEvents(this.userId, this.sessionUuid, events, chunkTimestamp);
+            const after = readSessionState();
+            if (after &&
+                after.session_uuid === state.session_uuid &&
+                after.chunk_seq === chunk_seq) {
+                writeSessionState({ ...after, chunk_seq: chunk_seq + 1 });
             }
         }
         catch (err) {
             __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "Event tracking failed", err);
         }
+        finally {
+            __classPrivateFieldSet(this, _SessionRecorder_uploading, false, "f");
+            __classPrivateFieldSet(this, _SessionRecorder_uploadingMaxTs, 0, "f");
+        }
     }, _SessionRecorder_clearEvents = function _SessionRecorder_clearEvents() {
         this.sessionEvents = [];
-    }, _SessionRecorder_removeLocalSessionData = function _SessionRecorder_removeLocalSessionData() {
-        localStorage.removeItem("userlensSessionUuid");
-        localStorage.removeItem("userlensSessionLastActive");
     };
 
     exports.default = SessionRecorder;