@taicode/common-base 1.1.0 → 1.1.2

package/source/logger/index.ts

@@ -1,43 +0,0 @@
-// 基础 Logger 实现，支持简单的日志输出和扩展能力
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-export interface LoggerOptions {
-  level?: LogLevel;
-  handler?: (level: LogLevel, ...args: any[]) => void;
-}
-
-export class Logger {
-  private level: LogLevel;
-  private handler: (level: LogLevel, ...args: any[]) => void;
-
-  constructor(options: LoggerOptions = {}) {
-    this.level = options.level || 'info';
-    this.handler = options.handler || this.defaultHandler;
-  }
-
-  private defaultHandler(level: LogLevel, ...args: any[]) {
-    const prefix = `[${level.toUpperCase()}]`;
-    // eslint-disable-next-line no-console
-    (console[level] || console.log)(prefix, ...args);
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    const order: LogLevel[] = ['debug', 'info', 'warn', 'error'];
-    return order.indexOf(level) >= order.indexOf(this.level);
-  }
-
-  debug(...args: any[]) {
-    if (this.shouldLog('debug')) this.handler('debug', ...args);
-  }
-  info(...args: any[]) {
-    if (this.shouldLog('info')) this.handler('info', ...args);
-  }
-  warn(...args: any[]) {
-    if (this.shouldLog('warn')) this.handler('warn', ...args);
-  }
-  error(...args: any[]) {
-    if (this.shouldLog('error')) this.handler('error', ...args);
-  }
-}
-
-export const logger = new Logger();

package/source/logger/logger.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { Logger } from './index';
-
-describe('Logger', () => {
-  it('应该默认记录 info 及以上级别', () => {
-    const handler = vi.fn();
-    const logger = new Logger({ handler });
-    logger.debug('debug');
-    logger.info('info');
-    logger.warn('warn');
-    logger.error('error');
-    expect(handler).not.toHaveBeenCalledWith('debug', 'debug');
-    expect(handler).toHaveBeenCalledWith('info', 'info');
-    expect(handler).toHaveBeenCalledWith('warn', 'warn');
-    expect(handler).toHaveBeenCalledWith('error', 'error');
-  });
-
-  it('应该遵守日志级别', () => {
-    const handler = vi.fn();
-    const logger = new Logger({ level: 'warn', handler });
-    logger.info('info');
-    logger.warn('warn');
-    logger.error('error');
-    expect(handler).not.toHaveBeenCalledWith('info', 'info');
-    expect(handler).toHaveBeenCalledWith('warn', 'warn');
-    expect(handler).toHaveBeenCalledWith('error', 'error');
-  });
-
-  it('应该允许自定义处理器', () => {
-    const logs: any[] = [];
-    const handler = (level: string, ...args: any[]) => logs.push([level, ...args]);
-    const logger = new Logger({ handler });
-    logger.error('err', 123);
-    expect(logs).toContainEqual(['error', 'err', 123]);
-  });
-});

package/source/number/index.ts

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

