@taicode/common-base 1.0.2 → 1.1.0

package/source/debounce/debounce.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { debounce, debounceFn } from './debounce'
+
+describe('debounce', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.useRealTimers()
+  })
+
+  describe('debounceFn', () => {
+    it('应该延迟函数执行', async () => {
+      const mockFn = vi.fn().mockResolvedValue('result')
+      const debouncedFn = debounceFn(mockFn, 100)
+
+      const promise = debouncedFn('arg1', 'arg2')
+      
+      // 函数不应该立即执行
+      expect(mockFn).not.toHaveBeenCalled()
+      
+      // 推进时间
+      vi.advanceTimersByTime(100)
+      await promise
+      
+      expect(mockFn).toHaveBeenCalledOnce()
+      expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2')
+    })
+
+    it('应该取消之前的调用', async () => {
+      const mockFn = vi.fn().mockResolvedValue('result')
+      const debouncedFn = debounceFn(mockFn, 100)
+
+      // 快速连续调用
+      debouncedFn('first')
+      debouncedFn('second')
+      const finalPromise = debouncedFn('third')
+
+      // 推进时间
+      vi.advanceTimersByTime(100)
+      await finalPromise
+
+      // 只应该执行最后一次调用
+      expect(mockFn).toHaveBeenCalledOnce()
+      expect(mockFn).toHaveBeenCalledWith('third')
+    })
+
+    it('应该处理同步函数', async () => {
+      const mockFn = vi.fn().mockReturnValue('sync-result')
+      const debouncedFn = debounceFn(mockFn, 100)
+
+      const promise = debouncedFn('arg')
+      vi.advanceTimersByTime(100)
+      
+      const result = await promise
+      expect(result).toBe('sync-result')
+      expect(mockFn).toHaveBeenCalledWith('arg')
+    })
+
+    it('应该处理异步函数', async () => {
+      const mockFn = vi.fn().mockResolvedValue('async-result')
+      const debouncedFn = debounceFn(mockFn, 100)
+
+      const promise = debouncedFn('arg')
+      vi.advanceTimersByTime(100)
+      
+      const result = await promise
+      expect(result).toBe('async-result')
+    })
+
+    it('应该处理函数执行错误', async () => {
+      const error = new Error('Test error')
+      const mockFn = vi.fn().mockRejectedValue(error)
+      const debouncedFn = debounceFn(mockFn, 100)
+
+      const promise = debouncedFn('arg')
+      vi.advanceTimersByTime(100)
+      
+      await expect(promise).rejects.toThrow('Test error')
+    })
+
+    it('应该保持 this 上下文', async () => {
+      class TestClass {
+        value = 'test-value'
+        
+        getValue() {
+          return this.value
+        }
+      }
+
+      const instance = new TestClass()
+      const debouncedMethod = debounceFn(instance.getValue, 100)
+      
+      const promise = debouncedMethod.call(instance)
+      vi.advanceTimersByTime(100)
+      
+      const result = await promise
+      expect(result).toBe('test-value')
+    })
+  })
+
+  describe('debounce decorator', () => {
+    it('应该装饰类方法', async () => {
+      class TestClass {
+        callCount = 0
+        
+        @debounce(100)
+        increment() {
+          this.callCount++
+          return this.callCount
+        }
+      }
+
+      const instance = new TestClass()
+      
+      // 快速连续调用
+      instance.increment()
+      instance.increment()
+      instance.increment()
+
+      // 推进时间
+      vi.advanceTimersByTime(100)
+      
+      // 只应该执行一次
+      expect(instance.callCount).toBe(1)
+    })
+
+    it('应该为每个实例独立工作', async () => {
+      class TestClass {
+        value = 0
+        
+        @debounce(100)
+        async setValue(newValue: number) {
+          this.value = newValue
+          return this.value
+        }
+      }
+
+      const instance1 = new TestClass()
+      const instance2 = new TestClass()
+      
+      const promise1 = instance1.setValue(10)
+      const promise2 = instance2.setValue(20)
+
+      vi.advanceTimersByTime(100)
+      
+      await Promise.all([promise1, promise2])
+      
+      expect(instance1.value).toBe(10)
+      expect(instance2.value).toBe(20)
+    })
+
+    it('应该处理带参数的方法', async () => {
+      class TestClass {
+        lastArgs: any[] = []
+        
+        @debounce(100)
+        async saveArgs(...args: any[]) {
+          this.lastArgs = args
+          return args
+        }
+      }
+
+      const instance = new TestClass()
+      
+      instance.saveArgs(1, 2, 3)
+      instance.saveArgs(4, 5, 6)
+      const promise = instance.saveArgs(7, 8, 9)
+
+      vi.advanceTimersByTime(100)
+      const result = await promise
+      
+      expect(result).toEqual([7, 8, 9])
+      expect(instance.lastArgs).toEqual([7, 8, 9])
+    })
+  })
+})

