@taicode/common-base 3.7.7 → 3.7.8

package/output/logger/transport.js

@@ -0,0 +1,153 @@
+import { RingCache } from '../ring-cache/index.js';
+/**
+ * 内存 LogTransport 实现
+ * 将结构化日志数据存储在内存中，支持查询和分析
+ * 使用RingCache实现高效的FIFO行为
+ */
+export class MemoryTransport {
+    name = 'memory';
+    level;
+    enabled = true;
+    cache;
+    static LOG_LEVELS = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+    constructor(options = {}) {
+        this.level = options.level;
+        this.enabled = options.enabled ?? true;
+        this.cache = new RingCache({
+            capacity: options.maxRecords ?? 1000
+        });
+    }
+    /**
+     * 检查是否应该处理此级别的日志
+     */
+    shouldLog(level) {
+        if (!this.enabled) {
+            return false;
+        }
+        if (!this.level) {
+            return true;
+        }
+        const currentIndex = MemoryTransport.LOG_LEVELS.indexOf(level);
+        const minIndex = MemoryTransport.LOG_LEVELS.indexOf(this.level);
+        return currentIndex >= minIndex;
+    }
+    log(record) {
+        if (!this.shouldLog(record.level)) {
+            return;
+        }
+        this.cache.add(record);
+    }
+    /**
+     * 获取所有日志记录
+     */
+    getRecords() {
+        return this.cache.getAll().map(entry => ({
+            ...entry.data,
+            id: entry.id
+        }));
+    }
+    /**
+     * 根据级别获取日志记录
+     */
+    getRecordsByLevel(level) {
+        return this.cache.search(entry => entry.data.level === level)
+            .map(entry => ({
+            ...entry.data,
+            id: entry.id
+        }));
+    }
+    /**
+     * 根据时间范围获取日志记录
+     */
+    getRecordsByTimeRange(start, end) {
+        return this.cache.getByTimeRange(start, end)
+            .map(entry => ({
+            ...entry.data,
+            id: entry.id
+        }));
+    }
+    /**
+     * 搜索日志记录
+     * @param predicate 搜索条件函数
+     */
+    searchRecords(predicate) {
+        return this.getRecords().filter(predicate);
+    }
+    /**
+     * 根据参数内容搜索
+     * @param searchText 搜索文本
+     */
+    searchByContent(searchText) {
+        const lowerSearchText = searchText.toLowerCase();
+        return this.cache.search(entry => entry.data.args.some(arg => {
+            if (typeof arg === 'string') {
+                return arg.toLowerCase().includes(lowerSearchText);
+            }
+            if (typeof arg === 'object' && arg !== null) {
+                try {
+                    return JSON.stringify(arg).toLowerCase().includes(lowerSearchText);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return false;
+        })).map(entry => ({
+            ...entry.data,
+            id: entry.id
+        }));
+    }
+    /**
+     * 获取最近的 N 条记录
+     */
+    getRecentRecords(count) {
+        return this.cache.getRecent(count).map(entry => ({
+            ...entry.data,
+            id: entry.id
+        }));
+    }
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        const cacheStats = this.cache.getStats();
+        const all = this.cache.getAll();
+        const stats = {
+            total: cacheStats.size,
+            byLevel: {
+                debug: 0,
+                info: 0,
+                warn: 0,
+                error: 0
+            },
+            oldestTimestamp: cacheStats.oldestTimestamp,
+            newestTimestamp: cacheStats.newestTimestamp
+        };
+        if (all.length === 0) {
+            return stats;
+        }
+        // 统计各级别数量
+        all.forEach(entry => {
+            stats.byLevel[entry.data.level]++;
+        });
+        return stats;
+    }
+    /**
+     * 清空所有记录
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * 导出为 JSON 格式
+     */
+    exportToJSON() {
+        return JSON.stringify(this.getRecords(), null, 2);
+    }
+    /**
+     * 关闭 LogTransport
+     */
+    close() {
+        this.clear();
+    }
+}

package/output/logger/transport.test.d.ts

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

package/output/logger/transport.test.d.ts.map

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

package/output/logger/transport.test.js

@@ -0,0 +1,309 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MemoryTransport } from './transport.js';
+// 创建一个测试用的 Transport 实现
+class TestTransport {
+    name;
+    level;
+    enabled = true;
+    loggedRecords = [];
+    static LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+    constructor(name = 'test', options = {}) {
+        this.name = name;
+        this.level = options.level;
+        this.enabled = options.enabled ?? true;
+    }
+    shouldLog(level) {
+        if (!this.enabled) {
+            return false;
+        }
+        if (!this.level) {
+            return true;
+        }
+        const currentIndex = TestTransport.LOG_LEVELS.indexOf(level);
+        const minIndex = TestTransport.LOG_LEVELS.indexOf(this.level);
+        return currentIndex >= minIndex;
+    }
+    log(record) {
+        if (!this.shouldLog(record.level)) {
+            return;
+        }
+        this.loggedRecords.push(record);
+    }
+    clear() {
+        this.loggedRecords = [];
+    }
+}
+describe('TestTransport', () => {
+    let transport;
+    beforeEach(() => {
+        transport = new TestTransport();
+    });
+    describe('基本功能', () => {
+        it('应该有正确的名称', () => {
+            expect(transport.name).toBe('test');
+        });
+        it('应该默认启用', () => {
+            expect(transport.enabled).toBe(true);
+        });
+        it('应该记录日志', () => {
+            const record = {
+                level: 'info',
+                timestamp: new Date(),
+                args: ['测试消息']
+            };
+            transport.log(record);
+            expect(transport.loggedRecords).toHaveLength(1);
+            expect(transport.loggedRecords[0]).toEqual(record);
+        });
+    });
+    describe('日志级别控制', () => {
+        it('应该遵守最低日志级别', () => {
+            transport = new TestTransport('test', { level: 'warn' });
+            const debugRecord = {
+                level: 'debug',
+                timestamp: new Date(),
+                args: ['debug消息']
+            };
+            const warnRecord = {
+                level: 'warn',
+                timestamp: new Date(),
+                args: ['warn消息']
+            };
+            transport.log(debugRecord);
+            transport.log(warnRecord);
+            expect(transport.loggedRecords).toHaveLength(1);
+            expect(transport.loggedRecords[0].level).toBe('warn');
+        });
+        it('应该记录等于或高于最低级别的日志', () => {
+            transport = new TestTransport('test', { level: 'info' });
+            const levels = ['debug', 'info', 'warn', 'error'];
+            levels.forEach(level => {
+                transport.log({
+                    level,
+                    timestamp: new Date(),
+                    args: [`${level}消息`]
+                });
+            });
+            expect(transport.loggedRecords).toHaveLength(3); // info, warn, error
+            expect(transport.loggedRecords.map(r => r.level)).toEqual(['info', 'warn', 'error']);
+        });
+    });
+    describe('启用状态控制', () => {
+        it('应该在禁用时不记录日志', () => {
+            transport = new TestTransport('test', { enabled: false });
+            transport.log({
+                level: 'error',
+                timestamp: new Date(),
+                args: ['错误消息']
+            });
+            expect(transport.loggedRecords).toHaveLength(0);
+        });
+        it('应该支持动态启用/禁用', () => {
+            const record = {
+                level: 'info',
+                timestamp: new Date(),
+                args: ['测试消息']
+            };
+            transport.enabled = false;
+            transport.log(record);
+            expect(transport.loggedRecords).toHaveLength(0);
+            transport.enabled = true;
+            transport.log(record);
+            expect(transport.loggedRecords).toHaveLength(1);
+        });
+    });
+});
+describe('MemoryTransport', () => {
+    let memoryTransport;
+    beforeEach(() => {
+        memoryTransport = new MemoryTransport();
+    });
+    describe('基本功能', () => {
+        it('应该有正确的名称', () => {
+            expect(memoryTransport.name).toBe('memory');
+        });
+        it('应该存储日志记录', () => {
+            const record = {
+                level: 'info',
+                timestamp: new Date(),
+                args: ['测试消息', { data: 'value' }],
+                metadata: { source: 'test' }
+            };
+            memoryTransport.log(record);
+            const records = memoryTransport.getRecords();
+            expect(records).toHaveLength(1);
+            expect(records[0].level).toBe('info');
+            expect(records[0].args).toEqual(['测试消息', { data: 'value' }]);
+            expect(records[0].metadata).toEqual({ source: 'test' });
+            expect(records[0].id).toBeDefined();
+        });
+        it('应该生成唯一ID', () => {
+            const record1 = {
+                level: 'info',
+                timestamp: new Date(),
+                args: ['消息1']
+            };
+            const record2 = {
+                level: 'info',
+                timestamp: new Date(),
+                args: ['消息2']
+            };
+            memoryTransport.log(record1);
+            memoryTransport.log(record2);
+            const records = memoryTransport.getRecords();
+            expect(records[0].id).not.toBe(records[1].id);
+        });
+    });
+    describe('容量管理', () => {
+        it('应该遵守最大记录数限制', () => {
+            memoryTransport = new MemoryTransport({ maxRecords: 3 });
+            // 添加4条记录
+            for (let i = 0; i < 4; i++) {
+                memoryTransport.log({
+                    level: 'info',
+                    timestamp: new Date(),
+                    args: [`消息${i}`]
+                });
+            }
+            const records = memoryTransport.getRecords();
+            expect(records).toHaveLength(3);
+            // 应该保留最新的3条记录
+            expect(records.map(r => r.args[0])).toEqual(['消息1', '消息2', '消息3']);
+        });
+        it('应该支持自定义最大记录数', () => {
+            memoryTransport = new MemoryTransport({ maxRecords: 1 });
+            memoryTransport.log({
+                level: 'info',
+                timestamp: new Date(),
+                args: ['第一条']
+            });
+            memoryTransport.log({
+                level: 'info',
+                timestamp: new Date(),
+                args: ['第二条']
+            });
+            const records = memoryTransport.getRecords();
+            expect(records).toHaveLength(1);
+            expect(records[0].args[0]).toBe('第二条');
+        });
+    });
+    describe('查询功能', () => {
+        beforeEach(() => {
+            // 添加测试数据
+            const testData = [
+                { level: 'debug', args: ['调试消息'] },
+                { level: 'info', args: ['信息消息', { type: 'user' }] },
+                { level: 'warn', args: ['警告消息'] },
+                { level: 'error', args: ['错误消息', new Error('测试错误')] },
+                { level: 'info', args: ['另一条信息'] }
+            ];
+            testData.forEach(data => {
+                memoryTransport.log({
+                    level: data.level,
+                    timestamp: new Date(),
+                    args: data.args
+                });
+            });
+        });
+        it('应该根据级别筛选记录', () => {
+            const infoRecords = memoryTransport.getRecordsByLevel('info');
+            expect(infoRecords).toHaveLength(2);
+            expect(infoRecords.every(r => r.level === 'info')).toBe(true);
+            const errorRecords = memoryTransport.getRecordsByLevel('error');
+            expect(errorRecords).toHaveLength(1);
+            expect(errorRecords[0].level).toBe('error');
+        });
+        it('应该根据时间范围筛选记录', () => {
+            const now = new Date();
+            const oneMinuteAgo = new Date(now.getTime() - 60000);
+            const oneMinuteLater = new Date(now.getTime() + 60000);
+            const records = memoryTransport.getRecordsByTimeRange(oneMinuteAgo, oneMinuteLater);
+            expect(records.length).toBeGreaterThan(0);
+        });
+        it('应该支持内容搜索', () => {
+            const results = memoryTransport.searchByContent('调试');
+            expect(results).toHaveLength(1);
+            expect(results[0].args[0]).toContain('调试');
+            const typeResults = memoryTransport.searchByContent('user');
+            expect(typeResults).toHaveLength(1);
+            expect(typeResults[0].args[1]).toEqual({ type: 'user' });
+        });
+        it('应该支持自定义搜索条件', () => {
+            const errorResults = memoryTransport.searchRecords(record => record.args.some(arg => arg instanceof Error));
+            expect(errorResults).toHaveLength(1);
+            expect(errorResults[0].level).toBe('error');
+        });
+        it('应该获取最近的记录', () => {
+            const recent = memoryTransport.getRecentRecords(2);
+            expect(recent).toHaveLength(2);
+            expect(recent[0].args[0]).toContain('错误消息');
+            expect(recent[1].args[0]).toContain('另一条信息');
+        });
+    });
+    describe('统计功能', () => {
+        beforeEach(() => {
+            // 添加不同级别的日志
+            memoryTransport.log({ level: 'debug', timestamp: new Date(), args: ['debug1'] });
+            memoryTransport.log({ level: 'debug', timestamp: new Date(), args: ['debug2'] });
+            memoryTransport.log({ level: 'info', timestamp: new Date(), args: ['info1'] });
+            memoryTransport.log({ level: 'warn', timestamp: new Date(), args: ['warn1'] });
+            memoryTransport.log({ level: 'error', timestamp: new Date(), args: ['error1'] });
+        });
+        it('应该提供正确的统计信息', () => {
+            const stats = memoryTransport.getStats();
+            expect(stats.total).toBe(5);
+            expect(stats.byLevel.debug).toBe(2);
+            expect(stats.byLevel.info).toBe(1);
+            expect(stats.byLevel.warn).toBe(1);
+            expect(stats.byLevel.error).toBe(1);
+            expect(stats.oldestTimestamp).toBeDefined();
+            expect(stats.newestTimestamp).toBeDefined();
+        });
+        it('应该处理空记录的统计', () => {
+            memoryTransport.clear();
+            const stats = memoryTransport.getStats();
+            expect(stats.total).toBe(0);
+            expect(stats.byLevel.debug).toBe(0);
+            expect(stats.oldestTimestamp).toBeUndefined();
+            expect(stats.newestTimestamp).toBeUndefined();
+        });
+    });
+    describe('导出功能', () => {
+        beforeEach(() => {
+            memoryTransport.log({
+                level: 'info',
+                timestamp: new Date('2023-01-01T00:00:00.000Z'),
+                args: ['测试消息', { data: 'value' }]
+            });
+        });
+        it('应该导出为 JSON 格式', () => {
+            const json = memoryTransport.exportToJSON();
+            const parsed = JSON.parse(json);
+            expect(Array.isArray(parsed)).toBe(true);
+            expect(parsed).toHaveLength(1);
+            expect(parsed[0].level).toBe('info');
+            expect(parsed[0].args).toEqual(['测试消息', { data: 'value' }]);
+        });
+    });
+    describe('清理功能', () => {
+        it('应该清空所有记录', () => {
+            memoryTransport.log({
+                level: 'info',
+                timestamp: new Date(),
+                args: ['测试消息']
+            });
+            expect(memoryTransport.getRecords()).toHaveLength(1);
+            memoryTransport.clear();
+            expect(memoryTransport.getRecords()).toHaveLength(0);
+        });
+        it('应该在关闭时清理资源', () => {
+            memoryTransport.log({
+                level: 'info',
+                timestamp: new Date(),
+                args: ['测试消息']
+            });
+            memoryTransport.close();
+            expect(memoryTransport.getRecords()).toHaveLength(0);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export { LruCache } from './lru-cache.js';
+//# 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,gBAAgB,CAAA"}

package/output/lru-cache/index.js

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

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":""}