package/source/number/number.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { bigintToNumber } from './number'
-
-describe('bigintToNumber 函数', () => {
-  it('应该将小的 bigint 转换为 number', () => {
-    const result = bigintToNumber(123n)
-    expect(result).toBe(123)
-  })
-
-  it('应该将负数 bigint 转换为 number', () => {
-    const result = bigintToNumber(-456n)
-    expect(result).toBe(-456)
-  })
-
-  it('应该将零 bigint 转换为 number', () => {
-    const result = bigintToNumber(0n)
-    expect(result).toBe(0)
-  })
-
-  it('应该为 null 输入返回 0', () => {
-    const result = bigintToNumber(null)
-    expect(result).toBe(0)
-  })
-
-  it('应该处理 MAX_SAFE_INTEGER 的 bigint', () => {
-    const maxSafe = BigInt(Number.MAX_SAFE_INTEGER)
-    const result = bigintToNumber(maxSafe)
-    expect(result).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  it('应该处理 MIN_SAFE_INTEGER 的 bigint', () => {
-    const minSafe = BigInt(Number.MIN_SAFE_INTEGER)
-    const result = bigintToNumber(minSafe)
-    expect(result).toBe(Number.MIN_SAFE_INTEGER)
-  })
-
-  it('应该为 bigint 溢出（正数）返回 MAX_SAFE_INTEGER', () => {
-    const tooBig = BigInt(Number.MAX_SAFE_INTEGER) + 1n
-    const result = bigintToNumber(tooBig)
-    expect(result).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  it('应该为 bigint 溢出（负数）返回 MAX_SAFE_INTEGER', () => {
-    const tooSmall = BigInt(Number.MIN_SAFE_INTEGER) - 1n
-    const result = bigintToNumber(tooSmall)
-    expect(result).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  it('应该处理非常大的 bigint', () => {
-    const veryLarge = 999999999999999999999n
-    const result = bigintToNumber(veryLarge)
-    expect(result).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  it('应该处理从 number 创建的 bigint', () => {
-    const bigintFromNumber = BigInt(42)
-    const result = bigintToNumber(bigintFromNumber)
-    expect(result).toBe(42)
-  })
-})

package/source/number/number.ts

@@ -1,25 +0,0 @@
-export function bigintToNumber(value: bigint | null): number {
-  if (value === null) return 0
-
-  // JavaScript 的 number 类型最大值
-  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER // 2^53 - 1
-  const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER // -(2^53 - 1)
-
-  try {
-    // 检查输入是否为 bigint
-    if (typeof value !== 'bigint') {
-      throw new TypeError('Input must be a bigint')
-    }
-
-    // 检查是否溢出
-    if (value > BigInt(MAX_SAFE_INTEGER) || value < BigInt(MIN_SAFE_INTEGER)) {
-      return MAX_SAFE_INTEGER // 溢出，返回 NaN
-    }
-
-    // 将 bigint 转换为 number
-    return Number(value)
-  } catch {
-    // 捕获任何错误并返回 NaN
-    return 0
-  }
-}

package/source/object/index.ts

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

package/source/object/object.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { objectMerge } from './object'
-
-describe('merge 函数', () => {
-  it('应该合并两个简单对象', () => {
-    const target = { a: 1 } as object
-    const source = { b: 2 } as object
-    const result = objectMerge(target, source)
-
-    expect(result).toEqual({ a: 1, b: 2 })
-  })
-
-  it('应该合并嵌套对象', () => {
-    const target = { a: 1, b: { c: 2 } } as object
-    const source = { b: { d: 3 }, e: 4 } as object
-    const result = objectMerge(target, source)
-
-    expect(result).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 })
-  })
-
-  it('应该合并多个对象', () => {
-    const target = { a: 1 } as object
-    const source1 = { b: 2 } as object
-    const source2 = { c: 3 } as object
-    const result = objectMerge(target, source1, source2)
-
-    expect(result).toEqual({ a: 1, b: 2, c: 3 })
-  })
-
-  it('应该覆盖现有属性', () => {
-    const target = { a: 1, b: 2 } as object
-    const source = { b: 3, c: 4 } as object
-    const result = objectMerge(target, source)
-
-    expect(result).toEqual({ a: 1, b: 3, c: 4 })
-  })
-
-  it('应该处理 null 和数组值', () => {
-    const target = { a: 1, b: null } as object
-    const source = { b: [1, 2, 3], c: 4 }
-    const result = objectMerge(target, source)
-
-    expect(result).toEqual({ a: 1, b: [1, 2, 3], c: 4 })
-  })
-
-  it('应该不改变原始目标对象', () => {
-    const target = { a: 1 } as object
-    const source = { b: 2 } as object
-    const result = objectMerge(target, source)
-
-    expect(result).toEqual({ a: 1, b: 2 })
-    expect(source).toEqual({ b: 2 }) // Target should remain unchanged
-  })
-})

package/source/object/object.ts

@@ -1,29 +0,0 @@
-/**
- * 递归合并对象，只针对对象类型的属性进行合并，其他类型后者覆盖前者
- */
-export function objectMerge<T extends object>(target: T, ...rest: Partial<T>[]): T {
-    for (const source of rest) {
-        for (const key in source) {
-            if (source.hasOwnProperty(key)) {
-                if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
-                    if (!target.hasOwnProperty(key)) {
-                        (target as any)[key] = {}
-                    }
-                    objectMerge((target as any)[key], (source as any)[key])
-                } else {
-                    (target as any)[key] = source[key]
-                }
-            }
-        }
-    }
-
-    return target
-}
-
-export function ObjectKeys<T extends object>(obj: T): (keyof T)[] {
-    return Object.keys(obj) as (keyof T)[]
-}
-
-export function ObjectValues<T extends object>(obj: T): T[keyof T][] {
-    return Object.values(obj) as T[keyof T][]
-}

package/source/string/index.ts

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

package/source/string/string.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { randomString } from './string'
-
-describe('randomString 函数', () => {
-  beforeEach(() => {
-    // 重置随机数生成器的模拟
-    vi.clearAllMocks()
-  })
-
-  it('应该生成指定长度的字符串', () => {
-    const result = randomString(10)
-    expect(result).toHaveLength(10)
-  })
-
-  it('应该为零长度生成空字符串', () => {
-    const result = randomString(0)
-    expect(result).toBe('')
-  })
-
-  it('应该在未指定时使用默认字符集', () => {
-    const result = randomString(100)
-    const defaultCharset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-    
-    // 检查结果只包含默认字符集中的字符
-    for (const char of result) {
-      expect(defaultCharset).toContain(char)
-    }
-  })
-
-  it('应该在提供时使用自定义字符集', () => {
-    const customCharset = '123'
-    const result = randomString(10, customCharset)
-    
-    // 检查结果只包含自定义字符集中的字符
-    for (const char of result) {
-      expect(customCharset).toContain(char)
-    }
-  })
-
-  it('应该在多次调用时生成不同的字符串', () => {
-    const result1 = randomString(20)
-    const result2 = randomString(20)
-    
-    // 虽然理论上可能相同，但实际上几乎不可能
-    expect(result1).not.toBe(result2)
-  })
-
-  it('应该对单字符字符集正常工作', () => {
-    const result = randomString(5, 'A')
-    expect(result).toBe('AAAAA')
-  })
-
-  it('应该对字符集中的特殊字符正常工作', () => {
-    const specialCharset = '!@#$%^&*()'
-    const result = randomString(10, specialCharset)
-    
-    expect(result).toHaveLength(10)
-    
-    // 检查结果只包含特殊字符集中的字符
-    for (const char of result) {
-      expect(specialCharset).toContain(char)
-    }
-  })
-
-  it('应该对字符集中的Unicode字符正常工作', () => {
-    const unicodeCharset = '你好世界🎉'
-    const result = randomString(5, unicodeCharset)
-    
-    expect(result).toHaveLength(5)
-    
-    // 检查结果只包含Unicode字符集中的字符
-    for (const char of result) {
-      expect(unicodeCharset).toContain(char)
-    }
-  })
-
-  it('应该处理大长度值', () => {
-    const result = randomString(1000)
-    expect(result).toHaveLength(1000)
-  })
-
-  it('应该对固定的Math.random具有确定性', () => {
-    // 模拟Math.random返回固定值
-    const mockRandom = vi.spyOn(Math, 'random')
-    mockRandom.mockReturnValueOnce(0) // 第一个字符
-    mockRandom.mockReturnValueOnce(0.5) // 第二个字符
-    
-    const charset = 'ABC'
-    const result = randomString(2, charset)
-    
-    // 基于模拟的随机值，应该返回特定的字符
-    // Math.floor(0 * 3) = 0 -> 'A'
-    // Math.floor(0.5 * 3) = 1 -> 'B'
-    expect(result).toBe('AB')
-    
-    mockRandom.mockRestore()
-  })
-})

package/source/string/string.ts

@@ -1,9 +0,0 @@
-/** 生成随机字符串，可以指定字符集和长度 */
-export function randomString(length: number, charset: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'): string {
-  let result = ''
-  const charsetLength = charset.length
-  for (let i = 0; i < length; i++) {
-    result += charset.charAt(Math.floor(Math.random() * charsetLength))
-  }
-  return result
-}

package/source/throttle/index.ts

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

package/source/throttle/throttle.test.ts

@@ -1,228 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { throttle, throttleFn } from './throttle'
-
-describe('throttle', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-    vi.useRealTimers()
-  })
-
-  describe('throttleFn', () => {
-    it('应该立即执行第一次调用', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100)
-
-      const result = throttledFn('arg1', 'arg2')
-      
-      expect(mockFn).toHaveBeenCalledOnce()
-      expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2')
-      expect(result).toBe('result')
-    })
-
-    it('应该在间隔时间内忽略后续调用', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100)
-
-      // 第一次调用应该立即执行
-      throttledFn('first')
-      expect(mockFn).toHaveBeenCalledOnce()
-
-      // 在间隔时间内的调用应该被忽略
-      throttledFn('second')
-      throttledFn('third')
-      expect(mockFn).toHaveBeenCalledOnce()
-    })
-
-    it('应该在间隔时间结束后允许新的调用', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100)
-
-      // 第一次调用
-      throttledFn('first')
-      expect(mockFn).toHaveBeenCalledOnce()
-
-      // 推进时间超过间隔
-      vi.advanceTimersByTime(150)
-
-      // 现在应该允许新的调用
-      throttledFn('second')
-      expect(mockFn).toHaveBeenCalledTimes(2)
-      expect(mockFn).toHaveBeenLastCalledWith('second')
-    })
-
-    it('应该支持 leading: false 选项', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100, { leading: false })
-
-      // 第一次调用不应该立即执行
-      throttledFn('first')
-      expect(mockFn).not.toHaveBeenCalled()
-    })
-
-    it('应该支持 trailing: true 选项', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100, { trailing: true })
-
-      // 第一次调用
-      throttledFn('first')
-      expect(mockFn).toHaveBeenCalledOnce()
-
-      // 在间隔时间内的调用
-      throttledFn('second')
-      throttledFn('third')
-
-      // 推进时间，应该执行 trailing 调用
-      vi.advanceTimersByTime(100)
-      expect(mockFn).toHaveBeenCalledTimes(2)
-      expect(mockFn).toHaveBeenLastCalledWith('third')
-    })
-
-    it('应该支持 trailing: false 选项', () => {
-      const mockFn = vi.fn().mockReturnValue('result')
-      const throttledFn = throttleFn(mockFn, 100, { trailing: false })
-
-      // 第一次调用
-      throttledFn('first')
-      expect(mockFn).toHaveBeenCalledOnce()
-
-      // 在间隔时间内的调用
-      throttledFn('second')
-      throttledFn('third')
-
-      // 推进时间，不应该执行 trailing 调用
-      vi.advanceTimersByTime(100)
-      expect(mockFn).toHaveBeenCalledOnce()
-    })
-
-    it('应该保持 this 上下文', () => {
-      class TestClass {
-        value = 'test-value'
-        
-        getValue() {
-          return this.value
-        }
-      }
-
-      const instance = new TestClass()
-      const throttledMethod = throttleFn(instance.getValue, 100)
-      
-      const result = throttledMethod.call(instance)
-      expect(result).toBe('test-value')
-    })
-
-    it('应该返回最后一次执行的结果', () => {
-      const mockFn = vi.fn()
-        .mockReturnValueOnce('first')
-        .mockReturnValueOnce('second')
-      
-      const throttledFn = throttleFn(mockFn, 100)
-
-      const result1 = throttledFn()
-      expect(result1).toBe('first')
-
-      // 在间隔时间内，应该返回缓存的结果
-      const result2 = throttledFn()
-      expect(result2).toBe('first')
-
-      // 推进时间后的新调用
-      vi.advanceTimersByTime(150)
-      const result3 = throttledFn()
-      expect(result3).toBe('second')
-    })
-  })
-
-  describe('throttle decorator', () => {
-    it('应该装饰类方法', () => {
-      class TestClass {
-        callCount = 0
-        
-        @throttle(100)
-        increment() {
-          this.callCount++
-          return this.callCount
-        }
-      }
-
-      const instance = new TestClass()
-      
-      // 第一次调用应该立即执行
-      const result1 = instance.increment()
-      expect(result1).toBe(1)
-      expect(instance.callCount).toBe(1)
-
-      // 快速连续调用应该被节流
-      instance.increment()
-      instance.increment()
-      expect(instance.callCount).toBe(1)
-    })
-
-    it('应该为每个实例独立工作', () => {
-      class TestClass {
-        callCount = 0
-        
-        @throttle(100)
-        increment() {
-          this.callCount++
-          return this.callCount
-        }
-      }
-
-      const instance1 = new TestClass()
-      const instance2 = new TestClass()
-      
-      instance1.increment()
-      instance2.increment()
-      
-      expect(instance1.callCount).toBe(1)
-      expect(instance2.callCount).toBe(1)
-    })
-
-    it('应该支持带选项的装饰器', () => {
-      class TestClass {
-        callCount = 0
-        
-        @throttle(100, { leading: false, trailing: true })
-        increment() {
-          this.callCount++
-          return this.callCount
-        }
-      }
-
-      const instance = new TestClass()
-      
-      // leading: false，第一次调用不应该立即执行
-      instance.increment()
-      expect(instance.callCount).toBe(0)
-
-      // trailing: true，应该在延迟后执行
-      vi.advanceTimersByTime(100)
-      expect(instance.callCount).toBe(1)
-    })
-
-    it('应该处理带参数的方法', () => {
-      class TestClass {
-        lastArgs: any[] = []
-        
-        @throttle(100)
-        saveArgs(...args: any[]) {
-          this.lastArgs = args
-          return args.length
-        }
-      }
-
-      const instance = new TestClass()
-      
-      const result = instance.saveArgs(1, 2, 3)
-      expect(result).toBe(3)
-      expect(instance.lastArgs).toEqual([1, 2, 3])
-
-      // 在间隔时间内的调用应该被忽略
-      instance.saveArgs(4, 5, 6, 7)
-      expect(instance.lastArgs).toEqual([1, 2, 3]) // 应该保持原值
-    })
-  })
-})

