@zk-tech/bedrock 0.0.1

package/src/async/queue/queue.test.ts

@@ -0,0 +1,70 @@
+import { type Mock } from 'vitest';
+import { defer, type Deferred } from '@/promise';
+import { AsyncQueue } from './queue';
+
+const nextTick = () => {
+  return new Promise<void>((res) => {
+    setTimeout(() => {
+      res();
+    }, 0);
+  });
+};
+
+const getTask = (): [() => Promise<void>, Deferred<void>, () => Mock<any, any>] => {
+  const defer1 = defer();
+  const mockFn1 = vi.fn();
+
+  return [
+    async () => {
+      mockFn1();
+      await defer1.promise;
+    },
+    defer1,
+    mockFn1,
+  ];
+};
+
+describe('AsyncQueue', () => {
+  test('base', async () => {
+    const queue = new AsyncQueue({
+      concurrent: 1,
+    });
+
+    const [fn1, defer1, mockFn1] = getTask();
+    queue.addTask(fn1);
+
+    const [fn2, defer2, mockFn2] = getTask();
+    queue.addTask(fn2);
+
+    expect(mockFn1).toBeCalled();
+    expect(mockFn2).not.toBeCalled();
+
+    defer1.resolve();
+    await nextTick();
+
+    expect(mockFn2).toBeCalled();
+  });
+
+  test('base 2', async () => {
+    const queue = new AsyncQueue({
+      concurrent: 2,
+    });
+
+    const [fn1, defer1, mockFn1] = getTask();
+    queue.addTask(fn1);
+
+    const [fn2, defer2, mockFn2] = getTask();
+    queue.addTask(fn2);
+
+    const [fn3, defer3, mockFn3] = getTask();
+    queue.addTask(fn3);
+
+    expect(mockFn1).toBeCalled();
+    expect(mockFn2).toBeCalled();
+    expect(mockFn3).not.toBeCalled();
+
+    defer1.resolve();
+    await nextTick();
+    expect(mockFn3).toBeCalled();
+  });
+});

package/src/async/queue/queue.ts

@@ -0,0 +1,56 @@
+/**
+ * 异步任务队列
+ */
+import { Disposable } from '@/dispose';
+import { AsyncTask, type IAsyncTask } from './task';
+import type { ICancellationToken } from '../cancellation';
+
+type IAsyncQueue = {
+  /** 队列的任务并发数 */
+  concurrent: number;
+};
+
+export class AsyncQueue extends Disposable {
+  private readonly _queue: AsyncTask[] = [];
+  private readonly _maxConcurrent: number = 1;
+  private _execCounter: number = 0;
+
+  constructor(options: IAsyncQueue) {
+    super();
+    // 初始化最大并发数
+    this._maxConcurrent = options.concurrent;
+  }
+
+  /** 添加一个异步任务到队列 */
+  addTask(
+    callback: (cancellation: ICancellationToken) => Promise<void>,
+    cancellationToken?: ICancellationToken,
+  ): IAsyncTask {
+    if (cancellationToken?.isCancellationRequested) {
+      return new AsyncTask(null);
+    }
+    const task = new AsyncTask(callback);
+    // 将任务函数加入队列
+    this._queue.push(this._store.add(task));
+    // 尝试执行下一个任务
+    this._next();
+
+    return task;
+  }
+
+  // 执行下一个任务，如果当前并发数小于最大并发数，并且队列不为空，则从队列中取出一个任务并执行，否则什么都不做
+  private _next() {
+    if (this._queue.length && this._execCounter < this._maxConcurrent && this._queue.length > 0) {
+      // 取出队列中的第一个任务函数，并从队列中移除它
+      const task = this._queue.shift()!;
+      // 增加当前并发数
+      this._execCounter++;
+      // 执行任务函数，并处理其返回的promise对象
+      task.safeExec().finally(() => {
+        // 不管成功还是失败，都要减少当前并发数，并执行下一个任务（递归调用）
+        this._execCounter--;
+        this._next();
+      });
+    }
+  }
+}

package/src/async/queue/task.test.ts

