@openreplay/tracker 14.0.10-beta.1 → 14.0.10

package/lib/modules/conditionsManager.js

@@ -1,340 +0,0 @@
-export default class ConditionsManager {
-    constructor(app, startParams) {
-        this.app = app;
-        this.startParams = startParams;
-        this.conditions = [];
-        this.hasStarted = false;
-        this.createConditionFromFilter = (filter) => {
-            if (filter.value.length) {
-                const resultCondition = mapCondition(filter);
-                if (resultCondition.type) {
-                    return resultCondition;
-                }
-            }
-            return undefined;
-        };
-        this.durationInt = null;
-    }
-    setConditions(conditions) {
-        this.conditions = conditions;
-    }
-    async fetchConditions(projectId, token) {
-        try {
-            const r = await fetch(`${this.app.options.ingestPoint}/v1/web/conditions/${projectId}`, {
-                method: 'GET',
-                headers: {
-                    Authorization: `Bearer ${token}`,
-                },
-            });
-            const { conditions } = (await r.json());
-            const mappedConditions = [];
-            conditions.forEach((c) => {
-                const filters = c.filters;
-                filters.forEach((filter) => {
-                    let cond;
-                    if (filter.type === 'fetch') {
-                        cond = {
-                            type: 'network_request',
-                            subConditions: [],
-                            name: c.name,
-                        };
-                        filter.filters.forEach((f) => {
-                            const subCond = this.createConditionFromFilter(f);
-                            if (subCond) {
-                                ;
-                                cond.subConditions.push(subCond);
-                            }
-                        });
-                    }
-                    else {
-                        cond = this.createConditionFromFilter(filter);
-                    }
-                    if (cond) {
-                        if (cond.type === 'session_duration') {
-                            this.processDuration(cond.value[0], c.name);
-                        }
-                        mappedConditions.push({ ...cond, name: c.name });
-                    }
-                });
-            });
-            this.conditions = mappedConditions;
-        }
-        catch (e) {
-            this.app.debug.error('Critical: cannot fetch start conditions');
-        }
-    }
-    trigger(conditionName) {
-        if (this.hasStarted)
-            return;
-        try {
-            this.hasStarted = true;
-            void this.app.start(this.startParams, undefined, conditionName);
-        }
-        catch (e) {
-            this.app.debug.error(e);
-        }
-    }
-    processMessage(message) {
-        if (this.hasStarted)
-            return;
-        switch (message[0]) {
-            case 78 /* Type.JSException */:
-                this.jsExceptionEvent(message);
-                break;
-            case 27 /* Type.CustomEvent */:
-                this.customEvent(message);
-                break;
-            case 68 /* Type.MouseClick */:
-                this.clickEvent(message);
-                break;
-            case 122 /* Type.SetPageLocation */:
-                this.pageLocationEvent(message);
-                break;
-            case 83 /* Type.NetworkRequest */:
-                this.networkRequest(message);
-                break;
-            default:
-                break;
-        }
-    }
-    processFlags(flag) {
-        const flagConds = this.conditions.filter((c) => c.type === 'feature_flag');
-        if (flagConds.length) {
-            flagConds.forEach((flagCond) => {
-                const operator = operators[flagCond.operator];
-                if (operator && flag.find((f) => operator(f.key, flagCond.value))) {
-                    this.trigger(flagCond.name);
-                }
-            });
-        }
-    }
-    processDuration(durationMs, condName) {
-        this.durationInt = setInterval(() => {
-            const sessionLength = performance.now();
-            if (sessionLength > durationMs) {
-                this.trigger(condName);
-            }
-        }, 1000);
-        this.app.attachStopCallback(() => {
-            if (this.durationInt) {
-                clearInterval(this.durationInt);
-            }
-        });
-    }
-    networkRequest(message) {
-        // method - 2, url - 3, status - 6, duration - 8
-        const reqConds = this.conditions.filter((c) => c.type === 'network_request');
-        if (!reqConds.length)
-            return;
-        reqConds.forEach((reqCond) => {
-            const validSubConditions = reqCond.subConditions.filter((c) => c.operator !== 'isAny');
-            if (validSubConditions.length) {
-                const allPass = validSubConditions.every((subCond) => {
-                    let value;
-                    switch (subCond.key) {
-                        case 'url':
-                            value = message[3];
-                            break;
-                        case 'status':
-                            value = message[6];
-                            break;
-                        case 'method':
-                            value = message[2];
-                            break;
-                        case 'duration':
-                            value = message[8];
-                            break;
-                        default:
-                            break;
-                    }
-                    const operator = operators[subCond.operator];
-                    // @ts-ignore
-                    if (operator && operator(value, subCond.value)) {
-                        return true;
-                    }
-                });
-                if (allPass) {
-                    this.trigger(reqCond.name);
-                }
-            }
-            else if (validSubConditions.length === 0 && reqCond.subConditions.length) {
-                this.trigger(reqCond.name);
-            }
-        });
-    }
-    customEvent(message) {
-        // name - 1, payload - 2
-        const evConds = this.conditions.filter((c) => c.type === 'custom_event');
-        if (evConds.length) {
-            evConds.forEach((evCond) => {
-                const operator = operators[evCond.operator];
-                if (operator &&
-                    (operator(message[1], evCond.value) || operator(message[2], evCond.value))) {
-                    this.trigger(evCond.name);
-                }
-            });
-        }
-    }
-    clickEvent(message) {
-        // label - 3, selector - 4
-        const clickCond = this.conditions.filter((c) => c.type === 'click');
-        if (clickCond.length) {
-            clickCond.forEach((click) => {
-                const operator = operators[click.operator];
-                if (operator && (operator(message[3], click.value) || operator(message[4], click.value))) {
-                    this.trigger(click.name);
-                }
-            });
-        }
-    }
-    pageLocationEvent(message) {
-        // url - 1
-        const urlConds = this.conditions.filter((c) => c.type === 'visited_url');
-        if (urlConds) {
-            urlConds.forEach((urlCond) => {
-                const operator = operators[urlCond.operator];
-                if (operator && operator(message[1], urlCond.value)) {
-                    this.trigger(urlCond.name);
-                }
-            });
-        }
-    }
-    jsExceptionEvent(message) {
-        // name - 1, message - 2, payload - 3
-        const testedValues = [message[1], message[2], message[3]];
-        const exceptionConds = this.conditions.filter((c) => c.type === 'exception');
-        if (exceptionConds) {
-            exceptionConds.forEach((exceptionCond) => {
-                const operator = operators[exceptionCond.operator];
-                if (operator && testedValues.some((val) => operator(val, exceptionCond.value))) {
-                    this.trigger(exceptionCond.name);
-                }
-            });
-        }
-    }
-}
-const operators = {
-    is: (val, target) => target.some((t) => val.includes(t)),
-    isAny: () => true,
-    isNot: (val, target) => !target.some((t) => val.includes(t)),
-    contains: (val, target) => target.some((t) => val.includes(t)),
-    notContains: (val, target) => !target.some((t) => val.includes(t)),
-    startsWith: (val, target) => target.some((t) => val.startsWith(t)),
-    endsWith: (val, target) => target.some((t) => val.endsWith(t)),
-    greaterThan: (val, target) => val > target,
-    greaterOrEqual: (val, target) => val >= target,
-    lessOrEqual: (val, target) => val <= target,
-    lessThan: (val, target) => val < target,
-};
-const mapCondition = (condition) => {
-    const opMap = {
-        on: 'is',
-        notOn: 'isNot',
-        '\u003e': 'greaterThan',
-        '\u003c': 'lessThan',
-        '\u003d': 'is',
-        '\u003c=': 'lessOrEqual',
-        '\u003e=': 'greaterOrEqual',
-    };
-    const mapOperator = (operator) => {
-        const keys = Object.keys(opMap);
-        // @ts-ignore
-        if (keys.includes(operator))
-            return opMap[operator];
-    };
-    let con = {
-        type: '',
-        operator: '',
-        value: condition.value,
-        key: '',
-    };
-    switch (condition.type) {
-        case 'click':
-            con = {
-                type: 'click',
-                operator: mapOperator(condition.operator),
-                value: condition.value,
-                key: '',
-            };
-            break;
-        case 'location':
-            con = {
-                type: 'visited_url',
-                // @ts-ignore
-                operator: condition.operator,
-                value: condition.value,
-                key: '',
-            };
-            break;
-        case 'custom':
-            con = {
-                type: 'custom_event',
-                // @ts-ignore
-                operator: condition.operator,
-                value: condition.value,
-                key: '',
-            };
-            break;
-        case 'metadata':
-            con = {
-                // @ts-ignore
-                type: condition.source === 'featureFlag' ? 'feature_flag' : condition.type,
-                // @ts-ignore
-                operator: condition.operator,
-                value: condition.value,
-                key: '',
-            };
-            break;
-        case 'error':
-            con = {
-                type: 'exception',
-                // @ts-ignore
-                operator: condition.operator,
-                value: condition.value,
-                key: '',
-            };
-            break;
-        case 'duration':
-            con = {
-                type: 'session_duration',
-                // @ts-ignore
-                value: condition.value[0],
-                key: '',
-            };
-            break;
-        case 'fetchUrl':
-            con = {
-                type: 'network_request',
-                key: 'url',
-                operator: condition.operator,
-                value: condition.value,
-            };
-            break;
-        case 'fetchStatusCode':
-            con = {
-                type: 'network_request',
-                key: 'status',
-                operator: mapOperator(condition.operator),
-                value: condition.value,
-            };
-            break;
-        case 'fetchMethod':
-            con = {
-                type: 'network_request',
-                key: 'method',
-                operator: mapOperator(condition.operator),
-                value: condition.value,
-            };
-            break;
-        case 'fetchDuration':
-            con = {
-                type: 'network_request',
-                key: 'duration',
-                operator: mapOperator(condition.operator),
-                value: condition.value,
-            };
-            break;
-    }
-    // @ts-ignore
-    return con;
-};