package/source/throttle/throttle.ts

@@ -1,76 +0,0 @@
-/**
- * 节流装饰器 - 基于 TC39 Stage 3 Decorators 提案
- * 限制函数在指定时间内最多执行一次
- */
-
-interface ThrottleOptions {
-  leading?: boolean  // 是否在开始时立即执行，默认 true
-  trailing?: boolean // 是否在结束时执行最后一次，默认 true
-}
-
-// 通用节流函数
-export function throttleFn<T extends (...args: any[]) => any>(
-  fn: T, 
-  wait: number, 
-  options: ThrottleOptions = {}
-): T {
-  const { leading = true, trailing = true } = options
-  let timeout: ReturnType<typeof setTimeout> | null = null
-  let lastCallTime: number = 0
-  let lastArgs: any[]
-  let lastThis: any
-  let result: any
-
-  function throttled(this: any, ...args: any[]) {
-    const now = Date.now()
-    
-    // 如果是第一次调用且不允许 leading
-    if (lastCallTime === 0 && !leading) {
-      lastCallTime = now
-    }
-
-    const remaining = wait - (now - lastCallTime)
-    lastArgs = args
-    lastThis = this
-
-    if (remaining <= 0 || remaining > wait) {
-      if (timeout) {
-        clearTimeout(timeout)
-        timeout = null
-      }
-      lastCallTime = now
-      result = fn.apply(this, args)
-    } else if (!timeout && trailing) {
-      timeout = setTimeout(() => {
-        lastCallTime = leading ? Date.now() : 0
-        timeout = null
-        result = fn.apply(lastThis, lastArgs)
-      }, remaining)
-    }
-
-    return result
-  }
-
-  return throttled as T
-}
-
-// TC39 Stage 3 装饰器实现
-export function throttle<T extends (...args: any[]) => any>(
-  wait: number, 
-  options?: ThrottleOptions
-) {
-  return function (originalMethod: T, context: ClassMethodDecoratorContext): T {
-    let methodKey = context.name
-    context.addInitializer(function () {
-      const self = this as any
-      // 只 patch 原型上的原始方法，避免多层嵌套
-      const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(self), methodKey)
-      const method = descriptor?.value ?? originalMethod
-      const throttledMethod = throttleFn(method.bind(self), wait, options)
-      self[methodKey] = throttledMethod
-    })
-    return originalMethod
-  }
-}
-
-export type { ThrottleOptions }

package/test-exports.js

@@ -1,6 +0,0 @@
-// 测试 exports 配置
-import { catchIt } from '@taicode/common-base/catch'
-import { logger } from '@taicode/common-base/logger'
-import { debounce } from '@taicode/common-base/debounce'
-
-console.log('Exports configuration test passed!')