/**
 * 路由缓存管理器
 * 提供路由转换结果、匹配结果的缓存功能
 */ "use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: Object.getOwnPropertyDescriptor(all, name).get
    });
}
_export(exports, {
    get RouteCache () {
        return RouteCache;
    },
    get getRouteCache () {
        return getRouteCache;
    }
});
const _utils = require("../../../utils");
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
let RouteCache = class RouteCache {
    /**
   * 初始化持久化缓存
   */ async initPersistence() {
        try {
            // 检查 IndexedDB 是否可用
            if (typeof window !== 'undefined' && 'indexedDB' in window) {
                this.persistenceEnabled = true;
                await this.loadFromPersistence();
                _utils.logger.debug('路由缓存持久化已启用');
            }
        } catch (error) {
            _utils.logger.warn('路由缓存持久化初始化失败', error);
            this.persistenceEnabled = false;
        }
    }
    /**
   * 从持久化存储加载缓存
   */ async loadFromPersistence() {
        try {
        // 这里可以实现从 IndexedDB 加载缓存的逻辑
        // 由于 IndexedDB 操作较复杂，这里先留空
        // 实际实现可以使用 idb 库或原生 IndexedDB API
        } catch (error) {
            _utils.logger.warn('从持久化存储加载缓存失败', error);
        }
    }
    /**
   * 保存到持久化存储
   */ async saveToPersistence(_key, _value) {
        if (!this.persistenceEnabled) {
            return;
        }
        try {
        // 这里可以实现保存到 IndexedDB 的逻辑
        // 实际实现可以使用 idb 库或原生 IndexedDB API
        } catch (error) {
            _utils.logger.warn('保存到持久化存储失败', error);
        }
    }
    /**
   * 生成缓存键
   */ generateKey(routes) {
        if (typeof routes === 'function') {
            // 对于函数，使用函数名或随机 ID
            return `fn_${routes.name || Math.random().toString(36).substring(7)}`;
        }
        // 对于数组，使用 JSON.stringify 生成键（注意：这可能会很慢）
        // 实际使用中可以考虑使用路由配置的哈希值
        try {
            const routesStr = JSON.stringify(routes, (_key, value)=>{
                // 过滤掉函数，避免序列化问题
                if (typeof value === 'function') {
                    return '[Function]';
                }
                return value;
            });
            return `routes_${this.hashString(routesStr)}`;
        } catch (error) {
            // 如果序列化失败，使用随机键
            return `routes_${Math.random().toString(36).substring(7)}`;
        }
    }
    /**
   * 字符串哈希函数（简单实现）
   */ hashString(str) {
        let hash = 0;
        for(let i = 0; i < str.length; i++){
            const char = str.charCodeAt(i);
            hash = (hash << 5) - hash + char;
            hash = hash & hash; // 转换为 32 位整数
        }
        return Math.abs(hash).toString(36);
    }
    /**
   * 检查缓存项是否过期
   */ isExpired(item) {
        return Date.now() > item.expiresAt;
    }
    /**
   * 清理过期缓存
   */ cleanup() {
        // 清理转换结果缓存
        for (const [key, item] of this.cache.entries()){
            if (this.isExpired(item)) {
                this.cache.delete(key);
            }
        }
        // 清理匹配结果缓存
        for (const [key, item] of this.matchCache.entries()){
            if (this.isExpired(item)) {
                this.matchCache.delete(key);
            }
        }
        // 如果缓存超过最大大小，删除最久未访问的项（LRU）
        this.evictLRU();
    }
    /**
   * LRU 淘汰策略
   */ evictLRU() {
        // 清理转换结果缓存
        if (this.cache.size > this.config.maxSize) {
            const sorted = Array.from(this.cache.entries()).sort((a, b)=>a[1].lastAccessedAt - b[1].lastAccessedAt);
            const toDelete = sorted.slice(0, this.cache.size - this.config.maxSize);
            toDelete.forEach(([key])=>this.cache.delete(key));
        }
        // 清理匹配结果缓存
        if (this.matchCache.size > this.config.maxSize) {
            const sorted = Array.from(this.matchCache.entries()).sort((a, b)=>a[1].lastAccessedAt - b[1].lastAccessedAt);
            const toDelete = sorted.slice(0, this.matchCache.size - this.config.maxSize);
            toDelete.forEach(([key])=>this.matchCache.delete(key));
        }
    }
    /**
   * 启动定期清理
   */ startCleanupInterval() {
        // 每 1 分钟清理一次过期缓存
        setInterval(()=>{
            this.cleanup();
        }, 60 * 1000);
    }
    /**
   * 获取转换结果缓存
   */ get(routes) {
        const key = this.generateKey(routes);
        const item = this.cache.get(key);
        if (!item) {
            return null;
        }
        if (this.isExpired(item)) {
            this.cache.delete(key);
            return null;
        }
        // 更新访问信息
        item.lastAccessedAt = Date.now();
        item.accessCount++;
        return item.value;
    }
    /**
   * 设置转换结果缓存
   */ set(routes, value) {
        const key = this.generateKey(routes);
        const now = Date.now();
        const item = {
            value,
            expiresAt: now + this.config.ttl,
            createdAt: now,
            accessCount: 0,
            lastAccessedAt: now
        };
        this.cache.set(key, item);
        // 保存到持久化存储
        if (this.persistenceEnabled) {
            this.saveToPersistence(key, value).catch((error)=>{
                _utils.logger.warn('保存缓存到持久化存储失败', error);
            });
        }
        // 检查是否需要淘汰
        this.evictLRU();
    }
    /**
   * 获取路由匹配缓存
   */ getMatch(path) {
        const item = this.matchCache.get(path);
        if (!item) {
            return undefined;
        }
        if (this.isExpired(item)) {
            this.matchCache.delete(path);
            return undefined;
        }
        // 更新访问信息
        item.lastAccessedAt = Date.now();
        item.accessCount++;
        return item.value;
    }
    /**
   * 设置路由匹配缓存
   */ setMatch(path, route) {
        const now = Date.now();
        const item = {
            value: route,
            expiresAt: now + this.config.ttl,
            createdAt: now,
            accessCount: 0,
            lastAccessedAt: now
        };
        this.matchCache.set(path, item);
        // 检查是否需要淘汰
        this.evictLRU();
    }
    /**
   * 清空所有缓存
   */ clear() {
        this.cache.clear();
        this.matchCache.clear();
        _utils.logger.debug('路由缓存已清空');
    }
    /**
   * 获取缓存统计信息
   */ getStats() {
        let totalHits = 0;
        let totalAccess = 0;
        // 统计转换结果缓存
        for (const item of this.cache.values()){
            totalHits += item.accessCount;
            totalAccess += item.accessCount;
        }
        // 统计匹配结果缓存
        for (const item of this.matchCache.values()){
            totalHits += item.accessCount;
            totalAccess += item.accessCount;
        }
        const hitRate = totalAccess > 0 ? totalHits / totalAccess : 0;
        return {
            transformCacheSize: this.cache.size,
            matchCacheSize: this.matchCache.size,
            totalSize: this.cache.size + this.matchCache.size,
            hitRate
        };
    }
    constructor(config = {}){
        _define_property(this, "cache", new Map());
        _define_property(this, "matchCache", new Map());
        _define_property(this, "config", void 0);
        _define_property(this, "persistenceEnabled", false);
        this.config = {
            maxSize: config.maxSize ?? 50,
            ttl: config.ttl ?? 5 * 60 * 1000,
            enablePersistence: config.enablePersistence ?? false,
            persistenceKeyPrefix: config.persistenceKeyPrefix ?? 'router_cache_'
        };
        // 初始化持久化缓存
        if (this.config.enablePersistence && typeof window !== 'undefined' && 'indexedDB' in window) {
            this.initPersistence();
        }
        // 定期清理过期缓存
        this.startCleanupInterval();
    }
};
/**
 * 获取路由缓存管理器单例
 */ let routeCacheInstance = null;
function getRouteCache(config) {
    if (!routeCacheInstance) {
        routeCacheInstance = new RouteCache(config);
    }
    return routeCacheInstance;
}

//# sourceMappingURL=RouteCache.js.map