oxy-uni-ui 2.1.1 → 2.1.3

package/devTools/core/libs/jsonCompress.js

@@ -0,0 +1,334 @@
+/**
+ * json压缩工具
+ */
+export default {
+  /**
+   * 压缩js对象成json字符串，并控制json字节大小，多余部分裁剪
+   */
+  compressObject(obj = {}, maxSize = 1024 * 10.24) {
+    try {
+      if (obj === undefined || obj === null) return obj;
+      if (typeof obj == "string") {
+        return this.truncateStrBySize(obj, maxSize);
+      }
+      if (typeof obj == "number") {
+        return obj;
+      }
+
+      let t = new Date().getTime()
+
+      const type = typeof obj;
+
+      if (type === 'symbol') {
+        obj = "Symbol->" + obj.toString();
+      } else if (type === 'bigint') {
+        obj = "bigint->" + obj.toString()
+      } else if (typeof Error != "undefined" && obj instanceof Error) {
+        obj = `Error->${obj.name}\n${obj.message}\n${obj.stack}`
+      } else if (typeof Date != "undefined" && obj instanceof Date) {
+        obj = "Date->" + obj.toISOString()
+      } else if (typeof obj == "function") {
+        obj = "Function->" + obj.toString()
+      } else if (typeof RegExp != "undefined" && obj instanceof RegExp) {
+        obj = "RegExp->" + obj.toString();
+      } else if (typeof Map != "undefined" && obj instanceof Map) {
+        obj = `Map->(${obj.size}) { ${Array.from(obj.entries()).map(([key, value]) => `${convertToString(key)} => ${convertToString(value)}`).join(', ')} }`;
+      } else if (typeof Set != "undefined" && obj instanceof Set) {
+        obj = `Set->(${obj.size}) { ${Array.from(obj.values()).map(value => convertToString(value)).join(', ')} }`;
+      } else if (typeof Blob != "undefined" && obj instanceof Blob) {
+        obj = `Blob->{ size: ${obj.size}, type: ${obj.type} }`;
+      } else if (typeof File != "undefined" && obj instanceof File) {
+        obj = `File->{ name: "${obj.name}", size: ${obj.size}, type: ${obj.type}, lastModified: ${new Date(obj.lastModified).toISOString()} }`;
+      } else if (typeof URL != "undefined" && obj instanceof URL) {
+        obj = `URL->{ href: "${obj.href}", protocol: "${obj.protocol}", host: "${obj.host}", pathname: "${obj.pathname}", search: "${obj.search}", hash: "${obj.hash}" }`;
+      } else if (typeof FormData != "undefined" && obj instanceof FormData) {
+        const entries = [];
+        obj.forEach((key, item) => {
+          entries.push(key)
+        })
+        obj = `FormData->{ ${entries.join(', ')} }`;
+      } else if (typeof Location != "undefined" && obj instanceof Location) {
+        obj = `Location->{ href: "${obj.href}", protocol: "${obj.protocol}", host: "${obj.host}", pathname: "${obj.pathname}", search: "${obj.search}", hash: "${obj.hash}" }`;
+      } else if (typeof Document != "undefined" && obj instanceof Document) {
+        obj = `Document->{ title: "${obj.title}", URL: "${obj.URL}" }`;
+      } else if (typeof Window !== "undefined" && obj instanceof Window) {
+        obj = `Window->{ location: ${this.compressObject(obj.location)}, document: ${this.compressObject(obj.document)} }`;
+      } else if (typeof Element != "undefined" && obj instanceof Element) {
+        obj = `Element->{ tagName: "${obj.tagName}", id: "${obj.id}", class: "${obj.className}" }`;
+      } else if (typeof HTMLCanvasElement != "undefined" && obj instanceof HTMLCanvasElement) {
+        obj = `Canvas->{ width: ${obj.width}, height: ${obj.height} }`;
+      } else if (typeof HTMLAudioElement != "undefined" && obj instanceof HTMLAudioElement) {
+        obj = `Audio->{ src: "${obj.src}", duration: ${obj.duration} }`;
+      } else if (typeof HTMLVideoElement != "undefined" && obj instanceof HTMLVideoElement) {
+        obj = `Video->{ src: "${obj.src}", width: ${obj.videoWidth}, height: ${obj.videoHeight}, duration: ${obj.duration} }`;
+      } else if (typeof Storage != "undefined" && obj instanceof Storage) {
+        obj = `Storage->{ length: ${obj.length} }`;
+      }
+      else if ((typeof Worker != "undefined" && typeof ServiceWorker != "undefined" && typeof SharedWorker != "undefined") && (obj instanceof Worker || obj instanceof ServiceWorker || obj instanceof SharedWorker)) {
+        obj = `Worker->${obj.constructor.name} { scriptURL: "${obj.scriptURL}" }`;
+      } else if (typeof WebSocket != "undefined" && obj instanceof WebSocket) {
+        obj = `WebSocket->{ url: "${obj.url}", readyState: ${obj.readyState} }`;
+      }
+      else if (typeof XMLHttpRequest != "undefined" && obj instanceof XMLHttpRequest) {
+        obj = `XMLHttpRequest->{ readyState: ${obj.readyState}, status: ${obj.status} }`;
+      }
+      else if (typeof EventSource != "undefined" && obj instanceof EventSource) {
+        obj = `EventSource->{ url: "${obj.url}", readyState: ${obj.readyState} }`;
+      }
+      else if (typeof MediaStream != "undefined" && obj instanceof MediaStream) {
+        obj = `MediaStream->{ id: "${obj.id}", active: ${obj.active} }`;
+      }
+      else if (typeof RTCPeerConnection != "undefined" && obj instanceof RTCPeerConnection) {
+        obj = `RTCPeerConnection->{ connectionState: "${obj.connectionState}" }`;
+      }
+      else if (typeof AudioContext != "undefined" && obj instanceof AudioContext) {
+        obj = `AudioContext->{ state: "${obj.state}" }`
+      }
+      else if (typeof Element != "undefined" && obj instanceof Element) {
+        obj = `Element->{ tagName: "${obj.tagName}", id: "${obj.id}", class: "${obj.className}" }`
+      }
+      else if (typeof HTMLCanvasElement != "undefined" && obj instanceof HTMLCanvasElement) {
+        obj = `Canvas->{ width: ${obj.width}, height: ${obj.height} }`
+      }
+      else if (typeof HTMLAudioElement != "undefined" && obj instanceof HTMLAudioElement) {
+        obj = `Audio->{ src: "${obj.src}", duration: ${obj.duration} }`;
+      }
+      else if (typeof HTMLVideoElement != "undefined" && obj instanceof HTMLVideoElement) {
+        obj = `Video->{ src: "${obj.src}", width: ${obj.videoWidth}, height: ${obj.videoHeight}, duration: ${obj.duration} }`;
+      }
+      else if (typeof Geolocation != "undefined" && obj instanceof Geolocation) {
+        obj = `Geolocation->{ }`;
+      }
+      else if (typeof Performance != "undefined" && obj instanceof Performance) {
+        obj = `Performance->{ now: ${obj.now()} }`
+      }
+      else if (typeof Event != "undefined" && obj instanceof Event) {
+        obj = `Event->{ type: "${obj.type}", target: "${obj.target}" }`;
+      }
+
+      if (typeof obj == "string") {
+        return this.truncateStrBySize(obj, maxSize);
+      }
+      if (typeof obj != "object") {
+        return obj;
+      }
+      if (maxSize < 2) return {};
+
+      let addEndOut = false;
+      if (maxSize > 50) {
+        let objSize = this.calculateStringByteSize(obj);
+        if (objSize > maxSize) {
+          maxSize = maxSize - 50;
+          addEndOut = true;
+        }
+      }
+
+      let sizeCount = 2;
+      let str = this.safeJsonStringify(obj, (key, value) => {
+        let keySize = this.calculateStringByteSize(key)
+        if (typeof value == "object") {
+          if (sizeCount + keySize + 6 > maxSize) {
+            return;
+          }
+          sizeCount = sizeCount + keySize + 6;
+          return value;
+        }
+        let valueSize = this.calculateStringByteSize(value)
+        let rowSize = keySize + valueSize + 6;
+        if (rowSize + sizeCount > maxSize) return;
+        sizeCount = sizeCount + rowSize;
+        return value;
+      })
+      let outPut = JSON.parse(str)
+      if (addEndOut) {
+        if (Array.isArray(outPut)) {
+          outPut.push('(已截断其余部分)')
+        } else if (typeof outPut == "object") {
+          outPut["*注意"] = "(已截断其余部分)";
+        }
+      }
+      // console.log("compressObject use time: " + (new Date().getTime() - t));
+      return outPut;
+    } catch (error) {
+      console.log("compressObject error", error);
+      return "";
+    }
+  },
+  /**
+   * 压缩数组不超过特定大小
+   * @param {any[]} [arr=[]] 需要处理的数组
+   * @param {string} [delType='start'] 数组超出后删除的开始位置
+   * @param {number} [maxSize=1024 * 972] 数组最大字节数
+   */
+  compressArray(arr = [], delType = "start", maxSize = 1024 * 972) {
+    let t = new Date().getTime()
+    try {
+      if (!arr || arr.length == 0 || !arr[0]) return [];
+      let i = 0;
+      while (true) {
+        i = i + 1;
+        if (i > 999999) return arr;
+        if (!arr || arr.length == 0) {
+          return [];
+        }
+        if (this.calculateStringByteSize(arr) <= maxSize) {
+          // consoleLog("compressArray t=>" + (new Date().getTime() - t) + "    i=>" + i)
+          return arr;
+        }
+        if (delType == "start") {
+          arr.splice(0, 1);
+        } else {
+          arr.splice(arr.length - 1, 1);
+        }
+      }
+    } catch (error) {
+      console.log("compressArray error", error);
+      return [];
+    }
+  },
+  /**
+   * 计算对象或字符串占用的字节大小，传入对象将自动转json
+   */
+  calculateStringByteSize(str) {
+    try {
+      let type = typeof str;
+      if (
+        type == "bigint"
+        || type == "number"
+        || type == "boolean"
+      ) {
+        return str.toString().length;
+      } else if (type == "function") {
+        str = str.toString().length
+      } else if (str === null || str === undefined) {
+        return 0;
+      } else {
+        try {
+          str = this.safeJsonStringify(str);
+          if (str && str.hasOwnProperty) {
+            return str.length;
+          } else {
+            return 1024 * 20;
+          }
+        } catch (error) {
+          console.log("calculateStringByteSize error", error);
+          return 1024 * 20;
+        }
+      }
+      let size = 0;
+      for (let i = 0; i < str.length; i++) {
+        const charCode = str.charCodeAt(i);
+        if (charCode < 0x0080) {
+          size += 1;
+        } else if (charCode < 0x0800) {
+          size += 2;
+        } else if (charCode >= 0xD800 && charCode <= 0xDFFF) {
+          size += 4;
+          i++;
+        } else {
+          size += 3;
+        }
+      }
+      return size;
+    } catch (error) {
+      console.log("calculateStringByteSize error", error);
+      return 1024 * 1024;
+    }
+  },
+  /**
+   * 安全的js对象转字符串
+   */
+  safeJsonStringify(obj, handleValue) {
+    if (!obj) return "{}";
+    try {
+      if (handleValue) {
+        return JSON.stringify(obj, (key, value) => {
+          return handleValue(key, value)
+        })
+      } else {
+        return JSON.stringify(obj, (key, value) => {
+          return value;
+        })
+      }
+    } catch (error) {
+      // 尝试解析json失败，可能是变量循环引用的问题，继续尝试增加WeakSet解析
+    }
+
+    try {
+      let seen = new WeakSet();
+      let jsonStr = JSON.stringify(obj, (key, value) => {
+        if (typeof value == "object") {
+          try {
+            if (value instanceof File) {
+              value = "js:File";
+            }
+            if (value && value.constructor && value.constructor.name && typeof value.constructor.name == "string") {
+              let className = value.constructor.name;
+              if (className == "VueComponent") {
+                return "js:Object:VueComponent";
+              }
+            }
+          } catch (error) { }
+        }
+        if (typeof value == "function") {
+          try {
+            value = value.toString();
+          } catch (error) {
+            value = "js:function";
+          }
+        }
+        if (typeof value === "object" && value !== null) {
+          // 处理循环引用问题
+          if (seen.has(value)) {
+            return;
+          }
+          seen.add(value);
+        }
+        if (handleValue && typeof handleValue == "function") {
+          try {
+            return handleValue(key, value);
+          } catch (error) {
+            console.log("handleValue error", error);
+          }
+          return;
+        }
+        return value;
+      });
+      seen = null;
+      return jsonStr;
+    } catch (error) {
+      return "{}";
+    }
+  },
+  /**
+   * 根据限制的字节大小截取字符串
+   */
+  truncateStrBySize(str = "", size = 20 * 1024) {
+    try {
+      if (size < 1) return "";
+      if (this.calculateStringByteSize(str) <= size) return str;
+      let endStr = "";
+      if (size > 30) {
+        endStr = "(已截断多余部分)"
+        size = size - 30;
+      }
+      let low = 0, high = str.length, mid;
+      while (low < high) {
+        mid = Math.floor((low + high) / 2);
+        let currentSize = this.calculateStringByteSize(str.substring(0, mid));
+        if (currentSize > size) {
+          // 如果大于限制值，减小高边界
+          high = mid;
+        } else {
+          // 如果小于或等于限制值，增加低边界
+          low = mid + 1;
+        }
+      }
+      // 返回截断的字符串，注意low-1是因为low是最后一次检查超出大小时的位置
+      return str.substring(0, low - 1) + endStr;
+    } catch (error) {
+      console.log("truncateStrBySize error", error);
+      return "";
+    }
+  }
+}

