customer-chat-sdk 1.0.34 → 1.0.36

package/dist/customer-sdk.cjs.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var html2canvas = require('html2canvas');
+
 // 直接使用base64字符串，避免打包后路径问题
 const iconImage = 'data:image/png;base64,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';
 class IconManager {
@@ -6898,25 +6900,62 @@ class ScreenshotManager {
                 }
             }
             let dataUrl;
-            // 等待一小段时间，确保 DOM 更新完成（减少等待时间）
-            await new Promise(resolve => setTimeout(resolve, 50));
             // 根据选择的引擎进行截图
-            if (selectedEngine === 'snapdom') {
+            if (selectedEngine === 'html2canvas') {
+                // html2canvas 需要更长的等待时间确保样式加载
+                // 额外等待样式和字体加载完成
+                await Promise.all([
+                    this.waitForStylesAndFonts(),
+                    this.waitForFonts()
+                ]);
+                // 再等待一段时间，确保样式完全应用
+                await new Promise(resolve => setTimeout(resolve, 200));
+                dataUrl = await this.takeScreenshotWithHtml2Canvas(this.targetElement);
+            }
+            else if (selectedEngine === 'snapdom') {
+                // 等待一小段时间，确保 DOM 更新完成
+                await new Promise(resolve => setTimeout(resolve, 50));
                 dataUrl = await this.takeScreenshotWithSnapdom(this.targetElement);
             }
             else {
                 // 默认使用 modern-screenshot
+                // 等待一小段时间，确保 DOM 更新完成
+                await new Promise(resolve => setTimeout(resolve, 50));
                 dataUrl = await this.takeScreenshotWithModernScreenshot(this.targetElement);
             }
             const timestamp = Date.now();
             // 更新状态
             this.screenshotCount++;
             this.lastScreenshotTime = timestamp;
-            // 管理历史记录
+            // 管理历史记录（限制内存占用）
+            // base64 字符串很大，需要严格控制历史记录数量
             if (this.screenshotHistory.length >= this.options.maxHistory) {
-                this.screenshotHistory.shift();
+                // 删除最旧的截图，释放内存
+                const removed = this.screenshotHistory.shift();
+                // 强制 GC（如果可能）
+                if (removed && removed.length > 1000000) { // 大于1MB的字符串
+                    if (!this.options.silentMode) {
+                        console.log(`📸 清理旧截图，释放内存: ${Math.round(removed.length * 0.75 / 1024)} KB`);
+                    }
+                }
             }
             this.screenshotHistory.push(dataUrl);
+            // 如果历史记录总大小超过限制，清理最旧的
+            let totalSize = this.screenshotHistory.reduce((sum, item) => sum + item.length, 0);
+            const maxTotalSize = 50 * 1024 * 1024; // 最大50MB
+            while (this.screenshotHistory.length > 0 && totalSize > maxTotalSize) {
+                const removed = this.screenshotHistory.shift();
+                if (removed) {
+                    const removedSize = removed.length;
+                    totalSize -= removedSize;
+                    if (!this.options.silentMode) {
+                        console.warn(`📸 ⚠️ 历史记录总大小超过限制，清理最旧截图: ${Math.round(removedSize * 0.75 / 1024)} KB`);
+                    }
+                }
+                else {
+                    break;
+                }
+            }
             // 打印基本信息
             const base64Data = dataUrl.split(',')[1];
             if (!this.options.silentMode) {
@@ -7066,8 +7105,206 @@ class ScreenshotManager {
             throw error;
         }
     }
+    /**
+     * 使用 html2canvas 截图
+     *
+     * 优势：
+     * - 处理 SVG 和本地资源更快（不需要复杂的 Worker 通信）
+     * - 兼容性好，支持更多 CSS 特性
+     * - 跨域处理相对简单
+     *
+     * 劣势：
+     * - 在主线程执行，可能阻塞 UI（但处理速度快，影响较小）
+     * - 不支持 Worker 模式
+     *
+     * 适用场景：
+     * - 页面包含大量 SVG 图标
+     * - 本地资源较多
+     * - 需要快速截图
+     */
+    async takeScreenshotWithHtml2Canvas(element) {
+        if (!this.options.silentMode) {
+            console.log('📸 使用 html2canvas 引擎截图...');
+        }
+        try {
+            // html2canvas 需要确保样式完全加载，额外等待
+            // 等待所有样式表加载完成
+            await this.waitForAllStylesLoaded();
+            // 等待字体加载完成
+            await this.waitForFonts();
+            // 等待 DOM 完全渲染
+            await new Promise(resolve => {
+                requestAnimationFrame(() => {
+                    requestAnimationFrame(() => {
+                        setTimeout(() => resolve(), 100);
+                    });
+                });
+            });
+            // 检查元素是否存在和可见
+            const rect = element.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0) {
+                throw new Error('元素尺寸为 0，无法截图');
+            }
+            const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+            const isLowEndDevice = navigator.hardwareConcurrency && navigator.hardwareConcurrency <= 4;
+            // 计算压缩后的尺寸
+            let elementWidth = element.scrollWidth || element.clientWidth || element.offsetWidth;
+            let elementHeight = element.scrollHeight || element.clientHeight || element.offsetHeight;
+            if (element === document.body || element === document.documentElement) {
+                elementWidth = Math.max(element.scrollWidth, element.offsetWidth, document.documentElement.scrollWidth, document.documentElement.offsetWidth, window.innerWidth);
+                elementHeight = Math.max(element.scrollHeight, element.offsetHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight, window.innerHeight);
+            }
+            const { width, height } = this.calculateCompressedSize(elementWidth, elementHeight, this.options.maxWidth, this.options.maxHeight);
+            const finalWidth = width < elementWidth ? width : Math.min(elementWidth, this.options.maxWidth);
+            const finalHeight = height < elementHeight ? height : Math.min(elementHeight, this.options.maxHeight);
+            // html2canvas 质量设置（0-1）
+            const finalQuality = isMobile || isLowEndDevice
+                ? Math.max(this.options.quality * 0.65, 0.2)
+                : this.options.quality;
+            // html2canvas 配置选项
+            const options = {
+                // 基本配置
+                backgroundColor: '#ffffff',
+                scale: this.options.scale !== 1 ? (isMobile ? 0.7 : this.options.scale) : (isMobile ? 0.7 : 1),
+                useCORS: this.options.enableCORS,
+                allowTaint: !this.options.enableCORS, // 如果启用 CORS，不允许 taint
+                logging: !this.options.silentMode,
+                width: finalWidth,
+                height: finalHeight,
+                // 关键配置：确保样式正确渲染
+                foreignObjectRendering: false, // 禁用 foreignObject，使用传统渲染方式（更稳定）
+                onclone: (_clonedDoc, _element) => {
+                    // 在克隆的文档中，确保所有样式都正确应用
+                    // html2canvas 会自动处理样式，这里不需要手动复制
+                    // 如果需要，可以在这里添加额外的样式处理逻辑
+                    // 复制所有样式表到克隆的文档
+                    const originalStyleSheets = Array.from(document.styleSheets);
+                    originalStyleSheets.forEach((originalSheet) => {
+                        try {
+                            // 检查样式表是否可访问
+                            if (originalSheet.cssRules) {
+                                // 样式表可访问，html2canvas 会自动处理
+                            }
+                        }
+                        catch (e) {
+                            // 跨域样式表无法访问，html2canvas 会尝试其他方式
+                        }
+                    });
+                },
+                // 性能优化
+                removeContainer: true, // 截图后移除临时容器
+                imageTimeout: this.options.imageLoadTimeout || 5000,
+                // 忽略某些元素（可选，提升性能）
+                ignoreElements: (element) => {
+                    // 忽略隐藏元素
+                    const style = window.getComputedStyle(element);
+                    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
+                        return true;
+                    }
+                    return false;
+                },
+            };
+            // html2canvas 不支持直接的 proxy 选项，需要通过 onclone 钩子处理图片
+            // 如果配置了代理服务器，在克隆时替换图片 URL
+            if (this.options.useProxy && this.options.proxyUrl && this.options.proxyUrl.trim() !== '') {
+                options.onclone = (clonedDoc) => {
+                    // 在克隆的文档中，替换所有跨域图片的 src
+                    const images = clonedDoc.querySelectorAll('img');
+                    images.forEach((img) => {
+                        const originalSrc = img.getAttribute('src');
+                        if (!originalSrc)
+                            return;
+                        // 检查是否是跨域图片
+                        try {
+                            const imgUrl = new URL(originalSrc, window.location.href);
+                            if (imgUrl.origin === window.location.origin) {
+                                return; // 同源图片，不需要处理
+                            }
+                        }
+                        catch {
+                            // URL 解析失败，可能是相对路径，继续处理
+                        }
+                        // 检查缓存
+                        const cachedDataUrl = this.getCachedImage(originalSrc);
+                        if (cachedDataUrl) {
+                            img.src = cachedDataUrl;
+                            return;
+                        }
+                        // 对于跨域图片，使用代理 URL
+                        // html2canvas 会自动处理，但我们可以预先处理
+                        // 注意：html2canvas 会自己处理图片加载，这里主要是为了缓存
+                    });
+                };
+            }
+            if (!this.options.silentMode) {
+                console.log(`📸 html2canvas 配置: 尺寸 ${finalWidth}x${finalHeight}, 质量 ${finalQuality.toFixed(2)}, 缩放 ${options.scale}`);
+            }
+            // 执行截图
+            const canvas = await html2canvas(element, options);
+            // 根据输出格式转换
+            let mimeType = 'image/png';
+            let finalQualityForExport = undefined;
+            if (this.options.outputFormat === 'webp' && !isMobile) {
+                try {
+                    const testCanvas = document.createElement('canvas');
+                    testCanvas.width = 1;
+                    testCanvas.height = 1;
+                    const testDataUrl = testCanvas.toDataURL('image/webp');
+                    if (testDataUrl.indexOf('webp') !== -1) {
+                        mimeType = 'image/webp';
+                        finalQualityForExport = finalQuality;
+                    }
+                }
+                catch {
+                    mimeType = 'image/jpeg';
+                    finalQualityForExport = finalQuality;
+                }
+            }
+            else if (this.options.outputFormat === 'jpeg') {
+                mimeType = 'image/jpeg';
+                finalQualityForExport = finalQuality;
+            }
+            // 转换为 data URL
+            const dataUrl = mimeType === 'image/png'
+                ? canvas.toDataURL(mimeType)
+                : canvas.toDataURL(mimeType, finalQualityForExport);
+            // 验证结果
+            if (!dataUrl || dataUrl.length < 100) {
+                throw new Error('生成的截图数据无效或过短');
+            }
+            if (!this.options.silentMode) {
+                console.log(`📸 html2canvas 截图成功！格式: ${this.options.outputFormat}, 尺寸: ${canvas.width}x${canvas.height}`);
+            }
+            return dataUrl;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!this.options.silentMode) {
+                console.error('📸 html2canvas 截图失败:', errorMessage);
+                if (errorMessage.includes('CORS') || errorMessage.includes('cross-origin')) {
+                    console.warn('📸 💡 建议：配置 proxyUrl 选项处理跨域图片');
+                }
+            }
+            throw error;
+        }
+    }
     /**
      * 使用 modern-screenshot 截图（启用 Worker）
+     *
+     * 优势：
+     * - 使用 Worker，不阻塞主线程 UI
+     * - 支持并发处理
+     * - 适合复杂页面
+     *
+     * 劣势：
+     * - 处理 SVG 和本地资源较慢（Worker 通信开销）
+     * - 配置相对复杂
+     * - 需要处理 Worker URL
+     *
+     * 适用场景：
+     * - 复杂页面，需要不阻塞 UI
+     * - 需要高质量截图
+     * - 页面资源较少
      */
     async takeScreenshotWithModernScreenshot(element) {
         if (!this.options.silentMode) {
@@ -7360,37 +7597,49 @@ class ScreenshotManager {
                     throw new Error('无法获取 canvas context');
                 }
                 const img = new Image();
-                await new Promise((resolve, reject) => {
-                    img.onload = () => {
-                        canvas.width = img.width;
-                        canvas.height = img.height;
-                        ctx.drawImage(img, 0, 0);
-                        resolve();
-                    };
-                    img.onerror = reject;
-                    img.src = dataUrl;
-                });
-                let mimeType = 'image/jpeg';
-                // 使用与 createContext 相同的质量设置
-                let conversionQuality = finalQuality;
-                if (this.options.outputFormat === 'webp' && !isMobile) {
-                    try {
-                        const testCanvas = document.createElement('canvas');
-                        testCanvas.width = 1;
-                        testCanvas.height = 1;
-                        const testDataUrl = testCanvas.toDataURL('image/webp');
-                        if (testDataUrl.indexOf('webp') !== -1) {
-                            mimeType = 'image/webp';
+                let convertedDataUrl;
+                try {
+                    await new Promise((resolve, reject) => {
+                        img.onload = () => {
+                            canvas.width = img.width;
+                            canvas.height = img.height;
+                            ctx.drawImage(img, 0, 0);
+                            resolve();
+                        };
+                        img.onerror = reject;
+                        img.src = dataUrl;
+                    });
+                    let mimeType = 'image/jpeg';
+                    // 使用与 createContext 相同的质量设置
+                    let conversionQuality = finalQuality;
+                    if (this.options.outputFormat === 'webp' && !isMobile) {
+                        try {
+                            const testCanvas = document.createElement('canvas');
+                            testCanvas.width = 1;
+                            testCanvas.height = 1;
+                            const testDataUrl = testCanvas.toDataURL('image/webp');
+                            if (testDataUrl.indexOf('webp') !== -1) {
+                                mimeType = 'image/webp';
+                            }
+                        }
+                        catch {
+                            mimeType = 'image/jpeg';
                         }
                     }
-                    catch {
-                        mimeType = 'image/jpeg';
-                    }
+                    // 使用优化后的质量进行格式转换
+                    convertedDataUrl = mimeType === 'image/png'
+                        ? canvas.toDataURL(mimeType)
+                        : canvas.toDataURL(mimeType, conversionQuality);
+                }
+                finally {
+                    // 清理资源，释放内存
+                    img.src = ''; // 清除图片引用
+                    img.onload = null;
+                    img.onerror = null;
+                    canvas.width = 0; // 清空 canvas
+                    canvas.height = 0;
+                    ctx.clearRect(0, 0, 0, 0); // 清除绘制内容
                 }
-                // 使用优化后的质量进行格式转换
-                const convertedDataUrl = mimeType === 'image/png'
-                    ? canvas.toDataURL(mimeType)
-                    : canvas.toDataURL(mimeType, conversionQuality);
                 return convertedDataUrl;
             }
             return dataUrl;
@@ -7411,15 +7660,34 @@ class ScreenshotManager {
             throw error;
         }
         finally {
-            // 每次截图后清理 context，下次重新创建（确保元素状态最新）
+            // 每次截图后立即清理 context，释放 Worker 和内存
+            // 这是防止内存泄漏的关键步骤
             if (this.screenshotContext) {
                 try {
                     destroyContext(this.screenshotContext);
+                    if (!this.options.silentMode) {
+                        console.log('📸 ✅ modern-screenshot context 已清理');
+                    }
                 }
                 catch (e) {
-                    // 忽略清理错误
+                    if (!this.options.silentMode) {
+                        console.warn('📸 ⚠️ 清理 context 失败:', e);
+                    }
+                }
+                finally {
+                    // 确保 context 引用被清除
+                    this.screenshotContext = null;
+                }
+            }
+            // 强制触发垃圾回收（如果可能）
+            // 注意：这需要浏览器支持，不是所有浏览器都有效
+            if (typeof window !== 'undefined' && window.gc && typeof window.gc === 'function') {
+                try {
+                    window.gc();
+                }
+                catch {
+                    // 忽略 GC 错误
                 }
-                this.screenshotContext = null;
             }
         }
     }
@@ -7994,15 +8262,42 @@ class ScreenshotManager {
         }
     }
     /**
-     * 等待 CSS 和字体加载完成（优化：减少等待时间，使用 requestAnimationFrame）
+     * 等待 CSS 和字体加载完成
+     * html2canvas 需要确保所有样式表都加载完成才能正确截图
      */
     async waitForStylesAndFonts() {
-        // 使用 requestAnimationFrame 优化渲染时机
-        return new Promise((resolve) => {
-            requestAnimationFrame(() => {
-                setTimeout(() => {
+        // 等待所有样式表加载完成
+        const styleSheets = Array.from(document.styleSheets);
+        const styleSheetPromises = styleSheets.map((sheet) => {
+            return new Promise((resolve) => {
+                try {
+                    // 检查样式表是否已加载
+                    // 尝试访问 cssRules，如果成功说明样式表已加载
+                    const rules = sheet.cssRules;
+                    if (rules) {
+                        resolve();
+                    }
+                    else {
+                        // 如果样式表还在加载，等待一下
+                        setTimeout(() => resolve(), 100);
+                    }
+                }
+                catch (e) {
+                    // 跨域样式表可能无法访问，忽略错误
                     resolve();
-                }, 30); // 减少到30ms
+                }
+            });
+        });
+        await Promise.all(styleSheetPromises);
+        // 使用 requestAnimationFrame 确保 DOM 已渲染
+        await new Promise((resolve) => {
+            requestAnimationFrame(() => {
+                requestAnimationFrame(() => {
+                    // 额外等待，确保样式应用完成
+                    setTimeout(() => {
+                        resolve();
+                    }, 100); // 增加到100ms，确保样式加载
+                });
             });
         });
     }
@@ -8021,6 +8316,52 @@ class ScreenshotManager {
             // 忽略错误
         }
     }
+    /**
+     * 等待所有样式表加载完成（html2canvas 专用）
+     */
+    async waitForAllStylesLoaded() {
+        const styleSheets = Array.from(document.styleSheets);
+        const promises = [];
+        styleSheets.forEach((sheet) => {
+            promises.push(new Promise((resolve) => {
+                try {
+                    // 尝试访问样式表规则，如果成功说明样式表已加载
+                    const rules = sheet.cssRules;
+                    if (rules) {
+                        resolve();
+                    }
+                    else {
+                        // 等待样式表加载
+                        const checkInterval = setInterval(() => {
+                            try {
+                                if (sheet.cssRules) {
+                                    clearInterval(checkInterval);
+                                    resolve();
+                                }
+                            }
+                            catch {
+                                // 跨域样式表无法访问，直接 resolve
+                                clearInterval(checkInterval);
+                                resolve();
+                            }
+                        }, 50);
+                        // 超时保护（5秒）
+                        setTimeout(() => {
+                            clearInterval(checkInterval);
+                            resolve();
+                        }, 5000);
+                    }
+                }
+                catch (e) {
+                    // 跨域样式表无法访问，直接 resolve
+                    resolve();
+                }
+            }));
+        });
+        await Promise.all(promises);
+        // 额外等待，确保样式应用
+        await new Promise(resolve => setTimeout(resolve, 150));
+    }
     /**
      * 计算压缩后的尺寸
      */
@@ -8237,6 +8578,11 @@ class ScreenshotManager {
         }
         // 清理图片代理缓存
         this.imageProxyCache.clear();
+        // 清理截图历史记录（释放大量内存）
+        this.screenshotHistory.length = 0;
+        // 清理图片下载队列
+        this.imageDownloadQueue.clear();
+        this.activeDownloads.clear();
     }
     /**
      * 获取缓存的图片（检查是否过期）
@@ -8258,8 +8604,34 @@ class ScreenshotManager {
     }
     /**
      * 设置缓存的图片（带时间戳）
+     * 添加内存大小限制，防止缓存无限增长
      */
     setCachedImage(url, dataUrl) {
+        // 估算当前缓存总大小（MB）
+        let totalSizeMB = 0;
+        this.imageProxyCache.forEach((cached) => {
+            totalSizeMB += cached.dataUrl.length * 0.75 / (1024 * 1024); // base64 转字节再转MB
+        });
+        // 添加新项的大小
+        const newItemSizeMB = dataUrl.length * 0.75 / (1024 * 1024);
+        const maxCacheSizeMB = 100; // 最大100MB内存缓存
+        // 如果超过限制，清理最旧的缓存
+        if (totalSizeMB + newItemSizeMB > maxCacheSizeMB) {
+            const sortedEntries = Array.from(this.imageProxyCache.entries())
+                .sort((a, b) => a[1].timestamp - b[1].timestamp); // 按时间排序
+            let currentSizeMB = totalSizeMB;
+            for (const [key, value] of sortedEntries) {
+                if (currentSizeMB + newItemSizeMB <= maxCacheSizeMB) {
+                    break;
+                }
+                const itemSizeMB = value.dataUrl.length * 0.75 / (1024 * 1024);
+                this.imageProxyCache.delete(key);
+                currentSizeMB -= itemSizeMB;
+                if (!this.options.silentMode) {
+                    console.log(`📸 清理内存缓存（超过限制）: ${key.substring(0, 50)}...`);
+                }
+            }
+        }
         this.imageProxyCache.set(url, {
             dataUrl,
             timestamp: Date.now()
@@ -8286,9 +8658,10 @@ class ScreenshotManager {
     }
     /**
      * 定期清理过期缓存（可选，在截图时也会自动清理）
+     * 增加清理频率，防止内存积累
      */
     startCacheCleanup() {
-        // 每5分钟清理一次过期缓存
+        // 每2分钟清理一次过期缓存（从5分钟改为2分钟，更频繁）
         setInterval(() => {
             this.cleanExpiredCache();
             // 如果启用 IndexedDB，也清理 IndexedDB 缓存
@@ -8299,9 +8672,12 @@ class ScreenshotManager {
             }
             if (!this.options.silentMode) {
                 const memoryCacheSize = this.imageProxyCache.size;
-                console.log(`📸 清理过期缓存，内存缓存数量: ${memoryCacheSize}`);
+                const memoryCacheSizeMB = Array.from(this.imageProxyCache.values())
+                    .reduce((sum, cached) => sum + cached.dataUrl.length * 0.75 / (1024 * 1024), 0);
+                const historySizeMB = this.screenshotHistory.reduce((sum, item) => sum + item.length * 0.75 / (1024 * 1024), 0);
+                console.log(`📸 清理过期缓存，内存缓存: ${memoryCacheSize} 项，${memoryCacheSizeMB.toFixed(2)} MB，历史记录: ${historySizeMB.toFixed(2)} MB`);
             }
-        }, 300000); // 5分钟
+        }, 120000); // 2分钟（从5分钟改为2分钟，更频繁清理）
     }
     /**
      * 获取状态