@lvce-editor/file-search-worker 1.5.0 → 1.7.0

package/dist/fileSearchWorkerMain.js

@@ -18,6 +18,113 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Directory$1 = 3;
+const File$1 = 7;
+
+const Slash$1 = '/';
+
+const Slash = Slash$1;
+
+const state$4 = {
+  files: Object.create(null)
+};
+const getDirent = uri => {
+  return state$4.files[uri];
+};
+const readFile = uri => {
+  const dirent = getDirent(uri);
+  if (!dirent) {
+    throw new Error(`File not found: ${uri}`);
+  }
+  if (dirent.type !== File$1) {
+    throw new Error('file is a directory');
+  }
+  return dirent.content;
+};
+const ensureParentDir = uri => {
+  const startIndex = 0;
+  let endIndex = uri.indexOf(Slash);
+  while (endIndex >= 0) {
+    const part = uri.slice(startIndex, endIndex + 1);
+    state$4.files[part] = {
+      type: Directory$1,
+      content: ''
+    };
+    endIndex = uri.indexOf(Slash, endIndex + 1);
+  }
+};
+const writeFile = (uri, content) => {
+  const dirent = getDirent(uri);
+  if (dirent) {
+    dirent.content = content;
+  } else {
+    ensureParentDir(uri);
+    state$4.files[uri] = {
+      type: File$1,
+      content
+    };
+  }
+};
+const mkdir = uri => {
+  if (!uri.endsWith(Slash)) {
+    uri += Slash;
+  }
+  ensureParentDir(uri);
+  state$4.files[uri] = {
+    type: Directory$1,
+    content: ''
+  };
+};
+const readDirWithFileTypes = uri => {
+  if (!uri.endsWith(Slash)) {
+    uri += Slash;
+  }
+  const dirents = [];
+  for (const [key, value] of Object.entries(state$4.files)) {
+    if (key.startsWith(uri)) {
+      // @ts-ignore
+      switch (value.type) {
+        case Directory$1:
+          if (!key.slice(0, -1).includes(Slash, uri.length) && key !== `${uri}/` && key !== uri) {
+            dirents.push({
+              // @ts-ignore
+              type: value.type,
+              name: key.slice(uri.length, -1)
+            });
+          }
+          break;
+        case File$1:
+          if (!key.includes(Slash, uri.length + 1)) {
+            dirents.push({
+              // @ts-ignore
+              type: value.type,
+              name: key.slice(uri.length)
+            });
+          }
+          break;
+      }
+    }
+  }
+  return dirents;
+};
+const getBlobUrl = uri => {
+  const content = readFile(uri);
+  const blob = new Blob([content]);
+  const url = URL.createObjectURL(blob);
+  return url;
+};
+const getBlob = uri => {
+  const content = readFile(uri);
+  const blob = new Blob([content]);
+  return blob;
+};
+const chmod = () => {
+  throw new Error('[memfs] chmod not implemented');
+};
+const getFiles = () => {
+  return state$4.files;
+};
+
 const searchFile$3 = async (workspace, root) => {
   return [];
 };
@@ -499,6 +606,193 @@ const searchFile$1 = async uri => {
   return all;
 };
 