@@ -0,0 +1,155 @@
+/* eslint-disable prefer-promise-reject-errors */
+/* eslint-disable max-lines-per-function */
+import { CancellationTokenSource } from '../cancellation';
+import { AsyncTask } from './task';
+
+describe('AsyncTask', () => {
+  test('resolve', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+    const task1 = new AsyncTask(() => {
+      callback();
+      return Promise.resolve();
+    });
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    const result1 = await task1.safeExec();
+    expect(callback).toHaveBeenCalled();
+    expect(successCb).toHaveBeenCalled();
+    expect(failureCb).not.toHaveBeenCalled();
+    expect(cancelCb).not.toHaveBeenCalled();
+    expect(result1).toBe(undefined);
+  });
+
+  test('reject', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+    const error = new Error('error');
+    const rej = Promise.reject(error);
+    const task1 = new AsyncTask(() => {
+      callback();
+      return rej;
+    });
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    const result1 = await task1.safeExec();
+    expect(callback).toHaveBeenCalled();
+    expect(successCb).not.toHaveBeenCalled();
+    expect(failureCb).toHaveBeenCalled();
+    expect(cancelCb).not.toHaveBeenCalled();
+    expect(result1).toBe(undefined);
+  });
+
+  test('cancel', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+
+    const task1 = new AsyncTask(() => {
+      callback();
+      return Promise.reject();
+    });
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    task1.cancel();
+    await task1.safeExec();
+    expect(callback).not.toHaveBeenCalled();
+    expect(successCb).not.toHaveBeenCalled();
+    expect(failureCb).not.toHaveBeenCalled();
+    expect(cancelCb).toHaveBeenCalled();
+  });
+
+  test('cancel 2', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+
+    const task1 = new AsyncTask(() => {
+      callback();
+      return Promise.reject();
+    });
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    await task1.safeExec();
+    task1.cancel();
+    expect(callback).toHaveBeenCalled();
+    expect(successCb).not.toHaveBeenCalled();
+    expect(failureCb).toHaveBeenCalled();
+    expect(cancelCb).not.toHaveBeenCalled();
+  });
+
+  /**
+   * Testing the behaviors of aborting with abort signal
+   * */
+  test('aborts a task before it is exected should prevent task from being executed', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+
+    const cancellationSource = new CancellationTokenSource();
+
+    const task1 = new AsyncTask(() => {
+      callback();
+      return Promise.reject();
+    }, cancellationSource.token);
+
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    // aborts the task before it is executed
+    cancellationSource.cancel();
+    // The abort event of abort controller will be dispatched synchronously
+
+    await task1.safeExec();
+
+    expect(callback).not.toHaveBeenCalled();
+    expect(successCb).not.toHaveBeenCalled();
+    expect(failureCb).not.toHaveBeenCalled();
+
+    expect(cancelCb).toHaveBeenCalled();
+  });
+
+  test('aborts a task after it has been executed should not cause the task to enter the cancelled stage', async () => {
+    const callback = vi.fn();
+    const successCb = vi.fn();
+    const failureCb = vi.fn();
+    const cancelCb = vi.fn();
+
+    const cancellationSource = new CancellationTokenSource();
+
+    const task1 = new AsyncTask(() => {
+      callback();
+      return Promise.reject();
+    }, cancellationSource.token);
+    task1.onSuccess(successCb);
+    task1.onFailure(failureCb);
+    task1.onCancel(cancelCb);
+
+    await task1.safeExec();
+
+    // aborts the task after it has been executed
+    cancellationSource.cancel();
+
+    expect(callback).toHaveBeenCalled();
+    expect(successCb).not.toHaveBeenCalled();
+    expect(failureCb).toHaveBeenCalled();
+
+    expect(cancelCb).not.toHaveBeenCalled();
+  });
+});

package/src/async/queue/task.ts