package/source/debounce/debounce.ts

@@ -0,0 +1,42 @@
+/**
+ * 防抖装饰器 - 基于 TC39 Stage 3 Decorators 提案
+ * 在最后一次调用后等待指定时间才执行函数
+ */
+
+// 通用防抖函数
+export function debounceFn<T extends (...args: any[]) => any>(
+  fn: T,
+  wait: number
+): T {
+  let timeout: ReturnType<typeof setTimeout> | null = null
+
+  function debounced(this: any, ...args: any[]) {
+    return new Promise((resolve, reject) => {
+      if (timeout) clearTimeout(timeout)
+      
+      timeout = setTimeout(async () => {
+        try {
+          const result = await Promise.resolve(fn.apply(this, args))
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        }
+      }, wait)
+    })
+  }
+
+  return debounced as T
+}
+
+// TC39 Stage 3 装饰器实现
+export function debounce<T extends (...args: any[]) => any>(wait: number) {
+  return function (originalMethod: T, context: ClassMethodDecoratorContext): T {
+    // 每个实例独立
+    context.addInitializer(function () {
+      const self = this as any
+      const debouncedMethod = debounceFn(originalMethod.bind(self), wait)
+      self[context.name] = debouncedMethod
+    })
+    return originalMethod
+  }
+}

package/source/debounce/index.ts

@@ -0,0 +1 @@
+export * from './debounce'

