@zk-tech/bedrock 0.0.1 → 0.1.0

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

@@ -1,155 +0,0 @@
-/* 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

@@ -1,67 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/**
- * 等待一段时间
- * @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

@@ -1,64 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

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

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

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

package/src/byte/var.ts

@@ -1,11 +0,0 @@
-// 常用常量
-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

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

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

@@ -1,88 +0,0 @@
-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();
-  });
-});

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

@@ -1,85 +0,0 @@
-import { ignoreDispose } from '@/dispose';
-import { LRUCache } from './lru';
-
-export class LRUCacheWithTimeout<T, K = string> {
-  private readonly _updateTime: Map<K, number> = new Map();
-  private _timer?: NodeJS.Timeout;
-  private readonly _lru: LRUCache<T, K>;
-
-  constructor(
-    capacity: number,
-    private readonly _timeout: number,
-  ) {
-    this._lru = new LRUCache(capacity);
-
-    ignoreDispose(
-      this._lru.onEvicted((key: K) => {
-        this._updateTime.delete(key);
-      }),
-    );
-  }
-
-  get(key: K): T | undefined {
-    const result = this._lru.get(key);
-    if (result) {
-      this._updateTime.set(key, Date.now() + this._timeout);
-    }
-    return result;
-  }
-
-  put(key: K, value: T): void {
-    this._startTimer();
-    this._updateTime.set(key, Date.now() + this._timeout);
-    return this._lru.put(key, value);
-  }
-
-  remove(key: K): void {
-    this._updateTime.delete(key);
-    return this._lru.remove(key);
-  }
-
-  size(): number {
-    return this._lru.size();
-  }
-
-  clear(): void {
-    this._updateTime.clear();
-    return this._lru.clear();
-  }
-
-  dispose(): void {
-    this.clear();
-    clearTimeout(this._timer);
-  }
-
-  private _startTimer() {
-    if (this._timer) {
-      return;
-    }
-    this._timer = setTimeout(this._tick, this._timeout);
-  }
-
-  private _check() {
-    const now = Date.now();
-    const shouldRemove: K[] = [];
-    for (const [key, time] of this._updateTime) {
-      if (time <= now) {
-        shouldRemove.push(key);
-      }
-    }
-    for (const key of shouldRemove) {
-      this._updateTime.delete(key);
-      this._lru.remove(key);
-    }
-  }
-
-  private readonly _tick = () => {
-    this._check();
-    if (this._lru.size() === 0) {
-      // 不再轮询
-      this._timer = undefined;
-      return;
-    }
-    this._timer = setTimeout(this._tick, this._timeout);
-  };
-}

package/src/cache/lru.test.ts

@@ -1,56 +0,0 @@
-import { LRUCache } from './lru';
-
-class Foo {
-  constructor(public readonly value: string) {}
-}
-
-describe('LRUCache', () => {
-  let cache: LRUCache<Foo>;
-
-  beforeEach(() => {
-    // 创建一个容量为5的缓存实例
-    cache = new LRUCache<Foo>(5);
-
-    // 向缓存中添加一些初始数据供测试使用
-    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');
-  });
-});

package/src/cache/lru.ts

@@ -1,59 +0,0 @@
-import { Emitter, type Event } from '@/event';
-
-/**
- * LRUCache
- * T 是值类型
- * K 是索引类型，默认string
- */
-export class LRUCache<T, K = string> {
-  protected readonly _cache: Map<K, T> = new Map();
-  private _onEvicted?: Emitter<[K, T]>;
-
-  constructor(private readonly _capacity: number) {}
-
-  get onEvicted(): Event<[K, T]> {
-    if (!this._onEvicted) {
-      this._onEvicted = new Emitter();
-    }
-    return this._onEvicted.event;
-  }
-
-  get(key: K): T | undefined {
-    const value = this._cache.get(key);
-    if (value) {
-      // 将访问过的 key 移到最近使用的位置
-      this._cache.delete(key);
-      this._cache.set(key, value);
-    }
-    return value;
-  }
-
-  put(key: K, value: T): void {
-    if (this._cache.has(key)) {
-      // 如果已存在该 key，则将其移动到最近使用的位置
-      this._cache.delete(key);
-    } else if (this._cache.size >= this._capacity) {
-      // 如果已达到容量上限，则删除最久未使用的键值对
-      const oldestKey = this._cache.keys().next().value as K;
-      const oldestVal = this._onEvicted ? this._cache.get(oldestKey)! : null;
-      this._cache.delete(oldestKey);
-      this._onEvicted?.fire(oldestKey, oldestVal!);
-    }
-    this._cache.set(key, value);
-  }
-
-  remove(key: K): void {
-    const obj = this._cache.get(key);
-    if (obj) {
-      this._cache.delete(key);
-    }
-  }
-
-  size(): number {
-    return this._cache.size;
-  }
-
-  clear(): void {
-    this._cache.clear();
-  }
-}