@highlight-run/rrweb 2.0.1 → 2.0.6

package/es/rrweb/packages/rrweb/src/plugins/console/record/index.js

@@ -1,134 +1,115 @@
-import { __values, __spreadArray, __read } from '../../../../ext/tslib/tslib.es6.js';
 import { patch } from '../../../utils.js';
 import { ErrorStackParser } from './error-stack-parser.js';
 import { stringify } from './stringify.js';
 
-var defaultLogOptions = {
-    level: [
-        'assert',
-        'clear',
-        'count',
-        'countReset',
-        'debug',
-        'dir',
-        'dirxml',
-        'error',
-        'group',
-        'groupCollapsed',
-        'groupEnd',
-        'info',
-        'log',
-        'table',
-        'time',
-        'timeEnd',
-        'timeLog',
-        'trace',
-        'warn',
-    ],
-    lengthThreshold: 1000,
-    logger: 'console',
-};
-function initLogObserver(cb, win, logOptions) {
-    var e_1, _a;
-    var loggerType = logOptions.logger;
-    if (!loggerType) {
-        return function () { };
-    }
-    var logger;
-    if (typeof loggerType === 'string') {
-        logger = win[loggerType];
-    }
-    else {
-        logger = loggerType;
-    }
-    var logCount = 0;
-    var cancelHandlers = [];
-    if (logOptions.level.includes('error')) {
-        if (window) {
-            var errorHandler_1 = function (event) {
-                var message = event.message, error = event.error;
-                var trace = ErrorStackParser.parse(error).map(function (stackFrame) { return stackFrame.toString(); });
-                var payload = [stringify(message, logOptions.stringifyOptions)];
-                cb({
-                    level: 'error',
-                    trace: trace,
-                    payload: payload,
-                });
-            };
-            window.addEventListener('error', errorHandler_1);
-            cancelHandlers.push(function () {
-                if (window)
-                    window.removeEventListener('error', errorHandler_1);
-            });
-        }
-    }
-    try {
-        for (var _b = __values(logOptions.level), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var levelType = _c.value;
-            cancelHandlers.push(replace(logger, levelType));
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return function () {
-        cancelHandlers.forEach(function (h) { return h(); });
-    };
-    function replace(_logger, level) {
-        var _this = this;
-        if (!_logger[level]) {
-            return function () { };
-        }
-        return patch(_logger, level, function (original) {
-            return function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
-                }
-                original.apply(_this, args);
-                try {
-                    var trace = ErrorStackParser.parse(new Error())
-                        .map(function (stackFrame) { return stackFrame.toString(); })
-                        .splice(1);
-                    var payload = args.map(function (s) {
-                        return stringify(s, logOptions.stringifyOptions);
-                    });
-                    logCount++;
-                    if (logCount < logOptions.lengthThreshold) {
-                        cb({
-                            level: level,
-                            trace: trace,
-                            payload: payload,
-                        });
-                    }
-                    else if (logCount === logOptions.lengthThreshold) {
-                        cb({
-                            level: 'warn',
-                            trace: [],
-                            payload: [
-                                stringify('The number of log records reached the threshold.'),
-                            ],
-                        });
-                    }
-                }
-                catch (error) {
-                    original.apply(void 0, __spreadArray(['rrweb logger error:', error], __read(args), false));
-                }
-            };
-        });
-    }
-}
-var PLUGIN_NAME = 'rrweb/console@1';
-var getRecordConsolePlugin = function (options) { return ({
-    name: PLUGIN_NAME,
-    observer: initLogObserver,
-    options: options
-        ? Object.assign({}, defaultLogOptions, options)
-        : defaultLogOptions,
-}); };
+const defaultLogOptions = {
+    level: [
+        'assert',
+        'clear',
+        'count',
+        'countReset',
+        'debug',
+        'dir',
+        'dirxml',
+        'error',
+        'group',
+        'groupCollapsed',
+        'groupEnd',
+        'info',
+        'log',
+        'table',
+        'time',
+        'timeEnd',
+        'timeLog',
+        'trace',
+        'warn',
+    ],
+    lengthThreshold: 1000,
+    logger: 'console',
+};
+function initLogObserver(cb, win, logOptions) {
+    const loggerType = logOptions.logger;
+    if (!loggerType) {
+        return () => { };
+    }
+    let logger;
+    if (typeof loggerType === 'string') {
+        logger = win[loggerType];
+    }
+    else {
+        logger = loggerType;
+    }
+    let logCount = 0;
+    const cancelHandlers = [];
+    if (logOptions.level.includes('error')) {
+        if (window) {
+            const errorHandler = (event) => {
+                const { message, error } = event;
+                const trace = ErrorStackParser.parse(error).map((stackFrame) => stackFrame.toString());
+                const payload = [stringify(message, logOptions.stringifyOptions)];
+                cb({
+                    level: 'error',
+                    trace,
+                    payload,
+                });
+            };
+            window.addEventListener('error', errorHandler);
+            cancelHandlers.push(() => {
+                if (window)
+                    window.removeEventListener('error', errorHandler);
+            });
+        }
+    }
+    for (const levelType of logOptions.level) {
+        cancelHandlers.push(replace(logger, levelType));
+    }
+    return () => {
+        cancelHandlers.forEach((h) => h());
+    };
+    function replace(_logger, level) {
+        if (!_logger[level]) {
+            return () => { };
+        }
+        return patch(_logger, level, (original) => {
+            return (...args) => {
+                original.apply(this, args);
+                try {
+                    const trace = ErrorStackParser.parse(new Error())
+                        .map((stackFrame) => stackFrame.toString())
+                        .splice(1);
+                    const payload = args.map((s) => stringify(s, logOptions.stringifyOptions));
+                    logCount++;
+                    if (logCount < logOptions.lengthThreshold) {
+                        cb({
+                            level,
+                            trace,
+                            payload,
+                        });
+                    }
+                    else if (logCount === logOptions.lengthThreshold) {
+                        cb({
+                            level: 'warn',
+                            trace: [],
+                            payload: [
+                                stringify('The number of log records reached the threshold.'),
+                            ],
+                        });
+                    }
+                }
+                catch (error) {
+                    original('rrweb logger error:', error, ...args);
+                }
+            };
+        });
+    }
+}
+const PLUGIN_NAME = 'rrweb/console@1';
+const getRecordConsolePlugin = (options) => ({
+    name: PLUGIN_NAME,
+    observer: initLogObserver,
+    options: options
+        ? Object.assign({}, defaultLogOptions, options)
+        : defaultLogOptions,
+});
 
 export { PLUGIN_NAME, getRecordConsolePlugin };