package/source/disposer/disposer.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Disposer } from './disposer'
+
+describe('Disposer', () => {
+  let disposer: Disposer
+
+  beforeEach(() => {
+    disposer = new Disposer()
+  })
+
+  describe('addDisposer', () => {
+    it('应该能够添加清理函数', () => {
+      const cleanupFn = vi.fn()
+      
+      expect(() => {
+        disposer.addDisposer(cleanupFn)
+      }).not.toThrow()
+    })
+
+    it('应该能够添加多个清理函数', () => {
+      const cleanupFn1 = vi.fn()
+      const cleanupFn2 = vi.fn()
+      const cleanupFn3 = vi.fn()
+      
+      disposer.addDisposer(cleanupFn1)
+      disposer.addDisposer(cleanupFn2)
+      disposer.addDisposer(cleanupFn3)
+
+      disposer.dispose()
+
+      expect(cleanupFn1).toHaveBeenCalledOnce()
+      expect(cleanupFn2).toHaveBeenCalledOnce()
+      expect(cleanupFn3).toHaveBeenCalledOnce()
+    })
+
+    it('应该能够添加返回不同类型的清理函数', () => {
+      const voidFn = vi.fn(() => {})
+      const stringFn = vi.fn(() => 'cleanup result')
+      const numberFn = vi.fn(() => 42)
+      const promiseFn = vi.fn(() => Promise.resolve('async cleanup'))
+      
+      disposer.addDisposer(voidFn)
+      disposer.addDisposer(stringFn)
+      disposer.addDisposer(numberFn)
+      disposer.addDisposer(promiseFn)
+
+      disposer.dispose()
+
+      expect(voidFn).toHaveBeenCalled()
+      expect(stringFn).toHaveBeenCalled()
+      expect(numberFn).toHaveBeenCalled()
+      expect(promiseFn).toHaveBeenCalled()
+    })
+  })
+
+  describe('dispose', () => {
+    it('应该执行所有清理函数', () => {
+      const cleanupFn1 = vi.fn()
+      const cleanupFn2 = vi.fn()
+      const cleanupFn3 = vi.fn()
+      
+      disposer.addDisposer(cleanupFn1)
+      disposer.addDisposer(cleanupFn2)
+      disposer.addDisposer(cleanupFn3)
+
+      disposer.dispose()
+
+      expect(cleanupFn1).toHaveBeenCalledOnce()
+      expect(cleanupFn2).toHaveBeenCalledOnce()
+      expect(cleanupFn3).toHaveBeenCalledOnce()
+    })
+
+    it('应该按添加顺序执行清理函数', () => {
+      const executionOrder: number[] = []
+      
+      disposer.addDisposer(() => executionOrder.push(1))
+      disposer.addDisposer(() => executionOrder.push(2))
+      disposer.addDisposer(() => executionOrder.push(3))
+
+      disposer.dispose()
+
+      expect(executionOrder).toEqual([1, 2, 3])
+    })
+
+    it('应该处理清理函数中的错误', () => {
+      const workingFn1 = vi.fn()
+      const errorFn = vi.fn(() => {
+        throw new Error('Cleanup error')
+      })
+      const workingFn2 = vi.fn()
+      
+      // 模拟 console.error
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      
+      disposer.addDisposer(workingFn1)
+      disposer.addDisposer(errorFn)
+      disposer.addDisposer(workingFn2)
+
+      // dispose 不应该抛出错误
+      expect(() => {
+        disposer.dispose()
+      }).not.toThrow()
+
+      // 所有函数都应该被调用
+      expect(workingFn1).toHaveBeenCalled()
+      expect(errorFn).toHaveBeenCalled()
+      expect(workingFn2).toHaveBeenCalled()
+
+      // 错误应该被记录
+      expect(consoleSpy).toHaveBeenCalledWith('Error during cleanup:', expect.any(Error))
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('应该在执行后清空清理函数列表', () => {
+      const cleanupFn = vi.fn()
+      
+      disposer.addDisposer(cleanupFn)
+      disposer.dispose()
+
+      expect(cleanupFn).toHaveBeenCalledOnce()
+
+      // 再次调用 dispose 不应该执行任何函数
+      disposer.dispose()
+      expect(cleanupFn).toHaveBeenCalledOnce()
+    })
+
+    it('应该能够在清空后重新添加清理函数', () => {
+      const firstCleanup = vi.fn()
+      const secondCleanup = vi.fn()
+      
+      disposer.addDisposer(firstCleanup)
+      disposer.dispose()
+
+      disposer.addDisposer(secondCleanup)
+      disposer.dispose()
+
+      expect(firstCleanup).toHaveBeenCalledOnce()
+      expect(secondCleanup).toHaveBeenCalledOnce()
+    })
+
+    it('应该在没有清理函数时安全执行', () => {
+      expect(() => {
+        disposer.dispose()
+      }).not.toThrow()
+    })
+
+    it('应该能够多次调用 dispose', () => {
+      const cleanupFn = vi.fn()
+      
+      disposer.addDisposer(cleanupFn)
+      
+      disposer.dispose()
+      disposer.dispose()
+      disposer.dispose()
+
+      expect(cleanupFn).toHaveBeenCalledOnce()
+    })
+  })
+
+  describe('实际使用场景', () => {
+    it('应该能够清理事件监听器', () => {
+      const removeEventListener = vi.fn()
+      const unsubscribe = vi.fn()
+      
+      disposer.addDisposer(removeEventListener)
+      disposer.addDisposer(unsubscribe)
+
+      disposer.dispose()
+
+      expect(removeEventListener).toHaveBeenCalled()
+      expect(unsubscribe).toHaveBeenCalled()
+    })
+
+    it('应该能够清理定时器', () => {
+      const clearTimeout = vi.fn()
+      const clearInterval = vi.fn()
+      
+      disposer.addDisposer(() => clearTimeout(123))
+      disposer.addDisposer(() => clearInterval(456))
+
+      disposer.dispose()
+
+      expect(clearTimeout).toHaveBeenCalledWith(123)
+      expect(clearInterval).toHaveBeenCalledWith(456)
+    })
+
+    it('应该能够清理资源连接', () => {
+      const closeConnection = vi.fn()
+      const releaseResource = vi.fn()
+      
+      disposer.addDisposer(() => closeConnection())
+      disposer.addDisposer(() => releaseResource())
+
+      disposer.dispose()
+
+      expect(closeConnection).toHaveBeenCalled()
+      expect(releaseResource).toHaveBeenCalled()
+    })
+
+    it('应该与 EventEmitter 配合使用', () => {
+      // 模拟 EventEmitter 的使用
+      const mockEventEmitter = {
+        on: vi.fn().mockReturnValue(vi.fn()), // 返回 off 函数
+        cleanup: vi.fn()
+      }
+
+      const offFunction1 = mockEventEmitter.on('event1', vi.fn())
+      const offFunction2 = mockEventEmitter.on('event2', vi.fn())
+      
+      disposer.addDisposer(offFunction1)
+      disposer.addDisposer(offFunction2)
+      disposer.addDisposer(() => mockEventEmitter.cleanup())
+
+      disposer.dispose()
+
+      expect(offFunction1).toHaveBeenCalled()
+      expect(offFunction2).toHaveBeenCalled()
+      expect(mockEventEmitter.cleanup).toHaveBeenCalled()
+    })
+  })
+
+  describe('错误处理', () => {
+    it('应该捕获并记录同步错误', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      const error = new Error('Sync error')
+      
+      disposer.addDisposer(() => {
+        throw error
+      })
+
+      disposer.dispose()
+
+      expect(consoleSpy).toHaveBeenCalledWith('Error during cleanup:', error)
+      consoleSpy.mockRestore()
+    })
+
+    it('应该处理不同类型的错误', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      
+      disposer.addDisposer(() => {
+        throw new TypeError('Type error')
+      })
+      disposer.addDisposer(() => {
+        throw 'String error'
+      })
+      disposer.addDisposer(() => {
+        throw { message: 'Object error' }
+      })
+
+      disposer.dispose()
+
+      expect(consoleSpy).toHaveBeenCalledTimes(3)
+      consoleSpy.mockRestore()
+    })
+  })
+})

package/source/disposer/index.ts

@@ -0,0 +1 @@
+export * from './disposer'