@taicode/common-base 3.7.5 → 3.7.7

package/output/ring-cache/ring-cache.js

@@ -1,197 +0,0 @@
-/**
- * 环形缓存（Ring Cache）实现
- * 专门用于日志场景的FIFO（先进先出）缓存
- *
- * 特点：
- * - FIFO行为：新数据总是添加到尾部，当容量满时从头部移除旧数据
- * - 固定容量：避免内存无限增长
- * - 高效操作：O(1)的添加和访问操作
- * - 适用场景：日志记录、事件历史、时间序列数据等
- */
-/**
- * 环形缓存实现
- * 使用固定大小的数组实现FIFO行为的环形缓存
- */
-export class RingCache {
-    buffer;
-    head = 0; // 指向最旧的元素
-    tail = 0; // 指向下一个要插入的位置
-    size = 0;
-    capacity;
-    totalAdded = 0;
-    nextId = 1;
-    constructor(options = {}) {
-        this.capacity = options.capacity ?? 1000;
-        if (this.capacity <= 0) {
-            throw new Error('Capacity must be greater than 0');
-        }
-        this.buffer = new Array(this.capacity);
-    }
-    /**
-     * 添加新条目到缓存
-     * 如果缓存已满，将覆盖最旧的条目
-     */
-    add(data) {
-        const entry = {
-            data,
-            timestamp: new Date(),
-            id: this.generateId()
-        };
-        this.buffer[this.tail] = entry;
-        this.tail = (this.tail + 1) % this.capacity;
-        this.totalAdded++;
-        if (this.size < this.capacity) {
-            this.size++;
-        }
-        else {
-            // 缓存已满，头指针也需要移动
-            this.head = (this.head + 1) % this.capacity;
-        }
-        return entry;
-    }
-    /**
-     * 获取所有缓存条目（按添加顺序）
-     */
-    getAll() {
-        if (this.size === 0) {
-            return [];
-        }
-        const result = [];
-        for (let i = 0; i < this.size; i++) {
-            const index = (this.head + i) % this.capacity;
-            const entry = this.buffer[index];
-            if (entry) {
-                result.push(entry);
-            }
-        }
-        return result;
-    }
-    /**
-     * 获取最近的N个条目
-     */
-    getRecent(count) {
-        if (count <= 0 || this.size === 0) {
-            return [];
-        }
-        const actualCount = Math.min(count, this.size);
-        const result = [];
-        // 从尾部向前获取
-        for (let i = 0; i < actualCount; i++) {
-            const index = (this.tail - 1 - i + this.capacity) % this.capacity;
-            const entry = this.buffer[index];
-            if (entry) {
-                result.unshift(entry); // 保持时间顺序
-            }
-        }
-        return result;
-    }
-    /**
-     * 获取最旧的N个条目
-     */
-    getOldest(count) {
-        if (count <= 0 || this.size === 0) {
-            return [];
-        }
-        const actualCount = Math.min(count, this.size);
-        const result = [];
-        for (let i = 0; i < actualCount; i++) {
-            const index = (this.head + i) % this.capacity;
-            const entry = this.buffer[index];
-            if (entry) {
-                result.push(entry);
-            }
-        }
-        return result;
-    }
-    /**
-     * 根据时间范围获取条目
-     */
-    getByTimeRange(start, end) {
-        return this.getAll().filter(entry => entry.timestamp >= start && entry.timestamp <= end);
-    }
-    /**
-     * 搜索满足条件的条目
-     */
-    search(predicate) {
-        return this.getAll().filter(predicate);
-    }
-    /**
-     * 获取缓存统计信息
-     */
-    getStats() {
-        const all = this.getAll();
-        return {
-            size: this.size,
-            capacity: this.capacity,
-            isFull: this.size >= this.capacity,
-            oldestTimestamp: all.length > 0 ? all[0].timestamp : undefined,
-            newestTimestamp: all.length > 0 ? all[all.length - 1].timestamp : undefined,
-            totalAdded: this.totalAdded
-        };
-    }
-    /**
-     * 检查缓存是否为空
-     */
-    isEmpty() {
-        return this.size === 0;
-    }
-    /**
-     * 检查缓存是否已满
-     */
-    isFull() {
-        return this.size >= this.capacity;
-    }
-    /**
-     * 获取当前缓存大小
-     */
-    getSize() {
-        return this.size;
-    }
-    /**
-     * 获取缓存容量
-     */
-    getCapacity() {
-        return this.capacity;
-    }
-    /**
-     * 清空缓存
-     */
-    clear() {
-        this.buffer = new Array(this.capacity);
-        this.head = 0;
-        this.tail = 0;
-        this.size = 0;
-        this.totalAdded = 0;
-        this.nextId = 1;
-    }
-    /**
-     * 导出为数组格式
-     */
-    toArray() {
-        return this.getAll().map(entry => entry.data);
-    }
-    /**
-     * 导出为JSON格式
-     */
-    toJSON() {
-        return JSON.stringify(this.getAll(), null, 2);
-    }
-    /**
-     * 生成唯一ID
-     */
-    generateId() {
-        return `${Date.now()}-${this.nextId++}`;
-    }
-    /**
-     * 创建迭代器，支持for...of语法
-     */
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.size; i++) {
-            const index = (this.head + i) % this.capacity;
-            const entry = this.buffer[index];
-            if (entry) {
-                yield entry;
-            }
-        }
-    }
-}

