@lvce-editor/file-search-worker 6.17.0 → 6.18.0

package/dist/fileSearchWorkerMain.js

@@ -243,8 +243,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -267,14 +267,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -293,8 +293,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -304,8 +304,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -366,8 +366,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -387,8 +387,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -445,8 +445,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -458,8 +458,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -469,8 +469,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
 };
 const Message$1 = 3;
 const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -483,8 +483,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -524,56 +524,14 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$2 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$2 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$2();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -769,7 +727,7 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -780,20 +738,20 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$4 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$4(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom$2,
@@ -880,29 +838,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -925,24 +860,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$p = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$o = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$n = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$n();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$o(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$p(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -959,7 +957,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -977,15 +975,16 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+const create$7 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register$1(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -993,8 +992,13 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3$1 = async ({
+const PlainMessagePortRpc = {
+  __proto__: null,
+  create: create$7
+};
+const create$5 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -1002,16 +1006,17 @@ const create$3$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$7({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3$1
+  create: create$5
 };
-const create$4 = async ({
+const create$2$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1023,15 +1028,9 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$2$1
 };
 
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-
 const EditorWorker = 99;
 const RendererWorker = 1;
 
@@ -1047,6 +1046,10 @@ const get$1 = id => {
 
 const create$3 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1061,17 +1064,14 @@ const create$3 = rpcId => {
     },
     set(rpc) {
       set$3(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
     }
   };
 };
 
 const {
   invoke: invoke$2,
-  set: set$2} = create$3(EditorWorker);
+  set: set$2
+} = create$3(EditorWorker);
 const getLines = async editorUid => {
   const lines = await invoke$2('Editor.getLines2', editorUid);
   return lines;
@@ -1080,7 +1080,8 @@ const getLines = async editorUid => {
 const {
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$1} = create$3(RendererWorker);
+  set: set$1
+} = create$3(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
@@ -2935,6 +2936,16 @@ const handleFocus = async state => {
   return state;
 };
 
+const commandMapRef = {};
+
+const handleMessagePort = async port => {
+  await PlainMessagePortRpc.create({
+    commandMap: commandMapRef,
+    isMessagePortOpen: true,
+    messagePort: port
+  });
+};
+
 const initialize = async () => {
   // TODO
   const rpc = await TransferMessagePortRpcParent.create({
@@ -3169,6 +3180,12 @@ const renderHeight = newState => {
   return ['Viewlet.send', newState.uid, /* method */SetItemsHeight, /* height */newState.height];
 };
 
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
@@ -3511,6 +3528,17 @@ const selectItem = async (state, label) => {
   return selectIndex(state, index);
 };
 
+const showQuickInput = async ({
+  ignoreFocusOut,
+  initialValue
+}) => {
+  // TODO ask renderer worker to create quickpick instance, with given options
+  return {
+    canceled: false,
+    inputValue: ''
+  };
+};
+
 const commandMap = {
   'QuickPick.addMenuEntries': add,
   'QuickPick.close': close,
@@ -3529,6 +3557,7 @@ const commandMap = {
   'QuickPick.handleClickAt': wrapCommand(handleClickAt),
   'QuickPick.handleFocus': wrapCommand(handleFocus),
   'QuickPick.handleInput': wrapCommand(handleInput),
+  'QuickPick.handleMessagePort': handleMessagePort,
   'QuickPick.handleWheel': wrapCommand(handleWheel),
   'QuickPick.initialize': initialize,
   'QuickPick.loadContent': wrapCommand(loadContent),
@@ -3538,7 +3567,8 @@ const commandMap = {
   'QuickPick.selectIndex': wrapCommand(selectIndex),
   'QuickPick.selectItem': wrapCommand(selectItem),
   'QuickPick.setDeltaY': wrapCommand(setDeltaY),
-  'QuickPick.setValue': wrapCommand(setValue)
+  'QuickPick.setValue': wrapCommand(setValue),
+  'QuickPick.showQuickInput': showQuickInput
 };
 
 const Memfs = 'memfs';
@@ -3594,6 +3624,7 @@ const searchModules = {
 };
 
 const listen = async () => {
+  Object.assign(commandMapRef, commandMap);
   registerCommands(commandMap);
   register(searchModules);
   const rpc = await WebWorkerRpcClient.create({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-search-worker",
-  "version": "6.17.0",
+  "version": "6.18.0",
   "keywords": [
     "text-search"
   ],
@@ -11,5 +11,8 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/fileSearchWorkerMain.js"
+  "main": "dist/fileSearchWorkerMain.js",
+  "dependencies": {
+    "@lvce-editor/constants": "^2.8.0"
+  }
 }