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

package/dist/fileSearchWorkerMain.js

@@ -100,6 +100,12 @@ const array = value => {
     throw new AssertionError('expected value to be of type array');
   }
 };
+const string = value => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -1288,7 +1294,7 @@ const getFiles = () => {
   return state$3.files;
 };
 
-const searchFile$4 = async () => {
+const searchFile$5 = async () => {
   const files = await getFiles();
   const keys = Object.keys(files);
   return keys;
@@ -1296,7 +1302,7 @@ const searchFile$4 = async () => {
 
 const SearchFileMemfs = {
   __proto__: null,
-  searchFile: searchFile$4
+  searchFile: searchFile$5
 };
 
 const assetDir = '';
@@ -1326,7 +1332,7 @@ const removeLeadingSlash = path => {
 // TODO simplify code
 // 1. don't have playground prefix in fileMap json
 // 2. remove code here that removes the prefix
-const searchFile$3 = async path => {
+const searchFile$4 = async path => {
   const fileList = await getJson(fileMapUrl);
   const result = fileList.map(removeLeadingSlash);
   const prefixLength = path.length - 'file:///'.length;
@@ -1339,7 +1345,7 @@ const searchFile$3 = async path => {
 
 const SearchFileFetch = {
   __proto__: null,
-  searchFile: searchFile$3
+  searchFile: searchFile$4
 };
 
 const Directory = 'directory';
@@ -1686,7 +1692,7 @@ const searchFilesRecursively = async (all, parent, handle) => {
   }
   await Promise.all(promises);
 };
-const searchFile$2 = async uri => {
+const searchFile$3 = async uri => {
   const path = uri.slice('html://'.length);
   const handle = await getDirectoryHandle(path);
   if (!handle) {
@@ -1700,7 +1706,7 @@ const searchFile$2 = async uri => {
 
 const SearchFileHtml = {
   __proto__: null,
-  searchFile: searchFile$2
+  searchFile: searchFile$3
 };
 
 const emptyMatches = [];
@@ -1911,7 +1917,7 @@ const splitLines = lines => {
 
 // TODO create direct connection from electron to file search worker using message ports
 
-const searchFile$1 = async (path, value, prepare) => {
+const searchFile$2 = async (path, value, prepare) => {
   const ripGrepArgs = getFileSearchRipGrepArgs();
   const options = {
     ripGrepArgs,
@@ -1929,7 +1935,7 @@ const searchFile$1 = async (path, value, prepare) => {
 
 const SearchFileRipGrep = {
   __proto__: null,
-  searchFile: searchFile$1
+  searchFile: searchFile$2
 };
 
 const getModule = protocol => {
@@ -1944,7 +1950,8 @@ const getModule = protocol => {
       return SearchFileRipGrep;
   }
 };
-const searchFile = async (path, value, prepare, assetDir) => {
+
+const searchFile$1 = async (path, value, prepare, assetDir) => {
   const protocol = getProtocol(path);
   // TODO call different providers depending on protocol
   const module = await getModule(protocol);
@@ -1967,6 +1974,12 @@ const pathDirName = path => {
   return path.slice(0, index);
 };
 
+const searchFile = async (path, value) => {
+  const prepare = true;
+  // @ts-ignore
+  const files = await searchFile$1(/* path */path, /* searchTerm */value, prepare);
+  return files;
+};
 const name$7 = 'file';
 const getPlaceholder$a = () => {
   return '';
@@ -1988,9 +2001,14 @@ const getNoResults$9 = () => {
   };
 };
 const getPicks$a = async searchValue => {
-  {
+  // TODO cache workspace path
+  const workspace = await invoke$1('Workspace.getPath');
+  if (!workspace) {
     return [];
   }
+  const files = await searchFile(workspace, searchValue);
+  // const picks = files.map(toPick)
+  return files;
 };
 const selectPick$a = async pick => {
   if (typeof pick === 'object') {
@@ -2697,9 +2715,29 @@ const focusIndex = async (state, index) => {
   };
 };
 
+const first = () => {
+  return 0;
+};
+const last = items => {
+  return items.length - 1;
+};
 const next = (items, index) => {
   return (index + 1) % items.length;
 };
+const previous = (items, index) => {
+  return index === 0 ? items.length - 1 : index - 1;
+};
+
+const focusFirst = state => {
+  return focusIndex(state, first());
+};
+
+const focusLast = state => {
+  const {
+    items
+  } = state;
+  return focusIndex(state, last(items));
+};
 
 const focusNext = state => {
   const {
@@ -2710,6 +2748,20 @@ const focusNext = state => {
   return focusIndex(state, nextIndex);
 };
 
+const focusPrevious = state => {
+  const {
+    items,
+    focusedIndex
+  } = state;
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
+};
+
+const commandIds = ['handleBlur', 'handleClickAt', 'handleWheel', 'selectCurrentIndex', 'selectIndex', 'selectItem', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'handleInput', 'handleBeforeInput'];
+const getCommandIds = () => {
+  return commandIds;
+};
+
 const Enter = 3;
 const Escape = 8;
 const PageUp = 10;
@@ -2748,6 +2800,182 @@ const getKeyBindings = () => {
   }];
 };
 
+const InsertText = 'insertText';
+const DeleteContentBackward = 'deleteContentBackward';
+const DeleteContentForward = 'deleteContentForward';
+const DeleteWordForward = 'deleteWordForward';
+const DeleteWordBackward = 'deleteWordBackward';
+const InsertLineBreak = 'insertLineBreak';
+const InsertCompositionText = 'insertCompositionText';
+const InsertFromPaste = 'insertFromPaste';
+
+const getNewValueInsertText = (value, selectionStart, selectionEnd, data) => {
+  if (selectionStart === value.length) {
+    const newValue = value + data;
+    return {
+      newValue,
+      cursorOffset: newValue.length
+    };
+  }
+  const before = value.slice(0, selectionStart);
+  const after = value.slice(selectionEnd);
+  const newValue = before + data + after;
+  return {
+    newValue,
+    cursorOffset: selectionStart + data.length
+  };
+};
+const getNewValueDeleteContentBackward = (value, selectionStart, selectionEnd, data) => {
+  const after = value.slice(selectionEnd);
+  if (selectionStart === selectionEnd) {
+    const before = value.slice(0, selectionStart - 1);
+    const newValue = before + after;
+    return {
+      newValue,
+      cursorOffset: before.length
+    };
+  }
+  const before = value.slice(0, selectionStart);
+  const newValue = before + after;
+  return {
+    newValue,
+    cursorOffset: selectionStart
+  };
+};
+const RE_ALPHA_NUMERIC = /[a-z\d]/i;
+const isAlphaNumeric = character => {
+  return RE_ALPHA_NUMERIC.test(character);
+};
+const getNewValueDeleteWordBackward = (value, selectionStart, selectionEnd, data) => {
+  const after = value.slice(selectionEnd);
+  if (selectionStart === selectionEnd) {
+    let startIndex = Math.max(selectionStart - 1, 0);
+    while (startIndex > 0 && isAlphaNumeric(value[startIndex])) {
+      startIndex--;
+    }
+    const before = value.slice(0, startIndex);
+    const newValue = before + after;
+    return {
+      newValue,
+      cursorOffset: before.length
+    };
+  }
+  const before = value.slice(0, selectionStart);
+  const newValue = before + after;
+  return {
+    newValue,
+    cursorOffset: selectionStart
+  };
+};
+const getNewValueDeleteContentForward = (value, selectionStart, selectionEnd, data) => {
+  const before = value.slice(0, selectionStart);
+  if (selectionStart === selectionEnd) {
+    const after = value.slice(selectionEnd + 1);
+    const newValue = before + after;
+    return {
+      newValue,
+      cursorOffset: selectionStart
+    };
+  }
+  const after = value.slice(selectionEnd);
+  const newValue = before + after;
+  return {
+    newValue,
+    cursorOffset: selectionStart
+  };
+};
+const getNewValueDeleteWordForward = (value, selectionStart, selectionEnd, data) => {
+  const before = value.slice(0, selectionStart);
+  if (selectionStart === selectionEnd) {
+    let startIndex = Math.min(selectionStart + 1, value.length - 1);
+    while (startIndex < value.length && isAlphaNumeric(value[startIndex])) {
+      startIndex++;
+    }
+    const after = value.slice(startIndex);
+    const newValue = before + after;
+    return {
+      newValue,
+      cursorOffset: before.length
+    };
+  }
+  const after = value.slice(selectionEnd);
+  const newValue = before + after;
+  return {
+    newValue,
+    cursorOffset: selectionStart
+  };
+};
+const getNewValueInsertCompositionText = (value, selectionStart, selectionEnd, data) => {
+  return getNewValueInsertText(value, selectionStart, selectionEnd, data);
+};
+const getNewValueInsertLineBreak = (value, selectionStart, selectionEnd, data) => {
+  return {
+    newValue: value,
+    cursorOffset: selectionEnd
+  };
+};
+const getFn = inputType => {
+  switch (inputType) {
+    case InsertFromPaste:
+    case InsertText:
+      return getNewValueInsertText;
+    case DeleteContentBackward:
+      return getNewValueDeleteContentBackward;
+    case DeleteContentForward:
+      return getNewValueDeleteContentForward;
+    case DeleteWordForward:
+      return getNewValueDeleteWordForward;
+    case DeleteWordBackward:
+      return getNewValueDeleteWordBackward;
+    case InsertLineBreak:
+      return getNewValueInsertLineBreak;
+    case InsertCompositionText:
+      return getNewValueInsertCompositionText;
+    default:
+      throw new Error(`unsupported input type ${inputType}`);
+  }
+};
+const getNewValue = (value, inputType, data, selectionStart, selectionEnd) => {
+  const fn = getFn(inputType);
+  return fn(value, selectionStart, selectionEnd, data);
+};
+
+// TODO when user types letters -> no need to query provider again -> just filter existing results
+const handleInput = async (state, newValue, cursorOffset, inputSource = Script) => {
+  if (state.value === newValue) {
+    return state;
+  }
+  // @ts-ignore
+  state.value = newValue;
+  // @ts-ignore
+  state.inputSource = inputSource;
+  const newPicks = await state.provider.getPicks(newValue);
+  const filterValue = state.provider.getFilterValue(newValue);
+  const items = filterQuickPickItems(newPicks, filterValue);
+  const focusedIndex = items.length === 0 ? -1 : 0;
+  return {
+    ...state,
+    picks: newPicks,
+    items,
+    focusedIndex,
+    cursorOffset
+  };
+};
+
+const handleBeforeInput = (state, inputType, data, selectionStart, selectionEnd) => {
+  string(inputType);
+  number(selectionStart);
+  number(selectionEnd);
+  const {
+    value
+  } = state;
+  const {
+    newValue,
+    cursorOffset
+  } = getNewValue(value, inputType, data, selectionStart, selectionEnd);
+  return handleInput(state, newValue, cursorOffset, User);
+};
+
 const closeWidget = async id => {
   await invoke$1('Viewlet.closeWidget', id);
 };
@@ -3099,7 +3327,7 @@ const loadContent = async state => {
   array(newPicks);
   // @ts-ignore
   const filterValue = provider.getFilterValue(value);
-  const items = filterQuickPickItems(state.items, filterValue);
+  const items = filterQuickPickItems(newPicks, filterValue);
   // @ts-ignore
   provider.getLabel();
   const minLineY = 0;
@@ -3311,29 +3539,29 @@ const SetItemsHeight = 'setItemsHeight';
 const SetValue = 'setValue';
 
 const renderValue = (oldState, newState) => {
-  return [/* method */SetValue, /* value */newState.value];
+  return ['Viewlet.send', newState.uid, /* method */SetValue, /* value */newState.value];
 };
 const renderCursorOffset = (oldState, newState) => {
-  return [/* method */SetCursorOffset, /* cursorOffset */newState.cursorOffset];
+  return ['Viewlet.send', newState.uid, /* 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];
+  return ['Viewlet.send', newState.uid, /* 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];
+  return ['Viewlet.send', newState.uid, /* method */SetFocusedIndex, /* oldFocusedIndex */oldFocusedIndex, /* newFocusedIndex */newFocusedIndex];
 };
 const renderHeight = (oldState, newState) => {
   if (newState.items.length === 0) {
-    return [/* method */SetItemsHeight, /* height */newState.itemHeight];
+    return ['Viewlet.send', newState.uid, /* 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];
+  return ['Viewlet.send', newState.uid, /* method */SetItemsHeight, /* height */height];
 };
 const renderFocus = (oldState, newState) => {
   const selector = newState.focused ? '.InputBox' : '';
@@ -3443,6 +3671,74 @@ const doRender = uid => {
   return applyRender(oldState, newState, diffResult);
 };
 
+const getPick = (items, index) => {
+  array(items);
+  number(index);
+  // if (index < state.recentPicks.length) {
+  //   return state.recentPicks[index]
+  // }
+  // index -= state.recentPicks.length
+  if (index < items.length) {
+    return items[index].pick;
+  }
+  console.warn('no pick matching index', index);
+};
+
+const selectIndex = async (state, index, button = /* left */0) => {
+  const {
+    minLineY,
+    provider,
+    items
+  } = state;
+  const actualIndex = index + minLineY;
+  const pick = getPick(items, actualIndex);
+  const selectPickResult = await provider.selectPick(pick, actualIndex, button);
+  object(selectPickResult);
+  string(selectPickResult.command);
+  const {
+    command
+  } = selectPickResult;
+  switch (command) {
+    case Hide:
+      await closeWidget(state.uid);
+      return state;
+    default:
+      return state;
+  }
+
+  // TODO recent picks should be per provider
+  // if (!state.recentPickIds.has(pick.id)) {
+  //   state.recentPicks.unshift(pick)
+  //   state.recentPickIds.add(pick.id)
+  // }
+  // if (state.recentPicks.length > RECENT_PICKS_MAX_SIZE) {
+  //   const last = state.recentPicks.pop()
+  //   state.recentPickIds.delete(last.id)
+  // }
+};
+
+const selectCurrentIndex = state => {
+  return selectIndex(state, state.focusedIndex);
+};
+
+const findLabelIndex = (items, label) => {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].pick.label === label) {
+      return i;
+    }
+  }
+  return -1;
+};
+
+const selectItem = async (state, label) => {
+  string(label);
+  const index = findLabelIndex(state.items, label);
+  if (index === -1) {
+    return state;
+  }
+  return selectIndex(state, index);
+};
+
 const wrapCommand = fn => {
   const wrapped = async (uid, ...args) => {
     const {
@@ -3455,23 +3751,31 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
-  'QuickPick.create': create,
   'QuickPick.create2': create$1,
+  'QuickPick.focusFirst': wrapCommand(focusFirst),
   'QuickPick.focusIndex': wrapCommand(focusIndex),
+  'QuickPick.focusLast': wrapCommand(focusLast),
   'QuickPick.focusNext': wrapCommand(focusNext),
+  'QuickPick.focusPrevious': wrapCommand(focusPrevious),
+  'QuickPick.getCommandIds': getCommandIds,
   'QuickPick.getKeyBindings': getKeyBindings,
+  'QuickPick.handleBeforeInput': wrapCommand(handleBeforeInput),
   'QuickPick.handleBlur': wrapCommand(handleBlur),
   'QuickPick.handleWheel': wrapCommand(handleWheel),
-  'QuickPick.setDeltaY': wrapCommand(setDeltaY),
   'QuickPick.loadContent': wrapCommand(loadContent),
   'QuickPick.loadEntries2': load,
   'QuickPick.render': doRender,
+  'QuickPick.selectCurrentIndex': wrapCommand(selectCurrentIndex),
+  'QuickPick.selectIndex': wrapCommand(selectIndex),
+  'QuickPick.selectItem': wrapCommand(selectItem),
+  'QuickPick.setDeltaY': wrapCommand(setDeltaY),
   'SearchFile.filter': filterQuickPickItems,
-  'SearchFile.searchFile': searchFile,
-  'SearchFile.searchFileWithFetch': searchFile$3,
-  'SearchFile.searchFileWithHtml': searchFile$2,
-  'SearchFile.searchFileWithRipGrep': searchFile$1,
+  'SearchFile.searchFile': searchFile$1,
+  'SearchFile.searchFileWithFetch': searchFile$4,
+  'SearchFile.searchFileWithHtml': searchFile$3,
+  'SearchFile.searchFileWithRipGrep': searchFile$2,
   // deprecated
+  'QuickPick.create': create,
   'QuickPick.loadEntries': loadQuickPickEntries,
   'FileSystemFetch.chmod': chmod,
   'FileSystemFetch.getBlob': getBlob,

package/package.json

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