flongo 1.0.1 → 1.1.0

package/dist/cache/cacheStats.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheMonitor = exports.CacheStatsCollector = void 0;
+exports.getGlobalCacheMonitor = getGlobalCacheMonitor;
+exports.resetGlobalCacheMonitor = resetGlobalCacheMonitor;
+class CacheStatsCollector {
+    constructor(maxHistorySize = 1000) {
+        this.startTime = Date.now();
+        this.lastResetTime = Date.now();
+        this.maxHistorySize = maxHistorySize;
+        this.metrics = {
+            operationCounts: new Map(),
+            operationLatencies: new Map(),
+            collectionStats: new Map(),
+            keyAccessCounts: new Map(),
+            memoryUsageOverTime: []
+        };
+    }
+    recordOperation(operation, latencyMs) {
+        const count = this.metrics.operationCounts.get(operation) || 0;
+        this.metrics.operationCounts.set(operation, count + 1);
+        let latencies = this.metrics.operationLatencies.get(operation);
+        if (!latencies) {
+            latencies = [];
+            this.metrics.operationLatencies.set(operation, latencies);
+        }
+        latencies.push(latencyMs);
+        if (latencies.length > this.maxHistorySize) {
+            latencies.shift();
+        }
+    }
+    recordKeyAccess(key) {
+        const count = this.metrics.keyAccessCounts.get(key) || 0;
+        this.metrics.keyAccessCounts.set(key, count + 1);
+    }
+    recordMemoryUsage(usageBytes) {
+        const entry = {
+            timestamp: Date.now(),
+            usage: usageBytes
+        };
+        this.metrics.memoryUsageOverTime.push(entry);
+        if (this.metrics.memoryUsageOverTime.length > this.maxHistorySize) {
+            this.metrics.memoryUsageOverTime.shift();
+        }
+    }
+    updateCollectionStats(collection, stats) {
+        const existing = this.metrics.collectionStats.get(collection) || {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            sets: 0,
+            deletes: 0,
+            clears: 0,
+            size: 0
+        };
+        this.metrics.collectionStats.set(collection, {
+            ...existing,
+            ...stats
+        });
+    }
+    getDetailedStats(baseStats) {
+        const totalRequests = baseStats.hits + baseStats.misses;
+        const uptime = Math.max(1, Date.now() - this.startTime);
+        return {
+            ...baseStats,
+            hitRate: totalRequests > 0 ? baseStats.hits / totalRequests : 0,
+            missRate: totalRequests > 0 ? baseStats.misses / totalRequests : 0,
+            evictionRate: baseStats.sets > 0 ? baseStats.evictions / baseStats.sets : 0,
+            averageAccessTime: this.calculateAverageLatency('get'),
+            totalRequests,
+            uptime,
+            lastReset: this.lastResetTime
+        };
+    }
+    getOperationStats() {
+        const stats = new Map();
+        for (const [operation, count] of this.metrics.operationCounts.entries()) {
+            const latencies = this.metrics.operationLatencies.get(operation) || [];
+            if (latencies.length === 0) {
+                stats.set(operation, {
+                    count,
+                    averageLatency: 0,
+                    p50: 0,
+                    p95: 0,
+                    p99: 0
+                });
+                continue;
+            }
+            const sorted = [...latencies].sort((a, b) => a - b);
+            stats.set(operation, {
+                count,
+                averageLatency: this.calculateAverage(latencies),
+                p50: this.calculatePercentile(sorted, 0.5),
+                p95: this.calculatePercentile(sorted, 0.95),
+                p99: this.calculatePercentile(sorted, 0.99)
+            });
+        }
+        return stats;
+    }
+    getTopKeys(limit = 10) {
+        const entries = Array.from(this.metrics.keyAccessCounts.entries());
+        return entries
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, limit)
+            .map(([key, count]) => ({ key, count }));
+    }
+    getMemoryTrend() {
+        return [...this.metrics.memoryUsageOverTime];
+    }
+    getCollectionStats() {
+        return new Map(this.metrics.collectionStats);
+    }
+    reset() {
+        this.lastResetTime = Date.now();
+        this.metrics = {
+            operationCounts: new Map(),
+            operationLatencies: new Map(),
+            collectionStats: new Map(),
+            keyAccessCounts: new Map(),
+            memoryUsageOverTime: []
+        };
+    }
+    calculateAverage(values) {
+        if (values.length === 0)
+            return 0;
+        const sum = values.reduce((a, b) => a + b, 0);
+        return sum / values.length;
+    }
+    calculatePercentile(sortedValues, percentile) {
+        if (sortedValues.length === 0)
+            return 0;
+        const index = Math.ceil(sortedValues.length * percentile) - 1;
+        return sortedValues[Math.max(0, Math.min(index, sortedValues.length - 1))];
+    }
+    calculateAverageLatency(operation) {
+        const latencies = this.metrics.operationLatencies.get(operation);
+        if (!latencies || latencies.length === 0)
+            return 0;
+        return this.calculateAverage(latencies);
+    }
+    toJSON() {
+        const operationStats = Object.fromEntries(this.getOperationStats());
+        const collectionStats = Object.fromEntries(this.getCollectionStats());
+        return {
+            uptime: Date.now() - this.startTime,
+            lastReset: this.lastResetTime,
+            operations: operationStats,
+            collections: collectionStats,
+            topKeys: this.getTopKeys(10),
+            memoryTrend: this.getMemoryTrend().slice(-100)
+        };
+    }
+}
+exports.CacheStatsCollector = CacheStatsCollector;
+class CacheMonitor {
+    constructor() {
+        this.collectors = new Map();
+        this.globalCollector = new CacheStatsCollector();
+    }
+    getCollector(name) {
+        let collector = this.collectors.get(name);
+        if (!collector) {
+            collector = new CacheStatsCollector();
+            this.collectors.set(name, collector);
+        }
+        return collector;
+    }
+    getGlobalCollector() {
+        return this.globalCollector;
+    }
+    startMonitoring(intervalMs = 60000, callback) {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(() => {
+            const stats = this.getSnapshot();
+            if (callback) {
+                callback(stats);
+            }
+        }, intervalMs);
+        if (this.intervalId.unref) {
+            this.intervalId.unref();
+        }
+    }
+    stopMonitoring() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    getSnapshot() {
+        const snapshot = {
+            timestamp: Date.now(),
+            global: this.globalCollector.toJSON(),
+            caches: {}
+        };
+        for (const [name, collector] of this.collectors.entries()) {
+            snapshot.caches[name] = collector.toJSON();
+        }
+        return snapshot;
+    }
+    reset() {
+        this.globalCollector.reset();
+        for (const collector of this.collectors.values()) {
+            collector.reset();
+        }
+    }
+    destroy() {
+        this.stopMonitoring();
+        this.collectors.clear();
+    }
+}
+exports.CacheMonitor = CacheMonitor;
+let globalMonitor;
+function getGlobalCacheMonitor() {
+    if (!globalMonitor) {
+        globalMonitor = new CacheMonitor();
+    }
+    return globalMonitor;
+}
+function resetGlobalCacheMonitor() {
+    if (globalMonitor) {
+        globalMonitor.destroy();
+        globalMonitor = undefined;
+    }
+}
+//# sourceMappingURL=cacheStats.js.map