package/output/ring-cache/ring-cache.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ring-cache.test.d.ts.map

package/output/ring-cache/ring-cache.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ring-cache.test.d.ts","sourceRoot":"","sources":["../../source/ring-cache/ring-cache.test.ts"],"names":[],"mappings":""}

package/output/ring-cache/ring-cache.test.js

@@ -1,196 +0,0 @@
-/**
- * RingCache 测试文件
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { RingCache } from './ring-cache.js';
-describe('RingCache', () => {
-    let cache;
-    beforeEach(() => {
-        cache = new RingCache({ capacity: 3 });
-    });
-    describe('基础功能', () => {
-        it('应该正确初始化', () => {
-            expect(cache.getSize()).toBe(0);
-            expect(cache.getCapacity()).toBe(3);
-            expect(cache.isEmpty()).toBe(true);
-            expect(cache.isFull()).toBe(false);
-        });
-        it('应该正确添加条目', () => {
-            const entry = cache.add('test1');
-            expect(entry.data).toBe('test1');
-            expect(entry.id).toBeDefined();
-            expect(entry.timestamp).toBeInstanceOf(Date);
-            expect(cache.getSize()).toBe(1);
-            expect(cache.isEmpty()).toBe(false);
-        });
-        it('应该正确处理容量限制', () => {
-            cache.add('test1');
-            cache.add('test2');
-            cache.add('test3');
-            expect(cache.getSize()).toBe(3);
-            expect(cache.isFull()).toBe(true);
-            // 添加第4个条目，应该覆盖第1个
-            cache.add('test4');
-            expect(cache.getSize()).toBe(3);
-            expect(cache.isFull()).toBe(true);
-            const all = cache.getAll();
-            expect(all.map(e => e.data)).toEqual(['test2', 'test3', 'test4']);
-        });
-    });
-    describe('获取功能', () => {
-        beforeEach(() => {
-            cache.add('first');
-            cache.add('second');
-            cache.add('third');
-        });
-        it('应该正确获取所有条目', () => {
-            const all = cache.getAll();
-            expect(all.length).toBe(3);
-            expect(all.map(e => e.data)).toEqual(['first', 'second', 'third']);
-        });
-        it('应该正确获取最近的条目', () => {
-            const recent = cache.getRecent(2);
-            expect(recent.length).toBe(2);
-            expect(recent.map(e => e.data)).toEqual(['second', 'third']);
-        });
-        it('应该正确获取最旧的条目', () => {
-            const oldest = cache.getOldest(2);
-            expect(oldest.length).toBe(2);
-            expect(oldest.map(e => e.data)).toEqual(['first', 'second']);
-        });
-        it('应该正确处理边界情况', () => {
-            expect(cache.getRecent(0)).toEqual([]);
-            expect(cache.getRecent(10)).toHaveLength(3);
-            expect(cache.getOldest(0)).toEqual([]);
-            expect(cache.getOldest(10)).toHaveLength(3);
-        });
-    });
-    describe('搜索功能', () => {
-        beforeEach(() => {
-            cache.add('apple');
-            cache.add('banana');
-            cache.add('apricot');
-        });
-        it('应该正确搜索条目', () => {
-            const results = cache.search(entry => entry.data.startsWith('ap'));
-            expect(results.length).toBe(2);
-            expect(results.map(e => e.data)).toEqual(['apple', 'apricot']);
-        });
-        it('应该支持时间范围搜索', () => {
-            const entries = cache.getAll();
-            const start = new Date(entries[0].timestamp.getTime() - 1);
-            const end = new Date(entries[entries.length - 1].timestamp.getTime() + 1);
-            const results = cache.getByTimeRange(start, end);
-            expect(results.length).toBe(3);
-        });
-    });
-    describe('统计功能', () => {
-        it('应该正确返回空缓存的统计信息', () => {
-            const stats = cache.getStats();
-            expect(stats.size).toBe(0);
-            expect(stats.capacity).toBe(3);
-            expect(stats.isFull).toBe(false);
-            expect(stats.oldestTimestamp).toBeUndefined();
-            expect(stats.newestTimestamp).toBeUndefined();
-            expect(stats.totalAdded).toBe(0);
-        });
-        it('应该正确返回有数据的统计信息', () => {
-            cache.add('test1');
-            cache.add('test2');
-            const stats = cache.getStats();
-            expect(stats.size).toBe(2);
-            expect(stats.capacity).toBe(3);
-            expect(stats.isFull).toBe(false);
-            expect(stats.oldestTimestamp).toBeInstanceOf(Date);
-            expect(stats.newestTimestamp).toBeInstanceOf(Date);
-            expect(stats.totalAdded).toBe(2);
-        });
-        it('应该正确跟踪总添加数', () => {
-            // 添加超过容量的条目
-            cache.add('1');
-            cache.add('2');
-            cache.add('3');
-            cache.add('4');
-            cache.add('5');
-            const stats = cache.getStats();
-            expect(stats.size).toBe(3);
-            expect(stats.totalAdded).toBe(5);
-        });
-    });
-    describe('清空和导出功能', () => {
-        beforeEach(() => {
-            cache.add('test1');
-            cache.add('test2');
-        });
-        it('应该正确清空缓存', () => {
-            cache.clear();
-            expect(cache.getSize()).toBe(0);
-            expect(cache.isEmpty()).toBe(true);
-            expect(cache.getStats().totalAdded).toBe(0);
-        });
-        it('应该正确导出为数组', () => {
-            const array = cache.toArray();
-            expect(array).toEqual(['test1', 'test2']);
-        });
-        it('应该正确导出为JSON', () => {
-            const json = cache.toJSON();
-            const parsed = JSON.parse(json);
-            expect(parsed).toHaveLength(2);
-            expect(parsed[0].data).toBe('test1');
-            expect(parsed[1].data).toBe('test2');
-        });
-    });
-    describe('迭代器功能', () => {
-        it('应该支持for...of语法', () => {
-            cache.add('a');
-            cache.add('b');
-            cache.add('c');
-            const results = [];
-            for (const entry of cache) {
-                results.push(entry.data);
-            }
-            expect(results).toEqual(['a', 'b', 'c']);
-        });
-    });
-    describe('边界条件', () => {
-        it('应该拒绝无效的容量', () => {
-            expect(() => new RingCache({ capacity: 0 })).toThrow('Capacity must be greater than 0');
-            expect(() => new RingCache({ capacity: -1 })).toThrow('Capacity must be greater than 0');
-        });
-        it('应该正确处理空缓存的操作', () => {
-            const emptyCache = new RingCache();
-            expect(emptyCache.getAll()).toEqual([]);
-            expect(emptyCache.getRecent(1)).toEqual([]);
-            expect(emptyCache.getOldest(1)).toEqual([]);
-            expect(emptyCache.toArray()).toEqual([]);
-        });
-        it('应该正确处理单个容量的缓存', () => {
-            const singleCache = new RingCache({ capacity: 1 });
-            singleCache.add('first');
-            expect(singleCache.getAll().map(e => e.data)).toEqual(['first']);
-            singleCache.add('second');
-            expect(singleCache.getAll().map(e => e.data)).toEqual(['second']);
-        });
-    });
-    describe('复杂数据类型', () => {
-        it('应该支持对象数据', () => {
-            const objectCache = new RingCache();
-            const obj1 = { name: 'test1', value: 1 };
-            const obj2 = { name: 'test2', value: 2 };
-            objectCache.add(obj1);
-            objectCache.add(obj2);
-            const all = objectCache.getAll();
-            expect(all[0].data).toEqual(obj1);
-            expect(all[1].data).toEqual(obj2);
-        });
-        it('应该支持搜索对象属性', () => {
-            const objectCache = new RingCache();
-            objectCache.add({ name: 'apple', type: 'fruit' });
-            objectCache.add({ name: 'carrot', type: 'vegetable' });
-            objectCache.add({ name: 'banana', type: 'fruit' });
-            const fruits = objectCache.search(entry => entry.data.type === 'fruit');
-            expect(fruits.length).toBe(2);
-            expect(fruits.map(e => e.data.name)).toEqual(['apple', 'banana']);
-        });
-    });
-});

package/output/service/index.d.ts

@@ -1,2 +0,0 @@
-export { Service } from './service.js';
-//# sourceMappingURL=index.d.ts.map

package/output/service/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA"}

package/output/service/index.js

@@ -1 +0,0 @@
-export { Service } from './service.js';

package/output/service/service.d.ts

@@ -1,6 +0,0 @@
-/** */
-export declare abstract class Service {
-    abstract inited: boolean;
-    abstract init(): Promise<boolean>;
-}
-//# sourceMappingURL=service.d.ts.map

