@lvce-editor/ipc 14.5.0 → 14.7.0

package/dist/index.js

@@ -197,8 +197,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
   };
 };
 
@@ -225,14 +225,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) => {
@@ -251,8 +251,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -263,8 +263,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -398,7 +398,7 @@ const getData$2 = event => {
 };
 
 const listen$9 = () => {
-  return window;
+  return globalThis;
 };
 const signal$a = global => {
   global.postMessage(readyMessage);
@@ -428,7 +428,7 @@ class IpcChildWithElectronWindow extends Ipc {
       const {
         ports
       } = event;
-      if (ports.length) {
+      if (ports.length > 0) {
         return;
       }
       callback(event);
@@ -535,8 +535,8 @@ const IpcChildWithModuleWorker$1 = {
 
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -557,8 +557,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -673,7 +673,12 @@ const signal$6 = messagePort => {
 };
 const wrap$c = port => {
   return {
-    port,
+    dispose() {
+      this.port.close();
+    },
+    off(event, listener) {
+      this.port.off(event, listener);
+    },
     on(event, listener) {
       const wrappedListener = message => {
         const event = {
@@ -684,15 +689,10 @@ const wrap$c = port => {
       };
       this.port.on(event, wrappedListener);
     },
-    off(event, listener) {
-      this.port.off(event, listener);
-    },
+    port,
     send(message) {
       this.port.postMessage(message);
     },
-    dispose() {
-      this.port.close();
-    },
     start() {
       throw new Error('start method is deprecated');
     }
@@ -818,8 +818,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 => {
@@ -831,8 +831,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);
@@ -848,28 +848,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
   };
 };
 
@@ -900,8 +900,8 @@ const handleUpgrade = async (...args) => {
 };
 
 const listen$1 = async ({
-  request,
-  handle
+  handle,
+  request
 }) => {
   if (!request) {
     throw new IpcError('request must be defined');
@@ -921,14 +921,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 => {
@@ -941,28 +946,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
   };
 };
 
@@ -974,7 +974,7 @@ const IpcChildWithWebSocket = {
 };
 
 const listen = () => {
-  return window;
+  return globalThis;
 };
 const signal$3 = global => {
   global.postMessage(readyMessage);
@@ -1001,7 +1001,7 @@ class IpcChildWithWindow extends Ipc {
       const {
         ports
       } = event;
-      if (ports.length) {
+      if (ports.length > 0) {
         return;
       }
       callback(event);
@@ -1071,8 +1071,8 @@ const Message$1 = 3;
 
 const getFirstUtilityProcessEvent = async utilityProcess => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   let stdout = '';
   let stderr = '';
@@ -1093,18 +1093,18 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   };
   const handleMessage = event => {
     cleanup({
-      type: Message$1,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Message$1
     });
   };
   const handleExit = event => {
     cleanup({
-      type: Exit,
       event,
+      stderr,
       stdout,
-      stderr
+      type: Exit
     });
   };
   // @ts-ignore
@@ -1114,23 +1114,23 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   utilityProcess.on('message', handleMessage);
   utilityProcess.on('exit', handleExit);
   const {
-    type,
-    event
+    event,
+    type
   } = await promise;
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 
 const create$6 = async ({
-  path,
   argv = [],
+  env = process.env,
   execArgv = [],
   name,
-  env = process.env
+  path
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
@@ -1138,10 +1138,10 @@ const create$6 = async ({
     utilityProcess
   } = await import('electron');
   const childProcess = utilityProcess.fork(path, actualArgv, {
+    env,
     execArgv,
-    stdio: 'pipe',
     serviceName: name,
-    env
+    stdio: 'pipe'
   });
   const handleExit = () => {
     // @ts-ignore
@@ -1153,9 +1153,9 @@ const create$6 = async ({
   // @ts-ignore
   childProcess.stdout.pipe(process.stdout);
   const {
-    type,
+    stderr,
     stdout,
-    stderr
+    type
   } = await getFirstUtilityProcessEvent(childProcess);
   if (type === Exit) {
     throw new IpcError(`Utility process exited before ipc connection was established`, stdout, stderr);
@@ -1199,8 +1199,8 @@ const IpcParentWithElectronUtilityProcess$1 = {
 };
 
 const create$5 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -1213,8 +1213,8 @@ const create$5 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -1260,8 +1260,8 @@ const Error$1 = 'error';
 
 const getFirstWorkerEvent = worker => {
   return getFirstEvent(worker, {
-    message: Message,
-    error: Error$1
+    error: Error$1,
+    message: Message
   });
 };
 
@@ -1301,16 +1301,16 @@ ${relevant}`;
 const Module = 'module';
 
 const create$4 = async ({
-  url,
-  name
+  name,
+  url
 }) => {
   const worker = new Worker(url, {
-    type: Module,
-    name
+    name,
+    type: Module
   });
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstWorkerEvent(worker);
   switch (type) {
     case Message:
@@ -1379,17 +1379,17 @@ const getPortTuple = () => {
 };
 
 const create$3 = async ({
+  name,
   sendPort,
-  url,
-  name
+  url
 }) => {
   const {
     port1,
     port2
   } = getPortTuple();
   await sendPort({
-    port: port1,
     name,
+    port: port1,
     url
   });
   return port2;
@@ -1433,8 +1433,8 @@ class ChildProcessError extends Error {
   constructor(stderr) {
     // @ts-ignore
     const {
-      message,
       code,
+      message,
       stack
     } = getHelpfulChildProcessError('', stderr);
     super(message || 'child process error');
@@ -1471,10 +1471,10 @@ const fixNodeChildProcessParameters = value => {
 
 const getFirstNodeChildProcessEvent = async childProcess => {
   const {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   } = await new Promise((resolve, reject) => {
     let stderr = '';
     let stdout = '';
@@ -1496,26 +1496,26 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     };
     const handleMessage = event => {
       cleanup({
-        type: Message$1,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Message$1
       });
     };
     const handleExit = event => {
       cleanup({
-        type: Exit,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Exit
       });
     };
     const handleError = event => {
       cleanup({
-        type: Error$2,
         event,
+        stderr,
         stdout,
-        stderr
+        type: Error$2
       });
     };
     if (childProcess.stdout && childProcess.stderr) {
@@ -1527,21 +1527,21 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     childProcess.on('error', handleError);
   });
   return {
-    type,
     event,
+    stderr,
     stdout,
-    stderr
+    type
   };
 };
 
 // @ts-ignore
 const create$2 = async ({
-  path,
   argv = [],
   env,
   execArgv = [],
-  stdio = 'inherit',
-  name = 'child process'
+  name = 'child process',
+  path,
+  stdio = 'inherit'
 }) => {
   try {
     string(path);
@@ -1555,9 +1555,9 @@ const create$2 = async ({
       stdio: 'pipe'
     });
     const {
-      type,
       event,
-      stderr
+      stderr,
+      type
     } = await getFirstNodeChildProcessEvent(childProcess);
     if (type === Exit) {
       throw new ChildProcessError(stderr);
@@ -1625,19 +1625,19 @@ const fixNodeWorkerParameters = value => {
 
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
-    message: Message$1,
+    error: Error$2,
     exit: Exit,
-    error: Error$2
+    message: Message$1
   });
 };
 
 const create$1 = async ({
-  path,
   argv = [],
   env = process.env,
   execArgv = [],
-  stdio,
-  name
+  name,
+  path,
+  stdio
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=node-worker', ...argv];
@@ -1653,13 +1653,13 @@ const create$1 = async ({
     argv: actualArgv,
     env: actualEnv,
     execArgv,
-    stdout: ignoreStdio,
+    name,
     stderr: ignoreStdio,
-    name
+    stdout: ignoreStdio
   });
   const {
-    type,
-    event
+    event,
+    type
   } = await getFirstNodeWorkerEvent(worker);
   if (type === Exit) {
     throw new IpcError(`Worker exited before ipc connection was established`);
@@ -1722,9 +1722,9 @@ const parse = content => {
 
 const waitForWebSocketToBeOpen = webSocket => {
   return getFirstEvent(webSocket, {
-    open: Open,
     close: Close,
-    error: Error$3
+    error: Error$3,
+    open: Open
   });
 };
 

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "14.5.0",
+  "version": "14.7.0",
   "description": "Inter Process Communication for Lvce Editor",
-  "main": "dist/index.js",
-  "type": "module",
-  "sideEffects": false,
   "keywords": [
     "ipc"
   ],
-  "author": "Lvce Editor",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/lvce-editor/ipc.git"
   },
+  "license": "MIT",
+  "author": "Lvce Editor",
+  "sideEffects": false,
+  "type": "module",
+  "main": "dist/index.js",
   "dependencies": {
-    "@lvce-editor/assert": "^1.4.0",
+    "@lvce-editor/assert": "^1.5.1",
     "@lvce-editor/verror": "^1.7.0",
     "@lvce-editor/web-socket-server": "^2.1.0"
   },