js-rpc2 2.1.0 → 2.2.0

package/README.md

@@ -312,4 +312,47 @@ export async function runWithAbortController(func) {
         await sleep(1000)
     } finally { ac.abort() }
 }
+```
+
+## Electron
+```js
+// main.js
+class AppApi {
+    asyncLocalStorage = new AsyncLocalStorage()
+
+    async hello(param) {
+        return 'wertyuioiuytre ' + param
+    }
+}
+
+import { ipcMain } from 'electron'
+import { createRpcServerElectronMessagePort } from 'js-rpc2/src/lib.js'
+
+ipcMain.on('port', (event) => {
+    const port = event.ports[0]
+    createRpcServerElectronMessagePort({ port, rpcKey: '', extension: new AppApi() })
+    port.start()
+})
+
+// preload.js
+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
+import { createRpcClientMessagePort } from 'js-rpc2/src/lib.js'
+
+const channel = new MessageChannel();
+window.postMessage("port", location.origin, [channel.port1]);
+let rpc = createRpcClientMessagePort({ port: channel.port2, rpcKey: "" });
+
+// uasge.js
+async function postPortMessage() {
+    let ret = await rpc.hello('6667');
+    console.info("ret from rpc:", ret);
+}
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "js web websocket http rpc",
   "main": "index.js",
   "type": "module",
