@lvce-editor/static-server 0.49.20 → 0.49.22

package/static/{3b2e1bb → 99348a0}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -985,6 +985,8 @@ const getPath = dirent => {
   return dirent.path;
 };
 
+const DELTA_EDITING = 100;
+
 const BlockDevice = 1;
 const CharacterDevice = 2;
 const Directory = 3;
@@ -996,6 +998,8 @@ const Symlink = 9;
 const SymLinkFile = 10;
 const SymLinkFolder = 11;
 const Unknown = 12;
+const EditingFile = File + DELTA_EDITING;
+const EditingFolder = Directory + DELTA_EDITING;
 
 const RendererWorker = 1;
 
@@ -1013,12 +1017,20 @@ const invoke = (method, ...params) => {
   return rpc.invoke(method, ...params);
 };
 
+const getFileIcon = async name => {
+  return invoke('IconTheme.getFileIcon', {
+    name
+  });
+};
+
+const getFolderIcon = async name => {
+  return invoke('IconTheme.getFolderIcon', {
+    name
+  });
+};
+
 const requestFileIcons = async requests => {
-  const promises = requests.map(request => request.type === File ? invoke('IconTheme.getFileIcon', {
-    name: request.name
-  }) : invoke('IconTheme.getFolderIcon', {
-    name: request.name
-  }));
+  const promises = requests.map(request => request.type === File ? getFileIcon(request.name) : getFolderIcon(request.name));
   return Promise.all(promises);
 };
 
