monitor-track 1.10.0

package/dist/cjs/index.js

@@ -0,0 +1,1485 @@
+'use strict';
+
+var axios = require('axios');
+var uuid = require('uuid');
+var uaParserJs = require('ua-parser-js');
+var rrweb = require('rrweb');
+var ErrorStackParser = require('error-stack-parser');
+var html2canvas = require('html2canvas');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var rrweb__namespace = /*#__PURE__*/_interopNamespace(rrweb);
+var ErrorStackParser__default = /*#__PURE__*/_interopDefaultLegacy(ErrorStackParser);
+var html2canvas__default = /*#__PURE__*/_interopDefaultLegacy(html2canvas);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const shuyunTrackId = 'shuyun-track-id';
+const shuyunTrackSessionId = 'shuyun-track-session-id';
+
+/*
+ * @Author: Mark.Zhang
+ * @Description 配置项相关参数及方法
+ */
+/**  */
+/**
+ * @description config配置项默认值
+ */
+const Config = {
+    reportUrl: '',
+    projectID: '',
+    maxLength: 1000,
+    spa: false,
+    hash: false,
+    enableBehavior: true,
+    enableError: true,
+    enableVisualTrack: false,
+    ignore: {
+        urls: [],
+        errors: [],
+        apis: [],
+    },
+};
+/**
+ * @description 设置config配置项
+ * @param config 配置项
+ */
+function setConfig(config) {
+    Object.assign(Config, config);
+}
+
+/*
+ * @Author: Mark.Zhang
+ * @Date: 2020-10-26 11:10:04
+ * @Description 资源加载错误及js错误相关的处理方法
+ */
+const eventsMatrix = [[]];
+rrweb__namespace.record({
+    emit(event, isCheckout) {
+        // isCheckout 是一个标识，告诉你重新制作了快照
+        if (isCheckout) {
+            eventsMatrix.push([]);
+        }
+        if (eventsMatrix.length > 2) {
+            eventsMatrix.shift();
+        }
+        const lastEvents = eventsMatrix[eventsMatrix.length - 1];
+        lastEvents.push(event);
+    },
+    // 每30秒重新制作快照
+    checkoutEveryNms: 30 * 1000,
+});
+/**
+ * @description 错误事件触发后的操作
+ */
+function handleError(event) {
+    setReportValue('type', 'error');
+    if (event.type === 'error') {
+        if (event instanceof ErrorEvent) {
+            setCaughtError(event);
+        }
+        else {
+            setResourceError(event);
+        }
+    }
+    else if (event.type === 'unhandledrejection') {
+        setPromiseError(event);
+    }
+}
+/**
+ * @description 设置错误信息
+ */
+function setCaughtError(event) {
+    var _a, _b;
+    if (ignoreError(event.message)) {
+        return;
+    }
+    let filename = event.filename, line = event.lineno, column = event.colno, functionName = '', stackFrame = JSON.stringify([]);
+    if (event.error && event.error.stack) {
+        const error = ErrorStackParser__default["default"].parse(event.error);
+        stackFrame = JSON.stringify(error);
+        const info = error.find((item) => item.fileName && !/node_modules|vendor|bundle/.test(item.fileName));
+        if (info) {
+            filename = info.fileName;
+            line = Number(info.lineNumber);
+            column = Number(info.columnNumber);
+            functionName = info.functionName || '';
+        }
+    }
+    setReportValue('error', {
+        subType: 'js',
+        line,
+        column,
+        message: event.message,
+        filename,
+        functionName,
+        stack: ((_b = (_a = event === null || event === void 0 ? void 0 : event.error) === null || _a === void 0 ? void 0 : _a.stack) === null || _b === void 0 ? void 0 : _b.substring(0, Config.maxLength)) || '',
+        stackFrame,
+        events: getUserEvents(false),
+    });
+    report(getReport());
+}
+/**
+ * @description 设置异步错误信息
+ */
+function setPromiseError(event) {
+    let message = event.reason;
+    if (event.reason && typeof event.reason === 'object') {
+        message = JSON.stringify(event.reason);
+        if (message === '{}') {
+            message = event.reason.stack;
+        }
+    }
+    if (ignoreError(message)) {
+        return;
+    }
+    setReportValue('error', {
+        subType: 'async',
+        message,
+        events: getUserEvents(false),
+    });
+    report(getReport());
+}
+/**
+ * @description 设置资源错误信息
+ */
+function setResourceError(event) {
+    const target = event.target;
+    if (ignoreError(target.outerHTML)) {
+        return;
+    }
+    setReportValue('error', {
+        subType: 'resource',
+        message: target.outerHTML,
+        filename: target.src || target.currentSrc,
+        stack: target.localName.toUpperCase().substring(0, Config.maxLength),
+        events: getUserEvents(false),
+    });
+    report(getReport());
+}
+/**
+ * 忽略的error
+ * @param errorMsg 错误信息
+ */
+function ignoreError(errorMsg) {
+    var _a;
+    const errors = ((_a = Config === null || Config === void 0 ? void 0 : Config.ignore) === null || _a === void 0 ? void 0 : _a.errors) || [];
+    const existIgnoreError = errors.findIndex((item) => {
+        if (typeof item === 'string') {
+            return item === errorMsg;
+        }
+        else if (Object.prototype.toString.call(item) === '[object Object]') {
+            if (item.regExp && typeof item.input === 'string') {
+                const regex = new RegExp(item.input, 'g');
+                return regex.test(errorMsg);
+            }
+            return false;
+        }
+        else {
+            return false;
+        }
+    });
+    return existIgnoreError > -1;
+}
+/**
+ * 获取用户最近得操作,视频录像时间应当在30秒到60秒之间
+ */
+let lastGetTime = Date.now(); //缓存操作录像，防止段时间内大量获取录像数据导滞内存溢出
+function getUserEvents(notUseCache) {
+    let events;
+    if (Date.now() - lastGetTime > 2000 || notUseCache) {
+        lastGetTime = Date.now();
+        if (eventsMatrix.length >= 2) {
+            const finalVideoData = eventsMatrix[eventsMatrix.length - 1];
+            events = JSON.stringify(eventsMatrix[eventsMatrix.length - 2].concat(finalVideoData));
+            if (events.length > 1024 * 1024 * 15 && JSON.stringify(finalVideoData).length > 1024 * 1024) {
+                //如果录像数据量太大且最后那个分片的数据量不算小，那么缩短上报的录像时长
+                events = JSON.stringify(eventsMatrix[eventsMatrix.length - 1]);
+            }
+        }
+        else {
+            events = JSON.stringify(eventsMatrix);
+        }
+    }
+    return events;
+}
+function getFullScreenShoot(filename) {
+    const name = filename || uuid.v4();
+    return html2canvas__default["default"](document.body).then(function (canvas) {
+        var _a;
+        const urlData = canvas.toDataURL('image/png', 1);
+        const bytes = window.atob(urlData.split(',')[1]);
+        const mime = (_a = urlData.split(',')[0].match(/:(.*?);/)) === null || _a === void 0 ? void 0 : _a[1];
+        const ab = new ArrayBuffer(bytes.length);
+        const ia = new Uint8Array(ab);
+        for (let i = 0; i < bytes.length; i++) {
+            ia[i] = bytes.charCodeAt(i);
+        }
+        const file = new File([ab], `${name}.png`, { type: mime });
+        return file;
+    });
+}
+
+/** 上报数据映射 */
+const reportMap = {
+    /** SDK 版本 */
+    version: '_v',
+    /** 项目ID */
+    projectID: 'pid',
+    /** location.host */
+    host: 'host',
+    /** 用户uuid */
+    uuid: '_id',
+    /** 上报日志的时间戳 */
+    time: 'time',
+    /** 源页面 */
+    originPage: 'o',
+    /** 当前页面 */
+    page: 'p',
+    /** 自定义payload */
+    customPayload: 'cP',
+    /** 信息类型 */
+    type: 't',
+    /** viewport的宽高 */
+    viewport: 'vp',
+    /** 屏幕宽高 */
+    screen: 'sc',
+    /** 页面title */
+    pageTitle: 'pt',
+    /** 页面referrer */
+    referrer: 'ref',
+    /** 页面编码 */
+    charset: 'char',
+    /** language */
+    language: 'lan',
+    /** vendor， 浏览器厂商 */
+    navigatorVendor: 'nV',
+    /** 网络连接类型 */
+    connectionType: 'cT',
+    /** 浏览器名称 */
+    browserName: 'bN',
+    /** 浏览器版本 */
+    browserVersion: 'bV',
+    /** 浏览器引擎名称 */
+    engineName: 'enN',
+    /** 浏览器引擎版本 */
+    engineVersion: 'enV',
+    /** 操作系统名称 */
+    osName: 'osN',
+    /** 操作系统版本 */
+    osVersion: 'osV',
+    pv: {
+        /** 子类型 */
+        subType: 'suT',
+        /** 停留时间 */
+        stayTime: 'sT',
+    },
+    error: {
+        /** 子类型 */
+        subType: 'suT',
+        /** 错误行 */
+        line: 'line',
+        /** 错误列 */
+        column: 'col',
+        /** 错误信息 */
+        message: 'msg',
+        /** 错误文件 */
+        filename: 'fil',
+        /** 错误函数名 */
+        functionName: 'fn',
+        /** 错误栈信息 */
+        stack: '_st',
+        /** 错误帧 */
+        stackFrame: '_sf',
+        /** 视频录制数据 */
+        events: 'evt',
+        /** 页面截图 */
+        picture: 'pic',
+    },
+    ua: {
+        /** 子类型 */
+        subType: 'suT',
+        /** x轴坐标 */
+        x: 'x',
+        /** y轴坐标 */
+        y: 'y',
+        /** 元素路径 */
+        path: 'path',
+    },
+    /** 性能数据 */
+    perf: {
+        navigation: {
+            /**
+           *一个无符号短整型，表示是如何导航到这个页面的。可能的值如下:
+            TYPE_NAVIGATE (0)
+            当前页面是通过点击链接，书签和表单提交，或者脚本操作，或者在url中直接输入地址，type值为0
+            TYPE_RELOAD (1)
+            点击刷新页面按钮或者通过Location.reload()方法显示的页面，type值为1
+            The page was accessed by clicking the Reload button or via the Location.reload() method.
+            TYPE_BACK_FORWARD (2)
+            页面通过历史记录和前进后退访问时。type值为2
+            TYPE_RESERVED (255)
+            任何其他方式，type值为255
+          */
+            type: 't',
+            /** 无符号短整型，表示在到达这个页面之前重定向了多少次。 */
+            redirectCount: 'rc',
+        },
+        memory: {
+            /** 上下文内可用堆的最大体积，以字节计算。 */
+            jsHeapSizeLimit: 'hsl',
+            /** 已分配的堆体积，以字节计算。 */
+            totalJSHeapSize: 'ths',
+            /** 当前 JS 堆活跃段（segment）的体积，以字节计算。 */
+            usedJSHeapSize: 'uhs',
+        },
+        /** 返回性能测量开始时的时间的高精度时间戳。 */
+        timeOrigin: 'to',
+        timing: {
+            /** 是一个无符号long long 型的毫秒数，返回浏览器与服务器之间的连接建立时的Unix毫秒时间戳。如果建立的是持久连接，则返回值等同于fetchStart属性的值。连接建立指的是所有握手和认证过程全部结束。 */
+            connectEnd: 'ce',
+            /** 是一个无符号long long 型的毫秒数，返回HTTP请求开始向服务器发送时的Unix毫秒时间戳。如果使用持久连接（persistent connection），则返回值等同于fetchStart属性的值 */
+            connectStart: 'cs',
+            /** 是一个无符号long long 型的毫秒数，返回当前文档解析完成，即Document.readyState 变为 'complete'且相对应的readystatechange (en-US) 被触发时的Unix毫秒时间戳。 */
+            domComplete: 'dc',
+            /** 是一个无符号long long 型的毫秒数，返回当所有需要立即执行的脚本已经被执行（不论执行顺序）时的Unix毫秒时间戳。 */
+            domContentLoadedEventEnd: 'scLee',
+            /** 是一个无符号long long 型的毫秒数，返回当解析器发送DOMContentLoaded (en-US) 事件，即所有需要被执行的脚本已经被解析时的Unix毫秒时间戳。 */
+            domContentLoadedEventStart: 'dcLes',
+            /** 是一个无符号long long 型的毫秒数，返回当前网页DOM结构结束解析、开始加载内嵌资源时（即Document.readyState属性变为“interactive”、相应的readystatechange (en-US)事件触发时）的Unix毫秒时间戳。 */
+            domInteractive: 'di',
+            /** 是一个无符号long long 型的毫秒数，返回当前网页DOM结构开始解析时（即Document.readyState属性变为“loading”、相应的 readystatechange (en-US)事件触发时）的Unix毫秒时间戳。 */
+            domLoading: 'dl',
+            /** 是一个无符号long long 型的毫秒数，表征了域名查询结束的UNIX时间戳。如果使用了持续连接(persistent connection)，或者这个信息存储到了缓存或者本地资源上，这个值将和 PerformanceTiming.fetchStart一致。 */
+            domainLookupEnd: 'dle',
+            /** 是一个无符号long long 型的毫秒数，表征了域名查询开始的UNIX时间戳。如果使用了持续连接(persistent connection)，或者这个信息存储到了缓存或者本地资源上，这个值将和 PerformanceTiming.fetchStart一致。 */
+            domainLookupStart: 'dls',
+            /** 是一个无符号long long 型的毫秒数，表征了浏览器准备好使用HTTP请求来获取(fetch)文档的UNIX时间戳。这个时间点会在检查任何应用缓存之前。 */
+            fetchStart: 'fs',
+            /** 是一个无符号long long 型的毫秒数，返回当load (en-US)事件结束，即加载事件完成时的Unix毫秒时间戳。如果这个事件还未被发送，或者尚未完成，它的值将会是0. */
+            loadEventEnd: 'lee',
+            /** 是一个无符号long long 型的毫秒数，返回该文档下，load (en-US)事件被发送时的Unix毫秒时间戳。如果这个事件还未被发送，它的值将会是0。 */
+            loadEventStart: 'les',
+            /** 是一个无符号long long 型的毫秒数，表征了从同一个浏览器上下文的上一个文档卸载(unload)结束时的UNIX时间戳。如果没有上一个文档，这个值会和PerformanceTiming.fetchStart相同 */
+            navigationStart: 'ns',
+            /** 是一个无符号long long 型的毫秒数，表征了最后一个HTTP重定向完成时（也就是说是HTTP响应的最后一个比特直接被收到的时间）的UNIX时间戳。如果没有重定向，或者重定向中的一个不同源，这个值会返回0. */
+            redirectEnd: 're',
+            /** 是一个无符号long long 型的毫秒数，表征了第一个HTTP重定向开始时的UNIX时间戳。如果没有重定向，或者重定向中的一个不同源，这个值会返回0. */
+            redirectStart: 'redS',
+            /** 是一个无符号long long 型的毫秒数，返回浏览器向服务器发出HTTP请求时（或开始读取本地缓存时）的Unix毫秒时间戳。 */
+            requestStart: 'reqS',
+            /** 是一个无符号long long 型的毫秒数，返回浏览器从服务器收到（或从本地缓存读取，或从本地资源读取）最后一个字节时（如果在此之前HTTP连接已经关闭，则返回关闭时）的Unix毫秒时间戳。 */
+            responseEnd: 'resE',
+            /** 是一个无符号long long 型的毫秒数，返回浏览器从服务器收到（或从本地缓存读取）第一个字节时的Unix毫秒时间戳。如果传输层在开始请求之后失败并且连接被重开，该属性将会被数制成新的请求的相对应的发起时间。 */
+            responseStart: 'resS',
+            /** 是一个无符号long long 型的毫秒数，返回浏览器与服务器开始安全链接的握手时的Unix毫秒时间戳。如果当前网页不要求安全连接，则返回0。 */
+            secureConnectionStart: 'scs',
+            /** 是一个无符号long long 型的毫秒数，表征了unload (en-US)事件处理完成时的UNIX时间戳。如果没有上一个文档，or if the previous document, or one of the needed redirects, is not of the same origin, 这个值会返回0. */
+            unloadEventEnd: 'uee',
+            /** 是一个无符号long long 型的毫秒数，表征了unload (en-US)事件抛出时的UNIX时间戳。如果没有上一个文档，or if the previous document, or one of the needed redirects, is not of the same origin, 这个值会返回0. */
+            unloadEventStart: 'ees',
+        },
+    },
+    /** api请求相关 */
+    req: {
+        /** 请求类型,xhr或fetch */
+        requestType: 'rT',
+        /** 请求地址 */
+        responseURL: 'url',
+        /** 请求结果 */
+        status: 'stat',
+        /** 请求耗时 */
+        loadTime: 'lT',
+        /** 请求状态 */
+        statusText: 'sT',
+        /** 上报原因, slow或failed */
+        reason: 're',
+        /** 上报时带上的详细信息 */
+        detail: 'de',
+    },
+    vD: {
+        /** 埋点名称 */
+        trackName: 'tN',
+        /** 埋点参数 */
+        params: 'params',
+    },
+    manualReport: 'mR',
+    lifeCycleId: 'li',
+    sessionId: 'sI',
+};
+const xhrFunc = (filename, userId, asyncUpdateId, file, res, callback, rest) => {
+    const formData = new FormData();
+    for (const i in rest) {
+        if (Object.prototype.hasOwnProperty.call(rest, i)) {
+            formData.append(i, rest[i]);
+        }
+    }
+    formData.append('filename', filename);
+    formData.append('asyncUpdateId', asyncUpdateId); //用于上传到oss后异步更新到db的id
+    formData.append('userId', userId);
+    formData.append('files', file);
+    const xhr = new XMLHttpRequest();
+    xhr.addEventListener('error', () => res(), false);
+    xhr.open('POST', Config.reportUrl);
+    xhr.onreadystatechange = function () {
+        var _a;
+        if (xhr.readyState === 4) {
+            if (xhr.status === 200) {
+                try {
+                    const response = xhr.responseText;
+                    const resp = JSON.parse(response);
+                    callback((_a = resp.result) === null || _a === void 0 ? void 0 : _a.response);
+                }
+                catch (_err) {
+                    //
+                }
+                res();
+            }
+            else {
+                res();
+            }
+        }
+    };
+    xhr.send(formData);
+};
+const ERROR_MESSAGE_MAP = {};
+function reportFunc(data) {
+    var _a, _b, _c;
+    const payload = convertToSchema(data, reportMap);
+    payload.time = new Date().getTime(); // 设置上报时间
+    let picturePromise = Promise.resolve();
+    let hasErrorEvent = false;
+    const filename = uuid.v4();
+    if (data.type === 'error') {
+        let message = ((_a = data.error) === null || _a === void 0 ? void 0 : _a.message) || 'default';
+        if (((_b = data.error) === null || _b === void 0 ? void 0 : _b.subType) === 'resource') {
+            message = 'resource';
+        }
+        if (ERROR_MESSAGE_MAP[message]) ;
+        else {
+            ERROR_MESSAGE_MAP[message] = true;
+            setTimeout(() => {
+                //节流效果，每隔3秒上报一次重复的错误录像和错误截图
+                delete ERROR_MESSAGE_MAP[message];
+            }, 3000);
+            const { p, pid, host, bN, pt } = payload;
+            if ((_c = data.error) === null || _c === void 0 ? void 0 : _c.events) {
+                hasErrorEvent = true;
+                const errorEvent = data.error.events;
+                const delayTime = Math.ceil(Math.random() * 10000);
+                setTimeout(() => {
+                    const blob = new Blob([errorEvent], { type: 'text/json' });
+                    return new Promise((res) => {
+                        xhrFunc(`${filename}.json`, data.uuid, filename, blob, res, () => { }, { p, pid, host, bN, pt });
+                    });
+                }, delayTime < 3500 ? 3500 : delayTime);
+            }
+            picturePromise = getFullScreenShoot(filename)
+                .then((file) => {
+                return new Promise((res) => {
+                    xhrFunc(file.name, data.uuid, filename, file, res, (result) => {
+                        payload.error.pic = result;
+                    }, { p, pid, host, bN, pt });
+                });
+            })
+                .catch((err) => {
+                payload.error.picError = (err === null || err === void 0 ? void 0 : err.stack) || (err === null || err === void 0 ? void 0 : err.toString());
+            });
+        }
+    }
+    return picturePromise
+        .then(() => {
+        var _a;
+        if ((_a = payload.error) === null || _a === void 0 ? void 0 : _a.evt)
+            delete payload.error.evt;
+        if (window && window.navigator && typeof window.navigator.sendBeacon === 'function') {
+            const formData = new FormData();
+            Object.keys(payload).forEach((key) => {
+                let value = payload[key];
+                if (value !== null && value !== undefined) {
+                    if (typeof value === 'object') {
+                        value = JSON.stringify(value);
+                    }
+                    formData.append(key, value);
+                }
+            });
+            //eventErrorFilename,将错误录像的文件名附在错误上报的埋点里，便于将错误录像上报回调地址异步的更新到db
+            if (hasErrorEvent)
+                formData.append('eef', filename);
+            window.navigator.sendBeacon(Config.reportUrl, formData);
+        }
+        else {
+            if (hasErrorEvent)
+                payload.eef = filename;
+            new Image().src = `${Config.reportUrl}?${serialize(payload)}`;
+        }
+    })
+        .catch((_err) => {
+        //
+    });
+}
+// 上报
+function report(data) {
+    return new Promise((res) => {
+        //在帧的空闲时间上报
+        const dataCopy = JSON.parse(JSON.stringify(data));
+        if (typeof window.requestIdleCallback === 'function') {
+            window.requestIdleCallback(() => reportFunc(dataCopy).then(res), { timeout: 2000 });
+        }
+        else {
+            setTimeout(() => reportFunc(dataCopy).then(res), 0);
+        }
+    });
+}
+/**
+ * @description 将数据转换成最终提交的数据，主要目的是简化数据的key的长度，从而降低荷载大小
+ * @param data 要转换的数据
+ * @param map 要转换的数据的字段映射
+ * @param redundancyData 冗余数据
+ */
+function convertToSchema(data, map, redundancyData) {
+    const reportData = {};
+    if (redundancyData) {
+        map = Object.assign(Object.assign({}, map), redundancyData);
+    }
+    for (const result of Object.entries(map)) {
+        const [key, mapKey] = result;
+        if (key === 'manualReport') {
+            reportData[mapKey] = data[key];
+        }
+        else {
+            //字段值为数组的场景，直接转换
+            if (typeof data[key] === 'object' && !Array.isArray(data[key])) {
+                if (data[key]) {
+                    if (redundancyData && Object.prototype.hasOwnProperty.call(redundancyData, key)) {
+                        reportData[key] = data[key];
+                    }
+                    else {
+                        reportData[key] = convertToSchema(data[key], map[key]);
+                    }
+                }
+                else {
+                    reportData[key] = data[key];
+                }
+            }
+            else {
+                // 排除undefined
+                if (data[key] !== undefined) {
+                    reportData[mapKey] = data[key];
+                }
+            }
+        }
+    }
+    return reportData;
+}
+
+/* eslint-disable prefer-rest-params */
+/** 路由栈数组，存储路由变化信息 */
+let routerStack = [];
+/** 路由触发的时间 */
+let time = 0;
+/**
+ * @description 派发pushState， replaceState 的监听
+ * @param type
+ */
+function _history(type) {
+    const origin = history[type];
+    return function () {
+        // @ts-ignore
+        const r = origin.apply(this, arguments);
+        const e = new Event(type);
+        // @ts-ignore
+        e.arguments = arguments;
+        window.dispatchEvent(e);
+        return r;
+    };
+}
+/**
+ * @description 处理history变化
+ * @param e history事件
+ */
+function handleHistoryChange(__e) {
+    visualTrackFunc();
+    setReport();
+}
+/**
+ * 设置信息并触发上报
+ */
+function setReport() {
+    let pageUrl = location.href;
+    /**
+     * 此判断的逻辑是因为spa且hash模式下，路由搜索参数更改也会触发handleHistoryChange事件
+     * 所以路由栈中的信息只保存无搜索参数的地址
+     */
+    if (Config.hash && Config.spa) {
+        const currentUrlSplit = location.href.split('#');
+        let currentUrlPostfix = '';
+        if (currentUrlSplit[1]) {
+            const index = currentUrlSplit[1].indexOf('?');
+            if (index > -1) {
+                currentUrlPostfix = currentUrlSplit[1].substring(0, index);
+            }
+            else {
+                currentUrlPostfix = currentUrlSplit[1];
+            }
+        }
+        const currentUrlResult = `${currentUrlSplit[0]}#${currentUrlPostfix}`;
+        pageUrl = currentUrlResult;
+    }
+    const { originPage, page } = setRouteStack(pageUrl);
+    // 愿页面等于当前页面，说明无路由变更。只有spa且hash模式下才会出现
+    if (originPage === page) {
+        return;
+    }
+    const currentTime = new Date().getTime();
+    // 页面停留时间
+    const stayTime = currentTime - time;
+    // 设置触发路由变化的时间
+    time = currentTime;
+    // 设置信息
+    setReportValue('originPage', originPage);
+    setReportValue('page', page);
+    setReportValue('type', 'pv');
+    setReportValue('pv', { stayTime });
+    // 上报数据
+    report(getReport());
+}
+function setPVTime() {
+    time = new Date().getTime();
+}
+/**
+ * @description 添加路由栈信息
+ * @param page 页面信息
+ */
+function setRouteStack(page) {
+    if (typeof page === 'string') {
+        routerStack.push(page);
+    }
+    else {
+        routerStack = routerStack.concat(page);
+    }
+    // 路由栈只需保留两个来作为源页面和当前页面
+    routerStack = routerStack.slice(-2);
+    return {
+        originPage: routerStack[0],
+        page: routerStack[1] || routerStack[0],
+    };
+}
+
+var version = "1.10.0";
+
+/*
+ * @Author: Mark.Zhang
+ * @Date: 2020-10-26 15:40:16
+ * @Description 全局配置项
+ */
+// 上报数据
+let Report = {
+    uuid: '',
+    projectID: '',
+    host: '',
+    originPage: '',
+    page: '',
+    time: 0,
+    browserName: '',
+    browserVersion: '',
+    engineName: '',
+    engineVersion: '',
+    language: '',
+    navigatorVendor: '',
+    connectionType: '2g',
+    osName: '',
+    osVersion: '',
+    type: 'init',
+    viewport: '',
+    screen: '',
+    version: '',
+    charset: '',
+    pageTitle: '',
+    referrer: '',
+    pv: null,
+    ua: null,
+    error: null,
+    dpr: 1,
+    perf: null,
+    vD: undefined,
+    manualReport: undefined,
+    lifeCycleId: uuid.v4(),
+    sessionId: getSessionId(),
+};
+/**
+ * @description 初始化上报数据并上报
+ */
+function initReport() {
+    if (document.readyState === 'complete') {
+        initReportFunc();
+    }
+    else {
+        // 注意：这里不要使用window.onload，因为一个项目window.onload只能用一次，如果这里用了就会影响宿主项目的功能
+        window.addEventListener('load', initReportFunc);
+    }
+}
+function initReportFunc() {
+    setRouteStack([location.href, location.href]);
+    setPVTime();
+    Report = Object.assign(Object.assign({}, getReport()), {
+        page: location.href,
+        originPage: location.href,
+        type: 'init',
+        perf: performance,
+        sessionId: getSessionId(),
+        lifeCycleId: uuid.v4(),
+    });
+    report(Report);
+}
+/**
+ * @description 设置Report的值
+ * @param key Report key
+ * @param value Report 值
+ */
+function setReportValue(key, value) {
+    if (Object.prototype.hasOwnProperty.call(Report, key)) {
+        if (['pv', 'ua', 'error', 'request'].includes(key)) {
+            Report = Object.assign(Object.assign({}, Report), {
+                pv: null,
+                ua: null,
+                error: null,
+                req: null,
+                manualReport: undefined,
+                perf: null,
+            });
+        }
+        Report[key] = value;
+    }
+}
+/**
+ * @description 获取上报数据
+ */
+function getReport() {
+    const nav = getNavigator();
+    const viewport = getViewport();
+    return Object.assign(Object.assign(Object.assign({}, Report), nav), {
+        version,
+        projectID: Config.projectID,
+        host: location.host,
+        uuid: getUid(),
+        viewport,
+        screen: `${screen.width} x ${screen.height}`,
+        pageTitle: document.title,
+        referrer: document.referrer,
+        charset: document.charset,
+        customPayload: Config.customPayload,
+        dpr: window.devicePixelRatio,
+    });
+}
+function ajaxEventTrigger(event) {
+    const ajaxEvent = new CustomEvent(event, {
+        detail: this,
+    });
+    window.dispatchEvent(ajaxEvent);
+}
+const OldXHR = window.XMLHttpRequest;
+function newXHR() {
+    const realXHR = new OldXHR();
+    realXHR.addEventListener('loadstart', function () {
+        ajaxEventTrigger.call(this, 'ajaxLoadStart');
+    }, false);
+    realXHR.addEventListener('loadend', function () {
+        ajaxEventTrigger.call(this, 'ajaxLoadEnd');
+    }, false);
+    // 此处的捕获的异常会连日志接口也一起捕获，如果日志上报接口异常了，就会导致死循环了。
+    realXHR.onerror = function (e) {
+        // eslint-disable-next-line no-console
+        console.warn('realXHR.onerror, e', e);
+    };
+    return realXHR;
+}
+/**
+ * 页面接口请求监控
+ */
+const tempUrlInfo = {};
+const recordXMLHttpRequestLog = (XMLHttpRequestTimeout) => {
+    XMLHttpRequestTimeout = typeof XMLHttpRequestTimeout === 'number' ? XMLHttpRequestTimeout : 1000;
+    const timeRecordArray = [];
+    window.__XMLHttpRequest__ = window.XMLHttpRequest;
+    window.XMLHttpRequest = newXHR;
+    window.addEventListener('ajaxLoadStart', function (e) {
+        const tempObj = {
+            timeStamp: new Date().getTime(),
+            event: e,
+        };
+        timeRecordArray.push(tempObj);
+    });
+    window.addEventListener('ajaxLoadEnd', function () {
+        const timeRecordArrayCopy = [].concat(timeRecordArray);
+        for (let i = 0; i < timeRecordArrayCopy.length; i++) {
+            if (timeRecordArrayCopy[i].event.detail && timeRecordArrayCopy[i].event.detail.status > 0) {
+                const currentTime = new Date().getTime();
+                const { responseURL, status, statusText, timeStamp } = timeRecordArrayCopy[i].event.detail;
+                const previousTime = timeStamp || timeRecordArrayCopy[i].timeStamp;
+                const loadTime = currentTime - previousTime;
+                const request = {
+                    requestType: 'xhr',
+                    responseURL,
+                    status,
+                    loadTime,
+                    statusText,
+                    reason: '',
+                    detail: '',
+                };
+                if (loadTime && loadTime > XMLHttpRequestTimeout) {
+                    request.reason = 'slow';
+                    request.detail = `request is too slow, XMLHttpRequestTimeout: ${XMLHttpRequestTimeout}`;
+                }
+                else if (status && status >= 300 && statusText && statusText.toLowerCase() !== 'ok') {
+                    request.reason = 'failed';
+                    request.detail = `request is failed, status: ${status}, statusText: ${statusText}`;
+                }
+                else ;
+                if (request.reason) {
+                    if (!tempUrlInfo[responseURL]) {
+                        tempUrlInfo[responseURL] = true;
+                        setTimeout(() => {
+                            delete tempUrlInfo[responseURL];
+                        }, 10);
+                        setReportValue('error', null);
+                        report(Object.assign(Object.assign({}, getReport()), {
+                            page: location.href,
+                            originPage: location.href,
+                            type: 'request',
+                            req: request,
+                        }));
+                    }
+                }
+            }
+            // 当前请求成功后就在数组中移除掉
+            timeRecordArray.splice(i, 1);
+        }
+    });
+};
+const hackFetch = (XMLHttpRequestTimeout) => {
+    XMLHttpRequestTimeout = typeof XMLHttpRequestTimeout === 'number' ? XMLHttpRequestTimeout : 1000;
+    if (typeof window.fetch === 'function') {
+        const __fetch__ = window.fetch;
+        window.__fetch__ = __fetch__;
+        window.fetch = function (t, ...args) {
+            const begin = Date.now();
+            //禁用数组的扩展运算符,否则portal的生产环境会报Uncaught TypeError: Object(...) is not a function,
+            //编译后的__spreadArray函数有问题,而这个函数来自于tslib.具体报错原因不知.
+            //其他平台使用数组的扩展运算符没有问题,比如前端监控平台的管理界面
+            const params = [].concat(t).concat(args);
+            return __fetch__
+                .apply(window, params)
+                .then(function (res) {
+                const response = res.clone();
+                const headers = response.headers;
+                if (headers && typeof headers.get === 'function') {
+                    const ct = headers.get('content-type');
+                    if (ct && !/(text)|(json)/.test(ct)) {
+                        return res;
+                    }
+                }
+                const loadTime = Date.now() - begin;
+                response
+                    .text()
+                    .then(function (result) {
+                    const { url, status, statusText, ok } = response;
+                    const request = {
+                        requestType: 'fetch',
+                        responseURL: url,
+                        status,
+                        loadTime,
+                        statusText,
+                        reason: '',
+                        detail: '',
+                    };
+                    if (!ok || status >= 300) {
+                        request.reason = 'failed';
+                        request.detail = `request is failed, status: ${status}, statusText: ${statusText}`;
+                    }
+                    else if (loadTime > XMLHttpRequestTimeout) {
+                        request.reason = 'slow';
+                        request.detail = `request is too slow, XMLHttpRequestTimeout: ${XMLHttpRequestTimeout}, result: ${result === null || result === void 0 ? void 0 : result.slice(0, 500)}`;
+                    }
+                    if (request.reason) {
+                        if (!tempUrlInfo[url]) {
+                            tempUrlInfo[url] = true;
+                            setTimeout(() => {
+                                delete tempUrlInfo[url];
+                            }, 10);
+                            setReportValue('error', null);
+                            report(Object.assign(Object.assign({}, getReport()), {
+                                page: location.href,
+                                originPage: location.href,
+                                type: 'request',
+                                req: request,
+                            }));
+                        }
+                    }
+                })
+                    .catch((err) => {
+                    // eslint-disable-next-line no-console
+                    console.log('hackFetch response.text() err', err);
+                });
+                return res;
+            })
+                .catch((err) => {
+                // eslint-disable-next-line no-console
+                console.log('hackFetch err', err);
+            });
+        };
+    }
+};
+
+/*
+ * @Author: Mark.Zhang
+ * @Date: 2020-10-26 11:10:04
+ * @Description 用户行为处理方法
+ */
+/**
+ * @description 点击事件触发后的操作
+ */
+function handleClick(event) {
+    const target = event.target;
+    if (target.nodeName === 'INPUT' || target.nodeName === 'TEXTAREA') {
+        return;
+    }
+    const path = getElmPath(target);
+    if (path) {
+        setReportValue('type', 'ua');
+        setReportValue('ua', {
+            subType: 'ui.click',
+            x: event.x,
+            y: event.y,
+            path,
+        });
+        report(getReport());
+    }
+}
+/**
+ * @description 点击触发失焦后的操作
+ */
+function handleBlur(event) {
+    const target = event.target;
+    if (target.nodeName !== 'INPUT' && target.nodeName !== 'TEXTAREA') {
+        return;
+    }
+    const path = getElmPath(target);
+    if (path) {
+        setReportValue('type', 'ua');
+        setReportValue('ua', {
+            subType: 'ui.blur',
+            x: event.x,
+            y: event.y,
+            path,
+            value: target.value,
+        });
+        report(getReport());
+    }
+}
+/**
+ * @description 滚动的操作
+ */
+let timeout$1;
+function handleScroll(_event) {
+    clearTimeout(timeout$1);
+    timeout$1 = setTimeout(() => {
+        setReportValue('type', 'ua');
+        setReportValue('ua', {
+            subType: 'ui.scroll',
+        });
+        report(getReport());
+    }, 1000);
+}
+
+const parser = new uaParserJs.UAParser();
+/**
+ * @description 获取uuid
+ */
+function getUid() {
+    let uid = localStorage.getItem(shuyunTrackId) || '';
+    if (!uid) {
+        uid = uuid.v4();
+        localStorage.setItem(shuyunTrackId, uid);
+    }
+    return uid;
+}
+/**
+ * @description 获取session id
+ */
+function getSessionId() {
+    const sessionId = sessionStorage.getItem(shuyunTrackSessionId);
+    if (sessionId) {
+        return sessionId;
+    }
+    else {
+        const id = uuid.v4();
+        sessionStorage.setItem(shuyunTrackSessionId, id);
+        return id;
+    }
+}
+/**
+ * @description 获取浏览器信息
+ */
+function getNavigator() {
+    var _a;
+    const uaResult = parser.getResult();
+    return {
+        language: navigator.language,
+        navigatorVendor: navigator.vendor,
+        connectionType: ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType) || '2g',
+        browserName: uaResult.browser.name || '',
+        browserVersion: uaResult.browser.version || '',
+        engineName: uaResult.engine.name || '',
+        engineVersion: uaResult.engine.version || '',
+        osName: uaResult.os.name || '',
+        osVersion: uaResult.os.version || '',
+    };
+}
+/**
+ * @description 获取viewport的宽高
+ */
+function getViewport() {
+    const w = document.documentElement.clientWidth || document.body.clientWidth;
+    const h = document.documentElement.clientHeight || document.body.clientHeight;
+    return `${w} x ${h}`;
+}
+/**
+ * @description 获取元素路径，最多保留5层
+ * @param e
+ */
+const getElmPath = function (target) {
+    if (!target || target.nodeType !== 1) {
+        return '';
+    }
+    const ret = [];
+    // 层数，最多5层
+    let deepLength = 0;
+    // 元素
+    let elm = '';
+    if (typeof target.innerText === 'string') {
+        ret.push(`(${target.innerText.substr(0, 50)})`);
+    }
+    for (let t = target || null; t && deepLength++ < 5 && !((elm = normalTarget(t)) === 'html');) {
+        // eslint-disable-next-line no-sequences
+        ret.push(elm), (t = t.parentNode);
+    }
+    return ret.reverse().join(' > ');
+};
+/**
+ * @description 处理html node
+ * @param e
+ */
+const normalTarget = function (target) {
+    let t, n, r, a, i;
+    const o = [];
+    if (!target || !target.tagName) {
+        return '';
+    }
+    o.push(target.tagName.toLowerCase());
+    if (target.id) {
+        o.push('#'.concat(target.id));
+    }
+    if ((t = target.className) && Object.prototype.toString.call(t) === '[object String]') {
+        for (n = t.split(/\s+/), i = 0; i < n.length; i++) {
+            // className包含active的不加入路径
+            if (n[i].indexOf('active') < 0)
+                o.push('.'.concat(n[i]));
+        }
+    }
+    const s = ['type', 'name', 'title', 'alt'];
+    for (i = 0; i < s.length; i++) {
+        r = s[i];
+        if ((a = target.getAttribute(r))) {
+            o.push('['.concat(r, '="').concat(a, '"]'));
+        }
+    }
+    return o.join('');
+};
+/**
+ * @description 序列化对象
+ * @param obj
+ */
+function serialize(obj) {
+    const str = [];
+    for (const p in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, p) && typeof obj[p] !== 'undefined') {
+            const value = typeof obj[p] === 'object' ? JSON.stringify(obj[p]) : obj[p];
+            str.push(encodeURIComponent(p) + '=' + encodeURIComponent(value));
+        }
+    }
+    return str.join('&');
+}
+/**
+ * @description 注册事件监听
+ * @param event 事件
+ * @param fn 回调方法
+ */
+const on = function (event, fn) {
+    if (window.addEventListener) {
+        window.addEventListener(event, fn, true);
+    }
+    else {
+        window.attachEvent(`on${event}`, fn);
+    }
+};
+/**
+ * @description 移除事件监听
+ * @param event 事件
+ * @param fn 回调方法
+ */
+const off = function (event, fn) {
+    if (window.removeEventListener) {
+        return window.removeEventListener(event, fn);
+    }
+    else {
+        return window.detachEvent(`on${event}`, fn);
+    }
+};
+const formatTrackElementXPath = (xPath) => {
+    const result = [];
+    const array = xPath.split('/');
+    array.forEach((item) => {
+        if (!['svg', 'path', 'g', 'image', 'text', 'line', 'rect', 'polygon', 'circle', 'ellipse'].some((child) => {
+            if (item.toLowerCase().split('[')[0] === child) {
+                result.push(`/*[name()="${child}"]`);
+                return true;
+            }
+            else {
+                return false;
+            }
+        })) {
+            result.push(item);
+        }
+    });
+    return result.join('/');
+};
+const formatElementXPath = (info) => {
+    var _a;
+    let elementXPathValue = '';
+    const elementXPath = info.elementXPath;
+    if (elementXPath) {
+        const xpathElement = document.evaluate(formatTrackElementXPath(elementXPath), document).iterateNext();
+        elementXPathValue = xpathElement ? (_a = (xpathElement.textContent || xpathElement.value)) === null || _a === void 0 ? void 0 : _a.trim() : '';
+    }
+    return {
+        elementXPath,
+        elementXPathValue,
+    };
+};
+let existTrackListenEvent = {};
+const elements = [];
+let timeout;
+const visualTrackFunc = () => {
+    if (Config.enableVisualTrack) {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            timeout = null;
+            const url = location.href.split('?')[0];
+            axios__default["default"]
+                .get(`${Config.reportUrl.replace('/s/r', '')}/visual/get_data_list?url=${encodeURIComponent(url)}`)
+                .then((res) => {
+                var _a, _b;
+                const listData = (_b = (_a = res.data.result) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.dataList;
+                if (Array.isArray(listData)) {
+                    try {
+                        listData.forEach((item) => {
+                            if (item.trackType === 'mount') {
+                                visualReportEvent(item);
+                            }
+                            else {
+                                const element = document
+                                    .evaluate(formatTrackElementXPath(item.trackElementXPath), document)
+                                    .iterateNext();
+                                const key = url + item.trackElementXPath;
+                                if (element) {
+                                    if (!existTrackListenEvent[key]) {
+                                        existTrackListenEvent[key] = true;
+                                        elements.push(element);
+                                        //@ts-ignore
+                                        element.setAttribute('visual-track-data-attr', JSON.stringify(item));
+                                        element.addEventListener('click', clickEventFunc);
+                                    }
+                                }
+                                else {
+                                    const func = () => {
+                                        var _a;
+                                        const { browserName, browserVersion } = getNavigator();
+                                        const payload = {
+                                            projectID: Config.projectID,
+                                            version,
+                                            url,
+                                            trackElementXPath: item.trackElementXPath,
+                                            trackNameInfo: item.trackNameInfo,
+                                            params: item.params,
+                                            customPayload: Config.customPayload,
+                                            type: 'visual_track_xpath_not_found',
+                                            browser: `${browserName} - ${browserVersion}`,
+                                        };
+                                        if (typeof ((_a = window.navigator) === null || _a === void 0 ? void 0 : _a.sendBeacon) === 'function') {
+                                            const formData = new FormData();
+                                            for (const i in payload) {
+                                                if (Object.prototype.hasOwnProperty.call(payload, i)) {
+                                                    const value = payload[i];
+                                                    formData.append(i, value && typeof value === 'object' ? JSON.stringify(value) : value);
+                                                }
+                                            }
+                                            window.navigator.sendBeacon(Config.reportUrl, formData);
+                                        }
+                                        else {
+                                            new Image().src = `${Config.reportUrl}?${serialize(payload)}`;
+                                        }
+                                    };
+                                    if (typeof window.requestIdleCallback === 'function') {
+                                        window.requestIdleCallback(() => func(), { timeout: 2000 });
+                                    }
+                                    else {
+                                        setTimeout(() => func(), 0);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                    catch (err) {
+                        // eslint-disable-next-line no-console
+                        console.log('visual track evaluate err', err);
+                    }
+                }
+            });
+        }, 1000);
+    }
+};
+const visualReportEvent = (item) => {
+    var _a;
+    const { elementXPath, elementXPathValue } = formatElementXPath(item.trackNameInfo);
+    const visualTrackData = {
+        trackType: item.trackType,
+        trackName: elementXPath ? elementXPathValue : item.trackNameInfo.name,
+        params: (_a = item.params) === null || _a === void 0 ? void 0 : _a.map((child) => {
+            const { elementXPath, elementXPathValue } = formatElementXPath(child);
+            return {
+                name: child.name,
+                value: elementXPath ? elementXPathValue : child.value,
+            };
+        }),
+    };
+    setReportValue('type', 'visual');
+    setReportValue('vD', visualTrackData);
+    report(getReport());
+    setReportValue('vD', undefined);
+};
+const clickEventFunc = (e) => {
+    //@ts-ignore
+    const item = JSON.parse(e.target.getAttribute('visual-track-data-attr'));
+    visualReportEvent(item);
+};
+const initWindowObjectFunction = () => {
+    if (typeof window.manualReportTrackFunc === 'undefined') {
+        window.manualReportTrackFunc = (data) => {
+            if (Object.prototype.toString.call(data) !== '[object Object]') {
+                // eslint-disable-next-line no-console
+                console.warn('manualReportTrackFunc参数必须是一个对象！');
+            }
+            else {
+                setReportValue('type', 'manual');
+                setReportValue('manualReport', data);
+                report(getReport());
+                setReportValue('manualReport', undefined);
+            }
+        };
+    }
+    if (typeof window.getFullScreenShootFunc === 'undefined') {
+        //下载页面截图
+        window.getFullScreenShootFunc = (filename) => __awaiter(void 0, void 0, void 0, function* () {
+            const file = yield getFullScreenShoot(filename);
+            const url = window.URL.createObjectURL(file);
+            const tagA = document.createElement('a');
+            tagA.setAttribute('href', url);
+            tagA.setAttribute('download', file.name);
+            tagA.setAttribute('target', '_blank');
+            document.body.appendChild(tagA);
+            tagA.click();
+            document.body.removeChild(tagA);
+        });
+    }
+    if (typeof window.getRRWebUserEventsCaptureFunc === 'undefined') {
+        window.getRRWebUserEventsCaptureFunc = () => {
+            setReportValue('type', 'error');
+            setReportValue('error', {
+                subType: 'manual',
+                message: 'manual trigger',
+                events: getUserEvents(true),
+            });
+            report(getReport());
+        };
+    }
+};
+let prewHref = '';
+const handleLocationChange = (e) => {
+    const curHref = location.href;
+    // href中`？`后面的值改变，不触发后续动作
+    if (prewHref.split('?')[0] === curHref.split('?')[0]) {
+        return;
+    }
+    prewHref = curHref;
+    handleHistoryChange();
+    elements.forEach((element) => {
+        element === null || element === void 0 ? void 0 : element.removeEventListener('click', clickEventFunc);
+    });
+    //清空可视化埋点之前的数据
+    existTrackListenEvent = {};
+    elements.length = 0;
+    visualTrackFunc();
+};
+
+class Track {
+    constructor() {
+        this.visualTrack = () => {
+            window.onload = () => {
+                visualTrackFunc();
+            };
+        };
+    }
+    init(config) {
+        var _a;
+        // 是否开启日志收集
+        if (!config || !config.enable) {
+            return;
+        }
+        // 没有项目ID，则不监听任何事件
+        if (!config.projectID) {
+            // eslint-disable-next-line no-console
+            console.warn('缺少项目ID或token!');
+            return;
+        }
+        // 没有reportUrl
+        if (!config.reportUrl) {
+            // eslint-disable-next-line no-console
+            console.warn('缺少上报地址!');
+            return;
+        }
+        if (this.ignoreUrl(((_a = config === null || config === void 0 ? void 0 : config.ignore) === null || _a === void 0 ? void 0 : _a.urls) || [])) {
+            return;
+        }
+        setConfig(config);
+        initReport();
+        recordXMLHttpRequestLog(config.XMLHttpRequestTimeout);
+        hackFetch(config.XMLHttpRequestTimeout);
+        Config.spa && this.addListenRouterChange();
+        Config.enableBehavior && this.addListenUserActivity();
+        Config.enableError && this.addListenJSUncaught();
+        this.visualTrack();
+        this.addListenUnload();
+        initWindowObjectFunction();
+    }
+    /**
+     * @description 监听错误异常
+     */
+    addListenJSUncaught() {
+        on('error', handleError);
+        on('unhandledrejection', handleError);
+    }
+    /**
+     * @description 监听行为
+     */
+    addListenUserActivity() {
+        on('click', handleClick); // 非输入框点击
+        on('blur', handleBlur); // 输入框失焦
+        on('scroll', handleScroll); // 输入框失焦
+    }
+    /**
+     * @description 监听路由变化
+     */
+    addListenRouterChange() {
+        on('popstate', handleLocationChange);
+        // on('hashchange', pv.handleHashChange);  //触发hashchange的同时也会触发popstate
+        if (Config.spa && !Config.hash) {
+            history.pushState = _history('pushState');
+            history.replaceState = _history('replaceState');
+            on('pushState', handleLocationChange);
+            on('replaceState', handleLocationChange);
+        }
+    }
+    /**
+     * @description 页面将要关闭
+     */
+    addListenUnload() {
+        on('beforeunload', () => {
+            this.destroy();
+        });
+    }
+    /**
+     * 忽略的url
+     * @param urls
+     */
+    ignoreUrl(urls) {
+        const someUrl = urls.some((url) => location.href.includes(url));
+        return someUrl;
+    }
+    /**
+     * @description 销毁监听器
+     */
+    destroy() {
+        if (Config.spa) {
+            // off('hashchange', pv.handleHashChange);
+            off('pushState', handleHistoryChange);
+            off('popstate', handleHistoryChange);
+            off('replaceState', handleHistoryChange);
+        }
+        if (Config.enableBehavior) {
+            off('click', handleClick);
+            off('blur', handleBlur);
+            off('scroll', handleScroll);
+        }
+        if (Config.enableError) {
+            off('error', handleError);
+        }
+        sessionStorage.removeItem(shuyunTrackSessionId);
+    }
+}
+
+module.exports = Track;