@@ -0,0 +1,67 @@
+import { Disposable, type IDisposable } from '@/dispose';
+import { type Event, Emitter } from '@/event';
+import { makeErrorBy, type ILvErrorRef } from '@/error';
+import { CancellationToken, type ICancellationToken } from '../cancellation';
+
+export interface IAsyncTask extends IDisposable {
+  onSuccess: Event<[]>;
+  onFailure: Event<[ILvErrorRef]>;
+  onCancel: Event<[]>;
+
+  /** 取消当前任务 */
+  cancel: () => void;
+}
+
+export class AsyncTask extends Disposable implements IAsyncTask {
+  private readonly _onSuccess = this._store.add(new Emitter<[]>());
+  public readonly onSuccess = this._onSuccess.event;
+
+  private readonly _onFailure = this._store.add(new Emitter<[ILvErrorRef]>());
+  public readonly onFailure = this._onFailure.event;
+
+  private readonly _onCancel = this._store.add(new Emitter<[]>());
+  public readonly onCancel = this._onCancel.event;
+
+  private _isExec: boolean = false;
+  private _isCancel: boolean = false;
+
+  constructor(
+    private _callback: ((cancellation: ICancellationToken) => Promise<void>) | null,
+    private readonly _cancellationToken?: ICancellationToken,
+  ) {
+    super();
+
+    this._cancellationToken?.onCancellationRequested(() => {
+      this.cancel();
+    });
+  }
+
+  /** 这个方法不对外暴露，只提供给 queue 使用. */
+  async safeExec(): Promise<void> {
+    if (this._isCancel || this._isExec) {
+      return;
+    }
+
+    try {
+      this._isExec = true;
+      await this._callback!(this._cancellationToken ?? CancellationToken.None);
+      this._onSuccess.fire();
+    } catch (err) {
+      /** handler error */
+      this._onFailure.fire(makeErrorBy(-1, 'exec error', err as Error));
+    }
+  }
+
+  cancel(): void {
+    if (this._isCancel) {
+      return;
+    }
+    if (this._isExec) {
+      return;
+    }
+
+    this._isCancel = true;
+    this._callback = null;
+    this._onCancel.fire();
+  }
+}

package/src/async/utils.test.ts

@@ -0,0 +1,28 @@
+import { invokeNextLoop } from './utils';
+
+describe('invokeNextLoop', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  it('invoke', () => {
+    let a = 0;
+    invokeNextLoop(() => {
+      a++;
+    });
+    expect(a).toBe(0);
+    vi.advanceTimersByTime(1);
+    expect(a).toBe(1);
+  });
+
+  it('dispose', () => {
+    let a = 0;
+    const disposable = invokeNextLoop(() => {
+      a++;
+    });
+    expect(a).toBe(0);
+    disposable.dispose();
+    vi.advanceTimersByTime(1);
+    expect(a).toBe(0);
+  });
+});

package/src/async/utils.ts

@@ -0,0 +1,8 @@
+import { makeSafeDisposable } from '@/dispose';
+
+export function invokeNextLoop(fn: (...args: any[]) => void) {
+  const handle = setTimeout(() => {
+    fn();
+  }, 0);
+  return makeSafeDisposable(() => clearTimeout(handle));
+}

package/src/async/wait.ts

@@ -0,0 +1,9 @@
+/**
+ * 等待一段时间
+ * @param ms 单位毫秒
+ */
+export function wait(ms: number): Promise<undefined> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export const sleep: (ms: number) => Promise<undefined> = wait;

package/src/byte/format.test.ts

