@lvce-editor/explorer-view 1.2.0 → 1.3.0

package/dist/explorerViewWorkerMain.js

@@ -943,7 +943,7 @@ const computeExplorerRenamedDirent = (dirents, index, newName) => {
   };
 };
 
-const None$1 = 0;
+const None$2 = 0;
 const CreateFile = 1;
 const CreateFolder = 2;
 const Rename = 3;
@@ -955,7 +955,7 @@ const getRealPath = async path => {};
 const stat = async dirent => {};
 const createFile = async uri => {};
 const mkdir = async uri => {};
-const rename = async (oldUri, newUri) => {};
+const rename$1 = async (oldUri, newUri) => {};
 
 class AssertionError extends Error {
   constructor(message) {
@@ -1097,7 +1097,7 @@ const acceptCreate = async (state, newDirentType, createFn) => {
     items: newDirents,
     editingIndex: -1,
     focusedIndex: insertIndex + 1,
-    editingType: None$1,
+    editingType: None$2,
     maxLineY: newMaxlineY
   };
 };
@@ -1114,7 +1114,7 @@ const acceptRename = async state => {
     const oldAbsolutePath = renamedDirent.path;
     const oldParentPath = dirname(pathSeparator, oldAbsolutePath);
     const newAbsolutePath = [oldParentPath, editingValue].join(pathSeparator);
-    await rename(oldAbsolutePath, newAbsolutePath);
+    await rename$1(oldAbsolutePath, newAbsolutePath);
   } catch (error) {
     // TODO
     // await ErrorHandling.showErrorDialog(error)
@@ -1130,7 +1130,7 @@ const acceptRename = async state => {
     ...state,
     editingIndex: -1,
     editingValue: '',
-    editingType: None$1,
+    editingType: None$2,
     editingIcon: '',
     focusedIndex,
     focused: true
@@ -1152,77 +1152,51 @@ const acceptEdit = state => {
   }
 };
 
-const ENOENT = 'ENOENT';
-
-const sortExplorerItems = rawDirents => {
-  rawDirents.sort(compareDirent);
+const getFocusedDirent$1 = state => {
+  const {
+    focusedIndex,
+    minLineY,
+    items
+  } = state;
+  const dirent = items[focusedIndex + minLineY];
+  return dirent;
 };
 
-const toDisplayDirents = (pathSeparator, rawDirents, parentDirent, excluded) => {
-  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: getIcon()
-    };
-  };
-  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 copyPath$1 = async state => {
+  // await Command.execute(RendererWorkerCommandType.ClipBoardWriteText, /* text */ path)
+  return state;
 };
 
-const getIndexFromPosition = (state, eventX, eventY) => {
-  const {
-    y,
-    itemHeight,
-    items
-  } = state;
-  const index = Math.floor((eventY - y) / itemHeight);
-  if (index < 0) {
-    return 0;
-  }
-  if (index >= items.length) {
-    return -1;
-  }
-  return index;
+const state = {
+  rpc: undefined
 };
-const getParentStartIndex = (dirents, index) => {
-  const dirent = dirents[index];
-  let startIndex = index - 1;
-  while (startIndex >= 0 && dirents[startIndex].depth >= dirent.depth) {
-    startIndex--;
-  }
-  return startIndex;
+const invoke = (method, ...params) => {
+  const rpc = state.rpc;
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
 };
-const getParentEndIndex = (dirents, index) => {
-  const dirent = dirents[index];
-  let endIndex = index + 1;
-  while (endIndex < dirents.length && dirents[endIndex].depth > dirent.depth) {
-    endIndex++;
-  }
-  return endIndex;
+const setRpc = rpc => {
+  state.rpc = rpc;
 };
+
+const writeText = async text => {
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+
+const copyRelativePath$1 = async state => {
+  const dirent = getFocusedDirent$1(state);
+  const relativePath = dirent.path.slice(1);
+  // TODO handle error
+  await writeText(relativePath);
+  return state;
+};
+
 const isSymbolicLink = dirent => {
   return dirent.type === Symlink;
 };
-const hasSymbolicLinks = rawDirents => {
-  return rawDirents.some(isSymbolicLink);
-};
+
+const ENOENT = 'ENOENT';
+
 const getSymlinkType = type => {
   switch (type) {
     case File:
@@ -1233,6 +1207,7 @@ const getSymlinkType = type => {
       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) => {
@@ -1270,6 +1245,42 @@ const resolveSymbolicLinks = async (uri, rawDirents) => {
   const resolvedDirents = await Promise.all(promises);
   return resolvedDirents;
 };
+
+const sortExplorerItems = rawDirents => {
+  rawDirents.sort(compareDirent);
+};
+
+const toDisplayDirents = (pathSeparator, rawDirents, parentDirent, excluded) => {
+  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: getIcon()
+    };
+  };
+  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();
   array(rawDirents);
@@ -1347,6 +1358,85 @@ const expandAll = async state => {
   };
 };
 
+const getParentEndIndex = (dirents, index) => {
+  const dirent = dirents[index];
+  let endIndex = index + 1;
+  while (endIndex < dirents.length && dirents[endIndex].depth > dirent.depth) {
+    endIndex++;
+  }
+  return endIndex;
+};
+
+const makeExpanded = dirent => {
+  if (dirent.type === Directory) {
+    return {
+      ...dirent,
+      type: DirectoryExpanded
+    };
+  }
+  return dirent;
+};
+const expandRecursively = async state => {
+  const {
+    items,
+    focusedIndex,
+    pathSeparator,
+    root,
+    height,
+    itemHeight,
+    minLineY
+  } = state;
+  const dirent = focusedIndex < 0 ? {
+    type: Directory,
+    path: root,
+    depth: 0
+  } : items[focusedIndex];
+  if (dirent.type !== Directory && dirent.type !== DirectoryExpanding && dirent.type !== DirectoryExpanded) {
+    return state;
+  }
+  // TODO this is very inefficient
+  const getChildDirentsRecursively = async dirent => {
+    switch (dirent.type) {
+      case File:
+        return [dirent];
+      case Directory:
+      case DirectoryExpanding:
+      case DirectoryExpanded:
+        const childDirents = await getChildDirents(pathSeparator, dirent);
+        const all = [makeExpanded(dirent)];
+        for (const childDirent of childDirents) {
+          const childAll = await getChildDirentsRecursively(childDirent);
+          all.push(...childAll);
+        }
+        return all;
+      default:
+        return [];
+    }
+  };
+  // TODO race condition: what if folder is being collapse while it is recursively expanding?
+  // TODO race condition: what if folder is being deleted while it is recursively expanding?
+  // TODO race condition: what if a new file/folder is created while the folder is recursively expanding?
+  const childDirents = await getChildDirentsRecursively(dirent);
+  const startIndex = focusedIndex;
+  if (focusedIndex >= 0) {
+    const endIndex = getParentEndIndex(items, focusedIndex);
+    const newDirents = [...items.slice(0, startIndex), ...childDirents, ...items.slice(endIndex)];
+    const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, newDirents.length);
+    return {
+      ...state,
+      items: newDirents,
+      maxLineY
+    };
+  }
+  const newDirents = childDirents.slice(1);
+  const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, newDirents.length);
+  return {
+    ...state,
+    items: newDirents,
+    maxLineY
+  };
+};
+
 const focusIndex = (state, index) => {
   const {
     minLineY,
@@ -1442,7 +1532,7 @@ const focusPrevious = state => {
   }
 };
 
-const None = 'none';
+const None$1 = 'none';
 const Tree = 'tree';
 const TreeItem$1 = 'treeitem';
 
@@ -1501,6 +1591,39 @@ const UiStrings = {
   OpenFolder: 'Open folder',
   NoFolderOpen: 'No Folder Open'
 };
+const newFile = () => {
+  return i18nString(UiStrings.NewFile);
+};
+const newFolder = () => {
+  return i18nString(UiStrings.NewFolder);
+};
+const openContainingFolder$1 = () => {
+  return i18nString(UiStrings.OpenContainingFolder);
+};
+const openInIntegratedTerminal = () => {
+  return i18nString(UiStrings.OpenInIntegratedTerminal);
+};
+const cut = () => {
+  return i18nString(UiStrings.Cut);
+};
+const copy = () => {
+  return i18nString(UiStrings.Copy);
+};
+const paste = () => {
+  return i18nString(UiStrings.Paste);
+};
+const copyPath = () => {
+  return i18nString(UiStrings.CopyPath);
+};
+const copyRelativePath = () => {
+  return i18nString(UiStrings.CopyRelativePath);
+};
+const rename = () => {
+  return i18nString(UiStrings.Rename);
+};
+const deleteItem = () => {
+  return i18nString(UiStrings.Delete);
+};
 const filesExplorer = () => {
   return i18nString(UiStrings.FilesExplorer);
 };
@@ -1523,7 +1646,7 @@ const getFileIconVirtualDom = icon => {
     type: Img,
     className: FileIcon,
     src: icon,
-    role: None,
+    role: None$1,
     childCount: 0
   };
 };
@@ -1805,6 +1928,121 @@ const getKeyBindings = () => {
   }];
 };
 
+const Separator = 1;
+const None = 0;
+const RestoreFocus = 6;
+
+const menuEntrySeparator = {
+  id: 'separator',
+  label: '',
+  flags: Separator,
+  command: ''
+};
+
+const menuEntryNewFile = {
+  id: 'newFile',
+  label: newFile(),
+  flags: None,
+  command: 'Explorer.newFile'
+};
+const menuEntryNewFolder = {
+  id: 'newFolder',
+  label: newFolder(),
+  flags: None,
+  command: 'Explorer.newFolder'
+};
+const menuEntryOpenContainingFolder = {
+  id: 'openContainingFolder',
+  label: openContainingFolder$1(),
+  flags: RestoreFocus,
+  command: 'Explorer.openContainingFolder'
+};
+const menuEntryOpenInIntegratedTerminal = {
+  id: 'openInIntegratedTerminal',
+  label: openInIntegratedTerminal(),
+  flags: None,
+  command: /* TODO */-1
+};
+const menuEntryCut = {
+  id: 'cut',
+  label: cut(),
+  flags: RestoreFocus,
+  command: /* TODO */-1
+};
+const menuEntryCopy = {
+  id: 'copy',
+  label: copy(),
+  flags: RestoreFocus,
+  command: 'Explorer.handleCopy'
+};
+const menuEntryPaste = {
+  id: 'paste',
+  label: paste(),
+  flags: None,
+  command: 'Explorer.handlePaste'
+};
+const menuEntryCopyPath = {
+  id: 'copyPath',
+  label: copyPath(),
+  flags: RestoreFocus,
+  command: 'Explorer.copyPath'
+};
+const menuEntryCopyRelativePath = {
+  id: 'copyRelativePath',
+  label: copyRelativePath(),
+  flags: RestoreFocus,
+  command: 'Explorer.copyRelativePath'
+};
+const menuEntryRename = {
+  id: 'rename',
+  label: rename(),
+  flags: None,
+  command: 'Explorer.renameDirent'
+};
+const menuEntryDelete = {
+  id: 'delete',
+  label: deleteItem(),
+  flags: None,
+  command: 'Explorer.removeDirent'
+};
+const ALL_ENTRIES = [menuEntryNewFile, menuEntryNewFolder, menuEntryOpenContainingFolder, menuEntryOpenInIntegratedTerminal, menuEntrySeparator, menuEntryCut, menuEntryCopy, menuEntryPaste, menuEntrySeparator, menuEntryCopyPath, menuEntryCopyRelativePath, menuEntrySeparator, menuEntryRename, menuEntryDelete];
+
+// TODO there are two possible ways of getting the focused dirent of explorer
+// 1. directly access state of explorer (bad because it directly accesses state of another component)
+// 2. expose getFocusedDirent method in explorer (bad because explorer code should not know about for menuEntriesExplorer, which needs that method)
+const getFocusedDirent = explorerState => {
+  if (!explorerState || explorerState.focusedIndex < 0) {
+    return undefined;
+  }
+  return explorerState.items[explorerState.focusedIndex];
+};
+const getMenuEntriesDirectory = () => {
+  return ALL_ENTRIES;
+};
+const getMenuEntriesFile = () => {
+  return [menuEntryOpenContainingFolder, menuEntryOpenInIntegratedTerminal, menuEntrySeparator, menuEntryCut, menuEntryCopy, menuEntryPaste, menuEntrySeparator, menuEntryCopyPath, menuEntryCopyRelativePath, menuEntrySeparator, menuEntryRename, menuEntryDelete];
+};
+const getMenuEntriesDefault = () => {
+  return ALL_ENTRIES;
+};
+const getMenuEntriesRoot = () => {
+  return [menuEntryNewFile, menuEntryNewFolder, menuEntryOpenContainingFolder, menuEntryOpenInIntegratedTerminal, menuEntrySeparator, menuEntryPaste, menuEntrySeparator, menuEntryCopyPath, menuEntryCopyRelativePath];
+};
+const getMenuEntries = state => {
+  const focusedDirent = getFocusedDirent(state);
+  if (!focusedDirent) {
+    return getMenuEntriesRoot();
+  }
+  switch (focusedDirent.type) {
+    case Directory:
+      return getMenuEntriesDirectory();
+    case File:
+      return getMenuEntriesFile();
+    default:
+      return getMenuEntriesDefault();
+  }
+};
+
 const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editingIndex, editingType, editingValue) => {
   const visible = [];
   for (let i = minLineY; i < Math.min(maxLineY, items.length); i++) {
@@ -1825,7 +2063,7 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
       });
     }
   }
