@lvce-editor/embeds-process 4.3.0 → 4.5.0

package/dist/embedsProcessMain.js

@@ -7,7 +7,7 @@ const add = (id, ipc) => {
 const get$2 = id => {
   return ipcMap[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete ipcMap[id];
 };
 const getAll = () => {
@@ -15,39 +15,7 @@ const getAll = () => {
 };
 
 const MainProcess$2 = -5;
-const SharedProcess$2 = 1;
-
-const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-
-const create$5 = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$5(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
+const SharedProcess$2 = 1492;
 
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
@@ -331,8 +299,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -355,14 +323,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -381,8 +349,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -392,8 +360,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -631,8 +599,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -644,8 +612,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -661,28 +629,28 @@ const getFirstWebSocketEvent = async webSocket => {
     WebSocket
   } = await import('ws');
   switch (webSocket.readyState) {
-    case WebSocket.OPEN:
+    case WebSocket.CLOSED:
       return {
-        type: Open,
-        event: undefined
+        event: undefined,
+        type: Close
       };
-    case WebSocket.CLOSED:
+    case WebSocket.OPEN:
       return {
-        type: Close,
-        event: undefined
+        event: undefined,
+        type: Open
       };
   }
   // @ts-ignore
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstEvent(webSocket, {
-    open: Open,
-    close: Close
+    close: Close,
+    open: Open
   });
   return {
-    type,
-    event
+    event,
+    type
   };
 };
 
@@ -712,8 +680,8 @@ const handleUpgrade$1 = async (...args) => {
   return module.handleUpgrade(...args);
 };
 const listen$1$1 = async ({
-  request,
-  handle
+  handle,
+  request
 }) => {
   if (!request) {
     throw new IpcError('request must be defined');
@@ -733,14 +701,19 @@ const signal$4 = webSocket => {
 };
 const wrap$9 = webSocket => {
   return {
-    webSocket,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
+    dispose() {
+      this.webSocket.close();
+    },
+    // @ts-ignore
+    off(event, listener) {
+      this.webSocket.off(event, listener);
+    },
     // @ts-ignore
     on(event, listener) {
       switch (event) {
+        case 'close':
+          webSocket.on('close', listener);
+          break;
         case 'message':
           // @ts-ignore
           const wrappedListener = message => {
@@ -753,28 +726,23 @@ const wrap$9 = webSocket => {
           };
           webSocket.on('message', wrappedListener);
           break;
-        case 'close':
-          webSocket.on('close', listener);
-          break;
         default:
           throw new Error('unknown event listener type');
       }
     },
     // @ts-ignore
-    off(event, listener) {
-      this.webSocket.off(event, listener);
-    },
-    // @ts-ignore
     send(message) {
       const stringifiedMessage = serialize(message);
       this.webSocket.send(stringifiedMessage);
     },
-    dispose() {
-      this.webSocket.close();
-    },
     start() {
       throw new Error('start method is deprecated');
-    }
+    },
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined
   };
 };
 const IpcChildWithWebSocket = {
@@ -784,56 +752,14 @@ const IpcChildWithWebSocket = {
   wrap: wrap$9
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -977,14 +903,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1029,7 +955,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -1040,20 +966,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1(id, errorProperty);
 };
-const create = (message, result) => {
+const create$2 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create(message, resultProperty);
+  return create$2(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -1140,29 +1066,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -1185,24 +1088,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$t = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$s = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$r = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$r();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$s(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$2(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$t(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -1219,7 +1185,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -1237,7 +1203,7 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$k = async ({
+const create$q = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1256,9 +1222,9 @@ const create$k = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$k
+  create: create$q
 };
-const create$j = async ({
+const create$p = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1270,7 +1236,7 @@ const create$j = async ({
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$j
+  create: create$p
 };
 const create$a = async ({
   commandMap
@@ -1288,15 +1254,15 @@ const NodeForkedProcessRpcClient = {
 };
 const create$8 = async ({
   commandMap,
-  request,
   handle,
+  request,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const ipc = await listen$2(IpcChildWithWebSocket, {
-    request,
-    handle
+    handle,
+    request
   });
   if (requiresSocket) {
     ipc.requiresSocket = requiresSocket;
@@ -1323,34 +1289,91 @@ const NodeWorkerRpcClient = {
   __proto__: null,
   create: create$7
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$4 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$4(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$4(rpcId, rpc);
+    }
+  };
+};
 
 const {
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set: set$3,
-  dispose: dispose$2
-} = create$5(MainProcess$2);
+  invoke: invoke$1,
+  set: set$3
+} = create(MainProcess$2);
 
 const MainProcess$1 = {
   __proto__: null,
-  dispose: dispose$2,
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
+  invoke: invoke$1,
   set: set$3
 };
 
 const {
-  invoke: invoke$1,
-  invokeAndTransfer,
-  set: set$2,
-  dispose: dispose$1
-} = create$5(SharedProcess$2);
+  set: set$2
+} = create(SharedProcess$2);
 
 const SharedProcess$1 = {
   __proto__: null,
-  dispose: dispose$1,
-  invoke: invoke$1,
-  invokeAndTransfer,
   set: set$2
 };
 
@@ -1461,8 +1484,8 @@ const handleIncomingIpcMessagePort = async (module, handle, message) => {
   const target = await module.targetMessagePort(handle, message);
   const response = module.upgradeMessagePort(handle, message);
   return {
-    target,
-    response
+    response,
+    target
   };
 };
 
@@ -1481,7 +1504,7 @@ const getIdsToDispose = ipc => {
 const handleIpcClosed = async event => {
   const idsToDispose = getIdsToDispose(event.target);
   for (const id of idsToDispose) {
-    remove$1(id);
+    remove$2(id);
     await disposeWebContentsView(id);
   }
   // SharedProcessIpc.send('HandleMessagePortForEmbedsProcess.handleEmbedsProcessIpcClosed')
@@ -1507,14 +1530,14 @@ const Auto = argv => {
 
 const getModule$1 = method => {
   switch (method) {
+    case ElectronMessagePort:
+      return ElectronMessagePortRpcClient.create;
+    case ElectronUtilityProcess:
+      return ElectronUtilityProcessRpcClient.create;
     case NodeForkedProcess:
       return NodeForkedProcessRpcClient.create;
     case NodeWorker:
       return NodeWorkerRpcClient.create;
-    case ElectronUtilityProcess:
-      return ElectronUtilityProcessRpcClient.create;
-    case ElectronMessagePort:
-      return ElectronMessagePortRpcClient.create;
     case WebSocket:
       return NodeWebSocketRpcClient.create;
     default:
@@ -1534,9 +1557,9 @@ const listen$1 = async ({
 const targetMessagePort$2 = async (messagePort, message) => {
   object(messagePort);
   const rpc = await listen$1({
-    method: ElectronMessagePort,
+    commandMap: commandMapRef,
     messagePort,
-    commandMap: commandMapRef
+    method: ElectronMessagePort
   });
   // @ts-ignore
   const {
@@ -1560,8 +1583,8 @@ const HandleIpcEmbedsWorker = {
 const targetMessagePort$1 = async (messagePort, message) => {
   object(messagePort);
   const rpc = await listen$1({
-    method: ElectronMessagePort,
-    messagePort
+    messagePort,
+    method: ElectronMessagePort
   });
   set$1(rpc);
   return rpc;
@@ -1585,8 +1608,8 @@ const {
 const targetMessagePort = async (messagePort, message) => {
   object(messagePort);
   const rpc = await ElectronMessagePortRpcClient.create({
-    messagePort,
-    commandMap: commandMapRef
+    commandMap: commandMapRef,
+    messagePort
   });
   set(rpc);
   return rpc;
@@ -1612,16 +1635,16 @@ const EmbedsWorkerAlt = 208;
 const getModule = ipcId => {
   number(ipcId);
   switch (ipcId) {
-    case SharedProcess:
-    case SharedProcessAlt:
-      return HandleIpcSharedProcess;
-    // deprecated
     case EmbedsWorker:
     case EmbedsWorkerAlt:
       return HandleIpcEmbedsWorker;
     case MainProcess:
       return HandleIpcMainProcess;
     // deprecated
+    case SharedProcess:
+    case SharedProcessAlt:
+      return HandleIpcSharedProcess;
+    // deprecated
     default:
       throw new Error(`Embeds process encountered unexpected incoming ipc ${ipcId}`);
   }
@@ -1634,8 +1657,8 @@ const handleIncomingIpc = async (ipcId, handle, message) => {
   number(ipcId);
   const module = getModule(ipcId);
   const {
-    target,
-    response
+    response,
+    target
   } = await getIpcAndResponse(module, handle, message);
   await applyIncomingIpcResponse(target, response);
 };
@@ -1694,8 +1717,8 @@ const commandMap = {
 const listen = async argv => {
   Object.assign(commandMapRef, commandMap);
   await listen$1({
-    method: Auto(argv),
-    commandMap: commandMap
+    commandMap: commandMap,
+    method: Auto(argv)
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/embeds-process",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "description": "Embeds Process",
   "keywords": [
     "Lvce Editor"