@lvce-editor/explorer-view 2.35.0 → 2.37.0

package/dist/explorerViewWorkerMain.js

@@ -850,6 +850,134 @@ const WebWorkerRpcClient = {
   create: create$2
 };
 
+const rpcs = Object.create(null);
+const set$5 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+const RendererWorker$1 = 1;
+const invoke$2 = (method, ...params) => {
+  const rpc = get$1(RendererWorker$1);
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
+};
+const set$2 = rpc => {
+  set$5(RendererWorker$1, rpc);
+};
+const RendererWorker = {
+  __proto__: null,
+  invoke: invoke$2,
+  set: set$2
+};
+
+const {
+  invoke,
+  set: set$1
+} = RendererWorker;
+
+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$1 = async (oldUri, newUri) => {
+  return invoke('FileSystem.rename', oldUri, newUri);
+};
+const copy$1 = async (oldUri, newUri) => {
+  return invoke('FileSystem.copy', oldUri, newUri);
+};
+
+const createNestedPath = async (root, path, pathSeparator) => {
+  const parts = path.slice(root.length).split(pathSeparator);
+  let currentPath = '';
+  for (const part of parts) {
+    if (!part) continue;
+    currentPath = currentPath ? `${currentPath}${pathSeparator}${part}` : part;
+    try {
+      await mkdir(`${root}${currentPath}`);
+    } catch (error) {
+      // Ignore error if directory already exists
+      if (!(error instanceof Error && error.message.includes('already exists'))) {
+        throw error;
+      }
+    }
+  }
+};
+
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
+  }
+  return path.slice(0, index);
+};
+const dirname2 = path => {
+  return dirname('/', path);
+};
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+const getBaseName = (pathSeparator, path) => {
+  return path.slice(path.lastIndexOf(pathSeparator) + 1);
+};
+const join2 = (path, childPath) => {
+  if (path.endsWith('/')) {
+    return `${path}${childPath}`;
+  }
+  return `${path}/${childPath}`;
+};
+
+const createNewDirentsAccept = async (newFileName, pathSeparator, absolutePath, root, createFn) => {
+  try {
+    // Create parent directories if they don't exist
+    if (newFileName.includes(pathSeparator)) {
+      const parentPath = dirname(pathSeparator, absolutePath);
+      await createNestedPath(root, parentPath, pathSeparator);
+    }
+    await createFn(absolutePath);
+    return true;
+  } catch (error) {
+    console.error(new VError(error, `Failed to create file`));
+    return false;
+  }
+};
+
+const createTree = (items, root) => {
+  const tree = Object.create(null);
+  const rootLength = root.length;
+  for (const item of items) {
+    const relativePath = item.path.slice(rootLength);
+    const dirname = dirname2(relativePath);
+    tree[dirname] ||= [];
+    tree[dirname].push({
+      name: item.name,
+      type: item.type
+    });
+  }
+  return tree;
+};
+
 const None$5 = 0;
 const CreateFile = 1;
 const CreateFolder = 2;
