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

package/dist/chatMessageParsingWorkerMain.js

@@ -486,10 +486,10 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get = id => {
+const get$1 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -635,14 +635,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$1(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -698,7 +698,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$8 = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -707,7 +707,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -801,7 +801,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$4 = (method, params) => {
+const create$7 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -809,7 +809,7 @@ const create$4 = (method, params) => {
   };
 };
 
-const create$3 = (id, method, params) => {
+const create$6 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -820,12 +820,12 @@ const create$3 = (id, method, params) => {
 };
 
 let id = 0;
-const create$2 = () => {
+const create$5 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$2();
+  const id = create$5();
   const {
     promise,
     resolve
@@ -842,7 +842,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$3(id, method, params);
+  const message = create$6(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -878,7 +878,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$4(method, params);
+      const message = create$7(method, params);
       ipc.send(message);
     }
   };
@@ -918,7 +918,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$1 = async ({
+const create$4 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -936,7 +936,66 @@ const create$1 = async ({
   return rpc;
 };
 
-const create = async ({
+const create$3 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$4({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$2 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -948,13 +1007,17 @@ const create = async ({
 };
 
 const handleMessagePort = async port => {
-  await create$1({
+  await create$4({
     commandMap: commandMap,
     isMessagePortOpen: true,
     messagePort: port
   });
 };
 
+const initialize = async (_, port) => {
+  await handleMessagePort(port);
+};
+
 const windowsAbsolutePathRegex = /^[a-zA-Z]:[\\/]/;
 const pathSeparatorRegex$1 = /[\\/]/;
 const isPathTraversalAttempt = path => {
@@ -1917,13 +1980,106 @@ const commandMap = {
   'ChatParser.parseMessageContent': parseMessageContent,
   'ChatParser.parseMessageContents': parseMessageContents,
   'HandleMessagePort.handleMessagePort': handleMessagePort,
-  initialize: (_, port) => handleMessagePort(port)
+  initialize: initialize
+};
+
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
+const rpcs = Object.create(null);
+const set$1 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$1(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$1(rpcId, rpc);
+    }
+  };
+};
+
+const {
+  set
+} = create(6007);
+
+const RendererWorker = 1;
+
+const {
+  invokeAndTransfer} = create(RendererWorker);
+const sendMessagePortToChatMathWorker$1 = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToChatMathWorker', port, command, rpcId);
+};
+
+const sendMessagePortToChatMathWorker = async port => {
+  await sendMessagePortToChatMathWorker$1(port, 0);
+};
+const initializeChatMathWorker = async () => {
+  const rpc = await create$2({
+    commandMap: {},
+    send: sendMessagePortToChatMathWorker
+  });
+  set(rpc);
 };
 
 const listen = async () => {
-  await create({
+  await create$1({
     commandMap: commandMap
   });
+  await initializeChatMathWorker();
 };
 
 const main = async () => {

package/package.json

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