@sybz-components/utils 0.0.5 → 0.0.6

package/dist/shared/utils.SMYVKGgi.mjs

@@ -0,0 +1,923 @@
+import { isRef, unref, toRaw } from '@vue/reactivity';
+import { consola } from 'consola';
+import { cloneDeep } from 'es-toolkit';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import { isStringNumber, isNumber } from '../is.mjs';
+
+function formatBytes(bytes, options = {}) {
+  let { digit = 2, thousands = false, prefix = "", suffix = "", roundType = "floor" } = options;
+  if (isStringNumber(bytes) || isNumber(bytes)) {
+    bytes = Number(bytes);
+  } else {
+    return bytes;
+  }
+  if (bytes <= 1) {
+    return Math[roundType](bytes * Math.pow(10, digit)) / Math.pow(10, digit) + " 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));
+  const power = Math.pow(k, i);
+  let num = bytes / power;
+  num = Math[roundType](num * Math.pow(10, digit)) / Math.pow(10, digit);
+  let res = num.toFixed(digit) + " " + sizes[i];
+  if (thousands) {
+    res = String(formatThousands(res));
+  }
+  return `${prefix}${res}${suffix}`;
+}
+function formatBytesConvert(oBytes, options = {}) {
+  let { thounsands = false, digit = 0 } = options;
+  let bytes = oBytes;
+  const parseDigitThounsands = (val) => {
+    let finalRes = val;
+    if (digit) {
+      finalRes = Number(finalRes).toFixed(digit);
+    }
+    if (thounsands) {
+      finalRes = formatThousands(finalRes);
+    }
+    return finalRes;
+  };
+  if (isStringNumber(oBytes) || isNumber(oBytes) || getType(oBytes) !== "string") {
+    return parseDigitThounsands(oBytes);
+  }
+  if (!oBytes) {
+    return parseDigitThounsands(oBytes);
+  }
+  const regex = /^\d{1,3}(,\d{3})*(\.\d+)?[a-zA-Z ]*$/;
+  if (typeof oBytes === "string" && regex.test(oBytes)) {
+    bytes = oBytes.replace(/,/g, "");
+    if (isStringNumber(bytes) || isNumber(bytes) || getType(bytes) !== "string") {
+      return parseDigitThounsands(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
+  };
+  if (typeof bytes !== "string") {
+    return parseDigitThounsands(bytes);
+  }
+  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 (!Object.prototype.hasOwnProperty.call(units, unit)) {
+    console.warn(
+      "Invalid bytes unit. Please provide a valid unit, like 'B', 'BYTE', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', or 'YB'."
+    );
+    return;
+  }
+  return parseDigitThounsands(size * units[unit]);
+}
+function formatThousands(value) {
+  const matches = ("" + value).match(/^([\d,]+)(\.?)(\d+)?(\D+)?$/);
+  if (!matches) {
+    return value;
+  }
+  const numericString = matches[1].replace(/\D/g, "");
+  const decimalString = matches[3] ? `.${matches[3]}` : "";
+  const unit = matches[4] || "";
+  const numberWithSeparator = numericString.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${numberWithSeparator}${decimalString}${unit}`;
+}
+function formatTime(time = /* @__PURE__ */ new Date(), cFormat = "{y}-{m}-{d} {h}:{i}:{s}", fallback = (value) => String(value)) {
+  let date;
+  const timeStr = String(time);
+  if (typeof time === "object" && time instanceof Date) {
+    date = time;
+  } else {
+    const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?$/;
+    const dateOnlyRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+    if (isoRegex.test(timeStr)) {
+      date = new Date(time);
+    } else if (dateOnlyRegex.test(timeStr)) {
+      const [, year, month, day] = timeStr.match(dateOnlyRegex);
+      date = new Date(Number(year), Number(month) - 1, Number(day));
+    } else if (timeStr.includes(".") && !isNaN(parseFloat(timeStr))) {
+      date = new Date(parseFloat(timeStr) * 1e3);
+    } else if (/^\d{10}$/.test(timeStr)) {
+      date = new Date(parseInt(timeStr) * 1e3);
+    } else {
+      date = new Date(time);
+    }
+  }
+  if (isNaN(date.getTime())) {
+    return typeof fallback === "function" ? fallback(time) : fallback;
+  }
+  const formatObj = {
+    y: date.getFullYear(),
+    m: date.getMonth() + 1,
+    d: date.getDate(),
+    h: date.getHours(),
+    i: date.getMinutes(),
+    s: date.getSeconds(),
+    a: date.getDay()
+  };
+  return cFormat.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
+    const value = formatObj[key];
+    if (key === "a") {
+      return ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"][value];
+    }
+    if (result.length > 0 && value < 10) {
+      return "0" + value;
+    }
+    return String(value);
+  });
+}
+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;
+  }
+  const hours = Math.floor(totalSeconds / (secondsPerMinute * minutesPerHour));
+  totalSeconds %= secondsPerMinute * minutesPerHour;
+  const minutes = Math.floor(totalSeconds / secondsPerMinute);
+  const 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] ?? "";
+      }
+    }
+  }
+  return parseFormat.replace(/{(y|m|d|h|i|s)+}/g, (result, key) => {
+    let value = formatObj[key];
+    if (result.length > 0 && value < 10 && value !== 0) {
+      return `0${value}`;
+    }
+    return String(value || "00");
+  });
+}
+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}/`;
+  const mergeSrc = `${addLastSlash}${photoName}`;
+  return new URL(`../${addLastBasePathSlash}${mergeSrc}`, import.meta.url).href;
+}
+function formatToFixed(value, options) {
+  if (typeof options === "number") {
+    options = { digit: options };
+  }
+  const finalOptions = {
+    digit: 2,
+    prefix: "",
+    suffix: "",
+    unit: true,
+    thousands: false,
+    ...options
+  };
+  const { digit, prefix, suffix, unit, thousands } = finalOptions;
+  const matches = ("" + value).match(/^([\d,]+)(\.?)(\d+)?(\D+)?$/);
+  if (!matches) {
+    return String(value);
+  }
+  const numericString = matches[1].replace(/\D/g, "");
+  const decimalString = matches[3] ? `.${matches[3]}` : "";
+  let finalUnit = matches[4] || "";
+  let res = numericString;
+  if (isStringNumber(numericString) || isNumber(numericString)) {
+    res = Number(numericString + decimalString).toFixed(digit);
+  }
+  if (thousands) {
+    res = String(formatThousands(res));
+  }
+  if (!unit) {
+    finalUnit = "";
+  }
+  return `${prefix}${res}${finalUnit}${suffix}`;
+}
+function formatTextToHtml(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;
+}
+
+const DEFAULT_CONFIRM_BUTTON_CLASS = "s-message-box__confirm-btn";
+const DEFAULT_CANCEL_BUTTON_CLASS = "s-message-box__cancel-btn";
+function _getBrowserStorage(isSession = false) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return isSession ? window.sessionStorage : window.localStorage;
+  } catch (error) {
+    return null;
+  }
+}
+function _parseStorageValue(value) {
+  if (value == null) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed !== "number") {
+      return parsed;
+    }
+  } catch (error) {
+  }
+  return value;
+}
+function $toast(message, type = "success", otherParams = {}) {
+  const typeMap = {
+    s: "success",
+    i: "info",
+    e: "error",
+    w: "warning"
+  };
+  function isShortType(t) {
+    return ["s", "i", "e", "w"].includes(t);
+  }
+  function isToastOptions(obj) {
+    return typeof obj === "object" && obj !== null;
+  }
+  if (isToastOptions(message)) {
+    if (message.closeAll) {
+      ElMessage.closeAll();
+    }
+    message.customClass = message.customClass === "el" ? "" : "s-antd-message";
+    ElMessage(message);
+    return;
+  }
+  if (isToastOptions(type)) {
+    if (type.closeAll) {
+      ElMessage.closeAll();
+    }
+    type.customClass = type.customClass === "el" ? "" : "s-antd-message";
+    ElMessage({
+      message,
+      type: "success",
+      ...type
+    });
+    return;
+  }
+  if (otherParams.closeAll) {
+    ElMessage.closeAll();
+  }
+  const resolvedType = isShortType(type) ? typeMap[type] : type;
+  otherParams.customClass = otherParams.customClass === "el" ? "" : "s-antd-message";
+  ElMessage({
+    message,
+    type: resolvedType,
+    ...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) {
+  const storage = _getBrowserStorage(isSession);
+  if (!storage) {
+    return;
+  }
+  let handleParams;
+  if (typeof params === "number" || typeof params === "string") {
+    handleParams = params;
+  } else {
+    handleParams = JSON.stringify(params);
+  }
+  storage.setItem(storageName, handleParams);
+}
+function getStorage(data, isSession = false) {
+  const storage = _getBrowserStorage(isSession);
+  if (!storage) {
+    return null;
+  }
+  return _parseStorageValue(storage.getItem(data));
+}
+function clearStorage(str = "") {
+  const sessionStorageRef = _getBrowserStorage(true);
+  const localStorageRef = _getBrowserStorage(false);
+  if (!sessionStorageRef && !localStorageRef) {
+    return;
+  }
+  if (isEmpty(str)) {
+    sessionStorageRef?.clear();
+    localStorageRef?.clear();
+  }
+  if (!isEmpty(str) && getType(str) !== "object") {
+    let strArr = Array.isArray(str) ? str : [str];
+    for (let i = 0; i < strArr.length; i++) {
+      sessionStorageRef?.removeItem(strArr[i]);
+      localStorageRef?.removeItem(strArr[i]);
+    }
+  }
+  if (_isObjectWithExclude(str)) {
+    if (!isEmpty(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);
+          }
+        }
+      }
+      sessionStorageRef?.clear();
+      localStorageRef?.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) => {
+    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 isPlainObject(data) {
+  if (Object.prototype.toString.call(data) !== "[object Object]") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(data);
+  return proto === Object.prototype || proto === null;
+}
+function isEmpty(data, strict = true) {
+  if (isRef(data)) {
+    data = unref(data);
+  }
+  if (data == null) return true;
+  if (data instanceof Date) {
+    return Number.isNaN(data.getTime());
+  }
+  switch (typeof data) {
+    case "string":
+      return data.trim().length === 0;
+    case "boolean":
+      return strict ? false : !data;
+    case "number":
+      return Number.isNaN(data) || !strict && data === 0;
+    case "symbol":
+      return false;
+    case "bigint":
+      return strict ? false : data === BigInt(0);
+    case "function":
+      return false;
+  }
+  if (data instanceof Map || data instanceof Set) return data.size === 0;
+  if (Array.isArray(data)) {
+    return data.length === 0;
+  }
+  if (isPlainObject(data)) {
+    return Reflect.ownKeys(data).length === 0;
+  }
+  return false;
+}
+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 (isRef(data)) {
+    data = unref(data);
+  }
+  if (getType(data) !== "array") {
+    return cloneDeep(data);
+  }
+  const clonedData = cloneDeep(data);
+  const result = [];
+  for (let i = 0; i < times; i++) {
+    result.push(...clonedData);
+  }
+  return result;
+}
+function uuid(type = "", length = 4, options = {}) {
+  const { emailStr = "@qq.com", timeStr = "{y}-{m}-{d} {h}:{i}:{s}", startStr = "", optionsIndex = null } = options;
+  function isRef2(obj) {
+    return obj && typeof obj === "object" && obj._isRef === true;
+  }
+  function unref2(ref) {
+    return isRef2(ref) ? ref.value : ref;
+  }
+  function random2(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+  }
+  type = unref2(type);
+  if (Array.isArray(type)) {
+    if (type.length === 0) return "";
+    const randIndex = optionsIndex ?? random2(0, type.length - 1);
+    const selectedItem = type[randIndex];
+    if (typeof selectedItem === "object" && selectedItem !== null && "value" in selectedItem) {
+      return selectedItem.value;
+    }
+    return selectedItem;
+  }
+  let randomChars = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  let result = startStr;
+  if (type === "phone") {
+    const prefixes = ["130", "131", "132", "133", "135", "136", "137", "138", "170", "187", "189"];
+    result = prefixes[random2(0, prefixes.length - 1)];
+    for (let i = 0; i < 8; i++) {
+      result += Math.floor(Math.random() * 10);
+    }
+    return result;
+  }
+  if (type === "email") {
+    result = uuid(startStr, length) + emailStr;
+    return result;
+  }
+  if (type === "time") {
+    return uuid(startStr, length, options) + " " + formatTime(/* @__PURE__ */ new Date(), timeStr);
+  }
+  if (type === "number") {
+    const numChars = "123456789";
+    result = "";
+    for (let i = 0; i < length; i++) {
+      result += numChars[random2(0, numChars.length - 1)];
+    }
+    return Number(result);
+  }
+  if (type === "ip") {
+    const randomNum = random2(1, 99);
+    return `10.0.11.${randomNum}`;
+  }
+  if (type === "port") {
+    return random2(1, 65535);
+  }
+  for (let i = 0; i < length; i++) {
+    result += randomChars[random2(0, randomChars.length - 1)];
+  }
+  return result;
+}
+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 validateTrigger(type = "required", rules = {}, pureValid = false) {
+  let mergeRules = {
+    trigger: ["blur", "change"],
+    ...rules
+  };
+  return validate(type, mergeRules, pureValid);
+}
+var ValidateType = /* @__PURE__ */ ((ValidateType2) => {
+  ValidateType2["REQUIRED"] = "required";
+  ValidateType2["PASSWORD"] = "password";
+  ValidateType2["NUMBER"] = "number";
+  ValidateType2["POSITIVE"] = "positive";
+  ValidateType2["ZERO_POSITIVE"] = "zeroPositive";
+  ValidateType2["INTEGER"] = "integer";
+  ValidateType2["DECIMAL"] = "decimal";
+  ValidateType2["MOBILE"] = "mobile";
+  ValidateType2["EMAIL"] = "email";
+  ValidateType2["IP"] = "ip";
+  ValidateType2["PORT"] = "port";
+  ValidateType2["BETWEEN"] = "between";
+  ValidateType2["LENGTH"] = "length";
+  ValidateType2["SAME"] = "same";
+  ValidateType2["CUSTOM"] = "custom";
+  return ValidateType2;
+})(ValidateType || {});
+function validate(type = "required", rules = {}, pureValid = false) {
+  const rulesObject = typeof rules === "object" && rules !== null ? rules : {};
+  let trigger = rulesObject.trigger || [];
+  const typeMaps = Object.values(ValidateType);
+  let parseRequired = rulesObject.required ?? true;
+  if (!typeMaps.includes(type)) {
+    return {
+      required: parseRequired,
+      message: type,
+      trigger
+    };
+  }
+  if (type === "required" /* REQUIRED */) {
+    return {
+      required: parseRequired,
+      message: rulesObject.message ?? "\u8BF7\u8F93\u5165",
+      trigger
+    };
+  }
+  if (type === "password" /* PASSWORD */) {
+    const validateName = (rule, value, callback) => {
+      let validFlag = /^[a-zA-Z0-9_-]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error(rulesObject.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" /* POSITIVE */ || type === "number" /* NUMBER */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u6574\u6570", pureValid, /^[1-9]+\d*$/);
+  }
+  if (type === "zeroPositive" /* ZERO_POSITIVE */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u975E\u8D1F\u6574\u6570", pureValid, /^(0|[1-9]+\d*)$/);
+  }
+  if (type === "integer" /* INTEGER */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6574\u6570", pureValid, /^(0|[-]?[1-9]\d*)$/);
+  }
+  if (type === "decimal" /* 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" /* MOBILE */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u786E\u7684\u624B\u673A\u53F7", pureValid, /^[1][0-9]{10}$/);
+  }
+  if (type === "email" /* EMAIL */) {
+    return _validValue(rules, "\u8BF7\u8F93\u5165\u6B63\u786E\u7684email", pureValid, /^[^\s@]+@[^\s@]+\.[^\s@]+$/);
+  }
+  if (type === "ip" /* 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 === "port" /* 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 === "between" /* BETWEEN */) {
+    let min = rulesObject.min;
+    let max = rulesObject.max;
+    const validateBetween = (rule, value, callback) => {
+      let validFlag = /^-?[0-9]+$/.test(value);
+      if (!validFlag) {
+        callback(new Error("\u8BF7\u8F93\u5165\u6570\u5B57"));
+      }
+      if (value < min && min !== void 0) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5C0F\u4E8E${min}`));
+      }
+      if (value > max && max !== void 0) {
+        callback(new Error(`\u6570\u5B57\u4E0D\u80FD\u5927\u4E8E${max}`));
+      }
+      callback();
+    };
+    return {
+      validator: validateBetween,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "length" /* LENGTH */) {
+    return {
+      min: rulesObject.min,
+      max: rulesObject.max,
+      message: rulesObject.message ?? `\u8BF7\u8F93\u5165${rulesObject.min}\u5230${rulesObject.max}\u4E2A\u5B57\u7B26`,
+      trigger,
+      required: parseRequired
+    };
+  }
+  if (type === "same" /* SAME */) {
+    const validateSame = (rule, value, callback) => {
+      let isSame = value === rulesObject.value;
+      if (!isSame) {
+        const errMessage = rulesObject.message || "\u5BC6\u7801\u548C\u786E\u8BA4\u5BC6\u7801\u8981\u4E00\u81F4";
+        callback(new Error(errMessage));
+      }
+      if (parseRequired && !value) {
+        callback(new Error(rulesObject.message || "\u8BF7\u8F93\u5165"));
+      }
+      callback();
+    };
+    let res = {
+      validator: validateSame,
+      trigger,
+      required: parseRequired
+    };
+    return res;
+  }
+  if (type === "custom" /* CUSTOM */) {
+    if (pureValid) {
+      return _validValue(rulesObject.value, rulesObject.message, pureValid, rulesObject.reg);
+    } else {
+      return _validValue(rulesObject, rulesObject.message, pureValid, rulesObject.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
+    };
+  }
+}
+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) {
+    const { hideToast, ...toastOptions } = toastParams;
+    $toast(text + "\u590D\u5236\u6210\u529F", toastOptions);
+    return true;
+  }
+  return true;
+};
+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 (isRef(variable)) {
+    let unrefVariable = unref(variable);
+    _log(toRaw(unrefVariable));
+  } else {
+    _log(variable);
+  }
+  function _log(consoleData) {
+    if (getType2(consoleData) === "object" || getType2(consoleData) === "array") {
+      consola.log(
+        `%c${variableStr} `,
+        "background:#fff; color: blue;font-size: 0.8em",
+        JSON.stringify(consoleData, null, "	"),
+        `${fileInfo}`
+      );
+    } else {
+      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;
+}
+const _CSS_UNIT_RE = /^[0-9]+(\.[0-9]+)?(px|%|em|rem|vw|vh|ch)$/;
+function processWidth(initValue, isBase = false) {
+  const raw = unref(initValue);
+  if (!raw) {
+    return isBase ? "" : {};
+  }
+  const str = typeof raw === "number" ? `${raw}` : raw;
+  let res;
+  if (!isNaN(Number(str))) {
+    res = str + "px";
+  } else if (_CSS_UNIT_RE.test(str)) {
+    res = str;
+  } else {
+    return isBase ? "" : {};
+  }
+  return isBase ? res : { width: res };
+}
+function throttle(fn, delay = 1e3) {
+  let last = 0;
+  let timer = void 0;
+  return function(...args) {
+    let context = this;
+    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);
+    }
+  };
+}
+async function tryCatch(task, sendLoading) {
+  const updateLoading = (value) => {
+    if (isRef(sendLoading)) {
+      sendLoading.value = value;
+    } else if (sendLoading !== void 0 && sendLoading !== null) {
+      console.warn("Cannot modify non-ref sendLoading directly!");
+    }
+  };
+  updateLoading(true);
+  try {
+    const data = typeof task === "function" ? await task() : await task;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  } finally {
+    updateLoading(false);
+  }
+}
+function debounce(func, delay = 500, immediate, resultCallback) {
+  let timer = null;
+  let isInvoke = false;
+  const _debounce = function(...args) {
+    return new Promise((resolve, reject) => {
+      if (timer) clearTimeout(timer);
+      if (immediate && !isInvoke) {
+        try {
+          const result = func.apply(this, args);
+          if (resultCallback) resultCallback(result);
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+        isInvoke = true;
+      } else {
+        timer = setTimeout(() => {
+          try {
+            const result = func.apply(this, args);
+            if (resultCallback) resultCallback(result);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+          isInvoke = false;
+          timer = null;
+        }, delay);
+      }
+    });
+  };
+  _debounce.cancel = function() {
+    if (timer) clearTimeout(timer);
+    isInvoke = false;
+    timer = null;
+  };
+  return _debounce;
+}
+function confirm(message, options = {}, appContext = null) {
+  const resolvedMessage = typeof message === "function" ? message() : message;
+  const resolvedAppendTo = _resolveAppendTarget(options?.appendTo);
+  const resolvedAppContext = _resolveAppContext(options?.appContext || appContext);
+  const mergeOptions = {
+    title: "\u63D0\u793A",
+    draggable: true,
+    showCancelButton: true,
+    cancelButtonText: "\u53D6\u6D88",
+    confirmButtonText: "\u786E\u5B9A",
+    dangerouslyUseHTMLString: true,
+    ...options,
+    appendTo: resolvedAppendTo,
+    appContext: resolvedAppContext,
+    confirmButtonClass: _mergeClassNames(DEFAULT_CONFIRM_BUTTON_CLASS, options?.confirmButtonClass),
+    cancelButtonClass: _mergeClassNames(DEFAULT_CANCEL_BUTTON_CLASS, options?.cancelButtonClass)
+  };
+  return ElMessageBox.confirm(resolvedMessage, mergeOptions);
+}
+function _mergeClassNames(...classNames) {
+  return classNames.filter(Boolean).join(" ");
+}
+function _resolveAppendTarget(appendTo) {
+  if (typeof document === "undefined") {
+    return appendTo;
+  }
+  if (appendTo instanceof HTMLElement) {
+    return appendTo;
+  }
+  if (typeof appendTo === "string" && appendTo.trim()) {
+    const rawSelector = appendTo.trim();
+    try {
+      const selector = rawSelector.startsWith("#") || rawSelector.startsWith(".") || rawSelector.startsWith("[") ? rawSelector : `#${rawSelector}`;
+      return document.querySelector(selector) || appendTo;
+    } catch (error) {
+      return appendTo;
+    }
+  }
+  const overlayList = Array.from(document.querySelectorAll(".el-overlay"));
+  const dialogOverlay = overlayList.filter((item) => {
+    if (!item.isConnected || item.style.display === "none") {
+      return false;
+    }
+    const containsDialog = item.querySelector(".el-dialog, .el-drawer");
+    const containsMessageBox = item.querySelector(".el-message-box");
+    return !!containsDialog && !containsMessageBox;
+  }).at(-1);
+  return dialogOverlay || appendTo;
+}
+function _resolveAppContext(appContext) {
+  if (appContext) {
+    return appContext;
+  }
+  if (typeof document === "undefined") {
+    return ElMessageBox.install?.context || ElMessageBox._context;
+  }
+  return ElMessageBox.install?.context || ElMessageBox._context || document.querySelector("#app")?._vue_app?._context;
+}
+function getVariable(propertyName, fallback = "") {
+  if (typeof document === "undefined") {
+    return fallback;
+  }
+  const res = getComputedStyle(document.documentElement).getPropertyValue(propertyName).trim();
+  return res || fallback;
+}
+function test() {
+  return `build time: ${"2026-06-09 10:40:54"}`;
+}
+
+export { $toast as $, formatImg as A, formatTextToHtml as B, formatThousands as C, formatTime as D, formatToFixed as E, clone as a, confirm as b, clearStorage as c, copy as d, debounce as e, getType as f, getStorage as g, getVariable as h, isEmpty as i, sleep as j, throttle as k, log as l, merge as m, toLine as n, tryCatch as o, processWidth as p, validate as q, random as r, setStorage as s, test as t, uuid as u, validForm as v, validateTrigger as w, formatBytes as x, formatBytesConvert as y, formatDurationTime as z };