package/lib/modules/connection.js

@@ -1,12 +0,0 @@
-import { ConnectionInformation } from '../app/messages.gen.js';
-export default function (app) {
-    const connection = navigator.connection ||
-        navigator.mozConnection ||
-        navigator.webkitConnection;
-    if (connection === undefined) {
-        return;
-    }
-    const sendConnectionInformation = () => app.send(ConnectionInformation(Math.round(connection.downlink * 1000), connection.type || 'unknown'));
-    sendConnectionInformation();
-    connection.addEventListener('change', sendConnectionInformation);
-}

package/lib/modules/console.js

@@ -1,124 +0,0 @@
-import { IN_BROWSER } from '../utils.js';
-import { ConsoleLog } from '../app/messages.gen.js';
-const printError = IN_BROWSER && 'InstallTrigger' in window // detect Firefox
-    ? (e) => e.message + '\n' + e.stack
-    : (e) => e.stack || e.message;
-function printString(arg) {
-    if (arg === undefined) {
-        return 'undefined';
-    }
-    if (arg === null) {
-        return 'null';
-    }
-    if (arg instanceof Error) {
-        return printError(arg);
-    }
-    if (Array.isArray(arg)) {
-        return `Array(${arg.length})`;
-    }
-    return String(arg);
-}
-function printFloat(arg) {
-    if (typeof arg !== 'number')
-        return 'NaN';
-    return arg.toString();
-}
-function printInt(arg) {
-    if (typeof arg !== 'number')
-        return 'NaN';
-    return Math.floor(arg).toString();
-}
-function printObject(arg) {
-    if (arg === undefined) {
-        return 'undefined';
-    }
-    if (arg === null) {
-        return 'null';
-    }
-    if (arg instanceof Error) {
-        return printError(arg);
-    }
-    if (Array.isArray(arg)) {
-        const length = arg.length;
-        const values = arg.slice(0, 10).map(printString).join(', ');
-        return `Array(${length})[${values}]`;
-    }
-    if (typeof arg === 'object') {
-        const res = [];
-        let i = 0;
-        for (const k in arg) {
-            if (++i === 10) {
-                break;
-            }
-            const v = arg[k];
-            res.push(k + ': ' + printString(v));
-        }
-        return '{' + res.join(', ') + '}';
-    }
-    return arg.toString();
-}
-function printf(args) {
-    if (typeof args[0] === 'string') {
-        args.unshift(args.shift().replace(/%(o|s|f|d|i)/g, (s, t) => {
-            const arg = args.shift();
-            if (arg === undefined)
-                return s;
-            switch (t) {
-                case 'o':
-                    return printObject(arg);
-                case 's':
-                    return printString(arg);
-                case 'f':
-                    return printFloat(arg);
-                case 'd':
-                case 'i':
-                    return printInt(arg);
-                default:
-                    return s;
-            }
-        }));
-    }
-    return args.map(printObject).join(' ');
-}
-const consoleMethods = ['log', 'info', 'warn', 'error', 'debug', 'assert'];
-export default function (app, opts) {
-    const options = Object.assign({
-        consoleMethods,
-        consoleThrottling: 30,
-    }, opts);
-    if (!Array.isArray(options.consoleMethods) || options.consoleMethods.length === 0) {
-        return;
-    }
-    const sendConsoleLog = app.safe((level, args) => app.send(ConsoleLog(level, printf(args))));
-    let n = 0;
-    const reset = () => {
-        n = 0;
-    };
-    app.attachStartCallback(reset);
-    app.ticker.attach(reset, 33, false);
-    const patchConsole = (console, ctx) => {
-        const handler = {
-            apply: function (target, thisArg, argumentsList) {
-                Reflect.apply(target, ctx, argumentsList);
-                n = n + 1;
-                if (n > options.consoleThrottling) {
-                    return;
-                }
-                else {
-                    sendConsoleLog(target.name, argumentsList);
-                }
-            },
-        };
-        options.consoleMethods.forEach((method) => {
-            if (consoleMethods.indexOf(method) === -1) {
-                app.debug.error(`OpenReplay: unsupported console method "${method}"`);
-                return;
-            }
-            const fn = ctx.console[method];
-            console[method] = new Proxy(fn, handler);
-        });
-    };
-    const patchContext = app.safe((context) => patchConsole(context.console, context));
-    patchContext(window);
-    app.observer.attachContextCallback(patchContext);
-}

