spy-client 2.1.7 → 2.1.9

package/src/lib/huffman.ts

@@ -1,307 +0,0 @@
-/**
- * @file Huffman
- * @author kaivean
- */
-
-/**
- *
- 赫夫曼编码
- 基本介绍
-
-    1.赫夫曼编码也翻译为    哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法
-    赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
-
-    2.赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间
-    赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码
-
- *
- *
- */
-
-class HuffmanNode {
-    data;// 存放数据(字符本身),比如 'a' => 97, ' '=>32
-    weight;// 权值，表示字符串出现的次数
-    left: HuffmanNode;
-    right: HuffmanNode;
-    constructor(data: any, weight: number) {
-        this.data = data;
-        this.weight = weight;
-    }
-
-    // 前序遍历
-    preOrder(arr: any) {
-        arr.push(this);
-        if (this.left) {
-            this.left.preOrder(arr);
-        }
-        if (this.right) {
-            this.right.preOrder(arr);
-        }
-    }
-}
-
-
-/**
- *
- * @param {接受字符数组} bytes
- * @return 返回的就是list形式
- */
-function getNodes(bytes: any[]): HuffmanNode[] {
-    // 创建一个list
-    let list: HuffmanNode[] = [];
-    // counts 统计每一个byte出现的次数
-    let counts: any = {};
-    for (let b of bytes) {
-        let count = counts[b]; // map还没有这个字符数据
-        if (count == null) {
-            counts[b] = 1;
-        }
-        else {
-            counts[b]++;
-        }
-    }
-
-    for (const [key, value] of Object.entries(counts)) {
-        list.push(new HuffmanNode(key, value as number));
-    }
-    return list;
-}
-
-
-// 通过list创建赫夫曼树
-function createHuffmanTree(nodes: HuffmanNode[]): HuffmanNode | undefined {
-    const compareFun = function (a: HuffmanNode, b: HuffmanNode) {
-        return a.weight - b.weight;
-    };
-    while (nodes.length > 1) {
-        // 排序,从小到大
-        nodes.sort(compareFun);
-        // 取出第一颗最小的二叉树
-        let leftNode = nodes.shift();
-        let rightNode = nodes.shift();
-        if (leftNode && rightNode) {
-            // 创建一个新的二叉树，它的根节点，没有data，只有权值
-            let parent = new HuffmanNode(null, leftNode.weight + rightNode.weight);
-            parent.left = leftNode;
-            parent.right = rightNode;
-
-            // 将新的二叉树，加入到nodes
-            nodes.unshift(parent);
-        }
-
-    }
-    // nodes最后的节点，就是根节点
-    return nodes.shift();
-}
-
-// 生成赫夫曼树对应的赫夫曼编码表
-function getHuffmanCodes(root: any) {
-    if (root == null) {
-        return null;
-    }
-    // 生成赫夫曼树对应的赫夫曼编码表
-    // 思路
-    // 1.将赫夫曼编码表存放在map里面
-    // 2.在生成赫夫曼编码表时，需要拼接路径，定义一个数组string,存储某个叶子节点的路径
-
-    let huffmanCodes: any = {};
-    let strings: any[] = [];
-
-    /**
-     * 将传入的node节点的所有叶子节点的赫夫曼编码得到，并放入到huffmanCodes集合中
-     * @param {传入节点} node
-     * @param {路径：左子节点是0，右子节点是1} code
-     * @param {用于拼接路径} string
-     */
-    function getCodes(node: HuffmanNode, code: string, strs: string[]) {
-        let string2 = ([] as string[]).concat(strs);
-        // 将code加入到string中
-        string2.push(code);
-        if (node != null) { // 如果node == null不处理
-            // 判断当前node是叶子节点还是非叶子节点
-            if (node.data == null) { // 非叶子节点
-                // 递归处理
-                // 向左递归
-                getCodes(node.left, '0', string2);
-                // 向右递归
-                getCodes(node.right, '1', string2);
-            }
-            else { // 说明是一个叶子节点
-                // 就表示找到了某个叶子节点的最后
-                huffmanCodes[node.data] = string2.join('');
-            }
-        }
-    }
-    getCodes(root, '', strings);
-    return huffmanCodes;
-}
-
-
-/**
- * 编写一个方法，将字符串对应的bytes数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码压缩后的byte数组
- * @param {原始的字符串对应的bytes数组} bytes
- * @param {生成的赫夫曼编码表} huffmanCodes
- * @return 返回的是字符串对应的一个byte数组
- */
-function zip(bytes: number[], huffmanCodes: any) {
-    // 1.利用huffmanCodes将bytes转成赫夫曼编码对应的字符串
-    let string = [];
-    // 遍历数组
-    for (let b of bytes) {
-        string.push(huffmanCodes[b]);
-    }
-    return string;
-}
-
-function huffStringToByte(strs: string[]) {
-    // 计算赫夫曼编码字符串的长度
-    let str = strs.join('');
-    let len = Math.ceil(str.length / 8);
-    // 创建存储压缩后的byte数组
-    let huffmanCodeByte = new Array(len + 1);
-    let index = 0;
-    let strByte: string = ''; // 记录是第几个byte
-    for (let i = 0; i < str.length; i += 8) {
-        strByte = str.substring(i, i + 8);
-        // 将strByte转成一个byte，放入huffmanCodeByte
-        huffmanCodeByte[index] = parseInt(strByte, 2);
-        index++;
-    }
-    // 记录最后一位二进制码的长度，因为，比如最后一位二进制strByte为00101时，
-    // parseInt(strByte, 2)后等于5，前面的两个00已经丢失，所以必须记录长度，以便解码时补足前面的0
-    huffmanCodeByte[index] = strByte.length;
-    return huffmanCodeByte;
-}
-
-// 使用一个方法，封装前面的方法，便于调用
-/**
- *
- * @param {原始的字符串对应的字节数组} bytes
- * @returns 是经过赫夫曼编码处理后，压缩后的字节数组
- *
- */
-function huffmanZip(bytes: any[]) {
-    // 1.生成节点数组
-    let nodes = getNodes(bytes);
-    // 2.根据节点数组创建赫夫曼树
-    let root = createHuffmanTree(nodes);
-    // 3.根据赫夫曼树生成赫夫曼编码
-    let hufumanCodes = getHuffmanCodes(root);
-    // 4.根据生成的赫夫曼编码生成压缩后的赫夫曼编码字节数组
-    let hufumanStrArr = zip(bytes, hufumanCodes);
-    let hufumanByteArr = huffStringToByte(hufumanStrArr);
-
-    return {result: hufumanByteArr, codes: hufumanCodes};
-}
-
-// 完成数据的解压
-// 思路
-// 1.将huffmanBytesArr先转成赫夫曼编码对应的二进制字符串
-// 2.将赫夫曼编码对应的二进制的字符串转成赫夫曼编码字符串
-
-/**
- *
- * @param {表示是否需要补高位，如果是true，表示需要，如果是false，表示不需要，如果是最后一个字节不需要补高位} flag
- * @param {传入的byte} byte
- * @returns 是byte对应的二进制字符串
- */
-function huffByteToString(flag: boolean, byte: number) {
-    // 如果是
-    if (flag) {
-        byte |= 256;
-    }
-    let str = Number(byte).toString(2);
-    if (flag) {
-        return str.substring(str.length - 8);
-    }
-    return str;
-}
-
-
-/**
- * 编写一份方法，完成对压缩数据的解码
- * @param {赫夫曼编码表} huffmanCodes
- * @param {赫夫曼编码得到的二进制数组} huffmanBytes
- */
-function decode(huffmanCodes: {[key: string]: string}, huffmanBytes: number[]) {
-    // 1.先得到二进制字符串 形式11001111111011......
-    let heffmanStrArr = [];
-    for (let i = 0; i < huffmanBytes.length - 1; i++) {
-        // 判断是不是最后一个字节
-        let flag = (i !== huffmanBytes.length - 2);
-        heffmanStrArr.push(huffByteToString(flag, huffmanBytes[i]));
-    }
-    // 最后一位记录的是最后一位二进制字符串的长度，该长度主要用于补足最后一位丢失的0,所以要单独处理，
-    let lastByteStr = heffmanStrArr[heffmanStrArr.length - 1];
-    let lastByteLength = huffmanBytes[huffmanBytes.length - 1];
-    lastByteStr = '00000000'.substring(8 - (lastByteLength - lastByteStr.length)) + lastByteStr;
-    heffmanStrArr[heffmanStrArr.length - 1] = lastByteStr;
-
-    // 把赫夫曼编码表进行调换
-    let map: {[key: string]: string} = {};
-    for (const [key, value] of Object.entries(huffmanCodes)) {
-        map[value] = key;
-    }
-    let heffmanStr = heffmanStrArr.join('');
-    let list = [];
-    let len = heffmanStr.length;
-    for (let i = 0; i < len;) {
-        let count = 1;
-        let flag = true;
-        let b: string | null = null;
-        while (flag && i + count <= len) {
-            // 取出一个1或0
-            // i不动，count移动，直到匹配到一个字符
-            let key = heffmanStr.substring(i, i + count);
-            if (key === '') {
-                break;
-            }
-            b = map[key];
-            if (!b) { // 没有匹配到
-                count++;
-            }
-            else {
-                // 匹配到
-                flag = false;
-            }
-        }
-        list.push(parseInt(b as string, 10));
-        i += count;
-    }
-    // 当for循环结束后，list中就存放了所有的字符
-
-    return list;
-}
-
-
-// js byte[] 和string 相互转换 UTF-8
-function stringToByte(str: string): number[] {
-    let bytes = [];
-    for (let index = 0; index < str.length; index++) {
-        bytes.push(str.charCodeAt(index));
-    }
-    return bytes;
-}
-
-function byteToString(arr: number[]): string {
-    let data = '';
-    for (const code of arr) {
-        data += String.fromCharCode(code);
-    }
-    return data;
-}
-
-export function huffmanEncode(str: string) {
-    let bytes = stringToByte(str);
-    let {result, codes} = huffmanZip(bytes);
-    return {
-        codes,
-        result: byteToString(result),
-    };
-}
-
-export function huffmanDecode(codes: any, str: string) {
-    let bytes = stringToByte(str);
-    const data = decode(codes, bytes);
-    return byteToString(data);
-}

