@taicode/common-base 1.2.0 → 1.4.0

package/output/logger/transport.test.js

@@ -0,0 +1,309 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryTransport } from './transport';
+// 创建一个测试用的 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/ring-cache/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ring Cache 模块
+ * 专门用于日志场景的FIFO环形缓存
+ */
+export * from './ring-cache';
+//# sourceMappingURL=index.d.ts.map

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

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

package/output/ring-cache/index.js

@@ -0,0 +1,5 @@
+/**
+ * Ring Cache 模块
+ * 专门用于日志场景的FIFO环形缓存
+ */
+export * from './ring-cache';

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

@@ -0,0 +1,125 @@
+/**
+ * 环形缓存（Ring Cache）实现
+ * 专门用于日志场景的FIFO（先进先出）缓存
+ *
+ * 特点：
+ * - FIFO行为：新数据总是添加到尾部，当容量满时从头部移除旧数据
+ * - 固定容量：避免内存无限增长
+ * - 高效操作：O(1)的添加和访问操作
+ * - 适用场景：日志记录、事件历史、时间序列数据等
+ */
+/**
+ * 环形缓存配置选项
+ */
+export interface RingCacheOptions {
+    /** 缓存容量，默认为1000 */
+    capacity?: number;
+}
+/**
+ * 环形缓存条目
+ */
+export interface RingCacheEntry<T> {
+    /** 数据 */
+    data: T;
+    /** 添加时间戳 */
+    timestamp: Date;
+    /** 条目ID */
+    id: string;
+}
+/**
+ * 环形缓存统计信息
+ */
+export interface RingCacheStats {
+    /** 当前条目数量 */
+    size: number;
+    /** 缓存容量 */
+    capacity: number;
+    /** 是否已满 */
+    isFull: boolean;
+    /** 最旧条目的时间戳 */
+    oldestTimestamp?: Date;
+    /** 最新条目的时间戳 */
+    newestTimestamp?: Date;
+    /** 总共添加的条目数（包括已被覆盖的） */
+    totalAdded: number;
+}
+/**
+ * 环形缓存实现
+ * 使用固定大小的数组实现FIFO行为的环形缓存
+ */
+export declare class RingCache<T> {
+    private buffer;
+    private head;
+    private tail;
+    private size;
+    private capacity;
+    private totalAdded;
+    private nextId;
+    constructor(options?: RingCacheOptions);
+    /**
+     * 添加新条目到缓存
+     * 如果缓存已满，将覆盖最旧的条目
+     */
+    add(data: T): RingCacheEntry<T>;
+    /**
+     * 获取所有缓存条目（按添加顺序）
+     */
+    getAll(): RingCacheEntry<T>[];
+    /**
+     * 获取最近的N个条目
+     */
+    getRecent(count: number): RingCacheEntry<T>[];
+    /**
+     * 获取最旧的N个条目
+     */
+    getOldest(count: number): RingCacheEntry<T>[];
+    /**
+     * 根据时间范围获取条目
+     */
+    getByTimeRange(start: Date, end: Date): RingCacheEntry<T>[];
+    /**
+     * 搜索满足条件的条目
+     */
+    search(predicate: (entry: RingCacheEntry<T>) => boolean): RingCacheEntry<T>[];
+    /**
+     * 获取缓存统计信息
+     */
+    getStats(): RingCacheStats;
+    /**
+     * 检查缓存是否为空
+     */
+    isEmpty(): boolean;
+    /**
+     * 检查缓存是否已满
+     */
+    isFull(): boolean;
+    /**
+     * 获取当前缓存大小
+     */
+    getSize(): number;
+    /**
+     * 获取缓存容量
+     */
+    getCapacity(): number;
+    /**
+     * 清空缓存
+     */
+    clear(): void;
+    /**
+     * 导出为数组格式
+     */
+    toArray(): T[];
+    /**
+     * 导出为JSON格式
+     */
+    toJSON(): string;
+    /**
+     * 生成唯一ID
+     */
+    private generateId;
+    /**
+     * 创建迭代器，支持for...of语法
+     */
+    [Symbol.iterator](): Iterator<RingCacheEntry<T>>;
+}
+//# sourceMappingURL=ring-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ring-cache.d.ts","sourceRoot":"","sources":["../../source/ring-cache/ring-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,SAAS;IACT,IAAI,EAAE,CAAC,CAAA;IACP,YAAY;IACZ,SAAS,EAAE,IAAI,CAAA;IACf,WAAW;IACX,EAAE,EAAE,MAAM,CAAA;CACX;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW;IACX,MAAM,EAAE,OAAO,CAAA;IACf,eAAe;IACf,eAAe,CAAC,EAAE,IAAI,CAAA;IACtB,eAAe;IACf,eAAe,CAAC,EAAE,IAAI,CAAA;IACtB,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAY;gBAEd,OAAO,GAAE,gBAAqB;IAQ1C;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAqB/B;;OAEG;IACH,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,EAAE;IAkB7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAoB7C;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAmB7C;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAM3D;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAI7E;;OAEG;IACH,QAAQ,IAAI,cAAc;IAa1B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,OAAO,IAAI,CAAC,EAAE;IAId;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CASlD"}

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

@@ -0,0 +1,197 @@
+/**
+ * 环形缓存（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

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

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

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