@oeos-components/utils 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -1,16 +1,795 @@
-const { createJiti } = require("../../../node_modules/.pnpm/jiti@2.5.1/node_modules/jiti/lib/jiti.cjs")
+'use strict';
 
-const jiti = createJiti(__filename, {
-  "interopDefault": true,
-  "alias": {
-    "@oeos-components/utils": "/Users/andy/cyrd/oeos-components/packages/utils"
-  },
-  "transformOptions": {
-    "babel": {
-      "plugins": []
+const reactivity = require('@vue/reactivity');
+const lodashEs = require('lodash-es');
+const consola = require('consola');
+const elementPlus = require('element-plus');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const isString = (val) => typeof val === "string";
+const isStringNumber = (val) => {
+  if (!isString(val)) {
+    return false;
+  }
+  return !Number.isNaN(Number(val));
+};
+const isNumber = (val) => typeof val === "number";
+function $toast(message, type = "success", otherParams = {}) {
+  const map = {
+    s: "success",
+    i: "info",
+    e: "error",
+    w: "warning"
+  };
+  if (getType(message) === "object") {
+    if (message.clodeAll) {
+      elementPlus.ElMessage.closeAll();
+    }
+    elementPlus.ElMessage(message);
+    return;
+  }
+  if (getType(type) === "object") {
+    if (type.clodeAll) {
+      elementPlus.ElMessage.closeAll();
+    }
+    elementPlus.ElMessage({
+      message,
+      type: "success",
+      ...type
+    });
+    return;
+  }
+  if (otherParams.closeAll) {
+    elementPlus.ElMessage.closeAll();
+  }
+  elementPlus.ElMessage({
+    message,
+    type: map[type] || type,
+    ...otherParams
+  });
+}
+$toast.success = (message, otherParams = {}) => $toast(message, "success", otherParams);
+$toast.info = (message, otherParams = {}) => $toast(message, "info", otherParams);
+$toast.error = (message, otherParams = {}) => $toast(message, "error", otherParams);
+$toast.warning = (message, otherParams = {}) => $toast(message, "warning", otherParams);
+function setStorage(storageName, params, isSession = false) {
+  let handleParams;
+  if (typeof params === "number" || typeof params === "string") {
+    handleParams = params;
+  } else {
+    handleParams = JSON.stringify(params);
+  }
+  if (isSession) {
+    sessionStorage.setItem(storageName, handleParams);
+  } else {
+    localStorage.setItem(storageName, handleParams);
+  }
+}
+function getStorage(data, isSession = false) {
+  let getLocalData = "";
+  let getSessionData = "";
+  if (isSession) {
+    getSessionData = sessionStorage.getItem(data);
+  } else {
+    getLocalData = localStorage.getItem(data);
+  }
+  if (getLocalData) {
+    try {
+      if (typeof JSON.parse(getLocalData) !== "number") {
+        getLocalData = JSON.parse(getLocalData);
+      }
+    } catch (e) {
+    }
+    return getLocalData;
+  } else if (getSessionData) {
+    try {
+      if (typeof JSON.parse(getSessionData) !== "number") {
+        getSessionData = JSON.parse(getSessionData);
+      }
+    } catch (e) {
+    }
+    return getSessionData;
+  }
+  return null;
+}
+function clearStorage(str = "") {
+  if (isEmpty(str)) {
+    sessionStorage.clear();
+    localStorage.clear();
+  }
+  if (notEmpty(str) && getType(str) !== "object") {
+    let strArr = Array.isArray(str) ? str : [str];
+    for (let i = 0; i < strArr.length; i++) {
+      sessionStorage.removeItem(strArr[i]);
+      localStorage.removeItem(strArr[i]);
+    }
+  }
+  if (_isObjectWithExclude(str)) {
+    if (notEmpty(str.exclude) && getType(str) === "object") {
+      let sessionStorageObj = {};
+      let localStorageObj = {};
+      for (const key in str.exclude) {
+        if (Object.prototype.hasOwnProperty.call(str.exclude, key)) {
+          const name = str.exclude[key];
+          if (getStorage(name)) {
+            localStorageObj[name] = getStorage(name);
+          }
+          if (getStorage(name, true)) {
+            sessionStorageObj[name] = getStorage(name, true);
+          }
+        }
+      }
+      sessionStorage.clear();
+      localStorage.clear();
+      for (const key in sessionStorageObj) {
+        setStorage(key, sessionStorageObj[key], true);
+      }
+      for (const key in localStorageObj) {
+        setStorage(key, localStorageObj[key]);
+      }
+    }
+  }
+}
+function _isObjectWithExclude(obj) {
+  return typeof obj === "object" && obj !== null && "exclude" in obj && typeof obj.exclude === "object";
+}
+function validForm(ref, { message = "\u8868\u5355\u6821\u9A8C\u9519\u8BEF, \u8BF7\u68C0\u67E5", detail = false, showMessage = true } = {}) {
+  return new Promise((resolve, reject) => {
+    reactivity.unref(ref).validate((valid, status) => {
+      if (valid) {
+        resolve(status);
+      } else {
+        if (message && showMessage) {
+          let errorText = Object.keys(status);
+          let toastMessage = message;
+          if (detail) {
+            toastMessage = message + errorText.join(",");
+          }
+          $toast(toastMessage, "e");
+        }
+        reject(status);
+      }
+    });
+  });
+}
+function isEmpty(data) {
+  if (reactivity.isRef(data)) {
+    data = reactivity.unref(data);
+  }
+  if (data instanceof Date) {
+    return isNaN(data.getTime());
+  }
+  switch (typeof data) {
+    case "undefined":
+      return true;
+    case "string":
+      if (data.trim().length === 0) return true;
+      break;
+    case "boolean":
+      if (!data) return true;
+      break;
+    case "number":
+      if (0 === data) return true;
+      break;
+    case "object":
+      if (null === data) return true;
+      if (void 0 !== data.length && data.length === 0) return true;
+      for (var k in data) {
+        return false;
+      }
+      return true;
+  }
+  return false;
+}
+function notEmpty(v) {
+  return !isEmpty(v);
+}
+function merge(obj1, obj2) {
+  let merged = { ...obj1, ...obj2 };
+  for (let key in merged) {
+    if (!isEmpty(obj1[key]) && !isEmpty(obj2[key])) {
+      merged[key] = obj2[key];
+    } else if (isEmpty(obj1[key]) && !isEmpty(obj2[key])) {
+      merged[key] = obj2[key];
+    } else if (!isEmpty(obj1[key]) && isEmpty(obj2[key])) {
+      merged[key] = obj1[key];
+    }
+  }
+  return merged;
+}
+function clone(data, times = 1) {
+  if (reactivity.isRef(data)) {
+    data = reactivity.unref(data);
+  }
+  if (getType(data) !== "array") {
+    return lodashEs.cloneDeep(data);
+  }
+  const clonedData = lodashEs.cloneDeep(data);
+  const result = [];
+  for (let i = 0; i < times; i++) {
+    result.push(...clonedData);
+  }
+  return result;
+}
+function formatTime(time, cFormat = "{y}-{m}-{d} {h}:{i}:{s}") {
+  if (!time) {
+    return time;
+  }
+  let date;
+  if (typeof time === "object") {
+    date = time;
+  } else {
+    if (("" + time).length === 10) time = parseInt(time) * 1e3;
+    date = new Date(time);
+  }
+  const formatObj = {
+    y: date.getFullYear(),
+    m: date.getMonth() + 1,
+    d: date.getDate(),
+    h: date.getHours(),
+    i: date.getMinutes(),
+    s: date.getSeconds(),
+    a: date.getDay()
+  };
+  const time_str = cFormat.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
+    let value = formatObj[key];
+    if (key === "a") {
+      return ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"][value];
+    }
+    if (result.length > 0 && value < 10) {
+      value = "0" + value;
+    }
+    return value || 0;
+  });
+  return time_str;
+}
+function formatDurationTime(timestamp, cFormat = "{d} \u5929 {h} \u65F6 {i} \u5206 {s} \u79D2") {
+  const secondsPerMinute = 60;
+  const minutesPerHour = 60;
+  const hoursPerDay = 24;
+  let totalSeconds = Math.floor(timestamp / 1e3);
+  let days = 0;
+  if (cFormat.indexOf("d") !== -1) {
+    days = Math.floor(totalSeconds / (secondsPerMinute * minutesPerHour * hoursPerDay));
+    totalSeconds %= secondsPerMinute * minutesPerHour * hoursPerDay;
+  }
+  let hours = Math.floor(totalSeconds / (secondsPerMinute * minutesPerHour));
+  totalSeconds %= secondsPerMinute * minutesPerHour;
+  let minutes = Math.floor(totalSeconds / secondsPerMinute);
+  let seconds = totalSeconds % secondsPerMinute;
+  const formatObj = {
+    d: days,
+    h: hours,
+    i: minutes,
+    s: seconds
+  };
+  let parseFormat = cFormat;
+  if (days === 0) {
+    parseFormat = cFormat.match(/{h}.*/g)[0];
+    if (hours === 0) {
+      parseFormat = cFormat.match(/{i}.*/g)[0];
+      if (minutes === 0) {
+        parseFormat = cFormat.match(/{s}.*/g)[0];
+      }
+    }
+  }
+  const time_str = parseFormat.replace(/{(y|m|d|h|i|s)+}/g, (result, key) => {
+    let value = formatObj[key];
+    if (result.length > 0 && value < 10 && value != 0) {
+      value = "0" + value;
+    }
+    return value || "00";
+  });
+  return time_str;
+}
+function uuid(type = "", length = 4, { emailStr = "@qq.com", timeStr = "{m}-{d} {h}:{i}:{s}", startStr = "", optionsIndex = null } = {}) {
+  let randomStr = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  let res = type;
+  if (reactivity.isRef(type)) {
+    type = reactivity.unref(type);
+  }
+  if (getType(type) === "array" && type.length > 0) {
+    let randNum = random(0, type.length - 1);
+    if (!length) {
+      return type[optionsIndex ?? randNum];
+    }
+    return type[optionsIndex ?? randNum][length === 4 ? "value" : length];
+  }
+  if (type === "phone") {
+    let prefixArray = new Array("130", "131", "132", "133", "135", "136", "137", "138", "170", "187", "189");
+    let i = parseInt(Math.random() * 10);
+    let res2 = prefixArray[i];
+    for (var j = 0; j < 8; j++) {
+      res2 += Math.floor(Math.random() * 10);
+    }
+    return res2;
+  }
+  if (type === "email") {
+    return uuid(startStr, length) + emailStr;
+  }
+  if (type === "time") {
+    return uuid(startStr, length) + " " + formatTime(/* @__PURE__ */ new Date(), timeStr);
+  }
+  if (type === "number") {
+    let randomStr2 = "123456789";
+    let res2 = "";
+    for (let i = length; i > 0; --i) {
+      res2 += randomStr2[Math.floor(Math.random() * randomStr2.length)];
+    }
+    return Number(res2);
+  }
+  if (type === "ip") {
+    let randomNum = random(1, 99);
+    return `10.0.11.` + randomNum;
+  }
+  if (type === "port") {
+    let randomNum = random(1, 65535);
+    return randomNum;
+  }
+  for (let i = length; i > 0; --i) {
+    res += randomStr[Math.floor(Math.random() * randomStr.length)];
+  }
+  return res;
+}
+function getType(type) {
+  if (typeof type === "object") {
+    const objType = Object.prototype.toString.call(type).slice(8, -1).toLowerCase();
+    return objType;
+  } else {
+    return typeof type;
+  }
+}
+function sleep(delay = 0, fn) {
+  return new Promise(
+    (resolve) => setTimeout(() => {
+      fn?.();
+      resolve();
+    }, delay)
+  );
+}
+function validate(type = "required", rules = {}, pureValid = false) {
+  if (getType(type) === "object") {
+    pureValid = rules || false;
+    rules = type;
+    type = "required";
+  }
+  let trigger = rules.trigger || [];
+  const typeMaps = ["required", "pwd", "number", "mobile", "between", "length", "same", "ip", "port", "custom"];
+  let parseRequired = rules.required ?? true;
+  if (!typeMaps.includes(type)) {
+    return {
+      required: parseRequired,
+      message: type,
+      trigger
+    };
+  }
+  if (type === "required") {
+    return {
+      required: parseRequired,
+      message: rules.message ?? "\u8BF7\u8F93\u5165",
+      trigger
+    };
+  }
+  if (type === "password") {
+    const validateName = (rule, value, callback) => {
+      let validFlag = /^[a-zA-Z0-9_-]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error(rules.message || "\u5BC6\u7801\u53EA\u80FD\u7531\u82F1\u6587\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u3001\u4E2D\u5212\u7EBF\u7EC4\u6210"));
+      } else {
+        callback();
+      }
+    };
+    return {
+      validator: validateName,
+      trigger
+    };
+  }
+  if (type === "positive" || type === "number") {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u6574\u6570", pureValid, /^[1-9]+\d*$/);
+  }
+  if (type === "zeroPositive") {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u975E\u8D1F\u6574\u6570", pureValid, /^(0|[1-9]+\d*)$/);
+  }
+  if (type === "integer") {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6574\u6570", pureValid, /^(0|[-]?[1-9]\d*)$/);
+  }
+  if (type === "decimal") {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u975E\u8D1F\u6570\u5B57, \u5305\u542B\u5C0F\u6570\u4E14\u6700\u591A2\u4F4D", pureValid, /(0|[1-9]\d*)(\.\d{1, 2})?|0\.\d{1,2}/);
+  }
+  if (type === "mobile") {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u786E\u7684\u624B\u673A\u53F7", pureValid, /^[1][0-9]{10}$/);
+  }
+  if (type === "ip") {
+    return _validValue(
+      rules,
+      "\u8BF7\u8F93\u5165\u6B63\u786E\u7684ip\u5730\u5740",
+      pureValid,
+      /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+    );
+  }
+  if (type === "between") {
+    let min = rules.min || 1;
+    let max = rules.max || 10;
+    const validateBetween = (rule, value, callback) => {
+      let validFlag = /^[0-9]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error("\u8BF7\u8F93\u5165\u6570\u5B57"));
+      }
+      if (value < min) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5C0F\u4E8E${min}`));
+      }
+      if (value > max) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5927\u4E8E${max}`));
+      }
+      callback();
+    };
+    return {
+      validator: validateBetween,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "length") {
+    return {
+      min: rules.min,
+      max: rules.max,
+      message: rules.message ?? `\u8BF7\u8F93\u5165${rules.min}\u5230${rules.max}\u4E2A\u5B57\u7B26`,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "port") {
+    return _validValue(
+      rules,
+      "\u8BF7\u8F93\u51651-65535\u7684\u7AEF\u53E3\u53F7",
+      pureValid,
+      /^([1-9]|[1-9][0-9]{1,3}|[1-5][0-9]{4}|6[0-5][0-5][0-3][0-5])$/
+    );
+  }
+  if (type === "same") {
+    const validateSame = (rule, value, callback) => {
+      let isSame = value === rules.value;
+      if (!isSame) {
+        const errMessage = rules.message || "\u5BC6\u7801\u548C\u786E\u8BA4\u5BC6\u7801\u8981\u4E00\u81F4";
+        callback(new Error(errMessage));
+      }
+      if (parseRequired && !value) {
+        callback(new Error(rules.message || "\u8BF7\u8F93\u5165"));
+      }
+      callback();
+    };
+    let res = {
+      validator: validateSame,
+      trigger,
+      required: parseRequired
+    };
+    return res;
+  }
+  if (type === "custom") {
+    if (pureValid) {
+      return _validValue(rules.value, rules.message, pureValid, rules.reg);
+    } else {
+      return _validValue(rules, rules.message, pureValid, rules.reg);
+    }
+  }
+  function _validValue(rules2, msg, pureValid2, reg) {
+    if (pureValid2 === true) {
+      return reg.test(rules2);
+    }
+    const validatePhone = (rule, value, callback) => {
+      let validFlag = reg.test(value);
+      if (!validFlag) {
+        callback(new Error(rules2.message ?? msg));
+      } else {
+        callback();
+      }
+    };
+    return {
+      validator: validatePhone,
+      required: rules2.required ?? true,
+      trigger
+    };
+  }
+}
+async function asyncWrapper(func, ...args) {
+  try {
+    const res = await func(...args);
+    return { res };
+  } catch (err) {
+    return { err };
+  }
+}
+function formatImg(photoName, addPath = "", { basePath = "assets/images" } = {}) {
+  if (photoName.startsWith("http") || photoName.startsWith("https")) {
+    return photoName;
+  }
+  if (photoName.indexOf(".") === -1) {
+    photoName = photoName + ".png";
+  }
+  const addLastSlash = addPath.endsWith("/") || !addPath ? addPath : `${addPath}/`;
+  const addLastBasePathSlash = basePath.endsWith("/") || !basePath ? basePath : `${basePath}/`;
+  let mergeSrc = `${addLastSlash}${photoName}`;
+  let res = new URL(`../${addLastBasePathSlash}${mergeSrc}`, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+  return res;
+}
+const copy = (text, toastParams = {}) => {
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  document.body.appendChild(textarea);
+  textarea.select();
+  document.execCommand("copy");
+  document.body.removeChild(textarea);
+  if (!toastParams.hideToast) {
+    $toast(text + "\u590D\u5236\u6210\u529F", toastParams);
+  }
+};
+function formatThousands(number) {
+  let matches = ("" + number).match(/^([\d,]+)(\.?)(\d+)?(\D+)?$/);
+  if (!matches) {
+    return number;
+  }
+  let numericString = matches[1].replace(/\D/g, "");
+  let decimalString = matches[3] ? `.${matches[3]}` : "";
+  let unit = matches[4] || "";
+  let numberWithSeparator = numericString.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${numberWithSeparator}${decimalString}${unit}`;
+}
+function log(variableStr, variable, otherInfo = "") {
+  const stack = new Error().stack.split("\n")[2].trim();
+  const matchResult = stack.match(/\((.*):(\d+):(\d+)\)/);
+  let fileInfo = "";
+  try {
+    if (matchResult && otherInfo) {
+      const lineNumber = matchResult[2];
+      fileInfo = `vscode://file${JSON.parse(otherInfo)}:${lineNumber}`;
+    }
+  } catch (error) {
+    fileInfo = otherInfo;
+  }
+  if (reactivity.isRef(variable)) {
+    let unrefVariable = reactivity.unref(variable);
+    _log(reactivity.toRaw(unrefVariable));
+  } else {
+    _log(variable);
+  }
+  function _log(consoleData) {
+    if (getType2(consoleData) === "object" || getType2(consoleData) === "array") {
+      consola.consola.log(
+        `%c${variableStr} `,
+        "background:#fff; color: blue;font-size: 0.8em",
+        JSON.stringify(consoleData, null, "	"),
+        `${fileInfo}`
+      );
+    } else {
+      consola.consola.log(`%c${variableStr} `, "background:#fff; color: blue;font-size: 0.8em", consoleData, `${fileInfo}`);
+    }
+  }
+  function getType2(type) {
+    if (typeof type === "object") {
+      const objType = Object.prototype.toString.call(type).slice(8, -1).toLowerCase();
+      return objType;
+    } else {
+      return typeof type;
+    }
+  }
+}
+function random(min = 0, max = 10) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function toLine(text, connect = "-") {
+  let translateText = text.replace(/([A-Z])/g, (match, p1, offset, origin) => {
+    if (offset === 0) {
+      return `${match.toLocaleLowerCase()}`;
+    } else {
+      return `${connect}${match.toLocaleLowerCase()}`;
+    }
+  }).toLocaleLowerCase();
+  return translateText;
+}
+function processWidth(initValue, isBase = false) {
+  let value = reactivity.unref(initValue);
+  let res = "";
+  if (!value) {
+    return isBase ? value : {};
+  } else if (typeof value === "number") {
+    value = String(value);
+  }
+  if (value === "") {
+    return isBase ? value : {};
+  } else if (typeof value === "string" && !isNaN(value)) {
+    res = value + "px";
+  } else if (typeof value === "string" && /^[0-9]+(\.[0-9]+)?(px|%|em|rem|vw|vh|ch)*$/.test(value)) {
+    res = value;
+  } else {
+    console.warn(`${value} is Invalid unit provided`);
+    return value;
+  }
+  if (isBase) {
+    return res;
+  }
+  return { width: res };
+}
+function toFixed(value, options = {}) {
+  if (typeof options === "number") {
+    options = { digit: options };
+  }
+  let { digit = 2, prefix = "", suffix = "", unit = true } = options;
+  let matches = ("" + value).match(/^([\d,]+)(\.?)(\d+)?(\D+)?$/);
+  if (!matches) {
+    return value;
+  }
+  let numericString = matches[1].replace(/\D/g, "");
+  let decimalString = matches[3] ? `.${matches[3]}` : "";
+  let finalUnit = matches[4] || "";
+  let res = numericString;
+  if (isStringNumber(numericString) || isNumber(numericString)) {
+    res = Number(numericString + decimalString).toFixed(digit);
+  }
+  if (!unit) {
+    finalUnit = "";
+  }
+  return `${prefix}${res}${finalUnit}${suffix}`;
+}
+function formatBytes(bytes, { toFixed: toFixed2 = 2, thousands = true } = {}) {
+  if (isStringNumber(bytes) || isNumber(bytes)) {
+    bytes = Number(bytes);
+  } else {
+    return bytes;
+  }
+  if (bytes <= 0) {
+    return bytes.toFixed(toFixed2) + " B";
+  }
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  let res = (bytes / Math.pow(k, i)).toFixed(toFixed2) + " " + sizes[i];
+  if (thousands) {
+    res = formatThousands(res);
+  }
+  return res;
+}
+function formatBytesConvert(oBytes, { thounsand = false, toFixed: toFixed2 = 0 } = {}) {
+  if (isStringNumber(oBytes) || isNumber(oBytes) || getType(oBytes) !== "string") {
+    return oBytes;
+  }
+  if (!oBytes) {
+    return oBytes;
+  }
+  const regex = /^\d{1,3}(,\d{3})*(\.\d+)?[a-zA-Z ]*$/;
+  let bytes = oBytes;
+  if (regex.test(oBytes)) {
+    bytes = oBytes.replace(/,/g, "");
+    if (isStringNumber(bytes) || isNumber(bytes) || getType(bytes) !== "string") {
+      return bytes;
+    }
+  }
+  const bytesRegex = /^(\d+(?:\.\d+)?)\s*([BKMGTPEZY]?B|Byte)$/i;
+  const units = {
+    B: 1,
+    BYTE: 1,
+    KB: 1024,
+    MB: 1024 ** 2,
+    GB: 1024 ** 3,
+    TB: 1024 ** 4,
+    PB: 1024 ** 5,
+    EB: 1024 ** 6,
+    ZB: 1024 ** 7,
+    YB: 1024 ** 8
+  };
+  const match = bytes.match(bytesRegex);
+  if (!match) {
+    console.warn("Invalid bytes format. Please provide a valid bytes string, like '100GB'.");
+    return;
+  }
+  const size = parseFloat(match[1]);
+  const unit = match[2].toUpperCase();
+  if (!units.hasOwnProperty(unit)) {
+    console.warn(
+      "Invalid bytes unit. Please provide a valid unit, like 'B', 'BYTE', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', or 'YB'."
+    );
+    return;
+  }
+  let finalRes = size * units[unit];
+  if (toFixed2) {
+    finalRes = parseFloat(finalRes.toFixed(toFixed2));
+  }
+  if (thounsand) {
+    finalRes = formatThousands(finalRes);
+  }
+  return finalRes;
+}
+function throttle(fn, delay = 1e3) {
+  let last = 0;
+  let timer = null;
+  return function() {
+    let context = this;
+    let args = arguments;
+    let now = +/* @__PURE__ */ new Date();
+    if (now - last < delay) {
+      clearTimeout(timer);
+      timer = setTimeout(function() {
+        last = now;
+        fn.apply(context, args);
+      }, delay);
+    } else {
+      last = now;
+      fn.apply(context, args);
+    }
+  };
+}
+function debounce(fn, delay = 1e3) {
+  let timer = null;
+  return function() {
+    if (timer) {
+      clearTimeout(timer);
     }
+    timer = setTimeout(() => {
+      fn.apply(this, arguments);
+      timer = null;
+    }, delay);
+  };
+}
+function confirm(message, options) {
+  const resolvedMessage = typeof message === "function" ? message() : message;
+  const elContext = elementPlus.ElMessageBox.install?.context || elementPlus.ElMessageBox._context || document.querySelector("#app")?._vue_app?._context;
+  const mergeOptions = {
+    title: "\u63D0\u793A",
+    draggable: true,
+    showCancelButton: false,
+    confirmButtonText: "\u786E\u5B9A",
+    dangerouslyUseHTMLString: true,
+    // 允许 HTML
+    appContext: elContext,
+    // 强制注入 Element Plus 的上下文
+    ...options
+  };
+  return elementPlus.ElMessageBox.confirm(resolvedMessage, mergeOptions);
+}
+function formatNewLines(str) {
+  if (!str || typeof str !== "string") {
+    return str;
   }
-})
+  str = str.replace(/\n/g, "<br>");
+  str = str.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;");
+  return str;
+}
+function getVariable(propertyName) {
+  let res = getComputedStyle(document.documentElement).getPropertyValue(propertyName).trim();
+  return res;
+}
 