-  if (editingType !== None$1 && editingIndex === -1) {
+  if (editingType !== None$2 && editingIndex === -1) {
     visible.push({
       depth: 3,
       posInSet: 1,
@@ -1841,14 +2079,29 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
   return visible;
 };
 
-const getFocusedDirent = state => {
+const getIndexFromPosition = (state, eventX, eventY) => {
   const {
-    focusedIndex,
-    minLineY,
+    y,
+    itemHeight,
     items
   } = state;
-  const dirent = items[focusedIndex + minLineY];
-  return dirent;
+  const index = Math.floor((eventY - y) / itemHeight);
+  if (index < 0) {
+    return 0;
+  }
+  if (index >= items.length) {
+    return -1;
+  }
+  return index;
+};
+
+const getParentStartIndex = (dirents, index) => {
+  const dirent = dirents[index];
+  let startIndex = index - 1;
+  while (startIndex >= 0 && dirents[startIndex].depth >= dirent.depth) {
+    startIndex--;
+  }
+  return startIndex;
 };
 
 const Keyboard = -1;
@@ -1917,7 +2170,7 @@ const removeDirent = async state => {
   if (state.focusedIndex < 0) {
     return state;
   }
-  const dirent = getFocusedDirent(state);
+  const dirent = getFocusedDirent$1(state);
   const absolutePath = dirent.path;
   try {
     // TODO handle error
@@ -1992,7 +2245,7 @@ const cancelEdit = state => {
     focused: true,
     editingIndex: -1,
     editingValue: '',
-    editingType: None$1
+    editingType: None$2
   };
 };
 
@@ -2225,7 +2478,7 @@ const handleBlur = state => {
   const {
     editingType
   } = state;
-  if (editingType !== None$1) {
+  if (editingType !== None$2) {
     return state;
   }
   return {
@@ -2241,18 +2494,6 @@ const handleClickOpenFolder = async state => {
   return state;
 };
 
-const state = {
-  rpc: undefined
-};
-const invoke = (method, ...params) => {
-  const rpc = state.rpc;
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
-};
-const setRpc = rpc => {
-  state.rpc = rpc;
-};
-
 const show = async (x, y, id, ...args) => {
   return invoke('ContextMenu.show', x, y, id, ...args);
 };
@@ -2294,18 +2535,6 @@ const handleContextMenu = (state, button, x, y) => {
   }
 };
 
-const writeText = async text => {
-  await invoke('ClipBoard.writeText', /* text */text);
-};
-
-const copyRelativePath = async state => {
-  const dirent = getFocusedDirent(state);
-  const relativePath = dirent.path.slice(1);
-  // TODO handle error
-  await writeText(relativePath);
-  return state;
-};
-
 const handlePointerDown = (state, button, x, y) => {
   const index = getIndexFromPosition(state, x, y);
   if (button === LeftClick && index === -1) {
@@ -2428,11 +2657,6 @@ const restoreState = savedState => {
   };
 };
 
-const copyPath = async state => {
-  // await Command.execute(RendererWorkerCommandType.ClipBoardWriteText, /* text */ path)
-  return state;
-};
-
 const isExpandedDirectory = dirent => {
   return dirent.type === DirectoryExpanded;
 };
@@ -2460,15 +2684,17 @@ const saveState = state => {
 const commandMap = {
   'Explorer.acceptEdit': acceptEdit,
   'Explorer.cancelEdit': cancelEdit,
-  'Explorer.copyPath': copyPath,
-  'Explorer.copyRelativePath': copyRelativePath,
+  'Explorer.copyPath': copyPath$1,
+  'Explorer.copyRelativePath': copyRelativePath$1,
   'Explorer.expandAll': expandAll,
+  'Explorer.expandRecursively': expandRecursively,
   'Explorer.focusFirst': focusFirst,
   'Explorer.focusIndex': focusIndex,
   'Explorer.focusLast': focusLast,
   'Explorer.focusNext': focusNext,
   'Explorer.focusPrevious': focusPrevious,
   'Explorer.getKeyBindings': getKeyBindings,
+  'Explorer.getMenuEntries': getMenuEntries,
   'Explorer.getVirtualDom': getExplorerVirtualDom,
   'Explorer.getVisibleItems': getVisibleExplorerItems,
   'Explorer.handleArrowLeft': handleArrowLeft,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/explorer-view",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Explorer Worker",
   "main": "dist/explorerViewWorkerMain.js",
   "type": "module",