@lynker-desktop/electron-ipc/esm/renderer/index.js

electron-ipc

import { getRandomUUID } from '../common/index.js';
export { WINDOWL_GLOBAL_KEY } from '../common/index.js';

const getIpc = () => {
    try {
        // @ts-ignore
        return window.__ELECTRON_IPC__ || window?.require('electron').ipcRenderer;
    }
    catch (error) {
        console.error('当前非桌面端环境, 请在桌面端中调用');
        return {};
    }
};
class RendererIPC {
    /**
     * 原生ipcRenderer
     */
    static get ipcRenderer() {
        return getIpc();
    }
    /**
     * 发送给主进程消息
     * 使用 Electron 原生的 invoke 方法，支持并发请求
     * @param channel 消息通道名称
     * @param args 传递给处理器的参数
     * @returns Promise<any> 返回处理结果
     */
    static async invokeMain(channel, ...args) {
        return await RendererIPC.ipcRenderer.invoke(channel, ...args);
    }
    /**
     * 处理主进程发送过来的消息
     * 支持 requestId 机制，确保并发请求正确匹配
     * @param channel 消息通道名称
     * @param handler 处理函数，接收除 requestId 外的所有参数
     */
    static handleMain(channel, handler) {
        RendererIPC.ipcRenderer.on(channel, async (_event, requestId, ...args) => {
            const result = await handler(...args);
            RendererIPC.ipcRenderer.send(`${channel}-reply-${requestId}`, result);
        });
        return {
            cancel: () => {
                RendererIPC.ipcRenderer.removeListener(channel, handler);
            }
        };
    }
    /**
     * 发送给渲染进程消息
     * 使用唯一的 requestId 确保并发请求不会互相干扰
     * @param channel 消息通道名称
     * @param args 传递给渲染进程的参数
     * @returns Promise<any> 返回渲染进程的处理结果
     */
    static invokeRenderer(channel, ...args) {
        return new Promise(resolve => {
            const requestId = getRandomUUID();
            RendererIPC.ipcRenderer.once(`${channel}-reply-${requestId}`, (_event, result) => {
                resolve(result);
            });
            RendererIPC.ipcRenderer.send('relay-message', { channel, requestId, args });
        });
    }
    /**
     * 发送给指定渲染进程消息
     * 使用唯一的 requestId 确保并发请求不会互相干扰
     * @param targetWindowId 目标窗口ID
     * @param channel 消息通道名称
     * @param args 传递给渲染进程的参数
     * @returns Promise<any> 返回渲染进程的处理结果
     */
    static invokeRendererByWinId(targetWindowId, channel, ...args) {
        return new Promise(resolve => {
            const requestId = getRandomUUID();
            RendererIPC.ipcRenderer.once(`${channel}-reply-${requestId}`, (_event, result) => {
                resolve(result);
            });
            RendererIPC.ipcRenderer.send('relay-message', { targetWindowId, channel, requestId, args });
        });
    }
    /**
     * 处理渲染进程发送过来的消息
     * 支持 requestId 机制，确保并发请求正确匹配
     * @param channel 消息通道名称
     * @param handler 处理函数，接收除 requestId 外的所有参数
     */
    static handleRenderer(channel, handler) {
        RendererIPC.ipcRenderer.on(channel, async (_event, requestId, ...args) => {
            const result = await handler(...args);
            RendererIPC.ipcRenderer.send('relay-reply', { originalChannel: channel, requestId, result });
        });
        return {
            cancel: () => {
                RendererIPC.ipcRenderer.removeListener(channel, handler);
            }
        };
    }
    /**
     * 获取当前渲染进程id
     */
    static async getCurrentWebContentId() {
        return new Promise(resolve => {
            const channel = `__GetCurrentWebContentId__`;
            RendererIPC.ipcRenderer.once(`${channel}-reply`, (_event, result) => {
                resolve(result);
            });
            RendererIPC.ipcRenderer.send(channel);
        });
    }
    /**
     * 打开当前窗口的开发者工具
     * @returns
     */
    static async openCurrentWebContentDevTools() {
        return new Promise(resolve => {
            const channel = `__OpenCurrentWebContentDevTools__`;
            RendererIPC.ipcRenderer.once(`${channel}-reply`, (_event, result) => {
                resolve(result);
            });
            RendererIPC.ipcRenderer.send(channel);
        });
    }
}

export { RendererIPC, getIpc };
//# sourceMappingURL=index.js.map