package/src/lib/interface.ts

@@ -1,331 +0,0 @@
-export interface SpyClientOption {
-    /**
-     * 模块ID
-     */
-    pid: string;
-
-    // 日志ID
-    /**
-     * 日志ID
-     */
-    lid?: string;
-
-    /**
-     * 全局抽样配置，默认是 1，取值从[0, 1]
-     */
-    sample?: number;
-
-    /**
-     * 是否校验发送字段符合规范，默认是 true
-     */
-    check?: boolean;
-
-    /**
-     * 日志服务器，默认是webb服务器，尾部需要加?
-     */
-    logServer?: string;
-
-    /**
-     * 本地日志cache对象，是指独立的spy-local-cache模块实例
-     */
-    localCache?: any;
-}
-
-export class Module {
-    // public constructor() {}
-    // [propName: string]: listenCallback[],
-    // init: () => void;
-    load?: () => void;
-    leave?: () => void;
-    destroy?: () => void;
-}
-
-export interface FIDMetric {
-    // First Input Delay https://web.dev/fid/
-    // 首次输入延迟
-    fid: number;
-}
-export type FIDCB = (metric: FIDMetric) => void;
-
-export interface LCPMetric {
-    // Largest Contentful Paint https://web.dev/lcp/
-    // 在onload时间内最大块内容绘制完成时间
-    lcp: number;
-}
-export type LCPCB = (metric: LCPMetric) => void;
-
-export enum ResType {
-    JS = 'js',
-    CSS = 'css',
-    IMG = 'img',
-    FONT = 'font',
-}
-
-export interface ResourceMetric {
-    // 页面整体大小：包括主文档、所有JS、CSS、Img、Font，单位KB
-    allSize: number;
-    // 主文档大小 KB
-    docSize: number;
-    // 主文档的响应header的大小，包含cookie等 KB
-    headerSize: number;
-
-    // js外链的个数
-    jsNum: number;
-    cssNum: number;
-    imgNum: number;
-    fontNum: number;
-
-    // 所有JS外链的大小
-    jsSize: number;
-    cssSize: number;
-    imgSize: number;
-    fontSize: number;
-
-    // 页面整体网络传输大小，通常来说资源有了缓存，传输大小就为0，另外有Gzip的话，传输大小相比资源本身大小也要小很多
-    allTransferSize: number;
-    // 主文档网络传输大小
-    docTransferSize: number;
-    // 所有JS外链的传输大小
-    jsTransferSize: number;
-    cssTransferSize: number;
-    imgTransferSize: number;
-    fontTransferSize: number;
-
-    jsDuration: number;
-    cssDuration: number;
-    imgDuration: number;
-    fontDuration: number;
-
-    // js cache率
-    jsCacheRate: number;
-    cssCacheRate: number;
-    imgCacheRate: number;
-};
-export interface ResourceHostMetric {
-    [host: string]: {
-        hostNum: number;
-        hostSize: number;
-        hostTransferSize: number;
-        hostDuration: number;
-        hostCacheRate: number;
-    };
-};
-export type ResourceCB = (metric: ResourceMetric, hostMetric: ResourceHostMetric) => void;
-
-
-export interface ResourceErrorInfo {
-    // 发生异常的资源链接
-    msg: string;
-    // 发生异常的资源元素的xpath信息，一直到body
-    xpath: string;
-    // 资源host
-    host: string;
-    // 资源类型
-    type: string;
-    // 资源耗时
-    dur?: number;
-}
-export type ResourceErrorCB = (info: ResourceErrorInfo) => void;
-
-
-export interface TimingMetric {
-    // dns解析
-    dns: number;
-    // tcp链接
-    tcp: number;
-    // 主文档请求
-    request: number;
-    // 主文档响应时间
-    response: number;
-    // DOM解析时间：Dom解析开始到结束时间
-    // 这是从页面部分数据返回，浏览器开始解析doc元素到最底部的script脚本解析执行完成
-    // 脚本里触发的异步方法或绑定了更靠后的事件，不再纳入范围内
-    parseHtml: number;
-    // DOM解析完成总时间：页面开始加载到Dom解析结束
-    // 很多事件绑定是在domContentLoaded事件里的，所以等其结束，一般页面元素的事件绑定好了，用户可以正确交互
-    // 当然存在在该加载事件之后绑定元素事件情况，但不再此考虑范围内
-    domReady: number;
-    // 处理所有注册的load事件函数的时间
-    loadEventHandle: number;
-    // onload完成时间
-    // 基本该做的都做完，资源也都加载完成了
-    // 当然在onload事件处理函数里启动了异步方法，不再纳入范围内
-    load: number;
-    // first-paint https://w3c.github.io/paint-timing/#sec-PerformancePaintTiming
-    fp?: number;
-    // first-contentful-paint  https://w3c.github.io/paint-timing/#sec-PerformancePaintTiming
-    fcp?: number;
-    // T7内核计算的首次绘制, 单位ms
-    t7FirstPaint?: number;
-    // T7内核计算的首屏时间, 单位ms
-    t7FirstScreen?: number;
-}
-export type TimingCB = (metric: TimingMetric) => void;
-
-
-export interface TTIMetric {
-    // Time to Interactive https://web.dev/tti/
-    // 用户可完全交互时间
-    tti: number;
-}
-export type TTICB = (metric: TTIMetric) => void;
-
-export interface TTIOption {
-    // TTI定义里的quiet window，默认是5000 单位ms
-    interval?: number;
-    // TTI要求在quiet window内，没有任何网络请求，但有一些不会影响页面的请求，比如日志请求，最好过滤掉，避免一直hang在quiet window
-    // 默认下，排除掉所有gif请求
-    filterRequest?: (entry: PerformanceEntry) => boolean;
-}
-
-export interface LayoutShiftMetric {
-    // Cumulative Layout Shift定义 https://web.dev/cls/
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内的 Cumulative Layout Shift
-    layoutShift: number;
-}
-export type LayoutShiftCB = (metric: LayoutShiftMetric) => void;
-
-
-export interface MemoryMetric {
-    // 使用内存, 单位KB
-    usedJSHeapSize: number;
-    // 分配给页面的内存，单位KB
-    totalJSHeapSize: number;
-    // 内存限制，单位KB
-    jsHeapSizeLimit: number;
-    // 内存使用率百分比 = 100 * usedJSHeapSize / totalJSHeapSize
-    usedJSHeapRate: number;
-}
-export type MemoryCB = (metric: MemoryMetric) => void;
-
-
-export interface NavigatorInfoMetric {
-    // 网络下载速度 https://developer.mozilla.org/zh-CN/docs/Web/API/Navigator/connection
-    downlink?: number;
-    // 网络类型
-    effectiveType?: '2g' | '3g' | '4g' | 'slow-2g';
-    // 估算的往返时间
-    rtt?: number;
-    // 数据保护模式
-    saveData?: boolean;
-    // 设备内存 https://developer.mozilla.org/en-US/docs/Web/API/Navigator/deviceMemory
-    deviceMemory?: number;
-    // 设备逻辑核数  https://developer.mozilla.org/en-US/docs/Web/API/NavigatorConcurrentHardware/hardwareConcurrency
-    hardwareConcurrency?: number;
-}
-export type NavigatorInfoCB = (metric: NavigatorInfoMetric) => void;
-
-
-export interface FSPLongtaskMetric {
-    // 在T7内核首屏时间内， 每个longtask的时间总和
-    fspLongtaskTime: number;
-    // 在T7内核首屏时间内，Total Blocking Time时间总和，即Sum(每个longtask的时间 - 50）
-    // Total Blocking Time定义：
-    fspTBT: number;
-    // T7内核首屏时间
-    fspTotalTime: number;
-    // 在T7内核首屏时间内, Longtask率 = 100 * fspLongtaskTime / fspTotalTime
-    fspLongtaskRate: number;
-    // 在T7内核首屏时间内的Longtask数量
-    fspLongtaskNum: number;
-}
-export type FSPLongtaskCB = (metric: FSPLongtaskMetric) => void;
-
-export interface LCPLongtaskMetric {
-    // 在Largest Contentful Paint时间内， 每个longtask的时间总和
-    lcpLongtaskTime: number;
-    // 在Largest Contentful Paint时间内，Total Blocking Time时间总和，即Sum(每个longtask的时间 - 50）
-    lcpTBT: number;
-    // Largest Contentful Paint时间
-    lcpTotalTime: number;
-    // 在Largest Contentful Paint时间内, Longtask率 = 100 * lcpLongtaskTime / lcpTotalTime
-    lcpLongtaskRate: number;
-    // 在Largest Contentful Paint时间内的Longtask数量
-    lcpLongtaskNum: number;
-}
-export type LCPLongtaskCB = (metric: LCPLongtaskMetric) => void;
-
-
-export interface LoadLongtaskMetric {
-    // 在onload即页面加载完成时间内， 每个longtask的时间总和
-    loadLongtaskTime: number;
-    // 在onload即页面加载完成时间内，Total Blocking Time时间总和，即Sum(每个longtask的时间 - 50）
-    loadTBT: number;
-    // onload即页面加载完成时间
-    loadTotalTime: number;
-    // 在onload即页面加载完成时间内, Longtask率 = 100 * loadLongtaskTime / loadTotalTime
-    loadLongtaskRate: number;
-    // 在onload即页面加载完成时间内的Longtask数量
-    loadLongtaskNum: number;
-}
-export type LoadLongtaskCB = (metric: LoadLongtaskMetric) => void;
-
-
-export interface PageLongtaskMetric {
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内， 每个longtask的时间总和
-    pageLongtaskTime: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内，Total Blocking Time时间总和，即Sum(每个longtask的时间 - 50）
-    pageTBT: number;
-    // 开始加载页面到第一次离开页面(隐藏或点出)时间
-    pageTotalTime: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内, Longtask率 = 100 * pageLongtaskTime / pageTotalTime
-    pageLongtaskRate: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内的Longtask数量
-    pageLongtaskNum: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内，每个来自iframe内的longtask的时间总和
-    pageIframeLongtaskTime: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内，每个来自iframe内的Longtask率 = 100 * pageIframeLongtaskTime / pageTotalTime
-    pageIframeLongtaskRate: number;
-    // 在开始加载页面到第一次离开页面(隐藏或点出)时间内，每个来自iframe内的Longtask数量
-    pageIframeLongtaskNum: number;
-}
-export type PageLongtaskCB = (metric: PageLongtaskMetric) => void;
-
-
-export interface ResOption {
-    ignorePaths?: string[];
-    trigger?: 'load' | 'leave';
-}
-
-export interface BigImgOption {
-    /**
-     * 体积大于该阈值，就认为是大图，默认150，单位是kb
-     */
-    maxSize?: number;
-    /**
-     * 忽略指定path的资源
-     */
-    ignorePaths?: string[];
-    /**
-     * 触发时机，在load事件触发后，还是在用户离开页面后，收集出现的加载慢的资源。，默认是load
-     */
-    trigger?: 'load' | 'leave';
-}
-
-export interface HttpResOption {
-    /**
-     * 忽略指定path的资源
-     */
-    ignorePaths?: string[];
-    /**
-     * 触发时机，在load事件触发后，还是在用户离开页面后，收集出现的加载慢的资源。，默认是load
-     */
-    trigger?: 'load' | 'leave';
-}
-
-export interface SlowOption {
-    /**
-     * 加载时长大于该阈值，就认为是慢资源，默认1000，单位是ms
-     */
-    threshold?: number;
-    /**
-     * 忽略指定path的资源
-     */
-    ignorePaths?: string[];
-    /**
-     * 触发时机，在load事件触发后，还是在用户离开页面后，收集出现的加载慢的资源。，默认是load
-     */
-    trigger?: 'load' | 'leave';
-}
-
-

package/src/lib/spyHeadInterface.ts

@@ -1,40 +0,0 @@
-export interface ErrorHandlerData {
-    info: {
-        [propName: string]: any;
-        msg: string;
-    };
-    group: string;
-    dim?: {
-        [propName: string]: any;
-    };
-}
-
-export interface ErrorConf {
-    // 抽样， 取值在[0, 1]，为0，则相当于禁用，默认是0
-    sample: number;
-    // 自定义spy平台的分组
-    group: string;
-    // 异常数据上报前的自定义处理，可以修改data对象，增加信息和维度，如果返回false，则表示不上报该数据
-    handler?: (data: ErrorHandlerData) => boolean | void | undefined;
-}
-
-export interface WhiteScreenErrorConf extends ErrorConf {
-    // 超时时间，在到达超时时间后，执行检测，如果条件不成立，则认为会抛出白屏错误
-    timeout: number;
-    // css选择器
-    selector: string;
-    // css选择器
-    subSelector: string;
-}
-
-export interface SpyHeadConf {
-    // spy平台申请的pid
-    pid: string;
-    // 可选，用户log id
-    lid?: string;
-    // 可选，自定义日志服务器
-    logServer?: string;
-    jsError: ErrorConf;
-    resourceError: ErrorConf;
-    whiteScreenError: WhiteScreenErrorConf;
-}