@lvce-editor/ipc 11.4.0 → 11.6.0

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export const IpcChildWithNodeForkedProcess: IpcChild
 export const IpcChildWithWebSocket: IpcChild
 export const IpcChildWithNodeWorker: IpcChild
 export const IpcChildWithRendererProcess2: IpcChild
+export const IpcChildWithModuleWorkerAndMessagePort: IpcChild
 
 interface IpcParent {
   readonly create: any
@@ -27,3 +28,5 @@ export const IpcParentWithNodeForkedProcess: IpcParent
 export const IpcParentWithNodeWorker: IpcParent
 export const IpcParentWithElectronMessagePort: IpcParent
 export const IpcParentWithMessagePort: IpcParent
+export const IpcParentWithWebSocket: IpcParent
+export const IpcParentWithModuleWorker: IpcParent

package/dist/index.js

@@ -287,7 +287,7 @@ const listen$8 = ({
   }
   return messagePort;
 };
-const signal$7 = messagePort => {
+const signal$8 = messagePort => {
   messagePort.start();
 };
 class IpcChildWithElectronMessagePort extends Ipc {
@@ -315,15 +315,15 @@ class IpcChildWithElectronMessagePort extends Ipc {
     this._rawIpc.on('close', callback);
   }
 }
-const wrap$c = messagePort => {
+const wrap$f = messagePort => {
   return new IpcChildWithElectronMessagePort(messagePort);
 };
 
 const IpcChildWithElectronMessagePort$1 = {
   __proto__: null,
   listen: listen$8,
-  signal: signal$7,
-  wrap: wrap$c
+  signal: signal$8,
+  wrap: wrap$f
 };
 
 // @ts-ignore
@@ -353,7 +353,7 @@ const listen$7 = () => {
   }
   return parentPort;
 };
-const signal$6 = parentPort => {
+const signal$7 = parentPort => {
   parentPort.postMessage(readyMessage);
 };
 class IpcChildWithElectronUtilityProcess extends Ipc {
@@ -380,18 +380,18 @@ class IpcChildWithElectronUtilityProcess extends Ipc {
     this._rawIpc.on('message', callback);
   }
 }
-const wrap$b = parentPort => {
+const wrap$e = parentPort => {
   return new IpcChildWithElectronUtilityProcess(parentPort);
 };
 
 const IpcChildWithElectronUtilityProcess$1 = {
   __proto__: null,
   listen: listen$7,
-  signal: signal$6,
-  wrap: wrap$b
+  signal: signal$7,
+  wrap: wrap$e
 };
 
-const getData$1 = event => {
+const getData$2 = event => {
   return event.data;
 };
 
@@ -402,12 +402,12 @@ const listen$6 = () => {
   }
   return globalThis;
 };
-const signal$5 = global => {
+const signal$6 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
   getData(event) {
-    return getData$1(event);
+    return getData$2(event);
   }
   send(message) {
     // @ts-ignore
@@ -428,15 +428,15 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$a = global => {
+const wrap$d = global => {
   return new IpcChildWithModuleWorker(global);
 };
 
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
   listen: listen$6,
-  signal: signal$5,
-  wrap: wrap$a
+  signal: signal$6,
+  wrap: wrap$d
 };
 
 const withResolvers = () => {
@@ -465,8 +465,8 @@ const waitForFirstMessage = async port => {
 
 const listen$5 = async () => {
   const parentIpcRaw = listen$6();
-  signal$5(parentIpcRaw);
-  const parentIpc = wrap$a(parentIpcRaw);
+  signal$6(parentIpcRaw);
+  const parentIpc = wrap$d(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -489,7 +489,7 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     super(port);
   }
   getData(event) {
-    return getData$1(event);
+    return getData$2(event);
   }
   send(message) {
     this._rawIpc.postMessage(message);
@@ -511,14 +511,14 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$9 = port => {
+const wrap$c = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
   listen: listen$5,
-  wrap: wrap$9
+  wrap: wrap$c
 };
 
 const getTransferrablesNode = value => {
@@ -545,7 +545,7 @@ const listen$4 = async () => {
   }
   return process;
 };
-const signal$4 = process => {
+const signal$5 = process => {
   process.send(readyMessage);
 };
 class IpcChildWithNodeForkedProcess extends Ipc {
@@ -572,15 +572,15 @@ class IpcChildWithNodeForkedProcess extends Ipc {
     // ignore
   }
 }
-const wrap$8 = process => {
+const wrap$b = process => {
   return new IpcChildWithNodeForkedProcess(process);
 };
 
 const IpcChildWithNodeForkedProcess$1 = {
   __proto__: null,
   listen: listen$4,
-  signal: signal$4,
-  wrap: wrap$8
+  signal: signal$5,
+  wrap: wrap$b
 };
 
 const listen$3 = async ({
@@ -591,10 +591,10 @@ const listen$3 = async ({
   }
   return messagePort;
 };
-const signal$3 = messagePort => {
+const signal$4 = messagePort => {
   messagePort.start();
 };
-const wrap$7 = port => {
+const wrap$a = port => {
   return {
     port,
     on(event, listener) {
@@ -625,8 +625,8 @@ const wrap$7 = port => {
 const IpcChildWithNodeMessagePort = {
   __proto__: null,
   listen: listen$3,
-  signal: signal$3,
-  wrap: wrap$7
+  signal: signal$4,
+  wrap: wrap$a
 };
 
 const listen$2 = async () => {
@@ -638,7 +638,7 @@ const listen$2 = async () => {
   }
   return parentPort;
 };
-const signal$2 = parentPort => {
+const signal$3 = parentPort => {
   parentPort.postMessage(readyMessage);
 };
 class IpcChildWithNodeWorker extends Ipc {
@@ -665,15 +665,15 @@ class IpcChildWithNodeWorker extends Ipc {
     this._rawIpc.close();
   }
 }
-const wrap$6 = parentPort => {
+const wrap$9 = parentPort => {
   return new IpcChildWithNodeWorker(parentPort);
 };
 
 const IpcChildWithNodeWorker$1 = {
   __proto__: null,
   listen: listen$2,
-  signal: signal$2,
-  wrap: wrap$6
+  signal: signal$3,
+  wrap: wrap$9
 };
 
 const preloadChannelType = 'port';
@@ -682,7 +682,7 @@ const listen$1 = ({
 }) => {
   return webContents;
 };
-const getData = (event, message) => {
+const getData$1 = (event, message) => {
   const {
     ports,
     sender
@@ -695,7 +695,7 @@ const getData = (event, message) => {
 };
 class IpcChildWithRendererProcess2 extends Ipc {
   getData(event, message) {
-    return getData(event, message);
+    return getData$1(event, message);
   }
   send(message) {
     this._rawIpc.postMessage(preloadChannelType, message);
@@ -714,14 +714,14 @@ class IpcChildWithRendererProcess2 extends Ipc {
     this._rawIpc.on('destroyed', callback);
   }
 }
-const wrap$5 = webContents => {
+const wrap$8 = webContents => {
   return new IpcChildWithRendererProcess2(webContents);
 };
 
 const IpcChildWithRendererProcess2$1 = {
   __proto__: null,
   listen: listen$1,
-  wrap: wrap$5
+  wrap: wrap$8
 };
 
 const Open = 1;
@@ -842,12 +842,12 @@ const listen = async ({
   }
   return webSocket;
 };
-const signal$1 = webSocket => {
+const signal$2 = webSocket => {
   webSocket.resume();
 };
 
 // @ts-ignore
-const wrap$4 = webSocket => {
+const wrap$7 = webSocket => {
   return {
     webSocket,
     /**
@@ -897,11 +897,11 @@ const wrap$4 = webSocket => {
 const IpcChildWithWebSocket = {
   __proto__: null,
   listen,
-  signal: signal$1,
-  wrap: wrap$4
+  signal: signal$2,
+  wrap: wrap$7
 };
 
-const create$3 = ({
+const create$6 = ({
   messagePort
 }) => {
   if (!isMessagePortMain(messagePort)) {
@@ -909,7 +909,7 @@ const create$3 = ({
   }
   return messagePort;
 };
-const signal = messagePort => {
+const signal$1 = messagePort => {
   messagePort.start();
 };
 class IpcParentWithElectronMessagePort extends Ipc {
@@ -937,20 +937,20 @@ class IpcParentWithElectronMessagePort extends Ipc {
     this._rawIpc.on('close', callback);
   }
 }
-const wrap$3 = messagePort => {
+const wrap$6 = messagePort => {
   return new IpcParentWithElectronMessagePort(messagePort);
 };
 
 const IpcParentWithElectronMessagePort$1 = {
   __proto__: null,
-  create: create$3,
-  signal,
-  wrap: wrap$3
+  create: create$6,
+  signal: signal$1,
+  wrap: wrap$6
 };
 
 const Exit = 1;
-const Error$1 = 2;
-const Message = 3;
+const Error$2 = 2;
+const Message$1 = 3;
 
 /**
  *
@@ -987,7 +987,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
   // @ts-ignore
   const handleMessage = event => {
     cleanup({
-      type: Message,
+      type: Message$1,
       event,
       stdout,
       stderr
@@ -1022,7 +1022,7 @@ const getFirstUtilityProcessEvent = async utilityProcess => {
 };
 
 // @ts-ignore
-const create$2 = async ({
+const create$5 = async ({
   path,
   argv = [],
   execArgv = [],
@@ -1085,14 +1085,180 @@ class IpcParentWithElectronUtilityProcess extends Ipc {
     this._rawIpc.on('message', callback);
   }
 }
-const wrap$2 = process => {
+const wrap$5 = process => {
   return new IpcParentWithElectronUtilityProcess(process);
 };
 
 const IpcParentWithElectronUtilityProcess$1 = {
   __proto__: null,
-  create: create$2,
-  wrap: wrap$2
+  create: create$5,
+  wrap: wrap$5
+};
+
+const create$4 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const event = await eventPromise;
+  // @ts-ignore
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$4 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$4,
+  signal,
+  wrap: wrap$4
+};
+
+const Message = 'message';
+const Error$1 = 'error';
+
+const getFirstWorkerEvent = worker => {
+  return getFirstEvent(worker, {
+    message: Message,
+    error: Error$1
+  });
+};
+
+const isErrorEvent = event => {
+  return event instanceof ErrorEvent;
+};
+
+const getWorkerDisplayName = name => {
+  if (!name) {
+    return '<unknown> worker';
+  }
+  if (name.endsWith('Worker') || name.endsWith('worker')) {
+    return name.toLowerCase();
+  }
+  return `${name} Worker`;
+};
+
+const tryToGetActualErrorMessage = async ({
+  name
+}) => {
+  const displayName = getWorkerDisplayName(name);
+  return `Failed to start ${displayName}: Worker Launch Error`;
+};
+
+class WorkerError extends Error {
+  constructor(event) {
+    super(event.message);
+    const stackLines = splitLines(this.stack || '');
+    const relevantLines = stackLines.slice(1);
+    const relevant = joinLines(relevantLines);
+    this.stack = `${event.message}
+    at Module (${event.filename}:${event.lineno}:${event.colno})
+${relevant}`;
+  }
+}
+
+const Module = 'module';
+
+const create$3 = async ({
+  url,
+  name
+}) => {
+  const worker = new Worker(url, {
+    type: Module,
+    name
+  });
+  const {
+    type,
+    event
+  } = await getFirstWorkerEvent(worker);
+  switch (type) {
+    case Message:
+      if (event.data !== readyMessage) {
+        throw new IpcError('unexpected first message from worker');
+      }
+      break;
+    case Error$1:
+      if (isErrorEvent(event)) {
+        throw new WorkerError(event);
+      }
+      const actualErrorMessage = await tryToGetActualErrorMessage({
+        name
+      });
+      throw new Error(actualErrorMessage);
+  }
+  return worker;
+};
+const getData = event => {
+  // TODO why are some events not instance of message event?
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+class IpcParentWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$3 = worker => {
+  return new IpcParentWithModuleWorker(worker);
+};
+
+const IpcParentWithModuleWorker$1 = {
+  __proto__: null,
+  create: create$3,
+  wrap: wrap$3
 };
 
 class ChildProcessError extends Error {
@@ -1169,7 +1335,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     // @ts-ignore
     const handleMessage = event => {
       cleanup({
-        type: Message,
+        type: Message$1,
         event,
         stdout,
         stderr
@@ -1187,7 +1353,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
     // @ts-ignore
     const handleError = event => {
       cleanup({
-        type: Error$1,
+        type: Error$2,
         event,
         stdout,
         stderr
@@ -1210,7 +1376,7 @@ const getFirstNodeChildProcessEvent = async childProcess => {
 };
 
 // @ts-ignore
-const create$1 = async ({
+const create$2 = async ({
   path,
   argv = [],
   env,
@@ -1237,7 +1403,7 @@ const create$1 = async ({
     if (type === Exit) {
       throw new ChildProcessError(stderr);
     }
-    if (type === Error$1) {
+    if (type === Error$2) {
       throw new Error(`child process had an error ${event}`);
     }
     if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
@@ -1277,14 +1443,14 @@ class IpcParentWithNodeForkedProcess extends Ipc {
     this._rawIpc.on('message', callback);
   }
 }
-const wrap$1 = childProcess => {
+const wrap$2 = childProcess => {
   return new IpcParentWithNodeForkedProcess(childProcess);
 };
 
 const IpcParentWithNodeForkedProcess$1 = {
   __proto__: null,
-  create: create$1,
-  wrap: wrap$1
+  create: create$2,
+  wrap: wrap$2
 };
 
 const fixNodeWorkerParameters = value => {
@@ -1300,14 +1466,14 @@ const fixNodeWorkerParameters = value => {
 
 const getFirstNodeWorkerEvent = worker => {
   return getFirstEvent(worker, {
-    message: Message,
+    message: Message$1,
     exit: Exit,
-    error: Error$1
+    error: Error$2
   });
 };
 
 // @ts-ignore
-const create = async ({
+const create$1 = async ({
   path,
   argv = [],
   env = process.env,
@@ -1336,7 +1502,7 @@ const create = async ({
   if (type === Exit) {
     throw new IpcError(`Worker exited before ipc connection was established`);
   }
-  if (type === Error$1) {
+  if (type === Error$2) {
     throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`);
   }
   if (event !== readyMessage) {
@@ -1371,14 +1537,75 @@ class IpcParentWithNodeWorker extends Ipc {
     this._rawIpc.on('message', callback);
   }
 }
-const wrap = worker => {
+const wrap$1 = worker => {
   return new IpcParentWithNodeWorker(worker);
 };
 
 const IpcParentWithNodeWorker$1 = {
+  __proto__: null,
+  create: create$1,
+  wrap: wrap$1
+};
+
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close
+  });
+};
+
+const create = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  // @ts-ignore
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+
+const IpcParentWithWebSocket$1 = {
   __proto__: null,
   create,
   wrap
 };
 
-export { IpcChildWithElectronMessagePort$1 as IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess$1 as IpcChildWithElectronUtilityProcess, IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithNodeForkedProcess$1 as IpcChildWithNodeForkedProcess, IpcChildWithNodeMessagePort, IpcChildWithNodeWorker$1 as IpcChildWithNodeWorker, IpcChildWithRendererProcess2$1 as IpcChildWithRendererProcess2, IpcChildWithWebSocket, IpcParentWithElectronMessagePort$1 as IpcParentWithElectronMessagePort, IpcParentWithElectronUtilityProcess$1 as IpcParentWithElectronUtilityProcess, IpcParentWithNodeForkedProcess$1 as IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker$1 as IpcParentWithNodeWorker };
+export { IpcChildWithElectronMessagePort$1 as IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess$1 as IpcChildWithElectronUtilityProcess, IpcChildWithModuleWorker$1 as IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort$1 as IpcChildWithModuleWorkerAndMessagePort, IpcChildWithNodeForkedProcess$1 as IpcChildWithNodeForkedProcess, IpcChildWithNodeMessagePort, IpcChildWithNodeWorker$1 as IpcChildWithNodeWorker, IpcChildWithRendererProcess2$1 as IpcChildWithRendererProcess2, IpcChildWithWebSocket, IpcParentWithElectronMessagePort$1 as IpcParentWithElectronMessagePort, IpcParentWithElectronUtilityProcess$1 as IpcParentWithElectronUtilityProcess, IpcParentWithMessagePort$1 as IpcParentWithMessagePort, IpcParentWithModuleWorker$1 as IpcParentWithModuleWorker, IpcParentWithNodeForkedProcess$1 as IpcParentWithNodeForkedProcess, IpcParentWithNodeWorker$1 as IpcParentWithNodeWorker, IpcParentWithWebSocket$1 as IpcParentWithWebSocket };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/ipc",
-  "version": "11.4.0",
+  "version": "11.6.0",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",