package/dist/cache/cacheStore.d.ts

@@ -0,0 +1,50 @@
+export interface CacheEntry<T> {
+    value: T;
+    ttl?: number;
+    createdAt: number;
+    lastAccessedAt: number;
+    accessCount: number;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    sets: number;
+    deletes: number;
+    clears: number;
+    size: number;
+    memoryUsage?: number;
+}
+export interface CacheStore<T> {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    size(): Promise<number>;
+    keys(): Promise<string[]>;
+    getStats(): Promise<CacheStats>;
+    resetStats(): Promise<void>;
+}
+export interface CacheStoreOptions {
+    maxEntries?: number;
+    defaultTTL?: number;
+    enableStats?: boolean;
+    onEviction?: <T>(key: string, value: T) => void;
+}
+export declare abstract class BaseCacheStore<T> implements CacheStore<T> {
+    protected stats: CacheStats;
+    protected options: Required<CacheStoreOptions>;
+    constructor(options?: CacheStoreOptions);
+    abstract get(key: string): Promise<T | undefined>;
+    abstract set(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    abstract delete(key: string): Promise<boolean>;
+    abstract clear(): Promise<void>;
+    abstract has(key: string): Promise<boolean>;
+    abstract size(): Promise<number>;
+    abstract keys(): Promise<string[]>;
+    getStats(): Promise<CacheStats>;
+    resetStats(): Promise<void>;
+    protected incrementStat(stat: keyof CacheStats, amount?: number): void;
+}
+//# sourceMappingURL=cacheStore.d.ts.map

package/dist/cache/cacheStore.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCacheStore = void 0;
+class BaseCacheStore {
+    constructor(options = {}) {
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            sets: 0,
+            deletes: 0,
+            clears: 0,
+            size: 0,
+            memoryUsage: 0
+        };
+        this.options = {
+            maxEntries: options.maxEntries ?? 10000,
+            defaultTTL: options.defaultTTL ?? 300,
+            enableStats: options.enableStats ?? true,
+            onEviction: options.onEviction ?? (() => { })
+        };
+    }
+    async getStats() {
+        if (!this.options.enableStats) {
+            return {
+                hits: 0,
+                misses: 0,
+                evictions: 0,
+                sets: 0,
+                deletes: 0,
+                clears: 0,
+                size: await this.size(),
+                memoryUsage: 0
+            };
+        }
+        return { ...this.stats, size: await this.size() };
+    }
+    async resetStats() {
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            sets: 0,
+            deletes: 0,
+            clears: 0,
+            size: 0,
+            memoryUsage: 0
+        };
+    }
+    incrementStat(stat, amount = 1) {
+        if (this.options.enableStats && typeof this.stats[stat] === 'number') {
+            this.stats[stat] += amount;
+        }
+    }
+}
+exports.BaseCacheStore = BaseCacheStore;
+//# sourceMappingURL=cacheStore.js.map

