@lvce-editor/chat-message-parsing-worker 1.4.0 → 1.6.0

package/dist/chatMessageParsingWorkerMain.js

@@ -267,45 +267,6 @@ const readyMessage = 'ready';
 const getData$2 = event => {
   return event.data;
 };
-const listen$8 = ({
-  port
-}) => {
-  return port;
-};
-const signal$9 = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(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);
-    this._rawIpc.start();
-  }
-}
-const wrap$g = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$8,
-  signal: signal$9,
-  wrap: wrap$g
-};
 const listen$7 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
@@ -407,6 +368,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  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,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -865,15 +920,19 @@ const listen$1 = async (module, options) => {
 
 const create$1 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$1(IpcChildWithMessagePort$1, {
-    port: messagePort
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
   });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
+  messagePort.start();
   return rpc;
 };
 
@@ -891,6 +950,7 @@ const create = async ({
 const handleMessagePort = async port => {
   await create$1({
     commandMap: commandMap,
+    isMessagePortOpen: true,
     messagePort: port
   });
 };
@@ -1852,9 +1912,12 @@ const parseMessageContents = rawMessages => {
 };
 
 const commandMap = {
+  'ChatMessageParsing.parseMessageContent': parseMessageContent,
+  'ChatMessageParsing.parseMessageContents': parseMessageContents,
   'ChatParser.parseMessageContent': parseMessageContent,
   'ChatParser.parseMessageContents': parseMessageContents,
-  'HandleMessagePort.handleMessagePort': handleMessagePort
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
+  initialize: (_, port) => handleMessagePort(port)
 };
 
 const listen = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-message-parsing-worker",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Chat Message Parsing Worker",
   "repository": {
     "type": "git",