@openreplay/tracker 11.0.0 → 11.0.1

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 11.0.1
+
+- minor fixes and refactoring
+
 # 11.0.0
 
 - canvas support

package/cjs/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/cjs/app/index.js

@@ -42,13 +42,14 @@ 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.1'; // 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
@@ -201,7 +202,6 @@ class App {
                 }
             };
         }
-        this.uxtManager = new index_js_1.default(this, uxtStorageKey);
     }
     _debug(context, e) {
         if (this.options.__debug_report_edp !== null) {
@@ -513,6 +513,9 @@ class App {
                 this.options.onStart(onStartInfo);
             }
             this.restartAttempts = 0;
+            this.uxtManager = this.uxtManager
+                ? this.uxtManager
+                : new index_js_1.default(this, uxtStorageKey);
             let uxtId;
             const savedUxtTag = this.localStorage.getItem(uxtStorageKey);
             if (savedUxtTag) {
@@ -525,8 +528,20 @@ 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) => {
@@ -540,6 +555,14 @@ 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/cjs/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/cjs/index.js

@@ -162,7 +162,7 @@ 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.1',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)
@@ -238,6 +238,12 @@ class API {
         }
         return this.app.getTabId();
     }
+    getUxId() {
+        if (this.app === null) {
+            return null;
+        }
+        return this.app.getUxtId();
+    }
     sessionID() {
         (0, utils_js_1.deprecationWarn)("'sessionID' method", "'getSessionID' method", '/');
         return this.getSessionID();

package/cjs/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/cjs/modules/userTesting/SignalManager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("./utils.js");
+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(utils_js_1.SESSION_ID, sessionId);
+                this.setStorageKey(this.storageKey, this.testId.toString());
+                this.setStorageKey(utils_js_1.TEST_START, timestamp.toString());
+            }
+            else {
+                this.removeStorageKey(this.storageKey);
+                this.removeStorageKey(utils_js_1.TASK_IND);
+                this.removeStorageKey(utils_js_1.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(utils_js_1.TEST_START);
+        if (possibleStart) {
+            this.durations.testStart = parseInt(possibleStart, 10);
+        }
+    }
+}
+exports.default = SignalManager;

package/cjs/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;