@@ -0,0 +1,64 @@
+import { getDefaultFormat, byteSizeFormat } from './format';
+
+describe('getDefaultFormat', () => {
+  it('should return b for values less than 0.1KB', () => {
+    expect(getDefaultFormat(100)).toBe('b');
+  });
+
+  it('should return kb for values between 0.1KB and 0.1MB', () => {
+    expect(getDefaultFormat(1024)).toBe('kb');
+    expect(getDefaultFormat(10 * 1024)).toBe('kb');
+  });
+
+  it('should return mb for values between 0.1MB and 1GB', () => {
+    expect(getDefaultFormat(1024 * 1024)).toBe('mb');
+    expect(getDefaultFormat(100 * 1024 * 1024)).toBe('mb');
+  });
+
+  it('should return gb for values between 1GB and 1TB', () => {
+    expect(getDefaultFormat(2 * 1024 * 1024 * 1024)).toBe('gb');
+  });
+
+  it('should return tb for values greater than 1TB', () => {
+    expect(getDefaultFormat(2 * 1024 * 1024 * 1024 * 1024)).toBe('tb');
+  });
+});
+
+describe('byteSizeFormat', () => {
+  it('should format bytes correctly', () => {
+    expect(byteSizeFormat(100, 'b')).toBe('100B');
+    expect(byteSizeFormat(100.123, 'b')).toBe('100.12B');
+  });
+
+  it('should format kilobytes correctly', () => {
+    expect(byteSizeFormat(1024, 'kb')).toBe('1KB');
+    expect(byteSizeFormat(1536, 'kb')).toBe('1.50KB');
+  });
+
+  it('should format megabytes correctly', () => {
+    expect(byteSizeFormat(1024 * 1024, 'mb')).toBe('1MB');
+    expect(byteSizeFormat(1.5 * 1024 * 1024, 'mb')).toBe('1.50MB');
+  });
+
+  it('should format gigabytes correctly', () => {
+    expect(byteSizeFormat(1024 * 1024 * 1024, 'gb')).toBe('1GB');
+    expect(byteSizeFormat(2.5 * 1024 * 1024 * 1024, 'gb')).toBe('2.50GB');
+  });
+
+  it('should format terabytes correctly', () => {
+    expect(byteSizeFormat(1024 * 1024 * 1024 * 1024, 'tb')).toBe('1TB');
+    expect(byteSizeFormat(1.5 * 1024 * 1024 * 1024 * 1024, 'tb')).toBe('1.50TB');
+  });
+
+  it('should use default format when no format is specified', () => {
+    expect(byteSizeFormat(100)).toBe('100B');
+    expect(byteSizeFormat(1024 * 100)).toBe('100KB');
+    expect(byteSizeFormat(1024 * 1024 * 100)).toBe('100MB');
+    expect(byteSizeFormat(1024 * 1024 * 1024 * 2)).toBe('2GB');
+  });
+
+  it('should remove .00 from formatted values', () => {
+    expect(byteSizeFormat(1024 * 1024, 'mb')).toBe('1MB');
+    expect(byteSizeFormat(2000, 'b')).toBe('2000B');
+  });
+}); 

package/src/byte/format.ts

@@ -0,0 +1,44 @@
+export function getDefaultFormat(value: number) {
+  if (value < 0.1 * 1024) {
+    // 小于0.1KB，则转化成B
+    return 'b';
+  }
+  if (value < 0.1 * 1024 * 1024) {
+    // 小于0.1MB，则转化成KB
+    return 'kb';
+  }
+  if (value < 1 * 1024 * 1024 * 1024) {
+    // 小于0.1GB，则转化成MB
+    return 'mb';
+  }
+  if (value < 1 * 1024 * 1024 * 1024 * 1024) {
+    // 其他转化成GB
+    return 'gb';
+  }
+  return 'tb';
+}
+
+const formatMap = {
+  b: (value: number) => `${value.toFixed(2)}B`,
+  kb: (value: number) => `${(value / 1024).toFixed(2)}KB`,
+  mb: (value: number) => `${(value / (1024 * 1024)).toFixed(2)}MB`,
+  gb: (value: number) => `${(value / (1024 * 1024 * 1024)).toFixed(2)}GB`,
+  tb: (value: number) => `${(value / (1024 * 1024 * 1024 * 1024)).toFixed(2)}TB`,
+};
+
+export function byteSizeFormat(limit: number, format?: 'b' | 'kb' | 'mb' | 'gb' | 'tb'): string {
+  let size = '';
+
+  const resetFormat = format || getDefaultFormat(limit);
+
+  size = formatMap[resetFormat](limit);
+
+  const sizeStr = `${size}`; // 转成字符串
+  const index = sizeStr.indexOf('.'); // 获取小数点处的索引
+  const dou = sizeStr.substr(index + 1, 2); // 获取小数点后两位的值
+  if (dou === '00') {
+    // 判断后两位是否为00，如果是则删除00
+    return sizeStr.substring(0, index) + sizeStr.substr(index + 3, 2);
+  }
+  return size;
+}

