@lvce-editor/file-search-worker 2.3.0 → 3.1.0

package/dist/fileSearchWorkerMain.js

@@ -1126,6 +1126,394 @@ const getFiles = () => {
   return state$2.files;
 };
 
+const emptyMatches = [];
+
+const convertToPick = item => {
+  return {
+    pick: item,
+    matches: emptyMatches
+  };
+};
+
+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 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 Enter = 3;
+const Escape = 8;
+const PageUp = 10;
+const PageDown = 11;
+const UpArrow = 14;
+const DownArrow = 16;
+
+const FocusQuickPickInput = 20;
+
+const getKeyBindings = () => {
+  return [{
+    key: Escape,
+    command: 'Viewlet.closeWidget',
+    args: ['QuickPick'],
+    when: FocusQuickPickInput
+  }, {
+    key: UpArrow,
+    command: 'QuickPick.focusPrevious',
+    when: FocusQuickPickInput
+  }, {
+    key: DownArrow,
+    command: 'QuickPick.focusNext',
+    when: FocusQuickPickInput
+  }, {
+    key: PageUp,
+    command: 'QuickPick.focusFirst',
+    when: FocusQuickPickInput
+  }, {
+    key: PageDown,
+    command: 'QuickPick.focusLast',
+    when: FocusQuickPickInput
+  }, {
+    key: Enter,
+    command: 'QuickPick.selectCurrentIndex',
+    when: FocusQuickPickInput
+  }];
+};
+
+// TODO support file icons
+const getFolderIcon = () => {
+  return '';
+};
+
+const Hide = 'hide';
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  Files: 'Files',
+  GoToFile: 'Go to file',
+  NoMatchingColorThemesFound: 'No matching color themes found',
+  NoMatchingResults: 'No matching results',
+  NoRecentlyOpenedFoldersFound: 'No recently opened folders found',
+  NoResults: 'No Results',
+  NoSymbolFound: 'No symbol found',
+  NoWorkspaceSymbolsFound: 'no workspace symbols found',
+  OpenRecent: 'Open Recent',
+  SelectColorTheme: 'Select Color Theme',
+  SelectToOpen: 'Select to open',
+  ShowAndRunCommands: 'Show And Run Commands',
+  TypeNameOfCommandToRun: 'Type the name of a command to run.',
+  TypeTheNameOfAViewToOpen: 'Type the name of a view, output channel or terminal to open.'
+};
+const selectToOpen = () => {
+  return i18nString(UiStrings.SelectToOpen);
+};
+const openRecent = () => {
+  return i18nString(UiStrings.OpenRecent);
+};
+const noRecentlyOpenedFoldersFound = () => {
+  return i18nString(UiStrings.NoRecentlyOpenedFoldersFound);
+};
+
+const state$1 = {
+  rpc: undefined
+};
+const invoke$1 = (method, ...params) => {
+  const rpc = state$1.rpc;
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
+};
+const setRpc = rpc => {
+  state$1.rpc = rpc;
+};
+
+// TODO this should be in FileSystem module
+const pathBaseName = path => {
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+
+// TODO this should be in FileSystem module
+const pathDirName = path => {
+  const pathSeparator = '/';
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return '';
+  }
+  return path.slice(0, index);
+};
+
+const getRecentlyOpened = () => {
+  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const openWorkspaceFolder = uri => {
+  return invoke$1(/* Workspace.setPath */'Workspace.setPath', /* path */uri);
+};
+const getPlaceholder = () => {
+  return selectToOpen();
+};
+const getLabel = () => {
+  return openRecent();
+};
+const getHelpEntries = () => {
+  return [];
+};
+const getNoResults = () => {
+  return {
+    label: noRecentlyOpenedFoldersFound()
+  };
+};
+
+// TODO could also change api so that getPicks returns an array of anything
+// and the transformPick gets the label for each pick
+// This would make the code more module since the code for getting the picks
+// would be more independent of the specific data format of the quickpick provider
+
+const getPicks = async () => {
+  const recentlyOpened = await getRecentlyOpened();
+  return recentlyOpened;
+};
+
+// TODO selectPick should be independent of show/hide
+const selectPick = async pick => {
+  const path = pick;
+  await openWorkspaceFolder(path);
+  return {
+    command: Hide
+  };
+};
+const getFilterValue = value => {
+  return pathBaseName(value);
+};
+const getPickFilterValue = pick => {
+  return pathBaseName(pick);
+};
+const getPickLabel = pick => {
+  return pathBaseName(pick);
+};
+const getPickDescription = pick => {
+  return pathDirName(pick);
+};
+const getPickIcon = () => {
+  return '';
+};
+const getPickFileIcon = () => {
+  return getFolderIcon();
+};
+
+const QuickPickEntriesOpenRecent = {
+  __proto__: null,
+  getFilterValue,
+  getHelpEntries,
+  getLabel,
+  getNoResults,
+  getPickDescription,
+  getPickFileIcon,
+  getPickFilterValue,
+  getPickIcon,
+  getPickLabel,
+  getPicks,
+  getPlaceholder,
+  selectPick
+};
+
+const Recent = 'quickPick://recent';
+
+const loadQuickPickEntries = moduleId => {
+  switch (moduleId) {
+    case Recent:
+      return QuickPickEntriesOpenRecent;
+    default:
+      throw new Error(`unknown module "${moduleId}"`);
+  }
+};
+
 const Memfs = 'memfs';
 const Html = 'html';
 const Fetch = 'fetch';
@@ -1455,7 +1843,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state$1 = {
+const state = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -1466,7 +1854,7 @@ const state$1 = {
 
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state$1.dbVersion, {
+  const db = await openDB('handle', state.dbVersion, {
     async upgrade(db) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         await db.createObjectStore('file-handles-store', {});
@@ -1540,210 +1928,11 @@ const SearchFileHtml = {
   searchFile: searchFile$2
 };
 
-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;
 };
 
-const state = {
-  rpc: undefined
-};
-const invoke$1 = (method, ...params) => {
-  const rpc = state.rpc;
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
-};
-const setRpc = rpc => {
-  state.rpc = rpc;
-};
-
 const invoke = (method, ...params) => {
   return invoke$1('SearchProcess.invoke', method, ...params);
 };
@@ -1815,6 +2004,9 @@ const commandMap = {
   'FileSystemMemory.readFile': readFile,
   'FileSystemMemory.remove': remove,
   'FileSystemMemory.writeFile': writeFile,
+  'QuickPick.getKeyBindings': getKeyBindings,
+  'QuickPick.loadEntries': loadQuickPickEntries,
+  'SearchFile.filter': filterQuickPickItems,
   'SearchFile.searchFile': searchFile,
   'SearchFile.searchFileWithFetch': searchFile$3,
   'SearchFile.searchFileWithHtml': searchFile$2,

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@lvce-editor/file-search-worker",
-  "version": "2.3.0",
+  "version": "3.1.0",
   "description": "",
   "main": "dist/fileSearchWorkerMain.js",
   "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "keywords": [
+    "text-search"
+  ],
+  "author": "Lvce Editor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvce-editor/file-search-worker.git"
+  }
 }