@openreplay/tracker 11.0.0 → 11.0.2

package/lib/app/index.d.ts

@@ -127,6 +127,9 @@ export default class App {
     active(): boolean;
     resetNextPageSession(flag: boolean): void;
     private _start;
+    onUxtCb: never[];
+    addOnUxtCb(cb: (id: number) => void): void;
+    getUxtId(): number | null;
     /**
      * basically we ask other tabs during constructor
      * and here we just apply 10ms delay just in case

package/lib/app/index.js

@@ -39,13 +39,14 @@ export default class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '11.0.0'; // TODO: version compatability check inside each plugin.
+        this.version = '11.0.2'; // TODO: version compatability check inside each plugin.
         this.compressionThreshold = 24 * 1000;
         this.restartAttempts = 0;
         this.bc = null;
         this.canvasRecorder = null;
         this._usingOldFetchPlugin = false;
         this.delay = 0;
+        this.onUxtCb = [];
         // if (options.onStart !== undefined) {
         //   deprecationWarn("'onStart' option", "tracker.start().then(/* handle session info */)")
         // } ?? maybe onStart is good
@@ -198,7 +199,6 @@ export default class App {
                 }
             };
         }
-        this.uxtManager = new UserTestManager(this, uxtStorageKey);
     }
     _debug(context, e) {
         if (this.options.__debug_report_edp !== null) {
@@ -510,6 +510,9 @@ export default class App {
                 this.options.onStart(onStartInfo);
             }
             this.restartAttempts = 0;
+            this.uxtManager = this.uxtManager
+                ? this.uxtManager
+                : new UserTestManager(this, uxtStorageKey);
             let uxtId;
             const savedUxtTag = this.localStorage.getItem(uxtStorageKey);
             if (savedUxtTag) {
@@ -522,8 +525,20 @@ export default class App {
                     uxtId = qId ? parseInt(qId, 10) : undefined;
                 }
             }
-            if (uxtId)
-                this.uxtManager.getTest(uxtId, token, Boolean(savedUxtTag));
+            if (uxtId) {
+                if (!this.uxtManager.isActive) {
+                    // eslint-disable-next-line
+                    this.uxtManager.getTest(uxtId, token, Boolean(savedUxtTag)).then((id) => {
+                        if (id) {
+                            this.onUxtCb.forEach((cb) => cb(id));
+                        }
+                    });
+                }
+                else {
+                    // @ts-ignore
+                    this.onUxtCb.forEach((cb) => cb(uxtId));
+                }
+            }
             return SuccessfulStart(onStartInfo);
         })
             .catch((reason) => {
@@ -537,6 +552,14 @@ export default class App {
             return UnsuccessfulStart(START_ERROR);
         });
     }
