@taicode/common-base 1.0.2 → 1.1.0

package/source/utils/poller/index.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, MockedFunction } from 'vitest'
-import { Poller } from './'
-
-describe('Poller', () => {
-  let poller: Poller
-  let task: MockedFunction<() => Promise<void> | void>
-  const interval = 100 // 100ms 的间隔
-
-  beforeEach(() => {
-    task = vi.fn()
-    poller = new Poller(task, interval)
-  })
-
-  afterEach(() => {
-    poller.stop() // 确保每次测试后停止轮询
-  })
-
-  it('should start and stop the poller', async () => {
-    poller.start()
-    expect(poller['isRunning']).toBe(true)
-
-    poller.stop()
-    expect(poller['isRunning']).toBe(false)
-  })
-
-  it('should execute the task at the specified interval', async () => {
-    poller.start()
-    await new Promise((resolve) => setTimeout(resolve, interval * 2)) // 等待两个间隔
-
-    expect(task).toHaveBeenCalledTimes(2) // 任务应该被执行两次
-  })
-
-  it('should stop the poller and clear the timeout', async () => {
-    poller.start()
-    await new Promise((resolve) => setTimeout(resolve, interval / 2)) // 等待半个间隔
-    poller.stop()
-
-    expect(poller['timeoutId']).toBeUndefined() // 定时器应该被清除
-    expect(poller['resolveCurrentWait']).toBeUndefined() // resolve 函数应该被清除
-  })
-
-  it('should handle task errors and continue polling', async () => {
-    const error = new Error('Task failed')
-    task.mockRejectedValueOnce(error) // 模拟任务第一次执行时出错
-
-    const consoleSpy = vi.spyOn(console, 'error') // 捕获 console.error 调用
-
-    poller.start()
-    await new Promise((resolve) => setTimeout(resolve, interval * 2)) // 等待两个间隔
-
-    expect(consoleSpy).toHaveBeenCalledWith('Task execution error:', error) // 应该捕获到错误
-    expect(task).toHaveBeenCalledTimes(2) // 任务应该被执行两次，即使第一次出错
-  })
-
-  it('should stop the poller immediately when stop is called', async () => {
-    poller.start()
-    await new Promise((resolve) => setTimeout(resolve, interval / 2)) // 等待半个间隔
-    poller.stop()
-
-    expect(task).toHaveBeenCalledTimes(1) // 任务应该只被执行一次
-  })
-})

package/source/utils/poller/index.ts

@@ -1,57 +0,0 @@
-export type PollerTask = () => Promise<void> | void
-
-export class Poller {
-  private task: PollerTask       // 需要执行的函数
-  private interval: number // 执行间隔（毫秒）
-  private isRunning: boolean = false; // 运行状态
-  private timeoutId?: number // 定时器 ID
-  private resolveCurrentWait?: () => void // 用于中断等待的 resolve 函数
-
-  constructor(task: PollerTask, interval: number) {
-    this.task = task
-    this.interval = interval
-  }
-
-  // 异步执行循环
-  private async run(): Promise<void> {
-    while (this.isRunning) {
-      try {
-        await this.task() // 执行任务（同步/异步）
-      } catch (error) {
-        console.error("Task execution error:", error) // 错误处理
-      }
-
-      // 等待指定间隔（可被 stop 中断）
-      await new Promise<void>((resolve) => {
-        this.resolveCurrentWait = resolve
-        this.timeoutId = setTimeout(() => {
-          this.resolveCurrentWait = undefined
-          resolve()
-        }, this.interval)
-      })
-    }
-  }
-
-  // 启动轮训
-  start(): void {
-    if (this.isRunning) return
-    this.isRunning = true
-    this.run()
-  }
-
-  // 停止轮训
-  stop(): void {
-    if (!this.isRunning) return
-    this.isRunning = false
-
-    // 清除定时器和立即结束等待
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId)
-      this.timeoutId = undefined
-    }
-    if (this.resolveCurrentWait) {
-      this.resolveCurrentWait()
-      this.resolveCurrentWait = undefined
-    }
-  }
-}

package/source/utils/promise/index.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { catchE, catchP } from '.'
-
-describe('@helper/catch test', () => {
-  it('test catchP', async () => {
-    const testCases = [
-      { input: Promise.reject(1), output: [undefined, 1] },
-      { input: Promise.resolve(1), output: [1, undefined] },
-      { input: Promise.reject({}), output: [undefined, {}] },
-      { input: Promise.resolve({}), output: [{}, undefined] },
-      { input: Promise.reject(null), output: [undefined, null] },
-      { input: Promise.resolve(null), output: [null, undefined] },
-    ]
-
-    for (let index = 0; index < testCases.length; index++) {
-      const testCase = testCases[index]
-      const result = await catchP(testCase.input)
-      expect(result).toEqual(testCase.output)
-    }
-  })
-
-  it('test catchE', async () => {
-    const testCases = [
-      { input: () => { throw 1 }, output: [undefined, 1] },
-      { input: () => { return 1 }, output: [1, undefined] },
-      { input: () => { throw {} }, output: [undefined, {}] },
-      { input: () => { return {} }, output: [{}, undefined] },
-      { input: () => { throw null }, output: [undefined, null] },
-      { input: () => { return null }, output: [null, undefined] },
-    ]
-
-    for (let index = 0; index < testCases.length; index++) {
-      const testCase = testCases[index]
-      const result = await catchE(testCase.input)
-      expect(result).toEqual(testCase.output)
-    }
-  })
-})

package/source/utils/promise/index.ts

@@ -1,45 +0,0 @@
-
-/**
- * 将 Promise<R> 转换成 [resolve:R, reject:unknown] 的形式
- */
-export async function catchP<R>(p: Promise<R>): Promise<[R, unknown]> {
-  const returned: [R, unknown] = [undefined, undefined] as unknown as [R, unknown]
-
-  await p
-    .then((result) => (returned[0] = result))
-    .catch((error: unknown) => (returned[1] = error))
-
-  return returned
-}
-
-type CatchType<F extends () => unknown> = F extends () => Promise<infer R> ? R : F extends () => infer R ? R : never
-
-/**
- * 执行函数 ()=>R 并以 [return: R, error:unknown] 的形式返回结果
- */
-export async function catchE<F extends () => unknown>(f: F): Promise<[CatchType<F>, unknown]> {
-  const returned: [CatchType<F>, unknown] = [undefined, undefined] as unknown as [CatchType<F>, unknown]
-
-  try {
-    const result = f()
-    if (result instanceof Promise) {
-      return catchP(result)
-    } else {
-      returned[0] = result as CatchType<F>
-    }
-  } catch (error) {
-    returned[1] = error
-  }
-
-  return returned
-}
-
-declare global {
-  interface Promise<T> {
-    result<R = T>(): Promise<[R, unknown]>
-  }
-}
-
-Promise.prototype.result = function () {
-  return catchP(this)
-}