@@ -26,10 +26,10 @@
   "author": "yuanliwei",
   "license": "MIT",
   "devDependencies": {
-    "@koa/router": "^13.1.1",
-    "@types/node": "^22.13.14",
-    "koa": "^2.15.3",
-    "ws": "^8.18.0"
+    "@koa/router": "^14.0.0",
+    "@types/node": "^24.2.1",
+    "koa": "^3.0.1",
+    "ws": "^8.18.3"
   },
   "dependencies": {
     "msgpackr": "^1.11.5"

package/src/lib.js

@@ -23,8 +23,8 @@ export function Promise_withResolvers() {
 }
 
 /**
- * @param {Promise<[CryptoKey,Uint8Array]>} key_iv
- * @returns {TransformStream<Uint8Array, Uint8Array>}
+ * @param {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>} key_iv
+ * @returns {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>}
  */
 export function createEncodeStream(key_iv) {
     let key = null
@@ -41,8 +41,8 @@ export function createEncodeStream(key_iv) {
 }
 
 /**
- * @param {Promise<[CryptoKey,Uint8Array]>} key_iv
- * @returns {TransformStream<Uint8Array, Uint8Array>}
+ * @param {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>} key_iv
+ * @returns {TransformStream<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>}
  */
 export function createDecodeStream(key_iv) {
     let key = null
@@ -65,10 +65,10 @@ export function createDecodeStream(key_iv) {
 const HEADER_CHECK = 0xb1f7705f
 
 /**
- * @param {Uint8Array[]} queue
+ * @param {Uint8Array<ArrayBuffer>[]} queue
  * @param {CryptoKey} key
- * @param {Uint8Array} iv
- * @returns {Promise<Uint8Array>}
+ * @param {Uint8Array<ArrayBuffer>} iv
+ * @returns {Promise<Uint8Array<ArrayBuffer>>}
  */
 export async function buildBufferData(queue, key, iv) {
     let buffers = []
@@ -134,7 +134,7 @@ export function processPackets() {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {number} offset
  */
 export function readUInt32LE(buffer, offset) {
@@ -146,7 +146,7 @@ export function readUInt32LE(buffer, offset) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {number} value
  * @param {number} offset
  */
@@ -159,7 +159,7 @@ export function writeUInt32LE(buffer, value, offset) {
 }
 
 /**
- * @param {Uint8Array[]} buffers
+ * @param {Uint8Array<ArrayBuffer>[]} buffers
  */
 export function Uint8Array_concat(buffers) {
     const totalLength = buffers.reduce((sum, buffer) => sum + buffer.length, 0)
@@ -196,7 +196,7 @@ export function Uint8Array_from(array, encoding) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {'utf-8' | 'hex' | 'base64'} [encoding]
  */
 export function Uint8Array_toString(buffer, encoding = 'utf-8') {
@@ -231,7 +231,7 @@ function buildBufferSizeString(string) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {number} offset
  */
 function readBufferSizeString(buffer, offset) {
@@ -258,7 +258,7 @@ export function guid() {
  * 
  * @param {string} password 
  * @param {number} iterations 
- * @returns {Promise<[CryptoKey,Uint8Array]>}
+ * @returns {Promise<[CryptoKey,Uint8Array<ArrayBuffer>]>}
  */
 export async function buildKeyIv(password, iterations) {
     if (!JS_RPC_WITH_CRYPTO) return [null, null]
@@ -294,9 +294,9 @@ export async function buildKeyIv(password, iterations) {
 
 /**
  * 
- * @param {Uint8Array} data 
+ * @param {Uint8Array<ArrayBuffer>} data 
  * @param {CryptoKey} key 
- * @param {Uint8Array} iv 
+ * @param {Uint8Array<ArrayBuffer>} iv 
  * @returns 
  */
 export async function encrypt(data, key, iv) {
@@ -311,7 +311,7 @@ export async function encrypt(data, key, iv) {
 /**
  * @param {Uint8Array<ArrayBuffer>} data 
  * @param {CryptoKey} key 
- * @param {Uint8Array} iv 
+ * @param {Uint8Array<ArrayBuffer>} iv 
  * @returns 
  */
 export async function decrypt(data, key, iv) {
@@ -373,7 +373,7 @@ export function buildRpcData(box) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  */
 export function parseRpcData(buffer) {
     let [id, type, data] = packr.unpack(buffer)
@@ -409,8 +409,8 @@ export function buildRpcItemData(items) {
 /**
  * @template T
  * @param {ExtensionApi<T>} extension
- * @param {WritableStreamDefaultWriter<Uint8Array>} writer
- * @param {Uint8Array} buffer
+ * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} writer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {(msg:string)=>void} logger
  */
 export async function rpcRunServerDecodeBuffer(extension, writer, buffer, logger) {
@@ -495,8 +495,8 @@ export function createRPCProxy(apiInvoke) {
 
 /** 
  * @typedef {{
- * writable: WritableStream<Uint8Array>;
- * readable: ReadableStream<Uint8Array>;
+ * writable: WritableStream<Uint8Array<ArrayBuffer>>;
+ * readable: ReadableStream<Uint8Array<ArrayBuffer>>;
  * }} RPC_HELPER_SERVER
  */
 
@@ -537,8 +537,8 @@ export function createRpcServerHelper(param) {
 
 /** 
  * @typedef {{
- * writable: WritableStream<Uint8Array>;
- * readable: ReadableStream<Uint8Array>;
+ * writable: WritableStream<Uint8Array<ArrayBuffer>>;
+ * readable: ReadableStream<Uint8Array<ArrayBuffer>>;
  * apiInvoke: (fnName: string, args: object[]) => Promise<object>;
  * reject: (error:object)=>void;
  * }} RPC_HELPER_CLIENT
@@ -671,7 +671,7 @@ export function createRpcClientWebSocket(param) {
     let helper = createRpcClientHelper({ rpcKey: param.rpcKey })
     let writer = helper.writable.getWriter()
     let signal = Promise_withResolvers()
-    /** @type{WritableStreamDefaultWriter<Uint8Array>} */
+    /** @type{WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} */
     let socketWriter = null
     helper.readable.pipeTo(new WritableStream({
         async write(chunk) {
@@ -761,3 +761,74 @@ export function createRpcClientHttp(param) {
     })).catch((err) => helper.reject(err))
     return createRPCProxy(helper.apiInvoke)
 }
+
+/**
+ * @template T
+ * @param {{
+ * port:MessagePort;
+ * rpcKey:string;
+ * extension: ExtensionApi<T>; 
+ * logger?:(msg:string)=>void;
+ * }} param 
+ */
+export function createRpcServerMessagePort(param) {
+    const port = param.port
+    let helper = createRpcServerHelper({
+        rpcKey: '', extension: param.extension, async: true, logger: param.logger,
+    })
+    let writer = helper.writable.getWriter()
+    port.onmessage = async (event) => {
+        await writer.write(event.data)
+    }
+    helper.readable.pipeTo(new WritableStream({
+        async write(chunk) {
+            port.postMessage(chunk)
+        }
+    }))
+}
+
+/**
+ * @import {Electron} from './types.js'
+ * @template T
+ * @param {{
+ * port:Electron.MessagePortMain;
+ * rpcKey:string;
+ * extension: ExtensionApi<T>; 
+ * logger?:(msg:string)=>void;
+ * }} param 
+ */
+export function createRpcServerElectronMessagePort(param) {
+    const port = param.port
+    let helper = createRpcServerHelper({
+        rpcKey: '', extension: param.extension, async: true, logger: param.logger,
+    })
+    let writer = helper.writable.getWriter()
+    port.on('message', async (event) => {
+        await writer.write(event.data)
+    })
+    helper.readable.pipeTo(new WritableStream({
+        async write(chunk) {
+            port.postMessage(chunk)
+        }
+    }))
+}
+
+/**
+ * @param {{
+ * port:MessagePort;
+ * rpcKey:string;
+ * }} param
+ */
+export function createRpcClientMessagePort(param) {
+    let helper = createRpcClientHelper({ rpcKey: param.rpcKey })
+    let writer = helper.writable.getWriter()
+    helper.readable.pipeTo(new WritableStream({
+        async write(chunk) {
+            param.port.postMessage(chunk)
+        }
+    }))
+    param.port.onmessage = async (event) => {
+        await writer.write(event.data)
+    }
+    return createRPCProxy(helper.apiInvoke)
+}

package/src/server.js

@@ -75,7 +75,6 @@ export function createRpcServerKoaRouter(param) {
     }
     param.router.post(param.path, async (ctx) => {
         let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension, logger: param.logger, context: ctx })
-        /** @type{ReadableStream} */
         let a = Readable.toWeb(ctx.req)
         await a.pipeTo(helper.writable)
         ctx.status = 200

package/src/types.ts

@@ -46,4 +46,46 @@ export type RPC_DATA = {
     data: { message: string, stack: string };
 };
 
-export type RPC_DATA_ARG_TYPE = RPC_DATA_ARG_TYPE_OTHERS | RPC_DATA_ARG_TYPE_FUNCTION;
+export type RPC_DATA_ARG_TYPE = RPC_DATA_ARG_TYPE_OTHERS | RPC_DATA_ARG_TYPE_FUNCTION;
+
+export declare namespace Electron {
+
+    const NodeEventEmitter: typeof import('events').EventEmitter;
+
+    class MessagePortMain extends NodeEventEmitter {
+
+        // Docs: https://electronjs.org/docs/api/message-port-main
+
+        /**
+         * Emitted when the remote end of a MessagePortMain object becomes disconnected.
+         */
+        on(event: 'close', listener: () => void): this;
+        off(event: 'close', listener: () => void): this;
+        once(event: 'close', listener: () => void): this;
+        addListener(event: 'close', listener: () => void): this;
+        removeListener(event: 'close', listener: () => void): this;
+        /**
+         * Emitted when a MessagePortMain object receives a message.
+         */
+        on(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+        off(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+        once(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+        addListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+        removeListener(event: 'message', listener: (messageEvent: MessageEvent) => void): this;
+        /**
+         * Disconnects the port, so it is no longer active.
+         */
+        close(): void;
+        /**
+         * Sends a message from the port, and optionally, transfers ownership of objects to
+         * other browsing contexts.
+         */
+        postMessage(message: any, transfer?: MessagePortMain[]): void;
+        /**
+         * Starts the sending of messages queued on the port. Messages will be queued until
+         * this method is called.
+         */
+        start(): void;
+    }
+
+}