package/dist/cache/cacheStrategies.d.ts

@@ -0,0 +1,61 @@
+import { CacheStore } from './cacheStore';
+import { ICollectionQuery } from '../types';
+export declare enum InvalidationStrategy {
+    TTL = "ttl",
+    LRU = "lru",
+    Manual = "manual",
+    Smart = "smart"
+}
+export interface InvalidationRule {
+    strategy: InvalidationStrategy;
+    pattern?: string;
+    ttlSeconds?: number;
+    maxAge?: number;
+    dependencies?: string[];
+}
+export interface InvalidationOptions<T = unknown> {
+    collection: string;
+    operation: 'create' | 'update' | 'delete' | 'batchCreate' | 'batchUpdate' | 'batchDelete';
+    ids?: string[];
+    query?: ICollectionQuery;
+    data?: T;
+}
+export declare class CacheInvalidator<T = unknown> {
+    private cache;
+    private rules;
+    private dependencies;
+    constructor(cache: CacheStore<T>);
+    addRule(pattern: string, rule: InvalidationRule): void;
+    invalidate(options: InvalidationOptions<T>): Promise<void>;
+    invalidatePattern(pattern: string): Promise<void>;
+    invalidateCollection(collection: string): Promise<void>;
+    invalidateOperation(collection: string, operation: string): Promise<void>;
+    smartInvalidate(options: InvalidationOptions<T>): Promise<void>;
+    private findAffectedKeys;
+    private isKeyAffected;
+    private invalidateByIds;
+    private invalidateByQuery;
+    private invalidateListQueries;
+    private invalidateCountQueries;
+    private invalidateRelatedQueries;
+    private invalidateDependencies;
+    private patternToRegex;
+}
+export declare class TTLStrategy {
+    private defaultTTL;
+    private customTTLs;
+    constructor(defaultTTLSeconds?: number);
+    setTTL(pattern: string, ttlSeconds: number): void;
+    getTTL(key: string): number;
+    private patternToRegex;
+}
+export declare class LRUStrategy {
+    private maxEntries;
+    private maxMemoryMB;
+    constructor(maxEntries?: number, maxMemoryMB?: number);
+    getMaxEntries(): number;
+    getMaxMemoryMB(): number;
+    setMaxEntries(max: number): void;
+    setMaxMemoryMB(max: number): void;
+}
+//# sourceMappingURL=cacheStrategies.d.ts.map

