@cloudcome/utils-core 1.1.1 → 1.2.1

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;
-}

package/test/array.test.ts

@@ -1,332 +0,0 @@
-import { promiseDelay } from '@/promise';
-import { describe, expect, it, vi } from 'vitest';
-import { arrayDiff, arrayEach, arrayEachAsync, arrayMove, arrayOmit, arrayPick, isArrayLike } from '../src/array';
-
-describe('isArrayLike', () => {
-  it('应正确判断类数组对象', () => {
-    expect(isArrayLike({ length: 0 })).toBe(true);
-    expect(isArrayLike({ length: 1, 0: 'a' })).toBe(true);
-    expect(isArrayLike({ length: -1 })).toBe(false);
-    expect(isArrayLike({ length: '1' })).toBe(false);
-    expect(isArrayLike([])).toBe(true);
-    expect(isArrayLike([1, 2, 3])).toBe(true);
-    expect(isArrayLike({})).toBe(false);
-    expect(isArrayLike(null)).toBe(false);
-    expect(isArrayLike(undefined)).toBe(false);
-    expect(isArrayLike('string')).toBe(false);
-    expect(isArrayLike(123)).toBe(false);
-  });
-});
-
-describe('arrayPick', () => {
-  it('应从数组中选择指定索引的元素', () => {
-    expect(arrayPick([1, 2, 3, 4], [0, 2])).toEqual([1, 3]);
-    expect(arrayPick([1, 2, 3, 4], [2, 0])).toEqual([1, 3]);
-    expect(arrayPick(['a', 'b', 'c'], [1])).toEqual(['b']);
-    expect(arrayPick([true, false, true], [0, 1, 2])).toEqual([true, false, true]);
-    expect(arrayPick([], [0, 1])).toEqual([]);
-    expect(arrayPick([1, 2, 3], [])).toEqual([]);
-  });
-});
-
-describe('arrayOmit', () => {
-  it('应从数组中排除指定索引的元素', () => {
-    expect(arrayOmit([1, 2, 3, 4], [0, 2])).toEqual([2, 4]);
-    expect(arrayOmit(['a', 'b', 'c'], [1])).toEqual(['a', 'c']);
-    expect(arrayOmit([true, false, true], [0, 1, 2])).toEqual([]);
-    expect(arrayOmit([], [0, 1])).toEqual([]);
-    expect(arrayOmit([1, 2, 3], [])).toEqual([1, 2, 3]);
-  });
-});
-
-describe('arrayMove', () => {
-  it('应正确移动数组中的元素', () => {
-    const arr = [1, 2, 3, 4];
-    expect(arrayMove(arr, 1, 3)).toEqual([1, 3, 4, 2]);
-    expect(arrayMove(arr, 2, 0)).toEqual([3, 1, 2, 4]);
-  });
-
-  it('应处理移动到数组开头的情况', () => {
-    const arr = [1, 2, 3, 4];
-    expect(arrayMove(arr, 2, 0)).toEqual([3, 1, 2, 4]);
-  });
-
-  it('应处理移动到数组末尾的情况', () => {
-    const arr = [1, 2, 3, 4];
-    expect(arrayMove(arr, 1, 3)).toEqual([1, 3, 4, 2]);
-  });
-
-  it('应处理无效索引的情况', () => {
-    const arr = [1, 2, 3, 4];
-    expect(arrayMove(arr, 5, 0)).toEqual([1, 2, 3, 4]);
-    expect(arrayMove(arr, 0, 5)).toEqual([1, 2, 3, 4]);
-  });
-
-  it('应处理空数组的情况', () => {
-    const arr: number[] = [];
-    expect(arrayMove(arr, 0, 1)).toEqual([]);
-  });
-});
-
-describe('arrayEach', () => {
-  it('应正确遍历数组中的每个元素', () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    arrayEach(arr, (item) => {
-      results.push(item);
-    });
-
-    expect(results).toEqual([1, 2, 3]);
-  });
-
-  it('应支持提前终止遍历', () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    arrayEach(arr, (item) => {
-      results.push(item);
-      if (item === 2) return false;
-    });
-
-    expect(results).toEqual([1, 2]);
-  });
-
-  it('应正确反向遍历数组', () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    arrayEach(
-      arr,
-      (item) => {
-        results.push(item);
-      },
-      true,
-    );
-
-    expect(results).toEqual([3, 2, 1]);
-  });
-
-  it('应支持反向遍历时提前终止', () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    arrayEach(
-      arr,
-      (item) => {
-        results.push(item);
-        if (item === 2) return false;
-      },
-      true,
-    );
-
-    expect(results).toEqual([3, 2]);
-  });
-
-  it('应支持在遍历过程中删除元素', () => {
-    const arr = ['a', 'b', 'c'];
-    const fn = vi.fn();
-
-    arrayEach(arr, (val, idx) => {
-      if (val === 'b') {
-        arr.splice(idx, 1);
-      }
-
-      fn(val, idx);
-    });
-
-    expect(fn).toHaveBeenCalledTimes(3);
-    expect(fn).toHaveBeenNthCalledWith(1, 'a', 0);
-    expect(fn).toHaveBeenNthCalledWith(2, 'b', 1);
-    expect(fn).toHaveBeenNthCalledWith(3, 'c', 2);
-    expect(arr).toEqual(['a', 'c']);
-  });
-});
-
-describe('arrayEachAsync', () => {
-  it('应正确异步遍历数组中的每个元素', async () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    await arrayEachAsync(arr, async (item) => {
-      await promiseDelay(1);
-      results.push(item);
-    });
-
-    expect(results).toEqual([1, 2, 3]);
-  });
-
-  it('应支持提前终止异步遍历', async () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    await arrayEachAsync(arr, async (item) => {
-      await promiseDelay(1);
-      results.push(item);
-
-      if (item === 2) return false;
-    });
-
-    expect(results).toEqual([1, 2]);
-  });
-
-  it('应正确反向异步遍历数组', async () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    await arrayEachAsync(
-      arr,
-      async (item) => {
-        await promiseDelay(1);
-        results.push(item);
-      },
-      true,
-    );
-
-    expect(results).toEqual([3, 2, 1]);
-  });
-
-  it('应支持反向异步遍历时提前终止', async () => {
-    const arr = [1, 2, 3];
-    const results: number[] = [];
-
-    await arrayEachAsync(
-      arr,
-      async (item) => {
-        await promiseDelay(1);
-        results.push(item);
-
-        if (item === 2) return false;
-      },
-      true,
-    );
-
-    expect(results).toEqual([3, 2]);
-  });
-});
-
-describe('arrayDiff', () => {
-  it('应正确识别新增和删除的元素', () => {
-    const ref = [1, 2, 3];
-    const cur = [2, 3, 4];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([{ refIndexes: [0], refValue: 1 }]);
-    expect(diff.adds).toEqual([{ curIndexes: [2], curValue: 4 }]);
-    expect(diff.equals).toEqual([
-      { refIndexes: [1], curIndexes: [0], refValue: 2, curValue: 2 },
-      { refIndexes: [2], curIndexes: [1], refValue: 3, curValue: 3 },
-    ]);
-  });
-
-  it('应正确处理完全不同的数组', () => {
-    const ref = [1, 2, 3];
-    const cur = [4, 5, 6];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([
-      { refIndexes: [0], refValue: 1 },
-      { refIndexes: [1], refValue: 2 },
-      { refIndexes: [2], refValue: 3 },
-    ]);
-    expect(diff.adds).toEqual([
-      { curIndexes: [0], curValue: 4 },
-      { curIndexes: [1], curValue: 5 },
-      { curIndexes: [2], curValue: 6 },
-    ]);
-    expect(diff.equals).toEqual([]);
-  });
-
-  it('应正确处理完全相同的数组', () => {
-    const ref = [1, 2, 3];
-    const cur = [1, 2, 3];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([]);
-    expect(diff.adds).toEqual([]);
-    expect(diff.equals).toEqual([
-      { refIndexes: [0], curIndexes: [0], refValue: 1, curValue: 1 },
-      { refIndexes: [1], curIndexes: [1], refValue: 2, curValue: 2 },
-      { refIndexes: [2], curIndexes: [2], refValue: 3, curValue: 3 },
-    ]);
-  });
-
-  it('应正确处理重复元素的差异', () => {
-    const ref = [1, 2, 2, 3];
-    const cur = [2, 3, 3, 4];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([{ refIndexes: [0], refValue: 1 }]);
-    expect(diff.adds).toEqual([{ curIndexes: [3], curValue: 4 }]);
-    expect(diff.equals).toEqual([
-      { refIndexes: [1, 2], curIndexes: [0], refValue: 2, curValue: 2 },
-      { refIndexes: [3], curIndexes: [1, 2], refValue: 3, curValue: 3 },
-    ]);
-  });
-
-  it('应正确处理空数组的情况', () => {
-    expect(arrayDiff([], [1, 2])).toEqual({
-      deletes: [],
-      adds: [
-        { curIndexes: [0], curValue: 1 },
-        { curIndexes: [1], curValue: 2 },
-      ],
-      equals: [],
-    });
-
-    expect(arrayDiff([1, 2], [])).toEqual({
-      deletes: [
-        { refIndexes: [0], refValue: 1 },
-        { refIndexes: [1], refValue: 2 },
-      ],
-      adds: [],
-      equals: [],
-    });
-
-    expect(arrayDiff([], [])).toEqual({
-      deletes: [],
-      adds: [],
-      equals: [],
-    });
-  });
-
-  it('应正确处理包含引用类型的数组', () => {
-    const obj1 = { id: 1 };
-    const obj2 = { id: 2 };
-    const obj3 = { id: 3 };
-
-    const ref = [obj1, obj2];
-    const cur = [obj2, obj3];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([{ refIndexes: [0], refValue: obj1 }]);
-    expect(diff.adds).toEqual([{ curIndexes: [1], curValue: obj3 }]);
-    expect(diff.equals).toEqual([{ refIndexes: [1], curIndexes: [0], refValue: obj2, curValue: obj2 }]);
-  });
-
-  it('应正确处理包含特殊值的数组', () => {
-    const ref = [null, undefined, Number.NaN];
-    const cur = [undefined, null];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([{ refIndexes: [2], refValue: Number.NaN }]);
-    expect(diff.adds).toEqual([]);
-    expect(diff.equals).toEqual([
-      { refIndexes: [0], curIndexes: [1], refValue: null, curValue: null },
-      { refIndexes: [1], curIndexes: [0], refValue: undefined, curValue: undefined },
-    ]);
-  });
-
-  it('应正确处理包含NaN的情况', () => {
-    const ref = [1, Number.NaN, 2];
-    const cur = [Number.NaN, 3];
-    const diff = arrayDiff(ref, cur);
-
-    expect(diff.deletes).toEqual([
-      { refIndexes: [0], refValue: 1 },
-      { refIndexes: [2], refValue: 2 },
-    ]);
-    expect(diff.adds).toEqual([{ curIndexes: [1], curValue: 3 }]);
-    expect(diff.equals).toEqual([{ refIndexes: [1], curIndexes: [0], refValue: Number.NaN, curValue: Number.NaN }]);
-  });
-});

package/test/async-real.test.ts

@@ -1,39 +0,0 @@
-import { asyncLimit } from '@/async';
-import { describe, expect, it, vi } from 'vitest';
-import { createAfn } from './helpers';
-
-describe('asyncLimit 异常', () => {
-  it('应正确处理拒绝的 Promise', async () => {
-    const reason = Math.random().toString();
-    // const afn = createAfn({
-    //   timeout: 0,
-    //   reason: reason,
-    // });
-    // const p = afn();
-    // await expect(p).rejects.toEqual(reason);
-
-    const fn = vi.fn();
-    const result = asyncLimit(
-      [
-        createAfn({
-          delay: 100,
-          result: 1,
-        }),
-        createAfn({
-          delay: 10,
-          reason: reason,
-        }),
-        // 并发 2，第 2 个 promise 提早报错后将不会再继续执行
-        createAfn({
-          delay: 1,
-          result: 3,
-          onFinally: fn,
-        }),
-      ],
-      2,
-    );
-
-    await expect(result).rejects.toThrow(reason);
-    expect(fn).not.toHaveBeenCalled();
-  });
-});