@cloudcome/utils-core 1.1.1 → 1.2.0

package/src/string.ts

@@ -1,146 +0,0 @@
-import { numberConvert, randomNumber } from './number';
-import { isFunction, isNullish, isNumber, isObject, isString, isUndefined } from './type';
-
-export const STRING_ARABIC_NUMERALS = '0123456789';
-export const STRING_HEXADECIMALS = '0123456789abcdef';
-export const STRING_LOWERCASE_ALPHA = 'abcdefghijklmnopqrstuvwxyz';
-export const STRING_UPPERCASE_ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-export const STRING_DICT = `${STRING_ARABIC_NUMERALS + STRING_UPPERCASE_ALPHA + STRING_LOWERCASE_ALPHA}`;
-
-/**
- * 将字符串转换为驼峰格式
- * @param {string} string - 要转换的字符串
- * @param {boolean} [bigger] - 是否大写第一个字母，默认为 false
- * @returns {string} - 转换后的驼峰格式字符串
- */
-export function stringCamelCase(string: string, bigger?: boolean): string {
-  const string2 = string.replace(/[\s_-](.)/g, (_, char) => (char as string).toUpperCase());
-  return bigger ? string2.slice(0, 1).toUpperCase() + string2.slice(1) : string2;
-}
-
-/**
- * 将字符串转换为连字格式
- * @param {string} string - 要转换的字符串
- * @param {string} [separator] - 分隔符，默认是 "-"（短横线）
- * @returns {string} - 转换后的连字格式字符串
- */
-export function stringKebabCase(string: string, separator = '-'): string {
-  return string.replace(/[A-Z]/g, (origin) => `${separator}${origin.toLowerCase()}`);
-}
-
-/**
- * 生成随机字符串
- * @param {number} length - 生成的随机字符串长度
- * @param {string} [dict] - 用于生成随机字符串的字符字典，默认为数字、小写字母和大写字母的组合
- * @returns {string} - 生成的随机字符串
- * @example
- * randomString(10); // 生成一个长度为 10 的随机字符串
- * randomString(8, 'ABCDEF'); // 生成一个长度为 8 的随机字符串，仅包含字符 'ABCDEF'
- */
-export function randomString(length: number, dict?: string): string {
-  const dictFinal = dict || STRING_DICT;
-  const dictLength = dictFinal.length;
-
-  let result = '';
-
-  for (let i = 0; i < length; i++) {
-    result += dictFinal.charAt(randomNumber(0, dictLength - 1));
-  }
-
-  return result;
-}
-
-/**
- * 简单的模板引擎，类似于 Python 的 `.format()` 方法
- * 支持通过索引或对象/名称的方式传递变量
- * 当使用对象/名称方式时，可以传递一个回退值作为第三个参数
- *
- * @category 字符串
- * @example
- * ```
- * // 索引方式
- * const result = stringFormat(
- *   '你好 {0}！我的名字是 {1}。',
- *   '张三',
- *   '李四'
- * ); // 你好 张三！我的名字是 李四。
- * ```
- *
- * @example
- * ```
- * // 对象方式
- * const result = stringFormat(
- *   '{greet}！我的名字是 {name}。',
- *   { greet: '你好', name: '王五' }
- * ); // 你好！我的名字是 王五。
- * ```
- *
- * @example
- * ```
- * // 带回退值的对象方式
- * const result = stringFormat(
- *   '{greet}！我的名字是 {name}。',
- *   { greet: '你好' }, // name 未传递，因此会使用回退值
- *   '未知'
- * ); // 你好！我的名字是 未知。
- * ```
- */
-export function stringFormat(
-  str: string,
-  object: Record<string | number, unknown>,
-  fallback?: string | ((key: string) => string),
-): string;
-export function stringFormat(str: string, ...args: (string | number | bigint | undefined | null)[]): string;
-export function stringFormat(str: string, ...args: unknown[]): string {
-  const [firstArg, fallback] = args;
-
-  if (isObject(firstArg) || isUndefined(firstArg)) {
-    const vars = firstArg || {};
-    return str.replace(/\{(\w+)\}/g, (_, key) => vars[key] ?? (isFunction(fallback) ? fallback(key) : fallback) ?? key);
-  }
-
-  return str.replace(/\{(\d+)\}/g, (_, key) => {
-    const index = Number(key);
-    if (Number.isNaN(index)) return key;
-    return args[index];
-  });
-}
-
-/**
- * 生成符合 [RFC 4122](https://www.ietf.org/rfc/rfc4122.txt) 版本 4 的 UUID 字符串
- * @returns {string} - 生成的 UUID 字符串
- * @example
- * const uuid = randomUUID4();
- * console.log(uuid); // 输出类似 '123e4567-e89b-12d3-a456-426614174000' 的 UUID 字符串
- */
-export function randomUUID4(): string {
-  const template = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-  let result = '';
-
-  for (let i = 0; i < template.length; i++) {
-    const t = template[i];
-
-    if (t === '-' || t === '4') {
-      result += t;
-      continue;
-    }
-
-    if (t === 'y') {
-      result += randomString(1, '89ab');
-      continue;
-    }
-
-    result += randomString(1, STRING_HEXADECIMALS);
-  }
-
-  return result;
-}
-
-/**
- * 将值转换为字符串，若值为 null 或 undefined 则返回空字符串
- * @param {unknown} value - 需要转换的值
- * @returns {string} 转换后的字符串结果
- */
-export function stringify(value: unknown) {
-  return isNullish(value) ? '' : String(value);
-}

