@oeos-components/utils 0.0.21 → 0.0.22

package/dist/format.d.ts

@@ -0,0 +1,134 @@
+/**
+ * 现有方法如下
+ * formatTime(time, cFormat = '{y}-{m}-{d} {h}:{i}:{s}')
+ * formatDurationTime(timestamp, cFormat = '{d} 天 {h} 时 {i} 分 {s} 秒')
+ * formatImg(photoName, addPath = '', { basePath = 'assets/images' } = {})
+ * formatThousands(number)
+ * formatBytes(bytes)
+ * formatBytesConvert(bytes)
+ * formatNewLines(str)
+ */
+/**
+ * 格式化字节单位
+ * @param bytes - 字节数
+ * @param options - 配置项
+ * @param options.digit - 小数位数（默认2）
+ * @param options.thousands - 是否千分位分隔（默认true）
+ * @param options.prefix - 前缀（默认空）
+ * @param options.suffix - 后缀（默认空）
+ * @param options.roundType - 取整方式：'floor'（向下, 默认） | 'ceil'（向上） | 'round'（四舍五入）
+ * @example
+ * formatBytes(0.999) => 0.99B
+ * formatBytes(1040000, { digit: 3, prefix: "$", suffiex: "/s", roundType: "round", thousands: true }) => $1,015.625 KB
+ */
+declare function formatBytes<const T extends {
+    digit?: number;
+    prefix?: string;
+    suffix?: string;
+    roundType?: 'floor' | 'ceil' | 'round';
+    thousands?: boolean;
+} = {
+    digit: 2;
+    prefix: '';
+    suffix: '';
+    roundType: 'floor';
+    thousands: false;
+}>(bytes: number | string, options?: T): string;
+/**
+ * 字节转数字
+ * @param oBytes
+ * @param param1
+ * @returns number
+ * formatBytesConvert('0.5GB') 536870912
+ *
+ * formatBytesConvert('1,234 GB') 1324997410816
+ *
+ * formatBytesConvert('1,234 GB', {thousands: true}) 1,324,997,410,816
+ *
+ * formatBytesConvert('1,234 GB', {digit: 2}) 1324997410816.00
+ */
+declare function formatBytesConvert<const T extends {
+    thounsands?: boolean;
+    digit?: number;
+} = {
+    thounsands: false;
+    digit: 0;
+}>(oBytes: any, options?: T): any;
+/**
+ * 1234 => 1,234
+ * 1234b => 1,234b
+ * 1234.12b => 1,234.12b
+ * @param number 加千分位
+ * @returns
+ */
+declare function formatThousands(number: any): any;
+type TimeType = Date | string | number;
+/**
+ * 时间格式化函数
+ * @param {TimeType} time - 可选时间参数，可以是 Date 对象、时间戳字符串或数字
+ * @param {FormatType} cFormat - '{y}-{m}-{d} {h}:{i}:{s}' - 格式化字符串，支持 {y}年 {m}月 {d}日 {h}时 {i}分 {s}秒 {a}星期
+ * @returns {string} 格式化后的时间字符串
+ * @examples
+ * formatTime(new Date(), '{y}-{m}-{d} {h}:{i}:{s} 星期{a}') // 示例输出: 2026-02-27 14:47:45 星期五 (实际结果取决于调用时的具体时间)
+ */
+declare function formatTime(time?: TimeType, cFormat?: string): string;
+/**
+ *
+ * @param timestamp 持续的时间戳
+ * @param cFormat 格式化的规则 {d}天{h}时{i}分{s}秒
+ * @returns 天时分秒的字符串
+ * @example
+ * formatDurationTime(1162821) => 19分24秒
+ */
+declare function formatDurationTime(timestamp: any, cFormat?: string): string;
+/** 获取assets静态资源
+ * @example
+ *  proxy.formatImg('1.png')
+ *  proxy.formatImg('1.png', 'menu')
+ *  */
+declare function formatImg(photoName: any, addPath?: string, { basePath }?: {
+    basePath?: string | undefined;
+}): any;
+/**
+ * 增加小数点
+ * formatToFixed(22) -> '22.00'
+ *
+ * formatToFixed('22') -> '22.00'
+ *
+ * formatToFixed('22', 4) -> '22.0000'
+ *
+ * formatToFixed('22', 2) -> 22
+ *
+ * formatToFixed('22 TB', {prefix: '$', suffix: '%', unit: false}) -> $22.00%
+ */
+declare function formatToFixed<const T extends {
+    digit?: number;
+    prefix?: string;
+    suffix?: string;
+    unit?: boolean;
+    thousands?: boolean;
+} = {
+    digit: 2;
+    prefix: '';
+    suffix: '';
+    unit: true;
+    thousands: false;
+}>(value: any, options?: T | number | any): string;
+/**
+ * 格式化字符串中的换行符和制表符为HTML标签
+ * @param str 待格式化的字符串
+ * @returns 格式化后的字符串，如果输入的不是字符串或为空，则返回原字符串
+ * @example
+$toast(
+  formatTextToHtml(
+    'Example file\n  File : 111.jpeg\n  CreateTime : 1721011155921 2024-07-15 10:39:15\n  LastUpdateTime : 1721011155921 2024-07-15 10:39:15\n------------------------------------------------------------------------\nExtract:\n  aa=231\n------------------------------------------------------------------------\n',
+  ),
+  {
+    duration: 5000,
+    dangerouslyUseHTMLString: true,
+  },
+)
+ */
+declare function formatTextToHtml(str: any): string;
+
+export { formatBytes, formatBytesConvert, formatDurationTime, formatImg, formatTextToHtml, formatThousands, formatTime, formatToFixed };

package/dist/format.mjs

@@ -0,0 +1,230 @@
+import { isStringNumber, isNumber } from './is.mjs';
+import { getType } from './base.mjs';
+import '@vue/reactivity';
+import 'consola';
+import 'es-toolkit';
+import 'element-plus';
+
+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 = formatThousands(res);
+  }
+  return `${prefix}${res}${suffix}`;
+}
+function formatBytesConvert(oBytes, options) {
+  let { thounsands = false, digit = 0 } = options ?? {};
+  let bytes = oBytes;
+  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 (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
+  };
+  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;
+  }
+  function parseDigitThounsands(val) {
+    let finalRes = val;
+    if (digit) {
+      finalRes = Number(finalRes).toFixed(digit);
+    }
+    if (thounsands) {
+      finalRes = formatThousands(finalRes);
+    }
+    return finalRes;
+  }
+  return parseDigitThounsands(size * units[unit]);
+}
+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 formatTime(time = /* @__PURE__ */ new Date(), cFormat = "{y}-{m}-{d} {h}:{i}:{s}") {
+  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})?)?$/;
+    if (isoRegex.test(timeStr)) {
+      date = new Date(time);
+    } 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())) {
+    throw new Error("Invalid Date");
+  }
+  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 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;
+  }
+  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 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}`, import.meta.url).href;
+  return res;
+}
+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;
+  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 (thousands) {
+    res = 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;
+}
+
+export { formatBytes, formatBytesConvert, formatDurationTime, formatImg, formatTextToHtml, formatThousands, formatTime, formatToFixed };