@lvce-editor/static-server 0.49.14 → 0.49.16

package/static/{687c128 → bd3fe96}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -901,164 +901,91 @@ const compareDirent = (direntA, direntB) => {
   return compareDirentType(direntA, direntB) || compareDirentName(direntA, direntB);
 };
 
-// TODO use posInSet and setSize properties to compute more effectively
-const computeExplorerRenamedDirent = (dirents, index, newName) => {
-  let startIndex = index;
-  let innerEndIndex = index + 1;
-  let insertIndex = -1;
-  let posInSet = -1;
-  const oldDirent = dirents[index];
-  const newDirent = {
-    ...oldDirent,
-    name: newName,
-    path: oldDirent.path.slice(0, -oldDirent.name.length) + newName,
-    icon: ''
-  };
-  const {
-    depth
-  } = newDirent;
-  // TODO
-  for (; startIndex >= 0; startIndex--) {
-    const dirent = dirents[startIndex];
-    if (dirent.depth > depth) {
-      continue;
-    }
-    if (dirent.depth < depth) {
-      break;
-    }
-    if (compareDirent(dirent, newDirent) === 1) {
-      insertIndex = startIndex;
-      posInSet = dirent.posInSet;
-      // dirent.posInSet++
-    }
-  }
-  startIndex++;
-  for (; innerEndIndex < dirents.length; innerEndIndex++) {
-    const dirent = dirents[innerEndIndex];
-    if (dirent.depth <= depth) {
-      break;
-    }
-    dirent.path = newDirent.path + dirent.path.slice(oldDirent.path.length);
-  }
-  innerEndIndex--;
-  let endIndex = innerEndIndex + 1;
-  for (; endIndex < dirents.length; endIndex++) {
-    const dirent = dirents[endIndex];
-    if (dirent.depth > depth) {
-      continue;
-    }
-    if (dirent.depth < depth) {
-      break;
-    }
-    if (insertIndex === -1 && compareDirent(dirent, newDirent) === -1) {
-      for (; endIndex < dirents.length; endIndex++) {
-      }
-      insertIndex = endIndex;
-      posInSet = dirent.posInSet + 1;
-    }
-  }
-  endIndex--;
-  for (let j = startIndex; j < index; j++) {
-    const dirent = dirents[j];
-    if (dirent.depth === depth) {
-      dirent.posInSet++;
-    }
-  }
-  for (let j = index; j < endIndex; j++) {
-    const dirent = dirents[j];
-    if (dirent.depth === depth) {
-      dirent.posInSet--;
-    }
-  }
-
-  // for (let j = startIndex; j < index; j++) {
-  //   const dirent = dirents[j]
-  //   dirent.posInSet++
-  // }
-
-  if (insertIndex === -1) {
-    insertIndex = index;
-    return {
-      focusedIndex: index,
-      newDirents: [...dirents.slice(0, index), newDirent, ...dirents.slice(index + 1)]
-    };
-  }
-  newDirent.posInSet = posInSet;
-  const newDirents = [...dirents];
-  if (index < insertIndex) {
-    insertIndex--;
-  }
-  newDirents.splice(index, 1);
-  newDirents.splice(insertIndex, 0, newDirent);
-  return {
-    newDirents,
-    focusedIndex: insertIndex
-  };
-};
-
 const None$5 = 0;
 const CreateFile = 1;
 const CreateFolder = 2;
 const Rename$1 = 3;
 
-const RendererWorker = 1;
+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);
+};
 
