@lynker-desktop/electron-sdk 0.0.9-alpha.7 → 0.0.9-alpha.72

package/main/resource-cache.js

@@ -0,0 +1,857 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const md5 = require('md5');
+const mime = require('mime-types');
+const electron = require('electron');
+const nodeDownloaderHelper = require('node-downloader-helper');
+
+/**
+ * 默认文件扩展名
+ */
+const DEFAULT_EXT = '.res';
+/**
+ * 默认 MIME 类型
+ */
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+/**
+ * 最大重定向次数
+ */
+const MAX_REDIRECTS = 5;
+/**
+ * 默认配置
+ */
+const DEFAULT_OPTIONS = {
+    cacheDir: '',
+    cacheTTL: 24 * 60 * 60 * 1000,
+    // 图片格式：png, jpg/jpeg, webp, gif, svg, ico, bmp, avif, heic, heif, tiff, tif
+    // 字体格式：woff, woff2, ttf, eot, otf
+    // 视频格式：mp4, webm, ogg, mov, avi, mkv, flv, m4v, 3gp
+    // 音频格式：mp3, wav, aac, m4a, flac, opus, wma
+    // 样式和脚本：css, js, json, xml, txt
+    // Web资源：wasm, map (source map)
+    // 文档格式：pdf
+    // 压缩文件：zip, 7z, rar, tar, gz, bz2
+    match: /\.(png|jpe?g|webp|gif|svg|ico|bmp|avif|heic|heif|tiff?|woff2?|ttf|eot|otf|mp4|webm|ogg|mov|avi|mkv|flv|m4v|3gp|mp3|wav|aac|m4a|flac|opus|wma|css|js|json|xml|txt|wasm|map|pdf|zip|7z|rar|tar|gz|bz2)(\?.*)?$/i,
+    allowedOrigins: null,
+};
+/**
+ * 资源缓存类：拦截并缓存静态资源，提升加载性能
+ */
+class ResourceCache {
+    /**
+     * 构造函数
+     * @param session Electron session
+     * @param options 缓存配置
+     */
+    constructor(session, options) {
+        this.cacheHost = `${ResourceCache.scheme}://-`;
+        /** 正在下载的 URL 和对应的下载信息（避免重复下载，允许多个请求等待同一个下载任务） */
+        this._downloadingUrls = new Map();
+        if (!session)
+            throw new Error('ResourceCache: session is required');
+        this.session = session;
+        // 合并配置，保证类型安全
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+            cacheDir: options.cacheDir,
+            cacheTTL: options.cacheTTL ?? DEFAULT_OPTIONS.cacheTTL,
+            match: options.match ?? DEFAULT_OPTIONS.match,
+            allowedOrigins: options.allowedOrigins ?? DEFAULT_OPTIONS.allowedOrigins,
+        };
+        if (!this.options.cacheDir) {
+            throw new Error('ResourceCache: cacheDir is required');
+        }
+        // 确保缓存目录存在
+        if (!fs.existsSync(this.options.cacheDir)) {
+            fs.mkdirSync(this.options.cacheDir, { recursive: true });
+        }
+        this._registerInterceptor();
+        // 异步清理过期缓存，不阻塞初始化
+        this._cleanOldCache().catch(err => {
+            console.log('初始化时清理过期缓存失败:', err);
+        });
+        electron.ipcMain.handle('core:cache', async (event, options) => {
+            try {
+                switch (options.method) {
+                    case 'clear':
+                        return await this.clearCache();
+                    case 'add': {
+                        const { id } = options;
+                        const sender = event.sender;
+                        const urls = Array.isArray(options.urls) ? options.urls : options.urls ? [options.urls] : [];
+                        const data = await this.addCacheUrls(urls, options.force ?? false, true, (data) => {
+                            try {
+                                if (sender) {
+                                    if (typeof sender?.send === 'function') {
+                                        sender?.send?.(`core:cache:progress`, {
+                                            id,
+                                            data
+                                        });
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                console.log('发送缓存进度回调失败:', error);
+                            }
+                        });
+                        return Array.isArray(options.urls) ? data : data[0];
+                    }
+                    case 'delete': {
+                        const urls = Array.isArray(options.urls) ? options.urls : options.urls ? [options.urls] : [];
+                        const data = await this.deleteCacheUrls(urls);
+                        return Array.isArray(options.urls) ? data : data[0];
+                    }
+                    case 'get': {
+                        const urls = Array.isArray(options.urls) ? options.urls : options.urls ? [options.urls] : [];
+                        const data = await this.getCacheUrls(urls);
+                        return Array.isArray(options.urls) ? data : data[0];
+                    }
+                    case 'stats':
+                        return await this.getCacheStats();
+                    default:
+                        return undefined;
+                }
+            }
+            catch (error) {
+                return { success: false, error: error instanceof Error ? error.message : '未知错误' };
+            }
+        });
+    }
+    /**
+     * 获取缓存统计信息（异步版本，性能更好）
+     */
+    async getCacheStats() {
+        try {
+            const files = await fs.promises.readdir(this.options.cacheDir);
+            if (files.length === 0) {
+                return { size: 0, totalSize: 0 };
+            }
+            // 并行获取文件信息，提升性能
+            const fileInfos = await Promise.allSettled(files.map(async (file) => {
+                const filePath = path.join(this.options.cacheDir, file);
+                try {
+                    const stats = await fs.promises.stat(filePath);
+                    return { file, filePath, size: stats.size };
+                }
+                catch (error) {
+                    return { file, filePath, size: 0, error };
+                }
+            }));
+            const validInfos = fileInfos
+                .filter((r) => r.status === 'fulfilled')
+                .map(r => r.value);
+            return {
+                size: validInfos.length,
+                totalSize: validInfos.reduce((sum, info) => sum + info.size, 0)
+            };
+        }
+        catch (error) {
+            console.log('获取缓存统计信息失败:', error);
+            return { size: 0, totalSize: 0 };
+        }
+    }
+    /**
+     * 获取资源匹配函数（带缓存，避免重复创建）
+     */
+    _getMatchFunction() {
+        if (this._cachedMatchFunction) {
+            return this._cachedMatchFunction;
+        }
+        const matcher = this.options.match;
+        if (typeof matcher === 'function') {
+            this._cachedMatchFunction = matcher;
+        }
+        else if (matcher instanceof RegExp) {
+            this._cachedMatchFunction = (url) => matcher.test(url);
+        }
+        else {
+            this._cachedMatchFunction = () => false;
+        }
+        return this._cachedMatchFunction;
+    }
+    /**
+     * 获取来源校验函数（带缓存，避免重复创建）
+     */
+    _getOriginAllowFunction() {
+        if (this._cachedOriginFunction) {
+            return this._cachedOriginFunction;
+        }
+        const origins = this.options.allowedOrigins;
+        if (!origins) {
+            this._cachedOriginFunction = () => true;
+        }
+        else if (typeof origins === 'function') {
+            this._cachedOriginFunction = origins;
+        }
+        else {
+            const prefixList = origins.map(o => o.toLowerCase());
+            this._cachedOriginFunction = (url) => {
+                try {
+                    const origin = new URL(url).origin.toLowerCase();
+                    return prefixList.some(prefix => origin.startsWith(prefix));
+                }
+                catch {
+                    return false;
+                }
+            };
+        }
+        return this._cachedOriginFunction;
+    }
+    /**
+     * 获取缓存文件路径
+     * @param url 资源URL
+     * @param customExt 自定义文件扩展名（可选，用于 base64 URL）
+     */
+    getCachedPath(url, customExt) {
+        const md5Str = md5(url);
+        let ext = '.res';
+        if (customExt) {
+            // 如果提供了自定义扩展名，使用它
+            ext = customExt.startsWith('.') ? customExt : `.${customExt}`;
+        }
+        else {
+            // 尝试从 URL 中提取扩展名
+            try {
+                const urlObj = new URL(url);
+                ext = path.extname(urlObj.pathname) || DEFAULT_EXT;
+            }
+            catch {
+                // 如果 URL 解析失败（可能是 base64 data URL），使用默认扩展名
+                ext = DEFAULT_EXT;
+            }
+        }
+        return {
+            filePath: path.join(this.options.cacheDir, `${md5Str}${ext}`),
+            hostPath: `${this.cacheHost}/${md5Str}${ext}`,
+        };
+    }
+    /**
+     * 判断缓存是否有效（同步版本，用于拦截器）
+     * @param filePath 缓存文件路径
+     */
+    isCacheValid(filePath) {
+        try {
+            if (!fs.existsSync(filePath))
+                return false;
+            const stat = fs.statSync(filePath);
+            return Date.now() - stat.mtimeMs < this.options.cacheTTL;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 判断缓存是否有效（异步版本，性能更好）
+     * @param filePath 缓存文件路径
+     */
+    async isCacheValidAsync(filePath) {
+        try {
+            const stat = await fs.promises.stat(filePath);
+            return Date.now() - stat.mtimeMs < this.options.cacheTTL;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 下载资源到本地缓存（异步版本，返回 Promise）
+     * @param url 资源URL
+     * @param filePath 本地缓存路径
+     * @param redirectCount 当前重定向次数（内部使用）
+     * @param onProgress 下载进度回调函数（可选）
+     * @returns Promise<void> 下载完成或失败
+     */
+    downloadResourceAsync(url, filePath, redirectCount = 0, onProgress) {
+        // 检查是否正在下载，如果正在下载则返回已存在的 Promise（允许多个请求等待同一个下载任务）
+        const existingDownload = this._downloadingUrls.get(url);
+        if (existingDownload) {
+            // 如果提供了新的进度回调，添加到回调列表中
+            if (onProgress) {
+                existingDownload.progressCallbacks.add(onProgress);
+            }
+            return existingDownload.promise;
+        }
+        // 检查重定向次数限制
+        if (redirectCount >= MAX_REDIRECTS) {
+            return Promise.reject(new Error(`重定向次数超过限制 (${MAX_REDIRECTS}): ${url}`));
+        }
+        // 创建新的下载 Promise
+        let downloader;
+        // 创建进度回调集合（在 Promise 外部，以便后续可以访问）
+        const progressCallbacks = new Set();
+        if (onProgress) {
+            progressCallbacks.add(onProgress);
+        }
+        const downloadPromise = new Promise((resolve, reject) => {
+            const tempFilePath = `${filePath}.cache`;
+            const downloadDir = path.dirname(tempFilePath);
+            const downloadFileName = path.basename(tempFilePath);
+            // 确保目录存在
+            if (!fs.existsSync(downloadDir)) {
+                fs.mkdirSync(downloadDir, { recursive: true });
+            }
+            // 创建下载器实例
+            const dl = new nodeDownloaderHelper.DownloaderHelper(url, downloadDir, {
+                fileName: downloadFileName,
+                retry: { maxRetries: 3, delay: 1000 },
+                // 超时设置：10 分钟（600000 毫秒）
+                // 对于视频等大文件，需要更长的超时时间
+                // 如果 10 分钟内没有任何数据传输，才会超时
+                timeout: 600000,
+                override: true, // 覆盖已存在的文件
+                httpRequestOptions: {
+                    // 允许重定向
+                    followRedirect: true,
+                    maxRedirects: MAX_REDIRECTS
+                }
+            });
+            // 将下载器实例赋值给外部变量（Promise 构造函数是同步执行的）
+            downloader = dl;
+            // 监听下载进度 - 必须在 start() 之前设置
+            // 注意：我们需要在 start() 之前设置事件监听器，这样后续的请求可以正确绑定进度回调
+            dl.on('progress', (stats) => {
+                // 调用所有注册的进度回调
+                const progressData = {
+                    url,
+                    downloaded: stats.downloaded || 0,
+                    total: stats.total || 0,
+                    percentage: stats.progress !== undefined ? Math.round(stats.progress) : -1,
+                    speed: stats.speed || 0
+                };
+                progressCallbacks.forEach((callback) => {
+                    try {
+                        callback(progressData);
+                    }
+                    catch (error) {
+                        // 忽略回调中的错误，避免影响下载
+                        console.error('进度回调执行失败:', error);
+                    }
+                });
+            });
+            // 监听下载完成
+            dl.on('end', () => {
+                // 将临时文件重命名为最终文件
+                fs.rename(tempFilePath, filePath, (renameErr) => {
+                    // 无论成功还是失败，都要从下载列表中删除
+                    this._downloadingUrls.delete(url);
+                    if (renameErr) {
+                        reject(new Error(`缓存文件重命名失败 from ${tempFilePath} to ${filePath}: ${renameErr.message}`));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+            // 监听下载错误
+            dl.on('error', (err) => {
+                // 从下载列表中删除
+                this._downloadingUrls.delete(url);
+                // 清理临时文件
+                fs.promises.unlink(tempFilePath).catch(() => {
+                    // 忽略删除失败
+                });
+                reject(err instanceof Error ? err : new Error(`下载失败: ${url}`));
+            });
+            // 监听下载停止（取消）
+            dl.on('stop', () => {
+                // 从下载列表中删除
+                this._downloadingUrls.delete(url);
+                // 清理临时文件
+                fs.promises.unlink(tempFilePath).catch(() => {
+                    // 忽略删除失败
+                });
+                reject(new Error(`下载已停止: ${url}`));
+            });
+            // 开始下载 - 必须在所有事件监听器设置完成后调用
+            dl.start().catch((err) => {
+                // 从下载列表中删除
+                this._downloadingUrls.delete(url);
+                reject(err instanceof Error ? err : new Error(`启动下载失败: ${url}`));
+            });
+        });
+        // 立即将 Promise、下载器实例和进度回调集合存储到 Map 中，供后续相同 URL 的请求复用
+        // 注意：必须在 start() 调用之前存储，以便后续请求可以绑定进度回调
+        // 由于 Promise 构造函数是同步执行的，此时 downloader 已经被赋值，事件监听器也已设置完成
+        this._downloadingUrls.set(url, {
+            promise: downloadPromise,
+            downloader: downloader,
+            progressCallbacks
+        });
+        return downloadPromise;
+    }
+    /**
+     * 下载资源到本地缓存（同步版本，不返回 Promise，用于拦截器）
+     * @param url 资源URL
+     * @param filePath 本地缓存路径
+     */
+    downloadResource(url, filePath) {
+        // 异步执行，不等待完成
+        // 如果正在下载，跳过（避免重复下载）
+        if (this._downloadingUrls.has(url)) {
+            return;
+        }
+        // 调用 downloadResourceAsync，它会自动处理重复下载的情况
+        this.downloadResourceAsync(url, filePath).catch(() => {
+            // 静默处理错误，避免日志过多
+        });
+    }
+    /**
+     * 从文件扩展名获取 MIME 类型
+     * @param ext 文件扩展名（带或不带点）
+     * @returns MIME 类型
+     */
+    _getMimeTypeFromExt(ext) {
+        const cleanExt = ext.replace(/^\./, '').toLowerCase();
+        const mimeType = mime.lookup(cleanExt);
+        return mimeType || DEFAULT_MIME_TYPE;
+    }
+    /**
+     * 检测并处理 base64 data URL
+     * @param url 资源URL
+     * @returns 如果是 base64 URL，返回 true、文件扩展名、MIME 类型和数据；否则返回 false
+     */
+    _isBase64DataUrl(url) {
+        if (!url.startsWith('data:')) {
+            return { isBase64: false };
+        }
+        try {
+            // 解析 data URL 格式：data:[<mediatype>][;base64],<data>
+            const commaIndex = url.indexOf(',');
+            if (commaIndex === -1) {
+                return { isBase64: false };
+            }
+            const header = url.substring(0, commaIndex);
+            const data = url.substring(commaIndex + 1);
+            // 检查是否包含 base64 标识
+            if (!header.includes('base64')) {
+                return { isBase64: false };
+            }
+            // 从 mediatype 中提取文件扩展名和 MIME 类型
+            // 例如：data:image/png;base64 -> png, image/png
+            // 例如：data:image/jpeg;base64 -> jpeg, image/jpeg
+            let ext = DEFAULT_EXT.replace(/^\./, '');
+            let mimeType = DEFAULT_MIME_TYPE;
+            const mimeMatch = header.match(/data:([^;]+)/);
+            if (mimeMatch && mimeMatch[1]) {
+                mimeType = mimeMatch[1];
+                // 使用 mime-types 包从 MIME 类型获取扩展名
+                const extension = mime.extension(mimeType);
+                if (extension) {
+                    ext = extension;
+                }
+            }
+            return { isBase64: true, ext, mimeType, data };
+        }
+        catch (error) {
+            return { isBase64: false };
+        }
+    }
+    /**
+     * 保存 base64 数据到文件
+     * @param base64Data base64 编码的数据
+     * @param filePath 目标文件路径
+     */
+    async _saveBase64ToFile(base64Data, filePath) {
+        try {
+            // 解码 base64 数据
+            const buffer = Buffer.from(base64Data, 'base64');
+            // 使用 Promise 版本的 writeFile
+            // Buffer 继承自 Uint8Array，可以直接使用
+            await fs.promises.writeFile(filePath, buffer);
+        }
+        catch (error) {
+            throw new Error(`保存 base64 文件失败: ${error instanceof Error ? error.message : '未知错误'}`);
+        }
+    }
+    /**
+     * 手动缓存指定 URL 的资源
+     * @param url 要缓存的资源 URL（支持普通 URL 和 base64 data URL）
+     * @param force 是否强制重新下载，即使缓存有效（默认 false）
+     * @param ignoreOrigin 是否忽略来源检查（默认 false）
+     * @param onDownloadProgress 下载进度回调函数（可选）
+     * @returns Promise<{ filePath: string, hostPath: string, mimeType: string, size: number }> 返回缓存文件路径、主机路径、MIME 类型和文件大小
+     * @throws 如果 URL 不匹配缓存规则或来源不允许，会抛出错误
+     */
+    async cacheUrl(url, force = false, ignoreOrigin = false, onDownloadProgress) {
+        // 检查是否是 base64 data URL
+        const base64Info = this._isBase64DataUrl(url);
+        if (base64Info.isBase64) {
+            // 处理 base64 data URL
+            if (!base64Info.data || !base64Info.ext) {
+                throw new Error(`无效的 base64 data URL: ${url}`);
+            }
+            // 获取缓存路径（使用检测到的扩展名）
+            const cachePath = this.getCachedPath(url, base64Info.ext);
+            const mimeType = base64Info.mimeType || this._getMimeTypeFromExt(base64Info.ext);
+            // 如果缓存有效且不强制重新下载，直接返回
+            if (!force && await this.isCacheValidAsync(cachePath.filePath)) {
+                const stats = await fs.promises.stat(cachePath.filePath);
+                return {
+                    ...cachePath,
+                    mimeType,
+                    size: stats.size
+                };
+            }
+            // 保存 base64 数据到文件
+            await this._saveBase64ToFile(base64Info.data, cachePath.filePath);
+            // 获取文件大小
+            const stats = await fs.promises.stat(cachePath.filePath);
+            return {
+                ...cachePath,
+                mimeType,
+                size: stats.size
+            };
+        }
+        // 处理普通 URL
+        const shouldCache = ignoreOrigin ? () => true : this._getMatchFunction();
+        const isAllowedOrigin = ignoreOrigin ? () => true : this._getOriginAllowFunction();
+        // 检查是否匹配缓存规则
+        if (!shouldCache(url)) {
+            throw new Error(`URL 不匹配缓存规则: ${url}`);
+        }
+        // 检查来源是否允许
+        if (!isAllowedOrigin(url)) {
+            throw new Error(`URL 来源不允许缓存: ${url}`);
+        }
+        // 获取缓存路径
+        const cachePath = this.getCachedPath(url);
+        // 从文件扩展名获取 MIME 类型
+        const ext = path.extname(cachePath.filePath).replace(/^\./, '') || DEFAULT_EXT.replace(/^\./, '');
+        const mimeType = this._getMimeTypeFromExt(ext);
+        // 如果缓存有效且不强制重新下载，直接返回
+        if (!force && await this.isCacheValidAsync(cachePath.filePath)) {
+            const stats = await fs.promises.stat(cachePath.filePath);
+            return {
+                ...cachePath,
+                mimeType,
+                size: stats.size
+            };
+        }
+        // 下载资源
+        await this.downloadResourceAsync(url, cachePath.filePath, 0, onDownloadProgress);
+        // 获取文件大小
+        const stats = await fs.promises.stat(cachePath.filePath);
+        return {
+            ...cachePath,
+            mimeType,
+            size: stats.size
+        };
+    }
+    /**
+     * 批量缓存多个 URL 的资源
+     * @param urls 要缓存的资源 URL 数组
+     * @param force 是否强制重新下载，即使缓存有效（默认 false）
+     * @param ignoreOrigin 是否忽略来源检查（默认 false）
+     * @param onProgress 进度回调函数（可选）
+     * @returns Promise<Array<{ url: string, success: boolean, filePath?: string, hostPath?: string, mimeType?: string, size?: number, error?: string }>> 返回每个 URL 的缓存结果
+     */
+    async addCacheUrls(urls, force = false, ignoreOrigin = false, onProgress) {
+        const total = urls.length;
+        const results = [];
+        let completed = 0;
+        // 存储每个 URL 的下载进度
+        const downloadProgressMap = new Map();
+        // 进度回调的包装函数，确保线程安全
+        const reportProgress = (url, success, result) => {
+            if (onProgress) {
+                completed++;
+                const downloadProgress = downloadProgressMap.get(url);
+                onProgress({
+                    current: completed,
+                    total,
+                    url,
+                    success,
+                    result,
+                    percentage: Math.round((completed / total) * 100),
+                    downloadProgress: downloadProgress ? {
+                        downloaded: downloadProgress.downloaded,
+                        total: downloadProgress.total,
+                        percentage: downloadProgress.percentage,
+                        speed: downloadProgress.speed
+                    } : undefined
+                });
+            }
+        };
+        // 并行处理所有 URL，但跟踪每个的完成状态
+        const promises = urls.map(async (url, index) => {
+            // 为每个 URL 创建下载进度回调
+            const onDownloadProgress = onProgress
+                ? (progress) => {
+                    // 更新下载进度
+                    downloadProgressMap.set(url, {
+                        downloaded: progress.downloaded,
+                        total: progress.total,
+                        percentage: progress.percentage,
+                        speed: progress.speed
+                    });
+                    // 实时报告下载进度（不增加 completed 计数）
+                    if (onProgress) {
+                        onProgress({
+                            current: completed,
+                            total,
+                            url,
+                            success: true, // 下载中视为进行中
+                            result: undefined,
+                            percentage: Math.round((completed / total) * 100),
+                            downloadProgress: {
+                                downloaded: progress.downloaded,
+                                total: progress.total,
+                                percentage: progress.percentage,
+                                speed: progress.speed
+                            }
+                        });
+                    }
+                }
+                : undefined;
+            try {
+                const result = await this.cacheUrl(url, force, ignoreOrigin, onDownloadProgress);
+                const item = {
+                    url,
+                    success: true,
+                    filePath: result.filePath,
+                    hostPath: result.hostPath,
+                    mimeType: result.mimeType,
+                    size: result.size
+                };
+                results[index] = item;
+                // 清除下载进度（已完成）
+                downloadProgressMap.delete(url);
+                // 调用进度回调
+                reportProgress(url, true, {
+                    filePath: result.filePath,
+                    hostPath: result.hostPath,
+                    mimeType: result.mimeType,
+                    size: result.size
+                });
+                return item;
+            }
+            catch (error) {
+                const item = {
+                    url,
+                    success: false,
+                    error: error instanceof Error ? error.message : '未知错误'
+                };
+                results[index] = item;
+                // 清除下载进度（失败）
+                downloadProgressMap.delete(url);
+                // 调用进度回调
+                reportProgress(url, false, {
+                    error: item.error
+                });
+                return item;
+            }
+        });
+        // 等待所有请求完成
+        await Promise.allSettled(promises);
+        return results;
+    }
+    /**
+     * 删除多个 URL 的资源
+     * @param urls 要删除的资源 URL 数组
+     * @returns Promise<Array<{ url: string, success: boolean, error?: string }>> 返回每个 URL 的删除结果
+     */
+    async deleteCacheUrls(urls) {
+        const results = await Promise.allSettled(urls.map(url => this.deleteUrl(url)));
+        return results.map((result, index) => {
+            const url = urls[index] || '';
+            if (result.status === 'fulfilled') {
+                return { url, success: true };
+            }
+            else {
+                return { url, success: false, error: result.reason?.message || '未知错误' };
+            }
+        });
+    }
+    /**
+     * 获取单个 URL 的缓存信息
+     * @param url 资源 URL
+     * @returns Promise<{ url: string, exists: boolean, valid?: boolean, filePath?: string, hostPath?: string, mimeType?: string, size?: number, error?: string }> 返回缓存信息
+     */
+    async getCacheUrl(url) {
+        try {
+            const cachePath = this.getCachedPath(url);
+            const exists = fs.existsSync(cachePath.filePath);
+            if (!exists) {
+                return { url, exists: false };
+            }
+            // 检查缓存是否有效
+            const valid = await this.isCacheValidAsync(cachePath.filePath);
+            // 获取文件信息
+            const stats = await fs.promises.stat(cachePath.filePath);
+            // 从文件扩展名获取 MIME 类型
+            const ext = path.extname(cachePath.filePath).replace(/^\./, '') || DEFAULT_EXT.replace(/^\./, '');
+            const mimeType = this._getMimeTypeFromExt(ext);
+            return {
+                url,
+                exists: true,
+                valid,
+                filePath: cachePath.filePath,
+                hostPath: cachePath.hostPath,
+                mimeType,
+                size: stats.size
+            };
+        }
+        catch (error) {
+            return {
+                url,
+                exists: false,
+                error: error instanceof Error ? error.message : '未知错误'
+            };
+        }
+    }
+    /**
+     * 获取多个 URL 的缓存信息
+     * @param urls 资源 URL 数组
+     * @returns Promise<Array<{ url: string, exists: boolean, valid?: boolean, filePath?: string, hostPath?: string, mimeType?: string, size?: number, error?: string }>> 返回每个 URL 的缓存信息
+     */
+    async getCacheUrls(urls) {
+        const results = await Promise.allSettled(urls.map(url => this.getCacheUrl(url)));
+        return results.map((result, index) => {
+            const url = urls[index] || '';
+            if (result.status === 'fulfilled') {
+                return result.value;
+            }
+            else {
+                return {
+                    url,
+                    exists: false,
+                    error: result.reason?.message || '未知错误'
+                };
+            }
+        });
+    }
+    /**
+     * 删除单个 URL 的资源（异步版本，性能更好）
+     * @param url 要删除的资源 URL
+     * @returns Promise<{ url: string, success: boolean, error?: string }> 返回删除结果
+     */
+    async deleteUrl(url) {
+        try {
+            const cachePath = this.getCachedPath(url);
+            try {
+                await fs.promises.unlink(cachePath.filePath);
+                return { url, success: true };
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return { url, success: false, error: '文件不存在' };
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            return {
+                url,
+                success: false,
+                error: error instanceof Error ? error.message : '未知错误'
+            };
+        }
+    }
+    /**
+     * 删除单个 URL 的资源（别名，保持向后兼容）
+     * @deprecated 使用 deleteUrl 代替
+     */
+    async deleteCache(url) {
+        return this.deleteUrl(url);
+    }
+    /**
+     * 清理过期缓存文件（异步并行处理，性能更好）
+     */
+    async _cleanOldCache() {
+        try {
+            const files = await fs.promises.readdir(this.options.cacheDir);
+            if (files.length === 0)
+                return;
+            const now = Date.now();
+            // 并行处理，提升性能
+            await Promise.allSettled(files.map(async (file) => {
+                const fullPath = path.join(this.options.cacheDir, file);
+                try {
+                    const stat = await fs.promises.stat(fullPath);
+                    if (now - stat.mtimeMs > this.options.cacheTTL) {
+                        await fs.promises.unlink(fullPath);
+                    }
+                }
+                catch {
+                    // 忽略单个文件异常
+                }
+            }));
+        }
+        catch (error) {
+            // 忽略目录读取错误
+            console.log('清理过期缓存时发生错误:', error);
+        }
+    }
+    /**
+     * 清理所有缓存文件（完全异步版本，性能更好）
+     * @returns Promise<{ success: number, failed: number, totalSize: number }> 返回清理统计信息
+     */
+    async clearCache() {
+        try {
+            const files = await fs.promises.readdir(this.options.cacheDir);
+            if (files.length === 0) {
+                return { success: 0, failed: 0, totalSize: 0 };
+            }
+            // 并行获取所有文件信息（避免并行时的竞态条件）
+            const fileInfos = await Promise.allSettled(files.map(async (file) => {
+                const filePath = path.join(this.options.cacheDir, file);
+                try {
+                    const stats = await fs.promises.stat(filePath);
+                    return { file, filePath, size: stats.size };
+                }
+                catch (error) {
+                    return { file, filePath, size: 0, error };
+                }
+            }));
+            const validInfos = fileInfos
+                .filter((r) => r.status === 'fulfilled')
+                .map(r => r.value);
+            // 计算总大小
+            const totalSize = validInfos.reduce((sum, info) => sum + info.size, 0);
+            // 并行删除文件，提升性能
+            const deleteResults = await Promise.allSettled(validInfos.map(async (info) => {
+                try {
+                    await fs.promises.unlink(info.filePath);
+                    return { success: true, file: info.file };
+                }
+                catch (error) {
+                    throw error;
+                }
+            }));
+            // 统计成功和失败数量
+            const success = deleteResults.filter(r => r.status === 'fulfilled').length;
+            const failed = deleteResults.filter(r => r.status === 'rejected').length;
+            return { success, failed, totalSize };
+        }
+        catch (error) {
+            console.log('清理缓存时发生错误:', error);
+            throw error;
+        }
+    }
+    /**
+     * 注册 Electron 请求拦截器，实现资源缓存
+     */
+    _registerInterceptor() {
+        const shouldCache = this._getMatchFunction();
+        const isAllowedOrigin = this._getOriginAllowFunction();
+        this.session.webRequest.onBeforeRequest({ urls: ['http://*/*', 'https://*/*'] }, (details, callback) => {
+            const url = details.url;
+            // 不匹配或来源不允许，直接放行
+            if (details.method !== 'GET' || !shouldCache(url) || !isAllowedOrigin(url))
+                return callback({});
+            const cachePath = this.getCachedPath(url);
+            // 命中缓存，直接重定向到本地文件
+            if (this.isCacheValid(cachePath.filePath)) {
+                return callback({ redirectURL: cachePath.hostPath });
+            }
+            // 未命中则异步下载，当前请求正常放行
+            this.downloadResource(url, cachePath.filePath);
+            return callback({});
+        });
+    }
+}
+ResourceCache.scheme = 'cachefile';
+
+exports.ResourceCache = ResourceCache;
+//# sourceMappingURL=resource-cache.js.map