@lvce-editor/completion-worker 4.0.0 → 4.1.0

package/dist/completionWorkerMain.js

@@ -531,7 +531,7 @@ const register = commandMap => {
 const getCommand$1 = key => {
   return commands[key];
 };
-const execute$1 = (command, ...args) => {
+const execute = (command, ...args) => {
   const fn = getCommand$1(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -753,7 +753,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -762,7 +762,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -856,7 +856,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -864,7 +864,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -875,12 +875,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -897,7 +897,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -933,7 +933,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -951,7 +951,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$1;
+  const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 
@@ -973,7 +973,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -991,7 +991,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1001,13 +1001,55 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     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$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$3 = async ({
   commandMap
 }) => {
@@ -1108,23 +1150,15 @@ const DownArrow = 16;
 const CtrlCmd = 1 << 11 >>> 0;
 
 const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
+const ExtensionManagementWorker = 9006;
 
 const {
   invoke: invoke$1,
   invokeAndTransfer,
   set: set$2
 } = create$2(EditorWorker$1);
-const sendMessagePortToExtensionHostWorker$1 = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
-};
-// TODO add tests for this
-const activateByEvent = async event => {
-  // @ts-ignore
-  await invoke$1('ActivateByEvent.activateByEvent', event);
+const sendMessagePortToExtensionManagementWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker', port, 0);
 };
 const applyEdit$1 = async (editorUid, changes) => {
   // @ts-ignore
@@ -1156,28 +1190,37 @@ const getWordAtOffset2 = async editorUid => {
 const getWordBefore$1 = async (editorUid, rowIndex, columnIndex) => {
   return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
+const getUri = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getUri', editorUid);
+};
+const getLanguageId = async editorUid => {
+  // @ts-ignore
+  return invoke$1('Editor.getLanguageId', editorUid);
+};
 
 const EditorWorker = {
   __proto__: null,
-  activateByEvent,
   applyEdit: applyEdit$1,
   closeWidget,
+  getLanguageId,
   getLines: getLines$1,
   getOffsetAtCursor: getOffsetAtCursor$1,
   getPositionAtCursor: getPositionAtCursor$1,
   getSelections: getSelections$1,
+  getUri,
   getWordAtOffset2,
   getWordBefore: getWordBefore$1,
   invoke: invoke$1,
   invokeAndTransfer,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  sendMessagePortToExtensionManagementWorker,
   set: set$2
 };
 
 const {
   invoke,
   set: set$1
-} = create$2(ExtensionHostWorker);
+} = create$2(ExtensionManagementWorker);
 
 const toCommandId = key => {
   const dotIndex = key.indexOf('.');
@@ -1495,40 +1538,27 @@ const replaceRange = (lines, ranges, replacement, origin) => {
   return changes;
 };
 
-const OnCompletion = 'onCompletion';
-
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
-
-const execute = async ({
-  args,
-  editorLanguageId,
-  editorUid,
-  event,
-  method
-}) => {
-  const fullEvent = `${event}:${editorLanguageId}`;
-  await activateByEvent(fullEvent);
-  const result = await invoke(method, editorUid, ...args);
-  return result;
+const getText = async editorUid => {
+  const lines = await getLines$1(editorUid);
+  return lines.join('\n');
+};
+const getTextDocument = async (editorUid, languageId) => {
+  const [text, uri] = await Promise.all([getText(editorUid), getUri(editorUid)]);
+  return {
+    documentId: editorUid,
+    languageId,
+    text,
+    uri
+  };
 };
-
 const executeCompletionProvider = async (editorUid, editorLanguageId, offset) => {
-  return execute({
-    args: [offset],
-    editorLanguageId,
-    editorUid,
-    event: OnCompletion,
-    method: CompletionExecute
-  });
+  const textDocument = await getTextDocument(editorUid, editorLanguageId);
+  return invoke('Extensions.executeCompletionProvider', textDocument, offset);
 };
 const executeResolveCompletionItem = async (editorUid, offset, name, completionItem) => {
-  return execute({
-    args: [offset, name, completionItem],
-    editorUid,
-    event: OnCompletion,
-    method: CompletionResolveExecute
-  });
+  const editorLanguageId = await getLanguageId(editorUid);
+  const textDocument = await getTextDocument(editorUid, editorLanguageId);
+  return invoke('Extensions.executeResolveCompletionItemProvider', textDocument, offset, name, completionItem);
 };
 
 const getOffsetAtCursor = async editorUid => {
@@ -2029,25 +2059,8 @@ const handleWheel = (state, deltaMode, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const {
-  sendMessagePortToExtensionHostWorker
-} = EditorWorker;
-
-const createExtensionHostRpc = async () => {
-  try {
-    const rpc = await create$4({
-      commandMap: {},
-      send: sendMessagePortToExtensionHostWorker
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
 const initialize = async () => {
-  const rpc = await createExtensionHostRpc();
-  set$1(rpc);
+  // Initialization happens during worker startup in Listen.listen.
 };
 
 const error = message => {
@@ -2560,8 +2573,19 @@ const initializeEditorWorker = async () => {
   set$2(rpc);
 };
 
+const send = async port => {
+  await sendMessagePortToExtensionManagementWorker(port);
+};
+const initializeExtensionManagementWorker = async () => {
+  const rpc = await create$4({
+    commandMap: commandMap,
+    send
+  });
+  set$1(rpc);
+};
+
 const listen = async () => {
-  await initializeEditorWorker();
+  await Promise.all([initializeEditorWorker(), initializeExtensionManagementWorker()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/completion-worker",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Web Worker for the completion widget in Lvce Editor",
   "repository": {
     "type": "git",