@cloudcome/utils-core 0.0.0 → 1.1.1

package/test/time.test.ts

@@ -0,0 +1,214 @@
+import { type TTimeDuration, timeFrom, timeParse, timeToDays, timeToHours, timeToMinutes, timeToSeconds } from '@/time';
+
+describe('timeToDays', () => {
+  test('解析123456789毫秒', () => {
+    expect(timeToDays(123456789)).toMatchObject({
+      days: 1,
+      hours: 10,
+      minutes: 17,
+      seconds: 36,
+      milliseconds: 789,
+    });
+  });
+
+  test('0毫秒', () => {
+    expect(timeToDays(0)).toMatchObject({
+      days: 0,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+      milliseconds: 0,
+    });
+  });
+
+  test('精确1天', () => {
+    expect(timeToDays(86400000)).toMatchObject({
+      days: 1,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+      milliseconds: 0,
+    });
+  });
+});
+
+describe('timeToHours', () => {
+  test('解析123456789毫秒', () => {
+    expect(timeToHours(123456789)).toMatchObject({
+      days: 0,
+      hours: 34,
+      minutes: 17,
+      seconds: 36,
+      milliseconds: 789,
+    });
+  });
+
+  test('精确3小时', () => {
+    expect(timeToHours(3 * 3600000)).toMatchObject({
+      days: 0,
+      hours: 3,
+      minutes: 0,
+      seconds: 0,
+      milliseconds: 0,
+    });
+  });
+});
+
+describe('timeToMinutes', () => {
+  test('解析123456789毫秒', () => {
+    expect(timeToMinutes(123456789)).toMatchObject({
+      hours: 0,
+      minutes: 2057,
+      seconds: 36,
+      milliseconds: 789,
+    });
+  });
+
+  test('精确5分钟', () => {
+    expect(timeToMinutes(5 * 60000)).toMatchObject({
+      hours: 0,
+      minutes: 5,
+      seconds: 0,
+      milliseconds: 0,
+    });
+  });
+});
+
+describe('timeToSeconds', () => {
+  test('解析123456789毫秒', () => {
+    expect(timeToSeconds(123456789)).toMatchObject({
+      seconds: 123456,
+      milliseconds: 789,
+    });
+  });
+
+  test('精确10秒', () => {
+    expect(timeToSeconds(10000)).toMatchObject({
+      seconds: 10,
+      milliseconds: 0,
+    });
+  });
+});
+
+describe('timeFrom', () => {
+  test('解析简单时间字符串', () => {
+    expect(timeFrom('1d2h30m')).toBe(95400000);
+  });
+
+  test('解析复杂时间字符串', () => {
+    expect(timeFrom('1y2M3d4h5m6s')).toBe(36993906000);
+  });
+
+  test('解析单个时间单位', () => {
+    expect(timeFrom('1h')).toBe(3600000);
+    expect(timeFrom('30m')).toBe(1800000);
+    expect(timeFrom('10s')).toBe(10000);
+  });
+
+  test('解析大小写不敏感', () => {
+    expect(timeFrom('1D2H30M')).toBe(77853600000);
+  });
+
+  test('解析空字符串', () => {
+    expect(timeFrom('')).toBe(0);
+  });
+
+  test('解析无效字符串', () => {
+    expect(timeFrom('invalid')).toBe(0);
+  });
+
+  it('应正确计算完整时间对象的毫秒数', () => {
+    const duration: TTimeDuration = {
+      years: 1,
+      months: 2,
+      days: 3,
+      hours: 4,
+      minutes: 5,
+      seconds: 6,
+      milliseconds: 0,
+    };
+    expect(timeFrom(duration)).toBe(
+      1 * 31536000000 + // 1年
+        2 * 2592000000 + // 2个月
+        3 * 86400000 + // 3天
+        4 * 3600000 + // 4小时
+        5 * 60000 + // 5分钟
+        6 * 1000, // 6秒
+    );
+  });
+
+  it('应处理部分时间单位', () => {
+    const duration: TTimeDuration = {
+      years: 0,
+      months: 0,
+      days: 2,
+      hours: 3,
+      minutes: 0,
+      seconds: 0,
+      milliseconds: 0,
+    };
+    expect(timeFrom(duration)).toBe(
+      2 * 86400000 + // 2天
+        3 * 3600000, // 3小时
+    );
+  });
+
+  it('应处理空对象', () => {
+    const duration: TTimeDuration = {
+      years: 0,
+      months: 0,
+      days: 0,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+      milliseconds: 0,
+    };
+    expect(timeFrom(duration)).toBe(0);
+  });
+});
+
+describe('timeParse', () => {
+  it('应正确解析完整时间字符串', () => {
+    expect(timeParse('1y2M3d4h5m6s')).toEqual({
+      years: 1,
+      months: 2,
+      days: 3,
+      hours: 4,
+      minutes: 5,
+      seconds: 6,
+    });
+  });
+
+  it('应处理部分时间单位', () => {
+    expect(timeParse('2d3h')).toEqual({
+      years: 0,
+      months: 0,
+      days: 2,
+      hours: 3,
+      minutes: 0,
+      seconds: 0,
+    });
+  });
+
+  it('应处理空字符串', () => {
+    expect(timeParse('')).toEqual({
+      years: 0,
+      months: 0,
+      days: 0,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+    });
+  });
+
+  it('应忽略无效格式', () => {
+    expect(timeParse('invalid')).toEqual({
+      years: 0,
+      months: 0,
+      days: 0,
+      hours: 0,
+      minutes: 0,
+      seconds: 0,
+    });
+  });
+});

