@cloudcome/utils-core 1.1.1 → 1.2.1

package/src/object/is.ts

@@ -1,128 +0,0 @@
-import { isArray, isObject, isString, typeIs } from '@/type';
-import type { AnyArray, AnyFunction, AnyObject } from '@/types';
-
-/**
- * 检查一个对象是否为空对象（不包含任何自有属性，包括符号属性）。
- *
- * @param obj - 要检查的对象
- * @returns 如果对象没有自有属性（包括符号属性）则返回 true，否则返回 false
- *
- * @example
- * ```typescript
- * isEmptyObject({}); // true
- * isEmptyObject({ a: 1 }); // false
- * isEmptyObject(Object.create(null)); // true
- * isEmptyObject({ [Symbol('key')]: 'value' }); // false
- * ```
- */
-export function isEmptyObject(obj: AnyObject): boolean {
-  return Object.getOwnPropertyNames(obj).length === 0 && Object.getOwnPropertySymbols(obj).length === 0;
-}
-
-/**
- * 检查一个对象是否为纯对象（通过对象字面量或Object构造函数创建，而非其他构造函数的实例）。
- *
- * @param obj - 要检查的对象
- * @returns 如果是纯对象则返回 true，否则返回 false
- *
- * @example
- * ```typescript
- * isPlainObject({}); // true
- * isPlainObject(Object.create(null)); // true
- * isPlainObject(new Date()); // false
- * isPlainObject([]); // false
- * isPlainObject(() => {}); // false
- * ```
- */
-export function isPlainObject(obj: AnyObject): boolean {
-  const proto: unknown = Object.getPrototypeOf(obj);
-
-  // 对象无原型
-  if (!proto) return true;
-
-  // 是否对象直接实例
-  return proto === Object.prototype;
-}
-
-// 移除，原因是，定义对象尽可能的使用 type 关键字即可避开此问题
-// /**
-//  * 精确对象，常用于联合类型判断
-//  * 相关 bug：https://l.ydr.me/Zp88vFKc
-//  */
-// // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-// export type ExactObject<T = any> = T extends AnyFunction
-//   ? never
-//   : T extends AnyArray
-//     ? never
-//     : T extends object
-//       ? T
-//       : never;
-//
-// /**
-//  * 检查值是否为精确接口对象
-//  * @param object - 传入对象，必须是一个对象与其他类型的联合
-//  * @returns 如果值为对象则返回 true，否则返回 false
-//  * @example
-//  * ```typescript
-//  * type Id = string | string[] | (() => string);
-//  *
-//  * interface Cache {
-//  *   id?: Id;
-//  * }
-//  *
-//  * type Share = {
-//  *   id?: Id;
-//  * }
-//  *
-//  * interface Options {
-//  *   cache?: Id | Cache;
-//  *   share?: Id | Share;
-//  * }
-//  *
-//  * function test(options: Options) {
-//  *   // string | string[] | (() => string) | Cache | undefined
-//  *   const cache = options.cache;
-//  *
-//  *   // Cache
-//  *   // 需要使用
-//  *   if (isExactObject(cache)) {
-//  *     cache.id;
-//  *   }
-//  *   // string[]
-//  *   else if (isArray(cache)) {
-//  *     cache.push();
-//  *   }
-//  *   // string
-//  *   else if (isString(cache)) {
-//  *     cache.charCodeAt(0);
-//  *   }
-//  *   // (() => string) | undefined
-//  *   else {
-//  *     cache?.();
-//  *   }
-//  *
-//  *   // string | string[] | (() => string) | Share | undefined
-//  *   const share = options.share;
-//  *
-//  *   // Share
-//  *   if (isObject(share)) {
-//  *     share.id;
-//  *   }
-//  *   // string[]
-//  *   else if (isArray(share)) {
-//  *     share.push();
-//  *   }
-//  *   // string
-//  *   else if (isString(share)) {
-//  *     share.charCodeAt(0);
-//  *   }
-//  *   // (() => string) | undefined
-//  *   else {
-//  *     share?.();
-//  *   }
-//  * }
-//  * ```
-//  */
-// export function isExactObject<T>(object: T): object is ExactObject<T> {
-//   return typeIs(object) === 'object';
-// }

