@lynker-desktop/electron-sdk 0.0.9-alpha.54 → 0.0.9-alpha.56

package/esm/main/resource-cache.js

@@ -2,44 +2,27 @@ import fs from 'node:fs';
 import path from 'node:path';
 import http from 'node:http';
 import https from 'node:https';
+import { Transform } from 'node:stream';
 import md5 from 'md5';
-import ipc__default from '@lynker-desktop/electron-ipc/main';
+import mime from 'mime-types';
+import { ipcMain } from 'electron';
 
 /**
- * MIME 类型到文件扩展名的映射表
+ * HTTP 重定向状态码
  */
-const MIME_TO_EXT = {
-    'image/png': 'png',
-    'image/jpeg': 'jpeg',
-    'image/jpg': 'jpg',
-    'image/gif': 'gif',
-    'image/webp': 'webp',
-    'image/svg+xml': 'svg',
-    'image/x-icon': 'ico',
-    'image/bmp': 'bmp',
-    'image/avif': 'avif',
-    'image/heic': 'heic',
-    'image/heif': 'heif',
-    'image/tiff': 'tiff',
-    'font/woff': 'woff',
-    'font/woff2': 'woff2',
-    'font/ttf': 'ttf',
-    'font/otf': 'otf',
-    'application/font-woff': 'woff',
-    'application/font-woff2': 'woff2',
-    'video/mp4': 'mp4',
-    'video/webm': 'webm',
-    'video/ogg': 'ogg',
-    'audio/mpeg': 'mp3',
-    'audio/wav': 'wav',
-    'text/css': 'css',
-    'text/javascript': 'js',
-    'application/javascript': 'js',
-    'application/json': 'json',
-    'text/xml': 'xml',
-    'text/plain': 'txt',
-    'application/pdf': 'pdf',
-};
+const REDIRECT_STATUS_CODES = [301, 302, 307, 308];
+/**
+ * 默认文件扩展名
+ */
+const DEFAULT_EXT = '.res';
+/**
+ * 默认 MIME 类型
+ */
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+/**
+ * 最大重定向次数
+ */
+const MAX_REDIRECTS = 5;
 /**
  * 默认配置
  */
