js-rpc2 2.0.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.0.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) {
@@ -364,16 +364,24 @@ export const RPC_DATA_ARG_TYPE_FUNCTION = 0x7ff45f
  * @param {RPC_DATA} box
  */
 export function buildRpcData(box) {
-    return Uint8Array.from(packr.pack(box))
+    let type = box.type
+    let data = box.data
+    if (type == RPC_TYPE_CALL || type == RPC_TYPE_CALLBACK) {
+        data = data.map(({ type, data }) => [type, data])
+    }
+    return Uint8Array.from(packr.pack([box.id, type, data]))
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  */
 export function parseRpcData(buffer) {
+    let [id, type, data] = packr.unpack(buffer)
+    if (type == RPC_TYPE_CALL || type == RPC_TYPE_CALLBACK) {
+        data = data.map(([type, data]) => ({ type, data }))
+    }
     /** @type{RPC_DATA} */
-    let box = packr.unpack(buffer)
-    return box
+    return { id, type, data }
 }
 
 /**
@@ -401,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) {
@@ -487,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
  */
 
@@ -529,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
@@ -663,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) {
@@ -753,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

@@ -1,49 +1,91 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-export type ExtensionApi<T> = { asyncLocalStorage: AsyncLocalStorage<T> } & object;
-
-
-export type RPC_TYPE_CALL = 0xdf68f4cb
-export type RPC_TYPE_RETURN = 0x68b17581
-export type RPC_TYPE_CALLBACK = 0x8d65e5cc
-export type RPC_TYPE_ERROR = 0xa07c0f84
-
-export type RPC_DATA_ARG_TYPE_OTHERS = 0xa7f68c
-export type RPC_DATA_ARG_TYPE_FUNCTION = 0x7ff45f
-
-
-export type RPC_TYPES = RPC_TYPE_CALL |
-    RPC_TYPE_RETURN |
-    RPC_TYPE_CALLBACK |
-    RPC_TYPE_ERROR;
-
-
-export type PromiseResolvers = {
-    promise: Promise<any>;
-    resolve: (value: any | null) => void;
-    reject: (reason: any | null) => void;
-};
-
-export type CALLBACK_ITEM = {
-    id: number;
-    type: RPC_TYPES;
-    promise?: PromiseResolvers;
-    callback?: (...data: object[]) => void;
-};
-
-export type RPC_DATA_ARG_ITEM = { type: RPC_DATA_ARG_TYPE; data: object; };
-export type RPC_DATA = {
-    id: number;
-    type: RPC_TYPE_CALL | RPC_TYPE_CALLBACK;
-    data: { type: RPC_DATA_ARG_TYPE; data: any; }[];
-} | {
-    id: number;
-    type: RPC_TYPE_RETURN;
-    data: any;
-} | {
-    id: number;
-    type: RPC_TYPE_ERROR;
-    data: { message: string, stack: string };
-};
-
-export type RPC_DATA_ARG_TYPE = RPC_DATA_ARG_TYPE_OTHERS | RPC_DATA_ARG_TYPE_FUNCTION;
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export type ExtensionApi<T> = { asyncLocalStorage: AsyncLocalStorage<T> } & object;
+
+
+export type RPC_TYPE_CALL = 0xdf68f4cb
+export type RPC_TYPE_RETURN = 0x68b17581
+export type RPC_TYPE_CALLBACK = 0x8d65e5cc
+export type RPC_TYPE_ERROR = 0xa07c0f84
+
+export type RPC_DATA_ARG_TYPE_OTHERS = 0xa7f68c
+export type RPC_DATA_ARG_TYPE_FUNCTION = 0x7ff45f
+
+
+export type RPC_TYPES = RPC_TYPE_CALL |
+    RPC_TYPE_RETURN |
+    RPC_TYPE_CALLBACK |
+    RPC_TYPE_ERROR;
+
+
+export type PromiseResolvers = {
+    promise: Promise<any>;
+    resolve: (value: any | null) => void;
+    reject: (reason: any | null) => void;
+};
+
+export type CALLBACK_ITEM = {
+    id: number;
+    type: RPC_TYPES;
+    promise?: PromiseResolvers;
+    callback?: (...data: object[]) => void;
+};
+
+export type RPC_DATA_ARG_ITEM = { type: RPC_DATA_ARG_TYPE; data: object; };
+export type RPC_DATA = {
+    id: number;
+    type: RPC_TYPE_CALL | RPC_TYPE_CALLBACK;
+    data: { type: RPC_DATA_ARG_TYPE; data: any; }[];
+} | {
+    id: number;
+    type: RPC_TYPE_RETURN;
+    data: any;
+} | {
+    id: number;
+    type: RPC_TYPE_ERROR;
+    data: { message: string, stack: string };
+};
+
+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;
+    }
+
+}