@@ -901,7 +1029,7 @@ const openInIntegratedTerminal = () => {
 const cut = () => {
   return i18nString(Cut$1);
 };
-const copy$1 = () => {
+const copy = () => {
   return i18nString(Copy$1);
 };
 const paste = () => {
@@ -913,7 +1041,7 @@ const copyPath$1 = () => {
 const copyRelativePath$1 = () => {
   return i18nString(CopyRelativePath);
 };
-const rename$1 = () => {
+const rename = () => {
   return i18nString(Rename);
 };
 const deleteItem = () => {
@@ -982,33 +1110,6 @@ const getPaths = items => {
   return items.map(getPath);
 };
 
-const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-const RendererWorker$1 = 1;
-const invoke$2 = (method, ...params) => {
-  const rpc = get$1(RendererWorker$1);
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
-};
-const set$2 = rpc => {
-  set$5(RendererWorker$1, rpc);
-};
-const RendererWorker = {
-  __proto__: null,
-  invoke: invoke$2,
-  set: set$2
-};
-
-const {
-  invoke,
-  set: set$1
-} = RendererWorker;
-
 const DELTA_EDITING = 100;
 
 const BlockDevice = 1;
@@ -1075,6 +1176,88 @@ const getFileIcons = async (dirents, fileIconCache) => {
   };
 };
 
+const getParentFolder = (dirents, index, root) => {
+  if (index < 0) {
+    return root;
+  }
+  return dirents[index].path;
+};
+
+const getPathParts = (root, uri, pathSeparator) => {
+  const parts = [];
+  let index = root.length - 1;
+  let depth = 0;
+  while ((index = uri.indexOf('/', index + 1)) !== -1) {
+    const partUri = uri.slice(0, index);
+    parts.push({
+      path: partUri,
+      depth: depth++,
+      root,
+      pathSeparator
+    });
+  }
+  return parts;
+};
+
+const isSymbolicLink = dirent => {
+  return dirent.type === Symlink;
+};
+
+const hasSymbolicLinks = rawDirents => {
+  return rawDirents.some(isSymbolicLink);
+};
+
+const ENOENT = 'ENOENT';
+
+const getSymlinkType = type => {
+  switch (type) {
+    case File:
+      return SymLinkFile;
+    case Directory:
+      return SymLinkFolder;
+    default:
+      return Symlink;
+  }
+};
+
+// TODO maybe resolving of symbolic links should happen in shared process?
+// so that there is less code and less work in the frontend
+const resolveSymbolicLink = async (uri, rawDirent) => {
+  try {
+    // TODO support windows paths
+    const absolutePath = uri + '/' + rawDirent.name;
+    const type = await stat(absolutePath);
+    const symLinkType = getSymlinkType(type);
+    return {
+      name: rawDirent.name,
+      type: symLinkType
+    };
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.code === ENOENT) {
+      return {
+        name: rawDirent.name,
+        type: SymLinkFile
+      };
+    }
+    console.error(`Failed to resolve symbolic link for ${rawDirent.name}: ${error}`);
+    return rawDirent;
+  }
+};
+const resolveSymbolicLinks = async (uri, rawDirents) => {
+  const promises = [];
+  for (const rawDirent of rawDirents) {
+    if (isSymbolicLink(rawDirent)) {
+      const resolvedDirent = resolveSymbolicLink(uri, rawDirent);
+      promises.push(resolvedDirent);
+    } else {
+      promises.push(rawDirent);
+    }
+  }
+  const resolvedDirents = await Promise.all(promises);
+  return resolvedDirents;
+};
+
 const RE_CHARACTERS = /^[a-zA-Z.-]+$/;
 const compareStringNumeric = (a, b) => {
   if (RE_CHARACTERS.test(a) && RE_CHARACTERS.test(b)) {
@@ -1103,99 +1286,151 @@ const compareDirent = (direntA, direntB) => {
   return compareDirentType(direntA, direntB) || compareDirentName(direntA, direntB);
 };
 
-const getParentFolder = (dirents, index, root) => {
-  if (index < 0) {
-    return root;
-  }
-  return dirents[index].path;
+const sortExplorerItems = rawDirents => {
+  return rawDirents.toSorted(compareDirent);
 };
-const getNewDirentsAccept = async (state, newDirentType, createFn) => {
-  const {
-    focusedIndex,
-    editingValue
-  } = state;
-  const newFileName = editingValue;
-  const parentFolder = getParentFolder(state.items, focusedIndex, state.root);
-  const absolutePath = [parentFolder, newFileName].join(state.pathSeparator);
-  // TODO better handle error
-  try {
-    await createFn(absolutePath);
-  } catch (error) {
-    console.error(new VError(error, `Failed to create file`));
-    // TODO display error
-    return {
-      dirents: state.items,
-      newFocusedIndex: state.focusedIndex
-    };
-  }
-  const parentDirent = focusedIndex >= 0 ? state.items[focusedIndex] : {
-    depth: 0};
-  const depth = parentDirent.depth + 1;
-  const newDirent = {
-    path: absolutePath,
-    // @ts-ignore
-    posInSet: -1,
-    setSize: 1,
-    depth,
-    name: newFileName,
-    type: newDirentType,
+
+// TODO figure out whether this uses too much memory (name,path -> redundant, depth could be computed on demand)
+const toDisplayDirent = (parentDirent, rawDirent, index, length) => {
+  const path = join2(parentDirent.path, rawDirent.name);
+  return {
+    name: rawDirent.name,
+    posInSet: index + 1,
+    setSize: length,
+    depth: parentDirent.depth + 1,
+    type: rawDirent.type,
+    path,
+    // TODO storing absolute path might be too costly, could also store relative path here
     icon: '',
     selected: false
   };
-  // @ts-ignore
-  newDirent.icon = '';
-  let insertIndex = state.focusedIndex;
-  let deltaPosInSet = 0;
-  let posInSet = 1;
-  let setSize = 1;
-  let i = Math.max(state.focusedIndex, -1) + 1;
-  const {
-    items
-  } = state;
-  // TODO update posinset and setsize of all affected dirents
-  for (; i < items.length; i++) {
-    const dirent = items[i];
-    if (dirent.depth !== depth) {
-      break;
-    }
-    const compareResult = compareDirent(dirent, newDirent);
-    if (compareResult === 1) {
-      insertIndex = i - 1;
-      deltaPosInSet = 1 - 1;
-      break;
-    } else {
-      // @ts-ignore
-      posInSet = dirent.posInSet + 1;
-      // @ts-ignore
-      setSize = dirent.setSize + 1;
-      // @ts-ignore
-      insertIndex = i;
+};
+
+const toDisplayDirents = (pathSeparator, rawDirents, parentDirent, excluded) => {
+  rawDirents = sortExplorerItems(rawDirents);
+  const result = [];
+  const visibleItems = rawDirents.filter(item => {
+    if (excluded.includes(item.name)) {
+      return false;
     }
-    // @ts-ignore
-    dirent.setSize++;
-    // @ts-ignore
-    dirent.posInSet += deltaPosInSet;
+    return true;
+  });
+  const count = visibleItems.length;
+  for (let i = 0; i < visibleItems.length; i++) {
+    const rawDirent = visibleItems[i];
+    result.push(toDisplayDirent(parentDirent, rawDirent, i, count));
   }
-  // @ts-ignore
-  newDirent.setSize = setSize;
-  // @ts-ignore
-  newDirent.posInSet = posInSet;
-  // @ts-ignore
-  items.splice(insertIndex + 1, 0, newDirent);
-  const newDirents = [...items].filter(item => item.type !== EditingFile && item.type !== EditingFolder);
+  return result;
+};
+
+const getChildDirentsRaw = async uri => {
+  const rawDirents = await readDirWithFileTypes(uri);
+  array(rawDirents);
+  if (hasSymbolicLinks(rawDirents)) {
+    return resolveSymbolicLinks(uri, rawDirents);
+  }
+  return rawDirents;
+};
+const getChildDirents = async (pathSeparator, parentDirent, excluded = []) => {
+  string(pathSeparator);
+  object(parentDirent);
+  // TODO use event/actor based code instead, this is impossible to cancel right now
+  // also cancel updating when opening new folder
+  // const dispose = state => state.pendingRequests.forEach(cancelRequest)
+  // TODO should use FileSystem directly in this case because it is globally available anyway
+  // and more typesafe than Command.execute
+  // and more performant
+  const uri = parentDirent.path;
+  const rawDirents = await getChildDirentsRaw(uri);
+  const displayDirents = toDisplayDirents(pathSeparator, rawDirents, parentDirent, excluded);
+  return displayDirents;
+};
+
+const isTopLevel = dirent => {
+  return dirent.depth === 1;
+};
+
+const orderDirents = dirents => {
+  if (dirents.length === 0) {
+    return dirents;
+  }
+  const withDeepChildren = (parent, processed) => {
+    if (processed.has(parent.path)) {
+      return [];
+    }
+    processed.add(parent.path);
+    const children = [];
+    for (const dirent of dirents) {
+      if (dirent.depth === parent.depth + 1 && dirent.path.startsWith(parent.path)) {
+        children.push(...withDeepChildren(dirent, processed));
+      }
+    }
+    return [parent, ...children];
+  };
+  const topLevelDirents = dirents.filter(isTopLevel);
+  const processed = new Set();
+  const ordered = topLevelDirents.flatMap(dirent => withDeepChildren(dirent, processed));
+  return ordered;
+};
+
+const getPathPartChildren = async pathPart => {
+  const children = await getChildDirents(pathPart.pathSeparator, pathPart);
+  return children;
+};
+const getPathPartsChildren = async pathparts => {
+  const pathPartsChildren = await Promise.all(pathparts.map(getPathPartChildren));
+  const pathPartsChildrenFlat = pathPartsChildren.flat();
+  const orderedPathParts = orderDirents(pathPartsChildrenFlat);
+  return orderedPathParts;
+};
+
+const mergeTrees = (a, b) => {
   return {
-    dirents: newDirents,
-    newFocusedIndex: insertIndex + 1
+    ...a,
+    ...b
   };
 };
 
+const treeToArray = (map, root) => {
+  const items = [];
+  const processChildren = (path, depth) => {
+    const children = map[path];
+    if (!children) {
+      return;
+    }
+    const count = children.length;
+    for (let i = 0; i < count; i++) {
+      const child = children[i];
+      const childPath = join2(path, child.name);
+      const absolutePath = `${root}${childPath}`;
+      items.push({
+        depth,
+        posInSet: i + 1,
+        setSize: count,
+        icon: '',
+        path: absolutePath,
+        selected: false,
+        name: child.name,
+        type: child.type
+      });
+      processChildren(childPath, depth + 1);
+    }
+  };
+  processChildren('', 0);
+  return items;
+};
+
 const acceptCreate = async (state, newDirentType, createFn) => {
   const {
     editingValue,
     minLineY,
     height,
     itemHeight,
-    fileIconCache
+    fileIconCache,
+    pathSeparator,
+    root,
+    focusedIndex,
+    items
   } = state;
   const newFileName = editingValue;
   if (!newFileName) {
@@ -1208,10 +1443,20 @@ const acceptCreate = async (state, newDirentType, createFn) => {
       editingErrorMessage
     };
   }
-  const {
-    dirents,
-    newFocusedIndex
-  } = await getNewDirentsAccept(state, newDirentType, createFn);
+  const parentFolder = getParentFolder(items, focusedIndex, root);
+  const absolutePath = join2(parentFolder, newFileName);
+  const successful = await createNewDirentsAccept(newFileName, pathSeparator, absolutePath, root, createFn);
+  if (!successful) {
+    return state;
+  }
+  const pathPaths = getPathParts(root, absolutePath, pathSeparator);
+  const children = await getPathPartsChildren(pathPaths);
+  const tree = createTree(items, root);
+  const childTree = createTree(children, root);
+  const merged = mergeTrees(tree, childTree);
+  const newItems = treeToArray(merged, root);
+  const dirents = newItems;
+  const newFocusedIndex = newItems.findIndex(dirent => dirent.path === absolutePath);
   const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, dirents.length);
   const visible = dirents.slice(minLineY, maxLineY);
   const {
@@ -1231,37 +1476,6 @@ const acceptCreate = async (state, newDirentType, createFn) => {
   };
 };
 
-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);
 };
@@ -1365,42 +1579,28 @@ const computeExplorerRenamedDirent = (dirents, index, newName) => {
   };
 };
 
-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 join2 = (path, childPath) => {
-  if (path.endsWith('/')) {
-    return `${path}${childPath}`;
+const createNewDirentsRename = async (renamedDirent, editingValue, pathSeparator) => {
+  try {
+    // TODO this does not work with rename of nested file
+    const oldAbsolutePath = renamedDirent.path;
+    const oldParentPath = dirname2(oldAbsolutePath);
+    const newAbsolutePath = join2(oldParentPath, editingValue);
+    await rename$1(oldAbsolutePath, newAbsolutePath);
+  } catch (error) {
+    console.error(new VError(error, `Failed to rename file`));
+    return false;
   }
-  return `${path}/${childPath}`;
+  return true;
 };
 
 const acceptRename = async state => {
   const {
     editingIndex,
     editingValue,
-    items,
-    pathSeparator
-  } = state;
+    items} = state;
   const renamedDirent = items[editingIndex];
-  try {
-    // TODO this does not work with rename of nested file
-    const oldAbsolutePath = renamedDirent.path;
-    const oldParentPath = dirname(pathSeparator, oldAbsolutePath);
-    const newAbsolutePath = join2(oldParentPath, editingValue);
-    await rename(oldAbsolutePath, newAbsolutePath);
-  } catch (error) {
-    console.error(new VError(error, `Failed to rename file`));
+  const successful = await createNewDirentsRename(renamedDirent, editingValue);
+  if (!successful) {
     return state;
   }
   const {
@@ -1514,10 +1714,6 @@ const cancelTypeAhead = state => {
   };
 };
 
-const isTopLevel$1 = dirent => {
-  return dirent.depth === 1;
-};
-
 const toCollapsedDirent = dirent => {
   if (dirent.type === DirectoryExpanded) {
     return {
@@ -1532,7 +1728,7 @@ const collapseAll = state => {
   const {
     items
   } = state;
-  const newDirents = items.filter(isTopLevel$1).map(toCollapsedDirent);
+  const newDirents = items.filter(isTopLevel).map(toCollapsedDirent);
   return {
     ...state,
     items: newDirents
@@ -1795,119 +1991,6 @@ const diff2 = uid => {
   return result;
 };
 
-const isSymbolicLink = dirent => {
-  return dirent.type === Symlink;
-};
-
-const ENOENT = 'ENOENT';
-
-const getSymlinkType = type => {
-  switch (type) {
-    case File:
-      return SymLinkFile;
-    case Directory:
-      return SymLinkFolder;
-    default:
-      return Symlink;
-  }
-};
-
-// TODO maybe resolving of symbolic links should happen in shared process?
-// so that there is less code and less work in the frontend
-const resolveSymbolicLink = async (uri, rawDirent) => {
-  try {
-    // TODO support windows paths
-    const absolutePath = uri + '/' + rawDirent.name;
-    const type = await stat(absolutePath);
-    const symLinkType = getSymlinkType(type);
-    return {
-      name: rawDirent.name,
-      type: symLinkType
-    };
-  } catch (error) {
-    // @ts-ignore
-    if (error && error.code === ENOENT) {
-      return {
-        name: rawDirent.name,
-        type: SymLinkFile
-      };
-    }
-    console.error(`Failed to resolve symbolic link for ${rawDirent.name}: ${error}`);
-    return rawDirent;
-  }
-};
-const resolveSymbolicLinks = async (uri, rawDirents) => {
-  const promises = [];
-  for (const rawDirent of rawDirents) {
-    if (isSymbolicLink(rawDirent)) {
-      const resolvedDirent = resolveSymbolicLink(uri, rawDirent);
-      promises.push(resolvedDirent);
-    } else {
-      promises.push(rawDirent);
-    }
-  }
-  const resolvedDirents = await Promise.all(promises);
-  return resolvedDirents;
-};
-
-const sortExplorerItems = rawDirents => {
-  return rawDirents.toSorted(compareDirent);
-};
-
-const toDisplayDirents = (pathSeparator, rawDirents, parentDirent, excluded) => {
-  rawDirents = sortExplorerItems(rawDirents);
-  // TODO figure out whether this uses too much memory (name,path -> redundant, depth could be computed on demand)
-  const toDisplayDirent = (rawDirent, index) => {
-    const path = [parentDirent.path, rawDirent.name].join(pathSeparator);
-    return {
-      name: rawDirent.name,
-      posInSet: index + 1,
-      setSize: rawDirents.length,
-      depth: parentDirent.depth + 1,
-      type: rawDirent.type,
-      path,
-      // TODO storing absolute path might be too costly, could also store relative path here
-      icon: ''
-    };
-  };
-  const result = [];
-  let i = 0;
-  for (const rawDirent of rawDirents) {
-    if (excluded.includes(rawDirent.name)) {
-      continue;
-    }
-    result.push(toDisplayDirent(rawDirent, i));
-    i++;
-  }
-  return result;
-};
-
-const hasSymbolicLinks = rawDirents => {
-  return rawDirents.some(isSymbolicLink);
-};
-const getChildDirentsRaw = async uri => {
-  const rawDirents = await readDirWithFileTypes(uri);
-  array(rawDirents);
-  if (hasSymbolicLinks(rawDirents)) {
-    return resolveSymbolicLinks(uri, rawDirents);
-  }
-  return rawDirents;
-};
-const getChildDirents = async (pathSeparator, parentDirent, excluded = []) => {
-  string(pathSeparator);
-  object(parentDirent);
-  // TODO use event/actor based code instead, this is impossible to cancel right now
-  // also cancel updating when opening new folder
-  // const dispose = state => state.pendingRequests.forEach(cancelRequest)
-  // TODO should use FileSystem directly in this case because it is globally available anyway
-  // and more typesafe than Command.execute
-  // and more performant
-  const uri = parentDirent.path;
-  const rawDirents = await getChildDirentsRaw(uri);
-  const displayDirents = toDisplayDirents(pathSeparator, rawDirents, parentDirent, excluded);
-  return displayDirents;
-};
-
 const expandAll = async state => {
   const {
     items,
@@ -2348,7 +2431,7 @@ const menuEntryCut = {
 };
 const menuEntryCopy = {
   id: 'copy',
-  label: copy$1(),
+  label: copy(),
   flags: RestoreFocus,
   command: 'Explorer.handleCopy'
 };
@@ -2372,7 +2455,7 @@ const menuEntryCopyRelativePath = {
 };
 const menuEntryRename = {
   id: 'rename',
-  label: rename$1(),
+  label: rename(),
   flags: None$4,
   command: 'Explorer.renameDirent'
 };
@@ -3116,7 +3199,7 @@ const applyOperation = operation => {
     return mkdir(operation.path);
   }
   if (operation.type === 'copy') {
-    return copy(operation.from || '', operation.path);
+    return copy$1(operation.from || '', operation.path);
   }
   return writeFile(operation.path, operation.text);
 };
@@ -3330,7 +3413,7 @@ const handleDropIntoFolder = async (state, dirent, index, fileHandles, files, pa
     const baseName = file.name;
     const to = dirent.path + pathSeparator + baseName;
     // @ts-ignore
-    await copy(file, to);
+    await copy$1(file, to);
   }
   const childDirents = await getChildDirents(pathSeparator, dirent);
   const mergedDirents = getMergedDirents(items, index, dirent, childDirents);
@@ -3584,7 +3667,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(source, target);
+    await copy$1(source, target);
   }
   // TODO only update folder at which level it changed
   return updateRoot(state);
@@ -3593,7 +3676,7 @@ 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(source, target);
+    await rename$1(source, target);
   }
   return state;
 };
@@ -4814,22 +4897,6 @@ const getIndex = (dirents, uri) => {
   return -1;
 };
 
-const getPathParts = (root, uri, pathSeparator) => {
-  const parts = [];
-  let index = root.length - 1;
-  let depth = 0;
-  while ((index = uri.indexOf('/', index + 1)) !== -1) {
-    const partUri = uri.slice(0, index);
-    parts.push({
-      path: partUri,
-      depth: depth++,
-      root,
-      pathSeparator
-    });
-  }
-  return parts;
-};
-
 const getPathPartsToReveal = (root, pathParts, dirents) => {
   for (let i = 0; i < pathParts.length; i++) {
     const pathPart = pathParts[i];
@@ -4842,30 +4909,18 @@ const getPathPartsToReveal = (root, pathParts, dirents) => {
   return pathParts;
 };
 
-const isTopLevel = dirent => {
-  return dirent.depth === 1;
-};
-const orderDirents = dirents => {
-  if (dirents.length === 0) {
-    return dirents;
-  }
-  const withDeepChildren = (parent, processed) => {
-    if (processed.has(parent.path)) {
-      return [];
-    }
-    processed.add(parent.path);
-    const children = [];
-    for (const dirent of dirents) {
-      if (dirent.depth === parent.depth + 1 && dirent.path.startsWith(parent.path)) {
-        children.push(...withDeepChildren(dirent, processed));
-      }
+const mergeVisibleWithHiddenItems = (visibleItems, hiddenItems) => {
+  const merged = [...visibleItems, ...hiddenItems];
+  const seen = Object.create(null);
+  const unique = [];
+  for (const item of merged) {
+    if (seen[item.path]) {
+      continue;
     }
-    return [parent, ...children];
-  };
-  const topLevelDirents = dirents.filter(isTopLevel);
-  const processed = new Set();
-  const ordered = topLevelDirents.flatMap(dirent => withDeepChildren(dirent, processed));
-  return ordered;
+    seen[item.path] = true;
+    unique.push(item);
+  }
+  return unique;
 };
 
 const scrollInto = (index, minLineY, maxLineY) => {
@@ -4890,24 +4945,6 @@ const scrollInto = (index, minLineY, maxLineY) => {
   };
 };
 
-const getPathPartChildren = async pathPart => {
-  const children = await getChildDirents(pathPart.pathSeparator, pathPart);
-  return children;
-};
-const mergeVisibleWithHiddenItems = (visibleItems, hiddenItems) => {
-  const merged = [...visibleItems, ...hiddenItems];
-  const seen = Object.create(null);
-  const unique = [];
-  for (const item of merged) {
-    if (seen[item.path]) {
-      continue;
-    }
-    seen[item.path] = true;
-    unique.push(item);
-  }
-  return unique;
-};
-
 // TODO maybe just insert items into explorer and refresh whole explorer
 const revealItemHidden = async (state, uri) => {
   const {
@@ -4922,7 +4959,7 @@ const revealItemHidden = async (state, uri) => {
     return state;
   }
   const pathPartsToReveal = getPathPartsToReveal(root, pathParts, items);
-  const pathPartsChildren = await Promise.all(pathPartsToReveal.map(getPathPartChildren));
+  const pathPartsChildren = await getPathPartsChildren(pathPartsToReveal);
   const pathPartsChildrenFlat = pathPartsChildren.flat();
   const orderedPathParts = orderDirents(pathPartsChildrenFlat);
   const mergedDirents = mergeVisibleWithHiddenItems(items, orderedPathParts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/explorer-view",
-  "version": "2.35.0",
+  "version": "2.37.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",