@lvce-editor/static-server 0.49.13 → 0.49.15

package/static/{df291da → b0358a2}/packages/explorer-worker/dist/explorerViewWorkerMain.js

@@ -1013,6 +1013,7 @@ const get$1 = id => {
 
 const invoke = (method, ...params) => {
   const rpc = get$1(RendererWorker);
+  // @ts-ignore
   return rpc.invoke(method, ...params);
 };
 
@@ -1288,7 +1289,42 @@ const ListItem = 22;
 const Slash = '/';
 
 // TODO parentUid might ot be needed
-const create = (id, uri, x, y, width, height, args, parentUid) => {
+const create2 = (uid, uri, x, y, width, height, args, parentUid, platform = 0) => {
+  const state = {
+    uid,
+    parentUid,
+    root: '',
+    items: [],
+    focusedIndex: -1,
+    focused: false,
+    hoverIndex: -1,
+    x,
+    y,
+    width,
+    height,
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    pathSeparator: Slash,
+    version: 0,
+    editingIndex: -1,
+    itemHeight: ListItem,
+    dropTargets: [],
+    excluded: [],
+    editingValue: '',
+    editingType: None$5,
+    editingIcon: '',
+    fileIconCache: Object.create(null),
+    useChevrons: false,
+    icons: [],
+    platform,
+    focus: 0
+  };
+  set(uid, state, state);
+};
+
+// TODO parentUid might ot be needed
+const create = (id, uri, x, y, width, height, args, parentUid, platform = 0) => {
   const state = {
     uid: id,
     parentUid,
@@ -1315,7 +1351,9 @@ const create = (id, uri, x, y, width, height, args, parentUid) => {
     editingIcon: '',
     fileIconCache: Object.create(null),
     useChevrons: false,
-    icons: []
+    icons: [],
+    platform,
+    focus: 0
   };
   set(state.uid, state, state);
   return state;
@@ -1349,7 +1387,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;
+  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;
 };
 
 const DiffItems = {
@@ -1760,6 +1798,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 {
@@ -1802,7 +1847,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', 'relealItem', '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;
@@ -1967,7 +2012,7 @@ const rename = () => {
 const deleteItem = () => {
   return i18nString(Delete);
 };
-const refresh = () => {
+const refresh$1 = () => {
   return i18nString(RefreshExplorer);
 };
 const collapseAll = () => {
@@ -2098,6 +2143,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;
@@ -2206,6 +2258,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;
@@ -2239,6 +2295,7 @@ const handleClickDirectory = async (state, dirent, index, keepFocus) => {
     icons,
     newFileIconCache
   } = await getFileIcons(parts, state.fileIconCache);
+  await setFocus(FocusExplorer);
   return {
     ...state,
     items: newDirents,
@@ -2443,6 +2500,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);
 };
@@ -2518,6 +2579,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;
@@ -2532,13 +2605,15 @@ const canBeDroppedInto = dirent => {
   }
 };
 
+const dropTargetFull = [-1];
+
 const getNewDropTargets = (state, x, y) => {
   const {
     items
   } = state;
   const index = getIndexFromPosition(state, x, y);
   if (index === -1) {
-    return [-1];
+    return dropTargetFull;
   }
   const item = items[index];
   if (!canBeDroppedInto(item)) {
@@ -2579,11 +2654,128 @@ 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$1(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.name;
+    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) => {
@@ -2591,18 +2783,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 {
@@ -2612,38 +2808,46 @@ 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.name;
+    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,
@@ -2652,16 +2856,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 = await 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) => {
@@ -2681,15 +2887,17 @@ 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;
-  for (const file of files) {
+  // @ts-ignore
+  for (const file of fileHandles) {
     // TODO path basename
-    const baseName = file;
+    const baseName = file.name;
     const to = dirent.path + pathSeparator + baseName;
+    // @ts-ignore
     await copy$1(file, to);
   }
   const childDirents = await getChildDirents(pathSeparator, dirent);
@@ -2701,18 +2909,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, index, files) => {
+const handleDropIndex = async (state, fileHandles, files, paths, index) => {
   const {
     items
   } = state;
@@ -2723,32 +2931,59 @@ const handleDropIndex = async (state, index, files) => {
   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;
   }
 };
 
-const handleDrop = async (state, x, y, files) => {
+const getDropHandler = index => {
+  switch (index) {
+    case -1:
+      return handleDropRoot;
+    default:
+      return handleDropIndex;
+  }
+};
+
+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);
-    switch (index) {
-      case -1:
-        return await handleDropRoot(state, files);
-      default:
-        return await handleDropIndex(state, index, files);
-    }
+    const fn = getDropHandler(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;
@@ -2785,39 +3020,21 @@ 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
   if (state1.disposed) {
     return 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
@@ -3095,15 +3312,18 @@ const getExcluded = () => {
   }
   return excluded;
 };
-const getSavedRoot$1 = (savedState, workspacePath) => {
+const getSavedRoot = (savedState, workspacePath) => {
   return workspacePath;
 };
 const loadContent = async (state, savedState) => {
+  const {
+    fileIconCache
+  } = state;
   const {
     useChevrons
   } = await getSettings();
   const workspacePath = await getWorkspacePath();
-  const root = getSavedRoot$1(savedState, workspacePath);
+  const root = getSavedRoot(savedState, workspacePath);
   // TODO path separator could be restored from saved state
   const pathSeparator = await getPathSeparator(root); // TODO only load path separator once
   const excluded = getExcluded();
@@ -3124,7 +3344,7 @@ const loadContent = async (state, savedState) => {
   const {
     icons,
     newFileIconCache
-  } = await getFileIcons(restoredDirents, Object.create(null));
+  } = await getFileIcons(restoredDirents, fileIconCache);
   return {
     ...state,
     root,
@@ -3306,6 +3526,8 @@ const ButtonPrimary = 'ButtonPrimary';
 const ButtonWide = 'ButtonWide';
 const Chevron = 'Chevron';
 const Explorer = 'Explorer';
+const Empty = '';
+const ExplorerDropTarget = 'DropTarget';
 const FileIcon = 'FileIcon';
 const FocusOutline = 'FocusOutline';
 const IconButton = 'IconButton';
@@ -3339,6 +3561,9 @@ 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(' ');
@@ -3469,25 +3694,33 @@ const getActiveDescendant = focusedIndex => {
   }
   return undefined;
 };
-const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused) => {
+const getClassName = (focused, focusedIndex, dropTarget) => {
+  const extraClass1 = focused && focusedIndex === -1 ? FocusOutline : Empty;
+  const extraClass2 = dropTarget === dropTargetFull ? ExplorerDropTarget : Empty;
+  const className = mergeClassNames(Viewlet, Explorer, extraClass1, extraClass2);
+  return className;
+};
+const getExplorerVirtualDom = (visibleItems, focusedIndex, root, isWide, focused, dropTargets) => {
   if (!root) {
     return getExplorerWelcomeVirtualDom(isWide);
   }
-  const extraClass = focused && focusedIndex === -1 ? FocusOutline : '';
   const dom = [{
     type: Div,
-    className: mergeClassNames(Viewlet, Explorer, extraClass),
+    className: getClassName(focused, focusedIndex, dropTargets),
     tabIndex: 0,
     role: Tree,
     ariaLabel: filesExplorer(),
     childCount: visibleItems.length,
     ariaActiveDescendant: getActiveDescendant(focusedIndex),
-    onFocus: HandleListFocus,
     onBlur: HandleListBlur,
+    onClick: HandleClick,
     onContextMenu: HandleContextMenu,
+    onDragLeave: HandleDragLeave,
+    onDragOver: HandleDragOver,
+    onDrop: HandleDrop,
+    onFocus: HandleListFocus,
     onPointerDown: HandlePointerDown,
-    onWheel: HandleWheel,
-    onClick: HandleClick
+    onWheel: HandleWheel
   }, ...visibleItems.flatMap(getExplorerItemVirtualDom)];
   return dom;
 };
@@ -3545,7 +3778,7 @@ const getTreeItemIndentWithChevron = (depth, chevron) => {
 };
 
 const ariaExpandedValues = [undefined, 'true', 'false'];
-const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, icons, useChevrons) => {
+const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue, icons, useChevrons, dropTargets) => {
   const visible = [];
   const indentFn = useChevrons ? getTreeItemIndentWithChevron : getTreeItemIndent;
   let iconIndex = 0;
@@ -3556,7 +3789,7 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
     const indent = indentFn(item.depth, chevron);
     const isFocused = i === focusedIndex;
     const id = isFocused ? 'TreeItemActive' : undefined;
-    const className = isFocused ? TreeItem + ' ' + TreeItemActive : TreeItem;
+    const className = isFocused ? mergeClassNames(TreeItem, TreeItemActive) : TreeItem;
     const expanded = getExpandedType(item.type);
     const ariaExpanded = ariaExpandedValues[expanded];
     visible.push({
@@ -3592,7 +3825,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 isWide = newState.width > 450;
-  const dom = getExplorerVirtualDom(visibleDirents, newState.focusedIndex, newState.root, isWide, newState.focused);
+  const dom = getExplorerVirtualDom(visibleDirents, newState.focusedIndex, newState.root, isWide, newState.focused, newState.dropTargets);
   return ['Viewlet.setDom2', dom];
 };
 
@@ -3654,7 +3887,7 @@ const getActions = root => {
     command: 'newFolder'
   }, {
     type: Button,
-    id: refresh(),
+    id: refresh$1(),
     icon: Refresh,
     command: 'refresh'
   }, {
@@ -3749,31 +3982,50 @@ const renderEventListeners = () => {
     name: HandleWheel,
     params: ['handleWheel', 'event.deltaMode', 'event.deltaY'],
     passive: true
+  }, {
+    name: HandleDragOver,
+    params: ['handleDragOver', 'event.clientX', 'event.clientY'],
+    preventDefault: true
+  }, {
+    name: HandleDrop,
+    params: ['handleDrop', 'event.clientX', 'event.clientY', 'event.dataTransfer.files2', 'event.dataTransfer.files'],
+    preventDefault: true
+  }, {
+    name: HandleDragLeave,
+    params: ['handleDragLeave']
   }];
 };
 
-const getSavedRoot = (savedState, workspacePath) => {
-  return workspacePath;
+const getSavedMinLineY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'minLineY' in savedState && typeof savedState.minLineY === 'number') {
+    return savedState.minLineY;
+  }
+  return 0;
+};
+const getSavedDeltaY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
+    return savedState.deltaY;
+  }
+  return 0;
+};
+const getSavedWorkspacePath = savedState => {
+  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
+    return savedState.workspacePath;
+  }
+  return '';
 };
-
 const restoreState = savedState => {
   if (!savedState) {
     return {
+      root: '',
       minLineY: 0,
       deltaY: 0
     };
   }
-  const root = getSavedRoot(savedState, savedState.workspacePath || '');
-  let minLineY = 0;
-  if (savedState && typeof savedState.minLineY === 'number') {
-    minLineY = savedState.minLineY;
-  }
-  let deltaY = 0;
-  if (savedState && typeof savedState.deltaY === 'number') {
-    deltaY = savedState.deltaY;
-  }
+  const root = getSavedWorkspacePath(savedState);
+  const minLineY = getSavedMinLineY(savedState);
+  const deltaY = getSavedDeltaY(savedState);
   return {
-    ...savedState,
     root,
     minLineY,
     deltaY
@@ -3866,8 +4118,8 @@ const getPathPartsToReveal = (root, pathParts, dirents) => {
   }
   return pathParts;
 };
-const getPathPartChildren = pathPart => {
-  const children = getChildDirents(pathPart.pathSeparator, pathPart);
+const getPathPartChildren = async pathPart => {
+  const children = await getChildDirents(pathPart.pathSeparator, pathPart);
   return children;
 };
 const mergeVisibleWithHiddenItems = (visibleItems, hiddenItems) => {
@@ -4060,6 +4312,7 @@ const wrapCommand = fn => {
 };
 
 const commandMap = {
+  'Explorer.getMenuEntries2': getMenuEntries2,
   'Explorer.acceptEdit': wrapCommand(acceptEdit),
   'Explorer.cancelEdit': wrapCommand(cancelEdit),
   'Explorer.collapseAll': wrapCommand(collapseAll$1),
@@ -4078,10 +4331,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),
@@ -4095,15 +4351,16 @@ 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': wrapCommand(restoreState),
+  'Explorer.restoreState': restoreState,
   'Explorer.revealItem': wrapCommand(revealItem),
   'Explorer.setDeltaY': wrapCommand(setDeltaY),
   'Explorer.updateEditingValue': wrapCommand(updateEditingValue),
   'Explorer.updateIcons': wrapCommand(updateIcons),
   // not wrapped
-  'Explorer.create': create,
+  'Explorer.create2': create2,
   'Explorer.diff2': diff2,
   'Explorer.getKeyBindings': getKeyBindings,
   'Explorer.getMenuEntries': getMenuEntries,
@@ -4111,7 +4368,9 @@ const commandMap = {
   'Explorer.renderActions2': renderActions,
   'Explorer.renderEventListeners': renderEventListeners,
   'Explorer.saveState': saveState,
-  'Explorer.terminate': terminate
+  'Explorer.terminate': terminate,
+  // deprecated
+  'Explorer.create': create
 };
 
 const listen = async () => {