userlens-session-recorder 1.2.2 → 2.0.1

package/dist/api/index.d.ts

@@ -1,2 +1,2 @@
-import type { eventWithTime } from "rrweb";
-export declare const uploadSessionEvents: (userId: string, sessionUuid: string, events: eventWithTime[], chunkTimestamp: number) => Promise<"ok" | undefined>;
+import type { UploadArgs } from "../types";
+export declare const uploadSessionEvents: (args: UploadArgs) => Promise<"ok" | undefined>;

package/dist/index.cjs.js

@@ -20609,48 +20609,71 @@ const getWriteCode = () => {
         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;
@@ -20659,65 +20682,88 @@ class SessionRecorder {
         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;
@@ -20746,15 +20792,15 @@ class SessionRecorder {
             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) {
@@ -20777,9 +20823,8 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_handleVi
         },
         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) {
@@ -20791,15 +20836,16 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_handleVi
     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) {
@@ -20810,24 +20856,29 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_handleVi
         __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) => {
@@ -20838,34 +20889,59 @@ _SessionRecorder_trackEventsThrottled = new WeakMap(), _SessionRecorder_handleVi
         }
     };
 }, _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;