+    addOnUxtCb(cb) {
+        // @ts-ignore
+        this.onUxtCb.push(cb);
+    }
+    getUxtId() {
+        var _a;
+        return (_a = this.uxtManager) === null || _a === void 0 ? void 0 : _a.getTestId();
+    }
     /**
      * basically we ask other tabs during constructor
      * and here we just apply 10ms delay just in case

package/lib/index.d.ts

@@ -47,6 +47,7 @@ export default class API {
     getSessionToken(): string | null | undefined;
     getSessionID(): string | null | undefined;
     getTabId(): string | null;
+    getUxId(): number | null;
     sessionID(): string | null | undefined;
     getSessionURL(options?: {
         withCurrentTime?: boolean;

package/lib/index.js

@@ -157,7 +157,7 @@ export default class API {
             // no-cors issue only with text/plain or not-set Content-Type
             // req.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
             req.send(JSON.stringify({
-                trackerVersion: '11.0.0',
+                trackerVersion: '11.0.2',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)
@@ -233,6 +233,12 @@ export default class API {
         }
         return this.app.getTabId();
     }
+    getUxId() {
+        if (this.app === null) {
+            return null;
+        }
+        return this.app.getUxtId();
+    }
     sessionID() {
         deprecationWarn("'sessionID' method", "'getSessionID' method", '/');
         return this.getSessionID();

package/lib/modules/Network/fetchProxy.js

@@ -113,9 +113,11 @@ export class FetchProxyHandler {
     apply(target, _, argsList) {
         const input = argsList[0];
         const init = argsList[1];
-        // @ts-ignore
-        if (!input || !(input === null || input === void 0 ? void 0 : input.url))
+        if (!input ||
+            // @ts-ignore
+            (typeof input !== 'string' && !(input === null || input === void 0 ? void 0 : input.url))) {
             return target.apply(window, argsList);
+        }
         const isORUrl = input instanceof URL || typeof input === 'string'
             ? this.isServiceUrl(String(input))
             : this.isServiceUrl(String(input.url));

package/lib/modules/userTesting/SignalManager.d.ts

@@ -0,0 +1,29 @@
+export default class SignalManager {
+    private readonly ingestPoint;
+    private readonly getTimestamp;
+    private readonly token;
+    private readonly testId;
+    private readonly storageKey;
+    private readonly setStorageKey;
+    private readonly removeStorageKey;
+    private readonly getStorageKey;
+    private readonly getSessionId;
+    private readonly durations;
+    constructor(ingestPoint: string, getTimestamp: () => number, token: string, testId: number, storageKey: string, setStorageKey: (key: string, value: string) => void, removeStorageKey: (key: string) => void, getStorageKey: (key: string) => string | null, getSessionId: () => string | undefined);
+    getDurations: () => {
+        testStart: number;
+        tasks: {
+            taskId: number;
+            started: number;
+        }[];
+    };
+    setDurations: (durations: {
+        testStart: number;
+        tasks: {
+            taskId: number;
+            started: number;
+        }[];
+    }) => void;
+    signalTask: (taskId: number, status: 'begin' | 'done' | 'skipped', taskAnswer?: string) => void | Promise<Response>;
+    signalTest: (status: 'begin' | 'done' | 'skipped') => Promise<Response>;
+}

package/lib/modules/userTesting/SignalManager.js

@@ -0,0 +1,80 @@
+import { TEST_START, TASK_IND, SESSION_ID } from './utils.js';
+export default class SignalManager {
+    constructor(ingestPoint, getTimestamp, token, testId, storageKey, setStorageKey, removeStorageKey, getStorageKey, getSessionId) {
+        this.ingestPoint = ingestPoint;
+        this.getTimestamp = getTimestamp;
+        this.token = token;
+        this.testId = testId;
+        this.storageKey = storageKey;
+        this.setStorageKey = setStorageKey;
+        this.removeStorageKey = removeStorageKey;
+        this.getStorageKey = getStorageKey;
+        this.getSessionId = getSessionId;
+        this.durations = {
+            testStart: 0,
+            tasks: [],
+        };
+        this.getDurations = () => {
+            return this.durations;
+        };
+        this.setDurations = (durations) => {
+            this.durations.testStart = durations.testStart;
+            this.durations.tasks = durations.tasks;
+        };
+        this.signalTask = (taskId, status, taskAnswer) => {
+            if (!taskId)
+                return console.error('User Testing: No Task ID Given');
+            const taskStart = this.durations.tasks.find((t) => t.taskId === taskId);
+            const timestamp = this.getTimestamp();
+            const duration = taskStart ? timestamp - taskStart.started : 0;
+            return fetch(`${this.ingestPoint}/v1/web/uxt/signals/task`, {
+                method: 'POST',
+                headers: {
+                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                    Authorization: `Bearer ${this.token}`,
+                },
+                body: JSON.stringify({
+                    testId: this.testId,
+                    taskId,
+                    status,
+                    duration,
+                    timestamp,
+                    taskAnswer,
+                }),
+            });
+        };
+        this.signalTest = (status) => {
+            const timestamp = this.getTimestamp();
+            if (status === 'begin' && this.testId) {
+                const sessionId = this.getSessionId();
+                this.setStorageKey(SESSION_ID, sessionId);
+                this.setStorageKey(this.storageKey, this.testId.toString());
+                this.setStorageKey(TEST_START, timestamp.toString());
+            }
+            else {
+                this.removeStorageKey(this.storageKey);
+                this.removeStorageKey(TASK_IND);
+                this.removeStorageKey(TEST_START);
+            }
+            const start = this.durations.testStart || timestamp;
+            const duration = timestamp - start;
+            return fetch(`${this.ingestPoint}/v1/web/uxt/signals/test`, {
+                method: 'POST',
+                headers: {
+                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                    Authorization: `Bearer ${this.token}`,
+                },
+                body: JSON.stringify({
+                    testId: this.testId,
+                    status,
+                    duration,
+                    timestamp,
+                }),
+            });
+        };
+        const possibleStart = this.getStorageKey(TEST_START);
+        if (possibleStart) {
+            this.durations.testStart = parseInt(possibleStart, 10);
+        }
+    }
+}

package/lib/modules/userTesting/index.d.ts

@@ -8,18 +8,18 @@ export default class UserTestManager {
     private widgetGuidelinesVisible;
     private widgetTasksVisible;
     private widgetVisible;
+    isActive: boolean;
     private descriptionSection;
     private taskSection;
     private endSection;
     private stopButton;
+    private stopButtonContainer;
     private test;
     private testId;
-    private token;
-    private readonly durations;
+    private signalManager;
     constructor(app: App, storageKey: string);
-    signalTask: (taskId: number, status: 'begin' | 'done' | 'skipped', answer?: string) => void | Promise<Response>;
-    signalTest: (status: 'begin' | 'done' | 'skipped') => Promise<Response>;
-    getTest: (id: number, token: string, inProgress?: boolean) => void;
+    getTestId(): number | null;
+    getTest: (id: number, token: string, inProgress?: boolean) => Promise<number | void>;
     hideTaskSection: () => boolean;
     showTaskSection: () => boolean;
     collapseWidget: () => boolean;