package/es/rrweb/packages/rrweb/src/plugins/console/record/stringify.js

@@ -1,141 +1,128 @@
-import { __values } from '../../../../ext/tslib/tslib.es6.js';
-
-function pathToSelector(node) {
-    if (!node || !node.outerHTML) {
-        return '';
-    }
-    var path = '';
-    while (node.parentElement) {
-        var name_1 = node.localName;
-        if (!name_1) {
-            break;
-        }
-        name_1 = name_1.toLowerCase();
-        var parent_1 = node.parentElement;
-        var domSiblings = [];
-        if (parent_1.children && parent_1.children.length > 0) {
-            for (var i = 0; i < parent_1.children.length; i++) {
-                var sibling = parent_1.children[i];
-                if (sibling.localName && sibling.localName.toLowerCase) {
-                    if (sibling.localName.toLowerCase() === name_1) {
-                        domSiblings.push(sibling);
-                    }
-                }
-            }
-        }
-        if (domSiblings.length > 1) {
-            name_1 += ':eq(' + domSiblings.indexOf(node) + ')';
-        }
-        path = name_1 + (path ? '>' + path : '');
-        node = parent_1;
-    }
-    return path;
-}
-function isObject(obj) {
-    return Object.prototype.toString.call(obj) === '[object Object]';
-}
-function isObjTooDeep(obj, limit) {
-    var e_1, _a;
-    if (limit === 0) {
-        return true;
-    }
-    var keys = Object.keys(obj);
-    try {
-        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-            var key = keys_1_1.value;
-            if (isObject(obj[key]) && isObjTooDeep(obj[key], limit - 1)) {
-                return true;
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return false;
-}
-function stringify(obj, stringifyOptions) {
-    var options = {
-        numOfKeysLimit: 50,
-        depthOfLimit: 4,
-    };
-    Object.assign(options, stringifyOptions);
-    var stack = [];
-    var keys = [];
-    return JSON.stringify(obj, function (key, value) {
-        if (stack.length > 0) {
-            var thisPos = stack.indexOf(this);
-            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
-            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
-            if (~stack.indexOf(value)) {
-                if (stack[0] === value) {
-                    value = '[Circular ~]';
-                }
-                else {
-                    value =
-                        '[Circular ~.' +
-                            keys.slice(0, stack.indexOf(value)).join('.') +
-                            ']';
-                }
-            }
-        }
-        else {
-            stack.push(value);
-        }
-        if (value === null || value === undefined) {
-            return value;
-        }
-        if (shouldIgnore(value)) {
-            return toString(value);
-        }
-        if (value instanceof Event) {
-            var eventResult = {};
-            for (var eventKey in value) {
-                var eventValue = value[eventKey];
-                if (Array.isArray(eventValue)) {
-                    eventResult[eventKey] = pathToSelector(eventValue.length ? eventValue[0] : null);
-                }
-                else {
-                    eventResult[eventKey] = eventValue;
-                }
-            }
-            return eventResult;
-        }
-        else if (value instanceof Node) {
-            if (value instanceof HTMLElement) {
-                return value ? value.outerHTML : '';
-            }
-            return value.nodeName;
-        }
-        else if (value instanceof Error) {
-            return value.stack
-                ? value.stack + '\nEnd of stack for Error object'
-                : value.name + ': ' + value.message;
-        }
-        return value;
-    });
-    function shouldIgnore(_obj) {
-        if (isObject(_obj) && Object.keys(_obj).length > options.numOfKeysLimit) {
-            return true;
-        }
-        if (typeof _obj === 'function') {
-            return true;
-        }
-        if (isObject(_obj) && isObjTooDeep(_obj, options.depthOfLimit)) {
-            return true;
-        }
-        return false;
-    }
-    function toString(_obj) {
-        var str = _obj.toString();
-        if (options.stringLengthLimit && str.length > options.stringLengthLimit) {
-            str = "".concat(str.slice(0, options.stringLengthLimit), "...");
-        }
-        return str;
-    }
+function pathToSelector(node) {
+    if (!node || !node.outerHTML) {
+        return '';
+    }
+    let path = '';
+    while (node.parentElement) {
+        let name = node.localName;
+        if (!name) {
+            break;
+        }
+        name = name.toLowerCase();
+        const parent = node.parentElement;
+        const domSiblings = [];
+        if (parent.children && parent.children.length > 0) {
+            for (let i = 0; i < parent.children.length; i++) {
+                const sibling = parent.children[i];
+                if (sibling.localName && sibling.localName.toLowerCase) {
+                    if (sibling.localName.toLowerCase() === name) {
+                        domSiblings.push(sibling);
+                    }
+                }
+            }
+        }
+        if (domSiblings.length > 1) {
+            name += ':eq(' + domSiblings.indexOf(node) + ')';
+        }
+        path = name + (path ? '>' + path : '');
+        node = parent;
+    }
+    return path;
+}
+function isObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+}
+function isObjTooDeep(obj, limit) {
+    if (limit === 0) {
+        return true;
+    }
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (isObject(obj[key]) && isObjTooDeep(obj[key], limit - 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+function stringify(obj, stringifyOptions) {
+    const options = {
+        numOfKeysLimit: 50,
+        depthOfLimit: 4,
+    };
+    Object.assign(options, stringifyOptions);
+    const stack = [];
+    const keys = [];
+    return JSON.stringify(obj, function (key, value) {
+        if (stack.length > 0) {
+            const thisPos = stack.indexOf(this);
+            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+            if (~stack.indexOf(value)) {
+                if (stack[0] === value) {
+                    value = '[Circular ~]';
+                }
+                else {
+                    value =
+                        '[Circular ~.' +
+                            keys.slice(0, stack.indexOf(value)).join('.') +
+                            ']';
+                }
+            }
+        }
+        else {
+            stack.push(value);
+        }
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (shouldIgnore(value)) {
+            return toString(value);
+        }
+        if (value instanceof Event) {
+            const eventResult = {};
+            for (const eventKey in value) {
+                const eventValue = value[eventKey];
+                if (Array.isArray(eventValue)) {
+                    eventResult[eventKey] = pathToSelector(eventValue.length ? eventValue[0] : null);
+                }
+                else {
+                    eventResult[eventKey] = eventValue;
+                }
+            }
+            return eventResult;
+        }
+        else if (value instanceof Node) {
+            if (value instanceof HTMLElement) {
+                return value ? value.outerHTML : '';
+            }
+            return value.nodeName;
+        }
+        else if (value instanceof Error) {
+            return value.stack
+                ? value.stack + '\nEnd of stack for Error object'
+                : value.name + ': ' + value.message;
+        }
+        return value;
+    });
+    function shouldIgnore(_obj) {
+        if (isObject(_obj) && Object.keys(_obj).length > options.numOfKeysLimit) {
+            return true;
+        }
+        if (typeof _obj === 'function') {
+            return true;
+        }
+        if (isObject(_obj) && isObjTooDeep(_obj, options.depthOfLimit)) {
+            return true;
+        }
+        return false;
+    }
+    function toString(_obj) {
+        let str = _obj.toString();
+        if (options.stringLengthLimit && str.length > options.stringLengthLimit) {
+            str = `${str.slice(0, options.stringLengthLimit)}...`;
+        }
+        return str;
+    }
 }
 
 export { stringify };