package/src/object/merge.ts

@@ -1,180 +0,0 @@
-import { isArray, isObject, typeIs } from '@/type';
-import type { AnyArray, AnyObject } from '@/types';
-import { objectEach } from './each';
-
-export type TObjectMergeRule = {
-  /**
-   * 处理冲突
-   * @param target - 目标对象
-   * @param source - 源对象
-   * @param key - 键名
-   * @returns 返回 true 表示继续处理，否则返回 false
-   */
-  next: (info: {
-    target: AnyObject | AnyArray;
-    source: AnyObject | AnyArray;
-    key: string | number;
-  }) => boolean;
-
-  /**
-   * 处理赋值
-   * @param target - 目标对象
-   * @param source - 源对象
-   * @param key - 键名
-   * @returns 返回处理后的值
-   */
-  assign: (info: {
-    target: AnyObject | AnyArray;
-    source: AnyObject | AnyArray;
-    key: string | number;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    merge: () => any;
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  }) => any;
-};
-
-function _objectMerge(mergeRule: TObjectMergeRule, target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {
-  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();
-  const { assign, next } = mergeRule;
-  const align = (target: AnyObject | AnyArray, source: AnyObject | AnyArray) => {
-    const targetType = typeIs(target);
-    const sourceType = typeIs(source);
-
-    if (targetType === sourceType) {
-      return target;
-    }
-
-    return sourceType === 'array' ? [] : {};
-  };
-  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  const each = (source: AnyObject | AnyArray, iterator: (val: any, key: string | number) => void) => {
-    if (isObject(source)) {
-      objectEach(source, iterator);
-    } else {
-      source.forEach(iterator);
-    }
-  };
-
-  const merge = (target: AnyObject | AnyArray, source: AnyObject | AnyArray): AnyObject | AnyArray => {
-    // 如果循环引用了，则直接返回目标对象
-    if (seen.has(source)) {
-      // biome-ignore lint/style/noNonNullAssertion: <explanation>
-      return seen.get(source)!;
-    }
-
-    // 对齐目标对象和源对象
-    const merged = align(target, source);
-
-    // 存储循环引用
-    seen.set(source, merged);
-
-    // 遍历源对象
-    each(source, (value, key) => {
-      if (!next({ target: merged, source, key })) {
-        return;
-      }
-
-      if (isObject(value) || isArray(value)) {
-        // @ts-expect-error
-        merged[key] = assign({
-          target: merged,
-          source,
-          key,
-          // @ts-expect-error
-          merge: () => merge(merged[key], value),
-        });
-      } else {
-        // @ts-expect-error
-        merged[key] = assign({
-          target: merged,
-          source,
-          key,
-          merge: () => value,
-        });
-      }
-    });
-
-    return merged;
-  };
-
-  let returnTarget = target;
-
-  for (const source of sources) {
-    returnTarget = merge(target, source);
-  }
-
-  return returnTarget;
-}
-
-/**
- * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。
- *
- * @param target - 目标对象或数组。
- * @param sources - 要合并的源对象或数组。
- * @returns 合并后的对象或数组。
- *
- * @example
- * ```typescript
- * const obj1 = { a: 1, b: { x: 10 } };
- * const obj2 = { b: { y: 20 }, c: 3 };
- * const merged = objectMerge(obj1, obj2);
- * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }
- * ```
- */
-export function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {
-  return _objectMerge(
-    {
-      next() {
-        return true;
-      },
-      assign({ merge }) {
-        return merge();
-      },
-    },
-    target,
-    ...sources,
-  );
-}
-
-/**
- * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。
- * 支持多个默认对象，优先级从左到右依次降低。
- * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。
- *
- * @param target - 目标对象或数组。
- * @param defaults - 默认对象或数组。
- * @returns 合并后的对象或数组。
- *
- * @example
- * ```typescript
- * const obj = { a: 1, b: undefined };
- * const defaults = { a: 4, b: 2, c: 3 };
- * const result = objectDefaults(obj, defaults);
- * console.log(result); // { a: 1, b: 2, c: 3 }
- *
- * const obj2 = { a: 1, b: 2 };
- * const defaults2 = { a: 5, b: 3, c: 4 };
- * const result2 = objectDefaults(obj2, defaults2);
- * console.log(result2); // { a: 1, b: 2, c: 4 }
- *
- * const obj3 = { a: { x: 1 }, b: undefined };
- * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };
- * const result3 = objectDefaults(obj3, defaults3);
- * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }
- * ```
- */
-export function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T {
-  return _objectMerge(
-    {
-      next({ target, source, key }) {
-        // @ts-expect-error
-        return target[key] === undefined || isObject(target[key]) || isArray(target[key]);
-      },
-      assign({ merge }) {
-        return merge();
-      },
-    },
-    target,
-    defaults,
-  ) as T;
-}

package/src/path.ts

@@ -1,188 +0,0 @@
-import { arrayEach } from './array';
-
-/**
- * 判断是否是当前目录标记
- * @param {string} slice - 路径片段
- * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false
- */
-function _isCurrentSlice(slice: string): boolean {
-  return slice === '.';
-}
-
-/**
- * 判断是否是上级目录标记
- * @param {string} slice - 路径片段
- * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false
- */
-function _isParentSlice(slice: string): boolean {
-  return slice === '..';
-}
-
-/**
- * 判断是否是绝对路径
- * @param {string} path - 路径字符串
- * @returns {boolean} - 如果是绝对路径则返回true，否则返回false
- * @example
- * ```typescript
- * const isAbs = isAbsolutePath('/path/to/file');
- * console.log(isAbs); // 输出: true
- * ```
- */
-export function isAbsolutePath(path: string): boolean {
-  return path.startsWith('/');
-}
-
-/**
- * 判断是否是相对路径
- * @param {string} path - 路径字符串
- * @returns {boolean} - 如果是相对路径则返回true，否则返回false
- * @example
- * ```typescript
- * const isRel = isRelativePath('path/to/file');
- * console.log(isRel); // 输出: true
- * ```
- */
-export function isRelativePath(path: string): boolean {
-  return !isAbsolutePath(path);
-}
-
-/**
- * 标准化路径
- * @param {string} path - 要标准化的路径字符串。
- * @returns {string} - 标准化后的路径字符串。
- * @example
- * ```typescript
- * const normalizedPath = pathNormalize('/path///to///file');
- * console.log(normalizedPath); // 输出: '/path/to/file'
- * ```
- */
-export function pathNormalize(path: string): string {
-  const slices = path
-    .replace(/\\/g, '/')
-    .replace(/\/{2,}/g, '/')
-    .replace(/\.{3,}/g, '..')
-    .replace(/\/\.\//g, '/')
-    .split('/')
-    .map((point) => point.trim());
-  const points: string[] = [];
-  const isAbs = slices[0] === '';
-
-  const push = (point: string) => {
-    points.push(point);
-  };
-
-  const back = () => {
-    // 绝对路径不能退到根目录
-    if (points.length === 1 && isAbs) return;
-
-    //
-    if (points.length === 0 || points.at(-1) === '..') {
-      points.push('..');
-    } else {
-      points.pop();
-    }
-  };
-
-  for (const slice of slices) {
-    const isCurrent = _isCurrentSlice(slice);
-    const isParent = _isParentSlice(slice);
-
-    // // 未进入实际路径
-    // if (!inPoints) {
-    //   push(slice);
-    //   inPoints = !isCurrent && !isParent;
-    //   continue;
-    // }
-
-    if (isCurrent) {
-      continue;
-    }
-
-    if (isParent) {
-      back();
-      continue;
-    }
-
-    push(slice);
-  }
-
-  return points.join('/');
-}
-
-/**
- * 路径合并
- * @param {string} from - 起始路径。
- * @param {...string[]} to - 要合并的路径片段。
- * @returns {string} - 合并后的路径字符串。
- * @example
- * ```typescript
- * const fullPath = pathJoin('/path', '/to', 'file');
- * console.log(fullPath); // 输出: '/path/to/file'
- * ```
- */
-export function pathJoin(from: string, ...to: string[]): string {
-  return pathNormalize([from, ...to].join('/'));
-}
-
-/**
- * 解析路径
- * @param {string} from - 起始路径
- * @param {...string[]} to - 要解析的路径片段
- * @returns {string} - 解析后的绝对路径
- * @example
- * ```typescript
- * const resolvedPath = pathResolve('/path', '/to', 'file');
- * console.log(resolvedPath); // 输出: '/to/file'
- * ```
- */
-export function pathResolve(from: string, ...to: string[]): string {
-  const paths = [from, ...to].map(pathNormalize);
-
-  let lastStartPath = from;
-  let lastStartIndex = 0;
-
-  arrayEach(
-    paths,
-    (path, index) => {
-      if (isAbsolutePath(path)) {
-        lastStartPath = path;
-        lastStartIndex = index;
-        return false;
-      }
-    },
-    true,
-  );
-
-  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
-}
-
-/**
- * 将相对路径转换为标准的相对路径格式(添加'./'前缀)
- *
- * @param {string} path - 要处理的路径字符串
- * @returns {string} 处理后的路径字符串
- *
- * @example <caption>处理绝对路径</caption>
- * ```typescript
- * const result = pathRelativize('/path/to/file');
- * console.log(result); // 输出: '/path/to/file'
- * ```
- *
- * @example <caption>处理已带'./'前缀的相对路径</caption>
- * ```typescript
- * const result = pathRelativize('./path/to/file');
- * console.log(result); // 输出: './path/to/file'
- * ```
- *
- * @example <caption>处理不带'./'前缀的相对路径</caption>
- * ```typescript
- * const result = pathRelativize('path/to/file');
- * console.log(result); // 输出: './path/to/file'
- * ```
- */
-export function pathRelativize(path: string): string {
-  if (isAbsolutePath(path)) return path;
-  if (path.startsWith('./')) return path;
-  if (path.startsWith('../')) return path;
-  return `./${path}`;
-}

package/src/regexp.ts

@@ -1,156 +0,0 @@
-const specialRE = /[.*+?^=!:${}()|[\]/\\-]/g;
-
-/**
- * 编码处理正则表达式
- * @example
- * ```js
- * reEscape('/$')
- * // => '\\/\\$'
- * ```
- * @param {string} string
- * @returns {string}
- */
-export function regexpEscape(string: string): string {
-  return string.replace(specialRE, '\\$&');
-}
-
-// 邮箱
-const EMAIL_RE = /^\w+[-+.\w]*@([a-z\d-]+\.)+[a-z]{2,5}$/i;
-/**
- * 判断字符串是否为邮箱格式，不对邮箱真实性做验证，如域名是否正确等
- * @param {string} value
- * @returns {boolean}
- */
-export function isEmail(value: string): boolean {
-  return EMAIL_RE.test(value);
-}
-
-// 手机号码
-const PHONE_RE = /^1\d{10}$/;
-/**
- * 判断字符串是否为宽松手机格式，即首位为 1 的 11 位数字都属于手机号
- * @param {string} value
- * @returns {boolean}
- */
-export function isPhone(value: string): boolean {
-  return PHONE_RE.test(value);
-}
-
-// 身份证号码
-// http://www.stats.gov.cn/tjsj/tjbz/xzqhdm/
-// ["北京市", "天津市", "河北省", "山西省", "内蒙古自治区",
-// "辽宁省", "吉林省", "黑龙江省",
-// "上海市", "江苏省", "浙江省", "安徽省", "福建省", "江西省", "山东省",
-// "河南省", "湖北省", "湖南省", "广东省", "广西壮族自治区", "海南省",
-// "重庆市", "四川省", "贵州省", "云南省", "西藏自治区",
-// "陕西省", "甘肃省", "青海省","宁夏回族自治区", "新疆维吾尔自治区",
-// "台湾省",
-// "香港特别行政区", "澳门特别行政区"]
-// ["11", "12", "13", "14", "15",
-// "21", "22", "23",
-// "31", "32", "33", "34", "35", "36", "37",
-// "41", "42", "43", "44", "45", "46",
-// "50", "51", "52", "53", "54",
-// "61", "62", "63", "64", "65",
-// "71",
-// "81", "82"]
-// 91 国外
-const IDNO_RE =
-  /^(1[1-5]|2[1-3]|3[1-7]|4[1-6]|5[0-4]|6[1-5]|7[1]|8[1-2]|9[1])\d{4}(18|19|20)\d{2}[01]\d[0123]\d{4}[\dxX]$/;
-/**
- * 判断字符串是否为身份证号码格式
- * @param {string} value
- * @returns {boolean}
- */
-export function isIDNo(value: string): boolean {
-  const isSameFormat = IDNO_RE.test(value);
-
-  if (!isSameFormat) return false;
-
-  const year = Number(value.slice(6, 10));
-  const month = Number(value.slice(10, 12));
-  const date = Number(value.slice(12, 14));
-  const d = new Date(year, month - 1, date);
-  const isSameDate = d.getFullYear() === year && d.getMonth() + 1 === month && d.getDate() === date;
-
-  if (!isSameDate) return false;
-
-  // 将身份证号码前面的17位数分别乘以不同的系数；
-  // 从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2
-  // 将这17位数字和系数相乘的结果相加；
-  // 用加出来和除以11，看余数是多少；
-  // 余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字；
-  // 其分别对应的最后一位身份证的号码为1－0－X－9－8－7－6－5－4－3－2
-  // 通过上面得知如果余数是2，就会在身份证的第18位数字上出现罗马数字的Ⅹ。如果余数是10，身份证的最后一位号码就是2。
-  const coefficientList = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
-  const residueList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
-  let sum = 0;
-
-  for (let start = 0; start < 17; start++) {
-    sum += Number(value.slice(start, start + 1)) * coefficientList[start];
-  }
-
-  return residueList[sum % 11] === value.slice(-1);
-}
-
-// url
-const URL_RE =
-  /^https?:\/\/(([a-z\d-]+\.)+[a-z]{2,5}|(\d{1,3}\.){3}\d{1,3})(:[1-9]\d{0,4})?(\/|\/[\w#!:.?+=&%@'/()-]+)?$/i;
-/**
- * 判断字符串是否为 url 格式，仅支持 http 协议，支持域名或者 ipV4
- * @param {string} value
- * @returns {boolean}
- */
-export function isURL(value: string): boolean {
-  return URL_RE.test(value);
-}
-
-// ipv4
-const IPV4_RE = /^(?:(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$/;
-/**
- * 判断字符串是否为 IPV4 格式，不对 ip 真实性做验证
- * @param {string} value
- * @returns {boolean}
- */
-export function isIPV4(value: string): boolean {
-  return IPV4_RE.test(value);
-}
-
-const INTEGER_RE = /^(-?[1-9]\d*|0)$/;
-/**
- * 判断字符串是否为整数（自然数），即 ...,-3,-2,-1,0,1,2,3,...
- * @param {string} value
- * @returns {boolean}
- */
-export function isInteger(value: string): boolean {
-  return INTEGER_RE.test(value);
-}
-
-const FLOAT_RE = /^-?([1-9]\d*|0)\.\d+$/;
-/**
- * 判断字符串是否为浮点数，即必须有小数点的有理数
- * @param {string} value
- * @returns {boolean}
- */
-export function isFloat(value: string): boolean {
-  return FLOAT_RE.test(value);
-}
-
-/**
- * 判断字符串是否为正确数值，包括整数和浮点数
- * @param {string} value
- * @returns {boolean}
- */
-export function isNumerical(value: string): boolean {
-  return isInteger(value) || isFloat(value);
-}
-
-const DIGIT_RE = /^\d+$/;
-/**
- * 判断字符串是否为数字，例如六位数字短信验证码（093031）
- * @param {string} value
- * @returns {boolean}
- */
-export function isDigit(value: string): boolean {
-  return DIGIT_RE.test(value);
-}