@openreplay/tracker 7.0.2 → 8.0.0-beta.1

package/lib/index.js

@@ -20,6 +20,7 @@ import Fonts from './modules/fonts.js';
 import Network from './modules/network.js';
 import ConstructedStyleSheets from './modules/constructedStyleSheets.js';
 import Selection from './modules/selection.js';
+import Tabs from './modules/tabs.js';
 import { IN_BROWSER, deprecationWarn, DOCS_HOST } from './utils.js';
 const DOCS_SETUP = '/installation/javascript-sdk';
 function processOptions(obj) {
@@ -113,6 +114,7 @@ export default class API {
             Fonts(app);
             Network(app, options.network);
             Selection(app);
+            Tabs(app);
             window.__OPENREPLAY__ = this;
             if (options.autoResetOnWindowOpen) {
                 const wOpen = window.open;
@@ -137,7 +139,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: '7.0.2-beta.1',
+                trackerVersion: '8.0.0-beta.1',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)
@@ -183,6 +185,12 @@ export default class API {
         }
         return this.app.getSessionID();
     }
+    getTabId() {
+        if (this.app === null) {
+            return null;
+        }
+        return this.app.getTabId();
+    }
     sessionID() {
         deprecationWarn("'sessionID' method", "'getSessionID' method", '/');
         return this.getSessionID();

package/lib/modules/network.js

@@ -158,7 +158,7 @@ export default function (app, opts = {}) {
             xhr.addEventListener('load', app.safe((e) => {
                 const { headers: reqHs, body: reqBody } = getXHRRequestDataObject(xhr);
                 const duration = startTime > 0 ? e.timeStamp - startTime : 0;
-                const hString = xhr.getAllResponseHeaders() || ''; // might be null (though only if no response received though)
+                const hString = xhr.getAllResponseHeaders() || ''; // might be null (only if no response received though)
                 const headersArr = hString.trim().split(/[\r\n]+/);
                 const headerMap = {};
                 headersArr.forEach(function (line) {

package/lib/modules/tabs.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/lib/modules/tabs.js

@@ -0,0 +1,10 @@
+import { TabChange } from '../app/messages.gen.js';
+export default function (app) {
+    function changeTab() {
+        if (!document.hidden) {
+            app.debug.log('Openreplay: tab change to' + app.session.getTabId());
+            app.send(TabChange(app.session.getTabId()));
+        }
+    }
+    app.attachEventListener(window, 'focus', changeTab, false, false);
+}

package/lib/utils.d.ts

@@ -11,8 +11,8 @@ export declare const DOCS_HOST = "https://docs.openreplay.com";
 export declare function deprecationWarn(nameOfFeature: string, useInstead: string, docsPath?: string): void;
 export declare function getLabelAttribute(e: Element): string | null;
 export declare function hasOpenreplayAttribute(e: Element, attr: string): boolean;
-export declare function isIframeCrossdomain(e: HTMLIFrameElement): boolean;
 /**
  * checks if iframe is accessible
  **/
 export declare function canAccessIframe(iframe: HTMLIFrameElement): boolean;
+export declare function generateRandomId(len?: number): string;

package/lib/utils.js

@@ -59,15 +59,6 @@ export function hasOpenreplayAttribute(e, attr) {
     }
     return false;
 }
-export function isIframeCrossdomain(e) {
-    var _a;
-    try {
-        return ((_a = e.contentWindow) === null || _a === void 0 ? void 0 : _a.location.href) !== window.location.href;
-    }
-    catch (e) {
-        return true;
-    }
-}
 /**
  * checks if iframe is accessible
  **/
@@ -79,3 +70,14 @@ export function canAccessIframe(iframe) {
         return false;
     }
 }
+function dec2hex(dec) {
+    return dec.toString(16).padStart(2, '0');
+}
+export function generateRandomId(len) {
+    const arr = new Uint8Array((len || 40) / 2);
+    // msCrypto = IE11
+    // @ts-ignore
+    const safeCrypto = window.crypto || window.msCrypto;
+    safeCrypto.getRandomValues(arr);
+    return Array.from(arr, dec2hex).join('');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openreplay/tracker",
   "description": "The OpenReplay tracker main package",
-  "version": "7.0.2",
+  "version": "8.0.0-beta.1",
   "keywords": [
     "logging",
     "replay"
@@ -22,7 +22,9 @@
     "build": "npm run clean && npm run tscRun && npm run rollup && npm run compile",
     "prepare": "cd ../../ && husky install tracker/.husky/",
     "lint-front": "lint-staged",
-    "test": "jest"
+    "test": "jest --coverage=false",
+    "test:ci": "jest --coverage=true",
+    "postversion": "npm run build"
   },
   "devDependencies": {
     "@babel/core": "^7.10.2",

package/cjs/vendors/finder/finder.d.ts

@@ -1,12 +0,0 @@
-export type Options = {
-    root: Element;
-    idName: (name: string) => boolean;
-    className: (name: string) => boolean;
-    tagName: (name: string) => boolean;
-    attr: (name: string, value: string) => boolean;
-    seedMinLength: number;
-    optimizedMinLength: number;
-    threshold: number;
-    maxNumberOfTries: number;
-};
-export declare function finder(input: Element, options?: Partial<Options>): string;

package/cjs/vendors/finder/finder.js

@@ -1,352 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.finder = void 0;
-var Limit;
-(function (Limit) {
-    Limit[Limit["All"] = 0] = "All";
-    Limit[Limit["Two"] = 1] = "Two";
-    Limit[Limit["One"] = 2] = "One";
-})(Limit || (Limit = {}));
-let config;
-let rootDocument;
-function finder(input, options) {
-    if (input.nodeType !== Node.ELEMENT_NODE) {
-        throw new Error("Can't generate CSS selector for non-element node type.");
-    }
-    if ('html' === input.tagName.toLowerCase()) {
-        return 'html';
-    }
-    const defaults = {
-        root: document.body,
-        idName: (name) => true,
-        className: (name) => true,
-        tagName: (name) => true,
-        attr: (name, value) => false,
-        seedMinLength: 1,
-        optimizedMinLength: 2,
-        threshold: 1000,
-        maxNumberOfTries: 10000,
-    };
-    config = Object.assign(Object.assign({}, defaults), options);
-    rootDocument = findRootDocument(config.root, defaults);
-    let path = bottomUpSearch(input, Limit.All, () => bottomUpSearch(input, Limit.Two, () => bottomUpSearch(input, Limit.One)));
-    if (path) {
-        const optimized = sort(optimize(path, input));
-        if (optimized.length > 0) {
-            path = optimized[0];
-        }
-        return selector(path);
-    }
-    else {
-        throw new Error('Selector was not found.');
-    }
-}
-exports.finder = finder;
-function findRootDocument(rootNode, defaults) {
-    if (rootNode.nodeType === Node.DOCUMENT_NODE) {
-        return rootNode;
-    }
-    if (rootNode === defaults.root) {
-        return rootNode.ownerDocument;
-    }
-    return rootNode;
-}
-function bottomUpSearch(input, limit, fallback) {
-    let path = null;
-    const stack = [];
-    let current = input;
-    let i = 0;
-    while (current && current !== config.root.parentElement) {
-        let level = maybe(id(current)) ||
-            maybe(...attr(current)) ||
-            maybe(...classNames(current)) ||
-            maybe(tagName(current)) || [any()];
-        const nth = index(current);
-        if (limit === Limit.All) {
-            if (nth) {
-                level = level.concat(level.filter(dispensableNth).map((node) => nthChild(node, nth)));
-            }
-        }
-        else if (limit === Limit.Two) {
-            level = level.slice(0, 1);
-            if (nth) {
-                level = level.concat(level.filter(dispensableNth).map((node) => nthChild(node, nth)));
-            }
-        }
-        else if (limit === Limit.One) {
-            const [node] = (level = level.slice(0, 1));
-            if (nth && dispensableNth(node)) {
-                level = [nthChild(node, nth)];
-            }
-        }
-        for (const node of level) {
-            node.level = i;
-        }
-        stack.push(level);
-        if (stack.length >= config.seedMinLength) {
-            path = findUniquePath(stack, fallback);
-            if (path) {
-                break;
-            }
-        }
-        current = current.parentElement;
-        i++;
-    }
-    if (!path) {
-        path = findUniquePath(stack, fallback);
-    }
-    return path;
-}
-function findUniquePath(stack, fallback) {
-    const paths = sort(combinations(stack));
-    if (paths.length > config.threshold) {
-        return fallback ? fallback() : null;
-    }
-    for (const candidate of paths) {
-        if (unique(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function selector(path) {
-    let node = path[0];
-    let query = node.name;
-    for (let i = 1; i < path.length; i++) {
-        const level = path[i].level || 0;
-        if (node.level === level - 1) {
-            query = `${path[i].name} > ${query}`;
-        }
-        else {
-            query = `${path[i].name} ${query}`;
-        }
-        node = path[i];
-    }
-    return query;
-}
-function penalty(path) {
-    return path.map((node) => node.penalty).reduce((acc, i) => acc + i, 0);
-}
-function unique(path) {
-    switch (rootDocument.querySelectorAll(selector(path)).length) {
-        case 0:
-            throw new Error(`Can't select any node with this selector: ${selector(path)}`);
-        case 1:
-            return true;
-        default:
-            return false;
-    }
-}
-function id(input) {
-    const elementId = input.getAttribute('id');
-    if (elementId && config.idName(elementId)) {
-        return {
-            name: '#' + cssesc(elementId, { isIdentifier: true }),
-            penalty: 0,
-        };
-    }
-    return null;
-}
-function attr(input) {
-    const attrs = Array.from(input.attributes).filter((attr) => config.attr(attr.name, attr.value));
-    return attrs.map((attr) => ({
-        name: '[' + cssesc(attr.name, { isIdentifier: true }) + '="' + cssesc(attr.value) + '"]',
-        penalty: 0.5,
-    }));
-}
-function classNames(input) {
-    const names = Array.from(input.classList).filter(config.className);
-    return names.map((name) => ({
-        name: '.' + cssesc(name, { isIdentifier: true }),
-        penalty: 1,
-    }));
-}
-function tagName(input) {
-    const name = input.tagName.toLowerCase();
-    if (config.tagName(name)) {
-        return {
-            name,
-            penalty: 2,
-        };
-    }
-    return null;
-}
-function any() {
-    return {
-        name: '*',
-        penalty: 3,
-    };
-}
-function index(input) {
-    const parent = input.parentNode;
-    if (!parent) {
-        return null;
-    }
-    let child = parent.firstChild;
-    if (!child) {
-        return null;
-    }
-    let i = 0;
-    while (child) {
-        if (child.nodeType === Node.ELEMENT_NODE) {
-            i++;
-        }
-        if (child === input) {
-            break;
-        }
-        child = child.nextSibling;
-    }
-    return i;
-}
-function nthChild(node, i) {
-    return {
-        name: node.name + `:nth-child(${i})`,
-        penalty: node.penalty + 1,
-    };
-}
-function dispensableNth(node) {
-    return node.name !== 'html' && !node.name.startsWith('#');
-}
-function maybe(...level) {
-    const list = level.filter(notEmpty);
-    if (list.length > 0) {
-        return list;
-    }
-    return null;
-}
-function notEmpty(value) {
-    return value !== null && value !== undefined;
-}
-function combinations(stack, path = []) {
-    const paths = [];
-    if (stack.length > 0) {
-        for (const node of stack[0]) {
-            paths.push(...combinations(stack.slice(1, stack.length), path.concat(node)));
-        }
-    }
-    else {
-        paths.push(path);
-    }
-    return paths;
-}
-function sort(paths) {
-    return Array.from(paths).sort((a, b) => penalty(a) - penalty(b));
-}
-function optimize(path, input, scope = {
-    counter: 0,
-    visited: new Map(),
-}) {
-    const paths = [];
-    if (path.length > 2 && path.length > config.optimizedMinLength) {
-        for (let i = 1; i < path.length - 1; i++) {
-            if (scope.counter > config.maxNumberOfTries) {
-                return paths; // Okay At least I tried!
-            }
-            scope.counter += 1;
-            const newPath = [...path];
-            newPath.splice(i, 1);
-            const newPathKey = selector(newPath);
-            if (scope.visited.has(newPathKey)) {
-                return paths;
-            }
-            if (unique(newPath) && same(newPath, input)) {
-                paths.push(newPath);
-                scope.visited.set(newPathKey, true);
-                paths.push(...optimize(newPath, input, scope));
-            }
-        }
-    }
-    return paths;
-}
-function same(path, input) {
-    return rootDocument.querySelector(selector(path)) === input;
-}
-const regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
-const regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
-const regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
-const defaultOptions = {
-    escapeEverything: false,
-    isIdentifier: false,
-    quotes: 'single',
-    wrap: false,
-};
-function cssesc(string, opt = {}) {
-    const options = Object.assign(Object.assign({}, defaultOptions), opt);
-    if (options.quotes != 'single' && options.quotes != 'double') {
-        options.quotes = 'single';
-    }
-    const quote = options.quotes == 'double' ? '"' : "'";
-    const isIdentifier = options.isIdentifier;
-    const firstChar = string.charAt(0);
-    let output = '';
-    let counter = 0;
-    const length = string.length;
-    while (counter < length) {
-        const character = string.charAt(counter++);
-        let codePoint = character.charCodeAt(0);
-        let value = void 0;
-        // If it’s not a printable ASCII character…
-        if (codePoint < 0x20 || codePoint > 0x7e) {
-            if (codePoint >= 0xd800 && codePoint <= 0xdbff && counter < length) {
-                // It’s a high surrogate, and there is a next character.
-                const extra = string.charCodeAt(counter++);
-                if ((extra & 0xfc00) == 0xdc00) {
-                    // next character is low surrogate
-                    codePoint = ((codePoint & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
-                }
-                else {
-                    // It’s an unmatched surrogate; only append this code unit, in case
-                    // the next code unit is the high surrogate of a surrogate pair.
-                    counter--;
-                }
-            }
-            value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-        }
-        else {
-            if (options.escapeEverything) {
-                if (regexAnySingleEscape.test(character)) {
-                    value = '\\' + character;
-                }
-                else {
-                    value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-                }
-            }
-            else if (/[\t\n\f\r\x0B]/.test(character)) {
-                value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
-            }
-            else if (character == '\\' ||
-                (!isIdentifier &&
-                    ((character == '"' && quote == character) || (character == "'" && quote == character))) ||
-                (isIdentifier && regexSingleEscape.test(character))) {
-                value = '\\' + character;
-            }
-            else {
-                value = character;
-            }
-        }
-        output += value;
-    }
-    if (isIdentifier) {
-        if (/^-[-\d]/.test(output)) {
-            output = '\\-' + output.slice(1);
-        }
-        else if (/\d/.test(firstChar)) {
-            output = '\\3' + firstChar + ' ' + output.slice(1);
-        }
-    }
-    // Remove spaces after `\HEX` escapes that are not followed by a hex digit,
-    // since they’re redundant. Note that this is only possible if the escape
-    // sequence isn’t preceded by an odd number of backslashes.
-    output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
-        if ($1 && $1.length % 2) {
-            // It’s not safe to remove the space, so don’t.
-            return $0;
-        }
-        // Strip the space.
-        return ($1 || '') + $2;
-    });
-    if (!isIdentifier && options.wrap) {
-        return quote + output + quote;
-    }
-    return output;
-}

package/lib/vendors/finder/finder.d.ts

@@ -1,12 +0,0 @@
-export type Options = {
-    root: Element;
-    idName: (name: string) => boolean;
-    className: (name: string) => boolean;
-    tagName: (name: string) => boolean;
-    attr: (name: string, value: string) => boolean;
-    seedMinLength: number;
-    optimizedMinLength: number;
-    threshold: number;
-    maxNumberOfTries: number;
-};
-export declare function finder(input: Element, options?: Partial<Options>): string;