package/src/time/from.ts

@@ -1,57 +0,0 @@
-// @rer https://day.js.org/docs/en/durations/creating
-
-import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';
-import { isString } from '@/type';
-import type { TTimeDuration } from './to';
-
-/**
- * 时间转换规则数组
- * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}
- * @property {RegExp} 0 - 匹配时间单位正则表达式
- * @property {function} 1 - 将匹配结果转换为毫秒数的函数
- */
-const rules: [key: keyof TTimeDuration, time: number][] = [
-  ['years', DATE_YEAR_MS],
-  ['months', DATE_MONTH_MS],
-  ['days', DATE_DAY_MS],
-  ['hours', DATE_HOUR_MS],
-  ['minutes', DATE_MINUTE_MS],
-  ['seconds', DATE_SECOND_MS],
-];
-
-/**
- * 将时间持续时间字符串或对象转换为毫秒数
- *
- * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TTimeDuration 对象
- * @returns 计算得到的总毫秒数
- */
-export function timeFrom(duration: string | TTimeDuration) {
-  const td = isString(duration) ? timeParse(duration) : duration;
-  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
-}
-
-const durationMatchRules: [RegExp, key: keyof TTimeDuration][] = [
-  [/(\d+)y/i, 'years'],
-  [/(\d+)M/, 'months'],
-  [/(\d+)d/i, 'days'],
-  [/(\d+)h/i, 'hours'],
-  [/(\d+)m/, 'minutes'],
-  [/(\d+)s/, 'seconds'],
-];
-
-/**
- * 将时长字符串解析为时间对象
- * @param duration - 时长字符串（例如 "1h30m"）
- * @returns 包含解析后时间单位的对象（小时、分钟等）
- */
-export function timeParse(duration: string) {
-  const result = {} as TTimeDuration;
-
-  for (const [regex, key] of durationMatchRules) {
-    const match = duration.match(regex);
-    if (match) result[key] = Number(match[1]);
-    else result[key] = 0;
-  }
-
-  return result;
-}

package/src/time/to.ts

