@openreplay/tracker 16.4.2 → 16.4.3-beta.0

package/dist/cjs/main/app/index.d.ts

@@ -252,7 +252,7 @@ export default class App {
      * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
      * and we will then send buffered batch, so it won't get lost
      * */
-    coldStart(startOpts?: StartOptions, conditional?: boolean): Promise<void>;
+    coldStart: (startOpts?: StartOptions, conditional?: boolean) => Promise<void>;
     private setupConditionalStart;
     onSessionSent: () => void;
     /**
@@ -260,7 +260,7 @@ export default class App {
      * @param {Object} startOpts - options for session start, same as .start()
      * @param {Function} onSessionSent - callback that will be called once session is fully sent
      * */
-    offlineRecording(startOpts: StartOptions | undefined, onSessionSent: () => void): {
+    offlineRecording: (startOpts: StartOptions | undefined, onSessionSent: () => void) => {
         saveBuffer: () => void;
         getBuffer: () => Message[];
         setBuffer: (buffer: Message[]) => void;
@@ -272,15 +272,15 @@ export default class App {
      *
      * Keeping the size of local storage reasonable is up to the end users of this library
      * */
-    saveBuffer(): void;
+    saveBuffer: () => void;
     /**
      * @returns buffer with stored messages for offline recording
      * */
-    getBuffer(): Message[];
+    getBuffer: () => Message[];
     /**
      * Used to set a buffer with messages array
      * */
-    setBuffer(buffer: Message[]): void;
+    setBuffer: (buffer: Message[]) => void;
     /**
      * Uploads the stored session buffer to backend
      * @returns promise that resolves once messages are loaded, it has to be awaited

package/dist/lib/entry.js

@@ -5271,7 +5271,7 @@ class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '16.4.2'; // TODO: version compatability check inside each plugin.
+        this.version = '16.4.3-beta.0'; // TODO: version compatability check inside each plugin.
         this.socketMode = false;
         this.compressionThreshold = 24 * 1000;
         this.bc = null;
@@ -5559,9 +5559,170 @@ class App {
         this.orderNumber = 0;
         this.coldStartTs = 0;
         this.singleBuffer = false;
+        /**
+         * start buffering messages without starting the actual session, which gives
+         * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
+         * and we will then send buffered batch, so it won't get lost
+         * */
+        this.coldStart = async (startOpts = {}, conditional) => {
+            this.singleBuffer = false;
+            const second = 1000;
+            const isNewSession = this.checkSessionToken(startOpts.forceNew);
+            if (conditional) {
+                await this.setupConditionalStart(startOpts);
+            }
+            const cycle = () => {
+                this.orderNumber += 1;
+                adjustTimeOrigin();
+                this.coldStartTs = now();
+                if (this.orderNumber % 2 === 0) {
+                    this.bufferedMessages1.length = 0;
+                    this.bufferedMessages1.push(Timestamp(this.timestamp()));
+                    this.bufferedMessages1.push(TabData(this.session.getTabId()));
+                }
+                else {
+                    this.bufferedMessages2.length = 0;
+                    this.bufferedMessages2.push(Timestamp(this.timestamp()));
+                    this.bufferedMessages2.push(TabData(this.session.getTabId()));
+                }
+                this.stop(false);
+                this.activityState = ActivityState.ColdStart;
+                if (startOpts.sessionHash) {
+                    this.session.applySessionHash(startOpts.sessionHash);
+                }
+                if (startOpts.forceNew) {
+                    this.session.reset();
+                }
+                this.session.assign({
+                    userID: startOpts.userID,
+                    metadata: startOpts.metadata,
+                });
+                if (!isNewSession) {
+                    this.debug.log('continuing session on new tab', this.session.getTabId());
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    this.send(TabChange(this.session.getTabId()));
+                }
+                this.observer.observe();
+                this.ticker.start();
+            };
+            this.coldInterval = setInterval(() => {
+                cycle();
+            }, 30 * second);
+            cycle();
+        };
+        this.setupConditionalStart = async (startOpts) => {
+            this.conditionsManager = new ConditionsManager(this, startOpts);
+            const r = await fetch(this.options.ingestPoint + '/v1/web/start', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    ...this.getTrackerInfo(),
+                    timestamp: now(),
+                    doNotRecord: true,
+                    bufferDiff: 0,
+                    userID: this.session.getInfo().userID,
+                    token: undefined,
+                    deviceMemory,
+                    jsHeapSizeLimit,
+                    timezone: getTimezone(),
+                    width: window.screen.width,
+                    height: window.screen.height,
+                }),
+            });
+            const { 
+            // this token is needed to fetch conditions and flags,
+            // but it can't be used to record a session
+            token, userBrowser, userCity, userCountry, userDevice, userOS, userState, projectID, features, } = await r.json();
+            this.features = features ? features : this.features;
+            this.session.assign({ projectID });
+            this.session.setUserInfo({
+                userBrowser,
+                userCity,
+                userCountry,
+                userDevice,
+                userOS,
+                userState,
+            });
+            const onStartInfo = { sessionToken: token, userUUID: '', sessionID: '' };
+            this.startCallbacks.forEach((cb) => cb(onStartInfo));
+            await this.conditionsManager?.fetchConditions(projectID, token);
+            if (this.features['feature-flags']) {
+                await this.featureFlags.reloadFlags(token);
+                this.conditionsManager?.processFlags(this.featureFlags.flags);
+            }
+            await this.tagWatcher.fetchTags(this.options.ingestPoint, token);
+        };
         this.onSessionSent = () => {
             return;
         };
+        /**
+         * Starts offline session recording
+         * @param {Object} startOpts - options for session start, same as .start()
+         * @param {Function} onSessionSent - callback that will be called once session is fully sent
+         * */
+        this.offlineRecording = (startOpts = {}, onSessionSent) => {
+            this.onSessionSent = onSessionSent;
+            this.singleBuffer = true;
+            const isNewSession = this.checkSessionToken(startOpts.forceNew);
+            adjustTimeOrigin();
+            this.coldStartTs = now();
+            const saverBuffer = this.localStorage.getItem(bufferStorageKey);
+            if (saverBuffer) {
+                const data = JSON.parse(saverBuffer);
+                this.bufferedMessages1 = Array.isArray(data) ? data : this.bufferedMessages1;
+                this.localStorage.removeItem(bufferStorageKey);
+            }
+            this.bufferedMessages1.push(Timestamp(this.timestamp()));
+            this.bufferedMessages1.push(TabData(this.session.getTabId()));
+            this.activityState = ActivityState.ColdStart;
+            if (startOpts.sessionHash) {
+                this.session.applySessionHash(startOpts.sessionHash);
+            }
+            if (startOpts.forceNew) {
+                this.session.reset();
+            }
+            this.session.assign({
+                userID: startOpts.userID,
+                metadata: startOpts.metadata,
+            });
+            const onStartInfo = { sessionToken: '', userUUID: '', sessionID: '' };
+            this.startCallbacks.forEach((cb) => cb(onStartInfo));
+            if (!isNewSession) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                this.send(TabChange(this.session.getTabId()));
+            }
+            this.observer.observe();
+            this.ticker.start();
+            return {
+                saveBuffer: this.saveBuffer,
+                getBuffer: this.getBuffer,
+                setBuffer: this.setBuffer,
+            };
+        };
+        /**
+         * Saves the captured messages in localStorage (or whatever is used in its place)
+         *
+         * Then, when this.offlineRecording is called, it will preload this messages and clear the storage item
+         *
+         * Keeping the size of local storage reasonable is up to the end users of this library
+         * */
+        this.saveBuffer = () => {
+            this.localStorage.setItem(bufferStorageKey, JSON.stringify(this.bufferedMessages1));
+        };
+        /**
+         * @returns buffer with stored messages for offline recording
+         * */
+        this.getBuffer = () => {
+            return this.bufferedMessages1;
+        };
+        /**
+         * Used to set a buffer with messages array
+         * */
+        this.setBuffer = (buffer) => {
+            this.bufferedMessages1 = buffer;
+        };
         this.prevOpts = {};
         this.restartCanvasTracking = () => {
             this.canvasRecorder?.restartTracking();
@@ -6068,167 +6229,6 @@ class App {
         const sessionToken = this.session.getSessionToken(this.projectKey);
         return needNewSessionID || !sessionToken;
     }
-    /**
-     * start buffering messages without starting the actual session, which gives
-     * user 30 seconds to "activate" and record session by calling `start()` on conditional trigger,
-     * and we will then send buffered batch, so it won't get lost
-     * */
-    async coldStart(startOpts = {}, conditional) {
-        this.singleBuffer = false;
-        const second = 1000;
-        const isNewSession = this.checkSessionToken(startOpts.forceNew);
-        if (conditional) {
-            await this.setupConditionalStart(startOpts);
-        }
-        const cycle = () => {
-            this.orderNumber += 1;
-            adjustTimeOrigin();
-            this.coldStartTs = now();
-            if (this.orderNumber % 2 === 0) {
-                this.bufferedMessages1.length = 0;
-                this.bufferedMessages1.push(Timestamp(this.timestamp()));
-                this.bufferedMessages1.push(TabData(this.session.getTabId()));
-            }
-            else {
-                this.bufferedMessages2.length = 0;
-                this.bufferedMessages2.push(Timestamp(this.timestamp()));
-                this.bufferedMessages2.push(TabData(this.session.getTabId()));
-            }
-            this.stop(false);
-            this.activityState = ActivityState.ColdStart;
-            if (startOpts.sessionHash) {
-                this.session.applySessionHash(startOpts.sessionHash);
-            }
-            if (startOpts.forceNew) {
-                this.session.reset();
-            }
-            this.session.assign({
-                userID: startOpts.userID,
-                metadata: startOpts.metadata,
-            });
-            if (!isNewSession) {
-                this.debug.log('continuing session on new tab', this.session.getTabId());
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                this.send(TabChange(this.session.getTabId()));
-            }
-            this.observer.observe();
-            this.ticker.start();
-        };
-        this.coldInterval = setInterval(() => {
-            cycle();
-        }, 30 * second);
-        cycle();
-    }
-    async setupConditionalStart(startOpts) {
-        this.conditionsManager = new ConditionsManager(this, startOpts);
-        const r = await fetch(this.options.ingestPoint + '/v1/web/start', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                ...this.getTrackerInfo(),
-                timestamp: now(),
-                doNotRecord: true,
-                bufferDiff: 0,
-                userID: this.session.getInfo().userID,
-                token: undefined,
-                deviceMemory,
-                jsHeapSizeLimit,
-                timezone: getTimezone(),
-                width: window.screen.width,
-                height: window.screen.height,
-            }),
-        });
-        const { 
-        // this token is needed to fetch conditions and flags,
-        // but it can't be used to record a session
-        token, userBrowser, userCity, userCountry, userDevice, userOS, userState, projectID, features, } = await r.json();
-        this.features = features ? features : this.features;
-        this.session.assign({ projectID });
-        this.session.setUserInfo({
-            userBrowser,
-            userCity,
-            userCountry,
-            userDevice,
-            userOS,
-            userState,
-        });
-        const onStartInfo = { sessionToken: token, userUUID: '', sessionID: '' };
-        this.startCallbacks.forEach((cb) => cb(onStartInfo));
-        await this.conditionsManager?.fetchConditions(projectID, token);
-        if (this.features['feature-flags']) {
-            await this.featureFlags.reloadFlags(token);
-            this.conditionsManager?.processFlags(this.featureFlags.flags);
-        }
-        await this.tagWatcher.fetchTags(this.options.ingestPoint, token);
-    }
-    /**
-     * Starts offline session recording
-     * @param {Object} startOpts - options for session start, same as .start()
-     * @param {Function} onSessionSent - callback that will be called once session is fully sent
-     * */
-    offlineRecording(startOpts = {}, onSessionSent) {
-        this.onSessionSent = onSessionSent;
-        this.singleBuffer = true;
-        const isNewSession = this.checkSessionToken(startOpts.forceNew);
-        adjustTimeOrigin();
-        this.coldStartTs = now();
-        const saverBuffer = this.localStorage.getItem(bufferStorageKey);
-        if (saverBuffer) {
-            const data = JSON.parse(saverBuffer);
-            this.bufferedMessages1 = Array.isArray(data) ? data : this.bufferedMessages1;
-            this.localStorage.removeItem(bufferStorageKey);
-        }
-        this.bufferedMessages1.push(Timestamp(this.timestamp()));
-        this.bufferedMessages1.push(TabData(this.session.getTabId()));
-        this.activityState = ActivityState.ColdStart;
-        if (startOpts.sessionHash) {
-            this.session.applySessionHash(startOpts.sessionHash);
-        }
-        if (startOpts.forceNew) {
-            this.session.reset();
-        }
-        this.session.assign({
-            userID: startOpts.userID,
-            metadata: startOpts.metadata,
-        });
-        const onStartInfo = { sessionToken: '', userUUID: '', sessionID: '' };
-        this.startCallbacks.forEach((cb) => cb(onStartInfo));
-        if (!isNewSession) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            this.send(TabChange(this.session.getTabId()));
-        }
-        this.observer.observe();
-        this.ticker.start();
-        return {
-            saveBuffer: this.saveBuffer,
-            getBuffer: this.getBuffer,
-            setBuffer: this.setBuffer,
-        };
-    }
-    /**
-     * Saves the captured messages in localStorage (or whatever is used in its place)
-     *
-     * Then, when this.offlineRecording is called, it will preload this messages and clear the storage item
-     *
-     * Keeping the size of local storage reasonable is up to the end users of this library
-     * */
-    saveBuffer() {
-        this.localStorage.setItem(bufferStorageKey, JSON.stringify(this.bufferedMessages1));
-    }
-    /**
-     * @returns buffer with stored messages for offline recording
-     * */
-    getBuffer() {
-        return this.bufferedMessages1;
-    }
-    /**
-     * Used to set a buffer with messages array
-     * */
-    setBuffer(buffer) {
-        this.bufferedMessages1 = buffer;
-    }
     /**
      * Uploads the stored session buffer to backend
      * @returns promise that resolves once messages are loaded, it has to be awaited
@@ -9651,7 +9651,7 @@ class API {
         this.signalStartIssue = (reason, missingApi) => {
             const doNotTrack = this.checkDoNotTrack();
             console.log("Tracker couldn't start due to:", JSON.stringify({
-                trackerVersion: '16.4.2',
+                trackerVersion: '16.4.3-beta.0',
                 projectKey: this.options.projectKey,
                 doNotTrack,
                 reason: missingApi.length ? `missing api: ${missingApi.join(',')}` : reason,