-const rpcs = Object.create(null);
-const set$1 = (id, rpc) => {
-  rpcs[id] = rpc;
+const CollapseAllFoldersInExplorer = 'Collapse All Folders in Explorer';
+const Copy$1 = 'Copy';
+const CopyPath = 'Copy Path';
+const CopyRelativePath = 'Copy Relative Path';
+const Cut$1 = 'Cut';
+const Delete$1 = 'Delete';
+const FileOrFolderNameMustBeProvider = 'A file or folder name must be provided.';
+const FilesExplorer = 'Files Explorer';
+const NewFile$1 = 'New File...';
+const NewFolder$1 = 'New Folder...';
+const OpenContainingFolder = 'Open Containing Folder';
+const OpenFolder = 'Open folder';
+const OpenInIntegratedTerminal = 'Open in integrated Terminal';
+const Paste = 'Paste';
+const RefreshExplorer = 'Refresh Explorer';
+const Rename = 'Rename';
+const YouHaveNotYetOpenedAFolder = 'You have not yet opened a folder';
+
+const newFile$1 = () => {
+  return i18nString(NewFile$1);
 };
-const get$1 = id => {
-  return rpcs[id];
+const newFolder$1 = () => {
+  return i18nString(NewFolder$1);
 };
-
-const invoke = (method, ...params) => {
-  const rpc = get$1(RendererWorker);
-  return rpc.invoke(method, ...params);
+const openContainingFolder$1 = () => {
+  return i18nString(OpenContainingFolder);
 };
-
-const remove = async dirent => {
-  return invoke('FileSystem.remove', dirent);
+const openInIntegratedTerminal = () => {
+  return i18nString(OpenInIntegratedTerminal);
 };
-const readDirWithFileTypes = async uri => {
-  return invoke('FileSystem.readDirWithFileTypes', uri);
+const cut = () => {
+  return i18nString(Cut$1);
 };
-const getPathSeparator$1 = async root => {
-  return invoke('FileSystem.getPathSeparator', root);
+const copy$1 = () => {
+  return i18nString(Copy$1);
 };
-const getRealPath = async path => {
-  return invoke('FileSystem.getRealPath', path);
+const paste = () => {
+  return i18nString(Paste);
 };
-const stat = async dirent => {
-  return invoke('FileSystem.stat', dirent);
+const copyPath$1 = () => {
+  return i18nString(CopyPath);
 };
-const createFile = async uri => {
-  return invoke('FileSystem.createFile', uri);
+const copyRelativePath$1 = () => {
+  return i18nString(CopyRelativePath);
 };
-const writeFile = async (uri, content) => {
-  return invoke('FileSystem.writeFile', uri, content);
+const rename$1 = () => {
+  return i18nString(Rename);
 };
-const mkdir = async uri => {
-  return invoke('FileSystem.mkdir', uri);
+const deleteItem = () => {
+  return i18nString(Delete$1);
 };
-const rename$1 = async (oldUri, newUri) => {
-  return invoke('FileSystem.rename', oldUri, newUri);
+const refresh$1 = () => {
+  return i18nString(RefreshExplorer);
 };
-const copy$1 = async (oldUri, newUri) => {
-  return invoke('FileSystem.copy', oldUri, newUri);
+const collapseAll$1 = () => {
+  return i18nString(CollapseAllFoldersInExplorer);
 };
-
-const dirname = (pathSeparator, path) => {
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return path;
-  }
-  return path.slice(0, index);
+const filesExplorer = () => {
+  return i18nString(FilesExplorer);
 };
-const join = (pathSeparator, ...parts) => {
-  return parts.join(pathSeparator);
+const youHaveNotYetOpenedAFolder = () => {
+  return i18nString(YouHaveNotYetOpenedAFolder);
 };
-const getBaseName = (pathSeparator, path) => {
-  return path.slice(path.lastIndexOf(pathSeparator) + 1);
+const openFolder$1 = () => {
+  return i18nString(OpenFolder);
+};
+const fileOrFolderNameMustBeProvided = () => {
+  return i18nString(FileOrFolderNameMustBeProvider);
 };
 
 const getParentFolder = (dirents, index, root) => {
@@ -1077,14 +1004,19 @@ const acceptCreate = async (state, newDirentType, createFn) => {
     // TODO show error message that file name must not be empty
     // below input box
     // await ErrorHandling.showErrorDialog(new Error('file name must not be empty'))
-    return state;
+    const editingErrorMessage = fileOrFolderNameMustBeProvided();
+    return {
+      ...state,
+      editingErrorMessage
+    };
   }
   const parentFolder = getParentFolder(state.items, focusedIndex, state.root);
   const absolutePath = [parentFolder, newFileName].join(state.pathSeparator);
   // TODO better handle error
   try {
     await createFn(absolutePath);
-  } catch {
+  } catch (error) {
+    console.error(new VError(error, `Failed to create file`));
     // TODO display error
     return state;
   }
@@ -1133,21 +1065,186 @@ const acceptCreate = async (state, newDirentType, createFn) => {
     // @ts-ignore
     dirent.posInSet += deltaPosInSet;
   }
-  newDirent.setSize = setSize;
+  newDirent.setSize = setSize;
+  newDirent.posInSet = posInSet;
+  // @ts-ignore
+  items.splice(insertIndex + 1, 0, newDirent);
+  const newDirents = [...items];
+  const newMaxlineY = Math.max(state.maxLineY, newDirents.length);
+  return {
+    ...state,
+    items: newDirents,
+    editingIndex: -1,
+    focusedIndex: insertIndex + 1,
+    editingType: None$5,
+    maxLineY: newMaxlineY
+  };
+};
+
+const RendererWorker = 1;
+
+const rpcs = Object.create(null);
+const set$1 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+
+const invoke = (method, ...params) => {
+  const rpc = get$1(RendererWorker);
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
+};
+
+const remove = async dirent => {
+  return invoke('FileSystem.remove', dirent);
+};
+const readDirWithFileTypes = async uri => {
+  return invoke('FileSystem.readDirWithFileTypes', uri);
+};
+const getPathSeparator$1 = async root => {
+  return invoke('FileSystem.getPathSeparator', root);
+};
+const getRealPath = async path => {
+  return invoke('FileSystem.getRealPath', path);
+};
+const stat = async dirent => {
+  return invoke('FileSystem.stat', dirent);
+};
+const createFile = async uri => {
+  return invoke('FileSystem.writeFile', uri, '');
+};
+const writeFile = async (uri, content) => {
+  return invoke('FileSystem.writeFile', uri, content);
+};
+const mkdir = async uri => {
+  return invoke('FileSystem.mkdir', uri);
+};
+const rename = async (oldUri, newUri) => {
+  return invoke('FileSystem.rename', oldUri, newUri);
+};
+const copy = async (oldUri, newUri) => {
+  return invoke('FileSystem.copy', oldUri, newUri);
+};
+
+const acceptCreateFile = async state => {
+  return acceptCreate(state, File, createFile);
+};
+
+const acceptCreateFolder = async state => {
+  return acceptCreate(state, Directory, mkdir);
+};
+
+// TODO use posInSet and setSize properties to compute more effectively
+const computeExplorerRenamedDirent = (dirents, index, newName) => {
+  let startIndex = index;
+  let innerEndIndex = index + 1;
+  let insertIndex = -1;
+  let posInSet = -1;
+  const oldDirent = dirents[index];
+  const newDirent = {
+    ...oldDirent,
+    name: newName,
+    path: oldDirent.path.slice(0, -oldDirent.name.length) + newName,
+    icon: ''
+  };
+  const {
+    depth
+  } = newDirent;
+  // TODO
+  for (; startIndex >= 0; startIndex--) {
+    const dirent = dirents[startIndex];
+    if (dirent.depth > depth) {
+      continue;
+    }
+    if (dirent.depth < depth) {
+      break;
+    }
+    if (compareDirent(dirent, newDirent) === 1) {
+      insertIndex = startIndex;
+      posInSet = dirent.posInSet;
+      // dirent.posInSet++
+    }
+  }
+  startIndex++;
+  for (; innerEndIndex < dirents.length; innerEndIndex++) {
+    const dirent = dirents[innerEndIndex];
+    if (dirent.depth <= depth) {
+      break;
+    }
+    dirent.path = newDirent.path + dirent.path.slice(oldDirent.path.length);
+  }
+  innerEndIndex--;
+  let endIndex = innerEndIndex + 1;
+  for (; endIndex < dirents.length; endIndex++) {
+    const dirent = dirents[endIndex];
+    if (dirent.depth > depth) {
+      continue;
+    }
+    if (dirent.depth < depth) {
+      break;
+    }
+    if (insertIndex === -1 && compareDirent(dirent, newDirent) === -1) {
+      for (; endIndex < dirents.length; endIndex++) {
+      }
+      insertIndex = endIndex;
+      posInSet = dirent.posInSet + 1;
+    }
+  }
+  endIndex--;
+  for (let j = startIndex; j < index; j++) {
+    const dirent = dirents[j];
+    if (dirent.depth === depth) {
+      dirent.posInSet++;
+    }
+  }
+  for (let j = index; j < endIndex; j++) {
+    const dirent = dirents[j];
+    if (dirent.depth === depth) {
+      dirent.posInSet--;
+    }
+  }
+
+  // for (let j = startIndex; j < index; j++) {
+  //   const dirent = dirents[j]
+  //   dirent.posInSet++
+  // }
+
+  if (insertIndex === -1) {
+    insertIndex = index;
+    return {
+      focusedIndex: index,
+      newDirents: [...dirents.slice(0, index), newDirent, ...dirents.slice(index + 1)]
+    };
+  }
   newDirent.posInSet = posInSet;
-  // @ts-ignore
-  items.splice(insertIndex + 1, 0, newDirent);
-  const newDirents = [...items];
-  const newMaxlineY = Math.max(state.maxLineY, newDirents.length);
+  const newDirents = [...dirents];
+  if (index < insertIndex) {
+    insertIndex--;
+  }
+  newDirents.splice(index, 1);
+  newDirents.splice(insertIndex, 0, newDirent);
   return {
-    ...state,
-    items: newDirents,
-    editingIndex: -1,
-    focusedIndex: insertIndex + 1,
-    editingType: None$5,
-    maxLineY: newMaxlineY
+    newDirents,
+    focusedIndex: insertIndex
   };
 };
+
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
+  }
+  return path.slice(0, index);
+};
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+const getBaseName = (pathSeparator, path) => {
+  return path.slice(path.lastIndexOf(pathSeparator) + 1);
+};
+
 const acceptRename = async state => {
   const {
     editingIndex,
@@ -1161,7 +1258,7 @@ const acceptRename = async state => {
     const oldAbsolutePath = renamedDirent.path;
     const oldParentPath = dirname(pathSeparator, oldAbsolutePath);
     const newAbsolutePath = [oldParentPath, editingValue].join(pathSeparator);
-    await rename$1(oldAbsolutePath, newAbsolutePath);
+    await rename(oldAbsolutePath, newAbsolutePath);
   } catch {
     // TODO
     // await ErrorHandling.showErrorDialog(error)
@@ -1184,15 +1281,16 @@ const acceptRename = async state => {
     focused: true
   };
 };
+
 const acceptEdit = async state => {
   const {
     editingType
   } = state;
   switch (editingType) {
     case CreateFile:
-      return acceptCreate(state, File, createFile);
+      return acceptCreateFile(state);
     case CreateFolder:
-      return acceptCreate(state, Directory, mkdir);
+      return acceptCreateFolder(state);
     case Rename$1:
       return acceptRename(state);
     default:
@@ -1228,7 +1326,7 @@ const toCollapsedDirent = dirent => {
   return dirent;
 };
 
-const collapseAll$1 = state => {
+const collapseAll = state => {
   const {
     items
   } = state;
@@ -1249,7 +1347,7 @@ const getFocusedDirent$1 = state => {
   return dirent;
 };
 
-const copyPath$1 = async state => {
+const copyPath = async state => {
   // await Command.execute(RendererWorkerCommandType.ClipBoardWriteText, /* text */ path)
   return state;
 };
@@ -1264,7 +1362,7 @@ const writeNativeFiles = async (type, files) => {
   return invoke('ClipBoard.writeNativeFiles', type, files);
 };
 
-const copyRelativePath$1 = async state => {
+const copyRelativePath = async state => {
   const dirent = getFocusedDirent$1(state);
   const relativePath = dirent.path.slice(1);
   // TODO handle error
@@ -1316,7 +1414,9 @@ const create2 = (uid, uri, x, y, width, height, args, parentUid, platform = 0) =
     fileIconCache: Object.create(null),
     useChevrons: false,
     icons: [],
-    platform
+    platform,
+    focus: 0,
+    editingErrorMessage: ''
   };
   set(uid, state, state);
 };
@@ -1350,7 +1450,9 @@ const create = (id, uri, x, y, width, height, args, parentUid, platform = 0) =>
     fileIconCache: Object.create(null),
     useChevrons: false,
     icons: [],
-    platform
+    platform,
+    focus: 0,
+    editingErrorMessage: ''
   };
   set(state.uid, state, state);
   return state;
@@ -1373,7 +1475,7 @@ const DiffEditingIndex = {
 
 const diffType$1 = RenderFocus;
 const isEqual$2 = (oldState, newState) => {
-  return oldState.focused === newState.focused;
+  return oldState.focused === newState.focused && oldState.focus === newState.focus;
 };
 
 const DiffFocus = {
@@ -1384,7 +1486,7 @@ const DiffFocus = {
 
 const diffType = RenderItems;
 const isEqual$1 = (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.width === newState.width && oldState.focused === newState.focused && oldState.dropTargets === newState.dropTargets;
+  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 DiffItems = {
@@ -1795,6 +1897,13 @@ const focusFirst = state => {
 const lastIndex = array => {
   return array.length - 1;
 };
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
+};
 
 const focusLast = state => {
   const {
@@ -1837,7 +1946,7 @@ const focusPrevious = state => {
   }
 };
 
-const commandIds = ['acceptEdit', 'cancelEdit', 'collapseAll', 'copyPath', 'copyRelativePath', 'expandAll', 'expandRecursively', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'getFocusedDirent', 'handleArrowLeft', 'handleArrowLeft', 'handleArrowRight', 'handleArrowRight', 'handleBlur', 'handleClick', 'handleClickAt', 'handleClickCurrent', 'handleClickCurrentButKeepFocus', 'handleClickOpenFolder', 'handleContextMenu', 'handleCopy', 'handleDragOver', 'handleDrop', 'handleFocus', 'handleIconThemeChange', 'handleLanguagesChanged', 'handleMouseEnter', 'handleMouseLeave', 'handlePaste', 'handlePointerDown', 'handleUpload', 'handleWheel', 'handleWorkspaceChange', 'hotReload', 'newFile', 'newFolder', 'openContainingFolder', 'refresh', 'refresh', 'revealItem', 'removeDirent', 'rename', 'renameDirent', 'revealItem', 'scrollDown', 'scrollUp', 'setDeltaY', 'renderEventListeners', 'updateEditingValue', 'updateIcons'];
+const commandIds = ['getMenuEntries2', 'acceptEdit', 'cancelEdit', 'collapseAll', 'copyPath', 'copyRelativePath', 'expandAll', 'expandRecursively', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'getFocusedDirent', '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 getCommandIds = () => {
   return commandIds;
@@ -1852,7 +1961,7 @@ const LeftArrow = 13;
 const UpArrow = 14;
 const RightArrow = 15;
 const DownArrow = 16;
-const Delete$1 = 18;
+const Delete = 18;
 const KeyC = 31;
 const KeyV = 50;
 const F2 = 58;
@@ -1922,7 +2031,7 @@ const getKeyBindings = () => {
     command: 'Explorer.acceptEdit',
     when: FocusExplorerEditBox
   }, {
-    key: Delete$1,
+    key: Delete,
     command: 'Explorer.removeDirent',
     when: FocusExplorer
   }, {
@@ -1940,84 +2049,6 @@ const getKeyBindings = () => {
   }];
 };
 
-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);
-};
-
-const NewFile$1 = 'New File...';
-const NewFolder$1 = 'New Folder...';
-const OpenContainingFolder = 'Open Containing Folder';
-const OpenInIntegratedTerminal = 'Open in integrated Terminal';
-const Cut$1 = 'Cut';
-const Copy$1 = 'Copy';
-const Paste = 'Paste';
-const CopyPath = 'Copy Path';
-const CopyRelativePath = 'Copy Relative Path';
-const Rename = 'Rename';
-const Delete = 'Delete';
-const RefreshExplorer = 'Refresh Explorer';
-const CollapseAllFoldersInExplorer = 'Collapse All Folders in Explorer';
-const FilesExplorer = 'Files Explorer';
-const YouHaveNotYetOpenedAFolder = 'You have not yet opened a folder';
-const OpenFolder = 'Open folder';
-
-const newFile$1 = () => {
-  return i18nString(NewFile$1);
-};
-const newFolder$1 = () => {
-  return i18nString(NewFolder$1);
-};
-const openContainingFolder$1 = () => {
-  return i18nString(OpenContainingFolder);
-};
-const openInIntegratedTerminal = () => {
-  return i18nString(OpenInIntegratedTerminal);
-};
-const cut = () => {
-  return i18nString(Cut$1);
-};
-const copy = () => {
-  return i18nString(Copy$1);
-};
-const paste = () => {
-  return i18nString(Paste);
-};
-const copyPath = () => {
-  return i18nString(CopyPath);
-};
-const copyRelativePath = () => {
-  return i18nString(CopyRelativePath);
-};
-const rename = () => {
-  return i18nString(Rename);
-};
-const deleteItem = () => {
-  return i18nString(Delete);
-};
-const refresh = () => {
-  return i18nString(RefreshExplorer);
-};
-const collapseAll = () => {
-  return i18nString(CollapseAllFoldersInExplorer);
-};
-const filesExplorer = () => {
-  return i18nString(FilesExplorer);
-};
-const youHaveNotYetOpenedAFolder = () => {
-  return i18nString(YouHaveNotYetOpenedAFolder);
-};
-const openFolder$1 = () => {
-  return i18nString(OpenFolder);
-};
-
 const Separator = 1;
 const None$4 = 0;
 const RestoreFocus = 6;
@@ -2061,7 +2092,7 @@ const menuEntryCut = {
 };
 const menuEntryCopy = {
   id: 'copy',
-  label: copy(),
+  label: copy$1(),
   flags: RestoreFocus,
   command: 'Explorer.handleCopy'
 };
@@ -2073,19 +2104,19 @@ const menuEntryPaste = {
 };
 const menuEntryCopyPath = {
   id: 'copyPath',
-  label: copyPath(),
+  label: copyPath$1(),
   flags: RestoreFocus,
   command: 'Explorer.copyPath'
 };
 const menuEntryCopyRelativePath = {
   id: 'copyRelativePath',
-  label: copyRelativePath(),
+  label: copyRelativePath$1(),
   flags: RestoreFocus,
   command: 'Explorer.copyRelativePath'
 };
 const menuEntryRename = {
   id: 'rename',
-  label: rename(),
+  label: rename$1(),
   flags: None$4,
   command: 'Explorer.renameDirent'
 };
@@ -2133,6 +2164,13 @@ const getMenuEntries = state => {
   }
 };
 
+const getMenuEntries2 = uid => {
+  const {
+    newState
+  } = get(uid);
+  return getMenuEntries(newState);
+};
+
 const getParentStartIndex = (dirents, index) => {
   const dirent = dirents[index];
   let startIndex = index - 1;
@@ -2241,6 +2279,10 @@ const handleArrowRightDirectoryExpanded = (state, dirent) => {
   return state;
 };
 
+const setFocus = key => {
+  return invoke('Focus.setFocus', key);
+};
+
 const handleClickDirectory = async (state, dirent, index, keepFocus) => {
   // @ts-ignore
   dirent.type = DirectoryExpanding;
@@ -2274,6 +2316,7 @@ const handleClickDirectory = async (state, dirent, index, keepFocus) => {
     icons,
     newFileIconCache
   } = await getFileIcons(parts, state.fileIconCache);
+  await setFocus(FocusExplorer);
   return {
     ...state,
     items: newDirents,
@@ -2478,6 +2521,10 @@ const handleClickAt = (state, button, x, y) => {
   return handleClick(state, index);
 };
 
+const handleClickCurrent = state => {
+  return handleClick(state, state.focusedIndex - state.minLineY, /* keepFocus */false);
+};
+
 const handleClickCurrentButKeepFocus = state => {
   return handleClick(state, state.focusedIndex - state.minLineY, /* keepFocus */true);
 };
@@ -2543,7 +2590,7 @@ const handleCopy = async state => {
   // TODO if not file is selected, what happens?
   const dirent = getFocusedDirent$1(state);
   if (!dirent) {
-    console.info('[ViewletExplorer/handleCopy] no dirent selected');
+    console.error('[ViewletExplorer/handleCopy] no dirent selected');
     return state;
   }
   const absolutePath = dirent.path;
@@ -2553,6 +2600,18 @@ const handleCopy = async state => {
   return state;
 };
 
+const handleDragLeave = state => {
+  return state;
+  // const { dropTargets } = state
+  // if (dropTargets.length === 0) {
+  //   return state
+  // }
+  // return {
+  //   ...state,
+  //   dropTargets: [],
+  // }
+};
+
 const canBeDroppedInto = dirent => {
   if (!dirent) {
     return false;
@@ -2616,11 +2675,130 @@ const handleDragOver = (state, x, y) => {
   };
 };
 
-const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) => {
-  // TODO send to renderer worker
+const getTopLevelDirents = (root, pathSeparator, excluded) => {
+  if (!root) {
+    return [];
+  }
+  return getChildDirents(pathSeparator, {
+    depth: 0,
+    path: root,
+    type: Directory
+  }, excluded);
 };
 
 const mergeDirents$2 = (oldDirents, newDirents) => {
+  const merged = [];
+  for (const newDirent of newDirents) {
+    merged.push(newDirent);
+  }
+  return merged;
+};
+
+// TODO add lots of tests for this
+const refresh = async state1 => {
+  const topLevelDirents = await getTopLevelDirents(state1.root, state1.pathSeparator, []);
+  const newDirents = mergeDirents$2(state1.items, topLevelDirents);
+  const state3 = {
+    ...state1,
+    items: newDirents
+  };
+  return state3;
+};
+
+const applyOperation = operation => {
+  if (operation.type === 'createFolder') {
+    return mkdir(operation.path);
+  }
+  if (operation.type === 'copy') {
+    return copy(operation.from || '', operation.path);
+  }
+  return writeFile(operation.path, operation.text);
+};
+const applyFileOperations = async operations => {
+  // TODO run operations in parallel if possible
+  for (const operation of operations) {
+    await applyOperation(operation);
+  }
+};
+
+const getChildHandles = async fileHandle => {
+  // @ts-ignore
+  const values = fileHandle.values();
+  const children = await fromAsync(values);
+  return children;
+};
+
+const getFileHandleText = async fileHandle => {
+  const file = await fileHandle.getFile();
+  const text = await file.text();
+  return text;
+};
+
+const isDirectoryHandle = fileHandle => {
+  return fileHandle.kind === 'directory';
+};
+
+const isFileHandle = fileHandle => {
+  return fileHandle.kind === 'file';
+};
+
+const createUploadTree = async (root, fileHandles) => {
+  const uploadTree = Object.create(null);
+  for (const fileHandle of fileHandles) {
+    const {
+      name
+    } = fileHandle;
+    if (isDirectoryHandle(fileHandle)) {
+      const children = await getChildHandles(fileHandle);
+      const childTree = await createUploadTree(name, children);
+      uploadTree[name] = childTree;
+    } else if (isFileHandle(fileHandle)) {
+      const text = await getFileHandleText(fileHandle);
+      uploadTree[name] = text;
+    }
+  }
+  return uploadTree;
+};
+
+const getFileOperations = (root, uploadTree) => {
+  const operations = [];
+  const processTree = (tree, currentPath) => {
+    for (const [path, value] of Object.entries(tree)) {
+      const fullPath = currentPath ? `${currentPath}/${path}` : path;
+      if (typeof value === 'object') {
+        operations.push({
+          type: 'createFolder',
+          path: `${root}/${fullPath}`,
+          text: ''
+        });
+        processTree(value, fullPath);
+      } else if (typeof value === 'string') {
+        operations.push({
+          type: 'createFile',
+          path: `${root}/${fullPath}`,
+          text: value
+        });
+      }
+    }
+  };
+  processTree(uploadTree, '');
+  return operations;
+};
+
+const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) => {
+  const uploadTree = await createUploadTree(root, fileSystemHandles);
+  const fileOperations = getFileOperations(root, uploadTree);
+  await applyFileOperations(fileOperations);
+
+  // TODO
+  // 1. in electron, use webutils.getPathForFile to see if a path is available
+  // 2. else, walk all files and folders recursively and upload all of them (if there are many, show a progress bar)
+
+  // TODO send file system operations to renderer worker
+  return true;
+};
+
+const mergeDirents$1 = (oldDirents, newDirents) => {
   return newDirents;
 };
 const getMergedDirents$2 = async (root, pathSeparator, dirents) => {
@@ -2628,18 +2806,22 @@ const getMergedDirents$2 = async (root, pathSeparator, dirents) => {
     path: root,
     depth: 0
   });
-  const mergedDirents = mergeDirents$2(dirents, childDirents);
+  const mergedDirents = mergeDirents$1(dirents, childDirents);
   return mergedDirents;
 };
-const handleDrop$2 = async (state, files) => {
+const handleDrop$2 = async (state, fileHandles, files) => {
   const {
     root,
     pathSeparator,
     items
   } = state;
-  const handled = await uploadFileSystemHandles();
+  const handled = await uploadFileSystemHandles(root, pathSeparator, fileHandles);
   if (handled) {
-    return state;
+    const updated = await refresh(state);
+    return {
+      ...updated,
+      dropTargets: []
+    };
   }
   const mergedDirents = await getMergedDirents$2(root, pathSeparator, items);
   return {
@@ -2649,38 +2831,48 @@ const handleDrop$2 = async (state, files) => {
   };
 };
 
-const getFilePathElectron = async file => {
-  return invoke('GetFilePathElectron.getFilePathElectron', file);
+const getFileOperationsElectron = async (root, paths, fileHandles) => {
+  const operations = [];
+  for (let i = 0; i < paths.length; i++) {
+    const fileHandle = fileHandles[i];
+    const {
+      name
+    } = fileHandle;
+    const path = paths[i];
+    operations.push({
+      type: 'copy',
+      path: `${root}/${name}`,
+      text: '',
+      from: path
+    });
+  }
+  return operations;
 };
 
-const mergeDirents$1 = (oldDirents, newDirents) => {
-  return newDirents;
+// TODO copy files in parallel
+const copyFilesElectron = async (root, pathSeparator, fileHandles, files, paths) => {
+  const operations = await getFileOperationsElectron(root, paths, fileHandles);
+  await applyFileOperations(operations);
 };
 
-// TODO copy files in parallel
-const copyFilesElectron = async (root, pathSeparator, files) => {
-  for (const file of files) {
-    const from = await getFilePathElectron(file);
-    // const from = file.path
-    const to = join(pathSeparator, root, file.name);
-    await copy$1(from, to);
-  }
+const mergeDirents = (oldDirents, newDirents) => {
+  return newDirents;
 };
 const getMergedDirents$1 = async (root, pathSeparator, dirents) => {
   const childDirents = await getChildDirents(pathSeparator, {
     path: root,
     depth: 0
   });
-  const mergedDirents = mergeDirents$1(dirents, childDirents);
+  const mergedDirents = mergeDirents(dirents, childDirents);
   return mergedDirents;
 };
-const handleDrop$1 = async (state, files) => {
+const handleDrop$1 = async (state, fileHandles, files, paths) => {
   const {
     root,
     pathSeparator,
     items
   } = state;
-  await copyFilesElectron(root, pathSeparator, files);
+  await copyFilesElectron(root, pathSeparator, fileHandles, files, paths);
   const mergedDirents = await getMergedDirents$1(root, pathSeparator, items);
   return {
     ...state,
@@ -2689,16 +2881,18 @@ const handleDrop$1 = async (state, files) => {
   };
 };
 
+const Electron = 2;
+
 const getModule = isElectron => {
   if (isElectron) {
     return handleDrop$1;
   }
   return handleDrop$2;
 };
-const handleDropRoot = async (state, files) => {
-  // @ts-ignore
-  const fn = getModule(state.isElectron);
-  return fn(state, files);
+const handleDropRoot = async (state, fileHandles, files, paths) => {
+  const isElectron = state.platform === Electron;
+  const fn = getModule(isElectron);
+  return fn(state, fileHandles, files, paths);
 };
 
 const getEndIndex = (items, index, dirent) => {
@@ -2718,17 +2912,18 @@ const getMergedDirents = (items, index, dirent, childDirents) => {
   }, ...childDirents, ...items.slice(endIndex)];
   return mergedDirents;
 };
-const handleDropIntoFolder = async (state, dirent, index, files) => {
+const handleDropIntoFolder = async (state, dirent, index, fileHandles, files, paths) => {
   const {
     pathSeparator,
     items
   } = state;
   // @ts-ignore
-  for (const file of files) {
+  for (const file of fileHandles) {
     // TODO path basename
-    const baseName = file;
+    const baseName = file.name;
     const to = dirent.path + pathSeparator + baseName;
-    await copy$1(file, to);
+    // @ts-ignore
+    await copy(file, to);
   }
   const childDirents = await getChildDirents(pathSeparator, dirent);
   const mergedDirents = getMergedDirents(items, index, dirent, childDirents);
@@ -2739,18 +2934,18 @@ const handleDropIntoFolder = async (state, dirent, index, files) => {
     dropTargets: []
   };
 };
-const handleDropIntoFile = (state, dirent, index, files) => {
+const handleDropIntoFile = (state, dirent, index, fileHandles, files, paths) => {
   const {
     items
   } = state;
   const parentIndex = getParentStartIndex(items, index);
   if (parentIndex === -1) {
-    return handleDropRoot(state, files);
+    return handleDropRoot(state, fileHandles, files, paths);
   }
   // @ts-ignore
   return handleDropIndex(parentIndex);
 };
-const handleDropIndex = async (state, files, index) => {
+const handleDropIndex = async (state, fileHandles, files, paths, index) => {
   const {
     items
   } = state;
@@ -2761,9 +2956,9 @@ const handleDropIndex = async (state, files, index) => {
   switch (dirent.type) {
     case Directory:
     case DirectoryExpanded:
-      return handleDropIntoFolder(state, dirent, index, files);
+      return handleDropIntoFolder(state, dirent, index, fileHandles);
     case File:
-      return handleDropIntoFile(state, dirent, index, files);
+      return handleDropIntoFile(state, dirent, index, fileHandles, files, paths);
     default:
       return state;
   }
@@ -2777,21 +2972,43 @@ const getDropHandler = index => {
       return handleDropIndex;
   }
 };
-const handleDrop = async (state, x, y, files) => {
+
+const getFileHandles = async fileIds => {
+  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+
+const getFilePathElectron = async file => {
+  return invoke('FileSystemHandle.getFilePathElectron', file);
+};
+
+const getFilepath = async file => {
+  return getFilePathElectron(file);
+};
+const getFilePaths = async (files, platform) => {
+  if (platform !== Electron) {
+    return files.map(file => '');
+  }
+  const promises = files.map(getFilepath);
+  const paths = await Promise.all(promises);
+  return paths;
+};
+
+const handleDrop = async (state, x, y, fileIds, fileList) => {
   try {
+    // @ts-ignore
+    const files = [...fileList];
+    const fileHandles = await getFileHandles(fileIds);
+    const paths = await getFilePaths(files, state.platform);
     const index = getIndexFromPosition(state, x, y);
     const fn = getDropHandler(index);
-    const result = await fn(state, files, index);
+    const result = await fn(state, fileHandles, files, paths, index);
     return result;
   } catch (error) {
     throw new VError(error, 'Failed to drop files');
   }
 };
 
-const setFocus = key => {
-  return invoke('Focus.setFocus', key);
-};
-
 const handleFocus = async state => {
   await setFocus(FocusExplorer);
   return state;
@@ -2828,25 +3045,6 @@ const handleIconThemeChange = state => {
   return updateIcons(state);
 };
 
-const getTopLevelDirents = (root, pathSeparator, excluded) => {
-  if (!root) {
-    return [];
-  }
-  return getChildDirents(pathSeparator, {
-    depth: 0,
-    path: root,
-    type: Directory
-  }, excluded);
-};
-
-const mergeDirents = (oldDirents, newDirents) => {
-  const merged = [];
-  for (const newDirent of newDirents) {
-    merged.push(newDirent);
-  }
-  return merged;
-};
-
 // TODO add lots of tests for this
 const updateRoot = async state1 => {
   // @ts-ignore
@@ -2855,13 +3053,13 @@ const updateRoot = async state1 => {
   }
   // const file = nativeFiles.files[0]
   // @ts-ignore
-  const topLevelDirents = await getTopLevelDirents(state1.root, state1.pathSeparator);
+  const topLevelDirents = await getTopLevelDirents(state1.root, state1.pathSeparator, []);
   // const state2 = Viewlet.getState('Explorer')
   // // TODO what if root changes while reading directories?
   // if (state2.disposed || state2.root !== state1.root) {
   //   return state2
   // }
-  const newDirents = mergeDirents(state1.items, topLevelDirents);
+  const newDirents = mergeDirents$2(state1.items, topLevelDirents);
   const state3 = {
     ...state1,
     items: newDirents
@@ -2878,7 +3076,7 @@ const handlePasteCopy = async (state, nativeFiles) => {
   for (const source of nativeFiles.files) {
     // @ts-ignore
     const target = join(state.pathSeperator, state.root, getBaseName(state.pathSeparator, source));
-    await copy$1(source, target);
+    await copy(source, target);
   }
   // TODO only update folder at which level it changed
   return updateRoot(state);
@@ -2887,13 +3085,13 @@ const handlePasteCopy = async (state, nativeFiles) => {
 const handlePasteCut = async (state, nativeFiles) => {
   for (const source of nativeFiles.files) {
     const target = `${state.root}${state.pathSeparator}${getBaseName(state.pathSeparator, source)}`;
-    await rename$1(source, target);
+    await rename(source, target);
   }
   return state;
 };
 
 const handlePasteNone = async (state, nativeFiles) => {
-  console.info('[ViewletExplorer/handlePaste] no paths detected');
+  console.error('[ViewletExplorer/handlePaste] no paths detected');
   return state;
 };
 
@@ -3197,6 +3395,8 @@ const handleWorkspaceChange = async state => {
   return newState;
 };
 
+const Input$1 = 2;
+
 const ExplorerEditBox = FocusExplorerEditBox;
 
 const newDirent = async (state, editingType) => {
@@ -3219,7 +3419,8 @@ const newDirent = async (state, editingType) => {
     ...state,
     editingIndex: focusedIndex,
     editingType,
-    editingValue: ''
+    editingValue: '',
+    focus: Input$1
   };
 };
 
@@ -3334,7 +3535,12 @@ const renderEditingIndex = (oldState, newState) => {
   return ['focusInput', 'ExplorerInput'];
 };
 
+const ExplorerInput = 'ExplorerInput';
+
 const renderFocus = (oldState, newState) => {
+  if (newState.focus === Input$1) {
+    return ['Viewlet.focusElementByName', ExplorerInput];
+  }
   // TODO
   // 1. when focused, focus the outer list element
   // 2. when focused, set focus context in renderer worker
@@ -3352,13 +3558,14 @@ const ButtonNarrow = 'ButtonNarrow';
 const ButtonPrimary = 'ButtonPrimary';
 const ButtonWide = 'ButtonWide';
 const Chevron = 'Chevron';
-const Explorer = 'Explorer';
 const Empty = '';
+const Explorer = 'Explorer';
 const ExplorerDropTarget = 'DropTarget';
 const FileIcon = 'FileIcon';
 const FocusOutline = 'FocusOutline';
 const IconButton = 'IconButton';
 const InputBox = 'InputBox';
+const InputValidationError = 'InputValidationError';
 const Label = 'Label';
 const MaskIconChevronDown = 'MaskIconChevronDown';
 const MaskIconChevronRight = 'MaskIconChevronRight';
@@ -3390,6 +3597,7 @@ const HandlePointerDown = 'handlePointerDown';
 const HandleWheel = 'handleWheel';
 const HandleDragOver = 'handleDragOver';
 const HandleDrop = 'handleDrop';
+const HandleDragLeave = 'handleDragLeave';
 
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
@@ -3436,18 +3644,22 @@ const getFileIconVirtualDom = icon => {
   };
 };
 
-const ExplorerInput = 'ExplorerInput';
-
 const label = {
   type: Div,
   className: Label,
   childCount: 1
 };
-const getInputOrLabelDom = (isEditing, name) => {
+const getClassName$1 = hasEditingError => {
+  if (hasEditingError) {
+    return mergeClassNames(InputBox, InputValidationError);
+  }
+  return InputBox;
+};
+const getInputOrLabelDom = (isEditing, hasEditingError, name) => {
   if (isEditing) {
     return [{
       type: Input,
-      className: InputBox,
+      className: getClassName$1(hasEditingError),
       id: 'ExplorerInput',
       onInput: HandleEditingInput,
       childCount: 0,
@@ -3470,7 +3682,8 @@ const getExplorerItemVirtualDom = item => {
     id,
     className,
     isEditing,
-    ariaExpanded
+    ariaExpanded,
+    hasEditingError
   } = item;
   const chevronDom = getChevronVirtualDom(chevron);
   const dom = [{
@@ -3488,7 +3701,7 @@ const getExplorerItemVirtualDom = item => {
     ariaExpanded,
     ariaDescription: '',
     id
-  }, ...chevronDom, getFileIconVirtualDom(icon), ...getInputOrLabelDom(isEditing, name)];
+  }, ...chevronDom, getFileIconVirtualDom(icon), ...getInputOrLabelDom(isEditing, hasEditingError, name)];
   return dom;
 };
 
@@ -3541,6 +3754,7 @@ const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused
     onBlur: HandleListBlur,
     onClick: HandleClick,
     onContextMenu: HandleContextMenu,
+    onDragLeave: HandleDragLeave,
     onDragOver: HandleDragOver,
     onDrop: HandleDrop,
     onFocus: HandleListFocus,
@@ -3603,7 +3817,7 @@ const getTreeItemIndentWithChevron = (depth, chevron) => {
 };
 
 const ariaExpandedValues = [undefined, 'true', 'false'];
-const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, icons, useChevrons, dropTargets) => {
+const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, editingErrorMessage, icons, useChevrons, dropTargets) => {
   const visible = [];
   const indentFn = useChevrons ? getTreeItemIndentWithChevron : getTreeItemIndent;
   let iconIndex = 0;
@@ -3620,6 +3834,7 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
     visible.push({
       ...item,
       isEditing: i === editingIndex,
+      hasEditingError: i === editingIndex && Boolean(editingErrorMessage),
       icon,
       indent,
       ariaExpanded,
@@ -3637,6 +3852,7 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
       name: 'new',
       path: '/test/new',
       isEditing: true,
+      hasEditingError: Boolean(editingErrorMessage),
       indent: '',
       ariaExpanded: undefined,
       chevron: 0,
@@ -3648,7 +3864,7 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
 };
 
 const renderItems = (oldState, newState) => {
-  const visibleDirents = getVisibleExplorerItems(newState.items, newState.minLineY, newState.maxLineY, newState.focusedIndex, newState.editingIndex, newState.editingType, newState.editingValue, 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);
   const isWide = newState.width > 450;
   const dom = getExplorerVirtualDom(visibleDirents, newState.focusedIndex, newState.root, isWide, newState.focused, newState.dropTargets);
   return ['Viewlet.setDom2', dom];
@@ -3712,12 +3928,12 @@ const getActions = root => {
     command: 'newFolder'
   }, {
     type: Button,
-    id: refresh(),
+    id: refresh$1(),
     icon: Refresh,
     command: 'refresh'
   }, {
     type: Button,
-    id: collapseAll(),
+    id: collapseAll$1(),
     icon: CollapseAll,
     command: 'collapseAll'
   }];
@@ -3813,8 +4029,11 @@ const renderEventListeners = () => {
     preventDefault: true
   }, {
     name: HandleDrop,
-    params: ['handleDrop', 'event.clientX', 'event.clientY', 'event.dataTransfer.files'],
+    params: ['handleDrop', 'event.clientX', 'event.clientY', 'event.dataTransfer.files2', 'event.dataTransfer.files'],
     preventDefault: true
+  }, {
+    name: HandleDragLeave,
+    params: ['handleDragLeave']
   }];
 };
 
@@ -4087,7 +4306,9 @@ const isExpandedDirectory = dirent => {
 const saveState = uid => {
   number(uid);
   const value = get(uid);
-  const newState = value.newState;
+  const {
+    newState
+  } = value;
   const {
     items,
     root,
@@ -4134,11 +4355,12 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
+  'Explorer.getMenuEntries2': getMenuEntries2,
   'Explorer.acceptEdit': wrapCommand(acceptEdit),
   'Explorer.cancelEdit': wrapCommand(cancelEdit),
-  'Explorer.collapseAll': wrapCommand(collapseAll$1),
-  'Explorer.copyPath': wrapCommand(copyPath$1),
-  'Explorer.copyRelativePath': wrapCommand(copyRelativePath$1),
+  'Explorer.collapseAll': wrapCommand(collapseAll),
+  'Explorer.copyPath': wrapCommand(copyPath),
+  'Explorer.copyRelativePath': wrapCommand(copyRelativePath),
   'Explorer.expandAll': wrapCommand(expandAll),
   'Explorer.expandRecursively': wrapCommand(expandRecursively),
   'Explorer.focusFirst': wrapCommand(focusFirst),
@@ -4152,10 +4374,13 @@ const commandMap = {
   'Explorer.handleBlur': wrapCommand(handleBlur),
   'Explorer.handleClick': wrapCommand(handleClick),
   'Explorer.handleClickAt': wrapCommand(handleClickAt),
+  'Explorer.handleClickCurrent': wrapCommand(handleClickCurrent),
   'Explorer.handleClickCurrentButKeepFocus': wrapCommand(handleClickCurrentButKeepFocus),
   'Explorer.handleClickOpenFolder': wrapCommand(handleClickOpenFolder),
   'Explorer.handleContextMenu': wrapCommand(handleContextMenu),
+  'Explorer.handleContextMenuKeyboard': wrapCommand(handleContextMenuKeyboard),
   'Explorer.handleCopy': wrapCommand(handleCopy),
+  'Explorer.handleDragLeave': wrapCommand(handleDragLeave),
   'Explorer.handleDragOver': wrapCommand(handleDragOver),
   'Explorer.handleDrop': wrapCommand(handleDrop),
   'Explorer.handleFocus': wrapCommand(handleFocus),
@@ -4169,6 +4394,7 @@ const commandMap = {
   'Explorer.newFile': wrapCommand(newFile),
   'Explorer.newFolder': wrapCommand(newFolder),
   'Explorer.openContainingFolder': wrapCommand(openContainingFolder),
+  'Explorer.refresh': wrapCommand(refresh),
   'Explorer.removeDirent': wrapCommand(removeDirent),
   'Explorer.renameDirent': wrapCommand(renameDirent),
   'Explorer.restoreState': restoreState,