package/devTools/core/libs/logReport.js

@@ -0,0 +1,59 @@
+import devCache from "./devCache";
+import devOptions from "./devOptions";
+import jsonCompress from "./jsonCompress";
+/**
+ * ! 运行日志提交工具
+ */
+
+
+
+/**
+ * 日志上报
+ */
+function logReport(msg) {
+  try {
+    if (!msg) return false;
+    let options = devOptions.getOptions()
+    if (!options.status) {
+      console.error("日志上报失败！dev工具未启用 msg:" + msg);
+      return;
+    }
+    if (!options.logs.status) {
+      console.error("日志上报失败！dev logs未启用 msg:" + msg);
+      return;
+    }
+
+    if (typeof msg == "object") {
+      try {
+        msg = JSON.stringify(msg)
+      } catch (error) {
+        msg = "logReport:error"
+      }
+    }
+
+    let log = {
+      t: new Date().getTime(),
+      m: "",
+    }
+    let logSize = jsonCompress.calculateStringByteSize(log)
+
+    msg = String(msg);
+    msg = jsonCompress.compressObject(msg, options.logs.cache.rowSize - logSize)
+    log.m = msg;
+
+    let logs = devCache.get("logReport");
+    if (!logs) logs = [];
+
+    logs.unshift(log);
+
+    logs = jsonCompress.compressArray(logs, "end", options.logs.cache.size)
+
+    devCache.set("logReport", logs)
+  } catch (error) {
+    console.log("logReport error", error);
+  }
+}
+
+
+
+export default logReport;

