js-rpc2 2.4.1 → 2.4.2

package/README.md

@@ -338,7 +338,7 @@ ipcMain.on('port', (event) => {
 import { ipcRenderer } from 'electron/renderer'
 
 window.onmessage = (/** @type {MessageEvent} */ event) => {
-    if (event.origin == location.origin && event.data != 'port') {
+    if (event.isTrusted && event.data == 'port') {
         ipcRenderer.postMessage('port', null, [event.ports[0]])
     }
 }

package/doc/chrome-extensions.md

@@ -1,133 +1,133 @@
-# Chrome Extensions RPC 通信使用说明
-
-## 概述
-
-本项目使用 `js-rpc2` 库实现在 Chrome 扩展各组件间的远程过程调用（RPC）通信，支持在 popup、content scripts 和 background 之间进行双向通信。
-
-## 项目结构
-
-### 组件说明
-
-- **background.js**: 后台脚本，提供核心服务接口
-- **content_scripts.js**: 内容脚本，运行在网页上下文中，可作为通信中继
-- **popup.js**: 扩展弹窗界面，用户交互入口
-
-## 核心实现
-
-### Background 脚本
-
-```javascript
-import {createRpcServerChromeExtensions} from 'js-rpc2/src/lib.js'
-
-export class RpcBackgroundApi {
-    /**
-     * 带回调的示例方法
-     * @param {(progress: string, date: Date) => Promise<void>} cb - 回调函数
-     */
-    async callback(cb) {
-        for (let i = 0; i < 10; i++) {
-            await sleep(1000)
-            await cb(`from background index is ${i}`, new Date())
-        }
-        return 'over!'
-    }
-}
-
-// 创建RPC服务端点
-createRpcServerChromeExtensions({ 
-    chrome, 
-    key: 'rpc-popup->background', 
-    extension: new RpcBackgroundApi()
-})
-
-createRpcServerChromeExtensions({ 
-    chrome, 
-    key: 'rpc-content-scripts->background', 
-    extension: new RpcBackgroundApi()
-})
-```
-
-### Content Scripts 脚本
-
-```javascript
-import {createRpcServerChromeExtensions, createRpcClientChromeExtensions} from 'js-rpc2/src/lib.js'
-
-export class RpcContentScriptsApi {
-    async callBackgroundWithCallback(name, callback) {
-        return await rpcContentScriptBackground.callback(callback)
-    }
-}
-
-// 创建RPC服务端点供popup调用
-createRpcServerChromeExtensions({
-    chrome, 
-    key: 'rpc-popup->content-script', 
-    extension: new RpcContentScriptsApi()
-})
-
-// 创建RPC客户端连接到background
-export const rpcContentScriptBackground = createRpcClientChromeExtensions({
-    chrome, 
-    key: 'rpc-content-scripts->background'
-})
-```
-
-### Popup 脚本
-
-```javascript
-import {createRpcClientChromeExtensions} from 'js-rpc2/src/lib.js'
-
-// 获取当前活动标签页
-const [tab] = await chrome.tabs.query({ active: true, currentWindow: true })
-
-// 创建RPC客户端
-export const rpcPopupContentScripts = createRpcClientChromeExtensions({
-    chrome, 
-    key: 'rpc-popup->content-script', 
-    tabId: tab.id
-})
-
-export const rpcPopupBackground = createRpcClientChromeExtensions({
-    chrome, 
-    key: 'rpc-popup->background'
-})
-
-// 使用示例
-let resp = await rpcPopupContentScripts.callBackgroundWithCallback("name", async (progress, date) => {
-    console.info('at popup callback', progress, date)
-})
-console.info("over!", resp)
-
-let resp2 = await rpcPopupBackground.callback(async (progress, date) => {
-    console.info('at popup callback', progress, date)
-})
-console.info("over!", resp2)
-```
-
-## 通信模式
-
-### 直接通信
-Popup → Background
-```javascript
-rpcPopupBackground.callback(callbackFunction)
-```
-
-### 间接通信
-Popup → Content Script → Background
-```javascript
-rpcPopupContentScripts.callBackgroundWithCallback(name, callbackFunction)
-```
-
-## 使用方法
-
-1. 在各组件中导入相应的 RPC 创建函数
-2. 定义服务接口类
-3. 使用 `createRpcServerChromeExtensions` 创建服务端点
-4. 使用 `createRpcClientChromeExtensions` 创建客户端连接
-5. 通过客户端实例调用远程方法
-
-## 注意事项
-
-- 确保 manifest.json 中正确配置了各组件的权限和通信策略
-- 注意处理异步回调的生命周期管理
+# Chrome Extensions RPC 通信使用说明
+
+## 概述
+
+本项目使用 `js-rpc2` 库实现在 Chrome 扩展各组件间的远程过程调用（RPC）通信，支持在 popup、content scripts 和 background 之间进行双向通信。
+
+## 项目结构
+
+### 组件说明
+
+- **background.js**: 后台脚本，提供核心服务接口
+- **content_scripts.js**: 内容脚本，运行在网页上下文中，可作为通信中继
+- **popup.js**: 扩展弹窗界面，用户交互入口
+
+## 核心实现
+
+### Background 脚本
+
+```javascript
+import {createRpcServerChromeExtensions} from 'js-rpc2/src/lib.js'
+
+export class RpcBackgroundApi {
+    /**
+     * 带回调的示例方法
+     * @param {(progress: string, date: Date) => Promise<void>} cb - 回调函数
+     */
+    async callback(cb) {
+        for (let i = 0; i < 10; i++) {
+            await sleep(1000)
+            await cb(`from background index is ${i}`, new Date())
+        }
+        return 'over!'
+    }
+}
+
+// 创建RPC服务端点
+createRpcServerChromeExtensions({ 
+    chrome, 
+    key: 'rpc-popup->background', 
+    extension: new RpcBackgroundApi()
+})
+
+createRpcServerChromeExtensions({ 
+    chrome, 
+    key: 'rpc-content-scripts->background', 
+    extension: new RpcBackgroundApi()
+})
+```
+
+### Content Scripts 脚本
+
+```javascript
+import {createRpcServerChromeExtensions, createRpcClientChromeExtensions} from 'js-rpc2/src/lib.js'
+
+export class RpcContentScriptsApi {
+    async callBackgroundWithCallback(name, callback) {
+        return await rpcContentScriptBackground.callback(callback)
+    }
+}
+
+// 创建RPC服务端点供popup调用
+createRpcServerChromeExtensions({
+    chrome, 
+    key: 'rpc-popup->content-script', 
+    extension: new RpcContentScriptsApi()
+})
+
+// 创建RPC客户端连接到background
+export const rpcContentScriptBackground = createRpcClientChromeExtensions({
+    chrome, 
+    key: 'rpc-content-scripts->background'
+})
+```
+
+### Popup 脚本
+
+```javascript
+import {createRpcClientChromeExtensions} from 'js-rpc2/src/lib.js'
+
+// 获取当前活动标签页
+const [tab] = await chrome.tabs.query({ active: true, currentWindow: true })
+
+// 创建RPC客户端
+export const rpcPopupContentScripts = createRpcClientChromeExtensions({
+    chrome, 
+    key: 'rpc-popup->content-script', 
+    tabId: tab.id
+})
+
+export const rpcPopupBackground = createRpcClientChromeExtensions({
+    chrome, 
+    key: 'rpc-popup->background'
+})
+
+// 使用示例
+let resp = await rpcPopupContentScripts.callBackgroundWithCallback("name", async (progress, date) => {
+    console.info('at popup callback', progress, date)
+})
+console.info("over!", resp)
+
+let resp2 = await rpcPopupBackground.callback(async (progress, date) => {
+    console.info('at popup callback', progress, date)
+})
+console.info("over!", resp2)
+```
+
+## 通信模式
+
+### 直接通信
+Popup → Background
+```javascript
+rpcPopupBackground.callback(callbackFunction)
+```
+
+### 间接通信
+Popup → Content Script → Background
+```javascript
+rpcPopupContentScripts.callBackgroundWithCallback(name, callbackFunction)
+```
+
+## 使用方法
+
+1. 在各组件中导入相应的 RPC 创建函数
+2. 定义服务接口类
+3. 使用 `createRpcServerChromeExtensions` 创建服务端点
+4. 使用 `createRpcClientChromeExtensions` 创建客户端连接
+5. 通过客户端实例调用远程方法
+
+## 注意事项
+
+- 确保 manifest.json 中正确配置了各组件的权限和通信策略
+- 注意处理异步回调的生命周期管理
 - 建议为所有 RPC 接口添加适当的错误处理机制

package/doc/electron.md

@@ -1,138 +1,138 @@
-# Electron RPC 通信使用说明
-
-## 概述
-
-本文档介绍如何在 Electron 应用中使用 `js-rpc2` 库实现主进程与渲染进程之间的 RPC 通信。通过 MessagePort 机制，实现跨进程的远程方法调用。
-
-## 项目结构
-
-### 组件说明
-
-- **main.js**: Electron 主进程，提供核心服务接口
-- **preload.js**: 预加载脚本，建立主进程与渲染进程的通信桥梁
-- **renderer.js**: 渲染进程，运行在浏览器环境中
-- **usage.js**: 使用示例，展示如何调用 RPC 方法
-
-## 核心实现
-
-### 主进程 (main.js)
-
-```javascript
-import { ipcMain } from 'electron'
-import { createRpcServerElectronMessagePort } from 'js-rpc2/src/lib.js'
-
-class AppApi {
-    asyncLocalStorage = new AsyncLocalStorage()
-
-    async hello(param) {
-        return 'wertyuioiuytre ' + param
-    }
-}
-
-// 监听来自渲染进程的 port 消息
-ipcMain.on('port', (event) => {
-    const port = event.ports[0]
-    // 创建 RPC 服务端点
-    createRpcServerElectronMessagePort({ 
-        port, 
-        rpcKey: '', 
-        extension: new AppApi() 
-    })
-    port.start()
-})
-```
-
-### 预加载脚本 (preload.js)
-
-```javascript
-import { ipcRenderer } from 'electron/renderer'
-
-// 监听来自渲染进程的消息
-window.onmessage = (/** @type {MessageEvent} */ event) => {
-    // 验证消息来源并转发给主进程
-    if (event.origin == location.origin && event.data != 'port') {
-        ipcRenderer.postMessage('port', null, [event.ports[0]])
-    }
-}
-```
-
-### 渲染进程 (renderer.js)
-
-```javascript
-import { createRpcClientMessagePort } from 'js-rpc2/src/lib.js'
-
-// 创建消息通道
-const channel = new MessageChannel();
-
-// 向主进程发送端口
-window.postMessage("port", location.origin, [channel.port1]);
-
-// 创建 RPC 客户端
-let rpc = createRpcClientMessagePort({ 
-    port: channel.port2, 
-    rpcKey: "" 
-});
-```
-
-### 使用示例 (usage.js)
-
-```javascript
-async function postPortMessage() {
-    // 调用远程方法
-    let ret = await rpc.hello('6667');
-    console.info("ret from rpc:", ret);
-}
-```
-
-## 通信流程
-
-1. 渲染进程创建 `MessageChannel` 并通过 `postMessage` 将 `port1` 发送到预加载脚本
-2. 预加载脚本验证消息来源并将端口转发给主进程
-3. 主进程接收端口并创建 RPC 服务端点
-4. 渲染进程使用 `port2` 创建 RPC 客户端
-5. 客户端可以调用主进程中定义的服务方法
-
-## 使用方法
-
-### 1. 主进程设置
-
-在主进程中定义服务类并创建 RPC 服务：
-
-```javascript
-class AppApi {
-    async yourMethod(params) {
-        // 实现业务逻辑
-        return result;
-    }
-}
-
-ipcMain.on('port', (event) => {
-    const port = event.ports[0]
-    createRpcServerElectronMessagePort({ 
-        port, 
-        rpcKey: '', 
-        extension: new AppApi() 
-    })
-    port.start()
-})
-```
-
-### 2. 渲染进程调用
-
-在渲染进程中建立连接并调用远程方法：
-
-```javascript
-const channel = new MessageChannel();
-window.postMessage("port", location.origin, [channel.port1]);
-let rpc = createRpcClientMessagePort({ port: channel.port2, rpcKey: "" });
-
-// 调用远程方法
-let result = await rpc.yourMethod(params);
-```
-
-## 注意事项
-
-- 确保在 Electron 的安全策略下正确配置 `contextIsolation` 和 `sandbox` 选项
-- 预加载脚本中的消息验证是安全通信的关键
-- MessagePort 需要在两端都启动后才能正常通信
+# Electron RPC 通信使用说明
+
+## 概述
+
+本文档介绍如何在 Electron 应用中使用 `js-rpc2` 库实现主进程与渲染进程之间的 RPC 通信。通过 MessagePort 机制，实现跨进程的远程方法调用。
+
+## 项目结构
+
+### 组件说明
+
+- **main.js**: Electron 主进程，提供核心服务接口
+- **preload.js**: 预加载脚本，建立主进程与渲染进程的通信桥梁
+- **renderer.js**: 渲染进程，运行在浏览器环境中
+- **usage.js**: 使用示例，展示如何调用 RPC 方法
+
+## 核心实现
+
+### 主进程 (main.js)
+
+```javascript
+import { ipcMain } from 'electron'
+import { createRpcServerElectronMessagePort } from 'js-rpc2/src/lib.js'
+
+class AppApi {
+    asyncLocalStorage = new AsyncLocalStorage()
+
+    async hello(param) {
+        return 'wertyuioiuytre ' + param
+    }
+}
+
+// 监听来自渲染进程的 port 消息
+ipcMain.on('port', (event) => {
+    const port = event.ports[0]
+    // 创建 RPC 服务端点
+    createRpcServerElectronMessagePort({ 
+        port, 
+        rpcKey: '', 
+        extension: new AppApi() 
+    })
+    port.start()
+})
+```
+
+### 预加载脚本 (preload.js)
+
+```javascript
+import { ipcRenderer } from 'electron/renderer'
+
+// 监听来自渲染进程的消息
+window.onmessage = (/** @type {MessageEvent} */ event) => {
+    // 验证消息来源并转发给主进程
+    if (event.isTrusted && event.data == 'port') {
+        ipcRenderer.postMessage('port', null, [event.ports[0]])
+    }
+}
+```
+
+### 渲染进程 (renderer.js)
+
+```javascript
+import { createRpcClientMessagePort } from 'js-rpc2/src/lib.js'
+
+// 创建消息通道
+const channel = new MessageChannel();
+
+// 向主进程发送端口
+window.postMessage("port", location.origin, [channel.port1]);
+
+// 创建 RPC 客户端
+let rpc = createRpcClientMessagePort({ 
+    port: channel.port2, 
+    rpcKey: "" 
+});
+```
+
+### 使用示例 (usage.js)
+
+```javascript
+async function postPortMessage() {
+    // 调用远程方法
+    let ret = await rpc.hello('6667');
+    console.info("ret from rpc:", ret);
+}
+```
+
+## 通信流程
+
+1. 渲染进程创建 `MessageChannel` 并通过 `postMessage` 将 `port1` 发送到预加载脚本
+2. 预加载脚本验证消息来源并将端口转发给主进程
+3. 主进程接收端口并创建 RPC 服务端点
+4. 渲染进程使用 `port2` 创建 RPC 客户端
+5. 客户端可以调用主进程中定义的服务方法
+
+## 使用方法
+
+### 1. 主进程设置
+
+在主进程中定义服务类并创建 RPC 服务：
+
+```javascript
+class AppApi {
+    async yourMethod(params) {
+        // 实现业务逻辑
+        return result;
+    }
+}
+
+ipcMain.on('port', (event) => {
+    const port = event.ports[0]
+    createRpcServerElectronMessagePort({ 
+        port, 
+        rpcKey: '', 
+        extension: new AppApi() 
+    })
+    port.start()
+})
+```
+
+### 2. 渲染进程调用
+
+在渲染进程中建立连接并调用远程方法：
+
+```javascript
+const channel = new MessageChannel();
+window.postMessage("port", location.origin, [channel.port1]);
+let rpc = createRpcClientMessagePort({ port: channel.port2, rpcKey: "" });
+
+// 调用远程方法
+let result = await rpc.yourMethod(params);
+```
+
+## 注意事项
+
+- 确保在 Electron 的安全策略下正确配置 `contextIsolation` 和 `sandbox` 选项
+- 预加载脚本中的消息验证是安全通信的关键
+- MessagePort 需要在两端都启动后才能正常通信
 - 异步方法调用需要正确处理 Promise 返回值

package/doc/worker_threads.md

@@ -1,187 +1,187 @@
-# 在 Node.js Worker Threads 中使用 js-rpc
-
-Node.js Worker Threads 是一种在 Node.js 中实现并行处理的机制，js-rpc 提供了在主线程和 Worker 线程之间进行 RPC 调用的能力。
-
-## 概述
-
-js-rpc 在 Node.js Worker Threads 中的使用主要包括两个部分：
-1. 在 Worker 线程中创建 RPC 服务器：使用 [createRpcServerNodeJSWorker](../src/lib.js#L993)
-2. 在主线程中创建 RPC 客户端：使用 [createRpcClientNodeJSWorker](../src/lib.js#L1013)
-
-## 完整示例
-
-### 1. Worker 线程代码 (worker.js)
-
-```js
-// 导入必要的模块
-import { parentPort } from 'worker_threads'
-import { createRpcServerNodeJSWorker } from 'js-rpc2/src/lib.js'
-
-// 定义可被远程调用的函数
-async function readClipboard() {
-    // 实现读取剪贴板的逻辑
-    // 这里只是示例，实际实现取决于你的需求
-    return 'clipboard content'
-}
-
-async function writeClipboard(data) {
-    // 实现写入剪贴板的逻辑
-    console.log('Writing to clipboard:', data)
-    return true
-}
-
-async function writeClipboardText(text) {
-    // 实现写入文本到剪贴板的逻辑
-    console.log('Writing text to clipboard:', text)
-    return true
-}
-
-async function readClipboardText() {
-    // 实现读取剪贴板文本的逻辑
-    return 'clipboard text'
-}
-
-async function readClipboardHtml() {
-    // 实现读取剪贴板 HTML 内容的逻辑
-    return '<p>clipboard html</p>'
-}
-
-async function readClipboardImage() {
-    // 实现读取剪贴板图片的逻辑
-    return new Uint8Array([1, 2, 3, 4]) // 示例二进制数据
-}
-
-// 将所有函数导出为一个 API 对象
-export const ExtensionApi = {
-    readClipboard,
-    writeClipboard,
-    writeClipboardText,
-    readClipboardText,
-    readClipboardHtml,
-    readClipboardImage,
-}
-
-// 创建 RPC 服务器
-createRpcServerNodeJSWorker({ 
-    parentPort, 
-    extension: ExtensionApi,
-    logger: (msg) => console.log('[Worker]', msg) // 可选的日志记录器
-})
-```
-
-### 2. 主线程代码 (main.js)
-
-```js
-// 导入必要的模块
-import { createRpcClientNodeJSWorker } from 'js-rpc2/src/lib.js'
-import { Worker } from 'worker_threads'
-
-// 创建 Worker 实例
-export const worker = new Worker(new URL('./worker.js', import.meta.url))
-
-// 创建 RPC 客户端
-/** @type{ExtensionApi} */
-const rpc = createRpcClientNodeJSWorker({ worker: worker })
-
-// 取消 Worker 的引用，允许程序在没有其他任务时退出
-worker.unref()
-
-// 包装远程调用函数
-export async function readClipboard() {
-    return await rpc.readClipboard()
-}
-
-/**
- * 写入剪贴板内容
- * @param {'text'|'richtext'|'image'} type - 数据类型
- * @param {string|Buffer} data - 要写入的数据
- */
-export async function writeClipboard(type, data) {
-    return await rpc.writeClipboard(type, data)
-}
-
-/**
- * 写入文本到剪贴板
- * @param {string} text - 要写入的文本
- */
-export async function writeClipboardText(text) {
-    return rpc.writeClipboardText(text)
-}
-
-export async function readClipboardText() {
-    return rpc.readClipboardText()
-}
-
-export async function readClipboardHtml() {
-    return rpc.readClipboardHtml()
-}
-
-export async function readClipboardImage() {
-    return rpc.readClipboardImage()
-}
-
-// 使用示例
-async function example() {
-    // 调用远程函数
-    const text = await readClipboardText()
-    console.log('Clipboard text:', text)
-    
-    await writeClipboardText('Hello from main thread!')
-    
-    const image = await readClipboardImage()
-    console.log('Clipboard image size:', image.length)
-}
-```
-
-## API 说明
-
-### createRpcServerNodeJSWorker
-
-在 Worker 线程中创建 RPC 服务器。
-
-```js
-/**
- * @param {{
- * parentPort: NodeJSMessagePort;
- * extension: Object;
- * logger?:(msg:string)=>void;
- * }} param 
- */
-export function createRpcServerNodeJSWorker(param)
-```
-
-参数说明：
-- `parentPort`: Worker 线程的 parentPort 对象，用于与主线程通信
-- `extension`: 包含可被远程调用函数的对象
-- `logger`: 可选的日志记录函数
-
-### createRpcClientNodeJSWorker
-
-在主线程中创建 RPC 客户端。
-
-```js
-/**
- * @param {{
- * worker:NodeJSWorker;
- * }} param
- */
-export function createRpcClientNodeJSWorker(param)
-```
-
-参数说明：
-- `worker`: Worker 实例
-
-## 特性
-
-1. **透明的远程调用**：在主线程中调用 Worker 中的函数就像调用本地函数一样简单
-2. **支持异步函数**：所有远程函数都可以是异步的
-3. **参数和返回值序列化**：自动处理参数和返回值的序列化/反序列化
-4. **类型安全**：通过 JSDoc 注解提供完整的类型支持
-5. **错误处理**：远程函数抛出的错误会正确传播到调用方
-
-## 注意事项
-
-1. 确保 Worker 线程中的函数是可序列化的
-2. 大数据传输可能影响性能，考虑使用流式传输
-3. 避免在远程函数中使用闭包引用 Worker 外部的变量
+# 在 Node.js Worker Threads 中使用 js-rpc
+
+Node.js Worker Threads 是一种在 Node.js 中实现并行处理的机制，js-rpc 提供了在主线程和 Worker 线程之间进行 RPC 调用的能力。
+
+## 概述
+
+js-rpc 在 Node.js Worker Threads 中的使用主要包括两个部分：
+1. 在 Worker 线程中创建 RPC 服务器：使用 [createRpcServerNodeJSWorker](../src/lib.js#L993)
+2. 在主线程中创建 RPC 客户端：使用 [createRpcClientNodeJSWorker](../src/lib.js#L1013)
+
+## 完整示例
+
+### 1. Worker 线程代码 (worker.js)
+
+```js
+// 导入必要的模块
+import { parentPort } from 'worker_threads'
+import { createRpcServerNodeJSWorker } from 'js-rpc2/src/lib.js'
+
+// 定义可被远程调用的函数
+async function readClipboard() {
+    // 实现读取剪贴板的逻辑
+    // 这里只是示例，实际实现取决于你的需求
+    return 'clipboard content'
+}
+
+async function writeClipboard(data) {
+    // 实现写入剪贴板的逻辑
+    console.log('Writing to clipboard:', data)
+    return true
+}
+
+async function writeClipboardText(text) {
+    // 实现写入文本到剪贴板的逻辑
+    console.log('Writing text to clipboard:', text)
+    return true
+}
+
+async function readClipboardText() {
+    // 实现读取剪贴板文本的逻辑
+    return 'clipboard text'
+}
+
+async function readClipboardHtml() {
+    // 实现读取剪贴板 HTML 内容的逻辑
+    return '<p>clipboard html</p>'
+}
+
+async function readClipboardImage() {
+    // 实现读取剪贴板图片的逻辑
+    return new Uint8Array([1, 2, 3, 4]) // 示例二进制数据
+}
+
+// 将所有函数导出为一个 API 对象
+export const ExtensionApi = {
+    readClipboard,
+    writeClipboard,
+    writeClipboardText,
+    readClipboardText,
+    readClipboardHtml,
+    readClipboardImage,
+}
+
+// 创建 RPC 服务器
+createRpcServerNodeJSWorker({ 
+    parentPort, 
+    extension: ExtensionApi,
+    logger: (msg) => console.log('[Worker]', msg) // 可选的日志记录器
+})
+```
+
+### 2. 主线程代码 (main.js)
+
+```js
+// 导入必要的模块
+import { createRpcClientNodeJSWorker } from 'js-rpc2/src/lib.js'
+import { Worker } from 'worker_threads'
+
+// 创建 Worker 实例
+export const worker = new Worker(new URL('./worker.js', import.meta.url))
+
+// 创建 RPC 客户端
+/** @type{ExtensionApi} */
+const rpc = createRpcClientNodeJSWorker({ worker: worker })
+
+// 取消 Worker 的引用，允许程序在没有其他任务时退出
+worker.unref()
+
+// 包装远程调用函数
+export async function readClipboard() {
+    return await rpc.readClipboard()
+}
+
+/**
+ * 写入剪贴板内容
+ * @param {'text'|'richtext'|'image'} type - 数据类型
+ * @param {string|Buffer} data - 要写入的数据
+ */
+export async function writeClipboard(type, data) {
+    return await rpc.writeClipboard(type, data)
+}
+
+/**
+ * 写入文本到剪贴板
+ * @param {string} text - 要写入的文本
+ */
+export async function writeClipboardText(text) {
+    return rpc.writeClipboardText(text)
+}
+
+export async function readClipboardText() {
+    return rpc.readClipboardText()
+}
+
+export async function readClipboardHtml() {
+    return rpc.readClipboardHtml()
+}
+
+export async function readClipboardImage() {
+    return rpc.readClipboardImage()
+}
+
+// 使用示例
+async function example() {
+    // 调用远程函数
+    const text = await readClipboardText()
+    console.log('Clipboard text:', text)
+    
+    await writeClipboardText('Hello from main thread!')
+    
+    const image = await readClipboardImage()
+    console.log('Clipboard image size:', image.length)
+}
+```
+
+## API 说明
+
+### createRpcServerNodeJSWorker
+
+在 Worker 线程中创建 RPC 服务器。
+
+```js
+/**
+ * @param {{
+ * parentPort: NodeJSMessagePort;
+ * extension: Object;
+ * logger?:(msg:string)=>void;
+ * }} param 
+ */
+export function createRpcServerNodeJSWorker(param)
+```
+
+参数说明：
+- `parentPort`: Worker 线程的 parentPort 对象，用于与主线程通信
+- `extension`: 包含可被远程调用函数的对象
+- `logger`: 可选的日志记录函数
+
+### createRpcClientNodeJSWorker
+
+在主线程中创建 RPC 客户端。
+
+```js
+/**
+ * @param {{
+ * worker:NodeJSWorker;
+ * }} param
+ */
+export function createRpcClientNodeJSWorker(param)
+```
+
+参数说明：
+- `worker`: Worker 实例
+
+## 特性
+
+1. **透明的远程调用**：在主线程中调用 Worker 中的函数就像调用本地函数一样简单
+2. **支持异步函数**：所有远程函数都可以是异步的
+3. **参数和返回值序列化**：自动处理参数和返回值的序列化/反序列化
+4. **类型安全**：通过 JSDoc 注解提供完整的类型支持
+5. **错误处理**：远程函数抛出的错误会正确传播到调用方
+
+## 注意事项
+
+1. 确保 Worker 线程中的函数是可序列化的
+2. 大数据传输可能影响性能，考虑使用流式传输
+3. 避免在远程函数中使用闭包引用 Worker 外部的变量
 4. Worker 线程在没有任务时会自动退出，如需保持运行请适当管理引用

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "js web websocket http rpc",
   "main": "index.js",
   "type": "module",

package/src/lib.js

@@ -696,13 +696,13 @@ export function createRpcClientWebSocket(param) {
             signal.resolve()
         })
         ws.addEventListener('error', (e) => {
-            if (param.intercept) {
-                param.intercept(e)
-            }
             console.error('createRpcClientWebSocket createWebSocket ws error', e)
             promise.resolve()
         })
-        ws.addEventListener('close', () => {
+        ws.addEventListener('close', (e) => {
+            if (param.intercept) {
+                param.intercept(e)
+            }
             console.error('createRpcClientWebSocket createWebSocket ws close')
             promise.resolve()
         })