@openreplay/tracker 3.6.2 → 4.0.1

package/cjs/app/observer/top_observer.js

@@ -4,51 +4,85 @@ const observer_js_1 = require("./observer.js");
 const guards_js_1 = require("../guards.js");
 const iframe_observer_js_1 = require("./iframe_observer.js");
 const shadow_root_observer_js_1 = require("./shadow_root_observer.js");
-const messages_js_1 = require("../../common/messages.js");
+const messages_gen_js_1 = require("../messages.gen.js");
 const utils_js_1 = require("../../utils.js");
+function isPatchedDocument(doc) {
+    // @ts-ignore
+    return typeof doc.__openreplay__getOffset === 'function';
+}
 const attachShadowNativeFn = utils_js_1.IN_BROWSER ? Element.prototype.attachShadow : () => new ShadowRoot();
 class TopObserver extends observer_js_1.default {
     constructor(app, options) {
         super(app, true);
+        this.contextCallbacks = [];
+        // Attached once per Tracker instance
+        this.contextsSet = new Set();
         this.iframeObservers = [];
         this.shadowRootObservers = [];
         this.options = Object.assign({
-            captureIFrames: true
+            captureIFrames: true,
         }, options);
         // IFrames
-        this.app.nodes.attachNodeCallback(node => {
-            if ((0, guards_js_1.hasTag)(node, "IFRAME") &&
-                ((this.options.captureIFrames && !(0, utils_js_1.hasOpenreplayAttribute)(node, "obscured"))
-                    || (0, utils_js_1.hasOpenreplayAttribute)(node, "capture"))) {
+        this.app.nodes.attachNodeCallback((node) => {
+            if ((0, guards_js_1.hasTag)(node, 'IFRAME') &&
+                ((this.options.captureIFrames && !(0, utils_js_1.hasOpenreplayAttribute)(node, 'obscured')) ||
+                    (0, utils_js_1.hasOpenreplayAttribute)(node, 'capture'))) {
                 this.handleIframe(node);
             }
         });
         // ShadowDOM
-        this.app.nodes.attachNodeCallback(node => {
+        this.app.nodes.attachNodeCallback((node) => {
             if ((0, guards_js_1.isElementNode)(node) && node.shadowRoot !== null) {
                 this.handleShadowRoot(node.shadowRoot);
             }
         });
     }
+    attachContextCallback(cb) {
+        this.contextCallbacks.push(cb);
+    }
+    // Le truc
+    getDocumentOffset(doc) {
+        if (isPatchedDocument(doc)) {
+            return doc.__openreplay__getOffset();
+        }
+        return { top: 0, left: 0 };
+    }
     handleIframe(iframe) {
         let doc = null;
+        let win = null;
         const handle = this.app.safe(() => {
             const id = this.app.nodes.getID(iframe);
             if (id === undefined) {
+                //log
                 return;
-            } //log
-            if (iframe.contentDocument === doc) {
-                return;
-            } // How frequently can it happen?
-            doc = iframe.contentDocument;
-            if (!doc || !iframe.contentWindow) {
-                return;
             }
-            const observer = new iframe_observer_js_1.default(this.app);
-            this.iframeObservers.push(observer);
-            observer.observe(iframe);
+            const currentWin = iframe.contentWindow;
+            const currentDoc = iframe.contentDocument;
+            if (currentDoc && currentDoc !== doc) {
+                const observer = new iframe_observer_js_1.default(this.app);
+                this.iframeObservers.push(observer);
+                observer.observe(iframe);
+                doc = currentDoc;
+                doc.__openreplay__getOffset = () => {
+                    const { top, left } = this.getDocumentOffset(iframe.ownerDocument);
+                    return {
+                        top: iframe.offsetTop + top,
+                        left: iframe.offsetLeft + left,
+                    };
+                };
+            }
+            if (currentWin &&
+                // Sometimes currentWin.window is null (not in specification). Such window object is not functional
+                currentWin === currentWin.window &&
+                !this.contextsSet.has(currentWin) // for each context callbacks called once per Tracker (TopObserver) instance
+            ) {
+                this.contextsSet.add(currentWin);
+                //@ts-ignore https://github.com/microsoft/TypeScript/issues/41684
+                this.contextCallbacks.forEach((cb) => cb(currentWin));
+                win = currentWin;
+            }
         });
-        iframe.addEventListener("load", handle); // why app.attachEventListener not working?
+        iframe.addEventListener('load', handle); // why app.attachEventListener not working?
         handle();
     }
     handleShadowRoot(shRoot) {
@@ -60,25 +94,26 @@ class TopObserver extends observer_js_1.default {
         // Protection from several subsequent calls?
         const observer = this;
         Element.prototype.attachShadow = function () {
+            // eslint-disable-next-line
             const shadow = attachShadowNativeFn.apply(this, arguments);
             observer.handleShadowRoot(shadow);
             return shadow;
         };
         // Can observe documentElement (<html>) here, because it is not supposed to be changing.
         // However, it is possible in some exotic cases and may cause an ignorance of the newly created <html>
-        // In this case context.document have to be observed, but this will cause 
-        // the change in the re-player behaviour caused by CreateDocument message: 
+        // In this case context.document have to be observed, but this will cause
+        // the change in the re-player behaviour caused by CreateDocument message:
         //   the 0-node ("fRoot") will become #document rather than documentElement as it is now.
         // Alternatively - observe(#document) then bindNode(documentElement)
         this.observeRoot(window.document, () => {
-            this.app.send(new messages_js_1.CreateDocument());
+            this.app.send((0, messages_gen_js_1.CreateDocument)());
         }, window.document.documentElement);
     }
     disconnect() {
         Element.prototype.attachShadow = attachShadowNativeFn;
-        this.iframeObservers.forEach(o => o.disconnect());
+        this.iframeObservers.forEach((o) => o.disconnect());
         this.iframeObservers = [];
-        this.shadowRootObservers.forEach(o => o.disconnect());
+        this.shadowRootObservers.forEach((o) => o.disconnect());
         this.shadowRootObservers = [];
         super.disconnect();
     }

package/cjs/app/sanitizer.d.ts

@@ -1,4 +1,4 @@
-import type App from "./index.js";
+import type App from './index.js';
 export interface Options {
     obscureTextEmails: boolean;
     obscureTextNumbers: boolean;

package/cjs/app/sanitizer.js

@@ -14,20 +14,20 @@ class Sanitizer {
     }
     handleNode(id, parentID, node) {
         if (this.masked.has(parentID) ||
-            ((0, guards_js_1.isElementNode)(node) &&
-                (0, utils_js_1.hasOpenreplayAttribute)(node, 'masked'))) {
+            ((0, guards_js_1.isElementNode)(node) && (0, utils_js_1.hasOpenreplayAttribute)(node, 'masked'))) {
             this.masked.add(id);
         }
         if (this.maskedContainers.has(parentID) ||
-            ((0, guards_js_1.isElementNode)(node) &&
-                (0, utils_js_1.hasOpenreplayAttribute)(node, 'htmlmasked'))) {
+            ((0, guards_js_1.isElementNode)(node) && (0, utils_js_1.hasOpenreplayAttribute)(node, 'htmlmasked'))) {
             this.maskedContainers.add(id);
         }
     }
     sanitize(id, data) {
         if (this.masked.has(id)) {
             // TODO: is it the best place to put trim() ? Might trimmed spaces be considered in layout in certain cases?
-            return data.trim().replace(/[^\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/g, '█');
+            return data
+                .trim()
+                .replace(/[^\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/g, '█');
         }
         if (this.options.obscureTextNumbers) {
             data = data.replace(/\d/g, '0');

package/cjs/app/session.d.ts

@@ -1,19 +1,37 @@
+import type App from './index.js';
 interface SessionInfo {
-    sessionID: string | null;
+    sessionID: string | undefined;
     metadata: Record<string, string>;
     userID: string | null;
+    timestamp: number;
+    projectID?: string;
 }
 declare type OnUpdateCallback = (i: Partial<SessionInfo>) => void;
+export declare type Options = {
+    session_token_key: string;
+    session_pageno_key: string;
+};
 export default class Session {
+    private readonly app;
+    private readonly options;
     private metadata;
     private userID;
     private sessionID;
-    private callbacks;
+    private readonly callbacks;
+    private timestamp;
+    private projectID;
+    constructor(app: App, options: Options);
     attachUpdateCallback(cb: OnUpdateCallback): void;
     private handleUpdate;
     update(newInfo: Partial<SessionInfo>): void;
     setMetadata(key: string, value: string): void;
     setUserID(userID: string): void;
+    private getPageNumber;
+    incPageNo(): number;
+    getSessionToken(): string | undefined;
+    setSessionToken(token: string): void;
+    applySessionHash(hash: string): void;
+    getSessionHash(): string | undefined;
     getInfo(): SessionInfo;
     reset(): void;
 }

package/cjs/app/session.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class Session {
-    constructor() {
+    constructor(app, options) {
+        this.app = app;
+        this.options = options;
         this.metadata = {};
         this.userID = null;
-        this.sessionID = null;
         this.callbacks = [];
+        this.timestamp = 0;
     }
     attachUpdateCallback(cb) {
         this.callbacks.push(cb);
@@ -17,18 +19,25 @@ class Session {
         if (newInfo.sessionID == null) {
             delete newInfo.sessionID;
         }
-        this.callbacks.forEach(cb => cb(newInfo));
+        this.callbacks.forEach((cb) => cb(newInfo));
     }
     update(newInfo) {
-        if (newInfo.userID !== undefined) { // TODO clear nullable/undefinable types
+        if (newInfo.userID !== undefined) {
+            // TODO clear nullable/undefinable types
             this.userID = newInfo.userID;
         }
         if (newInfo.metadata !== undefined) {
-            Object.entries(newInfo.metadata).forEach(([k, v]) => this.metadata[k] = v);
+            Object.entries(newInfo.metadata).forEach(([k, v]) => (this.metadata[k] = v));
         }
         if (newInfo.sessionID !== undefined) {
             this.sessionID = newInfo.sessionID;
         }
+        if (newInfo.timestamp !== undefined) {
+            this.timestamp = newInfo.timestamp;
+        }
+        if (newInfo.projectID !== undefined) {
+            this.projectID = newInfo.projectID;
+        }
         this.handleUpdate(newInfo);
     }
     setMetadata(key, value) {
@@ -39,17 +48,67 @@ class Session {
         this.userID = userID;
         this.handleUpdate({ userID });
     }
+    getPageNumber() {
+        const pageNoStr = this.app.sessionStorage.getItem(this.options.session_pageno_key);
+        if (pageNoStr == null) {
+            return undefined;
+        }
+        return parseInt(pageNoStr);
+    }
+    incPageNo() {
+        let pageNo = this.getPageNumber();
+        if (pageNo === undefined) {
+            pageNo = 0;
+        }
+        else {
+            pageNo++;
+        }
+        this.app.sessionStorage.setItem(this.options.session_pageno_key, pageNo.toString());
+        return pageNo;
+    }
+    getSessionToken() {
+        return this.app.sessionStorage.getItem(this.options.session_token_key) || undefined;
+    }
+    setSessionToken(token) {
+        this.app.sessionStorage.setItem(this.options.session_token_key, token);
+    }
+    applySessionHash(hash) {
+        const hashParts = decodeURI(hash).split('&');
+        let token = hash;
+        let pageNoStr = '100500'; // back-compat for sessionToken
+        if (hashParts.length == 2) {
+            ;
+            [token, pageNoStr] = hashParts;
+        }
+        if (!pageNoStr || !token) {
+            return;
+        }
+        this.app.sessionStorage.setItem(this.options.session_token_key, token);
+        this.app.sessionStorage.setItem(this.options.session_pageno_key, pageNoStr);
+    }
+    getSessionHash() {
+        const pageNo = this.getPageNumber();
+        const token = this.getSessionToken();
+        if (pageNo === undefined || token === undefined) {
+            return;
+        }
+        return encodeURI(String(pageNo) + '&' + token);
+    }
     getInfo() {
         return {
             sessionID: this.sessionID,
             metadata: this.metadata,
             userID: this.userID,
+            timestamp: this.timestamp,
+            projectID: this.projectID,
         };
     }
     reset() {
+        this.app.sessionStorage.removeItem(this.options.session_token_key);
         this.metadata = {};
         this.userID = null;
-        this.sessionID = null;
+        this.sessionID = undefined;
+        this.timestamp = 0;
     }
 }
 exports.default = Session;

package/cjs/app/ticker.d.ts

@@ -1,4 +1,4 @@
-import App from "./index.js";
+import App from './index.js';
 declare type Callback = () => void;
 export default class Ticker {
     private readonly app;

package/cjs/common/{webworker.d.ts → interaction.d.ts}

@@ -1,19 +1,19 @@
+import Message from './messages.gen.js';
 export interface Options {
     connAttemptCount?: number;
     connAttemptGap?: number;
 }
 declare type Start = {
-    type: "start";
+    type: 'start';
     ingestPoint: string;
     pageNo: number;
     timestamp: number;
+    url: string;
 } & Options;
 declare type Auth = {
-    type: "auth";
+    type: 'auth';
     token: string;
     beaconSizeLimit?: number;
 };
-export declare type WorkerMessageData = null | "stop" | Start | Auth | Array<{
-    _id: number;
-}>;
+export declare type WorkerMessageData = null | 'stop' | Start | Auth | Array<Message>;
 export {};