@taicode/common-base 1.1.3 → 1.1.4

package/output/catch/catch.d.ts

@@ -1,9 +1,9 @@
-type CatchType<F extends () => unknown> = F extends () => Promise<infer R> ? R : F extends () => infer R ? R : never;
+type CatchType<F extends () => unknown> = F extends () => PromiseLike<infer R> ? R : F extends () => infer R ? R : never;
 /**
- * 通用错误捕获函数，支持 Promise 和函数执行
+ * 通用错误捕获函数，支持 PromiseLike 和函数执行
  * 将结果转换成 [result, error] 的形式
  */
-export declare function catchIt<T>(input: Promise<T>): Promise<[T | undefined, unknown]>;
+export declare function catchIt<T>(input: PromiseLike<T>): Promise<[T | undefined, unknown]>;
 export declare function catchIt<F extends () => unknown>(input: F): Promise<[CatchType<F> | undefined, unknown]>;
 export {};
 //# sourceMappingURL=catch.d.ts.map

package/output/catch/catch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEpH;;;GAGG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AACtF,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA"}
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAKA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAExH;;;GAGG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AAC1F,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA"}

package/output/catch/catch.js

@@ -1,17 +1,21 @@
+// 辅助函数：检查是否为 PromiseLike
+function isPromiseLike(value) {
+    return value != null && typeof value === 'object' && 'then' in value && typeof value.then === 'function';
+}
 export async function catchIt(input) {
     const returned = [undefined, undefined];
     try {
-        if (input instanceof Promise) {
-            // 处理 Promise
-            await input
+        if (isPromiseLike(input)) {
+            // 处理 PromiseLike
+            await Promise.resolve(input)
                 .then((result) => (returned[0] = result))
                 .catch((error) => (returned[1] = error));
         }
         else if (typeof input === 'function') {
             // 处理函数
             const result = input();
-            if (result instanceof Promise) {
-                // 如果函数返回 Promise，递归调用
+            if (isPromiseLike(result)) {
+                // 如果函数返回 PromiseLike，递归调用
                 return catchIt(result);
             }
             else {

package/output/catch/catch.test.js

@@ -255,4 +255,109 @@ describe('catchIt', () => {
             expect(jsonError).toBeInstanceOf(SyntaxError);
         });
     });
+    describe('处理 PromiseLike 对象', () => {
+        it('应该正确处理自定义的 PromiseLike 对象', async () => {
+            // 创建自定义的 PromiseLike 对象
+            const customPromiseLike = {
+                then(onfulfilled, onrejected) {
+                    try {
+                        const result = onfulfilled?.('custom promise result');
+                        return Promise.resolve(result);
+                    }
+                    catch (error) {
+                        return onrejected ? Promise.resolve(onrejected(error)) : Promise.reject(error);
+                    }
+                }
+            };
+            const [result, error] = await catchIt(customPromiseLike);
+            expect(result).toBe('custom promise result');
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理失败的 PromiseLike 对象', async () => {
+            const customError = new Error('custom promise error');
+            const failingPromiseLike = {
+                then(onfulfilled, onrejected) {
+                    if (onrejected) {
+                        return Promise.resolve(onrejected(customError));
+                    }
+                    return Promise.reject(customError);
+                }
+            };
+            const [result, error] = await catchIt(failingPromiseLike);
+            expect(result).toBeUndefined();
+            expect(error).toBe(customError);
+        });
+        it('应该正确处理返回 PromiseLike 的函数', async () => {
+            const customPromiseLike = {
+                then(onfulfilled, onrejected) {
+                    try {
+                        const result = onfulfilled?.(42);
+                        return Promise.resolve(result);
+                    }
+                    catch (error) {
+                        return onrejected ? Promise.resolve(onrejected(error)) : Promise.reject(error);
+                    }
+                }
+            };
+            const fn = () => customPromiseLike;
+            const [result, error] = await catchIt(fn);
+            expect(result).toBe(42);
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理第三方库的 PromiseLike 对象', async () => {
+            // 模拟第三方库的 PromiseLike 实现 (如 jQuery.Deferred, Bluebird 等)
+            class CustomPromise {
+                value;
+                isResolved = false;
+                isRejected = false;
+                rejectionReason;
+                constructor(executor) {
+                    const resolve = (value) => {
+                        this.value = value;
+                        this.isResolved = true;
+                    };
+                    const reject = (reason) => {
+                        this.rejectionReason = reason;
+                        this.isRejected = true;
+                    };
+                    try {
+                        executor(resolve, reject);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+                then(onfulfilled, onrejected) {
+                    if (this.isResolved && onfulfilled) {
+                        try {
+                            const result = onfulfilled(this.value);
+                            return Promise.resolve(result);
+                        }
+                        catch (error) {
+                            return Promise.reject(error);
+                        }
+                    }
+                    else if (this.isRejected && onrejected) {
+                        try {
+                            const result = onrejected(this.rejectionReason);
+                            return Promise.resolve(result);
+                        }
+                        catch (error) {
+                            return Promise.reject(error);
+                        }
+                    }
+                    else if (this.isRejected) {
+                        return Promise.reject(this.rejectionReason);
+                    }
+                    return Promise.resolve(this.value);
+                }
+            }
+            const customPromise = new CustomPromise((resolve) => {
+                resolve('third party promise');
+            });
+            const [result, error] = await catchIt(customPromise);
+            expect(result).toBe('third party promise');
+            expect(error).toBeUndefined();
+        });
+    });
 });

package/output/lru-cache/index.d.ts

@@ -0,0 +1,2 @@
+export { LruCache } from './lru-cache';
+//# sourceMappingURL=index.d.ts.map

package/output/lru-cache/index.d.ts.map

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

package/output/lru-cache/index.js

@@ -0,0 +1 @@
+export { LruCache } from './lru-cache';

package/output/lru-cache/lru-cache.d.ts

@@ -0,0 +1,22 @@
+export declare class LruCache<T> {
+    private cache;
+    private maxSize;
+    private head;
+    private tail;
+    constructor(maxSize?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    get size(): number;
+    get capacity(): number;
+    clear(): void;
+    keys(): string[];
+    values(): T[];
+    entries(): Array<[string, T]>;
+    private addToHead;
+    private removeNode;
+    private moveToHead;
+    private removeTail;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/output/lru-cache/lru-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-cache.d.ts","sourceRoot":"","sources":["../../source/lru-cache/lru-cache.ts"],"names":[],"mappings":"AAOA,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAY;gBAEZ,OAAO,GAAE,MAAY;IAgBjC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAY/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAgChC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKzB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAY5B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAGD,IAAI,QAAQ,IAAI,MAAM,CAErB;IAGD,KAAK,IAAI,IAAI;IAOb,IAAI,IAAI,MAAM,EAAE;IAWhB,MAAM,IAAI,CAAC,EAAE;IAWb,OAAO,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAW7B,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,UAAU;CAQnB"}

package/output/lru-cache/lru-cache.js

@@ -0,0 +1,147 @@
+export class LruCache {
+    cache;
+    maxSize;
+    head;
+    tail;
+    constructor(maxSize = 100) {
+        if (maxSize <= 0) {
+            throw new Error('maxSize must be greater than 0');
+        }
+        this.maxSize = maxSize;
+        this.cache = new Map();
+        // 创建虚拟头尾节点
+        this.head = { key: '', value: null, prev: null, next: null };
+        this.tail = { key: '', value: null, prev: null, next: null };
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    // 获取缓存中的数据
+    get(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            return undefined;
+        }
+        // 移动到头部（最近使用）
+        this.moveToHead(node);
+        return node.value;
+    }
+    // 设置缓存数据
+    set(key, value) {
+        const existingNode = this.cache.get(key);
+        if (existingNode) {
+            // 更新现有节点的值并移动到头部
+            existingNode.value = value;
+            this.moveToHead(existingNode);
+        }
+        else {
+            // 创建新节点
+            const newNode = {
+                key,
+                value,
+                prev: null,
+                next: null
+            };
+            // 检查是否超过容量
+            if (this.cache.size >= this.maxSize) {
+                // 移除最少使用的节点（尾部）
+                const tail = this.removeTail();
+                if (tail) {
+                    this.cache.delete(tail.key);
+                }
+            }
+            // 添加到头部
+            this.cache.set(key, newNode);
+            this.addToHead(newNode);
+        }
+    }
+    // 检查键是否存在
+    has(key) {
+        return this.cache.has(key);
+    }
+    // 删除指定键
+    delete(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            return false;
+        }
+        this.removeNode(node);
+        this.cache.delete(key);
+        return true;
+    }
+    // 获取当前缓存大小
+    get size() {
+        return this.cache.size;
+    }
+    // 获取最大容量
+    get capacity() {
+        return this.maxSize;
+    }
+    // 清空缓存
+    clear() {
+        this.cache.clear();
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    // 获取所有键（按使用频率排序，最近使用的在前）
+    keys() {
+        const keys = [];
+        let current = this.head.next;
+        while (current && current !== this.tail) {
+            keys.push(current.key);
+            current = current.next;
+        }
+        return keys;
+    }
+    // 获取所有值（按使用频率排序，最近使用的在前）
+    values() {
+        const values = [];
+        let current = this.head.next;
+        while (current && current !== this.tail) {
+            values.push(current.value);
+            current = current.next;
+        }
+        return values;
+    }
+    // 获取所有键值对
+    entries() {
+        const entries = [];
+        let current = this.head.next;
+        while (current && current !== this.tail) {
+            entries.push([current.key, current.value]);
+            current = current.next;
+        }
+        return entries;
+    }
+    // 私有方法：添加节点到头部
+    addToHead(node) {
+        node.prev = this.head;
+        node.next = this.head.next;
+        if (this.head.next) {
+            this.head.next.prev = node;
+        }
+        this.head.next = node;
+    }
+    // 私有方法：移除节点
+    removeNode(node) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+    }
+    // 私有方法：移动节点到头部
+    moveToHead(node) {
+        this.removeNode(node);
+        this.addToHead(node);
+    }
+    // 私有方法：移除尾部节点
+    removeTail() {
+        const lastNode = this.tail.prev;
+        if (lastNode && lastNode !== this.head) {
+            this.removeNode(lastNode);
+            return lastNode;
+        }
+        return null;
+    }
+}

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

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

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

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

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

@@ -0,0 +1,239 @@
+import { describe, it, expect } from 'vitest';
+import { LruCache } from './lru-cache';
+describe('LruCache', () => {
+    describe('构造函数', () => {
+        it('应该创建默认容量为100的缓存', () => {
+            const cache = new LruCache();
+            expect(cache.capacity).toBe(100);
+            expect(cache.size).toBe(0);
+        });
+        it('应该创建指定容量的缓存', () => {
+            const cache = new LruCache(50);
+            expect(cache.capacity).toBe(50);
+            expect(cache.size).toBe(0);
+        });
+        it('应该在容量小于等于0时抛出错误', () => {
+            expect(() => new LruCache(0)).toThrow('maxSize must be greater than 0');
+            expect(() => new LruCache(-1)).toThrow('maxSize must be greater than 0');
+        });
+    });
+    describe('基本操作', () => {
+        it('应该能设置和获取值', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            expect(cache.get('key1')).toBe('value1');
+            expect(cache.size).toBe(1);
+        });
+        it('应该在键不存在时返回undefined', () => {
+            const cache = new LruCache(3);
+            expect(cache.get('nonexistent')).toBeUndefined();
+        });
+        it('应该正确检查键是否存在', () => {
+            const cache = new LruCache(3);
+            expect(cache.has('key1')).toBe(false);
+            cache.set('key1', 'value1');
+            expect(cache.has('key1')).toBe(true);
+        });
+        it('应该能更新现有键的值', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key1', 'updated_value1');
+            expect(cache.get('key1')).toBe('updated_value1');
+            expect(cache.size).toBe(1);
+        });
+        it('应该能删除键', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            expect(cache.delete('key1')).toBe(true);
+            expect(cache.has('key1')).toBe(false);
+            expect(cache.size).toBe(0);
+        });
+        it('应该在删除不存在的键时返回false', () => {
+            const cache = new LruCache(3);
+            expect(cache.delete('nonexistent')).toBe(false);
+        });
+        it('应该能清空缓存', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.clear();
+            expect(cache.size).toBe(0);
+            expect(cache.has('key1')).toBe(false);
+            expect(cache.has('key2')).toBe(false);
+        });
+    });
+    describe('LRU 行为', () => {
+        it('应该在达到容量限制时移除最久未使用的项', () => {
+            const cache = new LruCache(2);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3'); // 这应该移除 key1
+            expect(cache.has('key1')).toBe(false);
+            expect(cache.has('key2')).toBe(true);
+            expect(cache.has('key3')).toBe(true);
+            expect(cache.size).toBe(2);
+        });
+        it('应该在访问时更新使用顺序', () => {
+            const cache = new LruCache(2);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.get('key1'); // 使 key1 成为最近使用的
+            cache.set('key3', 'value3'); // 这应该移除 key2，而不是 key1
+            expect(cache.has('key1')).toBe(true);
+            expect(cache.has('key2')).toBe(false);
+            expect(cache.has('key3')).toBe(true);
+        });
+        it('应该在更新现有键时保持其为最近使用', () => {
+            const cache = new LruCache(2);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key1', 'updated_value1'); // 更新 key1
+            cache.set('key3', 'value3'); // 这应该移除 key2
+            expect(cache.has('key1')).toBe(true);
+            expect(cache.get('key1')).toBe('updated_value1');
+            expect(cache.has('key2')).toBe(false);
+            expect(cache.has('key3')).toBe(true);
+        });
+    });
+    describe('遍历方法', () => {
+        it('应该返回正确的键列表（按使用顺序）', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            cache.get('key1'); // 使 key1 成为最近使用的
+            const keys = cache.keys();
+            expect(keys).toEqual(['key1', 'key3', 'key2']);
+        });
+        it('应该返回正确的值列表（按使用顺序）', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            cache.get('key1'); // 使 key1 成为最近使用的
+            const values = cache.values();
+            expect(values).toEqual(['value1', 'value3', 'value2']);
+        });
+        it('应该返回正确的键值对列表（按使用顺序）', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            cache.get('key1'); // 使 key1 成为最近使用的
+            const entries = cache.entries();
+            expect(entries).toEqual([
+                ['key1', 'value1'],
+                ['key3', 'value3'],
+                ['key2', 'value2']
+            ]);
+        });
+        it('应该在空缓存时返回空数组', () => {
+            const cache = new LruCache(3);
+            expect(cache.keys()).toEqual([]);
+            expect(cache.values()).toEqual([]);
+            expect(cache.entries()).toEqual([]);
+        });
+    });
+    describe('边界情况', () => {
+        it('应该处理容量为1的缓存', () => {
+            const cache = new LruCache(1);
+            cache.set('key1', 'value1');
+            expect(cache.get('key1')).toBe('value1');
+            cache.set('key2', 'value2');
+            expect(cache.has('key1')).toBe(false);
+            expect(cache.get('key2')).toBe('value2');
+            expect(cache.size).toBe(1);
+        });
+        it('应该处理大量的操作', () => {
+            const cache = new LruCache(100);
+            // 添加200个项目
+            for (let i = 0; i < 200; i++) {
+                cache.set(`key${i}`, i);
+            }
+            expect(cache.size).toBe(100);
+            // 前100个应该被移除
+            for (let i = 0; i < 100; i++) {
+                expect(cache.has(`key${i}`)).toBe(false);
+            }
+            // 后100个应该存在
+            for (let i = 100; i < 200; i++) {
+                expect(cache.has(`key${i}`)).toBe(true);
+                expect(cache.get(`key${i}`)).toBe(i);
+            }
+        });
+        it('应该处理复杂的对象类型', () => {
+            const cache = new LruCache(3);
+            const obj1 = { id: 1, name: 'test1', data: { count: 10 } };
+            const obj2 = { id: 2, name: 'test2', data: { count: 20 } };
+            cache.set('obj1', obj1);
+            cache.set('obj2', obj2);
+            expect(cache.get('obj1')).toEqual(obj1);
+            expect(cache.get('obj2')).toEqual(obj2);
+        });
+        it('应该处理null和undefined值', () => {
+            const cache = new LruCache(3);
+            cache.set('null', null);
+            cache.set('undefined', undefined);
+            expect(cache.get('null')).toBeNull();
+            expect(cache.get('undefined')).toBeUndefined();
+            expect(cache.has('null')).toBe(true);
+            expect(cache.has('undefined')).toBe(true);
+        });
+    });
+    describe('性能和内存', () => {
+        it('应该在删除后正确管理内存', () => {
+            const cache = new LruCache(3);
+            cache.set('key1', 'value1');
+            cache.set('key2', 'value2');
+            cache.set('key3', 'value3');
+            expect(cache.size).toBe(3);
+            cache.delete('key2');
+            expect(cache.size).toBe(2);
+            expect(cache.keys()).toEqual(['key3', 'key1']);
+        });
+        it('应该正确处理连续的相同键设置', () => {
+            const cache = new LruCache(2);
+            cache.set('key1', 'value1');
+            cache.set('key1', 'value1_updated');
+            cache.set('key1', 'value1_final');
+            expect(cache.size).toBe(1);
+            expect(cache.get('key1')).toBe('value1_final');
+        });
+    });
+    describe('实际使用场景', () => {
+        it('应该能用作函数结果缓存', () => {
+            const cache = new LruCache(3);
+            let computeCount = 0;
+            function expensiveCompute(n) {
+                const cacheKey = `compute_${n}`;
+                if (cache.has(cacheKey)) {
+                    return cache.get(cacheKey);
+                }
+                computeCount++;
+                const result = n * n; // 模拟昂贵的计算
+                cache.set(cacheKey, result);
+                return result;
+            }
+            // 第一次计算
+            expect(expensiveCompute(5)).toBe(25);
+            expect(computeCount).toBe(1);
+            // 缓存命中
+            expect(expensiveCompute(5)).toBe(25);
+            expect(computeCount).toBe(1);
+            // 新的计算
+            expect(expensiveCompute(6)).toBe(36);
+            expect(computeCount).toBe(2);
+        });
+        it('应该能用作API响应缓存', () => {
+            const cache = new LruCache(10);
+            const mockApiResponse = {
+                data: [{ id: 1, name: 'test' }],
+                timestamp: Date.now()
+            };
+            cache.set('/api/users', mockApiResponse);
+            const cachedResponse = cache.get('/api/users');
+            expect(cachedResponse).toEqual(mockApiResponse);
+            expect(cachedResponse?.data).toHaveLength(1);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-base",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "author": "Alain",
   "license": "ISC",
   "description": "",