spy-client
Version:
spy client
753 lines (740 loc) • 28.5 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.SpyLocalCache = factory());
})(this, (function () { 'use strict';
/*! *****************************************************************************
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.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
/**
* @file Huffman
* @author kaivean
*/
/**
*
赫夫曼编码
基本介绍
1.赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法
赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
2.赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在20%～90%之间
赫夫曼码是可变字长编码(VLC)的一种。Huffman于1952年提出一种编码方法，称之为最佳编码
*
*
*/
var HuffmanNode = /** @class */ (function () {
function HuffmanNode(data, weight) {
this.data = data;
this.weight = weight;
}
// 前序遍历
HuffmanNode.prototype.preOrder = function (arr) {
arr.push(this);
if (this.left) {
this.left.preOrder(arr);
}
if (this.right) {
this.right.preOrder(arr);
}
};
return HuffmanNode;
}());
/**
*
* @param {接受字符数组} bytes
* @return 返回的就是list形式
*/
function getNodes(bytes) {
// 创建一个list
var list = [];
// counts 统计每一个byte出现的次数
var counts = {};
for (var _i = 0, bytes_1 = bytes; _i < bytes_1.length; _i++) {
var b = bytes_1[_i];
var count = counts[b]; // map还没有这个字符数据
if (count == null) {
counts[b] = 1;
}
else {
counts[b]++;
}
}
for (var _a = 0, _b = Object.entries(counts); _a < _b.length; _a++) {
var _c = _b[_a], key = _c[0], value = _c[1];
list.push(new HuffmanNode(key, value));
}
return list;
}
// 通过list创建赫夫曼树
function createHuffmanTree(nodes) {
var compareFun = function (a, b) {
return a.weight - b.weight;
};
while (nodes.length > 1) {
// 排序,从小到大
nodes.sort(compareFun);
// 取出第一颗最小的二叉树
var leftNode = nodes.shift();
var rightNode = nodes.shift();
if (leftNode && rightNode) {
// 创建一个新的二叉树，它的根节点，没有data，只有权值
var parent_1 = new HuffmanNode(null, leftNode.weight + rightNode.weight);
parent_1.left = leftNode;
parent_1.right = rightNode;
// 将新的二叉树，加入到nodes
nodes.unshift(parent_1);
}
}
// nodes最后的节点，就是根节点
return nodes.shift();
}
// 生成赫夫曼树对应的赫夫曼编码表
function getHuffmanCodes(root) {
if (root == null) {
return null;
}
// 生成赫夫曼树对应的赫夫曼编码表
// 思路
// 1.将赫夫曼编码表存放在map里面
// 2.在生成赫夫曼编码表时，需要拼接路径，定义一个数组string,存储某个叶子节点的路径
var huffmanCodes = {};
var strings = [];
/**
* 将传入的node节点的所有叶子节点的赫夫曼编码得到，并放入到huffmanCodes集合中
* @param {传入节点} node
* @param {路径：左子节点是0，右子节点是1} code
* @param {用于拼接路径} string
*/
function getCodes(node, code, strs) {
var string2 = [].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, huffmanCodes) {
// 1.利用huffmanCodes将bytes转成赫夫曼编码对应的字符串
var string = [];
// 遍历数组
for (var _i = 0, bytes_2 = bytes; _i < bytes_2.length; _i++) {
var b = bytes_2[_i];
string.push(huffmanCodes[b]);
}
return string;
}
function huffStringToByte(strs) {
// 计算赫夫曼编码字符串的长度
var str = strs.join('');
var len = Math.ceil(str.length / 8);
// 创建存储压缩后的byte数组
var huffmanCodeByte = new Array(len + 1);
var index = 0;
var strByte = ''; // 记录是第几个byte
for (var 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) {
// 1.生成节点数组
var nodes = getNodes(bytes);
// 2.根据节点数组创建赫夫曼树
var root = createHuffmanTree(nodes);
// 3.根据赫夫曼树生成赫夫曼编码
var hufumanCodes = getHuffmanCodes(root);
// 4.根据生成的赫夫曼编码生成压缩后的赫夫曼编码字节数组
var hufumanStrArr = zip(bytes, hufumanCodes);
var hufumanByteArr = huffStringToByte(hufumanStrArr);
return { result: hufumanByteArr, codes: hufumanCodes };
}
// 完成数据的解压
// 思路
// 1.将huffmanBytesArr先转成赫夫曼编码对应的二进制字符串
// 2.将赫夫曼编码对应的二进制的字符串转成赫夫曼编码字符串
/**
*
* @param {表示是否需要补高位，如果是true，表示需要，如果是false，表示不需要，如果是最后一个字节不需要补高位} flag
* @param {传入的byte} byte
* @returns 是byte对应的二进制字符串
*/
function huffByteToString(flag, byte) {
// 如果是
if (flag) {
byte |= 256;
}
var str = Number(byte).toString(2);
if (flag) {
return str.substring(str.length - 8);
}
return str;
}
/**
* 编写一份方法，完成对压缩数据的解码
* @param {赫夫曼编码表} huffmanCodes
* @param {赫夫曼编码得到的二进制数组} huffmanBytes
*/
function decode(huffmanCodes, huffmanBytes) {
// 1.先得到二进制字符串 形式11001111111011......
var heffmanStrArr = [];
for (var i = 0; i < huffmanBytes.length - 1; i++) {
// 判断是不是最后一个字节
var flag = (i !== huffmanBytes.length - 2);
heffmanStrArr.push(huffByteToString(flag, huffmanBytes[i]));
}
// 最后一位记录的是最后一位二进制字符串的长度，该长度主要用于补足最后一位丢失的0,所以要单独处理，
var lastByteStr = heffmanStrArr[heffmanStrArr.length - 1];
var lastByteLength = huffmanBytes[huffmanBytes.length - 1];
lastByteStr = '00000000'.substring(8 - (lastByteLength - lastByteStr.length)) + lastByteStr;
heffmanStrArr[heffmanStrArr.length - 1] = lastByteStr;
// 把赫夫曼编码表进行调换
var map = {};
for (var _i = 0, _a = Object.entries(huffmanCodes); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
map[value] = key;
}
var heffmanStr = heffmanStrArr.join('');
var list = [];
var len = heffmanStr.length;
for (var i = 0; i < len;) {
var count = 1;
var flag = true;
var b = null;
while (flag && i + count <= len) {
// 取出一个1或0
// i不动，count移动，直到匹配到一个字符
var key = heffmanStr.substring(i, i + count);
if (key === '') {
break;
}
b = map[key];
if (!b) { // 没有匹配到
count++;
}
else {
// 匹配到
flag = false;
}
}
list.push(parseInt(b, 10));
i += count;
}
// 当for循环结束后，list中就存放了所有的字符
return list;
}
// js byte[] 和string 相互转换 UTF-8
function stringToByte(str) {
var bytes = [];
for (var index = 0; index < str.length; index++) {
bytes.push(str.charCodeAt(index));
}
return bytes;
}
function byteToString(arr) {
var data = '';
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
var code = arr_1[_i];
data += String.fromCharCode(code);
}
return data;
}
function huffmanEncode(str) {
var bytes = stringToByte(str);
var _a = huffmanZip(bytes), result = _a.result, codes = _a.codes;
return {
codes: codes,
result: byteToString(result),
};
}
function huffmanDecode(codes, str) {
var bytes = stringToByte(str);
var data = decode(codes, bytes);
return byteToString(data);
}
var Storage = /** @class */ (function () {
function Storage() {
}
Storage.prototype.set = function (key, value) {
};
Storage.prototype.get = function (key, cb) {
};
Storage.prototype.rm = function (key) {
};
return Storage;
}());
var LS = /** @class */ (function (_super) {
__extends(LS, _super);
function LS() {
return _super !== null && _super.apply(this, arguments) || this;
}
LS.isSupport = function () {
return !!window.localStorage;
};
LS.prototype.set = function (key, value) {
try {
localStorage.setItem(key, value);
}
catch (e) {
console.error(e);
}
return;
};
LS.prototype.get = function (key, cb) {
var res = null;
try {
res = localStorage.getItem(key);
}
catch (e) {
console.error(e);
}
if (cb) {
cb(res);
}
return;
};
LS.prototype.rm = function (key) {
try {
localStorage.removeItem(key);
}
catch (e) {
console.error(e);
}
return;
};
return LS;
}(Storage));
var IndexedDB = /** @class */ (function (_super) {
__extends(IndexedDB, _super);
function IndexedDB() {
var _this = _super.call(this) || this;
_this.databaseName = 'spyLC';
_this.db = null;
_this.setQueue = [];
_this.getQueue = [];
var request = window.indexedDB.open(_this.databaseName);
request.onupgradeneeded = function (event) {
// @ts-ignore ts默认的EventTarget类型有问题，先ignore掉
_this.db = event.target && event.target.result;
if (_this.db && !_this.db.objectStoreNames.contains(_this.databaseName)) {
_this.db.createObjectStore(_this.databaseName, { keyPath: 'key' });
}
_this.runQueueTask();
};
request.onsuccess = function () {
_this.db = request.result;
_this.runQueueTask();
};
return _this;
}
IndexedDB.isSupport = function () {
return !!window.indexedDB;
};
IndexedDB.prototype.set = function (key, value) {
// 因为indexDB是异步初始化的，如果set的时候未初始化，先缓存之后再执行set
if (!this.db) {
this.setQueue.push({
key: key,
value: value,
});
return;
}
this.db.transaction([this.databaseName], 'readwrite')
.objectStore(this.databaseName)
.add({
key: key,
value: value,
});
};
IndexedDB.prototype.get = function (key, cb) {
// 因为indexDB是异步初始化的，如果get的时候未初始化，先缓存之后再执行get
if (!this.db) {
this.getQueue.push({
key: key,
cb: cb,
});
return;
}
var transaction = this.db.transaction([this.databaseName]);
var objectStore = transaction.objectStore(this.databaseName);
var request = objectStore.get(key);
request.onsuccess = function () {
var result = request.result ? request.result : { value: '' };
cb(result.value);
};
};
IndexedDB.prototype.runQueueTask = function () {
var _this = this;
this.setQueue.forEach(function (ele) {
_this.set(ele.key, ele.value);
});
this.getQueue.forEach(function (ele) {
_this.get(ele.key, ele.cb);
});
};
return IndexedDB;
}(Storage));
function assign() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
var __assign = Object.assign || function __assign(t) {
for (var s = void 0, i = 1, n = arguments.length; i < n; i++) {
// eslint-disable-next-line prefer-rest-params
s = arguments[i];
for (var p in s) {
if (Object.prototype.hasOwnProperty.call(s, p)) {
t[p] = s[p];
}
}
}
return t;
};
return __assign.apply(this, args);
}
function utf8Encode(text) {
var result = '';
for (var n = 0; n < text.length; n++) {
var c = text.charCodeAt(n);
if (c < 128) {
result += String.fromCharCode(c);
}
else if (c > 127 && c < 2048) {
result += String.fromCharCode((c >> 6) | 192);
result += String.fromCharCode((c & 63) | 128);
}
else {
result += String.fromCharCode((c >> 12) | 224);
result += String.fromCharCode(((c >> 6) & 63) | 128);
result += String.fromCharCode((c & 63) | 128);
}
}
return result;
// return window.btoa(result);
}
function utf8Decode(text) {
// text = window.atob(text);
var result = '';
var i = 0;
var c1 = 0;
var c2 = 0;
var c3 = 0;
while (i < text.length) {
c1 = text.charCodeAt(i);
if (c1 < 128) {
result += String.fromCharCode(c1);
i++;
}
else if (c1 > 191 && c1 < 224) {
c2 = text.charCodeAt(i + 1);
result += String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
i += 2;
}
else {
c2 = text.charCodeAt(i + 1);
c3 = text.charCodeAt(i + 2);
result += String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
i += 3;
}
}
return result;
}
function lzw(text, deCompress) {
if (deCompress === void 0) { deCompress = false; }
if (!text) {
return '';
}
if (!deCompress) {
text = utf8Encode(text);
}
var dict = {};
var out = [];
var prefix = text.charAt(0);
var curChar = prefix;
var oldPrefix = curChar;
var idx = 256;
var i;
var c;
var d;
var g = function () {
out.push(prefix.length > 1 ? String.fromCharCode(dict[prefix]) : prefix);
};
if (deCompress) {
out.push(prefix);
}
for (i = 1, d; i < text.length; i++) {
c = text.charAt(i);
if (deCompress) {
d = text.charCodeAt(i);
prefix = d < 256 ? c : dict[d] || (prefix + curChar);
out.push(prefix);
curChar = prefix.charAt(0);
dict[idx++] = oldPrefix + curChar;
oldPrefix = prefix;
}
else {
if (dict.hasOwnProperty(prefix + c)) {
prefix += c;
}
else {
g();
dict[prefix + c] = idx++;
prefix = c;
}
}
}
if (!deCompress) {
g();
}
var ret = out.join('');
if (deCompress) {
ret = utf8Decode(ret);
}
return ret;
}
var SpyLocalCache = /** @class */ (function () {
function SpyLocalCache(option) {
if (option === void 0) { option = {}; }
this.tmpList = [];
this.option = assign({
defaultTrigger: true,
compress: 'lzw',
key: 'SpyLocalCache',
interval: 500,
maxRecordLen: 30,
onFlush: function () { },
onSave: function () { },
onAdd: function () {
return true;
},
storage: IndexedDB.isSupport()
? 'indexedDB'
: LS.isSupport()
? 'localstorage'
: 'empty',
}, option);
this.load = this.load.bind(this);
this.init();
}
SpyLocalCache.prototype.init = function () {
if (this.option.storage === 'indexedDB') {
this.storage = new IndexedDB();
}
else if (this.option.storage === 'localstorage') {
this.storage = new LS();
}
else {
this.storage = new Storage();
}
if (document.readyState === 'complete') {
this.load();
}
else {
window.addEventListener('load', this.load);
}
};
SpyLocalCache.prototype.load = function () {
if (location.search.indexOf('_FlushLogLocalCache=1') > -1 && this.option.defaultTrigger) {
this.flushLog();
}
};
SpyLocalCache.prototype.addLog = function (info) {
var _this = this;
if (this.option.onAdd) {
if (!this.option.onAdd(info)) {
return;
}
}
info = JSON.stringify(info);
this.tmpList.push(info);
// 控制写日志频率
if (this.timer) {
clearTimeout(this.timer);
}
this.timer = setTimeout(function () {
_this.save();
}, this.option.interval);
};
SpyLocalCache.prototype.getData = function (cb) {
var _this = this;
try {
this.storage.get(this.option.key, function (encodeStr) {
if (encodeStr) {
_this.storage.get(_this.option.key + 'Codes', function (codes) {
var res = [];
try {
if (codes) {
codes = JSON.parse(codes);
}
var str = _this.unzip(encodeStr, codes);
res = str.split('\n');
}
catch (e) {
console.error(e);
}
cb(res);
});
}
else {
cb([]);
}
});
}
catch (e) {
console.error(e);
cb([]);
}
};
SpyLocalCache.prototype.save = function () {
var _this = this;
var st = Date.now();
this.getData(function (list) {
// 只保留最近的maxRecordLen条日志
var reserveLen = _this.option.maxRecordLen - 1;
var originList = list.length > reserveLen ? list.slice(list.length - reserveLen, list.length) : list;
var newList = originList.concat(_this.tmpList);
var content = newList.join('\n');
var error = null;
var len = 0;
try {
var data = _this.zip(content);
var codesStr = '';
if (data.codes) {
codesStr = JSON.stringify(data.codes);
_this.storage.set(_this.option.key + 'Codes', codesStr);
}
else {
_this.storage.rm(_this.option.key + 'Codes');
}
_this.storage.set(_this.option.key, data.result);
len = data.result.length;
}
catch (e) {
error = e;
console.error(e);
}
_this.tmpList = [];
_this.option.onSave && _this.option.onSave({
cost: Date.now() - st,
length: len / 1024,
list: newList,
error: error,
});
});
};
SpyLocalCache.prototype.flushLog = function () {
var _this = this;
this.getData(function (list) {
// 先解析来自存储的数据，若失败，说明格式有问题，清空存储
try {
for (var index = 0; index < list.length; index++) {
list[index] = JSON.parse(list[index]);
}
}
catch (e) {
list = [];
_this.storage.rm(_this.option.key);
console.error(e);
}
// 未落盘的数据也加上
for (var index = 0; index < _this.tmpList.length; index++) {
list.push(JSON.parse(_this.tmpList[index]));
}
_this.option.onFlush && _this.option.onFlush(list);
});
};
SpyLocalCache.prototype.zip = function (str) {
if (this.option.compress === 'lzw') {
return {
codes: null,
result: lzw(str),
};
}
else if (this.option.compress === 'huffman') {
return huffmanEncode(str);
}
return {
codes: null,
result: str,
};
};
SpyLocalCache.prototype.unzip = function (str, codes) {
if (this.option.compress === 'lzw') {
return lzw(str, true);
}
else if (this.option.compress === 'huffman') {
return huffmanDecode(codes, str);
}
return str;
};
return SpyLocalCache;
}());
// For test
// let content = JSON.stringify({
// type: 3,
// fm: 'disp',
// data: [{"base":{"size":{"doc":{"w":360,"h":4875},"wind":{"w":360,"h":640},"scr":{"w":360,"h":640}},"vsb":"visible","num":16},"t":1629773746698,"path":"/s"}],
// qid: 10991431029479106376,
// did: '8dd09c47c7bc90c9fd7274f0ad2c581e',
// q: '刘德华',
// t: 1629773746698,
// });
// const compressText = lzw(content);
// const deCompressText = lzw(compressText, true);
// console.log('compressText', compressText, compressText.length);
// console.log('deCompressText', deCompressText, deCompressText.length);
return SpyLocalCache;
}));