@lvce-editor/ipc 3.0.0 → 3.2.0

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+interface IpcChild {
+  readonly listen: any
+  readonly wrap: any
+}
+
+export const IpcChildWithElectronMessagePort: IpcChild
+export const IpcChildWithElectronUtilityProcess: IpcChild
+export const IpcChildWithNodeForkedProcess: IpcChild
+export const IpcChildWithWebSocket: IpcChild
+export const IpcChildWithModuleWorkerAndMessagePort: IpcChild
+export const IpcChildWithModuleWorker: IpcChild
+
+interface IpcParent {
+  readonly create: any
+  readonly wrap: any
+}
+
+export const IpcParentWithElectronUtilityProcess: IpcParent
+export const IpcParentWithNodeForkedProcess: IpcParent
+export const IpcParentWithNodeWorker: IpcParent

package/dist/index.js

@@ -1,7 +1,5 @@
 import { VError } from '@lvce-editor/verror';
 import { string, array } from '@lvce-editor/assert';
-import { fork } from 'node:child_process';
-import { Worker } from 'node:worker_threads';
 
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -9,14 +7,14 @@ const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
 
 const NewLine = '\n';
 
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-
 const joinLines = lines => {
   return lines.join(NewLine);
 };
 
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+
 const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
 const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
 const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
