@lvce-editor/completion-worker 1.0.0 → 1.2.0

package/dist/completionWorkerMain.js

@@ -403,9 +403,103 @@ 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 {
+    resolve,
+    promise
+  } = 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({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  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 {
+    type,
+    event
+  } = 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
+};
 
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -413,7 +507,7 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$2 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -432,13 +526,13 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$2(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
   };
 };
-const create$2$1 = (method, params) => {
+const create$2$2 = (method, params) => {
   const {
     id,
     promise
@@ -730,7 +824,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
-  } = create$2$1(method, params);
+  } = create$2$2(method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -740,13 +834,13 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -776,10 +870,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -818,6 +912,35 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 const create$3 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$2$1 = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$3({
+    commandMap,
+    messagePort
+  });
+};
+const PlainMessagePortRpcParent = {
+  __proto__: null,
+  create: create$2$1
+};
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -829,7 +952,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 
 const create$2 = () => {
@@ -893,11 +1016,11 @@ const create$2 = () => {
 
 const {
   get: get$1,
-  set: set$1,
+  set: set$2,
   wrapCommand
 } = create$2();
 
-const create$1 = (uid, x, y, width, height, parentUid) => {
+const create$1 = (uid, x, y, width, height, editorUid, editorLanguageId) => {
   const state = {
     uid,
     items: [],
@@ -916,9 +1039,11 @@ const create$1 = (uid, x, y, width, height, parentUid) => {
     headerHeight: 0,
     leadingWord: '',
     unfilteredItems: [],
-    version: 0
+    version: 0,
+    editorUid,
+    editorLanguageId
   };
-  set$1(uid, state, state);
+  set$2(uid, state, state);
 };
 
 const modules = [];
@@ -950,14 +1075,17 @@ const getCommandIds = () => {
   return commandIds;
 };
 
-const initialize = async () => {
-  // TODO create connection to extension host worker
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
 };
 
-const OnCompletion = 'onCompletion';
-
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-
 const rpcs = Object.create(null);
 const set$9 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -989,56 +1117,98 @@ const create = rpcId => {
 };
 const EditorWorker$1 = 99;
 const ExtensionHostWorker = 44;
-const RendererWorker$1 = 1;
 const {
-  invoke: invoke$8} = create(EditorWorker$1);
+  invoke: invoke$8,
+  invokeAndTransfer: invokeAndTransfer$8,
+  set: set$8
+} = create(EditorWorker$1);
 const EditorWorker = {
   __proto__: null,
-  invoke: invoke$8};
+  invoke: invoke$8,
+  invokeAndTransfer: invokeAndTransfer$8,
+  set: set$8
+};
 const {
-  invoke: invoke$6} = create(ExtensionHostWorker);
+  invoke: invoke$6,
+  set: set$6
+} = create(ExtensionHostWorker);
 const ExtensionHost = {
   __proto__: null,
-  invoke: invoke$6};
+  invoke: invoke$6,
+  set: set$6
+};
+
 const {
-  invoke: invoke$4,
-  set: set$4
-} = create(RendererWorker$1);
-const RendererWorker = {
-  __proto__: null,
-  invoke: invoke$4,
-  set: set$4
+  invoke: invoke$1,
+  set: set$1,
+  invokeAndTransfer
+} = EditorWorker;
+
+const sendMessagePortToExtensionHostWorker = async port => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  // @ts-ignore
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0 // TODO
+  );
+};
+
+const createExtensionHostRpc = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await sendMessagePortToExtensionHostWorker(port2);
+    const rpc = await PlainMessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port1
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
 };
 
 const {
-  set,
-  invoke: invoke$2} = RendererWorker;
+  invoke,
+  set
+} = ExtensionHost;
+
+const initialize = async () => {
+  const rpc = await createExtensionHostRpc();
+  set(rpc);
+};
+
+const OnCompletion = 'onCompletion';
+
+const CompletionExecute = 'ExtensionHostCompletion.execute';
 
 // TODO add tests for this
 const activateByEvent = async event => {
-  await invoke$2('ExtensionHostManagement.activateByEvent', event);
+  // @ts-ignore
+  await invoke$1('ActivateByEvent.activateByEvent', event);
 };
 
