@lynx-js/web-worker-rpc 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @lynx-js/web-worker-rpc
 
+## 0.8.0
+
+### Patch Changes
+
+- feat: `createRpcEndpoint` adds a new parameter: `hasReturnTransfer`. ([#194](https://github.com/lynx-family/lynx-stack/pull/194))
+
+  When `isSync`: false, `hasReturn`: true, you can add `transfer` to the callback postMessage created.
+
+  At this time, the return value structure of register-handler is changed: `{ data: unknown; transfer: Transferable[]; } | Promise<{ data: unknown; transfer: Transferable[];}>`.
+
+## 0.7.1
+
+### Patch Changes
+
+- Support NPM provenance. ([#30](https://github.com/lynx-family/lynx-stack/pull/30))
+
 ## 0.7.0
 
 ## 0.6.2

package/dist/Rpc.d.ts

@@ -1,4 +1,4 @@
-import type { RpcEndpoint, RpcEndpointAsync, RpcEndpointAsyncVoid, RpcEndpointBase, RpcEndpointSync, RpcEndpointSyncVoid } from './RpcEndpoint.js';
+import type { RpcEndpoint, RpcEndpointAsync, RpcEndpointAsyncVoid, RpcEndpointAsyncWithTransfer, RpcEndpointBase, RpcEndpointSync, RpcEndpointSyncVoid } from './RpcEndpoint.js';
 type RetEndpoint<Return> = RpcEndpointBase<[
     Return,
     boolean
@@ -38,6 +38,13 @@ export declare class Rpc {
      */
     registerHandler<T extends RetEndpoint<any>>(endpoint: T, handler: (...args: T['_TypeParameters']) => void): void;
     registerHandler<T extends RpcEndpoint<any[], any>>(endpoint: T, handler: ((...args: T['_TypeParameters']) => T['_TypeReturn']) | ((...args: T['_TypeParameters']) => Promise<T['_TypeReturn']>)): void;
+    registerHandler<T extends RpcEndpointAsyncWithTransfer<any[], any>>(endpoint: T, handler: ((...args: T['_TypeParameters']) => {
+        data: T['_TypeReturn'];
+        transfer: Transferable[];
+    }) | ((...args: T['_TypeParameters']) => Promise<{
+        data: T['_TypeReturn'];
+        transfer: Transferable[];
+    }>)): void;
     /**
      * register a property of an object as a handler
      * @param endpoint

package/dist/Rpc.js

@@ -44,7 +44,17 @@ export class Rpc {
                 ? Rpc.createRetEndpoint(message.retId)
                 : undefined;
             try {
-                const retData = await handler(...message.data);
+                const result = await handler(...message.data);
+                let retData = undefined, transfer = [];
+                if (message.sync) {
+                    retData = result;
+                }
+                else if (message.hasTransfer) {
+                    ({ data: retData, transfer } = (result || {}));
+                }
+                else {
+                    retData = result;
+                }
                 if (message.sync) {
                     if (message.buf) {
                         const retStr = JSON.stringify(retData);
@@ -63,7 +73,7 @@ export class Rpc {
                         this.invoke(replyTempEndpoint, [
                             retData,
                             false,
-                        ]);
+                        ], transfer || []);
                     }
                 }
             }
@@ -185,6 +195,7 @@ export class Rpc {
                     data: parameters,
                     sync: false,
                     retId: retHandler?.name,
+                    hasTransfer: endpoint.hasReturnTransfer,
                 };
                 this.port.postMessage(message, { transfer });
                 return promise;

package/dist/RpcEndpoint.d.ts

@@ -2,7 +2,12 @@ export type RpcEndpointSyncVoid<Parameters extends any[]> = RpcEndpointBase<Para
 export interface RpcEndpointSync<Parameters extends any[], Return> extends RpcEndpointBase<Parameters, Return, true, true> {
     readonly bufferSize: number;
 }
-export type RpcEndpointAsync<Parameters extends any[], Return> = RpcEndpointBase<Parameters, Return, false, true>;
+export interface RpcEndpointAsync<Parameters extends any[], Return> extends RpcEndpointBase<Parameters, Return, false, true> {
+    readonly hasReturnTransfer: false;
+}
+export interface RpcEndpointAsyncWithTransfer<Parameters extends any[], Return> extends RpcEndpointBase<Parameters, Return, true, true> {
+    readonly hasReturnTransfer: true;
+}
 export type RpcEndpointAsyncVoid<Parameters extends any[]> = RpcEndpointBase<Parameters, void, false, false>;
 export interface RpcEndpointBase<Parameters extends any[], Return, IsSync extends boolean, HasReturn extends boolean> {
     /**
@@ -40,9 +45,17 @@ export interface RpcEndpointBase<Parameters extends any[], Return, IsSync extend
      * So you should ensure this size is enough for your stringified return value.
      */
     readonly bufferSize: never | number;
+    /**
+     * @public
+     * Make the message invoke created by hasReturn support transfer.
+     * Only valid for async and hasReturn endpoints
+     */
+    readonly hasReturnTransfer: never | boolean;
 }
-export type RpcEndpoint<Parameters extends any[], Return> = RpcEndpointSyncVoid<Parameters> | RpcEndpointSync<Parameters, Return> | RpcEndpointAsync<Parameters, Return> | RpcEndpointAsyncVoid<Parameters>;
+export type RpcEndpoint<Parameters extends any[], Return> = RpcEndpointSyncVoid<Parameters> | RpcEndpointSync<Parameters, Return> | RpcEndpointAsync<Parameters, Return> | RpcEndpointAsyncVoid<Parameters> | RpcEndpointAsyncWithTransfer<Parameters, Return>;
 export declare function createRpcEndpoint<Parameters extends any[], Return = void>(name: string, isSync: false, hasReturn: false): RpcEndpointAsyncVoid<Parameters>;
 export declare function createRpcEndpoint<Parameters extends any[], Return = void>(name: string, isSync: false, hasReturn: true): RpcEndpointAsync<Parameters, Return>;
+export declare function createRpcEndpoint<Parameters extends any[], Return = void>(name: string, isSync: false, hasReturn: true, hasReturnTransfer: false): RpcEndpointAsync<Parameters, Return>;
+export declare function createRpcEndpoint<Parameters extends any[], Return = void>(name: string, isSync: false, hasReturn: true, hasReturnTransfer: true): RpcEndpointAsyncWithTransfer<Parameters, Return>;
 export declare function createRpcEndpoint<Parameters extends any[]>(name: string, isSync: true, hasReturn: false): RpcEndpointSyncVoid<Parameters>;
-export declare function createRpcEndpoint<Parameters extends any[], Return>(name: string, isSync: true, hasReturn: true, bufferSize: number): RpcEndpointSync<Parameters, Return>;
+export declare function createRpcEndpoint<Parameters extends any[], Return>(name: string, isSync: true, hasReturn: true, hasReturnTransfer: false, bufferSize: number): RpcEndpointSync<Parameters, Return>;

package/dist/RpcEndpoint.js

@@ -1,8 +1,9 @@
-export function createRpcEndpoint(name, isSync, hasReturn = true, bufferSize) {
+export function createRpcEndpoint(name, isSync, hasReturn = true, hasReturnTransfer = false, bufferSize) {
     return {
         name,
         isSync,
         hasReturn,
+        hasReturnTransfer,
         bufferSize,
     };
 }

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@lynx-js/web-worker-rpc",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "description": "",
   "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lynx-family/lynx-stack.git",
+    "directory": "packages/web-platform/web-worker-rpc"
+  },
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",