@lvce-editor/file-search-worker 1.0.0 → 1.2.0

package/dist/fileSearchWorkerMain.js

@@ -18,12 +18,26 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
-const searchFile = async (workspace, root) => {
+const searchFile$1 = async (workspace, root) => {
   return [];
 };
 
-const commandMap = {
-  'SearchFile.searchFile': searchFile
+const getFileSearchRipGrepArgs = () => {
+  const ripGrepArgs = ['--files', '--sort-files'];
+  return ripGrepArgs;
+};
+
+const state$2 = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined
+};
+const get$1 = () => {
+  return state$2.ipc;
+};
+const set$1 = ipc => {
+  state$2.ipc = ipc;
 };
 
 const Two = '2.0';
@@ -64,15 +78,49 @@ const number = value => {
 const state$1 = {
   callbacks: Object.create(null)
 };
+const set = (id, fn) => {
+  state$1.callbacks[id] = fn;
+};
 const get = id => {
   return state$1.callbacks[id];
 };
 const remove = id => {
   delete state$1.callbacks[id];
 };
+const state = {
+  id: 0
+};
+const create$3 = () => {
+  return ++state.id;
+};
 const warn = (...args) => {
   console.warn(...args);
 };
+const withResolvers$1 = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const registerPromise = () => {
+  const id = create$3();
+  const {
+    resolve,
+    promise
+  } = withResolvers$1();
+  set(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
 const resolve = (id, args) => {
   number(id);
   const fn = get(id);
@@ -84,14 +132,153 @@ const resolve = (id, args) => {
   fn(args);
   remove(id);
 };
+const create$2 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'JsonRpcError';
   }
 }
+const NewLine$2 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$2 + parentStack;
+  }
+  return parentStack;
+};
+const joinLines$1 = lines => {
+  return lines.join(NewLine$2);
+};
 const MethodNotFound = -32601;
 const Custom = -32001;
+const splitLines$2 = lines => {
+  return lines.split(NewLine$2);
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$2 + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex$1(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getType = prettyError => {
   if (prettyError && prettyError.type) {
@@ -210,6 +397,51 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
+const invoke$2 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+
+const invoke$1 = (method, ...params) => {
+  const ipc = get$1();
+  return invoke$2(ipc, method, ...params);
+};
+const listen$2 = ipc => {
+  set$1(ipc);
+};
+
+const invoke = (method, ...params) => {
+  return invoke$1('SearchProcess.invoke', method, ...params);
+};
+
+const splitLines$1 = lines => {
+  return lines.split('\n');
+};
+
+// TODO create direct connection from electron to file search worker using message ports
+
+const searchFile = async (path, value) => {
+  const ripGrepArgs = getFileSearchRipGrepArgs();
+  const options = {
+    ripGrepArgs,
+    searchPath: path,
+    limit: 9999999
+  };
+  const stdout = await invoke('SearchFile.searchFile', options);
+  const lines = splitLines$1(stdout);
+  return lines;
+};
+
+const commandMap = {
+  'SearchFile.searchFile': searchFile$1,
+  'SearchFile.searchFileWithRipGrep': searchFile
+};
 
 const requiresSocket = () => {
   return false;
@@ -662,6 +894,7 @@ const listen = async () => {
     method: Auto()
   });
   handleIpc(ipc);
+  listen$2(ipc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-search-worker",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/fileSearchWorkerMain.js",
   "type": "module",