package/output/service/service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../source/service/service.ts"],"names":[],"mappings":"AAAA,MAAM;AACN,8BAAsB,OAAO;IAC3B,SAAgB,MAAM,EAAE,OAAO,CAAA;aACf,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;CACzC"}

package/output/service/service.js

@@ -1,3 +0,0 @@
-/** */
-export class Service {
-}

package/output/string/index.d.ts

@@ -1,2 +0,0 @@
-export * from './string.js';
-//# sourceMappingURL=index.d.ts.map

package/output/string/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/output/string/index.js

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

package/output/string/string.d.ts

@@ -1,3 +0,0 @@
-/** 生成随机字符串，可以指定字符集和长度 */
-export declare function randomString(length: number, charset?: string): string;
-//# sourceMappingURL=string.d.ts.map

package/output/string/string.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../source/string/string.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,MAAyE,GAAG,MAAM,CAOvI"}

package/output/string/string.js

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

package/output/string/string.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=string.test.d.ts.map

package/output/string/string.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string.test.d.ts","sourceRoot":"","sources":["../../source/string/string.test.ts"],"names":[],"mappings":""}

package/output/string/string.test.js

@@ -1,77 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { randomString } from './string.js';
-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/output/throttle/index.d.ts

@@ -1,2 +0,0 @@
-export * from './throttle.js';
-//# sourceMappingURL=index.d.ts.map