package/dist/cache/cacheStrategies.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUStrategy = exports.TTLStrategy = exports.CacheInvalidator = exports.InvalidationStrategy = void 0;
+const cacheKeyGenerator_1 = require("./cacheKeyGenerator");
+var InvalidationStrategy;
+(function (InvalidationStrategy) {
+    InvalidationStrategy["TTL"] = "ttl";
+    InvalidationStrategy["LRU"] = "lru";
+    InvalidationStrategy["Manual"] = "manual";
+    InvalidationStrategy["Smart"] = "smart";
+})(InvalidationStrategy || (exports.InvalidationStrategy = InvalidationStrategy = {}));
+class CacheInvalidator {
+    constructor(cache) {
+        this.cache = cache;
+        this.rules = new Map();
+        this.dependencies = new Map();
+    }
+    addRule(pattern, rule) {
+        const rules = this.rules.get(pattern) || [];
+        rules.push(rule);
+        this.rules.set(pattern, rules);
+        if (rule.dependencies) {
+            for (const dep of rule.dependencies) {
+                const deps = this.dependencies.get(dep) || new Set();
+                deps.add(pattern);
+                this.dependencies.set(dep, deps);
+            }
+        }
+    }
+    async invalidate(options) {
+        const affectedKeys = await this.findAffectedKeys(options);
+        for (const key of affectedKeys) {
+            await this.cache.delete(key);
+        }
+        await this.invalidateDependencies(options);
+    }
+    async invalidatePattern(pattern) {
+        const keys = await this.cache.keys();
+        const regex = this.patternToRegex(pattern);
+        for (const key of keys) {
+            if (regex.test(key)) {
+                await this.cache.delete(key);
+            }
+        }
+    }
+    async invalidateCollection(collection) {
+        const pattern = cacheKeyGenerator_1.CacheKeyGenerator.generatePattern(collection);
+        await this.invalidatePattern(pattern);
+    }
+    async invalidateOperation(collection, operation) {
+        const pattern = cacheKeyGenerator_1.CacheKeyGenerator.generatePattern(collection, operation);
+        await this.invalidatePattern(pattern);
+    }
+    async smartInvalidate(options) {
+        switch (options.operation) {
+            case 'create':
+            case 'batchCreate':
+                await this.invalidateListQueries(options.collection);
+                await this.invalidateCountQueries(options.collection);
+                break;
+            case 'update':
+                if (options.ids && options.ids.length > 0) {
+                    await this.invalidateByIds(options.collection, options.ids);
+                }
+                await this.invalidateRelatedQueries(options);
+                break;
+            case 'batchUpdate':
+                if (options.query) {
+                    await this.invalidateByQuery(options.collection, options.query);
+                }
+                else if (options.ids && options.ids.length > 0) {
+                    await this.invalidateByIds(options.collection, options.ids);
+                }
+                await this.invalidateListQueries(options.collection);
+                break;
+            case 'delete':
+            case 'batchDelete':
+                if (options.ids && options.ids.length > 0) {
+                    await this.invalidateByIds(options.collection, options.ids);
+                }
+                await this.invalidateListQueries(options.collection);
+                await this.invalidateCountQueries(options.collection);
+                break;
+        }
+    }
+    async findAffectedKeys(options) {
+        const keys = await this.cache.keys();
+        const affected = [];
+        for (const key of keys) {
+            if (this.isKeyAffected(key, options)) {
+                affected.push(key);
+            }
+        }
+        return affected;
+    }
+    isKeyAffected(key, options) {
+        if (!cacheKeyGenerator_1.CacheKeyGenerator.isFlongoKey(key)) {
+            return false;
+        }
+        const collection = cacheKeyGenerator_1.CacheKeyGenerator.getCollectionFromKey(key);
+        if (collection !== options.collection) {
+            return false;
+        }
+        const operation = cacheKeyGenerator_1.CacheKeyGenerator.getOperationFromKey(key);
+        switch (options.operation) {
+            case 'create':
+            case 'batchCreate':
+                return operation === 'getAll' ||
+                    operation === 'getSome' ||
+                    operation === 'count' ||
+                    operation === 'exists';
+            case 'update':
+            case 'batchUpdate':
+                return true;
+            case 'delete':
+            case 'batchDelete':
+                return true;
+            default:
+                return false;
+        }
+    }
+    async invalidateByIds(collection, ids) {
+        for (const id of ids) {
+            const key = cacheKeyGenerator_1.CacheKeyGenerator.generate({
+                collection,
+                operation: 'get',
+                id
+            });
+            await this.cache.delete(key);
+        }
+    }
+    async invalidateByQuery(collection, query) {
+        const keys = await this.cache.keys();
+        for (const key of keys) {
+            if (cacheKeyGenerator_1.CacheKeyGenerator.getCollectionFromKey(key) === collection) {
+                await this.cache.delete(key);
+            }
+        }
+    }
+    async invalidateListQueries(collection) {
+        const operations = ['getAll', 'getSome', 'getFirst'];
+        for (const op of operations) {
+            await this.invalidateOperation(collection, op);
+        }
+    }
+    async invalidateCountQueries(collection) {
+        await this.invalidateOperation(collection, 'count');
+        await this.invalidateOperation(collection, 'exists');
+    }
+    async invalidateRelatedQueries(options) {
+        if (!options.data) {
+            // If no data provided, invalidate all list queries for safety
+            await this.invalidateListQueries(options.collection);
+            return;
+        }
+        const keys = await this.cache.keys();
+        const changedFields = Object.keys(options.data);
+        for (const key of keys) {
+            if (cacheKeyGenerator_1.CacheKeyGenerator.getCollectionFromKey(key) === options.collection) {
+                const operation = cacheKeyGenerator_1.CacheKeyGenerator.getOperationFromKey(key);
+                // Only invalidate list queries since individual item queries are handled by invalidateByIds
+                if (operation === 'getAll' ||
+                    operation === 'getSome' ||
+                    operation === 'getFirst') {
+                    await this.cache.delete(key);
+                }
+            }
+        }
+    }
+    async invalidateDependencies(options) {
+        const pattern = `${options.collection}:*`;
+        const dependentPatterns = this.dependencies.get(pattern) || new Set();
+        for (const depPattern of dependentPatterns) {
+            await this.invalidatePattern(depPattern);
+        }
+    }
+    patternToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            .replace(/\\\*/g, '.*');
+        return new RegExp(`^${escaped}$`);
+    }
+}
+exports.CacheInvalidator = CacheInvalidator;
+class TTLStrategy {
+    constructor(defaultTTLSeconds = 300) {
+        this.defaultTTL = defaultTTLSeconds;
+        this.customTTLs = new Map();
+    }
+    setTTL(pattern, ttlSeconds) {
+        this.customTTLs.set(pattern, ttlSeconds);
+    }
+    getTTL(key) {
+        for (const [pattern, ttl] of this.customTTLs.entries()) {
+            const regex = this.patternToRegex(pattern);
+            if (regex.test(key)) {
+                return ttl;
+            }
+        }
+        return this.defaultTTL;
+    }
+    patternToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            .replace(/\\\*/g, '.*');
+        return new RegExp(`^${escaped}$`);
+    }
+}
+exports.TTLStrategy = TTLStrategy;
+class LRUStrategy {
+    constructor(maxEntries = 10000, maxMemoryMB = 100) {
+        this.maxEntries = maxEntries;
+        this.maxMemoryMB = maxMemoryMB;
+    }
+    getMaxEntries() {
+        return this.maxEntries;
+    }
+    getMaxMemoryMB() {
+        return this.maxMemoryMB;
+    }
+    setMaxEntries(max) {
+        this.maxEntries = max;
+    }
+    setMaxMemoryMB(max) {
+        this.maxMemoryMB = max;
+    }
+}
+exports.LRUStrategy = LRUStrategy;
+//# sourceMappingURL=cacheStrategies.js.map