+const Diagonal = 1;
+const Left = 2;
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const createTable = size => {
+  const table = [];
+  for (let i = 0; i < size; i++) {
+    const row = new Uint8Array(size);
+    table.push(row);
+  }
+  return table;
+};
+const EmptyMatches = [];
+const Dash = '-';
+const Dot = '.';
+const EmptyString = '';
+const Space = ' ';
+const Underline = '_';
+const T = 't';
+const isLowerCase = char => {
+  return char === char.toLowerCase();
+};
+const isUpperCase = char => {
+  return char === char.toUpperCase();
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const isGap = (columnCharBefore, columnChar) => {
+  switch (columnCharBefore) {
+    case Dash:
+    case Underline:
+    case EmptyString:
+    case T:
+    case Space:
+    case Dot:
+      return true;
+  }
+  if (isLowerCase(columnCharBefore) && isUpperCase(columnChar)) {
+    return true;
+  }
+  return false;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const getScore = (rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, isDiagonalMatch) => {
+  if (rowCharLow !== columnCharLow) {
+    return -1;
+  }
+  const isMatch = rowChar === columnChar;
+  if (isMatch) {
+    if (isDiagonalMatch) {
+      return 8;
+    }
+    if (isGap(columnCharBefore, columnChar)) {
+      return 8;
+    }
+    return 5;
+  }
+  if (isGap(columnCharBefore, columnChar)) {
+    return 8;
+  }
+  return 5;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+
+const isPatternInWord = (patternLow, patternPos, patternLen, wordLow, wordPos, wordLen) => {
+  while (patternPos < patternLen && wordPos < wordLen) {
+    if (patternLow[patternPos] === wordLow[wordPos]) {
+      patternPos += 1;
+    }
+    wordPos += 1;
+  }
+  return patternPos === patternLen; // pattern must be exhausted
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const traceHighlights = (table, arrows, patternLength, wordLength) => {
+  let row = patternLength;
+  let column = wordLength;
+  const matches = [];
+  while (row >= 1 && column >= 1) {
+    const arrow = arrows[row][column];
+    if (arrow === Left) {
+      column--;
+    } else if (arrow === Diagonal) {
+      row--;
+      column--;
+      const start = column + 1;
+      while (row >= 1 && column >= 1) {
+        const arrow = arrows[row][column];
+        if (arrow === Left) {
+          break;
+        }
+        if (arrow === Diagonal) {
+          row--;
+          column--;
+        }
+      }
+      const end = column;
+      matches.unshift(end, start);
+    }
+  }
+  matches.unshift(table[patternLength][wordLength - 1]);
+  return matches;
+};
+
+// based on https://github.com/microsoft/vscode/blob/3059063b805ed0ac10a6d9539e213386bfcfb852/src/vs/base/common/filters.ts by Microsoft (License MIT)
+const gridSize = 128;
+const table = createTable(gridSize);
+const arrows = createTable(gridSize);
+const fuzzySearch = (pattern, word) => {
+  const patternLength = Math.min(pattern.length, gridSize - 1);
+  const wordLength = Math.min(word.length, gridSize - 1);
+  const patternLower = pattern.toLowerCase();
+  const wordLower = word.toLowerCase();
+  if (!isPatternInWord(patternLower, 0, patternLength, wordLower, 0, wordLength)) {
+    return EmptyMatches;
+  }
+  let strongMatch = false;
+  for (let row = 1; row < patternLength + 1; row++) {
+    const rowChar = pattern[row - 1];
+    const rowCharLow = patternLower[row - 1];
+    for (let column = 1; column < wordLength + 1; column++) {
+      const columnChar = word[column - 1];
+      const columnCharLow = wordLower[column - 1];
+      const columnCharBefore = word[column - 2] || '';
+      const isDiagonalMatch = arrows[row - 1][column - 1] === Diagonal;
+      const score = getScore(rowCharLow, rowChar, columnCharBefore, columnCharLow, columnChar, isDiagonalMatch);
+      if (row === 1 && score > 5) {
+        strongMatch = true;
+      }
+      let diagonalScore = score + table[row - 1][column - 1];
+      if (isDiagonalMatch && score !== -1) {
+        diagonalScore += 2;
+      }
+      const leftScore = table[row][column - 1];
+      if (leftScore > diagonalScore) {
+        table[row][column] = leftScore;
+        arrows[row][column] = Left;
+      } else {
+        table[row][column] = diagonalScore;
+        arrows[row][column] = Diagonal;
+      }
+    }
+  }
+  if (!strongMatch) {
+    return EmptyMatches;
+  }
+  const highlights = traceHighlights(table, arrows, patternLength, wordLength);
+  return highlights;
+};
+
+const filterQuickPickItem = (pattern, word) => {
+  const matches = fuzzySearch(pattern, word);
+  return matches;
+};
+
+const getBaseName = path => {
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+const emptyMatches = [];
+const convertToPick = item => {
+  return {
+    pick: item,
+    matches: emptyMatches
+  };
+};
+const filterQuickPickItems = (items, value) => {
+  if (!value) {
+    return items.map(convertToPick);
+  }
+  const results = [];
+  for (const item of items) {
+    const baseName = getBaseName(item);
+    const matches = filterQuickPickItem(value, baseName);
+    if (matches.length > 0) {
+      results.push({
+        pick: item,
+        matches
+      });
+    }
+  }
+  return results;
+};
+
 const getFileSearchRipGrepArgs = () => {
   const ripGrepArgs = ['--files', '--sort-files'];
   return ripGrepArgs;
@@ -903,7 +1197,7 @@ const splitLines$1 = lines => {
 
 // TODO create direct connection from electron to file search worker using message ports
 
-const searchFile = async (path, value) => {
+const searchFile = async (path, value, prepare) => {
   const ripGrepArgs = getFileSearchRipGrepArgs();
   const options = {
     ripGrepArgs,
@@ -912,14 +1206,26 @@ const searchFile = async (path, value) => {
   };
   const stdout = await invoke('SearchFile.searchFile', options);
   const lines = splitLines$1(stdout);
-  return lines;
+  if (!prepare) {
+    return lines;
+  }
+  const filtered = filterQuickPickItems(lines, value);
+  return filtered;
 };
 
 const commandMap = {
   'SearchFile.searchFile': searchFile$3,
   'SearchFile.searchFileWithRipGrep': searchFile,
   'SearchFile.searchFileWithHtml': searchFile$1,
-  'SearchFile.searchFileWithFetch': searchFile$2
+  'SearchFile.searchFileWithFetch': searchFile$2,
+  'FileSystemMemory.readFile': readFile,
+  'FileSystemMemory.writeFile': writeFile,
+  'FileSystemMemory.mkdir': mkdir,
+  'FileSystemMemory.readDirWithFileTypes': readDirWithFileTypes,
+  'FileSystemMemory.getBlobUrl': getBlobUrl,
+  'FileSystemMemory.getBlob': getBlob,
+  'FileSystemMemory.chmod': chmod,
+  'FileSystemMemory.getFiles': getFiles
 };
 
 const requiresSocket = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-search-worker",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "",
   "main": "dist/fileSearchWorkerMain.js",
   "type": "module",
@@ -8,6 +8,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@lvce-editor/fuzzy-search": "^1.0.0",
     "idb": "^8.0.0"
   }
 }