@@ -53,7 +51,7 @@ const isModulesSyntaxError = stderr => {
   }
   return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const getModuleSyntaxError = stderr => {
+const getModuleSyntaxError = () => {
   return {
     message: `ES Modules are not supported in electron`,
     code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
@@ -122,6 +120,7 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 };
 
 class IpcError extends VError {
+  // @ts-ignore
   constructor(message, stdout = '', stderr = '') {
     if (stdout || stderr) {
       // @ts-ignore
@@ -151,7 +150,8 @@ const isMessagePortMain = value => {
   return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
 
-const listen$3 = ({
+// @ts-ignore
+const listen$5 = ({
   messagePort
 }) => {
   if (!isMessagePortMain(messagePort)) {
@@ -159,6 +159,8 @@ const listen$3 = ({
   }
   return messagePort;
 };
+
+// @ts-ignore
 const getActualData$1 = event => {
   const {
     data,
@@ -172,11 +174,15 @@ const getActualData$1 = event => {
     params: [...ports, ...data.params]
   };
 };
-const wrap$6 = messagePort => {
+
+// @ts-ignore
+const wrap$8 = messagePort => {
   return {
     messagePort,
+    // @ts-ignore
     on(event, listener) {
       if (event === 'message') {
+        // @ts-ignore
         const wrappedListener = event => {
           const actualData = getActualData$1(event);
           listener(actualData);
@@ -188,9 +194,11 @@ const wrap$6 = messagePort => {
         throw new Error('unsupported event type');
       }
     },
+    // @ts-ignore
     off(event, listener) {
       this.messagePort.off(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.messagePort.postMessage(message);
     },
@@ -205,10 +213,11 @@ const wrap$6 = messagePort => {
 
 const IpcChildWithElectronMessagePort = {
   __proto__: null,
-  listen: listen$3,
-  wrap: wrap$6
+  listen: listen$5,
+  wrap: wrap$8
 };
 
+// @ts-ignore
 const getUtilityProcessPortData = event => {
   const {
     data,
@@ -223,7 +232,7 @@ const getUtilityProcessPortData = event => {
   };
 };
 
-const listen$2 = () => {
+const listen$4 = () => {
   // @ts-ignore
   const {
     parentPort
@@ -233,14 +242,20 @@ const listen$2 = () => {
   }
   return parentPort;
 };
-const signal$1 = parentPort => {
+
+// @ts-ignore
+const signal$2 = parentPort => {
   parentPort.postMessage('ready');
 };
-const wrap$5 = parentPort => {
+
+// @ts-ignore
+const wrap$7 = parentPort => {
   return {
     parentPort,
+    // @ts-ignore
     on(event, listener) {
       if (event === 'message') {
+        // @ts-ignore
         const wrappedListener = event => {
           const actualData = getUtilityProcessPortData(event);
           listener(actualData);
@@ -252,12 +267,15 @@ const wrap$5 = parentPort => {
         throw new Error('unsupported event type');
       }
     },
+    // @ts-ignore
     off(event, listener) {
       this.parentPort.off(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.parentPort.postMessage(message);
     },
+    // @ts-ignore
     sendAndTransfer(message, transfer) {
       this.parentPort.postMessage(message, transfer);
     },
@@ -269,8 +287,146 @@ const wrap$5 = parentPort => {
 
 const IpcChildWithElectronUtilityProcess = {
   __proto__: null,
-  listen: listen$2,
+  listen: listen$4,
+  signal: signal$2,
+  wrap: wrap$7
+};
+
+const getData = event => {
+  return event.data;
+};
+
+const listen$3 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  // @ts-ignore
+  globalThis.postMessage('ready');
+  return globalThis;
+};
+const signal$1 = global => {
+  global.postMessage('ready');
+};
+const wrap$6 = global => {
+  return {
+    global,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    send(message) {
+      this.global.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      this.global.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      const wrappedListener = event => {
+        const data = getData(event);
+        // @ts-expect-error
+        listener({
+          data,
+          target: this
+        });
+      };
+      this.listener = listener;
+      this.global.onmessage = wrappedListener;
+    }
+  };
+};
+
+const IpcChildWithModuleWorker = {
+  __proto__: null,
+  listen: listen$3,
   signal: signal$1,
+  wrap: wrap$6
+};
+
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const cleanup = value => {
+    port.onmessage = null;
+    resolve(value);
+  };
+  const handleMessage = event => {
+    cleanup(event);
+  };
+  port.onmessage = handleMessage;
+  const event = await promise;
+  // @ts-expect-error
+  return event.data;
+};
+
+const listen$2 = async () => {
+  const parentIpcRaw = listen$3();
+  const parentIpc = wrap$6(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+const wrap$5 = port => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      this.port.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return this.wrappedListener;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        // @ts-expect-error
+        this.wrappedListener = event => {
+          const data = getData(event);
+          // @ts-expect-error
+          listener({
+            data,
+            target: this
+          });
+        };
+      } else {
+        this.wrappedListener = undefined;
+      }
+      this.port.onmessage = this.wrappedListener;
+    }
+  };
+};
+
+const IpcChildWithModuleWorkerAndMessagePort = {
+  __proto__: null,
+  listen: listen$2,
   wrap: wrap$5
 };
 
@@ -280,9 +436,13 @@ const listen$1 = async () => {
   }
   return process;
 };
+
+// @ts-ignore
 const signal = process => {
   process.send('ready');
 };
+
+// @ts-ignore
 const getActualData = (message, handle) => {
   if (handle) {
     return {
@@ -292,11 +452,15 @@ const getActualData = (message, handle) => {
   }
   return message;
 };
+
+// @ts-ignore
 const wrap$4 = process => {
   return {
     process,
+    // @ts-ignore
     on(event, listener) {
       if (event === 'message') {
+        // @ts-ignore
         const wrappedListener = (event, handle) => {
           const actualData = getActualData(event, handle);
           listener(actualData);
@@ -308,9 +472,11 @@ const wrap$4 = process => {
         throw new Error('unsupported event type');
       }
     },
+    // @ts-ignore
     off(event, listener) {
       this.process.off(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.process.send(message);
     },
@@ -328,39 +494,23 @@ const IpcChildWithNodeForkedProcess = {
 const Open = 1;
 const Close = 2;
 
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
-  });
-  return {
-    resolve: _resolve,
-    reject: _reject,
-    promise
-  };
-};
-
+// @ts-ignore
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
     resolve,
     promise
   } = withResolvers();
   const listenerMap = Object.create(null);
+  // @ts-ignore
   const cleanup = value => {
     for (const event of Object.keys(eventMap)) {
       eventEmitter.off(event, listenerMap[event]);
     }
+    // @ts-ignore
     resolve(value);
   };
   for (const [event, type] of Object.entries(eventMap)) {
+    // @ts-ignore
     const listener = event => {
       cleanup({
         type,
@@ -373,7 +523,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 
+// @ts-ignore
 const getFirstWebSocketEvent = async webSocket => {
+  // @ts-ignore
   const {
     WebSocket
   } = await import('ws');
@@ -403,26 +555,33 @@ const getFirstWebSocketEvent = async webSocket => {
   };
 };
 
+// @ts-ignore
 const isWebSocketOpen = async webSocket => {
+  // @ts-ignore
   const {
     WebSocket
   } = await import('ws');
   return webSocket.readyState === WebSocket.OPEN;
 };
 
+// @ts-ignore
 const serialize = message => {
   return JSON.stringify(message);
 };
+
+// @ts-ignore
 const deserialize = message => {
   return JSON.parse(message.toString());
 };
 
+// @ts-ignore
 const handleUpgrade = async (...args) => {
   const module = await import('@lvce-editor/web-socket-server');
   // @ts-ignore
   return module.handleUpgrade(...args);
 };
 
+// @ts-ignore
 const listen = async ({
   request,
   handle
@@ -440,6 +599,8 @@ const listen = async ({
   }
   return webSocket;
 };
+
+// @ts-ignore
 const wrap$3 = webSocket => {
   return {
     webSocket,
@@ -447,9 +608,11 @@ const wrap$3 = webSocket => {
      * @type {any}
      */
     wrappedListener: undefined,
+    // @ts-ignore
     on(event, listener) {
       switch (event) {
         case 'message':
+          // @ts-ignore
           const wrappedListener = message => {
             const data = deserialize(message);
             listener(data);
@@ -463,9 +626,11 @@ const wrap$3 = webSocket => {
           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);
@@ -494,6 +659,7 @@ const Message = 3;
  * @param {any} utilityProcess
  * @returns
  */
+// @ts-ignore
 const getFirstUtilityProcessEvent = async utilityProcess => {
   const {
     resolve,
@@ -501,6 +667,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   } = withResolvers();
   let stdout = '';
   let stderr = '';
+  // @ts-ignore
   const cleanup = value => {
     // @ts-ignore
     utilityProcess.stderr.off('data', handleStdErrData);
@@ -508,14 +675,18 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
     utilityProcess.stdout.off('data', handleStdoutData);
     utilityProcess.off('message', handleMessage);
     utilityProcess.off('exit', handleExit);
+    // @ts-ignore
     resolve(value);
   };
+  // @ts-ignore
   const handleStdErrData = data => {
     stderr += data;
   };
+  // @ts-ignore
   const handleStdoutData = data => {
     stdout += data;
   };
+  // @ts-ignore
   const handleMessage = event => {
     cleanup({
       type: Message,
@@ -524,6 +695,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
       stderr
     });
   };
+  // @ts-ignore
   const handleExit = event => {
     cleanup({
       type: Exit,
@@ -551,6 +723,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   };
 };
 
+// @ts-ignore
 const create$2 = async ({
   path,
   argv = [],
@@ -583,15 +756,20 @@ const create$2 = async ({
   childProcess.stderr.pipe(process.stderr);
   return childProcess;
 };
+
+// @ts-ignore
 const wrap$2 = process => {
   return {
     process,
+    // @ts-ignore
     on(event, listener) {
       this.process.on(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.process.postMessage(message);
     },
+    // @ts-ignore
     sendAndTransfer(message, transfer) {
       array(transfer);
       this.process.postMessage(message, transfer);
@@ -609,6 +787,7 @@ const IpcParentWithElectronUtilityProcess = {
 };
 
 class ChildProcessError extends Error {
+  // @ts-ignore
   constructor(stderr) {
     // @ts-ignore
     const {
@@ -623,6 +802,7 @@ class ChildProcessError extends Error {
       this.code = code;
     }
     if (stack) {
+      // @ts-ignore
       const lines = splitLines(this.stack);
       const [firstLine, ...stackLines] = lines;
       const newStackLines = [firstLine, ...stack, ...stackLines];
@@ -632,6 +812,7 @@ class ChildProcessError extends Error {
   }
 }
 
+// @ts-ignore
 const getFirstNodeChildProcessEvent = async childProcess => {
   // @ts-ignore
   const {
@@ -642,6 +823,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
   } = await new Promise((resolve, reject) => {
     let stderr = '';
     let stdout = '';
+    // @ts-ignore
     const cleanup = value => {
       if (childProcess.stdout && childProcess.stderr) {
         childProcess.stderr.off('data', handleStdErrData);
@@ -652,12 +834,15 @@ const getFirstNodeChildProcessEvent = async childProcess => {
       childProcess.off('error', handleError);
       resolve(value);
     };
+    // @ts-ignore
     const handleStdErrData = data => {
       stderr += data;
     };
+    // @ts-ignore
     const handleStdoutData = data => {
       stdout += data;
     };
+    // @ts-ignore
     const handleMessage = event => {
       cleanup({
         type: Message,
@@ -666,6 +851,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
         stderr
       });
     };
+    // @ts-ignore
     const handleExit = event => {
       cleanup({
         type: Exit,
@@ -674,6 +860,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
         stderr
       });
     };
+    // @ts-ignore
     const handleError = event => {
       cleanup({
         type: Error$1,
@@ -698,6 +885,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
   };
 };
 
+// @ts-ignore
 const create$1 = async ({
   path,
   argv = [],
@@ -706,9 +894,13 @@ const create$1 = async ({
   stdio = 'inherit',
   name = 'child process'
 }) => {
+  // @ts-ignore
   try {
     string(path);
     const actualArgv = ['--ipc-type=node-forked-process', ...argv];
+    const {
+      fork
+    } = await import('node:child_process');
     const childProcess = fork(path, actualArgv, {
       env,
       execArgv,
@@ -735,18 +927,24 @@ const create$1 = async ({
     throw new VError(error, `Failed to launch ${name}`);
   }
 };
+
+// @ts-ignore
 const wrap$1 = childProcess => {
   return {
     childProcess,
+    // @ts-ignore
     on(event, listener) {
       this.childProcess.on(event, listener);
     },
+    // @ts-ignore
     off(event, listener) {
       this.childProcess.off(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.childProcess.send(message);
     },
+    // @ts-ignore
     sendAndTransfer(message, handle) {
       this.childProcess.send(message, handle);
     },
@@ -763,6 +961,7 @@ const IpcParentWithNodeForkedProcess = {
   wrap: wrap$1
 };
 
+// @ts-ignore
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
     exit: Exit,
@@ -770,18 +969,23 @@ const getFirstNodeWorkerEvent = worker => {
   });
 };
 
+// @ts-ignore
 const create = async ({
   path,
   argv = [],
   env = process.env,
   execArgv = []
 }) => {
+  // @ts-ignore
   string(path);
   const actualArgv = ['--ipc-type=node-worker', ...argv];
   const actualEnv = {
     ...env,
     ELECTRON_RUN_AS_NODE: '1'
   };
+  const {
+    Worker
+  } = await import('node:worker_threads');
   const worker = new Worker(path, {
     argv: actualArgv,
     env: actualEnv,
@@ -803,15 +1007,20 @@ const create = async ({
   }
   return worker;
 };
+
+// @ts-ignore
 const wrap = worker => {
   return {
     worker,
+    // @ts-ignore
     on(event, listener) {
       this.worker.on(event, listener);
     },
+    // @ts-ignore
     send(message) {
       this.worker.postMessage(message);
     },
+    // @ts-ignore
     sendAndTransfer(message, transfer) {
       array(transfer);
       this.worker.postMessage(message, transfer);
@@ -828,4 +1037,4 @@ const IpcParentWithNodeWorker = {
   wrap
 };
 
-export { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeForkedProcess, IpcChildWithWebSocket, IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker };
+export { IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort, IpcChildWithNodeForkedProcess, IpcChildWithWebSocket, IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",
@@ -20,5 +20,6 @@
   },
   "engines": {
     "node": ">=18"
-  }
+  },
+  "types": "dist/index.d.ts"
 }