@lvce-editor/ipc 3.6.0 → 3.7.1

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,
@@ -41,15 +41,20 @@ const wrap$1 = global => {
       };
       this.listener = listener;
       this.global.onmessage = wrappedListener;
+    },
+    dispose() {
+      // @ts-ignore
+      this.listener = null;
+      this.global.onmessage = null;
     }
   };
 };
 
 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,21 +287,23 @@ 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();
+  signal$1(parentIpcRaw);
+  const parentIpc = wrap$3(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') {
+    parentIpc.dispose();
     const port = firstMessage.params[1];
     return port;
   }
   return globalThis;
 };
-const wrap = port => {
+const wrap$2 = port => {
   return {
     port,
     /**
@@ -316,7 +323,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 +339,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 {
@@ -335,6 +335,11 @@ const wrap$8 = global => {
       };
       this.listener = listener;
       this.global.onmessage = wrappedListener;
+    },
+    dispose() {
+      // @ts-ignore
+      this.listener = null;
+      this.global.onmessage = null;
     }
   };
 };
@@ -377,6 +382,7 @@ const waitForFirstMessage = async port => {
 
 const listen$4 = async () => {
   const parentIpcRaw = listen$5();
+  signal$2(parentIpcRaw);
   const parentIpc = wrap$8(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
@@ -384,6 +390,7 @@ const listen$4 = async () => {
   }
   const type = firstMessage.params[0];
   if (type === 'message-port') {
+    parentIpc.dispose();
     const port = firstMessage.params[1];
     return port;
   }
@@ -439,7 +446,7 @@ const listen$3 = async () => {
 
 // @ts-ignore
 const signal$1 = process => {
-  process.send('ready');
+  process.send(readyMessage);
 };
 
 // @ts-ignore
@@ -540,7 +547,7 @@ const listen$1 = async () => {
   return parentPort;
 };
 const signal = parentPort => {
-  parentPort.postMessage('ready');
+  parentPort.postMessage(readyMessage);
 };
 const wrap$4 = parentPort => {
   return {
@@ -1079,7 +1086,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.6.0",
+  "version": "3.7.1",
   "description": "Inter Process Communication for Lvce Editor",
   "main": "dist/index.js",
   "type": "module",