userlens-session-recorder 2.0.2 → 2.1.0

package/dist/types/index.d.ts

@@ -1,20 +1,43 @@
+import { eventWithTime } from 'rrweb';
+
 type MaskingOption = "passwords" | "all";
+type RecorderMode = "auto" | "manual";
 interface SessionRecordingOptions {
     TIMEOUT?: number;
     BUFFER_SIZE?: number;
     maskingOptions?: MaskingOption[];
     recordCrossOriginIframes?: boolean;
 }
-interface SessionRecorderConfig {
+interface EventBatch {
+    session_uuid: string;
+    chunk_seq: number;
+    chunk_start_ts: string;
+    chunk_end_ts: string;
+    initial_url?: string;
+    events: eventWithTime[];
+    keepalive?: boolean;
+}
+type OnEventsCallback = (batch: EventBatch) => void | Promise<void>;
+interface AutoModeConfig {
+    mode?: "auto";
     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;
@@ -30,4 +53,4 @@ declare class SessionRecorder {
 }
 
 export { SessionRecorder as default };
-export type { MaskingOption, SessionRecorderConfig };
+export type { AutoModeConfig, EventBatch, ManualModeConfig, MaskingOption, OnEventsCallback, RecorderMode, SessionRecorderConfig };

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

@@ -20717,16 +20717,37 @@
                     writeSessionState({ ...state, chunk_seq: chunk_seq + 1 });
                     const start_ts_ms = events[0].timestamp;
                     const end_ts_ms = events[events.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(() => { });
+                    const initial_url = chunk_seq === 0 ? state.initial_url : undefined;
+                    const chunk_start_ts = new Date(start_ts_ms).toISOString();
+                    const chunk_end_ts = new Date(end_ts_ms).toISOString();
+                    if (this.mode === "manual") {
+                        try {
+                            void this.onEvents({
+                                session_uuid: this.sessionUuid,
+                                chunk_seq,
+                                chunk_start_ts,
+                                chunk_end_ts,
+                                initial_url,
+                                events,
+                                keepalive: true,
+                            });
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                    else {
+                        uploadSessionEvents({
+                            user_id: this.userId,
+                            session_uuid: this.sessionUuid,
+                            chunk_seq,
+                            chunk_start_ts,
+                            chunk_end_ts,
+                            initial_url,
+                            events,
+                            keepalive: true,
+                        }).catch(() => { });
+                    }
                     this.sessionEvents = [];
                     this.bufferBytes = 0;
                 }
@@ -20755,11 +20776,22 @@
                 sessionStorage.setItem(testKey, "1");
                 sessionStorage.removeItem(testKey);
                 this.debug = (_a = config.debug) !== null && _a !== void 0 ? _a : false;
-                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;
+                if (config.mode === "manual") {
+                    this.mode = "manual";
+                    if (!config.onEvents || typeof config.onEvents !== "function") {
+                        __classPrivateFieldGet(this, _SessionRecorder_instances, "m", _SessionRecorder_log).call(this, "onEvents callback is required in manual mode");
+                        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;
                 }
-                saveWriteCode(config.WRITE_CODE);
-                this.userId = config.userId;
                 const { recordingOptions = {} } = config;
                 const { TIMEOUT = 30 * 60 * 1000, BUFFER_SIZE = 30, maskingOptions = ["passwords"], recordCrossOriginIframes = false, } = recordingOptions;
                 this.TIMEOUT = TIMEOUT;
@@ -20906,15 +20938,30 @@
                 return;
             }
             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 initial_url = chunk_seq === 0 ? state.initial_url : undefined;
+            const chunk_start_ts = new Date(start_ts_ms).toISOString();
+            const chunk_end_ts = new Date(end_ts_ms).toISOString();
+            if (this.mode === "manual") {
+                await this.onEvents({
+                    session_uuid: this.sessionUuid,
+                    chunk_seq,
+                    chunk_start_ts,
+                    chunk_end_ts,
+                    initial_url,
+                    events,
+                });
+            }
+            else {
+                await uploadSessionEvents({
+                    user_id: this.userId,
+                    session_uuid: this.sessionUuid,
+                    chunk_seq,
+                    chunk_start_ts,
+                    chunk_end_ts,
+                    initial_url,
+                    events,
+                });
+            }
             const removedBytes = events.reduce((sum, e) => sum + estimateEventSize(e), 0);
             this.sessionEvents = this.sessionEvents.slice(snapshot_count);
             this.bufferBytes = Math.max(0, this.bufferBytes - removedBytes);