@lynker-desktop/electron-window-manager 0.0.9-alpha.7 → 0.0.9-alpha.70

package/renderer/index.js

@@ -7,28 +7,37 @@ const eIpc = require('@lynker-desktop/electron-ipc/renderer');
  * @author Lynker Desktop Team
  * @version 1.0.0
  */
-// ==================== 工具函数 ====================
 /**
- * 获取 IPC 渲染器实例
- * 优先从全局变量获取，回退到 require 方式
- *
- * @returns IpcRenderer 实例或空对象
+ * 通用获取函数：从全局变量或 require 获取模块
+ * @param globalKey 全局对象中的键名
+ * @param requirePath require 路径
+ * @param errorMessage 错误提示信息
+ * @returns 获取到的模块或空对象
  */
-const getIpc = () => {
+const getModule = (globalKey, requirePath, errorMessage) => {
     try {
         // 优先从全局变量获取（预加载脚本注入）
-        const globalIpc = window?.__ELECTRON_WINDOW_MANAGER__?.ipcRenderer;
-        if (globalIpc) {
-            return globalIpc;
+        const globalValue = window?.__ELECTRON_WINDOW_MANAGER__?.[globalKey];
+        if (globalValue) {
+            return globalValue;
         }
         // 回退到 require 方式
-        return window?.require('electron').ipcRenderer;
+        return window?.require?.(requirePath);
     }
     catch (error) {
-        console.error('当前非桌面端环境, 请在桌面端中调用');
+        console.error(errorMessage, error);
         return {};
     }
 };
+/**
+ * 获取 IPC 渲染器实例
+ * 优先从全局变量获取，回退到 require 方式
+ *
+ * @returns IpcRenderer 实例或空对象
+ */
+const getIpc = () => {
+    return getModule('ipcRenderer', 'electron', '当前非桌面端环境, 请在桌面端中调用');
+};
 /**
  * 获取 Electron Remote 模块
  * 优先从全局变量获取，回退到 require 方式
@@ -36,55 +45,95 @@ const getIpc = () => {
  * @returns RemoteType 实例或空对象
  */
 const getRemote = () => {
-    try {
-        // 优先从全局变量获取（预加载脚本注入）
-        const globalRemote = window?.__ELECTRON_WINDOW_MANAGER__?.remote;
-        if (globalRemote) {
-            return globalRemote;
-        }
-        // 回退到 require 方式
-        return window?.require('@electron/remote');
-    }
-    catch (error) {
-        console.error('获取 Remote 模块失败: ', error);
-        return {};
-    }
+    return getModule('remote', '@electron/remote', '获取 Remote 模块失败');
 };
 /**
  * 获取所有窗口的 BrowserView 列表
- * 遍历所有窗口并收集其 BrowserView
+ * 遍历所有窗口并收集其 BrowserView（带缓存优化）
  *
+ * @param forceRefresh 是否强制刷新缓存
  * @returns BrowserView 数组
  */
-const getAllBrowserViews = () => {
-    const remote = getRemote();
-    const allWindows = remote.BrowserWindow.getAllWindows();
-    const allBrowserViews = [];
-    allWindows.forEach(window => {
-        const views = window.getBrowserViews();
-        allBrowserViews.push(...views);
-    });
-    return allBrowserViews;
-};
+const getAllBrowserViews = (() => {
+    let cachedViews = null;
+    let cacheTime = 0;
+    const CACHE_DURATION = 100; // 缓存 100ms
+    return (forceRefresh = false) => {
+        const now = Date.now();
+        if (!forceRefresh && cachedViews && (now - cacheTime < CACHE_DURATION)) {
+            return cachedViews;
+        }
+        const remote = getRemote();
+        try {
+            const allWindows = remote.BrowserWindow?.getAllWindows?.() || [];
+            const allBrowserViews = [];
+            allWindows.forEach(window => {
+                try {
+                    const views = window.getBrowserViews?.() || [];
+                    allBrowserViews.push(...views);
+                }
+                catch (error) {
+                    // 忽略获取 views 失败的情况
+                }
+            });
+            cachedViews = allBrowserViews;
+            cacheTime = now;
+            return allBrowserViews;
+        }
+        catch (error) {
+            console.error('获取 BrowserView 列表失败:', error);
+            return cachedViews || [];
+        }
+    };
+})();
 /**
  * 通过 WebContents 查找对应的 BrowserView
  * 如果找不到已挂载的 BrowserView，则创建虚拟的 BrowserView 对象
  *
  * @param webContent - WebContents 实例
- * @returns BVItem 实例
+ * @returns BVItem 实例或 null
  */
 const getBrowserViewByWebContent = (webContent) => {
-    const allBrowserViews = getAllBrowserViews();
-    const existingView = allBrowserViews.find(view => view.webContents === webContent);
-    // 如果找到已挂载的 BrowserView，直接返回
-    if (existingView) {
-        return existingView;
+    if (!webContent) {
+        return null;
     }
-    // 如果 WebContents 存在但未挂载到窗口，创建虚拟 BrowserView
-    if (webContent && !webContent.isDestroyed?.()) {
+    try {
+        // 检查 webContents 是否已销毁
+        if (webContent.isDestroyed?.()) {
+            return null;
+        }
+        // 查找已挂载的 BrowserView
+        const allBrowserViews = getAllBrowserViews();
+        const existingView = allBrowserViews.find(view => view.webContents === webContent);
+        if (existingView) {
+            return existingView;
+        }
+        // 如果 WebContents 存在但未挂载到窗口，创建虚拟 BrowserView
         return createVirtualBrowserView(webContent);
     }
-    return existingView;
+    catch (error) {
+        console.error('获取 BrowserView 失败:', error);
+        return null;
+    }
+};
+/**
+ * 统一的 IPC 调用封装
+ * @param type IPC 消息类型
+ * @param data IPC 消息数据
+ * @returns Promise<T> IPC 调用结果
+ */
+const invokeIpc = async (type, data) => {
+    try {
+        const ipc = getIpc();
+        if (!ipc || !ipc.invoke) {
+            throw new Error('IPC 不可用');
+        }
+        return await ipc.invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', { type, data });
+    }
+    catch (error) {
+        console.error(`IPC 调用失败 [${type}]:`, error);
+        throw error;
+    }
 };
 /**
  * 创建虚拟的 BrowserView 对象
@@ -94,37 +143,37 @@ const getBrowserViewByWebContent = (webContent) => {
  * @returns 虚拟的 BVItem 对象
  */
 const createVirtualBrowserView = (webContent) => {
+    const webContentId = webContent.id;
     const virtualView = {
-        id: webContent.id,
-        _id: webContent.id,
+        id: webContentId,
+        _id: webContentId,
         _type: 'BV',
         _name: '',
         _extraData: '',
         webContents: webContent,
         // 代理方法，通过 IPC 调用主进程
         getBounds: async () => {
-            const result = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-                type: 'borrowView_getBounds',
-                data: { webContentId: webContent.id, options: {} }
+            return invokeIpc('borrowView_getBounds', {
+                webContentId,
+                options: {}
             });
-            return result;
         },
         setBounds: async (bounds) => {
-            return await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-                type: 'borrowView_setBounds',
-                data: { webContentId: webContent.id, options: bounds }
+            return invokeIpc('borrowView_setBounds', {
+                webContentId,
+                options: bounds
             });
         },
         setAutoResize: async (autoResize) => {
-            return await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-                type: 'borrowView_setAutoResize',
-                data: { webContentId: webContent.id, options: autoResize }
+            return invokeIpc('borrowView_setAutoResize', {
+                webContentId,
+                options: autoResize
             });
         },
         setBackgroundColor: async (color) => {
-            return await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-                type: 'borrowView_setBackgroundColor',
-                data: { webContentId: webContent.id, options: color }
+            return invokeIpc('borrowView_setBackgroundColor', {
+                webContentId,
+                options: color
             });
         },
     };
@@ -137,34 +186,107 @@ const createVirtualBrowserView = (webContent) => {
  * @param data - 窗口数据
  */
 const setWindowProperties = (window, data) => {
-    if (!window)
+    if (!window || !data)
         return;
-    window._name = data.winName || '';
-    window._type = data.winType || '';
-    window._extraData = data.winExtraData || '';
-    window._initUrl = data.winInitUrl || '';
+    try {
+        window._name = data.winName || '';
+        window._type = data.winType || '';
+        window._extraData = data.winExtraData || '';
+        window._initUrl = data.winInitUrl || '';
+        window._zIndex = data.winZIndex ?? 0;
+        // 尝试设置 ID
+        if (data.winId) {
+            try {
+                window.id = Number(data.winId);
+            }
+            catch (error) {
+                // 忽略设置 ID 失败的情况
+            }
+        }
+    }
+    catch (error) {
+        console.error('设置窗口属性失败:', error);
+    }
 };
-async function create(options) {
+/**
+ * 根据 webContents ID 查找窗口实例
+ * 通过 webContents 查找对应的 BrowserWindow 或 BrowserView
+ * 如果是 webview，则找到它的父 BrowserWindow
+ *
+ * @param webContentsId - webContents ID
+ * @returns 窗口实例或 null
+ */
+const findWindowById = (webContentsId) => {
+    if (!webContentsId || webContentsId <= 0) {
+        return null;
+    }
     const remote = getRemote();
-    // 通过 IPC 调用主进程创建窗口
-    const data = await eIpc.RendererIPC.invokeMain('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'create',
-        data: options
-    });
-    // 尝试通过 ID 获取窗口
-    let window = remote.BrowserWindow.fromId(data.winId);
-    // 如果不是 BrowserWindow，尝试获取 BrowserView
-    if (!window) {
-        const webContent = remote.webContents.fromId(data.winId);
-        if (webContent) {
-            window = getBrowserViewByWebContent(webContent);
+    try {
+        // 首先通过 webContentsId 获取 webContents
+        const webContent = remote.webContents?.fromId?.(webContentsId);
+        if (!webContent) {
+            return null;
+        }
+        // Case 1: 查找 BrowserView
+        // 遍历所有窗口的 BrowserView，查找匹配的
+        const allWindows = remote.BrowserWindow?.getAllWindows?.() || [];
+        for (const win of allWindows) {
+            try {
+                const views = win.getBrowserViews?.() || [];
+                for (const view of views) {
+                    if (view.webContents?.id === webContentsId) {
+                        return view;
+                    }
+                }
+            }
+            catch (error) {
+                // 忽略获取 views 失败的情况
+            }
+        }
+        // Case 2: WebView
+        // webview 有 hostWebContents，指向它所在的 BrowserWindow 的 webContents
+        if (webContent.hostWebContents) {
+            const parentWindow = remote.BrowserWindow?.fromWebContents?.(webContent.hostWebContents);
+            if (parentWindow) {
+                return parentWindow;
+            }
+        }
+        // Case 3: 普通 BrowserWindow 本身
+        const browserWindow = remote.BrowserWindow?.fromWebContents?.(webContent);
+        if (browserWindow) {
+            return browserWindow;
         }
+        // Case 4: 如果找不到已挂载的 BrowserView，尝试创建虚拟 BrowserView
+        return getBrowserViewByWebContent(webContent);
     }
-    // 设置窗口属性
-    if (window) {
+    catch (error) {
+        console.error(`查找窗口失败 [${webContentsId}]:`, error);
+    }
+    return null;
+};
+async function create(options) {
+    try {
+        // 通过 IPC 调用主进程创建窗口
+        const data = await eIpc.RendererIPC.invokeMain('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
+            type: 'create',
+            data: options
+        });
+        if (!data?.winId) {
+            throw new Error('创建窗口失败: 未返回有效的窗口 ID');
+        }
+        // 查找窗口实例
+        const window = findWindowById(data.winId);
+        if (!window) {
+            throw new Error(`创建窗口失败: 无法找到窗口实例 [${data.winId}]`);
+        }
+        // 设置窗口属性
         setWindowProperties(window, data);
+        return window;
+    }
+    catch (error) {
+        console.error('创建窗口失败:', error);
+        throw error;
     }
-    return window;
 }
 /**
  * 获取当前窗口实例
@@ -174,7 +296,7 @@ async function create(options) {
 const getCurrentWindow = async () => {
     const remote = getRemote();
     const currentWindow = remote.getCurrentWindow();
-    return await get(currentWindow.id);
+    return await get(currentWindow?.webContents?.id);
 };
 /**
  * 根据 ID 或名称获取窗口
@@ -192,85 +314,70 @@ const getCurrentWindow = async () => {
  * ```
  */
 const get = async (idOrName) => {
-    const remote = getRemote();
-    // 通过 IPC 获取窗口信息
-    const data = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'get',
-        data: idOrName
-    });
-    // 尝试通过 ID 获取窗口
-    let window = remote.BrowserWindow.fromId(data.winId);
-    // 如果不是 BrowserWindow，尝试获取 BrowserView
-    if (!window) {
-        const webContent = remote.webContents.fromId(data.winId);
-        if (webContent) {
-            window = getBrowserViewByWebContent(webContent);
+    try {
+        // 通过 IPC 获取窗口信息
+        const data = await invokeIpc('get', idOrName);
+        if (!data?.winId) {
+            return undefined;
         }
+        // 查找窗口实例
+        const window = findWindowById(data.winId);
+        if (window) {
+            setWindowProperties(window, data);
+        }
+        return window || undefined;
     }
-    // 设置窗口属性
-    if (window) {
-        setWindowProperties(window, data);
+    catch (error) {
+        console.error('获取窗口失败:', error);
+        return undefined;
     }
-    return window;
 };
 async function getAll(type) {
-    const remote = getRemote();
-    // 通过 IPC 获取所有窗口信息
-    const windowData = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'getAll',
-        data: undefined
-    });
-    const allWindows = new Map();
-    const browserWindows = new Map();
-    const browserViews = new Map();
-    const allBrowserWindows = remote.BrowserWindow.getAllWindows();
-    // 遍历窗口数据
-    for (const key in windowData) {
-        const element = windowData[key];
-        let window;
-        // 尝试在 BrowserWindow 中查找
-        window = allBrowserWindows.find(win => `${win.id}` === `${element?.winId}`);
-        // 如果不是 BrowserWindow，尝试获取 BrowserView
-        if (!window) {
-            const webContent = remote.webContents.fromId(element.winId);
-            if (webContent) {
-                window = getBrowserViewByWebContent(webContent);
-            }
+    try {
+        // 通过 IPC 获取所有窗口信息
+        const windowData = await invokeIpc('getAll', undefined);
+        if (!windowData || typeof windowData !== 'object') {
+            return new Map();
         }
-        if (window) {
-            // 设置窗口属性
-            try {
-                window.id = Number(element?.winId);
-            }
-            catch (error) {
-                // 忽略设置 ID 失败的情况
-            }
-            setWindowProperties(window, {
-                winId: element.winId,
-                winName: element.winName,
-                winType: element.winType,
-                winExtraData: element.winExtraData,
-                winInitUrl: element.winInitUrl
-            });
-            const windowId = window.id || window._id;
-            allWindows.set(windowId, window);
-            // 按类型分类
-            if (window._type === 'BW') {
-                browserWindows.set(windowId, window);
+        const allWindows = new Map();
+        const browserWindows = new Map();
+        const browserViews = new Map();
+        // 遍历窗口数据
+        for (const key in windowData) {
+            const element = windowData[key];
+            if (!element?.winId) {
+                continue;
             }
-            else if (window._type === 'BV') {
-                browserViews.set(windowId, window);
+            // 查找窗口实例
+            const window = findWindowById(element.winId);
+            if (window) {
+                // 设置窗口属性
+                setWindowProperties(window, element);
+                // 统一使用 webContents.id 作为键
+                const windowId = window.webContents?.id || element.winId;
+                allWindows.set(windowId, window);
+                // 按类型分类
+                if (window._type === 'BW') {
+                    browserWindows.set(windowId, window);
+                }
+                else if (window._type === 'BV') {
+                    browserViews.set(windowId, window);
+                }
             }
         }
+        // 根据类型返回对应的映射表
+        if (type === 'BW') {
+            return browserWindows;
+        }
+        if (type === 'BV') {
+            return browserViews;
+        }
+        return allWindows;
     }
-    // 根据类型返回对应的映射表
-    if (type === 'BW') {
-        return browserWindows;
-    }
-    if (type === 'BV') {
-        return browserViews;
+    catch (error) {
+        console.error('获取所有窗口失败:', error);
+        return new Map();
     }
-    return allWindows;
 }
 /**
  * 关闭指定窗口
@@ -279,11 +386,14 @@ async function getAll(type) {
  * @returns Promise<boolean> 操作是否成功
  */
 const close = async (idOrName) => {
-    await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'close',
-        data: idOrName
-    });
-    return true;
+    try {
+        await invokeIpc('close', idOrName);
+        return true;
+    }
+    catch (error) {
+        console.error('关闭窗口失败:', error);
+        return false;
+    }
 };
 /**
  * 关闭所有窗口
@@ -291,11 +401,14 @@ const close = async (idOrName) => {
  * @returns Promise<boolean> 操作是否成功
  */
 const closeAll = async () => {
-    await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'closeAll',
-        data: undefined
-    });
-    return true;
+    try {
+        await invokeIpc('closeAll', undefined);
+        return true;
+    }
+    catch (error) {
+        console.error('关闭所有窗口失败:', error);
+        return false;
+    }
 };
 /**
  * 根据 WebContents ID 查找对应的窗口
@@ -303,12 +416,18 @@ const closeAll = async () => {
  * @param webContentId - WebContents ID
  * @returns Promise<BWItem | BVItem | undefined> 窗口实例
  */
-const getWindowForWebContentId = async (webContentId) => {
-    const winId = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'getWindowForWebContentId',
-        data: webContentId
-    });
-    return get(winId);
+const getWindowForWebContentsId = async (webContentId) => {
+    try {
+        const winId = await invokeIpc('getWindowForWebContentsId', webContentId);
+        if (!winId) {
+            return undefined;
+        }
+        return get(winId);
+    }
+    catch (error) {
+        console.error('根据 WebContents ID 查找窗口失败:', error);
+        return undefined;
+    }
 };
 /**
  * 重命名窗口
@@ -318,11 +437,17 @@ const getWindowForWebContentId = async (webContentId) => {
  * @returns Promise<BWItem | BVItem | undefined> 重命名后的窗口实例
  */
 const rename = async (idOrName, newName) => {
-    const data = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'rename',
-        data: { idOrName, newName }
-    });
-    return get(data.winId);
+    try {
+        const data = await invokeIpc('rename', { idOrName, newName });
+        if (!data?.winId) {
+            return undefined;
+        }
+        return get(data.winId);
+    }
+    catch (error) {
+        console.error('重命名窗口失败:', error);
+        return undefined;
+    }
 };
 /**
  * 重置窗口初始化URL
@@ -332,22 +457,31 @@ const rename = async (idOrName, newName) => {
  * @returns Promise<BWItem | BVItem | undefined> 重置后的窗口实例
  */
 const reInitUrl = async (idOrName, url) => {
-    const data = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'reInitUrl',
-        data: { idOrName, url }
-    });
-    return get(data.winId);
+    try {
+        const data = await invokeIpc('reInitUrl', { idOrName, url });
+        if (!data?.winId) {
+            return undefined;
+        }
+        return get(data.winId);
+    }
+    catch (error) {
+        console.error('重置窗口 URL 失败:', error);
+        return undefined;
+    }
 };
 /**
- * 设置预加载 WebContents URL
+ * 设置预加载 WebContents 配置
  *
- * @param preloadWebContentsUrl - 预加载 URL
+ * @param preloadWebContentsConfig - 预加载配置
  */
-const setPreloadWebContentsUrl = async (preloadWebContentsUrl) => {
-    await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-        type: 'setPreloadWebContentsUrl',
-        data: preloadWebContentsUrl
-    });
+const setPreloadWebContentsConfig = async (preloadWebContentsConfig) => {
+    try {
+        await invokeIpc('setPreloadWebContentsConfig', preloadWebContentsConfig);
+    }
+    catch (error) {
+        console.error('设置预加载配置失败:', error);
+        throw error;
+    }
 };
 /**
  * 获取预加载脚本路径
@@ -356,24 +490,46 @@ const setPreloadWebContentsUrl = async (preloadWebContentsUrl) => {
  * @returns Promise<string | undefined> 预加载脚本路径
  */
 const getPreload = (() => {
-    let cachedPreload = undefined;
+    let cachedPreload = null;
+    let isLoading = false;
+    let loadPromise = null;
     return async () => {
         // 如果已有缓存，直接返回
-        if (cachedPreload !== undefined) {
+        if (cachedPreload !== null) {
             return cachedPreload;
         }
-        // 通过 IPC 获取预加载脚本路径
-        const data = await getIpc().invoke('__ELECTRON_WINDOW_MANAGER_IPC_CHANNEL__', {
-            type: 'getPreload',
-            data: undefined,
-        });
-        // 缓存结果
-        cachedPreload = data;
-        return data;
+        // 如果正在加载，返回同一个 Promise
+        if (isLoading && loadPromise) {
+            return loadPromise;
+        }
+        // 开始加载
+        isLoading = true;
+        loadPromise = (async () => {
+            try {
+                // 通过 IPC 获取预加载脚本路径
+                const data = await invokeIpc('getPreload', undefined);
+                // 缓存结果（即使是 undefined 也缓存，避免重复请求）
+                cachedPreload = data;
+                return data;
+            }
+            catch (error) {
+                console.error('获取预加载脚本路径失败:', error);
+                // 失败时也缓存 null，避免重复请求
+                cachedPreload = undefined;
+                return undefined;
+            }
+            finally {
+                isLoading = false;
+                loadPromise = null;
+            }
+        })();
+        return loadPromise;
     };
 })();
-// 初始化时获取预加载脚本
-getPreload();
+// 初始化时异步获取预加载脚本（不阻塞）
+getPreload().catch(() => {
+    // 静默处理初始化失败
+});
 // ==================== 开发工具相关（已注释） ====================
 /*
  * 开发工具相关功能（已注释，可根据需要启用）
@@ -400,8 +556,8 @@ exports.get = get;
 exports.getAll = getAll;
 exports.getCurrentWindow = getCurrentWindow;
 exports.getPreload = getPreload;
-exports.getWindowForWebContentId = getWindowForWebContentId;
+exports.getWindowForWebContentsId = getWindowForWebContentsId;
 exports.reInitUrl = reInitUrl;
 exports.rename = rename;
-exports.setPreloadWebContentsUrl = setPreloadWebContentsUrl;
+exports.setPreloadWebContentsConfig = setPreloadWebContentsConfig;
 //# sourceMappingURL=index.js.map