-/** @type {import("/Users/andy/cyrd/oeos-components/packages/utils/src/index")} */
-module.exports = jiti("/Users/andy/cyrd/oeos-components/packages/utils/src/index.ts")
+exports.$toast = $toast;
+exports.asyncWrapper = asyncWrapper;
+exports.clearStorage = clearStorage;
+exports.clone = clone;
+exports.confirm = confirm;
+exports.copy = copy;
+exports.debounce = debounce;
+exports.formatBytes = formatBytes;
+exports.formatBytesConvert = formatBytesConvert;
+exports.formatDurationTime = formatDurationTime;
+exports.formatImg = formatImg;
+exports.formatNewLines = formatNewLines;
+exports.formatThousands = formatThousands;
+exports.formatTime = formatTime;
+exports.getStorage = getStorage;
+exports.getType = getType;
+exports.getVariable = getVariable;
+exports.isEmpty = isEmpty;
+exports.isNumber = isNumber;
+exports.isString = isString;
+exports.isStringNumber = isStringNumber;
+exports.log = log;
+exports.merge = merge;
+exports.notEmpty = notEmpty;
+exports.processWidth = processWidth;
+exports.random = random;
+exports.setStorage = setStorage;
+exports.sleep = sleep;
+exports.throttle = throttle;
+exports.toFixed = toFixed;
+exports.toLine = toLine;
+exports.uuid = uuid;
+exports.validForm = validForm;
+exports.validate = validate;