package/dist/cache/index.d.ts

@@ -0,0 +1,7 @@
+export { CacheStore, CacheEntry, CacheStats, CacheStoreOptions, BaseCacheStore } from './cacheStore';
+export { MemoryCache, MemoryCacheOptions } from './memoryCache';
+export { CacheKeyGenerator, CacheKeyOptions } from './cacheKeyGenerator';
+export { InvalidationStrategy, InvalidationRule, InvalidationOptions, CacheInvalidator, TTLStrategy, LRUStrategy } from './cacheStrategies';
+export { CacheConfig, CacheProviderConfig, CacheConfiguration, createDefaultConfig, createProductionConfig, createDevelopmentConfig } from './cacheConfig';
+export { DetailedCacheStats, CacheMetrics, CacheStatsCollector, CacheMonitor, getGlobalCacheMonitor, resetGlobalCacheMonitor } from './cacheStats';
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetGlobalCacheMonitor = exports.getGlobalCacheMonitor = exports.CacheMonitor = exports.CacheStatsCollector = exports.createDevelopmentConfig = exports.createProductionConfig = exports.createDefaultConfig = exports.CacheConfiguration = exports.LRUStrategy = exports.TTLStrategy = exports.CacheInvalidator = exports.InvalidationStrategy = exports.CacheKeyGenerator = exports.MemoryCache = exports.BaseCacheStore = void 0;
+var cacheStore_1 = require("./cacheStore");
+Object.defineProperty(exports, "BaseCacheStore", { enumerable: true, get: function () { return cacheStore_1.BaseCacheStore; } });
+var memoryCache_1 = require("./memoryCache");
+Object.defineProperty(exports, "MemoryCache", { enumerable: true, get: function () { return memoryCache_1.MemoryCache; } });
+var cacheKeyGenerator_1 = require("./cacheKeyGenerator");
+Object.defineProperty(exports, "CacheKeyGenerator", { enumerable: true, get: function () { return cacheKeyGenerator_1.CacheKeyGenerator; } });
+var cacheStrategies_1 = require("./cacheStrategies");
+Object.defineProperty(exports, "InvalidationStrategy", { enumerable: true, get: function () { return cacheStrategies_1.InvalidationStrategy; } });
+Object.defineProperty(exports, "CacheInvalidator", { enumerable: true, get: function () { return cacheStrategies_1.CacheInvalidator; } });
+Object.defineProperty(exports, "TTLStrategy", { enumerable: true, get: function () { return cacheStrategies_1.TTLStrategy; } });
+Object.defineProperty(exports, "LRUStrategy", { enumerable: true, get: function () { return cacheStrategies_1.LRUStrategy; } });
+var cacheConfig_1 = require("./cacheConfig");
+Object.defineProperty(exports, "CacheConfiguration", { enumerable: true, get: function () { return cacheConfig_1.CacheConfiguration; } });
+Object.defineProperty(exports, "createDefaultConfig", { enumerable: true, get: function () { return cacheConfig_1.createDefaultConfig; } });
+Object.defineProperty(exports, "createProductionConfig", { enumerable: true, get: function () { return cacheConfig_1.createProductionConfig; } });
+Object.defineProperty(exports, "createDevelopmentConfig", { enumerable: true, get: function () { return cacheConfig_1.createDevelopmentConfig; } });
+var cacheStats_1 = require("./cacheStats");
+Object.defineProperty(exports, "CacheStatsCollector", { enumerable: true, get: function () { return cacheStats_1.CacheStatsCollector; } });
+Object.defineProperty(exports, "CacheMonitor", { enumerable: true, get: function () { return cacheStats_1.CacheMonitor; } });
+Object.defineProperty(exports, "getGlobalCacheMonitor", { enumerable: true, get: function () { return cacheStats_1.getGlobalCacheMonitor; } });
+Object.defineProperty(exports, "resetGlobalCacheMonitor", { enumerable: true, get: function () { return cacheStats_1.resetGlobalCacheMonitor; } });
+//# sourceMappingURL=index.js.map