@@ -1107,13 +1119,16 @@ const getNewDirentsAccept = async (state, newDirentType, createFn) => {
   const depth = parentDirent.depth + 1;
   const newDirent = {
     path: absolutePath,
+    // @ts-ignore
     posInSet: -1,
     setSize: 1,
     depth,
     name: newFileName,
     type: newDirentType,
-    icon: ''
+    icon: '',
+    selected: false
   };
+  // @ts-ignore
   newDirent.icon = '';
   let insertIndex = state.focusedIndex;
   let deltaPosInSet = 0;
@@ -1147,11 +1162,13 @@ const getNewDirentsAccept = async (state, newDirentType, createFn) => {
     // @ts-ignore
     dirent.posInSet += deltaPosInSet;
   }
+  // @ts-ignore
   newDirent.setSize = setSize;
+  // @ts-ignore
   newDirent.posInSet = posInSet;
   // @ts-ignore
   items.splice(insertIndex + 1, 0, newDirent);
-  const newDirents = [...items];
+  const newDirents = [...items].filter(item => item.type !== EditingFile && item.type !== EditingFolder);
   return {
     dirents: newDirents,
     newFocusedIndex: insertIndex + 1
@@ -1401,12 +1418,41 @@ const acceptEdit = async state => {
   }
 };
 
+const getNewDirentsForCancelRename = (items, editingIndex) => {
+  const item = items[editingIndex];
+  const newItems = [...items];
+  newItems[editingIndex] = {
+    ...item,
+    type: item.type - DELTA_EDITING
+  };
+  return newItems;
+};
+
+const isNormalItem = item => {
+  return item.type !== EditingFile && item.type !== EditingFolder;
+};
 const cancelEdit = state => {
   const {
-    editingIndex
+    editingIndex,
+    editingType
   } = state;
+  if (editingType === Rename$1) {
+    const newItems = getNewDirentsForCancelRename(state.items, editingIndex);
+    return {
+      ...state,
+      items: newItems,
+      focusedIndex: editingIndex,
+      focused: true,
+      editingIndex: -1,
+      editingValue: '',
+      editingType: None$5,
+      focus: List
+    };
+  }
+  const filteredItems = state.items.filter(isNormalItem);
   return {
     ...state,
+    items: filteredItems,
     focusedIndex: editingIndex,
     focused: true,
     editingIndex: -1,
@@ -1573,19 +1619,29 @@ const create = (id, uri, x, y, width, height, args, parentUid, platform = 0) =>
 
 const RenderItems = 4;
 const RenderFocus = 6;
+const RenderFocusContext = 7;
+const RenderValue = 8;
 
-const diffType$1 = RenderFocus;
-const isEqual$2 = (oldState, newState) => {
+const diffType$2 = RenderFocus;
+const isEqual$3 = (oldState, newState) => {
   return oldState.focused === newState.focused && oldState.focus === newState.focus;
 };
 
-const diffType = RenderItems;
-const isEqual$1 = (oldState, newState) => {
+const diffType$1 = RenderItems;
+const isEqual$2 = (oldState, newState) => {
   return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.focusedIndex === newState.focusedIndex && oldState.editingIndex === newState.editingIndex && oldState.editingType === newState.editingType && oldState.editingValue === newState.editingValue && oldState.editingErrorMessage === newState.editingErrorMessage && oldState.width === newState.width && oldState.focused === newState.focused && oldState.dropTargets === newState.dropTargets;
 };
 
-const modules = [isEqual$1, isEqual$2];
-const numbers = [diffType, diffType$1];
+const diffType = RenderValue;
+const isEqual$1 = (oldState, newState) => {
+  if (newState.focus !== Input$1) {
+    return true;
+  }
+  return oldState.focus === Input$1 && newState.focus === Input$1 && oldState.editingValue === newState.editingValue;
+};
+
+const modules = [isEqual$2, isEqual$3, isEqual$3, isEqual$1];
+const numbers = [diffType$1, diffType$2, RenderFocusContext, diffType];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1872,12 +1928,18 @@ const expandRecursively = async state => {
 const focusIndex = (state, index) => {
   const {
     minLineY,
-    maxLineY
+    maxLineY,
+    items
   } = state;
+  const newItems = items.map((item, i) => ({
+    ...item,
+    selected: i === index ? true : false
+  }));
   if (index < minLineY) {
     if (index < 0) {
       return {
         ...state,
+        items: newItems,
         focusedIndex: index,
         focused: true
       };
@@ -1885,6 +1947,7 @@ const focusIndex = (state, index) => {
     const diff = maxLineY - minLineY;
     return {
       ...state,
+      items: newItems,
       focusedIndex: index,
       focused: true,
       minLineY: index,
@@ -1895,6 +1958,7 @@ const focusIndex = (state, index) => {
     const diff = maxLineY - minLineY;
     return {
       ...state,
+      items: newItems,
       focusedIndex: index,
       focused: true,
       minLineY: index + 1 - diff,
@@ -1903,6 +1967,7 @@ const focusIndex = (state, index) => {
   }
   return {
     ...state,
+    items: newItems,
     focusedIndex: index,
     focused: true
   };
@@ -1953,6 +2018,16 @@ const focusNext = state => {
   return focusIndex(state, focusedIndex + 1);
 };
 
+const focusNone = state => {
+  const {
+    focusedIndex
+  } = state;
+  if (focusedIndex === -1) {
+    return state;
+  }
+  return focusIndex(state, -1);
+};
+
 const focusPrevious = state => {
   const {
     focusedIndex,
@@ -1971,7 +2046,7 @@ const focusPrevious = state => {
   }
 };
 
-const commandIds = ['acceptEdit', 'cancelEdit', 'collapseAll', 'copyPath', 'copyRelativePath', 'dispose', 'expandAll', 'expandRecursively', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'getFocusedDirent', 'getMenuEntries2', 'handleArrowLeft', 'handleArrowLeft', 'handleArrowRight', 'handleArrowRight', 'handleBlur', 'handleClick', 'handleClickAt', 'handleClickCurrent', 'handleClickCurrentButKeepFocus', 'handleClickOpenFolder', 'handleContextMenu', 'handleContextMenuKeyboard', 'handleCopy', 'handleDragLeave', 'handleDragOver', 'handleDrop', 'handleFocus', 'handleIconThemeChange', 'handleLanguagesChanged', 'handleMouseEnter', 'handleMouseLeave', 'handlePaste', 'handlePointerDown', 'handleUpload', 'handleWheel', 'handleWorkspaceChange', 'hotReload', 'newFile', 'newFolder', 'openContainingFolder', 'refresh', 'refresh', 'removeDirent', 'rename', 'renameDirent', 'renderEventListeners', 'revealItem', 'revealItem', 'scrollDown', 'scrollUp', 'setDeltaY', 'updateEditingValue', 'updateIcons'];
+const commandIds = ['acceptEdit', 'cancelEdit', 'collapseAll', 'copyPath', 'copyRelativePath', 'dispose', 'expandAll', 'expandRecursively', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'getFocusedDirent', 'getMenuEntries2', 'getMouseActions', 'handleArrowLeft', 'handleArrowLeft', 'handleArrowRight', 'handleArrowRight', 'handleBlur', 'handleClick', 'handleClickAt', 'handleClickCurrent', 'handleClickCurrentButKeepFocus', 'handleClickOpenFolder', 'handleContextMenu', 'handleContextMenuKeyboard', 'handleCopy', 'handleDragLeave', 'handleDragOver', 'handleDrop', 'handleFocus', 'handleIconThemeChange', 'handleInputBlur', 'handleLanguagesChanged', 'handleMouseEnter', 'handleMouseLeave', 'handlePaste', 'handlePointerDown', 'handleUpload', 'handleWheel', 'handleWorkspaceChange', 'hotReload', 'newFile', 'newFolder', 'openContainingFolder', 'refresh', 'removeDirent', 'rename', 'renameDirent', 'renderEventListeners', 'revealItem', 'revealItem', 'scrollDown', 'scrollUp', 'selectAll', 'selectDown', 'selectUp', 'setDeltaY', 'setSelectedIndices', 'updateEditingValue', 'updateIcons'];
 
 const getCommandIds = () => {
   return commandIds;
@@ -1987,12 +2062,14 @@ const UpArrow = 14;
 const RightArrow = 15;
 const DownArrow = 16;
 const Delete = 18;
+const KeyA = 29;
 const KeyC = 31;
 const KeyV = 50;
 const F2 = 58;
 const Star = 131;
 
 const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
 const Alt = 1 << 9 >>> 0;
 
 const FocusExplorer = 13;
@@ -2000,6 +2077,14 @@ const FocusExplorerEditBox = 14;
 
 const getKeyBindings = () => {
   return [{
+    key: Shift | UpArrow,
+    command: 'Explorer.selectUp',
+    when: FocusExplorer
+  }, {
+    key: Shift | DownArrow,
+    command: 'Explorer.selectDown',
+    when: FocusExplorer
+  }, {
     key: RightArrow,
     command: 'Explorer.handleArrowRight',
     when: FocusExplorer
@@ -2045,7 +2130,7 @@ const getKeyBindings = () => {
     when: FocusExplorer
   }, {
     key: F2,
-    command: 'Explorer.rename',
+    command: 'Explorer.renameDirent',
     when: FocusExplorer
   }, {
     key: Escape,
@@ -2071,6 +2156,10 @@ const getKeyBindings = () => {
     key: Enter,
     command: 'Explorer.handleClickCurrent',
     when: FocusExplorer
+  }, {
+    key: CtrlCmd | KeyA,
+    command: 'Explorer.selectAll',
+    when: FocusExplorer
   }];
 };
 
@@ -2196,6 +2285,35 @@ const getMenuEntries2 = uid => {
   return getMenuEntries(newState);
 };
 
+const Keyboard = -1;
+const LeftClick = 0;
+
+const getMouseActions = () => {
+  return [{
+    description: 'Open file on click',
+    button: LeftClick,
+    modifiers: {},
+    command: 'Explorer.openFile',
+    when: FocusExplorer
+  }, {
+    description: 'Toggle selection with Ctrl+Click',
+    button: LeftClick,
+    modifiers: {
+      ctrl: true
+    },
+    command: 'Explorer.toggleSelection',
+    when: FocusExplorer
+  }, {
+    description: 'Select range with Shift+Click',
+    button: LeftClick,
+    modifiers: {
+      shift: true
+    },
+    command: 'Explorer.rangeSelection',
+    when: FocusExplorer
+  }];
+};
+
 const getParentStartIndex = (dirents, index) => {
   const dirent = dirents[index];
   let startIndex = index - 1;
@@ -2535,14 +2653,48 @@ const getIndexFromPosition = (state, eventX, eventY) => {
   return index;
 };
 
-const Keyboard = -1;
-const LeftClick = 0;
+/**
+ * Handles range selection in the explorer.
+ * @param state The current explorer state
+ * @param startIndex The starting index of the range (must be ≤ endIndex)
+ * @param endIndex The ending index of the range (must be ≥ startIndex)
+ * @throws Error if startIndex > endIndex
+ */
+const handleRangeSelection = (state, startIndex, endIndex) => {
+  if (startIndex > endIndex) {
+    throw new Error('startIndex must be less than or equal to endIndex');
+  }
+  const {
+    items
+  } = state;
+  const newItems = items.map((item, i) => ({
+    ...item,
+    selected: i >= startIndex && i <= endIndex ? true : item.selected
+  }));
+  return {
+    ...state,
+    items: newItems
+  };
+};
+
+const handleClickAtRangeSelection = async (state, index) => {
+  const firstSelectedIndex = state.items.findIndex(item => item.selected);
+  if (firstSelectedIndex === -1) {
+    return handleRangeSelection(state, index, index);
+  }
+  const min = Math.min(firstSelectedIndex, index);
+  const max = Math.min(firstSelectedIndex, index);
+  return handleRangeSelection(state, min, max);
+};
 
-const handleClickAt = (state, button, x, y) => {
+const handleClickAt = async (state, button, ctrlKey, shiftKey, x, y) => {
   if (button !== LeftClick) {
     return state;
   }
   const index = getIndexFromPosition(state, x, y);
+  if (shiftKey) {
+    return handleClickAtRangeSelection(state, index);
+  }
   return handleClick(state, index);
 };
 
@@ -2758,6 +2910,7 @@ const applyOperation = operation => {
   }
   return writeFile(operation.path, operation.text);
 };
+
 const applyFileOperations = async operations => {
   // TODO run operations in parallel if possible
   for (const operation of operations) {
@@ -3085,6 +3238,10 @@ const handleIconThemeChange = state => {
   return updateIcons(state);
 };
 
+const handleInputBlur = state => {
+  return cancelEdit(state);
+};
+
 // TODO add lots of tests for this
 const updateRoot = async state1 => {
   // @ts-ignore
@@ -3438,28 +3595,118 @@ const handleWorkspaceChange = async state => {
 
 const ExplorerEditBox = FocusExplorerEditBox;
 
+const getNewChildDirentsForNewDirent = async (items, depth, parentPath, direntType) => {
+  // Get existing children or query them if they don't exist
+  let existingChildren = items.filter(item => item.depth === depth && item.path.startsWith(parentPath));
+  if (existingChildren.length === 0) {
+    const childDirents = await readDirWithFileTypes(parentPath);
+    existingChildren = childDirents.map((dirent, index) => ({
+      name: dirent.name,
+      type: dirent.type,
+      path: `${parentPath}/${dirent.name}`,
+      depth,
+      selected: false,
+      posInSet: index + 1,
+      setSize: childDirents.length,
+      icon: ''
+    }));
+  }
+  const updatedChildren = existingChildren.map((child, index) => ({
+    ...child,
+    posInSet: index + 1,
+    setSize: existingChildren.length + 2
+  }));
+  const newDirent = {
+    name: '',
+    type: direntType,
+    path: parentPath,
+    depth,
+    selected: false,
+    posInSet: updatedChildren.length + 1,
+    setSize: existingChildren.length + 2,
+    icon: ''
+  };
+  const allChildDirents = [...updatedChildren, newDirent];
+  return allChildDirents;
+};
+
+const getNewDirentsForNewDirent = async (items, focusedIndex, type, root) => {
+  if (items.length === 0 || focusedIndex === -1) {
+    const newDirent = {
+      name: '',
+      type,
+      path: root,
+      depth: 0,
+      selected: false,
+      posInSet: 1,
+      setSize: 1,
+      icon: ''
+    };
+    return [...items, newDirent];
+  }
+  const focusedItem = items[focusedIndex];
+  if (!focusedItem) {
+    return items;
+  }
+  const parentPath = focusedItem.path;
+  const depth = focusedItem.depth + 1;
+  const updatedChildren = await getNewChildDirentsForNewDirent(items, depth, parentPath, type);
+
+  // Create new array with updated items
+  const parentIndex = focusedIndex;
+  const itemsBeforeParent = items.slice(0, parentIndex);
+  const itemsAfterChildren = items.slice(parentIndex + updatedChildren.length);
+  const updatedParent = {
+    ...items[parentIndex],
+    setSize: (items[parentIndex]?.setSize || 0) + 1
+  };
+  return [...itemsBeforeParent, updatedParent, ...updatedChildren, ...itemsAfterChildren];
+};
+
+const getNewDirentType = editingType => {
+  switch (editingType) {
+    case CreateFile:
+      return EditingFile;
+    case CreateFolder:
+      return EditingFolder;
+    default:
+      return File;
+  }
+};
+
 const newDirent = async (state, editingType) => {
   // TODO make focus functional instead of side effect
   await setFocus(ExplorerEditBox);
   // TODO do it like vscode, select position between folders and files
   const {
     focusedIndex,
-    items
+    items,
+    minLineY,
+    height,
+    itemHeight,
+    fileIconCache,
+    root
   } = state;
-  if (focusedIndex >= 0) {
-    const dirent = items[focusedIndex];
-    if (dirent.type === Directory) {
-      // TODO handle error
-      // @ts-ignore
-      await handleClickDirectory(state, dirent);
-    }
-  }
+  const direntType = getNewDirentType(editingType);
+  const newDirents = await getNewDirentsForNewDirent(items, focusedIndex, direntType, root);
+  const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, newDirents.length);
+  const visible = newDirents.slice(minLineY, maxLineY);
+  const {
+    icons,
+    newFileIconCache
+  } = await getFileIcons(visible, fileIconCache);
+  const editingIndex = newDirents.findIndex(item => item.type === EditingFile || item.type === EditingFolder);
   return {
     ...state,
-    editingIndex: focusedIndex,
+    items: newDirents,
+    editingIndex,
     editingType,
     editingValue: '',
-    focus: Input$1
+    focusedIndex: editingIndex,
+    focus: Input$1,
+    icons,
+    fileIconCache: newFileIconCache,
+    maxLineY
   };
 };
 
@@ -3563,26 +3810,44 @@ const removeDirent = async state => {
   };
 };
 
+const getNewDirentsForRename = (items, focusedIndex) => {
+  const item = items[focusedIndex];
+  const newItems = [...items];
+  const editingType = item.type === File ? EditingFile : EditingFolder;
+  newItems[focusedIndex] = {
+    ...item,
+    type: editingType
+  };
+  return newItems;
+};
+
+const User = 1;
+const Script = 2;
+
 const renameDirent = state => {
   const {
     focusedIndex,
     items
   } = state;
+  if (items.length === 0) {
+    return state;
+  }
   const item = items[focusedIndex];
+  const newItems = getNewDirentsForRename(items, focusedIndex);
   return {
     ...state,
+    items: newItems,
     editingIndex: focusedIndex,
     editingType: Rename$1,
     editingValue: item.name,
-    focus: Input$1
+    focus: Input$1,
+    inputSource: Script
   };
 };
 
 const ExplorerInput = 'ExplorerInput';
 
-const User = 1;
-
-const renderFocus = (oldState, newState) => {
+const renderFocus$1 = (oldState, newState) => {
   if (newState.inputSource === User) {
     return [];
   }
@@ -3598,6 +3863,16 @@ const renderFocus = (oldState, newState) => {
   return [];
 };
 
+const renderFocus = (oldState, newState) => {
+  if (newState.focus === Input$1) {
+    return ['Viewlet.setFocusContext', FocusExplorerEditBox];
+  }
+  if (newState.focus === List) {
+    return ['Viewlet.setFocusContext', FocusExplorer];
+  }
+  return [];
+};
+
 const None$2 = 'none';
 const ToolBar = 'toolbar';
 const Tree = 'tree';
@@ -3642,14 +3917,15 @@ const WelcomeMessage = 'WelcomeMessage';
 const HandleClick = 'handleClick';
 const HandleClickOpenFolder = 'handleClickOpenFolder';
 const HandleContextMenu = 'handleContextMenu';
+const HandleDragLeave = 'handleDragLeave';
+const HandleDragOver = 'handleDragOver';
+const HandleDrop = 'handleDrop';
 const HandleEditingInput = 'handleEditingInput';
+const HandleInputBlur = 'handleInputBlur';
 const HandleListBlur = 'handleListBlur';
 const HandleListFocus = 'handleListFocus';
 const HandlePointerDown = 'handlePointerDown';
 const HandleWheel = 'handleWheel';
-const HandleDragOver = 'handleDragOver';
-const HandleDrop = 'handleDrop';
-const HandleDragLeave = 'handleDragLeave';
 
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
@@ -3696,7 +3972,7 @@ const getFileIconVirtualDom = icon => {
   };
 };
 
-const getClassName$1 = hasEditingError => {
+const getClassName$2 = hasEditingError => {
   if (hasEditingError) {
     return mergeClassNames(InputBox, InputValidationError);
   }
@@ -3705,9 +3981,10 @@ const getClassName$1 = hasEditingError => {
 const getInputDom = hasEditingError => {
   return [{
     type: Input,
-    className: getClassName$1(hasEditingError),
+    className: getClassName$2(hasEditingError),
     id: 'ExplorerInput',
     onInput: HandleEditingInput,
+    onBlur: HandleInputBlur,
     childCount: 0,
     name: ExplorerInput
   }];
@@ -3789,7 +4066,7 @@ const getActiveDescendant = focusedIndex => {
   }
   return undefined;
 };
-const getClassName = (focused, focusedIndex, dropTarget) => {
+const getClassName$1 = (focused, focusedIndex, dropTarget) => {
   const extraClass1 = focused && focusedIndex === -1 ? FocusOutline : Empty;
   const extraClass2 = dropTarget === dropTargetFull ? ExplorerDropTarget : Empty;
   const className = mergeClassNames(ListItems, extraClass1, extraClass2);
@@ -3807,7 +4084,7 @@ const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused
   }
   const dom = [parentNode, {
     type: Div,
-    className: getClassName(focused, focusedIndex, dropTargets),
+    className: getClassName$1(focused, focusedIndex, dropTargets),
     tabIndex: 0,
     role: Tree,
     ariaLabel: filesExplorer(),
@@ -3879,26 +4156,40 @@ const getTreeItemIndentWithChevron = (depth, chevron) => {
 };
 
 const ariaExpandedValues = [undefined, 'true', 'false'];
-const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, editingErrorMessage, icons, useChevrons, dropTargets) => {
+const getClassName = (isSelected, isFocused) => {
+  if (isFocused) {
+    return mergeClassNames(TreeItem, TreeItemActive);
+  }
+  if (isSelected) {
+    return mergeClassNames(TreeItem, TreeItemActive);
+  }
+  return TreeItem;
+};
+const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, editingErrorMessage, icons, useChevrons, dropTargets, editingIcon) => {
   const visible = [];
   const indentFn = useChevrons ? getTreeItemIndentWithChevron : getTreeItemIndent;
   let iconIndex = 0;
   for (let i = minLineY; i < Math.min(maxLineY, items.length); i++) {
     const item = items[i];
-    const icon = icons[iconIndex++];
     const chevron = getChevronType(item.type, useChevrons);
     const indent = indentFn(item.depth, chevron);
     const isFocused = i === focusedIndex;
     const id = isFocused ? 'TreeItemActive' : undefined;
-    const className = isFocused ? mergeClassNames(TreeItem, TreeItemActive) : TreeItem;
+    const isSelected = item.selected;
+    const className = getClassName(isSelected, isFocused);
     const expanded = getExpandedType(item.type);
     const ariaExpanded = ariaExpandedValues[expanded];
-
-    // @ts-ignore
+    const isEditing = i === editingIndex;
+    let icon = icons[iconIndex++];
+    if (isEditing) {
+      icon = editingIcon;
+    }
     visible.push({
       ...item,
-      isEditing: i === editingIndex,
-      hasEditingError: i === editingIndex && Boolean(editingErrorMessage),
+      posInSet: item.posInSet ?? i + 1,
+      setSize: item.setSize ?? items.length,
+      isEditing: isEditing,
+      hasEditingError: isEditing && Boolean(editingErrorMessage),
       icon,
       indent,
       ariaExpanded,
@@ -3907,39 +4198,36 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
       className
     });
   }
-  if (editingType !== None$5 && editingIndex === -1) {
-    visible.push({
-      depth: 3,
-      posInSet: 1,
-      setSize: 1,
-      icon: '',
-      name: 'new',
-      path: '/test/new',
-      isEditing: true,
-      hasEditingError: Boolean(editingErrorMessage),
-      indent: '',
-      ariaExpanded: undefined,
-      chevron: 0,
-      id: undefined,
-      className: TreeItem
-    });
-  }
   return visible;
 };
 
 const renderItems = (oldState, newState) => {
-  const visibleDirents = getVisibleExplorerItems(newState.items, newState.minLineY, newState.maxLineY, newState.focusedIndex, newState.editingIndex, newState.editingType, newState.editingValue, newState.editingErrorMessage, newState.icons, newState.useChevrons);
+  const visibleDirents = getVisibleExplorerItems(newState.items, newState.minLineY, newState.maxLineY, newState.focusedIndex, newState.editingIndex, newState.editingType, newState.editingValue, newState.editingErrorMessage, newState.icons, newState.useChevrons, newState.dropTargets, newState.editingIcon);
   const isWide = newState.width > 450;
   const dom = getExplorerVirtualDom(visibleDirents, newState.focusedIndex, newState.root, isWide, newState.focused, newState.dropTargets);
   return ['Viewlet.setDom2', dom];
 };
 
+const renderValue = (oldState, newState) => {
+  if (newState.inputSource === User) {
+    return [];
+  }
+  if (newState.focus === Input$1) {
+    return ['Viewlet.setValueByName', ExplorerInput, newState.editingValue];
+  }
+  return [];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderItems:
       return renderItems;
     case RenderFocus:
+      return renderFocus$1;
+    case RenderFocusContext:
       return renderFocus;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -4054,8 +4342,8 @@ const renderActions = uid => {
 
 const renderEventListeners = () => {
   return [{
-    name: HandleListBlur,
-    params: ['handleBlur']
+    name: HandleInputBlur,
+    params: ['handleInputBlur']
   }, {
     name: HandleListFocus,
     params: ['handleFocus', 'event.isTrusted', 'event.target.className']
@@ -4064,7 +4352,7 @@ const renderEventListeners = () => {
     params: ['handleBlur']
   }, {
     name: HandleClick,
-    params: ['handleClickAt', 'event.button', 'event.clientX', 'event.clientY'],
+    params: ['handleClickAt', 'event.button', 'event.ctrlKey', 'event.shiftKey', 'event.clientX', 'event.clientY'],
     preventDefault: true
   }, {
     name: HandleClickOpenFolder,
@@ -4333,23 +4621,108 @@ const saveState = uid => {
   };
 };
 
+const selectAll = state => {
+  const {
+    items
+  } = state;
+  const newItems = items.map(item => ({
+    ...item,
+    selected: true
+  }));
+  return {
+    ...state,
+    items: newItems
+  };
+};
+
+const getLastSelectedIndex = items => {
+  let lastSelectedIndex = -1;
+  for (let index = 0; index < items.length; index++) {
+    if (items[index].selected) {
+      lastSelectedIndex = index;
+    }
+  }
+  return lastSelectedIndex;
+};
+const selectDown = state => {
+  const {
+    items,
+    focusedIndex
+  } = state;
+  const lastSelectedIndex = getLastSelectedIndex(items);
+  const targetIndex = lastSelectedIndex === -1 ? focusedIndex : lastSelectedIndex;
+  if (targetIndex >= items.length - 1) {
+    return state;
+  }
+  const newItems = items.map((item, i) => ({
+    ...item,
+    selected: i === targetIndex + 1 ? true : item.selected
+  }));
+  return {
+    ...state,
+    items: newItems,
+    focusedIndex: targetIndex + 1
+  };
+};
+
+const setSelectedIndices = (state, indices) => {
+  const {
+    items
+  } = state;
+  const newItems = items.map((item, i) => ({
+    ...item,
+    selected: indices.includes(i)
+  }));
+  return {
+    ...state,
+    items: newItems
+  };
+};
+
+const selectUp = state => {
+  const {
+    items,
+    focusedIndex
+  } = state;
+  const firstSelectedIndex = items.findIndex(item => item.selected);
+  const targetIndex = firstSelectedIndex === -1 ? focusedIndex : firstSelectedIndex;
+  if (targetIndex <= 0) {
+    return state;
+  }
+  const newItems = items.map((item, i) => ({
+    ...item,
+    selected: i === targetIndex - 1 ? true : item.selected
+  }));
+  return {
+    ...state,
+    items: newItems
+  };
+};
+
 const terminate = () => {
   globalThis.close();
 };
 
 const getEditingIcon = async (editingType, value) => {
-  if (editingType === File) {
+  if (editingType === CreateFile) {
     return invoke('IconTheme.getFileIcon', {
       name: value
     });
   }
-  if (editingType === Directory) {
+  // TODO need renamefile and renamefolder type
+  if (editingType === Rename$1) {
+    return invoke('IconTheme.getFileIcon', {
+      name: value
+    });
+  }
+  if (editingType === CreateFolder) {
     return invoke('IconTheme.getFolderIcon', {
       name: value
     });
   }
   return '';
 };
+
 const updateEditingValue = async (state, value, inputSource = User) => {
   const editingIcon = await getEditingIcon(state.editingType, value);
   return {
@@ -4375,10 +4748,10 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
-  'Explorer.getMenuEntries2': getMenuEntries2,
   'Explorer.acceptEdit': wrapCommand(acceptEdit),
   'Explorer.cancelEdit': wrapCommand(cancelEdit),
   'Explorer.collapseAll': wrapCommand(collapseAll),
+  'Explorer.handleInputBlur': wrapCommand(handleInputBlur),
   'Explorer.copyPath': wrapCommand(copyPath),
   'Explorer.copyRelativePath': wrapCommand(copyRelativePath),
   'Explorer.expandAll': wrapCommand(expandAll),
@@ -4387,8 +4760,11 @@ const commandMap = {
   'Explorer.focusIndex': wrapCommand(focusIndex),
   'Explorer.focusLast': wrapCommand(focusLast),
   'Explorer.focusNext': wrapCommand(focusNext),
+  'Explorer.focusNone': wrapCommand(focusNone),
   'Explorer.focusPrevious': wrapCommand(focusPrevious),
   'Explorer.getCommandIds': getCommandIds,
+  'Explorer.getMenuEntries2': getMenuEntries2,
+  'Explorer.getMouseActions': getMouseActions,
   'Explorer.handleArrowLeft': wrapCommand(handleArrowLeft),
   'Explorer.handleArrowRight': wrapCommand(handleArrowRight),
   'Explorer.handleBlur': wrapCommand(handleBlur),
@@ -4419,7 +4795,11 @@ const commandMap = {
   'Explorer.renameDirent': wrapCommand(renameDirent),
   'Explorer.restoreState': restoreState,
   'Explorer.revealItem': wrapCommand(revealItem),
+  'Explorer.selectAll': wrapCommand(selectAll),
+  'Explorer.selectDown': wrapCommand(selectDown),
+  'Explorer.selectUp': wrapCommand(selectUp),
   'Explorer.setDeltaY': wrapCommand(setDeltaY),
+  'Explorer.setSelectedIndices': wrapCommand(setSelectedIndices),
   'Explorer.updateEditingValue': wrapCommand(updateEditingValue),
   'Explorer.updateIcons': wrapCommand(updateIcons),
   // not wrapped