@lvce-editor/ipc 3.5.0 → 3.7.0

package/dist/browser.js

@@ -1,20 +1,20 @@
-const getData = event => {
+const getData$1 = event => {
   return event.data;
 };
 
-const listen$1 = () => {
+const readyMessage = 'ready';
+
+const listen$2 = () => {
   // @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 = global => {
-  global.postMessage('ready');
+const signal$1 = global => {
+  global.postMessage(readyMessage);
 };
-const wrap$1 = global => {
+const wrap$3 = global => {
   return {
     global,
     /**
@@ -32,7 +32,7 @@ const wrap$1 = global => {
     },
     set onmessage(listener) {
       const wrappedListener = event => {
-        const data = getData(event);
+        const data = getData$1(event);
         // @ts-expect-error
         listener({
           data,
@@ -47,9 +47,9 @@ const wrap$1 = global => {
 
 const IpcChildWithModuleWorker = {
   __proto__: null,
-  listen: listen$1,
-  signal,
-  wrap: wrap$1
+  listen: listen$2,
+  signal: signal$1,
+  wrap: wrap$3
 };
 
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
@@ -282,9 +282,9 @@ const waitForFirstMessage = async port => {
   return event.data;
 };
 
-const listen = async () => {
-  const parentIpcRaw = listen$1();
-  const parentIpc = wrap$1(parentIpcRaw);
+const listen$1 = async () => {
+  const parentIpcRaw = listen$2();
+  const parentIpc = wrap$3(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -296,7 +296,7 @@ const listen = async () => {
   }
   return globalThis;
 };
-const wrap = port => {
+const wrap$2 = port => {
   return {
     port,
     /**
@@ -316,7 +316,7 @@ const wrap = port => {
       if (listener) {
         // @ts-expect-error
         this.wrappedListener = event => {
-          const data = getData(event);
+          const data = getData$1(event);
           // @ts-expect-error
           listener({
             data,
@@ -332,9 +332,206 @@ const wrap = port => {
 };
 
 const IpcChildWithModuleWorkerAndMessagePort = {
+  __proto__: null,
+  listen: listen$1,
+  wrap: wrap$2
+};
+
+const listen = () => {
+  // @ts-ignore
+  return window;
+};
+const signal = global => {
+  global.postMessage(readyMessage);
+};
+const wrap$1 = window => {
+  return {
+    window,
+    /**
+     * @type {any}
+     */
+    listener: undefined,
+    get onmessage() {
+      return this.listener;
+    },
+    set onmessage(listener) {
+      this.listener = listener;
+      const wrappedListener = event => {
+        const data = event.data;
+        if ('method' in data) {
+          return;
+        }
+        // @ts-ignore
+        listener({
+          data,
+          target: this
+        });
+      };
+      this.window.onmessage = wrappedListener;
+    },
+    send(message) {
+      this.window.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      this.window.postMessage(message, '*', transfer);
+    },
+    dispose() {
+      this.window.onmessage = null;
+      this.window = undefined;
+      this.listener = undefined;
+    }
+  };
+};
+
+const IpcChildWithWindow = {
   __proto__: null,
   listen,
+  signal,
+  wrap: wrap$1
+};
+
+const Message = 'message';
+const Error$1 = 'error';
+
+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,
+        event
+      });
+    };
+    eventEmitter.on(event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+
+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 = 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;
+};
+const wrap = worker => {
+  let handleMessage;
+  return {
+    get onmessage() {
+      return handleMessage;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        handleMessage = event => {
+          const data = getData(event);
+          listener({
+            data,
+            target: this
+          });
+        };
+      } else {
+        handleMessage = null;
+      }
+      worker.onmessage = handleMessage;
+    },
+    send(message) {
+      worker.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      worker.postMessage(message, transfer);
+    }
+  };
+};
+
+const IpcParentWithModuleWorker = {
+  __proto__: null,
+  create,
   wrap
 };
 
-export { IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort };
+export { IpcChildWithModuleWorker, IpcChildWithModuleWorkerAndMessagePort, IpcChildWithWindow, IpcParentWithModuleWorker };

package/dist/index.js

@@ -232,6 +232,8 @@ const getUtilityProcessPortData = event => {
   };
 };
 
+const readyMessage = 'ready';
+
 const listen$6 = () => {
   // @ts-ignore
   const {
@@ -245,7 +247,7 @@ const listen$6 = () => {
 
 // @ts-ignore
 const signal$3 = parentPort => {
-  parentPort.postMessage('ready');
+  parentPort.postMessage(readyMessage);
 };
 
 // @ts-ignore
@@ -301,12 +303,10 @@ const listen$5 = () => {
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
-  // @ts-ignore
-  globalThis.postMessage('ready');
   return globalThis;
 };
 const signal$2 = global => {
-  global.postMessage('ready');
+  global.postMessage(readyMessage);
 };
 const wrap$8 = global => {
   return {
@@ -439,7 +439,7 @@ const listen$3 = async () => {
 
 // @ts-ignore
 const signal$1 = process => {
-  process.send('ready');
+  process.send(readyMessage);
 };
 
 // @ts-ignore
@@ -540,7 +540,7 @@ const listen$1 = async () => {
   return parentPort;
 };
 const signal = parentPort => {
-  parentPort.postMessage('ready');
+  parentPort.postMessage(readyMessage);
 };
 const wrap$4 = parentPort => {
   return {
@@ -803,7 +803,8 @@ const create$2 = async ({
   path,
   argv = [],
   execArgv = [],
-  name
+  name,
+  env = process.env
 }) => {
   string(path);
   const actualArgv = ['--ipc-type=electron-utility-process', ...argv];
@@ -814,7 +815,8 @@ const create$2 = async ({
   const childProcess = utilityProcess.fork(path, actualArgv, {
     execArgv,
     stdio: 'pipe',
-    serviceName: name
+    serviceName: name,
+    env
   });
   // @ts-ignore
   childProcess.stdout.pipe(process.stdout);
@@ -1077,7 +1079,7 @@ const create = async ({
   if (type === Error$1) {
     throw new IpcError(`Worker threw an error before ipc connection was established: ${event}`);
   }
-  if (event !== 'ready') {
+  if (event !== readyMessage) {
     throw new IpcError('unexpected first message from worker');
   }
   return worker;

package/package.json

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