package/src/byte/index.ts

@@ -0,0 +1,2 @@
+export * from './var';
+export { byteSizeFormat } from './format';

package/src/byte/node_modules/.vitest/results.json

@@ -0,0 +1 @@
+{"version":"1.0.1","results":[[":format.test.ts",{"duration":2,"failed":false}]]}

package/src/byte/var.ts

@@ -0,0 +1,11 @@
+// 常用常量
+export const kb = 1024;
+export const mb = kb * 1024;
+export const gb = mb * 1024;
+export const tb = gb * 1024;
+
+// 常用常量支持大写
+export const KB = kb;
+export const MB = mb;
+export const GB = gb;
+export const TB = tb;

package/src/cache/index.ts

@@ -0,0 +1,2 @@
+export { LRUCache } from './lru';
+export { LRUCacheWithTimeout } from './lru-with-timeout';

package/src/cache/lru-with-timeout.test.ts

@@ -0,0 +1,88 @@
+import { LRUCacheWithTimeout } from './lru-with-timeout';
+
+class Foo {
+  constructor(public readonly value: string) {}
+}
+
+// LRU基本能力依然保留
+describe('LRU Base', () => {
+  let cache: LRUCacheWithTimeout<Foo>;
+
+  beforeEach(() => {
+    // 创建一个容量为5的缓存实例
+    cache = new LRUCacheWithTimeout<Foo>(5, 100);
+
+    // 向缓存中添加一些初始数据供测试使用
+    cache.put('1', new Foo('apple'));
+    cache.put('2', new Foo('banana'));
+    cache.put('3', new Foo('orange'));
+  });
+
+  it('should return the value when getting an existing key', () => {
+    const result = cache.get('2');
+    expect(result).not.toBeUndefined();
+    expect(result!.value).toBe('banana');
+  });
+
+  it('should return undefined when getting a non-existing key', () => {
+    const result = cache.get('4');
+    expect(result).toBeUndefined();
+  });
+
+  it('should update the value when putting an existing key', () => {
+    cache.put('2', new Foo('grapefruit'));
+    const result = cache.get('2');
+    expect(result).not.toBeUndefined();
+    expect(result!.value).toBe('grapefruit');
+  });
+
+  it('should add the key-value pair to the cache when putting a new key', () => {
+    cache.put('4', new Foo('kiwi'));
+    const result = cache.get('4');
+    expect(result).not.toBeUndefined();
+    expect(result!.value).toBe('kiwi');
+  });
+
+  it('should remove the least recently used item when the cache is full and a new item is added', () => {
+    cache.put('4', new Foo('kiwi'));
+    cache.put('5', new Foo('pear'));
+    cache.put('6', new Foo('mango'));
+    // 检查最早添加的项是否被移除
+    const result1 = cache.get('1');
+    const result2 = cache.get('2');
+    expect(result1).toBeUndefined();
+    expect(result2).not.toBeUndefined();
+    expect(result2!.value).toBe('banana');
+  });
+});
+
+// 判断超时逻辑
+describe('Timeout', () => {
+  beforeAll(() => {
+    vi.useFakeTimers();
+  });
+
+  it('timeout', () => {
+    const now = Date.now();
+    const cache = new LRUCacheWithTimeout<Foo>(5, 200);
+    cache.put('1', new Foo('capcut'));
+    const result1 = cache.get('1');
+    expect(result1).not.toBeUndefined();
+
+    vi.spyOn(Date, 'now').mockImplementationOnce(() => {
+      return now + 100;
+    });
+    vi.advanceTimersByTime(100);
+
+    const result2 = cache.get('1');
+    expect(result2).not.toBeUndefined();
+
+    vi.spyOn(Date, 'now').mockImplementationOnce(() => {
+      return now + 300;
+    });
+    vi.advanceTimersByTime(300);
+
+    const result3 = cache.get('1');
+    expect(result3).toBeUndefined();
+  });
+});