-const {
-  invoke: invoke$1} = ExtensionHost;
-
 const execute = async ({
-  editor,
+  editorLanguageId,
+  editorUid,
   args,
   event,
   method,
   noProviderFoundMessage,
   noProviderFoundResult = undefined
 }) => {
-  const fullEvent = `${event}:${editor.languageId}`;
+  const fullEvent = `${event}:${editorLanguageId}`;
   await activateByEvent(fullEvent);
-  const result = await invoke$1(method, editor.uid, ...args);
+  const result = await invoke(method, editorUid, ...args);
   return result;
 };
 
-const executeCompletionProvider = async (editor, offset) => {
+const executeCompletionProvider = async (editorUid, editorLanguageId, offset) => {
   return execute({
-    editor,
+    editorUid,
+    editorLanguageId,
     event: OnCompletion,
     method: CompletionExecute,
     args: [offset],
@@ -1046,15 +1216,15 @@ const executeCompletionProvider = async (editor, offset) => {
     noProviderFoundResult: []});
 };
 
-const getOffsetAtCursor = editor => {
-  // TODO
+const getOffsetAtCursor = editorUid => {
+  // TODO ask editor worker
   return 0;
 };
 
 // TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
-const getCompletions = async editor => {
+const getCompletions = async (editorUid, editorLanguageId) => {
   const offset = getOffsetAtCursor();
-  const completions = await executeCompletionProvider(editor, offset);
+  const completions = await executeCompletionProvider(editorUid, editorLanguageId, offset);
   return completions;
 };
 
@@ -1271,49 +1441,33 @@ const getListHeight = (itemsLength, itemHeight, maxHeight) => {
   return Math.min(totalHeight, maxHeight);
 };
 
-const {
-  invoke} = EditorWorker;
-
 const getPositionAtCursor = async parentUid => {
-  const position = await invoke('Editor.getPositionAtCursor', parentUid);
+  const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
   return position;
 };
 
-const RE_WORD = /[\w\-]+$/;
-const getWordAtOffset = editor => {
-  const {
-    lines,
-    selections
-  } = editor;
-  const rowIndex = selections[0];
-  const columnIndex = selections[1];
-  const line = lines[rowIndex];
-  const part = line.slice(0, columnIndex);
-  const wordMatch = part.match(RE_WORD);
-  if (wordMatch) {
-    return wordMatch[0];
-  }
+const getWordAtOffset = async editorUid => {
+  // TODO ask editor worker
   return '';
 };
 
 const loadContent = async state => {
-  const editor = {}; // TODO
   const {
     itemHeight,
-    maxHeight
+    maxHeight,
+    editorUid,
+    editorLanguageId
   } = state;
-  const unfilteredItems = await getCompletions(editor);
-  const wordAtOffset = getWordAtOffset(editor);
+  const unfilteredItems = await getCompletions(editorUid, editorLanguageId);
+  const wordAtOffset = await getWordAtOffset();
   const items = filterCompletionItems(unfilteredItems, wordAtOffset);
   const {
     rowIndex,
     columnIndex,
     x,
     y
-  } = await getPositionAtCursor(editor);
+  } = await getPositionAtCursor(editorUid);
   const newMaxLineY = Math.min(items.length, 8);
-  editor.widgets = editor.widgets || [];
-  // editor.widgets.push(ViewletModuleId.EditorCompletion)
   const itemsLength = items.length;
   const newFocusedIndex = itemsLength === 0 ? -1 : 0;
   const total = items.length;
@@ -1333,7 +1487,6 @@ const loadContent = async state => {
     // @ts-ignore
     rowIndex,
     columnIndex,
-    // editorUid,
     width: 200
   };
 };
@@ -1373,7 +1526,7 @@ const render2 = (uid, diffResult) => {
     oldState,
     newState
   } = get$1(uid);
-  set$1(uid, newState, newState);
+  set$2(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -1389,14 +1542,14 @@ const commandMap = {
   'Completions.loadContent': wrapCommand(loadContent),
   'Completions.render2': render2,
   'Completions.terminate': terminate,
-  'Completions.intialize': initialize
+  'Completions.initialize': initialize
 };
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

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