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

package/dist/fileSearchWorkerMain.js

@@ -63,7 +63,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String = 4;
+const String$1 = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
@@ -75,7 +75,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String;
+      return String$1;
     case 'object':
       if (value === null) {
         return Null;
@@ -110,7 +110,7 @@ const array = value => {
 };
 const string = value => {
   const type = getType(value);
-  if (type !== String) {
+  if (type !== String$1) {
     throw new AssertionError('expected value to be of type string');
   }
 };
@@ -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);
@@ -468,9 +468,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+const create$5 = async ({
+  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');
@@ -519,60 +519,18 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
+const Two$1 = '2.0';
+const callbacks$1 = Object.create(null);
 const get$2 = id => {
-  return callbacks[id];
+  return callbacks$1[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
-  };
+  delete callbacks$1[id];
 };
 class JsonRpcError extends Error {
   constructor(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$q = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$p = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$o = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$o();
+  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$p(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$q(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$8 = 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$8
+};
+const create$6 = 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$8({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3$1
+  create: create$6
 };
-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
@@ -1287,6 +1288,7 @@ const handleWheel = (state, deltaMode, deltaY) => {
 
 const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, workspaceUri, assetDir) => {
   const state = {
+    allowEmptyResult: false,
     cursorOffset: 0,
     height: 300,
     icons: [],
@@ -1312,6 +1314,7 @@ const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, w
     fileIconCache: Object.create(null),
     focused: false,
     inputSource: User,
+    placeholder: '',
     platform,
     value: ''
   };
@@ -2935,6 +2938,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({
@@ -2987,6 +3000,27 @@ const getQuickPickProviderId = prefix => {
   }
 };
 
+const parseArgs = (subId, args) => {
+  if (subId !== Custom$1) {
+    return {
+      ignoreFocusOut: false,
+      initialValue: ''
+    };
+  }
+  const last = args.at(-1);
+  if (!last || typeof last !== 'object') {
+    return {
+      ignoreFocusOut: false,
+      initialValue: ''
+    };
+  }
+  return {
+    // @ts-ignore
+    ignoreFocusOut: Boolean(last.ignoreFocusOut),
+    // @ts-ignore
+    initialValue: String(last.initialValue)
+  };
+};
 const loadContent = async state => {
   const {
     args,
@@ -3017,6 +3051,8 @@ const loadContent = async state => {
   } = await getQuickPickFileIcons(sliced, fileIconCache);
   const listHeight = getListHeight(items.length, itemHeight, height);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
+  const parsedArgs = parseArgs(subId, args);
+  const finalValue = parsedArgs.initialValue || value;
   return {
     ...state,
     args,
@@ -3031,12 +3067,20 @@ const loadContent = async state => {
     maxLineY,
     minLineY,
     picks: newPicks,
+    placeholder: '',
     providerId: id,
     state: Finished,
-    value
+    value: finalValue
   };
 };
 
+const callbacks = Object.create(null);
+const executeCallback = id => {
+  const fn = callbacks[id];
+  delete callbacks[id];
+  fn();
+};
+
 const getVisible$1 = (items, minLineY, maxLineY, icons) => {
   const range = items.slice(minLineY, maxLineY);
   const protoVisibleItems = range.map((item, index) => {
@@ -3169,6 +3213,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(' ');
 };
@@ -3490,7 +3540,10 @@ const renderEventListeners = () => {
 };
 
 const selectCurrentIndex = state => {
-  return selectIndex(state, state.focusedIndex);
+  const {
+    focusedIndex
+  } = state;
+  return selectIndex(state, focusedIndex);
 };
 
 const findLabelIndex = (items, label) => {
@@ -3511,12 +3564,32 @@ const selectItem = async (state, label) => {
   return selectIndex(state, index);
 };
 
+const showQuickInput = async ({
+  ignoreFocusOut,
+  initialValue,
+  waitUntil
+}) => {
+  // TODO ask renderer worker to create quickpick instance, with given options
+  const picks = [];
+  // const id=QuickPickCallbacks.registerCallback()
+  await invoke$1('QuickPick.showCustom', picks, {
+    ignoreFocusOut,
+    initialValue,
+    waitUntil
+  });
+  return {
+    canceled: false,
+    inputValue: ''
+  };
+};
+
 const commandMap = {
   'QuickPick.addMenuEntries': add,
   'QuickPick.close': close,
   'QuickPick.create2': create,
   'QuickPick.diff2': diff2,
   'QuickPick.dispose': dispose,
+  'QuickPick.executeCallback': executeCallback,
   'QuickPick.focusFirst': wrapCommand(focusFirst),
   'QuickPick.focusIndex': wrapCommand(focusIndex),
   'QuickPick.focusLast': wrapCommand(focusLast),
@@ -3529,6 +3602,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 +3612,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';
@@ -3563,7 +3638,7 @@ const searchFile$1 = async uri => {
 };
 
 const getFileSearchRipGrepArgs = () => {
-  const ripGrepArgs = ['--files', '--sort-files'];
+  const ripGrepArgs = ['--files', '--sort-files', '--hidden'];
   return ripGrepArgs;
 };
 
@@ -3594,6 +3669,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": "7.0.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"
+  }
 }