@lvce-editor/explorer-view 2.36.0 → 2.37.0

package/dist/explorerViewWorkerMain.js

@@ -932,6 +932,9 @@ const dirname = (pathSeparator, path) => {
   }
   return path.slice(0, index);
 };
+const dirname2 = path => {
+  return dirname('/', path);
+};
 const join = (pathSeparator, ...parts) => {
   return parts.join(pathSeparator);
 };
@@ -960,6 +963,21 @@ const createNewDirentsAccept = async (newFileName, pathSeparator, absolutePath,
   }
 };
 
+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;
@@ -1158,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)) {
@@ -1186,72 +1286,138 @@ 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 = (items, focusedIndex, editingValue, root, pathSeparator, newDirentType) => {
-  const newFileName = editingValue;
-  const parentFolder = getParentFolder(items, focusedIndex, root);
-  const absolutePath = [parentFolder, newFileName].join(pathSeparator);
-  const parentDirent = focusedIndex >= 0 ? 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 = focusedIndex;
-  let deltaPosInSet = 0;
-  let posInSet = 1;
-  let setSize = 1;
-  let i = Math.max(focusedIndex, -1) + 1;
-  // 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;
-  const newItems = [...items];
-  newItems.splice(insertIndex + 1, 0, newDirent);
+  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: newItems,
-    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) => {
@@ -1283,10 +1449,14 @@ const acceptCreate = async (state, newDirentType, createFn) => {
   if (!successful) {
     return state;
   }
-  const {
-    dirents,
-    newFocusedIndex
-  } = getNewDirentsAccept(items, focusedIndex, editingValue, root, pathSeparator, newDirentType);
+  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 {
@@ -1413,7 +1583,7 @@ const createNewDirentsRename = async (renamedDirent, editingValue, pathSeparator
   try {
     // TODO this does not work with rename of nested file
     const oldAbsolutePath = renamedDirent.path;
-    const oldParentPath = dirname(pathSeparator, oldAbsolutePath);
+    const oldParentPath = dirname2(oldAbsolutePath);
     const newAbsolutePath = join2(oldParentPath, editingValue);
     await rename$1(oldAbsolutePath, newAbsolutePath);
   } catch (error) {
@@ -1427,11 +1597,9 @@ const acceptRename = async state => {
   const {
     editingIndex,
     editingValue,
-    items,
-    pathSeparator
-  } = state;
+    items} = state;
   const renamedDirent = items[editingIndex];
-  const successful = await createNewDirentsRename(renamedDirent, editingValue, pathSeparator);
+  const successful = await createNewDirentsRename(renamedDirent, editingValue);
   if (!successful) {
     return state;
   }
@@ -1546,10 +1714,6 @@ const cancelTypeAhead = state => {
   };
 };
 
-const isTopLevel = dirent => {
-  return dirent.depth === 1;
-};
-
 const toCollapsedDirent = dirent => {
   if (dirent.type === DirectoryExpanded) {
     return {
@@ -1827,120 +1991,6 @@ const diff2 = uid => {
   return result;
 };
 
-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 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 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,
@@ -4847,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];
@@ -4889,29 +4923,6 @@ const mergeVisibleWithHiddenItems = (visibleItems, hiddenItems) => {
   return unique;
 };
 
-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 scrollInto = (index, minLineY, maxLineY) => {
   const diff = maxLineY - minLineY;
   const smallerHalf = Math.floor(diff / 2);
@@ -4934,11 +4945,6 @@ const scrollInto = (index, minLineY, maxLineY) => {
   };
 };
 
-const getPathPartChildren = async pathPart => {
-  const children = await getChildDirents(pathPart.pathSeparator, pathPart);
-  return children;
-};
-
 // TODO maybe just insert items into explorer and refresh whole explorer
 const revealItemHidden = async (state, uri) => {
   const {
@@ -4953,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.36.0",
+  "version": "2.37.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",