package/devTools/core/libs/pageLinkList.js

@@ -0,0 +1,125 @@
+import devCache from "./devCache"
+
+export default {
+  pageRouteMap: [],
+  pageRouteKeyMap: {},
+  /**
+   * 安装路径分析插件
+   */
+  install() {
+
+    let allRoutes = this.getAllRoutes();
+
+    let pageRouteKeyMap = devCache.get("pageRouteKeyMap")
+    if (!pageRouteKeyMap || typeof pageRouteKeyMap != "object") {
+      pageRouteKeyMap = {}
+    }
+
+    let lastNo = 0;
+    Object.keys(pageRouteKeyMap).forEach((key) => {
+      let item = Number(pageRouteKeyMap[key])
+      if (item > lastNo) {
+        lastNo = item;
+      }
+    })
+
+    allRoutes.forEach(item => {
+      if (!pageRouteKeyMap[item.path]) {
+        pageRouteKeyMap[item.path] = lastNo + 1;
+        lastNo = lastNo + 1;
+      }
+    })
+
+    devCache.set("pageRouteKeyMap", pageRouteKeyMap)
+    this.pageRouteKeyMap = pageRouteKeyMap;
+
+
+    let pageRouteMap = devCache.get("pageRouteMap");
+    if (!pageRouteMap || typeof pageRouteMap != "object") {
+      pageRouteMap = {}
+    }
+
+    Object.keys(pageRouteMap).forEach((key) => {
+      try {
+        let n = Number(pageRouteMap[key]);
+        if (!Number.isInteger(n) || n < 0) {
+          pageRouteMap[key] = 1;
+        }
+      } catch (error) { }
+    })
+    this.pageRouteMap = pageRouteMap;
+
+    this.saveData()
+
+  },
+  /**
+   * 获取APP注册的所有路由
+   * @returns {{path: string}[]} 返回路由列表
+   */
+  getAllRoutes() {
+    let pages = [];
+    // #ifdef H5 || APP-PLUS
+    try {
+      __uniRoutes.map((item) => {
+        let path = item.alias ? item.alias : item.path;
+        pages.push({ path })
+      });
+    } catch (error) {
+      pages = [];
+    }
+    // #endif
+    // #ifdef MP-WEIXIN
+    try {
+      let wxPages = __wxConfig.pages;
+      wxPages.map((item) => {
+        pages.push({
+          path: "/" + item,
+        })
+      });
+    } catch (error) {
+      pages = [];
+    }
+    // #endif
+    return pages;
+  },
+  /**
+   * 写入路由列表
+   */
+  pushPageRouteMap(list = []) {
+    if (!list || list.length == 0) {
+      list = getCurrentPages()
+    }
+    let key = ""
+    list.forEach((item) => {
+      let path = item.route.indexOf("/") == 0 ? item.route : "/" + item.route;
+      let keyItem = this.pageRouteKeyMap[path];
+      if (!keyItem) {
+        keyItem = path;
+      }
+      if (key == "") {
+        key = keyItem + ""
+      } else {
+        key = key + "," + keyItem
+      }
+    })
+
+    if (this.pageRouteMap[key]) {
+      this.pageRouteMap[key] = this.pageRouteMap[key] + 1;
+    } else {
+      this.pageRouteMap[key] = 1;
+    }
+
+  },
+  /**
+   * 保存路由缓存
+   */
+  saveData() {
+    let that = this;
+    setTimeout(() => {
+      devCache.set("pageRouteMap", that.pageRouteMap)
+      setTimeout(() => {
+        that.saveData()
+      }, 500);
+    }, Math.round(Math.random() * 3 * 1000) + 2000);
+  },
+}