@@ -1,106 +0,0 @@
-import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';
-
-export type TTimeDuration = {
-  years: number;
-  months: number;
-  /** 天数 */
-  days: number;
-  /** 小时数 */
-  hours: number;
-  /** 分钟数 */
-  minutes: number;
-  /** 秒数 */
-  seconds: number;
-  /** 毫秒数 */
-  milliseconds: number;
-};
-
-type _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';
-
-/**
- * 解析时间毫秒数为绝对时间对象
- * @param timeMs 时间毫秒数
- * @param maxPoint 最大时间单位（决定分解的起始单位）
- * @returns 包含时间单位分解结果的对象
- * @example
- * ```typescript
- * // 默认以天为最大单位分解
- * timeInDay(123456789);
- * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }
- *
- * // 指定最大单位为分钟，分解到分钟及以下单位
- * timeInMinute(123456789);
- * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }
- * ```
- */
-function _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TTimeDuration {
-  const minPoint: _TTimeParsePoint = 'S';
-
-  const defines: [point: _TTimeParsePoint, key: keyof TTimeDuration, base: number][] = [
-    ['D', 'days', DATE_DAY_MS],
-    ['h', 'hours', DATE_HOUR_MS],
-    ['m', 'minutes', DATE_MINUTE_MS],
-    ['s', 'seconds', DATE_SECOND_MS],
-    ['S', 'milliseconds', 1],
-  ] as const;
-
-  const minIndex = defines.findIndex((item) => item[0] === maxPoint);
-  const maxIndex = defines.findIndex((item) => item[0] === minPoint);
-
-  let timeMsFinal = timeMs;
-  const dao: TTimeDuration = {
-    years: 0,
-    months: 0,
-    days: 0,
-    hours: 0,
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0,
-  };
-
-  for (let i = minIndex; i <= maxIndex; i++) {
-    const mode = defines[i];
-    const base = mode[2];
-    const value = Math.floor(timeMsFinal / base);
-    timeMsFinal = timeMsFinal - value * base;
-    dao[mode[1]] = value;
-  }
-
-  return dao;
-}
-
-/**
- * 将时间毫秒数解析为以天为最大单位的绝对时间对象
- * @param timeMs 时间毫秒数
- * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象
- */
-export function timeToDays(timeMs: number) {
-  return _timeAbsolute(timeMs, 'D');
-}
-
-/**
- * 将时间毫秒数解析为以小时为最大单位的绝对时间对象
- * @param timeMs 时间毫秒数
- * @returns 包含小时/分钟/秒/毫秒分解结果的对象
- */
-export function timeToHours(timeMs: number) {
-  return _timeAbsolute(timeMs, 'h');
-}
-
-/**
- * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象
- * @param timeMs 时间毫秒数
- * @returns 包含分钟/秒/毫秒分解结果的对象
- */
-export function timeToMinutes(timeMs: number) {
-  return _timeAbsolute(timeMs, 'm');
-}
-
-/**
- * 将时间毫秒数解析为以秒为最大单位的绝对时间对象
- * @param timeMs 时间毫秒数
- * @returns 包含秒/毫秒分解结果的对象
- */
-export function timeToSeconds(timeMs: number) {
-  return _timeAbsolute(timeMs, 's');
-}

package/src/unique.ts

@@ -1,77 +0,0 @@
-import { numberConvert, randomNumber } from './number';
-import { STRING_DICT } from './string';
-import { isNumber, isString } from './type';
-
-let lastTimestamp = 0;
-let lastSafePadding = 0;
-
-/**
- * 生成一个唯一的 BigInt 值。
- *
- * @param randomLength - 可选参数，指定随机部分的长度，默认为 0。
- *                        如果大于 0，则会在结果中附加指定长度的随机数。
- * @returns 返回一个唯一的 BigInt 值，包含时间戳、随机部分（如果有）以及递增的填充值。
- */
-export function uniqueBigInt(randomLength = 0): bigint {
-  const now = Date.now();
-
-  if (now !== lastTimestamp) {
-    lastTimestamp = now;
-    lastSafePadding = 0;
-  }
-
-  let randomPart = '';
-
-  if (randomLength > 0) {
-    const randomMin = 10 ** (randomLength - 1);
-    const randomMax = 10 ** randomLength - 1;
-    randomPart = String(randomNumber(randomMin, randomMax));
-  }
-
-  return BigInt(randomPart + lastSafePadding++ + now);
-}
-
-const _randomChar = (dict: string): string => {
-  const poolIndex = randomNumber(0, dict.length - 1);
-
-  return dict[poolIndex];
-};
-
-/**
- * 生成一个唯一的字符串。
- *
- * @param minLength - 可选参数，指定生成字符串的最小长度。
- *                 如果未提供或为字符串类型，则使用默认长度。
- * @param dict - 可选参数，指定生成字符串时使用的字符集。
- *               如果未提供，则使用默认字符集 `STRING_DICT`。
- * @returns 返回一个唯一的字符串，包含时间戳、随机部分（如果有）以及递增的填充值。
- *          如果指定了 `length`，则返回值的长度将被调整到指定长度。
- */
-export function uniqueString(minLength: number, dict: string): string;
-export function uniqueString(minLength: number): string;
-export function uniqueString(dict: string): string;
-export function uniqueString(): string;
-export function uniqueString(minLength?: number | string, dict?: string) {
-  let finalLength = 0;
-  let finalDict = STRING_DICT;
-
-  if (isString(dict)) {
-    finalLength = minLength as number;
-    finalDict = dict;
-  } else if (isNumber(minLength)) {
-    finalLength = minLength;
-  } else if (isString(minLength)) {
-    finalDict = minLength;
-  }
-
-  let uniqueString = numberConvert(uniqueBigInt(), finalDict);
-  let insertLength = finalLength - uniqueString.length;
-
-  if (insertLength <= 0) return uniqueString;
-
-  while (insertLength--) {
-    uniqueString += _randomChar(finalDict);
-  }
-
-  return uniqueString;
-}

package/src/url.ts