package/output/throttle/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/throttle/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/output/throttle/index.js

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

package/output/throttle/throttle.d.ts

@@ -1,12 +0,0 @@
-/**
- * 节流装饰器 - 基于 TC39 Stage 3 Decorators 提案
- * 限制函数在指定时间内最多执行一次
- */
-interface ThrottleOptions {
-    leading?: boolean;
-    trailing?: boolean;
-}
-export declare function throttleFn<T extends (...args: any[]) => any>(fn: T, wait: number, options?: ThrottleOptions): T;
-export declare function throttle<T extends (...args: any[]) => any>(wait: number, options?: ThrottleOptions): (originalMethod: T, context: ClassMethodDecoratorContext) => T;
-export type { ThrottleOptions };
-//# sourceMappingURL=throttle.d.ts.map

package/output/throttle/throttle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../source/throttle/throttle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,UAAU,eAAe;IACvB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAGD,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1D,EAAE,EAAE,CAAC,EACL,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,CAAC,CAuCH;AAGD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,eAAe,IAER,gBAAgB,CAAC,EAAE,SAAS,2BAA2B,KAAG,CAAC,CAY7E;AAED,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/output/throttle/throttle.js

@@ -1,55 +0,0 @@
-/**
- * 节流装饰器 - 基于 TC39 Stage 3 Decorators 提案
- * 限制函数在指定时间内最多执行一次
- */
-// 通用节流函数
-export function throttleFn(fn, wait, options = {}) {
-    const { leading = true, trailing = true } = options;
-    let timeout = null;
-    let lastCallTime = 0;
-    let lastArgs;
-    let lastThis;
-    let result;
-    function throttled(...args) {
-        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;
-}
-// TC39 Stage 3 装饰器实现
-export function throttle(wait, options) {
-    return function (originalMethod, context) {
-        let methodKey = context.name;
-        context.addInitializer(function () {
-            const self = this;
-            // 只 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;
-    };
-}

package/output/throttle/throttle.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=throttle.test.d.ts.map

package/output/throttle/throttle.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.test.d.ts","sourceRoot":"","sources":["../../source/throttle/throttle.test.ts"],"names":[],"mappings":""}