@lvce-editor/file-search-worker 3.5.0 → 3.6.0

package/dist/fileSearchWorkerMain.js

@@ -82,6 +82,18 @@ const getType = value => {
       return 'unknown';
   }
 };
+const object = value => {
+  const type = getType(value);
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
 const array = value => {
   const type = getType(value);
   if (type !== 'array') {
@@ -416,7 +428,7 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
 };
 
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -751,7 +763,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
 const invoke$2 = (ipc, method, ...params) => {
@@ -825,7 +837,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$3 = async ({
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -837,7 +849,7 @@ const create$3 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$3
+  create: create$4
 };
 
 const User = 1;
@@ -875,63 +887,58 @@ const i18nString = (key, placeholders = emptyObject) => {
   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 Files = 'Files';
+const GoToFile = 'Go to file';
+const NoMatchingColorThemesFound = 'No matching color themes found';
+const NoMatchingResults = 'No matching results';
+const NoRecentlyOpenedFoldersFound = 'No recently opened folders found';
+const NoResults = 'No Results';
+const NoSymbolFound = 'No symbol found';
+const NoWorkspaceSymbolsFound = 'no workspace symbols found';
+const OpenRecent = 'Open Recent';
+const SelectColorTheme = 'Select Color Theme';
+const SelectToOpen = 'Select to open';
+const ShowAndRunCommands = 'Show And Run Commands';
+const TypeNameOfCommandToRun = 'Type the name of a command to run.';
+
 const noMatchingColorThemesFound = () => {
-  return i18nString(UiStrings.NoMatchingColorThemesFound);
+  return i18nString(NoMatchingColorThemesFound);
 };
 const selectColorTheme = () => {
-  return i18nString(UiStrings.SelectColorTheme);
+  return i18nString(SelectColorTheme);
 };
 const typeNameofCommandToRun = () => {
-  return i18nString(UiStrings.TypeNameOfCommandToRun);
+  return i18nString(TypeNameOfCommandToRun);
 };
 const showAndRunCommands = () => {
-  return i18nString(UiStrings.ShowAndRunCommands);
+  return i18nString(ShowAndRunCommands);
 };
 const noMatchingResults = () => {
-  return i18nString(UiStrings.NoMatchingResults);
+  return i18nString(NoMatchingResults);
 };
 const files = () => {
-  return i18nString(UiStrings.Files);
+  return i18nString(Files);
 };
 const goToFile = () => {
-  return i18nString(UiStrings.GoToFile);
+  return i18nString(GoToFile);
 };
 const noResults = () => {
-  return i18nString(UiStrings.NoResults);
+  return i18nString(NoResults);
 };
 const selectToOpen = () => {
-  return i18nString(UiStrings.SelectToOpen);
+  return i18nString(SelectToOpen);
 };
 const openRecent = () => {
-  return i18nString(UiStrings.OpenRecent);
+  return i18nString(OpenRecent);
 };
 const noRecentlyOpenedFoldersFound = () => {
-  return i18nString(UiStrings.NoRecentlyOpenedFoldersFound);
+  return i18nString(NoRecentlyOpenedFoldersFound);
 };
 const noSymbolFound = () => {
-  return i18nString(UiStrings.NoSymbolFound);
+  return i18nString(NoSymbolFound);
 };
 const noWorkspaceSymbolsFound = () => {
-  return i18nString(UiStrings.NoWorkspaceSymbolsFound);
+  return i18nString(NoWorkspaceSymbolsFound);
 };
 
 const state$4 = {
@@ -1616,11 +1623,7 @@ replaceTraps(oldTraps => ({
 }));
 
 const state$2 = {
-  databases: Object.create(null),
-  eventId: 0,
-  dbVersion: 1,
-  cachedDb: undefined
-};
+  dbVersion: 1};
 
 // TODO high memory usage in idb because of transactionDoneMap
 
@@ -2016,7 +2019,7 @@ const getPickLabel$4 = pick => {
   const baseName = pathBaseName(pick);
   return baseName;
 };
-const getPickDescription$3 = pick => {
+const getPickDescription$4 = pick => {
   if (typeof pick === 'object') {
     pick = pick.pick;
   }
@@ -2042,7 +2045,7 @@ const QuickPickEntriesFile = {
   getHelpEntries: getHelpEntries$9,
   getLabel: getLabel$4,
   getNoResults: getNoResults$9,
-  getPickDescription: getPickDescription$3,
+  getPickDescription: getPickDescription$4,
   getPickFileIcon: getPickFileIcon$2,
   getPickFilterValue: getPickFilterValue$5,
   getPickIcon: getPickIcon$4,
@@ -2254,7 +2257,7 @@ const Symbol$2 = '@';
 const WorkspaceSymbol$1 = '#';
 const GoToLine = ':';
 const View$1 = 'view ';
-const None$1 = '';
+const None$2 = '';
 
 // TODO avoid global variable
 
@@ -2296,7 +2299,7 @@ const getPrefix = value => {
   if (value.startsWith(View$1)) {
     return View$1;
   }
-  return None$1;
+  return None$2;
 };
 const getQuickPickProvider = prefix => {
   // TODO could use enum for prefix
@@ -2351,7 +2354,7 @@ const getPickFilterValue$3 = pick => {
   } = state$1;
   return provider.getPickFilterValue(pick);
 };
-const getPickDescription$2 = pick => {
+const getPickDescription$3 = pick => {
   const {
     provider
   } = state$1;
@@ -2405,7 +2408,7 @@ const QuickPickEntriesEverything = {
   getHelpEntries: getHelpEntries$3,
   getLabel: getLabel$3,
   getNoResults: getNoResults$4,
-  getPickDescription: getPickDescription$2,
+  getPickDescription: getPickDescription$3,
   getPickFileIcon: getPickFileIcon$1,
   getPickFilterValue: getPickFilterValue$3,
   getPickIcon: getPickIcon$3,
@@ -2423,7 +2426,7 @@ const QuickPickEntriesEverything = {
 const Default = 0;
 const Finished = 2;
 
-const create$2 = () => {
+const create$3 = () => {
   const states = Object.create(null);
   return {
     get(uid) {
@@ -2441,9 +2444,9 @@ const create$2 = () => {
 const {
   get,
   set
-} = create$2();
+} = create$3();
 
-const create$1 = ({
+const create$2 = ({
   itemHeight,
   headerHeight = 0,
   minimumSliderSize = 20
@@ -2465,6 +2468,82 @@ const create$1 = ({
     scrollBarActive: false
   };
 };
+const getListHeight = (height, headerHeight) => {
+  if (headerHeight) {
+    return height - headerHeight;
+  }
+  return headerHeight;
+};
+const setDeltaY = (state, deltaY) => {
+  object(state);
+  number(deltaY);
+  const {
+    itemHeight,
+    items,
+    height,
+    headerHeight
+  } = state;
+  const listHeight = getListHeight(height, headerHeight);
+  const itemsLength = items.length;
+  const finalDeltaY = itemsLength * itemHeight - listHeight;
+  if (deltaY < 0) {
+    deltaY = 0;
+  } else if (deltaY > finalDeltaY) {
+    deltaY = Math.max(finalDeltaY, 0);
+  }
+  if (state.deltaY === deltaY) {
+    return state;
+  }
+  const minLineY = Math.round(deltaY / itemHeight);
+  const maxLineY = minLineY + Math.round(listHeight / itemHeight);
+  number(minLineY);
+  number(maxLineY);
+  return {
+    ...state,
+    deltaY,
+    minLineY,
+    maxLineY
+  };
+};
+const handleWheel = (state, deltaMode, deltaY) => {
+  object(state);
+  number(deltaMode);
+  number(deltaY);
+  return setDeltaY(state, state.deltaY + deltaY);
+};
+
+const create$1 = (uid, uri, listItemHeight, x, y, width, height, platform, args) => {
+  const state = {
+    uid,
+    state: Default,
+    picks: [],
+    recentPicks: [],
+    recentPickIds: new Map(),
+    // TODO use object.create(null) instead
+    versionId: 0,
+    provider: QuickPickEntriesEverything,
+    // TODO make this dynamic again
+    warned: [],
+    visiblePicks: [],
+    maxVisibleItems: 10,
+    uri,
+    cursorOffset: 0,
+    height: 300,
+    top: 50,
+    width: 600,
+    ...create$2({
+      itemHeight: listItemHeight,
+      headerHeight: 30,
+      minimumSliderSize: minimumSliderSize
+    }),
+    inputSource: User,
+    args,
+    focused: false,
+    platform,
+    value: ''
+  };
+  set(uid, state, state);
+};
 
 const create = (uid, uri, listItemHeight, x, y, width, height, platform, args) => {
   const state = {
@@ -2485,7 +2564,7 @@ const create = (uid, uri, listItemHeight, x, y, width, height, platform, args) =
     height: 300,
     top: 50,
     width: 600,
-    ...create$1({
+    ...create$2({
       itemHeight: listItemHeight,
       headerHeight: 30,
       minimumSliderSize: minimumSliderSize
@@ -2576,6 +2655,61 @@ const getBlob = async (uri, type) => {
   return blob;
 };
 
+const focusIndex = async (state, index) => {
+  const {
+    provider,
+    maxVisibleItems,
+    items,
+    minLineY,
+    maxLineY
+  } = state;
+  // TODO get types working
+  // @ts-ignore
+  if (provider.focusPick) {
+    // @ts-ignore
+    await provider.focusPick(items[index].pick);
+  }
+  if (index < minLineY + 1) {
+    const minLineY = index;
+    const maxLineY = Math.min(index + maxVisibleItems, items.length - 1);
+    // TODO need to scroll up
+    return {
+      ...state,
+      minLineY,
+      maxLineY,
+      focusedIndex: index
+    };
+  }
+  if (index >= maxLineY - 1) {
+    // TODO need to scroll down
+    const maxLineY = index + 1;
+    const minLineY = Math.max(maxLineY - maxVisibleItems, 0);
+    return {
+      ...state,
+      minLineY,
+      maxLineY,
+      focusedIndex: index
+    };
+  }
+  return {
+    ...state,
+    focusedIndex: index
+  };
+};
+
+const next = (items, index) => {
+  return (index + 1) % items.length;
+};
+
+const focusNext = state => {
+  const {
+    items,
+    focusedIndex
+  } = state;
+  const nextIndex = next(items, focusedIndex);
+  return focusIndex(state, nextIndex);
+};
+
 const Enter = 3;
 const Escape = 8;
 const PageUp = 10;
@@ -2614,6 +2748,15 @@ const getKeyBindings = () => {
   }];
 };
 
+const closeWidget = async id => {
+  await invoke$1('Viewlet.closeWidget', id);
+};
+
+const handleBlur = async state => {
+  await closeWidget(state.uid);
+  return state;
+};
+
 const getDefaultValue = uri => {
   switch (uri) {
     case 'quickPick://everything':
@@ -2685,7 +2828,7 @@ const QuickPickEntriesColorTheme = {
 const Tag$1 = 'Tag';
 const Cloud$1 = 'Cloud';
 const SourceControl$1 = 'SourceControl';
-const None = '';
+const None$1 = '';
 
 const SourceControl = 1;
 const Cloud = 2;
@@ -2737,7 +2880,7 @@ const getPickFilterValue$1 = pick => {
 const getPickLabel$1 = pick => {
   return pick.label;
 };
-const getPickDescription$1 = pick => {
+const getPickDescription$2 = pick => {
   return pick.description || '';
 };
 const convertIcon = icon => {
@@ -2749,7 +2892,7 @@ const convertIcon = icon => {
     case Tag:
       return Tag$1;
     default:
-      return None;
+      return None$1;
   }
 };
 const getPickIcon$1 = pick => {
@@ -2762,7 +2905,7 @@ const QuickPickEntriesCustom = {
   getHelpEntries: getHelpEntries$2,
   getLabel: getLabel$1,
   getNoResults: getNoResults$2,
-  getPickDescription: getPickDescription$1,
+  getPickDescription: getPickDescription$2,
   getPickFilterValue: getPickFilterValue$1,
   getPickIcon: getPickIcon$1,
   getPickLabel: getPickLabel$1,
@@ -2879,7 +3022,7 @@ const getPickFilterValue = pick => {
 const getPickLabel = pick => {
   return pathBaseName(pick);
 };
-const getPickDescription = pick => {
+const getPickDescription$1 = pick => {
   return pathDirName(pick);
 };
 const getPickIcon = () => {
@@ -2895,7 +3038,7 @@ const QuickPickEntriesOpenRecent = {
   getHelpEntries,
   getLabel,
   getNoResults,
-  getPickDescription,
+  getPickDescription: getPickDescription$1,
   getPickFileIcon,
   getPickFilterValue,
   getPickIcon,
@@ -2986,7 +3129,350 @@ const loadQuickPickEntries = moduleId => {
   }
 };
 
+const RenderItems = 1;
+const RenderFocus = 2;
+const RenderValue = 3;
+const RenderCursorOffset = 7;
+const RenderFocusedIndex = 8;
+const Height = 9;
+
+const FileIcon = 'FileIcon';
+const Label = 'Label';
+const QuickPickHighlight = 'QuickPickHighlight';
+const QuickPickItem = 'QuickPickItem';
+const QuickPickItemActive = 'QuickPickItemActive';
+const QuickPickItemDescription = 'QuickPickItemDescription';
+const QuickPickItemLabel = 'QuickPickItemLabel';
+
+const None = 'none';
+const Option = 'option';
+
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+
+const getFileIconVirtualDom = icon => {
+  return {
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None,
+    childCount: 0
+  };
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const quickPickHighlight = {
+  type: Span,
+  className: QuickPickHighlight,
+  childCount: 1
+};
+const addHighlights = (dom, highlights, label) => {
+  const labelDom = {
+    type: Div,
+    className: QuickPickItemLabel,
+    childCount: 0
+  };
+  dom.push(labelDom);
+  let position = 0;
+  for (let i = 0; i < highlights.length; i += 2) {
+    const highlightStart = highlights[i];
+    const highlightEnd = highlights[i + 1];
+    if (position < highlightStart) {
+      const beforeText = label.slice(position, highlightStart);
+      labelDom.childCount++;
+      dom.push(text(beforeText));
+    }
+    const highlightText = label.slice(highlightStart, highlightEnd);
+    labelDom.childCount++;
+    dom.push(quickPickHighlight, text(highlightText));
+    position = highlightEnd;
+  }
+  if (position < label.length) {
+    const afterText = label.slice(position);
+    labelDom.childCount++;
+    dom.push(text(afterText));
+  }
+};
+const getQuickPickItemVirtualDom = visibleItem => {
+  const {
+    posInSet,
+    label,
+    setSize,
+    isActive,
+    description,
+    icon,
+    matches,
+    fileIcon
+  } = visibleItem;
+  const highlights = matches.slice(1);
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: QuickPickItem,
+    role: Option,
+    ariaPosInSet: posInSet,
+    ariaSetSize: setSize,
+    childCount: 1
+  });
+  const parent = dom[0];
+  if (isActive) {
+    // @ts-ignore
+    parent.id = 'QuickPickItemActive';
+    parent.className += ' ' + QuickPickItemActive;
+  }
+  if (fileIcon) {
+    parent.childCount++;
+    dom.push(getFileIconVirtualDom(fileIcon));
+  } else if (icon) {
+    parent.childCount++;
+    dom.push({
+      type: Div,
+      className: `QuickPickMaskIcon MaskIcon MaskIcon${icon}`,
+      childCount: 0
+    });
+  }
+  addHighlights(dom, highlights, label);
+  if (description) {
+    parent.childCount++;
+    dom.push({
+      type: Div,
+      className: QuickPickItemDescription,
+      childCount: 1
+    }, text(description));
+  }
+  return dom;
+};
+
+const getQuickPickItemsVirtualDom = visibleItems => {
+  if (visibleItems.length === 0) {
+    return [{
+      type: Div,
+      className: 'QuickPickItem QuickPickItemActive QuickPickStatus',
+      childCount: 1
+    }, {
+      type: Div,
+      className: Label,
+      childCount: 1
+    }, text('No Results')];
+  }
+  const dom = visibleItems.flatMap(getQuickPickItemVirtualDom);
+  return dom;
+};
+
+const getPickDescription = (provider, pick) => {
+  if (provider.getPickDescription) {
+    return provider.getPickDescription(pick);
+  }
+  return '';
+};
+const getFileIcon = (provider, pick) => {
+  if (provider.getPickFileIcon) {
+    return provider.getPickFileIcon(pick);
+  }
+  return '';
+};
+const getVisible = (provider, items, minLineY, maxLineY, focusedIndex) => {
+  const visibleItems = [];
+  const setSize = items.length;
+  const max = Math.min(setSize, maxLineY);
+  for (let i = minLineY; i < max; i++) {
+    const item = items[i];
+    const pick = item.pick;
+    const label = provider.getPickLabel(pick);
+    const description = getPickDescription(provider, pick);
+    const icon = provider.getPickIcon(pick);
+    const fileIcon = getFileIcon(provider, pick);
+    visibleItems.push({
+      label,
+      description,
+      icon,
+      fileIcon,
+      posInSet: i + 1,
+      setSize,
+      isActive: i === focusedIndex,
+      matches: item.matches
+    });
+  }
+  return visibleItems;
+};
+
+const SetCursorOffset = 'setCursorOffset';
+const SetFocusedIndex = 'setFocusedIndex';
+const SetItemsHeight = 'setItemsHeight';
+const SetValue = 'setValue';
+
+const renderValue = (oldState, newState) => {
+  return [/* method */SetValue, /* value */newState.value];
+};
+const renderCursorOffset = (oldState, newState) => {
+  return [/* method */SetCursorOffset, /* cursorOffset */newState.cursorOffset];
+};
+const renderItems = (oldState, newState) => {
+  const visibleItems = getVisible(newState.provider, newState.items, newState.minLineY, newState.maxLineY, newState.focusedIndex);
+  const dom = getQuickPickItemsVirtualDom(visibleItems);
+  return [/* method */'setItemsDom', dom];
+};
+const renderFocusedIndex = (oldState, newState) => {
+  const oldFocusedIndex = oldState.focusedIndex - oldState.minLineY;
+  const newFocusedIndex = newState.focusedIndex - newState.minLineY;
+  return [/* method */SetFocusedIndex, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */newFocusedIndex];
+};
+const renderHeight = (oldState, newState) => {
+  if (newState.items.length === 0) {
+    return [/* method */SetItemsHeight, /* height */newState.itemHeight];
+  }
+  const maxLineY = Math.min(newState.maxLineY, newState.items.length);
+  const itemCount = maxLineY - newState.minLineY;
+  const height = itemCount * newState.itemHeight;
+  return [/* method */SetItemsHeight, /* height */height];
+};
+const renderFocus = (oldState, newState) => {
+  const selector = newState.focused ? '.InputBox' : '';
+  return ['Viewlet.focusSelector', selector];
+};
+const getRenderer = diffType => {
+  switch (diffType) {
+    case RenderValue:
+      return renderValue;
+    case RenderCursorOffset:
+      return renderCursorOffset;
+    case RenderItems:
+      return renderItems;
+    case RenderFocusedIndex:
+      return renderFocusedIndex;
+    case Height:
+      return renderHeight;
+    case RenderFocus:
+      return renderFocus;
+    default:
+      throw new Error('unknown renderer');
+  }
+};
+
+const applyRender = (oldState, newState, diffResult) => {
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer(item);
+    commands.push(fn(oldState, newState));
+  }
+  return commands;
+};
+
+const diffType$4 = RenderFocus;
+const isEqual$4 = (oldState, newState) => {
+  return oldState.focused === newState.focused;
+};
+
+const DiffFocus = {
+  __proto__: null,
+  diffType: diffType$4,
+  isEqual: isEqual$4
+};
+
+const diffType$3 = RenderFocusedIndex;
+const isEqual$3 = (oldState, newState) => {
+  return oldState.focusedIndex === newState.focusedIndex;
+};
+
+const DiffFocusedIndex = {
+  __proto__: null,
+  diffType: diffType$3,
+  isEqual: isEqual$3
+};
+
+const diffType$2 = Height;
+const isEqual$2 = (oldState, newState) => {
+  return oldState.items.length === newState.items.length;
+};
+
+const DiffHeight = {
+  __proto__: null,
+  diffType: diffType$2,
+  isEqual: isEqual$2
+};
+
+const diffType$1 = RenderItems;
+const isEqual$1 = (oldState, newState) => {
+  return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex;
+};
+
+const DiffItems = {
+  __proto__: null,
+  diffType: diffType$1,
+  isEqual: isEqual$1
+};
+
+const diffType = RenderValue;
+const isEqual = (oldState, newState) => {
+  return newState.inputSource === User || oldState.value === newState.value;
+};
+
+const DiffValue = {
+  __proto__: null,
+  diffType,
+  isEqual
+};
+
+const modules = [DiffHeight, DiffItems, DiffFocus, DiffFocus, DiffValue, DiffFocusedIndex];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (const module of modules) {
+    if (!module.isEqual(oldState, newState)) {
+      diffResult.push(module.diffType);
+    }
+  }
+  return diffResult;
+};
+
+const doRender = uid => {
+  const {
+    oldState,
+    newState
+  } = get(uid);
+  const diffResult = diff(oldState, newState);
+  return applyRender(oldState, newState, diffResult);
+};
+
+const wrapCommand = fn => {
+  const wrapped = async (uid, ...args) => {
+    const {
+      newState
+    } = get(uid);
+    const newerState = await fn(newState, ...args);
+    set(uid, newState, newerState);
+  };
+  return wrapped;
+};
+
 const commandMap = {
+  'QuickPick.create': create,
+  'QuickPick.create2': create$1,
+  'QuickPick.focusIndex': wrapCommand(focusIndex),
+  'QuickPick.focusNext': wrapCommand(focusNext),
+  'QuickPick.getKeyBindings': getKeyBindings,
+  'QuickPick.handleBlur': wrapCommand(handleBlur),
+  'QuickPick.handleWheel': wrapCommand(handleWheel),
+  'QuickPick.setDeltaY': wrapCommand(setDeltaY),
+  'QuickPick.loadContent': wrapCommand(loadContent),
+  'QuickPick.loadEntries2': load,
+  'QuickPick.render': doRender,
+  'SearchFile.filter': filterQuickPickItems,
+  'SearchFile.searchFile': searchFile,
+  'SearchFile.searchFileWithFetch': searchFile$3,
+  'SearchFile.searchFileWithHtml': searchFile$2,
+  'SearchFile.searchFileWithRipGrep': searchFile$1,
+  // deprecated
+  'QuickPick.loadEntries': loadQuickPickEntries,
   'FileSystemFetch.chmod': chmod,
   'FileSystemFetch.getBlob': getBlob,
   'FileSystemFetch.mkdir': mkdir,
@@ -3002,17 +3488,7 @@ const commandMap = {
   'FileSystemMemory.readDirWithFileTypes': readDirWithFileTypes$1,
   'FileSystemMemory.readFile': readFile$1,
   'FileSystemMemory.remove': remove$1,
-  'FileSystemMemory.writeFile': writeFile$1,
-  'QuickPick.create': create,
-  'QuickPick.getKeyBindings': getKeyBindings,
-  'QuickPick.loadContent': loadContent,
-  'QuickPick.loadEntries': loadQuickPickEntries,
-  'QuickPick.loadEntries2': load,
-  'SearchFile.filter': filterQuickPickItems,
-  'SearchFile.searchFile': searchFile,
-  'SearchFile.searchFileWithFetch': searchFile$3,
-  'SearchFile.searchFileWithHtml': searchFile$2,
-  'SearchFile.searchFileWithRipGrep': searchFile$1
+  'FileSystemMemory.writeFile': writeFile$1
 };
 
 const listen = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-search-worker",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "",
   "keywords": [
     "text-search"