package/devTools/core/libs/timeFormat.js

@@ -0,0 +1,94 @@
+// padStart 的 polyfill，因为某些机型或情况，还无法支持es7的padStart，比如电脑版的微信小程序
+// 所以这里做一个兼容polyfill的兼容处理
+try {
+	if (!String.prototype.padStart) {
+		// 为了方便表示这里 fillString 用了ES6 的默认参数，不影响理解
+		String.prototype.padStart = function (maxLength, fillString = ' ') {
+			if (Object.prototype.toString.call(fillString) !== "[object String]") throw new TypeError(
+				'fillString must be String')
+			let str = this
+			// 返回 String(str) 这里是为了使返回的值是字符串字面量，在控制台中更符合直觉
+			if (str.length >= maxLength) return String(str)
+
+			let fillLength = maxLength - str.length,
+				times = Math.ceil(fillLength / fillString.length)
+			while (times >>= 1) {
+				fillString += fillString
+				if (times === 1) {
+					fillString += fillString
+				}
+			}
+			return fillString.slice(0, fillLength) + str;
+		}
+	}
+} catch (error) {
+	console.log("timeFormat fillString error", error);
+}
+
+// 其他更多是格式化有如下:
+// yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合
+export function timeFormat(dateTime = null, fmt = 'yyyy-mm-dd hh:MM:ss') {
+	try {
+		// 如果为null,则格式化当前时间
+		if (!dateTime) dateTime = Number(new Date());
+		// 如果dateTime长度为10或者13，则为秒和毫秒的时间戳，如果超过13位，则为其他的时间格式
+		if (dateTime.toString().length == 10) dateTime *= 1000;
+		let date = new Date(dateTime);
+		let ret;
+		let opt = {
+			"y+": date.getFullYear().toString(), // 年
+			"m+": (date.getMonth() + 1).toString(), // 月
+			"d+": date.getDate().toString(), // 日
+			"h+": date.getHours().toString(), // 时
+			"M+": date.getMinutes().toString(), // 分
+			"s+": date.getSeconds().toString() // 秒
+			// 有其他格式化字符需求可以继续添加，必须转化成字符串
+		};
+		for (let k in opt) {
+			ret = new RegExp("(" + k + ")").exec(fmt);
+			if (ret) {
+				fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
+			};
+		};
+		return fmt;
+	} catch (error) {
+		console.log("timeFormat error", error);
+		return "unknown error"
+	}
+}
+
+export function timeFromNow(timestamp) {
+	try {
+		const now = new Date().getTime();
+		let diff = timestamp - now;
+
+		// 确定是过去还是未来
+		const suffix = diff > 0 ? "后" : "前";
+		diff = Math.abs(diff);
+
+		// 计算时间差异
+		const seconds = Math.floor(diff / 1000);
+		const minutes = Math.floor(seconds / 60);
+		const hours = Math.floor(minutes / 60);
+		const days = Math.floor(hours / 24);
+		const months = Math.floor(days / 30);
+		const years = Math.floor(days / 365);
+
+		// 根据时间差异返回相应的字符串
+		if (seconds < 60) {
+			return `${seconds}秒${suffix}`;
+		} else if (minutes < 60) {
+			return `${minutes}分钟${suffix}`;
+		} else if (hours < 24) {
+			return `${hours}小时${suffix}`;
+		} else if (days < 30) {
+			return `${days}天${suffix}`;
+		} else if (months < 12) {
+			return `${months}个月${suffix}`;
+		} else {
+			return `${years}年${suffix}`;
+		}
+	} catch (error) {
+		console.log("timeFromNow error", error);
+	}
+}