package/test/timer.test.ts

@@ -0,0 +1,114 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { timeInterval } from '../src/timer';
+
+describe('timeInterval 定时器', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('应该按照指定间隔时间执行回调', async () => {
+    vi.useFakeTimers();
+    const mockFn = vi.fn();
+    const timer = timeInterval(mockFn, 1000);
+
+    // 立即执行
+    timer.start();
+    expect(mockFn).not.toHaveBeenCalled();
+
+    // 第一次执行
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // 第二次执行
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    timer.stop();
+    expect(mockFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('immediate=true 时应立即执行回调', async () => {
+    vi.useFakeTimers();
+    const mockFn = vi.fn();
+    const timer = timeInterval(mockFn, 1000, { leading: true, trailing: true });
+
+    // 立即执行
+    timer.start();
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    // 第一次间隔执行
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    // 停止执行
+    timer.stop();
+    expect(mockFn).toHaveBeenCalledTimes(3);
+  });
+
+  it('调用 stop 后应停止定时器', async () => {
+    vi.useFakeTimers();
+    const mockFn = vi.fn();
+    const timer = timeInterval(mockFn, 1000);
+
+    timer.start();
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    timer.stop();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('可以暂停和恢复定时器', async () => {
+    vi.useFakeTimers();
+    const mockFn = vi.fn();
+    const timer = timeInterval(mockFn, 1000);
+
+    timer.start();
+    expect(mockFn).toHaveBeenCalledTimes(0);
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    timer.pause();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(1);
+
+    timer.resume();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(mockFn).toHaveBeenCalledTimes(2);
+
+    timer.stop();
+  });
+
+  it('回调函数应接收正确的参数', async () => {
+    vi.useFakeTimers();
+    const mockFn = vi.fn();
+    const timer = timeInterval(mockFn, 1000);
+
+    timer.start();
+
+    await vi.advanceTimersByTimeAsync(1000);
+    const arg = mockFn.mock.calls[0][0];
+    expect(Object.keys(arg)).toEqual(
+      expect.arrayContaining([
+        'times',
+        'startAt',
+        'stopAt',
+        'pauseAt',
+        'resumeAt',
+        'currentAt',
+        'elapsedTime',
+        'runningTime',
+        'intervalTime',
+      ]),
+    );
+
+    timer.stop();
+  });
+});

package/test/tree.test.ts

@@ -0,0 +1,348 @@
+import { type TTreeItem, deepFlat, treeEach, treeFind, treeFrom } from '@/tree';
+import { describe, expect, it } from 'vitest';
+
+type TestTreeItem = TTreeItem & {
+  id: string;
+};
+
+const treeList: TestTreeItem[] = [
+  {
+    id: '1',
+    children: [
+      {
+        id: '1-1',
+        children: [
+          {
+            id: '1-1-1',
+          },
+        ],
+      },
+      {
+        id: '1-2',
+        children: [
+          {
+            id: '1-2-1',
+          },
+        ],
+      },
+    ],
+  },
+];
+
+describe('treeEach', () => {
+  it('应正确执行深度优先遍历', () => {
+    const results: string[] = [];
+
+    treeEach(treeList, (info) => {
+      results.push(info.item.id);
+    });
+
+    expect(results).toEqual(['1', '1-1', '1-1-1', '1-2', '1-2-1']);
+  });
+
+  it('应正确执行广度优先遍历', () => {
+    const results: string[] = [];
+
+    treeEach(
+      treeList,
+      (info) => {
+        results.push(info.item.id);
+      },
+      true,
+    );
+
+    expect(results).toEqual(['1', '1-1', '1-2', '1-1-1', '1-2-1']);
+  });
+
+  it('应支持提前终止深度遍历', () => {
+    const results: string[] = [];
+
+    treeEach(treeList, (info) => {
+      results.push(info.item.id);
+      if (info.item.id === '1-1-1') return false;
+    });
+
+    expect(results).toEqual(['1', '1-1', '1-1-1']);
+  });
+
+  it('应支持提前终止深度遍历', () => {
+    const results: string[] = [];
+
+    treeEach(
+      treeList,
+      (info) => {
+        results.push(info.item.id);
+        if (info.item.id === '1-2') return false;
+      },
+      true,
+    );
+
+    expect(results).toEqual(['1', '1-1', '1-2']);
+  });
+
+  it('深度优先信息', () => {
+    const idList: string[] = [];
+    const parentList: (TestTreeItem | null)[] = [];
+    const levelList: number[] = [];
+    const pathList: string[][] = [];
+
+    treeEach(treeList, ({ item, index, list, parent, level, path }) => {
+      idList.push(item.id);
+      parentList.push(parent);
+      levelList.push(level);
+      pathList.push(path.map((item) => item.id));
+    });
+
+    let i = 0;
+    // console.log(idList);
+    expect(idList[i++]).toEqual('1');
+    expect(idList[i++]).toEqual('1-1');
+    expect(idList[i++]).toEqual('1-1-1');
+    expect(idList[i++]).toEqual('1-2');
+    expect(idList[i++]).toEqual('1-2-1');
+    expect(idList[i++]).toEqual(undefined);
+    let j = 0;
+    // console.log(parentList);
+    expect(parentList[j++]).toEqual(null);
+    expect(parentList[j++]?.id).toEqual('1');
+    expect(parentList[j++]?.id).toEqual('1-1');
+    expect(parentList[j++]?.id).toEqual('1');
+    expect(parentList[j++]?.id).toEqual('1-2');
+    expect(parentList[j++]).toEqual(undefined);
+    let k = 0;
+    // console.log(levelList);
+    expect(levelList[k++]).toEqual(1);
+    expect(levelList[k++]).toEqual(2);
+    expect(levelList[k++]).toEqual(3);
+    expect(levelList[k++]).toEqual(2);
+    expect(levelList[k++]).toEqual(3);
+    expect(levelList[k++]).toEqual(undefined);
+
+    expect(pathList).toEqual([
+      //
+      ['1'],
+      ['1', '1-1'],
+      ['1', '1-1', '1-1-1'],
+      ['1', '1-2'],
+      ['1', '1-2', '1-2-1'],
+    ]);
+  });
+
+  it('广度优先信息', () => {
+    const idList: string[] = [];
+    const parentList: (TestTreeItem | null)[] = [];
+    const levelList: number[] = [];
+    const pathList: string[][] = [];
+
+    treeEach(
+      treeList,
+      ({ item, index, list, parent, level, path }) => {
+        idList.push(item.id);
+        parentList.push(parent);
+        levelList.push(level);
+        pathList.push(path.map((item) => item.id));
+      },
+      true,
+    );
+
+    let i = 0;
+    // console.log(idList);
+    expect(idList[i++]).toEqual('1');
+    expect(idList[i++]).toEqual('1-1');
+    expect(idList[i++]).toEqual('1-2');
+    expect(idList[i++]).toEqual('1-1-1');
+    expect(idList[i++]).toEqual('1-2-1');
+    expect(idList[i++]).toEqual(undefined);
+    let j = 0;
+    // console.log(parentList);
+    expect(parentList[j++]).toEqual(null);
+    expect(parentList[j++]?.id).toEqual('1');
+    expect(parentList[j++]?.id).toEqual('1');
+    expect(parentList[j++]?.id).toEqual('1-1');
+    expect(parentList[j++]?.id).toEqual('1-2');
+    expect(parentList[j++]).toEqual(undefined);
+    let k = 0;
+    // console.log(levelList);
+    expect(levelList[k++]).toEqual(1);
+    expect(levelList[k++]).toEqual(2);
+    expect(levelList[k++]).toEqual(2);
+    expect(levelList[k++]).toEqual(3);
+    expect(levelList[k++]).toEqual(3);
+    expect(levelList[k++]).toEqual(undefined);
+
+    expect(pathList).toEqual([
+      //
+      ['1'],
+      ['1', '1-1'],
+      ['1', '1-2'],
+      ['1', '1-1', '1-1-1'],
+      ['1', '1-2', '1-2-1'],
+    ]);
+  });
+});
+
+describe('treeFind', () => {
+  it('深度优先', () => {
+    const expected = treeList[0].children?.[1].children?.[0];
+    const found2 = treeFind(treeList, (info) => info.item.id === '1-2-1');
+
+    expect(found2?.item).toBe(expected);
+    expect(found2?.item.id).toEqual('1-2-1');
+    expect(found2?.index).toEqual(0);
+    expect(found2?.list).toBe(treeList[0].children?.[1].children);
+    expect(found2?.parent).not.toBe(null);
+    expect(found2?.parent?.id).toEqual('1-2');
+    expect(found2?.level).toEqual(3);
+    expect(found2?.path.map((el) => el.id)).toEqual(['1', '1-2', '1-2-1']);
+  });
+
+  it('广度优先', () => {
+    const expected = treeList[0].children?.[1].children?.[0];
+    const found2 = treeFind(treeList, (info) => info.item.id === '1-2-1', true);
+
+    expect(found2?.item).toBe(expected);
+    expect(found2?.item.id).toEqual('1-2-1');
+    expect(found2?.index).toEqual(0);
+    expect(found2?.list).toBe(treeList[0].children?.[1].children);
+    expect(found2?.parent).not.toBe(null);
+    expect(found2?.parent?.id).toEqual('1-2');
+    expect(found2?.level).toEqual(3);
+    expect(found2?.path.map((el) => el.id)).toEqual(['1', '1-2', '1-2-1']);
+  });
+
+  it('应返回 undefined 如果没有找到满足条件的节点', () => {
+    const found = treeFind(treeList, (info) => info.item.id === 'nonexistent');
+    expect(found).toBeUndefined();
+  });
+});
+
+describe('treeFlat', () => {
+  it('深度优先', () => {
+    const shallowList = deepFlat(treeList, ({ item }) => item.id);
+    expect(shallowList).toEqual(['1', '1-1', '1-1-1', '1-2', '1-2-1']);
+  });
+
+  it('广度优先', () => {
+    const shallowList = deepFlat(treeList, ({ item }) => item.id, true);
+    expect(shallowList).toEqual(['1', '1-1', '1-2', '1-1-1', '1-2-1']);
+  });
+});
+
+describe('treeFrom', () => {
+  it('应从扁平列表构建树形结构', () => {
+    const list = [
+      { id: 1, parentId: 0, name: 'Root' },
+      { id: 2, parentId: 1, name: 'Child 1' },
+      { id: 3, parentId: 1, name: 'Child 2' },
+      { id: 4, parentId: 2, name: 'Grandchild 1' },
+    ];
+
+    const tree = treeFrom(list, {
+      getSelfKey: (item) => item.id,
+      getParentKey: (item) => (item.parentId === 0 ? null : item.parentId),
+      appendChild: (parent, info) => {
+        const parentItem = parent.item as typeof parent.item & { children: (typeof parent.item)[] };
+        if (!parentItem.children) parentItem.children = [];
+        parentItem.children.push(info.item);
+      },
+    });
+
+    expect(tree).toEqual([
+      {
+        id: 1,
+        parentId: 0,
+        name: 'Root',
+        children: [
+          {
+            id: 2,
+            parentId: 1,
+            name: 'Child 1',
+            children: [{ id: 4, parentId: 2, name: 'Grandchild 1' }],
+          },
+          { id: 3, parentId: 1, name: 'Child 2' },
+        ],
+      },
+    ]);
+  });
+
+  it('应处理游离节点', () => {
+    const list = [
+      { id: 2, parentId: 3, name: 'Child 1' },
+      { id: 1, parentId: 0, name: 'Root' },
+      { id: 3, parentId: 1, name: 'Child 2' },
+    ];
+
+    const tree = treeFrom(list, {
+      getSelfKey: (item) => item.id,
+      getParentKey: (item) => (item.parentId === 0 ? null : item.parentId),
+      appendChild: (parent, info) => {
+        const parentItem = parent.item as typeof parent.item & { children: (typeof parent.item)[] };
+        if (!parentItem.children) parentItem.children = [];
+        parentItem.children.push(info.item);
+      },
+    });
+
+    expect(tree).toEqual([
+      {
+        id: 1,
+        parentId: 0,
+        name: 'Root',
+        children: [
+          {
+            id: 3,
+            parentId: 1,
+            name: 'Child 2',
+            children: [{ id: 2, parentId: 3, name: 'Child 1' }],
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('应返回 undefined 如果未找到根节点', () => {
+    const list = [
+      { id: 11, parentId: 2, name: 'Child 1' },
+      { id: 12, parentId: 1, name: 'Child 2' },
+      { id: 13, parentId: 3, name: 'Child 3' },
+      { id: 1, parentId: 0, name: 'Root' },
+      { id: 2, parentId: 0, name: 'Root' },
+    ];
+
+    const tree = treeFrom(list, {
+      getSelfKey: (item) => item.id,
+      getParentKey: (item) => (item.parentId === 0 ? null : item.parentId),
+      appendChild: (parent, info) => {
+        const parentItem = parent.item as typeof parent.item & { children: (typeof parent.item)[] };
+        if (!parentItem.children) parentItem.children = [];
+        parentItem.children.push(info.item);
+      },
+    });
+
+    expect(tree).toEqual([
+      {
+        id: 1,
+        parentId: 0,
+        name: 'Root',
+        children: [
+          {
+            id: 12,
+            parentId: 1,
+            name: 'Child 2',
+          },
+        ],
+      },
+      {
+        id: 2,
+        parentId: 0,
+        name: 'Root',
+        children: [
+          {
+            id: 11,
+            parentId: 2,
+            name: 'Child 1',
+          },
+        ],
+      },
+    ]);
+  });
+});