@@ -1,93 +0,0 @@
-/**
- * 表示解析后的 URL 组件。
- */
-export type TURLMeta = {
-  /**
-   * 协议部分，包含冒号，例如 "https:"。
-   */
-  protocol: string;
-  /**
-   * 主机部分，包括主机名和端口。
-   */
-  host: string;
-  /**
-   * 主机名部分。
-   */
-  hostname: string;
-  /**
-   * 端口部分。
-   */
-  port: string;
-  /**
-   * 路径部分。
-   */
-  pathname: string;
-  /**
-   * 查询字符串部分。
-   */
-  search: string;
-  /**
-   * 哈希部分。
-   */
-  hash: string;
-  /**
-   * 用户名部分。
-   */
-  username: string;
-  /**
-   * 密码部分。
-   */
-  password: string;
-};
-
-/**
- * 解析 URL 字符串为组件对象。
- * @param url - 需要解析的 URL 字符串。
- * @returns 包含解析后 URL 组件的对象。
- */
-export function urlParse(url: string): TURLMeta {
-  let result: URL | null = null;
-
-  try {
-    // 添加 globalThis 是便于对接外部环境 URL 的自行实现
-    // 例如在 uni-app、微信小程序等运行环境。
-    result = new globalThis.URL(url);
-  } catch (e) {
-    // ignore
-  }
-
-  const protocol = result?.protocol || '';
-  const host = result?.host || '';
-
-  return {
-    protocol,
-    host,
-    hostname: result?.hostname || '',
-    port: result?.port || '',
-    pathname: result?.pathname || '',
-    search: result?.search || '',
-    hash: result?.hash || '',
-    username: result?.username || '',
-    password: result?.password || '',
-  };
-}
-
-/**
- * 将 URLInfo 对象转换回 URL 字符串。
- * @param url - 需要转换的 URLInfo 对象。
- * @returns 转换后的 URL 字符串。
- */
-export function urlStringify(url: TURLMeta) {
-  const { protocol, hostname, port, pathname, search, hash, username, password } = url;
-  return [
-    protocol ? `${protocol}//` : '',
-    username && password ? `${username}:${password}@` : '',
-    hostname,
-    port ? `:${port}` : '',
-    pathname,
-    search,
-    hash,
-  ]
-    .filter(Boolean)
-    .join('');
-}

package/src/version.ts

@@ -1,71 +0,0 @@
-import { isUndefined } from './type';
-
-/**
- * 表示包含主版本号、次版本号和修订号的对象
- */
-export type TVersionObject = {
-  /**
-   * 主版本号，当有不兼容的API修改时递增
-   */
-  major: number;
-  /**
-   * 次版本号，当有向下兼容的功能新增时递增
-   */
-  minor: number;
-  /**
-   * 修订号，当有向下兼容的问题修正时递增
-   */
-  patch: number;
-};
-
-/**
- * 将数字转换为安全的数值，如果输入为NaN则返回0
- * @param n - 要转换的数字
- * @returns 安全的数字（如果输入为NaN则返回0）
- */
-function internal_numerical(n?: number) {
-  return Number.isNaN(n) || isUndefined(n) ? 0 : n;
-}
-
-/**
- * 将语义化版本号字符串解析为VersionObject对象
- * @param version - 要解析的版本号字符串 (例如 "1.2.3")
- * @returns 包含主版本号、次版本号和修订号的对象
- * @throws 如果版本号字符串格式无效将抛出错误
- */
-export function versionParse(version: string): TVersionObject {
-  const [major, minor, patch] = version.split('.').map(Number);
-  return {
-    major: internal_numerical(major),
-    minor: internal_numerical(minor),
-    patch: internal_numerical(patch),
-  };
-}
-
-/**
- * 比较两个语义化版本号字符串
- * @param version1 - 要比较的第一个版本号字符串
- * @param version2 - 要比较的第二个版本号字符串
- * @returns 如果version1较大返回1，version2较大返回-1，相等返回0
- * @throws 如果任一版本号字符串格式无效将抛出错误
- */
-export function versionCompare(version1: string, version2: string): number {
-  const vo1 = versionParse(version1);
-  const vo2 = versionParse(version2);
-  const order: (keyof TVersionObject)[] = ['major', 'minor', 'patch'];
-
-  for (const key of order) {
-    const n1 = vo1[key];
-    const n2 = vo2[key];
-
-    if (n1 > n2) {
-      return 1;
-    }
-
-    if (n1 < n2) {
-      return -1;
-    }
-  }
-
-  return 0;
-}