package/lib/modules/constructedStyleSheets.js

@@ -1,133 +0,0 @@
-import { AdoptedSSReplaceURLBased, AdoptedSSInsertRuleURLBased, AdoptedSSAddOwner, AdoptedSSRemoveOwner, } from '../app/messages.gen.js';
-import { isRootNode } from '../app/guards.js';
-function hasAdoptedSS(node) {
-    return (isRootNode(node) &&
-        // @ts-ignore
-        !!node.adoptedStyleSheets);
-}
-// TODO: encapsulate to be init-ed on-start and join with cssrules.ts under one folder
-let _id = 0xf;
-export function nextID() {
-    return _id++;
-}
-export const styleSheetIDMap = new Map();
-export default function (app) {
-    if (app === null) {
-        return;
-    }
-    if (!hasAdoptedSS(document)) {
-        return;
-    }
-    const styleSheetIDMap = new Map();
-    const adoptedStyleSheetsOwnings = new Map();
-    const sendAdoptedStyleSheetsUpdate = (root) => setTimeout(() => {
-        let nodeID = app.nodes.getID(root);
-        if (root === document) {
-            nodeID = 0; // main document doesn't have nodeID. ID count starts from the documentElement
-        }
-        if (nodeID === undefined) {
-            return;
-        }
-        let pastOwning = adoptedStyleSheetsOwnings.get(nodeID);
-        if (!pastOwning) {
-            pastOwning = [];
-        }
-        const nowOwning = [];
-        const styleSheets = root.adoptedStyleSheets;
-        if (styleSheets && Symbol.iterator in styleSheets) {
-            for (const s of styleSheets) {
-                let sheetID = styleSheetIDMap.get(s);
-                const init = !sheetID;
-                if (!sheetID) {
-                    sheetID = nextID();
-                    styleSheetIDMap.set(s, sheetID);
-                }
-                if (!pastOwning.includes(sheetID)) {
-                    app.send(AdoptedSSAddOwner(sheetID, nodeID));
-                }
-                if (init) {
-                    const rules = s.cssRules;
-                    for (let i = 0; i < rules.length; i++) {
-                        app.send(AdoptedSSInsertRuleURLBased(sheetID, rules[i].cssText, i, app.getBaseHref()));
-                    }
-                }
-                nowOwning.push(sheetID);
-            }
-        }
-        if (Symbol.iterator in pastOwning) {
-            for (const sheetID of pastOwning) {
-                if (!nowOwning.includes(sheetID)) {
-                    app.send(AdoptedSSRemoveOwner(sheetID, nodeID));
-                }
-            }
-        }
-        adoptedStyleSheetsOwnings.set(nodeID, nowOwning);
-    }, 20); // Mysterious bug:
-    /* On the page https://explore.fast.design/components/fast-accordion
-      the only rule inside the only adoptedStyleSheet of the iframe-s document
-      gets changed during first milliseconds after the load.
-      However, none of the documented methods (replace, insertRule) is triggered.
-      The rule is not substituted (remains the same object), however the text gets changed.
-    */
-    function patchAdoptedStyleSheets(prototype) {
-        const nativeAdoptedStyleSheetsDescriptor = Object.getOwnPropertyDescriptor(prototype, 'adoptedStyleSheets');
-        if (nativeAdoptedStyleSheetsDescriptor) {
-            Object.defineProperty(prototype, 'adoptedStyleSheets', {
-                ...nativeAdoptedStyleSheetsDescriptor,
-                set: function (value) {
-                    // @ts-ignore
-                    const retVal = nativeAdoptedStyleSheetsDescriptor.set.call(this, value);
-                    sendAdoptedStyleSheetsUpdate(this);
-                    return retVal;
-                },
-            });
-        }
-    }
-    const patchContext = (context) => {
-        // @ts-ignore
-        if (context.__openreplay_adpss_patched__) {
-            return;
-        }
-        else {
-            // @ts-ignore
-            context.__openreplay_adpss_patched__ = true;
-        }
-        patchAdoptedStyleSheets(context.Document.prototype);
-        patchAdoptedStyleSheets(context.ShadowRoot.prototype);
-        //@ts-ignore TODO: upgrade ts to 4.8+
-        const { replace, replaceSync } = context.CSSStyleSheet.prototype;
-        //@ts-ignore
-        context.CSSStyleSheet.prototype.replace = function (text) {
-            return replace.call(this, text).then((sheet) => {
-                const sheetID = styleSheetIDMap.get(this);
-                if (sheetID) {
-                    app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
-                }
-                return sheet;
-            });
-        };
-        //@ts-ignore
-        context.CSSStyleSheet.prototype.replaceSync = function (text) {
-            const sheetID = styleSheetIDMap.get(this);
-            if (sheetID) {
-                app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
-            }
-            return replaceSync.call(this, text);
-        };
-    };
-    patchContext(window);
-    app.observer.attachContextCallback(app.safe(patchContext));
-    app.attachStopCallback(() => {
-        styleSheetIDMap.clear();
-        adoptedStyleSheetsOwnings.clear();
-    });
-    // So far main Document is not triggered with nodeCallbacks
-    app.attachStartCallback(() => {
-        sendAdoptedStyleSheetsUpdate(document);
-    });
-    app.nodes.attachNodeCallback((node) => {
-        if (hasAdoptedSS(node)) {
-            sendAdoptedStyleSheetsUpdate(node);
-        }
-    });
-}