@lvce-editor/json-rpc 1.3.0 → 2.0.0

package/dist/index.d.ts

@@ -6,24 +6,46 @@ export const invoke: (
   ...params: any[]
 ) => Promise<any>
 
-export const invokeAndTransfer: (
-  ipc: any,
-  transfer: any,
-  method: string,
-  ...params: any[]
-) => Promise<any>
+interface InvokeAndTransfer {
+  (ipc: any, transfer: any, method: string, ...params: any[]): Promise<any>
+  (ipc: any, method: string, ...params: any[]): Promise<any>
+}
+
+export const invokeAndTransfer: InvokeAndTransfer
 
 export const resolve: (id: number, message: any) => void
 
-export const handleJsonRpcMessage: (
-  ipc: any,
-  message: any,
-  execute: (method: string, ...params: any[]) => Promise<any>,
-  resolve: any,
-  preparePrettyError: (error: any) => any,
-  logError: (error: any) => void,
-  requiresSocket: (method: string) => void,
-) => Promise<void>
+interface HandleJsonRpcMessage {
+  (
+    ipc: any,
+    message: any,
+    execute: (method: string, ...params: any[]) => Promise<any>,
+    resolve: any,
+    preparePrettyError: (error: any) => any,
+    logError: (error: any) => void,
+    requiresSocket: (method: string) => void,
+  ): Promise<void>
+
+  ({
+    ipc,
+    message,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket,
+  }: {
+    ipc: any
+    message: any
+    execute: (method: string, ...params: any[]) => Promise<any>
+    resolve?: any
+    preparePrettyError: (error: any) => any
+    logError: (error: any) => void
+    requiresSocket: (method: string) => void
+  }): Promise<void>
+}
+
+export const handleJsonRpcMessage: HandleJsonRpcMessage
 
 export const getErrorResponse: (
   message: any,

package/dist/index.js

@@ -277,6 +277,58 @@ const unwrapJsonRpcResult = responseMessage => {
   throw new JsonRpcError('unexpected response message');
 };
 
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+
+const isSingleTransferrable = value => {
+  return isSocket(value);
+};
+
+const isMessagePort = value => {
+  return typeof MessagePort !== 'undefined' && value instanceof MessagePort;
+};
+
+const isMessagePortMain = value => {
+  return isInstanceOf(value, 'MessagePortMain');
+};
+
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const getTransferrableParams = value => {
+  if (isTransferrable(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const result = value.filter(isTransferrable);
+    if (result.length === 0) {
+      return undefined;
+    }
+    if (result.length === 1 && isSingleTransferrable(result[0])) {
+      return result[0];
+    }
+    return result;
+  }
+  return undefined;
+};
+
 const create$1 = (message, error) => {
   return {
     jsonrpc: Two,
@@ -306,7 +358,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const getErrorResponse = (message, error, ipc, preparePrettyError, logError) => {
+const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
@@ -331,18 +383,53 @@ const getResponse = async (message, ipc, execute, preparePrettyError, logError,
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, ipc, preparePrettyError, logError);
+    return getErrorResponse(message, error, preparePrettyError, logError);
   }
 };
 
-const handleJsonRpcMessage = async (ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket) => {
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+const handleJsonRpcMessage = async (...args) => {
+  let message;
+  let ipc;
+  let execute;
+  let preparePrettyError;
+  let logError;
+  let resolve;
+  let requiresSocket;
+  if (args.length === 1) {
+    const arg = args[0];
+    message = arg.message;
+    ipc = arg.ipc;
+    execute = arg.execute;
+    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
+    logError = arg.logError || defaultLogError;
+    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
+    resolve = arg.resolve || defaultResolve;
+  } else {
+    ipc = args[0];
+    message = args[1];
+    execute = args[2];
+    resolve = args[3];
+    preparePrettyError = args[4];
+    logError = args[5];
+    requiresSocket = args[6];
+  }
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, ipc, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -371,12 +458,21 @@ const invoke = async (ipc, method, ...params) => {
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
 };
+
+// TODO deprecated old typings,
+// always use automatic transferrable detection
 const invokeAndTransfer = async (ipc, handle, method, ...params) => {
+  let transfer = handle;
+  if (typeof handle === 'string') {
+    params = [method, ...params];
+    method = handle;
+    transfer = getTransferrableParams(params);
+  }
   const {
     message,
     promise
   } = create$2(method, params);
-  ipc.sendAndTransfer(message, handle);
+  ipc.sendAndTransfer(message, transfer);
   const responseMessage = await promise;
   const result = unwrapJsonRpcResult(responseMessage);
   return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/json-rpc",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "JsonRpc implementation",
   "main": "dist/index.js",
   "type": "module",