@@ -68,6 +51,8 @@ class ResourceCache {
      */
     constructor(session, options) {
         this.cacheHost = `${ResourceCache.scheme}://-`;
+        /** 正在下载的 URL 集合（避免重复下载） */
+        this._downloadingUrls = new Set();
         if (!session)
             throw new Error('ResourceCache: session is required');
         this.session = session;
@@ -92,31 +77,39 @@ class ResourceCache {
         this._cleanOldCache().catch(err => {
             console.log('初始化时清理过期缓存失败:', err);
         });
-        ipc__default.mainIPC.handleRenderer('core:cache', async (options) => {
+        ipcMain.handle('core:cache', async (event, options) => {
             try {
-                if (options.method === 'clear') {
-                    return await this.clearCache();
-                }
-                if (options.method === 'add') {
-                    if (typeof options.urls === 'string') {
-                        const data = await this.addCacheUrls([options.urls], options.force ?? false, true);
-                        return data[0];
+                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 (sender) {
+                                        sender?.send?.(`core:cache:progress:${id}`, data);
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                console.log('发送缓存进度回调失败:', error);
+                            }
+                        });
+                        return Array.isArray(options.urls) ? data : data[0];
                     }
-                    const data = await this.addCacheUrls(options.urls ?? [], options.force ?? false, true);
-                    return data;
-                }
-                if (options.method === 'delete') {
-                    if (typeof options.urls === 'string') {
-                        const data = await this.deleteCacheUrls([options.urls]);
-                        return 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];
                     }
-                    const data = await this.deleteCacheUrls(options.urls ?? []);
-                    return data;
+                    case 'stats':
+                        return await this.getCacheStats();
+                    default:
+                        return undefined;
                 }
-                if (options.method === 'stats') {
-                    return await this.getCacheStats();
-                }
-                return undefined;
             }
             catch (error) {
                 return { success: false, error: error instanceof Error ? error.message : '未知错误' };
@@ -219,11 +212,11 @@ class ResourceCache {
             // 尝试从 URL 中提取扩展名
             try {
                 const urlObj = new URL(url);
-                ext = path.extname(urlObj.pathname) || '.res';
+                ext = path.extname(urlObj.pathname) || DEFAULT_EXT;
             }
             catch {
                 // 如果 URL 解析失败（可能是 base64 data URL），使用默认扩展名
-                ext = '.res';
+                ext = DEFAULT_EXT;
             }
         }
         return {
@@ -263,45 +256,84 @@ class ResourceCache {
      * 下载资源到本地缓存（异步版本，返回 Promise）
      * @param url 资源URL
      * @param filePath 本地缓存路径
+     * @param redirectCount 当前重定向次数（内部使用）
+     * @param onProgress 下载进度回调函数（可选）
      * @returns Promise<void> 下载完成或失败
      */
-    downloadResourceAsync(url, filePath) {
+    downloadResourceAsync(url, filePath, redirectCount = 0, onProgress) {
+        // 检查是否正在下载，避免重复下载
+        if (this._downloadingUrls.has(url)) {
+            return Promise.reject(new Error(`资源正在下载中: ${url}`));
+        }
+        // 检查重定向次数限制
+        if (redirectCount >= MAX_REDIRECTS) {
+            return Promise.reject(new Error(`重定向次数超过限制 (${MAX_REDIRECTS}): ${url}`));
+        }
+        this._downloadingUrls.add(url);
         return new Promise((resolve, reject) => {
             const tempFilePath = `${filePath}.cache`;
             const lib = url.startsWith('https') ? https : http;
             const file = fs.createWriteStream(tempFilePath);
             let request;
+            // 下载进度跟踪
+            let downloaded = 0;
+            let total = 0;
+            let lastProgressTime = Date.now();
+            let lastDownloaded = 0;
+            let progressInterval = null;
             const cleanupAndAbort = (errMsg, err) => {
-                if (err) {
-                    console.log(errMsg, err);
-                }
-                else {
-                    console.log(errMsg);
+                this._downloadingUrls.delete(url);
+                if (progressInterval) {
+                    clearInterval(progressInterval);
+                    progressInterval = null;
                 }
                 if (request) {
                     request.destroy();
                 }
                 file.close(() => {
-                    // 使用 existsSync 避免在文件不存在时 unlink 抛出错误
-                    if (fs.existsSync(tempFilePath)) {
-                        fs.unlink(tempFilePath, () => { });
-                    }
+                    // 异步删除临时文件，不阻塞
+                    fs.promises.unlink(tempFilePath).catch(() => {
+                        // 忽略删除失败
+                    });
                 });
-                reject(new Error(errMsg));
+                const error = err instanceof Error ? err : new Error(errMsg);
+                reject(error);
+            };
+            const reportProgress = () => {
+                if (!onProgress)
+                    return;
+                const now = Date.now();
+                const timeDiff = (now - lastProgressTime) / 1000; // 秒
+                const downloadedDiff = downloaded - lastDownloaded;
+                const speed = timeDiff > 0 ? downloadedDiff / timeDiff : 0;
+                const percentage = total > 0
+                    ? Math.round((downloaded / total) * 100)
+                    : -1;
+                onProgress({
+                    url,
+                    downloaded,
+                    total,
+                    percentage,
+                    speed
+                });
+                lastProgressTime = now;
+                lastDownloaded = downloaded;
             };
             request = lib.get(url, (res) => {
                 // 处理重定向
-                if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) {
+                if (res.statusCode && REDIRECT_STATUS_CODES.includes(res.statusCode)) {
                     const location = res.headers.location;
                     if (location) {
                         request.destroy();
                         file.close(() => {
-                            if (fs.existsSync(tempFilePath)) {
-                                fs.unlink(tempFilePath, () => { });
-                            }
+                            // 异步删除临时文件，不阻塞
+                            fs.promises.unlink(tempFilePath).catch(() => {
+                                // 忽略删除失败
+                            });
                         });
-                        // 递归处理重定向
-                        this.downloadResourceAsync(location, filePath).then(resolve).catch(reject);
+                        this._downloadingUrls.delete(url);
+                        // 递归处理重定向，增加重定向计数，传递进度回调
+                        this.downloadResourceAsync(location, filePath, redirectCount + 1, onProgress).then(resolve).catch(reject);
                         return;
                     }
                     // 如果没有 location，继续处理为错误
@@ -311,14 +343,40 @@ class ResourceCache {
                     cleanupAndAbort(`下载失败，状态码: ${res.statusCode} for ${url}`);
                     return;
                 }
-                res.pipe(file);
+                // 获取文件总大小（如果服务器提供）
+                const contentLength = res.headers['content-length'];
+                if (contentLength) {
+                    total = parseInt(contentLength, 10);
+                }
+                // 使用 Transform 流来跟踪下载进度，避免与 pipe 冲突
+                const progressStream = new Transform({
+                    transform(chunk, encoding, callback) {
+                        downloaded += chunk.length;
+                        callback(null, chunk);
+                    }
+                });
+                // 定期报告进度（每 200ms 一次）
+                if (onProgress) {
+                    progressInterval = setInterval(reportProgress, 200);
+                }
+                // 将响应流通过进度跟踪流再写入文件
+                res.pipe(progressStream).pipe(file);
             });
             file.on('finish', () => {
+                if (progressInterval) {
+                    clearInterval(progressInterval);
+                    progressInterval = null;
+                }
+                // 最终进度报告
+                if (onProgress) {
+                    reportProgress();
+                }
                 file.close((err) => {
                     if (err) {
                         return cleanupAndAbort(`关闭临时文件流失败: ${tempFilePath}`, err);
                     }
                     fs.rename(tempFilePath, filePath, (renameErr) => {
+                        this._downloadingUrls.delete(url);
                         if (renameErr) {
                             cleanupAndAbort(`缓存文件重命名失败 from ${tempFilePath} to ${filePath}`, renameErr);
                         }
@@ -334,6 +392,13 @@ class ResourceCache {
             request.on('error', (err) => {
                 cleanupAndAbort(`下载资源请求失败: ${url}`, err);
             });
+            // 添加超时处理（30秒）
+            const timeout = setTimeout(() => {
+                cleanupAndAbort(`下载超时: ${url}`);
+            }, 30000);
+            request.on('close', () => {
+                clearTimeout(timeout);
+            });
         });
     }
     /**
@@ -343,14 +408,28 @@ class ResourceCache {
      */
     downloadResource(url, filePath) {
         // 异步执行，不等待完成
-        this.downloadResourceAsync(url, filePath).catch((err) => {
-            console.log('后台下载资源失败:', err);
+        // 如果正在下载，跳过（避免重复下载）
+        if (this._downloadingUrls.has(url)) {
+            return;
+        }
+        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 和文件扩展名；否则返回 false
+     * @returns 如果是 base64 URL，返回 true、文件扩展名、MIME 类型和数据；否则返回 false
      */
     _isBase64DataUrl(url) {
         if (!url.startsWith('data:')) {
@@ -368,16 +447,21 @@ class ResourceCache {
             if (!header.includes('base64')) {
                 return { isBase64: false };
             }
-            // 从 mediatype 中提取文件扩展名
-            // 例如：data:image/png;base64 -> png
-            // 例如：data:image/jpeg;base64 -> jpeg
-            let ext = 'res';
+            // 从 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]) {
-                const mimeType = mimeMatch[1];
-                ext = MIME_TO_EXT[mimeType] || ext;
+                mimeType = mimeMatch[1];
+                // 使用 mime-types 包从 MIME 类型获取扩展名
+                const extension = mime.extension(mimeType);
+                if (extension) {
+                    ext = extension;
+                }
             }
-            return { isBase64: true, ext, data };
+            return { isBase64: true, ext, mimeType, data };
         }
         catch (error) {
             return { isBase64: false };
@@ -404,10 +488,12 @@ class ResourceCache {
      * 手动缓存指定 URL 的资源
      * @param url 要缓存的资源 URL（支持普通 URL 和 base64 data URL）
      * @param force 是否强制重新下载，即使缓存有效（默认 false）
-     * @returns Promise<{ filePath: string, hostPath: string }> 返回缓存文件路径和主机路径
+     * @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) {
+    async cacheUrl(url, force = false, ignoreOrigin = false, onDownloadProgress) {
         // 检查是否是 base64 data URL
         const base64Info = this._isBase64DataUrl(url);
         if (base64Info.isBase64) {
@@ -417,16 +503,28 @@ class ResourceCache {
             }
             // 获取缓存路径（使用检测到的扩展名）
             const cachePath = this.getCachedPath(url, base64Info.ext);
+            const mimeType = base64Info.mimeType || this._getMimeTypeFromExt(base64Info.ext);
             // 如果缓存有效且不强制重新下载，直接返回
             if (!force && await this.isCacheValidAsync(cachePath.filePath)) {
-                return cachePath;
+                const stats = await fs.promises.stat(cachePath.filePath);
+                return {
+                    ...cachePath,
+                    mimeType,
+                    size: stats.size
+                };
             }
             // 保存 base64 数据到文件
             await this._saveBase64ToFile(base64Info.data, cachePath.filePath);
-            return cachePath;
+            // 获取文件大小
+            const stats = await fs.promises.stat(cachePath.filePath);
+            return {
+                ...cachePath,
+                mimeType,
+                size: stats.size
+            };
         }
         // 处理普通 URL
-        const shouldCache = this._getMatchFunction();
+        const shouldCache = ignoreOrigin ? () => true : this._getMatchFunction();
         const isAllowedOrigin = ignoreOrigin ? () => true : this._getOriginAllowFunction();
         // 检查是否匹配缓存规则
         if (!shouldCache(url)) {
@@ -438,40 +536,135 @@ class ResourceCache {
         }
         // 获取缓存路径
         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)) {
-            return cachePath;
+            const stats = await fs.promises.stat(cachePath.filePath);
+            return {
+                ...cachePath,
+                mimeType,
+                size: stats.size
+            };
         }
         // 下载资源
-        await this.downloadResourceAsync(url, cachePath.filePath);
-        return cachePath;
+        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）
-     * @returns Promise<Array<{ url: string, success: boolean, filePath?: string, hostPath?: string, error?: string }>> 返回每个 URL 的缓存结果
+     * @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) {
-        const results = await Promise.allSettled(urls.map(url => this.cacheUrl(url, force, ignoreOrigin)));
-        return results.map((result, index) => {
-            const url = urls[index] || '';
-            if (result.status === 'fulfilled') {
-                return {
+    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.value.filePath,
-                    hostPath: result.value.hostPath
+                    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;
             }
-            else {
-                return {
+            catch (error) {
+                const item = {
                     url,
                     success: false,
-                    error: result.reason?.message || '未知错误'
+                    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 的资源
@@ -553,45 +746,44 @@ class ResourceCache {
         }
     }
     /**
-     * 清理所有缓存文件
+     * 清理所有缓存文件（完全异步版本，性能更好）
      * @returns Promise<{ success: number, failed: number, totalSize: number }> 返回清理统计信息
      */
     async clearCache() {
         try {
-            const files = fs.readdirSync(this.options.cacheDir);
+            const files = await fs.promises.readdir(this.options.cacheDir);
             if (files.length === 0) {
-                console.log('缓存目录为空，无需清理');
                 return { success: 0, failed: 0, totalSize: 0 };
             }
-            // 先统计所有文件大小（避免并行时的竞态条件）
-            const fileInfos = files.map((file) => {
+            // 并行获取所有文件信息（避免并行时的竞态条件）
+            const fileInfos = await Promise.allSettled(files.map(async (file) => {
                 const filePath = path.join(this.options.cacheDir, file);
                 try {
-                    const stats = fs.statSync(filePath);
+                    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 = fileInfos.reduce((sum, info) => sum + info.size, 0);
+            const totalSize = validInfos.reduce((sum, info) => sum + info.size, 0);
             // 并行删除文件，提升性能
-            const deleteResults = await Promise.allSettled(fileInfos.map(async (info) => {
+            const deleteResults = await Promise.allSettled(validInfos.map(async (info) => {
                 try {
                     await fs.promises.unlink(info.filePath);
                     return { success: true, file: info.file };
                 }
                 catch (error) {
-                    console.log(`清理缓存文件失败: ${info.file}`, error);
                     throw error;
                 }
             }));
             // 统计成功和失败数量
             const success = deleteResults.filter(r => r.status === 'fulfilled').length;
             const failed = deleteResults.filter(r => r.status === 'rejected').length;
-            const sizeMB = (totalSize / (1024 * 1024)).toFixed(2);
-            console.log(`缓存清理完成: 成功 ${success} 个, 失败 ${failed} 个, 释放空间 ${sizeMB} MB`);
             return { success, failed, totalSize };
         }
         catch (error) {