@hhfenpm/utils 1.0.1 → 1.0.3

package/dist/index.js

@@ -2196,66 +2196,107 @@ function cleanEscapedString(input) {
   return matched[1].replace(doubleQuoteRegExp, "'");
 }
 
-// 数据格式化
+/**
+ * 数据格式化工具
+ */
 
-// 完整时间：yyyy-MM-dd HH:mm:ss
-function format_date(timestamp, str = "yyyy-MM-dd") {
+/**
+ * 日期格式化
+ * @param {number|string} timestamp - 时间戳
+ * @param {string} formatStr - 格式化字符串，默认 "yyyy-MM-dd"
+ * @returns {string} 格式化后的日期字符串
+ */
+function formatDate(timestamp, formatStr = 'yyyy-MM-dd') {
   if (!timestamp) return ''
   try {
     const num = +timestamp;
     if (num) {
-      return format(num, str)
+      return format(num, formatStr)
     }
-    return format(new Date(timestamp), str)
+    return format(new Date(timestamp), formatStr)
   } catch (error) {
     return ''
   }
 }
 
+/**
+ * 日期时间格式化（精确到分钟）
+ * @param {number|string} timestamp - 时间戳
+ * @returns {string} 格式化后的日期时间字符串 "yyyy-MM-dd HH:mm"
+ */
 function formatDateMinute(timestamp) {
   if (!timestamp) return ''
   try {
-    return format(+timestamp, "yyyy-MM-dd HH:mm")
+    return format(+timestamp, 'yyyy-MM-dd HH:mm')
   } catch (error) {
     return ''
   }
 }
 
-// 小数转百分比 数字（会删除小数点后面的0）
-function format_decimal(number = 0, num = 2, scale = 100) {
-  return +(+number * scale).toFixed(num)
+/**
+ * 小数转百分比（数字，会删除小数点后面的0）
+ * @param {number} number - 小数
+ * @param {number} decimalPlaces - 保留小数位数，默认2
+ * @param {number} scale - 缩放比例，默认100
+ * @returns {number} 百分比数字
+ */
+function formatDecimal(number = 0, decimalPlaces = 2, scale = 100) {
+  return +(+number * scale).toFixed(decimalPlaces)
 }
 
-// 小数转百分比 字符串（不会删除小数点后面的0）
-function format_decimal_string(number = 0, num = 2, scale = 100) {
-  return (+number * scale).toFixed(num)
+/**
+ * 小数转百分比（字符串，不会删除小数点后面的0）
+ * @param {number} number - 小数
+ * @param {number} decimalPlaces - 保留小数位数，默认2
+ * @param {number} scale - 缩放比例，默认100
+ * @returns {string} 百分比字符串
+ */
+function formatDecimalString(
+  number = 0,
+  decimalPlaces = 2,
+  scale = 100
+) {
+  return (+number * scale).toFixed(decimalPlaces)
 }
 
-// 处理金额
-function format_money(number = 0, num = 2, scale = 100) {
-  return (+number / scale).toFixed(num)
+/**
+ * 金额格式化
+ * @param {number} number - 金额数字
+ * @param {number} decimalPlaces - 保留小数位数，默认2
+ * @param {number} scale - 缩放比例，默认100
+ * @returns {string} 格式化后的金额字符串
+ */
+function formatMoney(number = 0, decimalPlaces = 2, scale = 100) {
+  return (+number / scale).toFixed(decimalPlaces)
 }
 
-// 创建唯一id
-function create_guid() {
+/**
+ * 创建唯一ID
+ * @returns {string} 唯一ID
+ */
+function createGuid() {
   return (
     (Math.random() * 10000000).toString(16).substring(0, 4) +
-    "-" +
+    '-' +
     new Date().getTime() +
-    "-" +
+    '-' +
     Math.random().toString().substring(2, 7)
   )
 }
 
-// 数字格式
-function format_number(num) {
-  if (!num) return 0
+/**
+ * 数字格式化（千分位）
+ * @param {number} num - 数字
+ * @returns {string} 格式化后的数字字符串
+ */
+function formatNumber(num) {
+  if (!num) return '0'
   let str = `${num}`;
   let len = str.length;
   if (len === 3) {
     return str
   }
-  let str2 = "";
+  let str2 = '';
   let max = Math.floor(len / 3);
   if (len % 3 === 0) {
     max = max - 1;
@@ -2263,19 +2304,24 @@ function format_number(num) {
   for (let i = 0; i < max; i++) {
     let s = str.slice(len - 3, len);
     str = str.substring(0, len - 3);
-    str2 = "," + s + str2;
+    str2 = ',' + s + str2;
     len = str.length;
   }
   str += str2;
   return str
 }
 
-// 数组转标签
-function arr_label(arr, props) {
+/**
+ * 数组转标签对象
+ * @param {Array} arr - 数组
+ * @param {Object} props - 属性映射 {label: 'label', value: 'value', children: 'children', re: true}
+ * @returns {Object} 标签对象
+ */
+function arrToLabel(arr, props) {
   props = {
-    label: "label",
-    value: "value",
-    children: "children",
+    label: 'label',
+    value: 'value',
+    children: 'children',
     re: true,
     ...props,
   };
@@ -2292,11 +2338,16 @@ function arr_label(arr, props) {
   return obj
 }
 
-// 数组转对象
-function arr_obj(arr, props) {
+/**
+ * 数组转对象
+ * @param {Array} arr - 数组
+ * @param {Object} props - 属性映射 {value: 'value', children: 'children', re: true}
+ * @returns {Object} 对象
+ */
+function arrToObj(arr, props) {
   props = {
-    value: "value",
-    children: "children",
+    value: 'value',
+    children: 'children',
     re: true,
     ...props,
   };
@@ -2313,53 +2364,69 @@ function arr_obj(arr, props) {
   return obj
 }
 
-// 复制
-function copy_content(content) {
+/**
+ * 复制文本到剪贴板
+ * @param {string} content - 要复制的内容
+ * @returns {boolean} 是否成功
+ */
+function copyContent(content) {
   if (typeof document === 'undefined') {
-    console.warn('copy_content需要在浏览器环境使用');
+    console.warn('copyContent需要在浏览器环境使用');
     return false
   }
-  const input = document.createElement("input");
-  input.setAttribute("value", content);
+  const input = document.createElement('input');
+  input.setAttribute('value', content);
   document.body.appendChild(input);
   input.select();
-  const result = document.execCommand("copy");
+  const result = document.execCommand('copy');
   document.body.removeChild(input);
   return result
 }
 
-//计算高度
-function calculate_height(item, container) {
+/**
+ * 计算高度（判断元素高度是否超过容器）
+ * @param {string} itemId - 元素ID
+ * @param {string} containerId - 容器ID
+ * @returns {boolean} 元素高度是否超过容器
+ */
+function calculateHeight(itemId, containerId) {
   if (typeof document === 'undefined') {
     return false
   }
-  const dom = document.getElementById(item);
-  const containerDom = document.getElementById(container);
+  const dom = document.getElementById(itemId);
+  const containerDom = document.getElementById(containerId);
   if (dom && containerDom) {
     const height = dom.offsetHeight;
-    const max_height = containerDom.offsetHeight;
-    return height > max_height
+    const maxHeight = containerDom.offsetHeight;
+    return height > maxHeight
   }
   return false
 }
 
-// 文字超过8个...
-function formatTxt(text) {
-  if (!text) return ""
-
-  let trimTetx = text.trim();
-
-  if (trimTetx.length <= 8) {
-    return trimTetx
+/**
+ * 文字截断（超过指定长度显示...）
+ * @param {string} text - 文本
+ * @param {number} maxLength - 最大长度，默认8
+ * @returns {string} 截断后的文本
+ */
+function formatText(text, maxLength = 8) {
+  if (!text) return ''
+  let trimText = text.trim();
+  if (trimText.length <= maxLength) {
+    return trimText
   }
-
-  return trimTetx.substring(0, 8) + "..."
+  return trimText.substring(0, maxLength) + '...'
 }
 
-//设置光标
-function set_cursor(dom, start = 0, end = 0) {
+/**
+ * 设置光标位置（用于contenteditable元素）
+ * @param {HTMLElement} dom - DOM元素
+ * @param {number} start - 起始位置，默认0
+ * @param {number} end - 结束位置，默认0
+ */
+function setCursor(dom, start = 0, end = 0) {
   if (typeof window === 'undefined' || !dom) {
-    console.warn('set_cursor需要在浏览器环境使用');
+    console.warn('setCursor需要在浏览器环境使用');
     return
   }
   const selection = window.getSelection();
@@ -2371,11 +2438,19 @@ function set_cursor(dom, start = 0, end = 0) {
   dom.focus();
 }
 
-// 同步setTimeout
+/**
+ * 同步setTimeout（Promise版本）
+ * @param {number} time - 延迟时间（毫秒）
+ * @returns {Promise} Promise对象
+ */
 function sleep(time) {
-  return new Promise((resolve) => setTimeout(resolve, time))
+  return new Promise(resolve => setTimeout(resolve, time))
 }
 
+/**
+ * 检测浏览器缩放比例
+ * @returns {number} 缩放比例
+ */
 function detectZoom() {
   if (typeof window === 'undefined') {
     return 1
@@ -2390,7 +2465,10 @@ function detectZoom() {
     if (screen.deviceXDPI && screen.logicalXDPI) {
       ratio = screen.deviceXDPI / screen.logicalXDPI;
     }
-  } else if (window.outerWidth !== undefined && window.innerWidth !== undefined) {
+  } else if (
+    window.outerWidth !== undefined &&
+    window.innerWidth !== undefined
+  ) {
     ratio = window.outerWidth / window.innerWidth;
   }
 
@@ -2399,25 +2477,28 @@ function detectZoom() {
 
 /**
  * 递归查找树节点
- * @param {Array} tree 树数据
- * @param {String} id 节点id值
- * @param {Object} keyMap 节点字段映射
- * @returns {Object|Null} 节点对象
+ * @param {Array} tree - 树数据
+ * @param {string} id - 节点id值
+ * @param {Object} keyMap - 节点字段映射 {id: 'id', children: 'children'}
+ * @returns {Object|null} 节点对象
  */
 function findNodeOfTree(tree, id, keyMap = {}) {
-  const _keyMap = {
-    id: "id",
-    children: "children",
+  const keyMapConfig = {
+    id: 'id',
+    children: 'children',
     ...keyMap,
   };
 
   function searchTree(nodes) {
     for (let node of nodes) {
-      if (node[_keyMap.id] === id) {
+      if (node[keyMapConfig.id] === id) {
         return node
       }
-      if (node[_keyMap.children] && node[_keyMap.children].length > 0) {
-        const foundNode = searchTree(node[_keyMap.children]);
+      if (
+        node[keyMapConfig.children] &&
+        node[keyMapConfig.children].length > 0
+      ) {
+        const foundNode = searchTree(node[keyMapConfig.children]);
         if (foundNode) {
           return foundNode
         }
@@ -2429,24 +2510,35 @@ function findNodeOfTree(tree, id, keyMap = {}) {
   return searchTree(tree)
 }
 
-function copyToClip(content, type = "input") {
+/**
+ * 复制文本到剪贴板（兼容版）
+ * @param {string} content - 要复制的内容
+ * @param {string} type - 元素类型，'input' 或 'textarea'，默认'input'
+ * @returns {boolean} 是否成功
+ */
+function copyToClip(content, type = 'input') {
   if (typeof document === 'undefined') {
     console.warn('copyToClip需要在浏览器环境使用');
     return false
   }
-  var aux = document.createElement(type);
+  const aux = document.createElement(type);
   document.body.appendChild(aux);
-  if (type === "input") {
-    aux.setAttribute("value", content);
+  if (type === 'input') {
+    aux.setAttribute('value', content);
   } else {
     aux.value = content;
   }
   aux.select();
-  const result = document.execCommand("copy");
+  const result = document.execCommand('copy');
   document.body.removeChild(aux);
   return result
 }
 
+/**
+ * 手机号脱敏
+ * @param {string|number} phone - 手机号
+ * @returns {string} 脱敏后的手机号
+ */
 function hidePhone(phone) {
   if (!phone) return ''
   phone = phone.toString();
@@ -2454,7 +2546,9 @@ function hidePhone(phone) {
 }
 
 /**
- * 将字符串中的属于正则表达式的特殊字符，转换成正则表达式中的普通字符
+ * 转义正则表达式特殊字符
+ * @param {string} string - 要转义的字符串
+ * @returns {string} 转义后的字符串
  */
 function escapeRegExp(string) {
   if (!string) {
@@ -2463,10 +2557,19 @@ function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-// 基于 Promise 的 validateField 方法，为了校验多个字段时避免回调地狱
+/**
+ * 数据验证工具
+ */
+
+/**
+ * 基于Promise的表单字段验证（避免回调地狱）
+ * @param {string} prop - 字段名
+ * @param {Object} form - 表单实例
+ * @returns {Promise} Promise对象，验证通过resolve，失败reject
+ */
 function validateFieldAsync(prop, form) {
   return new Promise((resolve, reject) => {
-    form.validateField(prop, (valid) => {
+    form.validateField(prop, valid => {
       if (valid) {
         reject(new Error(valid));
       } else {
@@ -2476,19 +2579,28 @@ function validateFieldAsync(prop, form) {
   })
 }
 
-// 校验手机号
+/**
+ * 手机号验证规则
+ * @param {Object} rule - 验证规则
+ * @param {string} value - 待验证的值
+ * @param {Function} callback - 回调函数
+ */
 function validatePhone(rule, value, callback) {
   const reg = /^1[3456789]\d{9}$/;
   if (!value) {
-    return callback(new Error("请输入手机号"))
+    return callback(new Error('请输入手机号'))
   } else if (!reg.test(value)) {
-    return callback(new Error("请输入正确的手机号"))
+    return callback(new Error('请输入正确的手机号'))
   } else {
     callback();
   }
 }
 
-// 对象是否为空
+/**
+ * 判断对象是否为空
+ * @param {Object} obj - 待判断的对象
+ * @returns {boolean} 是否为空对象
+ */
 function isEmptyObj(obj) {
   for (const name in obj) {
     return false
@@ -2496,102 +2608,117 @@ function isEmptyObj(obj) {
   return true
 }
 
-// 只判断两个值对应相等，不包含引用
+/**
+ * 深度比较两个值是否相等（不包含引用比较）
+ * @param {*} a - 第一个值
+ * @param {*} b - 第二个值
+ * @returns {boolean} 是否相等
+ */
 function isEqual(a, b) {
   const classNameA = Object.prototype.toString.call(a);
   const classNameB = Object.prototype.toString.call(b);
+
   // 如果数据类型不相等，则返回false
   if (classNameA !== classNameB) {
     return false
-  } else {
-    // 如果数据类型相等，再根据不同数据类型分别判断
-    if (classNameA === "[object Object]") {
-      for (let key in a) {
-        if (!isEqual(a[key], b[key])) return false
-      }
-      for (let key in b) {
-        if (!isEqual(a[key], b[key])) return false
+  }
+
+  // 如果数据类型相等，再根据不同数据类型分别判断
+  if (classNameA === '[object Object]') {
+    for (let key in a) {
+      if (!isEqual(a[key], b[key])) return false
+    }
+    for (let key in b) {
+      if (!isEqual(a[key], b[key])) return false
+    }
+    return true
+  } else if (classNameA === '[object Array]') {
+    if (a.length !== b.length) {
+      return false
+    } else {
+      for (let i = 0, len = a.length; i < len; i++) {
+        if (!isEqual(a[i], b[i])) return false
       }
       return true
-    } else if (classNameA === "[object Array]") {
-      if (a.length !== b.length) {
-        return false
-      } else {
-        for (let i = 0, len = a.length; i < len; i++) {
-          if (!isEqual(a[i], b[i])) return false
-        }
-        return true
-      }
-    } else if (classNameA === "[object Function]") {
-      return a.toString() === b.toString()
-    } else {
-      return Object.is(a, b)
     }
+  } else if (classNameA === '[object Function]') {
+    return a.toString() === b.toString()
+  } else {
+    return Object.is(a, b)
   }
 }
 
-// 是否为空
+/**
+ * 判断值是否为空
+ * @param {*} value - 待判断的值
+ * @returns {boolean} 是否为空
+ */
 function isEmpty(value) {
-  if (value === undefined || value === null || value === "") {
+  if (value === undefined || value === null || value === '') {
     return true
   }
   return false
 }
 
+/**
+ * 获取浏览器信息
+ * @returns {Object} {type: string, version: string}
+ */
 function getBrowserInfo() {
   if (typeof navigator === 'undefined') {
     return {
-      type: "Unknown",
-      version: "Unknown",
+      type: 'Unknown',
+      version: 'Unknown',
     }
   }
+
   const userAgent = navigator.userAgent;
-  let browserType = "Unknown";
-  let browserVersion = "Unknown";
+  let browserType = 'Unknown';
+  let browserVersion = 'Unknown';
 
   // Check for Firefox
-  if (userAgent.indexOf("Firefox") > -1) {
-    browserType = "Mozilla Firefox";
+  if (userAgent.indexOf('Firefox') > -1) {
+    browserType = 'Mozilla Firefox';
     const match = userAgent.match(/Firefox\/(\d+\.\d+)/);
-    browserVersion = match ? match[1] : "Unknown";
+    browserVersion = match ? match[1] : 'Unknown';
   }
   // Check for Samsung Browser
-  else if (userAgent.indexOf("SamsungBrowser") > -1) {
-    browserType = "Samsung Internet";
+  else if (userAgent.indexOf('SamsungBrowser') > -1) {
+    browserType = 'Samsung Internet';
     const match = userAgent.match(/SamsungBrowser\/(\d+\.\d+)/);
-    browserVersion = match ? match[1] : "Unknown";
+    browserVersion = match ? match[1] : 'Unknown';
   }
   // Check for Opera or OPR (Opera based on Chromium)
-  else if (userAgent.indexOf("Opera") > -1 || userAgent.indexOf("OPR") > -1) {
-    browserType = "Opera";
+  else if (userAgent.indexOf('Opera') > -1 || userAgent.indexOf('OPR') > -1) {
+    browserType = 'Opera';
     const match = userAgent.match(/(Opera|OPR)\/(\d+\.\d+)/);
-    browserVersion = match ? match[2] : "Unknown";
+    browserVersion = match ? match[2] : 'Unknown';
   }
   // Check for Internet Explorer
-  else if (userAgent.indexOf("Trident") > -1) {
-    browserType = "Microsoft Internet Explorer";
+  else if (userAgent.indexOf('Trident') > -1) {
+    browserType = 'Microsoft Internet Explorer';
     const versionMatch = userAgent.match(/rv:(\d+\.\d+)/);
     if (versionMatch) {
       browserVersion = versionMatch[1];
     }
   }
   // Check for Microsoft Edge
-  else if (userAgent.indexOf("Edge") > -1) {
-    browserType = "Microsoft Edge";
+  else if (userAgent.indexOf('Edge') > -1) {
+    browserType = 'Microsoft Edge';
     const match = userAgent.match(/Edge\/(\d+\.\d+)/);
-    browserVersion = match ? match[1] : "Unknown";
+    browserVersion = match ? match[1] : 'Unknown';
   }
   // Check for Google Chrome
-  else if (userAgent.indexOf("Chrome") > -1) {
-    browserType = "Google Chrome";
+  else if (userAgent.indexOf('Chrome') > -1) {
+    browserType = 'Google Chrome';
     const match = userAgent.match(/Chrome\/(\d+\.\d+)/);
-    browserVersion = match ? match[1] : "Unknown";
+    browserVersion = match ? match[1] : 'Unknown';
   }
   // Check for Apple Safari
-  else if (userAgent.indexOf("Safari") > -1) {
-    browserType = "Apple Safari";
+  else if (userAgent.indexOf('Safari') > -1) {
+    browserType = 'Apple Safari';
     const match = userAgent.match(/Version\/(\d+\.\d+)/);
-    browserVersion = match ? match[1] : "Unknown";
+    browserVersion = match ? match[1] : 'Unknown';
   }
 
   return {
@@ -2600,21 +2727,36 @@ function getBrowserInfo() {
   }
 }
 
+/**
+ * 检测浏览器是否支持媒体设备（getUserMedia）
+ * @returns {boolean} 是否支持
+ */
 function isSupported() {
   if (typeof navigator === 'undefined') {
     return false
   }
+
   const browserInfo = getBrowserInfo();
-  if (browserInfo.type === "Mozilla Firefox") {
+
+  // Firefox需要版本大于38
+  if (browserInfo.type === 'Mozilla Firefox') {
     return parseFloat(browserInfo.version) > 38
   }
+
+  // 检测是否支持getUserMedia
   return !!(
     navigator.mediaDevices &&
-    (navigator.mediaDevices.getUserMedia || navigator.getUserMedia || navigator.webkitGetUserMedia)
+    (navigator.mediaDevices.getUserMedia ||
+      navigator.getUserMedia ||
+      navigator.webkitGetUserMedia)
   )
 }
 
-// 校验无意义连续符号
+/**
+ * 校验无意义连续符号
+ * @param {string} input - 待校验的输入
+ * @returns {Object} {isValid: boolean, message: string}
+ */
 function validateMeaninglessConsecutiveSymbols(input) {
   // 检查是否为空
   if (input.trim() === '') {
@@ -2623,6 +2765,7 @@ function validateMeaninglessConsecutiveSymbols(input) {
       message: '请输入内容',
     }
   }
+
   // 检查连续符号（中英文符号）
   const symbolRegex =
     /([\-\+\=\*\.\,\;\:\!\@\#\$\%\^\&\_\(\)\[\]\{\}\|\\\/\?\<\>\~\"\'\`\s]|[\u3000-\u303F]|[\uFF00-\uFFEF])\1{6,}/;
@@ -2632,6 +2775,7 @@ function validateMeaninglessConsecutiveSymbols(input) {
       message: '输入无意义内容，请修改',
     }
   }
+
   // 检查连续数字
   const digitRegex = /(\d)\1{6,}/;
   if (digitRegex.test(input)) {
@@ -2640,6 +2784,7 @@ function validateMeaninglessConsecutiveSymbols(input) {
       message: '输入无意义内容，请修改',
     }
   }
+
   // 检查连续相同文字（中英文）
   const charRegex = /([\u4e00-\u9fa5a-zA-Z])\1{2,}/;
   if (charRegex.test(input)) {
@@ -2648,188 +2793,318 @@ function validateMeaninglessConsecutiveSymbols(input) {
       message: '输入无意义内容，请修改',
     }
   }
+
   return {
     isValid: true,
     message: '',
   }
 }
 
-// 数据存储
+/**
+ * 内存缓存工具
+ */
+
+/**
+ * 内存缓存对象
+ */
 const cache = {
   data: {},
+
+  /**
+   * 设置缓存
+   * @param {string} key - 键名
+   * @param {*} data - 数据
+   */
   set(key, data) {
     this.data[key] = data;
   },
+
+  /**
+   * 获取缓存
+   * @param {string} key - 键名
+   * @returns {*} 缓存的数据
+   */
   get(key) {
     return this.data[key]
   },
+
+  /**
+   * 清除缓存
+   * @param {string} key - 键名，如果不传则清除所有缓存
+   */
   clear(key) {
     if (key) {
       delete this.data[key];
     } else {
       this.data = {};
     }
-  }
+  },
 };
 
-// 建立唯一的key值
-const buildUniqueUrl = (url, method, params = {}, data = {}) => {
-  const paramStr = (obj) => {
+/**
+ * 构建唯一的URL key（用于请求缓存）
+ * @param {string} url - 请求URL
+ * @param {string} method - 请求方法
+ * @param {Object} params - URL参数
+ * @param {Object} data - 请求体数据
+ * @returns {string} 唯一的URL key
+ */
+function buildUniqueUrl(url, method, params = {}, data = {}) {
+  const paramStr = obj => {
     if (Object.prototype.toString.call(obj) === '[object Object]') {
-      return JSON.stringify(Object.keys(obj).sort().reduce((result, key) => {
-        result[key] = obj[key];
-        return result
-      }, {}))
+      return JSON.stringify(
+        Object.keys(obj)
+          .sort()
+          .reduce((result, key) => {
+            result[key] = obj[key];
+            return result
+          }, {})
+      )
     } else {
       return JSON.stringify(obj)
     }
   };
   url += `?${paramStr(params)}&${paramStr(data)}&${method}`;
   return url
-};
+}
 
-// 系统标识
-let system_flag = null;
+/**
+ * Session管理工具
+ * 提供localStorage和sessionStorage的封装，支持系统标识前缀
+ */
+
+let systemFlag = null;
 
-function set_system_key(key) {
-  system_flag = key;
-  return system_flag;
+/**
+ * 设置系统标识
+ * @param {string} flag - 系统标识
+ * @returns {string} 系统标识
+ */
+function setSystemKey(flag) {
+  systemFlag = flag;
+  return systemFlag
 }
 
-function get_system_key(key) {
-  if (!system_flag) {
-    console.warn("系统标识未设置，请先调用 set_system_key()");
-    return key;
+/**
+ * 获取带系统标识的key
+ * @param {string} key - 原始key
+ * @returns {string} 带系统标识的key
+ */
+function getSystemKey(key) {
+  if (!systemFlag) {
+    console.warn('系统标识未设置，请先调用 setSystemKey()');
+    return key
   }
-  return `${system_flag}_${key}`;
+  return `${systemFlag}_${key}`
 }
 
-// 用户信息
-function removeSession(key = "session") {
-  if (typeof window === "undefined" || !window.localStorage) {
-    console.warn("localStorage不可用");
-    return;
+/**
+ * 移除localStorage中的session
+ * @param {string} key - 键名，默认'session'
+ */
+function removeSession(key = 'session') {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    console.warn('localStorage不可用');
+    return
   }
-  localStorage.removeItem(get_system_key(key));
+  localStorage.removeItem(getSystemKey(key));
 }
 
-function setSession(session, key = "session") {
-  if (typeof window === "undefined" || !window.localStorage) {
-    console.warn("localStorage不可用");
-    return;
+/**
+ * 设置localStorage中的session
+ * @param {*} session - 要存储的数据
+ * @param {string} key - 键名，默认'session'
+ */
+function setSession(session, key = 'session') {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    console.warn('localStorage不可用');
+    return
   }
-  localStorage.setItem(get_system_key(key), JSON.stringify(session));
+  localStorage.setItem(getSystemKey(key), JSON.stringify(session));
 }
 
-function getSession(key = "session") {
-  if (typeof window === "undefined" || !window.localStorage) {
-    console.warn("localStorage不可用");
-    return null;
+/**
+ * 获取localStorage中的session
+ * @param {string} key - 键名，默认'session'
+ * @returns {*} 存储的数据
+ */
+function getSession(key = 'session') {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    console.warn('localStorage不可用');
+    return null
   }
-  const value = localStorage.getItem(get_system_key(key));
-  if (value === null || value === undefined || value === "") {
-    return value;
-  } else if (value === "undefined") {
-    return undefined;
+  const value = localStorage.getItem(getSystemKey(key));
+  if (value === null || value === undefined || value === '') {
+    return value
+  } else if (value === 'undefined') {
+    return undefined
   } else {
     try {
-      return JSON.parse(value);
+      return JSON.parse(value)
     } catch (e) {
-      console.error("解析session失败:", e);
-      return value;
+      console.error('解析session失败:', e);
+      return value
     }
   }
 }
 
-// 扩展session中的部分属性，而不是全量替换
-function extentSession(patch, key = "session") {
-  if (typeof window === "undefined" || !window.localStorage) {
-    console.warn("localStorage不可用");
-    return null;
+/**
+ * 扩展session中的部分属性，而不是全量替换
+ * @param {Object} patch - 要扩展的属性
+ * @param {string} key - 键名，默认'session'
+ * @returns {*} 更新后的session
+ */
+function extendSession(patch, key = 'session') {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    console.warn('localStorage不可用');
+    return null
   }
   const prev = getSession(key);
-  if (typeof prev === "object" && prev !== null) {
+  if (typeof prev === 'object' && prev !== null) {
     localStorage.setItem(
-      get_system_key(key),
+      getSystemKey(key),
       JSON.stringify({ ...prev, ...patch })
     );
   }
-  return getSession(key);
+  return getSession(key)
 }
 
-function setSessionStorage(session, key = "collapse") {
-  if (typeof window === "undefined" || !window.sessionStorage) {
-    console.warn("sessionStorage不可用");
-    return;
+/**
+ * 扩展session中的部分属性（向后兼容，拼写错误但保留）
+ * @param {Object} patch - 要扩展的属性
+ * @param {string} key - 键名，默认'session'
+ * @returns {*} 更新后的session
+ * @deprecated 请使用 extendSession，此函数保留仅为向后兼容
+ */
+const extentSession = extendSession;
+
+/**
+ * 设置sessionStorage
+ * @param {*} session - 要存储的数据
+ * @param {string} key - 键名，默认'collapse'
+ */
+function setSessionStorage(session, key = 'collapse') {
+  if (typeof window === 'undefined' || !window.sessionStorage) {
+    console.warn('sessionStorage不可用');
+    return
   }
-  sessionStorage.setItem(get_system_key(key), JSON.stringify(session));
+  sessionStorage.setItem(getSystemKey(key), JSON.stringify(session));
 }
 
-function getSessionStorage(key = "collapse") {
-  if (typeof window === "undefined" || !window.sessionStorage) {
-    console.warn("sessionStorage不可用");
-    return null;
+/**
+ * 获取sessionStorage
+ * @param {string} key - 键名，默认'collapse'
+ * @returns {*} 存储的数据
+ */
+function getSessionStorage(key = 'collapse') {
+  if (typeof window === 'undefined' || !window.sessionStorage) {
+    console.warn('sessionStorage不可用');
+    return null
   }
-  const value = sessionStorage.getItem(get_system_key(key));
-  if (value === null || value === undefined || value === "") {
-    return value;
-  } else if (value === "undefined") {
-    return undefined;
+  const value = sessionStorage.getItem(getSystemKey(key));
+  if (value === null || value === undefined || value === '') {
+    return value
+  } else if (value === 'undefined') {
+    return undefined
   } else {
     try {
-      return JSON.parse(value);
+      return JSON.parse(value)
     } catch (e) {
-      console.error("解析sessionStorage失败:", e);
-      return value;
+      console.error('解析sessionStorage失败:', e);
+      return value
     }
   }
 }
 
-function removeSessionStorage(key = "collapse") {
-  if (typeof window === "undefined" || !window.sessionStorage) {
-    console.warn("sessionStorage不可用");
-    return;
+/**
+ * 移除sessionStorage
+ * @param {string} key - 键名，默认'collapse'
+ */
+function removeSessionStorage(key = 'collapse') {
+  if (typeof window === 'undefined' || !window.sessionStorage) {
+    console.warn('sessionStorage不可用');
+    return
   }
-  sessionStorage.removeItem(get_system_key(key));
+  sessionStorage.removeItem(getSystemKey(key));
 }
 
-// 图片地址
+/**
+ * 图片URL处理工具
+ * 注意：需要配置 GLOBAL_CONFIG.backend_server
+ */
+
+/**
+ * 获取图片URL
+ * @param {string} url - 图片路径
+ * @returns {string} 完整的图片URL
+ */
 function getImgURL(url) {
   if (!url) return ''
-  if (!/^http/g.test(url) && !/^data:image/g.test(url)) {
-    const backendServer = typeof window !== 'undefined' && window.GLOBAL_CONFIG 
-      ? window.GLOBAL_CONFIG.backend_server 
+
+  // 如果已经是完整的URL或data URL，直接返回
+  if (/^http/g.test(url) || /^data:image/g.test(url)) {
+    return url
+  }
+
+  // 获取基础URL
+  const backendServer =
+    typeof window !== 'undefined' && window.GLOBAL_CONFIG
+      ? window.GLOBAL_CONFIG.backend_server
       : '';
-    if (backendServer) {
-      url = `${backendServer}/_uploads/files/${url}`;
-    }
+
+  if (!backendServer) {
+    console.warn('未配置 backend_server，返回原始URL');
+    return url
   }
-  return url
+
+  return `${backendServer}/_uploads/files/${url}`
 }
 
-// 量表图片地址
+/**
+ * 获取量表图片URL
+ * @param {string} url - 图片路径
+ * @returns {string} 完整的图片URL
+ */
 function getGaugeImgUrl(url) {
   if (!url) return ''
-  if (!/^http/g.test(url) && !/^data:image/g.test(url)) {
-    const backendServer = typeof window !== 'undefined' && window.GLOBAL_CONFIG 
-      ? window.GLOBAL_CONFIG.backend_server 
+
+  // 如果已经是完整的URL或data URL，直接返回
+  if (/^http/g.test(url) || /^data:image/g.test(url)) {
+    return url
+  }
+
+  // 获取基础URL
+  const backendServer =
+    typeof window !== 'undefined' && window.GLOBAL_CONFIG
+      ? window.GLOBAL_CONFIG.backend_server
       : '';
-    if (backendServer) {
-      url = `${backendServer}/api/v1/ma/mobile/resource/local/files?file=${url}`;
-    }
+
+  if (!backendServer) {
+    console.warn('未配置 backend_server，返回原始URL');
+    return url
   }
-  return url
+
+  return `${backendServer}/api/v1/ma/mobile/resource/local/files?file=${url}`
 }
 
-// 医生头像
-function doctor_head_img(url) {
+/**
+ * 获取医生头像URL
+ * @param {string} url - 图片路径
+ * @param {string} defaultUrl - 默认头像URL
+ * @returns {string} 完整的图片URL
+ */
+function doctorHeadImg(url, defaultUrl = './img/doc_defalut_male.jpg') {
   if (!url) {
-    return './img/doc_defalut_male.jpg'
+    return defaultUrl
   }
-  if (!/^http/g.test(url) && !/^data:image/g.test(url)) {
-    return `https://annetinfo1.oss-cn-shenzhen.aliyuncs.com/${url}`
+
+  // 如果已经是完整的URL或data URL，直接返回
+  if (/^http/g.test(url) || /^data:image/g.test(url)) {
+    return url
   }
-  return url
+
+  // 使用OSS基础URL
+  return `https://annetinfo1.oss-cn-shenzhen.aliyuncs.com/${url}`
 }
 
 /**
@@ -2850,19 +3125,21 @@ function isTablet() {
 
   // 检测常见的平板设备标识
   const tabletPatterns = [
-    /ipad/,                    // iPad
-    /android.*tablet/,         // Android 平板
-    /kindle/,                  // Kindle
-    /silk/,                    // Amazon Silk
-    /playbook/,                // BlackBerry PlayBook
-    /bb10/,                    // BlackBerry 10
-    /rim tablet/,              // BlackBerry Tablet OS
-    /windows.*touch/,          // Windows 平板
-    /tablet/,                  // 通用平板标识
+    /ipad/, // iPad
+    /android.*tablet/, // Android 平板
+    /kindle/, // Kindle
+    /silk/, // Amazon Silk
+    /playbook/, // BlackBerry PlayBook
+    /bb10/, // BlackBerry 10
+    /rim tablet/, // BlackBerry Tablet OS
+    /windows.*touch/, // Windows 平板
+    /tablet/, // 通用平板标识
   ];
 
   // 检查用户代理是否匹配平板模式
-  const isTabletByUserAgent = tabletPatterns.some(pattern => pattern.test(userAgent));
+  const isTabletByUserAgent = tabletPatterns.some(pattern =>
+    pattern.test(userAgent)
+  );
 
   // 检测屏幕尺寸和触摸支持
   const hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
@@ -2872,19 +3149,21 @@ function isTablet() {
   const maxDimension = Math.max(screenWidth, screenHeight);
 
   // 平板设备的典型屏幕尺寸范围
-  const isTabletByScreenSize = (
-    (minDimension >= 600 && minDimension <= 1200) &&
-    (maxDimension >= 800 && maxDimension <= 1600)
-  );
+  const isTabletByScreenSize =
+    minDimension >= 600 &&
+    minDimension <= 1200 &&
+    maxDimension >= 800 &&
+    maxDimension <= 1600;
 
   // 检测是否为移动设备但屏幕较大（可能是平板）
-  const isMobile = /android|webos|iphone|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+  const isMobile =
+    /android|webos|iphone|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
   const isLargeMobile = isMobile && minDimension >= 600;
 
   // 综合判断：用户代理匹配 或 (屏幕尺寸符合平板特征 且 支持触摸) 或 (大屏移动设备)
-  return isTabletByUserAgent ||
-         (isTabletByScreenSize && hasTouch) ||
-         isLargeMobile
+  return (
+    isTabletByUserAgent || (isTabletByScreenSize && hasTouch) || isLargeMobile
+  )
 }
 
 /**
@@ -2901,7 +3180,8 @@ function getDeviceType() {
   }
 
   const userAgent = navigator.userAgent.toLowerCase();
-  const isMobile = /android|webos|iphone|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
+  const isMobile =
+    /android|webos|iphone|ipod|blackberry|iemobile|opera mini/i.test(userAgent);
 
   return isMobile ? 'mobile' : 'desktop'
 }
@@ -2931,7 +3211,7 @@ function getDeviceInfo() {
       screenWidth: 0,
       screenHeight: 0,
       devicePixelRatio: 1,
-      orientation: 'unknown'
+      orientation: 'unknown',
     }
   }
 
@@ -2943,29 +3223,24 @@ function getDeviceInfo() {
     screenWidth: window.screen.width,
     screenHeight: window.screen.height,
     devicePixelRatio: window.devicePixelRatio || 1,
-    orientation: screen.orientation ? screen.orientation.type : 'unknown'
+    orientation: screen.orientation ? screen.orientation.type : 'unknown',
   }
 }
 
-/* eslint-disable */
-
-/*
-  将url的传参参数形式的字符串转化为json对象格式
-
-  let param = 'school=gongda&hobby=skating&number=3'
-  let jsonObj = queryToObj(param)
+/**
+ * URL参数处理工具
+ * 注意：部分函数依赖浏览器环境（window.location）
+ */
 
-  console.log(jsonObj)
-  输出：{
-          school: 'gongda',
-          hobby: 'skaing',
-          number: '3'
-        }
-*/
+/**
+ * 将查询字符串转换为对象
+ * @param {string} str - 查询字符串，如 'a=1&b=2'
+ * @returns {Object} 对象，如 {a: '1', b: '2'}
+ */
 function queryToObj(str) {
-  var theRequest = {};
+  const theRequest = {};
   if (str) {
-    var strs = str.includes('&') ? str.split('&') : ('&' + str).split('&');
+    const strs = str.includes('&') ? str.split('&') : ('&' + str).split('&');
     for (let i = 0; i < strs.length; i++) {
       if (strs[i].includes('=')) {
         const parts = strs[i].split('=');
@@ -2976,11 +3251,11 @@ function queryToObj(str) {
   return theRequest
 }
 
-/*
- * 将obj转换成url参数形式
- * toQueryString({a:1,b:2})  =>   a=1&b=2
- *
- * */
+/**
+ * 将对象转换为查询字符串
+ * @param {Object} obj - 对象，如 {a: 1, b: 2}
+ * @returns {string} 查询字符串，如 'a=1&b=2'
+ */
 function toQueryPair(key, value) {
   if (typeof value == 'undefined') {
     return key
@@ -2989,37 +3264,31 @@ function toQueryPair(key, value) {
 }
 
 function toQueryString(obj) {
-  var ret = [];
-  for (var key in obj) {
-    key = encodeURIComponent(key);
-    var values = obj[key];
+  const ret = [];
+  for (const key in obj) {
+    const encodedKey = encodeURIComponent(key);
+    const values = obj[key];
     if (values && values.constructor == Array) {
-      //数组
-      var queryValues = [];
-      for (var i = 0, len = values.length, value; i < len; i++) {
+      // 数组
+      const queryValues = [];
+      for (let i = 0, len = values.length, value; i < len; i++) {
         value = values[i];
-        queryValues.push(toQueryPair(key, value));
+        queryValues.push(toQueryPair(encodedKey, value));
       }
       ret = ret.concat(queryValues);
     } else {
-      //字符串
-      ret.push(toQueryPair(key, values));
+      // 字符串
+      ret.push(toQueryPair(encodedKey, values));
     }
   }
   return ret.join('&')
 }
 
-/*
-  直接取url中的参数转为json（或者不转）
-   用法1：
-   let para = urlToJson()
-   console.log(para)
-
-   用法2：
-   let para = urlToJson('https://www.baidu.com?a=1&b=2')
-   console.log(para)
-
-* */
+/**
+ * URL转JSON对象
+ * @param {string} selfUrl - URL字符串，如果不传则使用当前页面URL
+ * @returns {Object} {paramStr: string, paramJson: Object}
+ */
 function urlToJson(selfUrl) {
   if (typeof window === 'undefined') {
     return { paramStr: '', paramJson: {} }
@@ -3030,47 +3299,40 @@ function urlToJson(selfUrl) {
   const urlMatch = url.match(reg);
 
   // 匹配去掉？的纯参数(正则精髓，贪婪永远匹配最后一个？后的参数)
-  const param = urlMatch && urlMatch.length ? urlMatch[0].replace(/^\?*.*\?/, '') : '';
+  const param =
+    urlMatch && urlMatch.length ? urlMatch[0].replace(/^\?*.*\?/, '') : '';
 
   const output = {
     paramStr: param,
-    paramJson: queryToObj(param)
+    paramJson: queryToObj(param),
   };
 
   return output
 }
 
-/*
-  直接取url中的某个参数
-  用法：
-   let deviceType = getQueryString('deviceType')
-   console.log(deviceType)
-
-* */
+/**
+ * 获取URL中的指定参数
+ * @param {string} name - 参数名
+ * @param {string} url - URL字符串，如果不传则使用当前页面URL
+ * @returns {string} 参数值
+ */
 function getQueryString(name, url) {
   if (typeof window === 'undefined') {
     return ''
   }
   url = url || window.location.href;
-  var str = url.match(new RegExp('([?&#])' + name.replace('#', '') + '=([^#&?]*)', 'gi'));
+  const str = url.match(
+    new RegExp('([?&#])' + name.replace('#', '') + '=([^#&?]*)', 'gi')
+  );
   return str ? decodeURIComponent(str[0].split('=')[1]) : ''
 }
 
-/*
-  更改url中的某个参数，返回更改后的最终带参数url
-  参数解析：
-  json: 更改参数的json对象
-  originUrl：预置的网站地址
-
-  用法一：
-  let resultUrl = setUrl({id: 1, name: '测试页面'})
-  console.log(resultUrl) // 输出：https://********.html?id=1&name=测试页面
-
-  用法二：
-  let resultUrl = setUrl({id: 3, name: '哈哈哈'}, 'https://www.baidu.com')
-  console.log(resultUrl) // 输出：https://www.baidu.com?id=3&name=哈哈哈
-
-* */
+/**
+ * 设置URL参数，返回新的URL
+ * @param {Object} json - 要设置的参数对象
+ * @param {string} originUrl - 原始URL，如果不传则使用当前页面URL
+ * @returns {string} 新的URL
+ */
 function setUrl(json, originUrl = '') {
   if (typeof window === 'undefined') {
     return ''
@@ -3079,21 +3341,27 @@ function setUrl(json, originUrl = '') {
   // 新的参数
   let newJson = {
     ...paramJson,
-    ...json
+    ...json,
   };
 
   // 参数对象 =》get参数
   let paramStr = toQueryString(newJson);
 
   // url的origin + pathname
-  let oPath = originUrl ? originUrl : window.location.origin + window.location.pathname;
+  let oPath = originUrl
+    ? originUrl
+    : window.location.origin + window.location.pathname;
 
   let resultUrl = oPath + '?' + paramStr;
   return resultUrl
 }
 
-// url参数（兼容旧API）
-function get_url_params(url) {
+/**
+ * 获取URL参数
+ * @param {string} url - URL字符串，默认使用当前页面URL
+ * @returns {Object} 参数对象
+ */
+function getUrlParams(url) {
   if (typeof window === 'undefined') {
     return {}
   }
@@ -3101,12 +3369,28 @@ function get_url_params(url) {
   return urlToJson(targetUrl).paramJson
 }
 
+/**
+ * 通用工具函数
+ */
+
+/**
+ * 将毫秒转换为时分秒
+ * @param {number} ms - 毫秒数
+ * @param {boolean} secondsTo2decimal - 秒数是否保留两位小数，默认false
+ * @returns {Object} {hours: number, minutes: number, seconds: number}
+ */
 function convertMilliseconds(ms, secondsTo2decimal = false) {
-  if (!ms) return "";
+  if (!ms)
+    return {
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+    }
 
   const hours = Math.floor(ms / 3600000); // 计算小时
   const minutes = Math.floor((ms % 3600000) / 60000); // 计算分钟
   let seconds = 0;
+
   if (secondsTo2decimal) {
     seconds = parseFloat(((ms % 60000) / 1000).toFixed(2));
   } else {
@@ -3117,46 +3401,106 @@ function convertMilliseconds(ms, secondsTo2decimal = false) {
     hours,
     minutes,
     seconds,
-  };
+  }
 }
 
-const myDebounce = function (fn, time = 600) {
-  let timerId = "";
-  return function (...arg) {
-    timerId && clearTimeout(timerId);
+/**
+ * 防抖函数
+ * @param {Function} fn - 要防抖的函数
+ * @param {number} delay - 延迟时间（毫秒），默认600
+ * @returns {Function} 防抖后的函数
+ */
+function debounce(fn, delay = 600) {
+  let timerId = null;
+  return function (...args) {
+    if (timerId) clearTimeout(timerId);
     timerId = setTimeout(() => {
-      fn && fn.call(this, ...arg);
-    }, time);
-  };
-};
+      fn && fn.call(this, ...args);
+    }, delay);
+  }
+}
+
+/**
+ * 防抖函数（别名，向后兼容）
+ * @param {Function} fn - 要防抖的函数
+ * @param {number} delay - 延迟时间（毫秒），默认600
+ * @returns {Function} 防抖后的函数
+ */
+const myDebounce = debounce;
+
+/**
+ * 节流函数
+ * @param {Function} fn - 要节流的函数
+ * @param {number} delay - 延迟时间（毫秒），默认100
+ * @returns {Function} 节流后的函数
+ */
+function throttle(fn, delay = 100) {
+  let timer = null;
+  let startTime = Date.now();
+
+  return function (...args) {
+    const currentTime = Date.now();
+    const diff = delay - (currentTime - startTime);
 
-const mapStringifyReplacer = function (key, value) {
+    if (timer) clearTimeout(timer);
+
+    if (diff <= 0) {
+      fn.apply(this, args);
+      startTime = Date.now();
+    } else {
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+      }, diff);
+    }
+  }
+}
+
+/**
+ * Map序列化的replacer函数（用于JSON.stringify）
+ * @param {string} key - 键名
+ * @param {*} value - 值
+ * @returns {*} 处理后的值
+ */
+function mapStringifyReplacer(key, value) {
   if (value instanceof Map) {
     return {
-      dataType: "Map",
+      dataType: 'Map',
       value: Array.from(value.entries()),
-    };
+    }
   } else {
-    return value;
+    return value
   }
-};
+}
 
-const mapParseReviver = function (key, value) {
-  if (typeof value === "object" && value !== null) {
-    if (value.dataType === "Map") {
-      return new Map(value.value);
+/**
+ * Map反序列化的reviver函数（用于JSON.parse）
+ * @param {string} key - 键名
+ * @param {*} value - 值
+ * @returns {*} 处理后的值
+ */
+function mapParseReviver(key, value) {
+  if (typeof value === 'object' && value !== null) {
+    if (value.dataType === 'Map') {
+      return new Map(value.value)
     }
   }
-  return value;
-};
+  return value
+}
 
+/**
+ * 获取指定月数前的今天
+ * @param {number} reduce - 减少的月数，默认12
+ * @returns {number} 时间戳
+ */
 function getHalfYearAgoToday(reduce = 12) {
   const today = new Date().setHours(0, 0, 0, 0);
   const currentMonth = new Date().getMonth();
-  return new Date(today).setMonth(currentMonth - reduce);
+  return new Date(today).setMonth(currentMonth - reduce)
 }
 
-// 文件下载助手
+/**
+ * 文件下载助手
+ */
 const fileDownloadHelper = {
   /**
    * 下载文件
@@ -3164,14 +3508,15 @@ const fileDownloadHelper = {
    * @param {string} filename - 下载文件名
    */
   download(blob, filename) {
-    if (typeof window === "undefined") {
-      console.warn("fileDownloadHelper.download只能在浏览器环境使用");
-      return;
+    if (typeof window === 'undefined') {
+      console.warn('fileDownloadHelper.download只能在浏览器环境使用');
+      return
     }
+
     const url = window.URL.createObjectURL(blob);
-    const link = document.createElement("a");
+    const link = document.createElement('a');
     link.href = url;
-    link.setAttribute("download", filename);
+    link.setAttribute('download', filename);
     document.body.appendChild(link);
     link.click();
     window.URL.revokeObjectURL(url);
@@ -3185,93 +3530,69 @@ const fileDownloadHelper = {
    * @returns {string} 文件名
    */
   getFilenameFromHeaders(headers, defaultName) {
-    const contentDisposition = headers["content-disposition"];
-    if (!contentDisposition) return defaultName;
+    const contentDisposition = headers['content-disposition'];
+    if (!contentDisposition) return defaultName
 
     const filenameMatch = contentDisposition.match(/filename=(.+)/);
     return filenameMatch && filenameMatch.length > 1
-      ? decodeURIComponent(filenameMatch[1]).replace(/['"]/g, "")
-      : defaultName;
+      ? decodeURIComponent(filenameMatch[1]).replace(/['"]/g, '')
+      : defaultName
   },
 };
 
 /**
- * 复制文本到剪贴板
+ * 复制文本到剪贴板（Promise版本）
  * @param {string} text - 要复制的文本
- * @returns {Promise<boolean>} - 返回一个Promise，复制成功返回true，失败返回false
+ * @returns {Promise<boolean>} 复制成功返回true，失败返回false
  */
 async function copyText(text) {
-  if (typeof window === "undefined") {
-    console.warn("copyText只能在浏览器环境使用");
-    return false;
+  if (typeof window === 'undefined') {
+    console.warn('copyText只能在浏览器环境使用');
+    return false
   }
 
   try {
     // 优先使用现代的Clipboard API
     if (navigator.clipboard && window.isSecureContext) {
       await navigator.clipboard.writeText(text);
-      return true;
+      return true
     }
 
     // 降级方案：使用传统的document.execCommand方法
-    const textArea = document.createElement("textarea");
+    const textArea = document.createElement('textarea');
     textArea.value = text;
 
     // 防止页面滚动
-    textArea.style.position = "fixed";
-    textArea.style.left = "-999999px";
-    textArea.style.top = "-999999px";
+    textArea.style.position = 'fixed';
+    textArea.style.left = '-999999px';
+    textArea.style.top = '-999999px';
 
     document.body.appendChild(textArea);
     textArea.focus();
     textArea.select();
 
     try {
-      const successful = document.execCommand("copy");
+      const successful = document.execCommand('copy');
       document.body.removeChild(textArea);
-      return successful;
+      return successful
     } catch (err) {
       document.body.removeChild(textArea);
-      return false;
+      return false
     }
   } catch (err) {
-    return false;
+    return false
   }
 }
 
-// 防抖（兼容旧API）
-function debounce(fn, delay = 200) {
-  let timeout = null;
-  return function () {
-    let context = this;
-    let args = arguments;
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      fn.apply(context, args);
-    }, delay);
-  };
-}
-
-// 节流
-const throttle = (fn, delay = 100) => {
-  let timer = null;
-  let start_time = Date.now();
-  return function (...args) {
-    const current_time = Date.now();
-    const diff = delay - (current_time - start_time);
-    if (timer) clearTimeout(timer);
-    if (diff <= 0) {
-      fn.apply(this, args);
-      start_time = Date.now();
-    } else {
-      timer = setTimeout(() => {
-        fn.apply(this, args);
-      }, diff);
-    }
-  };
-};
+/**
+ * UUID生成工具
+ */
 
-const uuid = function () {
+/**
+ * 生成短UUID
+ * @returns {string} UUID字符串
+ */
+function uuid() {
   let random;
 
   try {
@@ -3288,24 +3609,46 @@ const uuid = function () {
   }
 
   return random.toString(36)
-};
+}
 
-const uuidLong = function () {
+/**
+ * 生成长UUID（由三个短UUID拼接）
+ * @returns {string} 长UUID字符串
+ */
+function uuidLong() {
   return `${uuid()}${uuid()}${uuid()}`
-};
-
-function baseGet(object, path) {
-  path = castPath(path);
+}
 
-  var index = 0,
-    length = path.length;
+/**
+ * 对象属性获取工具
+ * 类似lodash的get方法，支持路径字符串和数组
+ */
 
-  while (object != null && index < length) {
-    object = object[path[index++]];
+/**
+ * 将字符串路径转换为数组
+ * @param {string} string - 路径字符串，如 'a.b[0].c'
+ * @returns {Array} 路径数组
+ */
+function stringToPath(string) {
+  const result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
   }
-  return (index && index == length) ? object : undefined
+  string.replace(
+    /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,
+    function (match, number, quote, subString) {
+      result.push(quote ? subString.replace(/\\(\\)?/g, '$1') : number || match);
+    }
+  );
+  return result
 }
 
+/**
+ * 转换路径为数组格式
+ * @param {string|Array} value - 路径字符串或数组
+ * @param {Object} object - 对象（用于兼容性，未使用）
+ * @returns {Array} 路径数组
+ */
 function castPath(value, object) {
   if (Array.isArray(value)) {
     return value
@@ -3313,29 +3656,53 @@ function castPath(value, object) {
   return stringToPath(String(value))
 }
 
-function stringToPath(string) {
-  var result = [];
-  if (string.charCodeAt(0) === 46 /* . */) {
-    result.push('');
+/**
+ * 基础get方法
+ * @param {Object} object - 对象
+ * @param {string|Array} path - 路径
+ * @returns {*} 获取到的值
+ */
+function baseGet(object, path) {
+  path = castPath(path);
+
+  let index = 0;
+  const length = path.length;
+
+  while (object != null && index < length) {
+    object = object[path[index++]];
   }
-  string.replace(/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, function(match, number, quote, subString) {
-    result.push(quote ? subString.replace(/\\(\\)?/g, '$1') : (number || match));
-  });
-  return result
+  return index && index == length ? object : undefined
 }
 
+/**
+ * 获取对象属性值（支持路径）
+ * @param {Object} object - 对象
+ * @param {string|Array} path - 路径，如 'a.b[0].c' 或 ['a', 'b', 0, 'c']
+ * @param {*} defaultValue - 默认值
+ * @returns {*} 获取到的值，如果不存在则返回默认值
+ */
 function get(object, path, defaultValue) {
-  var result = object == null ? undefined : baseGet(object, path);
+  const result = object == null ? undefined : baseGet(object, path);
   return result === undefined ? defaultValue : result
 }
 
-// 防止重复请求
+/**
+ * Axios 适配器 - 防止重复请求
+ * @param {Object} options - 配置选项
+ * @param {number} options.cacheTime - 缓存时间（毫秒），设置为0不清除缓存，默认0
+ * @param {boolean} options.cache - 是否支持缓存，默认false
+ * @param {boolean} options.noWarn - 是否禁用警告，默认false
+ * @returns {Function} Axios 适配器函数
+ */
 var index = (options = {}) =>
-  async (config) => {
+  async config => {
     const defaultOptions = {
-      time: 0, // 设置为0，不清除缓存
+      cacheTime: 0, // 缓存时间，设置为0，不清除缓存
+      cache: false, // 是否支持缓存
+      noWarn: false, // 是否有提示
       ...options,
     };
+
     const index = buildUniqueUrl(
       config.url,
       config.method,
@@ -3343,16 +3710,17 @@ var index = (options = {}) =>
       config.data
     );
     let responsePromise = cache.get(index);
-    if (!responsePromise) {
+
+    if (!responsePromise || !defaultOptions.cache) {
       responsePromise = (async () => {
         try {
-          // 需要确保axios可用，这里假设axios已经通过其他方式引入
+          // 需要确保axios可用
           let axios = null;
-          if (typeof window !== "undefined" && window.axios) {
+          if (typeof window !== 'undefined' && window.axios) {
             axios = window.axios;
-          } else if (typeof require !== "undefined") {
+          } else if (typeof require !== 'undefined') {
             try {
-              axios = require("axios");
+              axios = require('axios');
             } catch (e) {
               // ignore
             }
@@ -3360,50 +3728,55 @@ var index = (options = {}) =>
 
           if (axios && axios.defaults && axios.defaults.adapter) {
             const response = await axios.defaults.adapter(config);
-            return Promise.resolve(response);
+            return Promise.resolve(response)
           } else {
-            throw new Error("axios未找到，请确保已安装axios");
+            throw new Error('axios未找到，请确保已安装axios')
           }
         } catch (reason) {
           cache.clear(index);
-          return Promise.reject(reason);
+          if (defaultOptions.noWarn) reason.noWarn = true;
+          return Promise.reject(reason)
         }
       })();
+
       cache.set(index, responsePromise);
-      if (defaultOptions.time !== 0) {
+
+      if (defaultOptions.cacheTime !== 0) {
         setTimeout(() => {
           cache.clear(index);
-        }, defaultOptions.time);
+        }, defaultOptions.cacheTime);
       }
     }
-    return responsePromise.then((data) => JSON.parse(JSON.stringify(data))); // 为防止数据源污染
+
+    return responsePromise.then(data => JSON.parse(JSON.stringify(data))) // 为防止数据源污染
   };
 
-exports.arr_label = arr_label;
-exports.arr_obj = arr_obj;
+exports.arrToLabel = arrToLabel;
+exports.arrToObj = arrToObj;
 exports.buildUniqueUrl = buildUniqueUrl;
 exports.cache = cache;
-exports.calculate_height = calculate_height;
+exports.calculateHeight = calculateHeight;
 exports.convertMilliseconds = convertMilliseconds;
+exports.copyContent = copyContent;
 exports.copyText = copyText;
 exports.copyToClip = copyToClip;
-exports.copy_content = copy_content;
-exports.create_guid = create_guid;
+exports.createGuid = createGuid;
 exports.debounce = debounce;
 exports.defaultAdapter = index;
 exports.detectZoom = detectZoom;
-exports.doctor_head_img = doctor_head_img;
+exports.doctorHeadImg = doctorHeadImg;
 exports.escapeRegExp = escapeRegExp;
+exports.extendSession = extendSession;
 exports.extentSession = extentSession;
 exports.fileDownloadHelper = fileDownloadHelper;
 exports.findNodeOfTree = findNodeOfTree;
+exports.formatDate = formatDate;
 exports.formatDateMinute = formatDateMinute;
-exports.formatTxt = formatTxt;
-exports.format_date = format_date;
-exports.format_decimal = format_decimal;
-exports.format_decimal_string = format_decimal_string;
-exports.format_money = format_money;
-exports.format_number = format_number;
+exports.formatDecimal = formatDecimal;
+exports.formatDecimalString = formatDecimalString;
+exports.formatMoney = formatMoney;
+exports.formatNumber = formatNumber;
+exports.formatText = formatText;
 exports.get = get;
 exports.getBrowserInfo = getBrowserInfo;
 exports.getDeviceInfo = getDeviceInfo;
@@ -3414,8 +3787,8 @@ exports.getImgURL = getImgURL;
 exports.getQueryString = getQueryString;
 exports.getSession = getSession;
 exports.getSessionStorage = getSessionStorage;
-exports.get_system_key = get_system_key;
-exports.get_url_params = get_url_params;
+exports.getSystemKey = getSystemKey;
+exports.getUrlParams = getUrlParams;
 exports.hidePhone = hidePhone;
 exports.isEmpty = isEmpty;
 exports.isEmptyObj = isEmptyObj;
@@ -3429,11 +3802,11 @@ exports.myDebounce = myDebounce;
 exports.queryToObj = queryToObj;
 exports.removeSession = removeSession;
 exports.removeSessionStorage = removeSessionStorage;
+exports.setCursor = setCursor;
 exports.setSession = setSession;
 exports.setSessionStorage = setSessionStorage;
+exports.setSystemKey = setSystemKey;
 exports.setUrl = setUrl;
-exports.set_cursor = set_cursor;
-exports.set_system_key = set_system_key;
 exports.sleep = sleep;
 exports.throttle = throttle;
 exports.toQueryString = toQueryString;