@lvce-editor/explorer-view 6.11.0 → 6.14.0

package/dist/explorerViewWorkerMain.js

@@ -189,7 +189,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String = 4;
+const String$1 = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
@@ -201,7 +201,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String;
+      return String$1;
     case 'object':
       if (value === null) {
         return Null;
@@ -236,7 +236,7 @@ const array = value => {
 };
 const string = value => {
   const type = getType(value);
-  if (type !== String) {
+  if (type !== String$1) {
     throw new AssertionError('expected value to be of type string');
   }
 };
@@ -1436,8 +1436,8 @@ const applyFileOperations = async operations => {
     }
     return '';
   } catch (error) {
-    console.error(new VError(error, `Failed to apply file operations`));
-    return `${error}`;
+    console.error(new VError(error, 'Failed to apply file operations'));
+    return String(error);
   }
 };
 
@@ -1667,11 +1667,31 @@ const getChildDirentsRaw = async uri => {
 };
 
 const RE_CHARACTERS = /^[a-zA-Z.-]+$/;
+const RE_LEADING_DIGITS = /^\d+/;
+const compareLeadingDigits = (a, b) => {
+  const normalizedA = a.replace(/^0+/, '') || '0';
+  const normalizedB = b.replace(/^0+/, '') || '0';
+  if (normalizedA.length !== normalizedB.length) {
+    return normalizedA.length - normalizedB.length;
+  }
+  if (normalizedA !== normalizedB) {
+    return normalizedA < normalizedB ? -1 : 1;
+  }
+  return a.length - b.length;
+};
+const compareLeadingNumbers = (a, b) => {
+  const leadingDigitsA = a.match(RE_LEADING_DIGITS)?.[0];
+  const leadingDigitsB = b.match(RE_LEADING_DIGITS)?.[0];
+  if (leadingDigitsA && leadingDigitsB) {
+    return compareLeadingDigits(leadingDigitsA, leadingDigitsB);
+  }
+  return 0;
+};
 const compareStringNumeric = (a, b) => {
   if (RE_CHARACTERS.test(a) && RE_CHARACTERS.test(b)) {
     return a < b ? -1 : 1;
   }
-  return a.localeCompare(b, 'en', {
+  return compareLeadingNumbers(a, b) || a.localeCompare(b, 'en', {
     numeric: true
   });
 };
@@ -1739,14 +1759,11 @@ const getChildDirents = async (pathSeparator, parentDirentPath, parentDirentDept
   return displayDirents;
 };
 
-const isTopLevel = dirent => {
-  return dirent.depth === 1;
-};
-
 const orderDirents = dirents => {
   if (dirents.length === 0) {
     return dirents;
   }
+  const minDepth = Math.min(...dirents.map(dirent => dirent.depth));
   const withDeepChildren = (parent, processed) => {
     if (processed.has(parent.path)) {
       return [];
@@ -1760,7 +1777,7 @@ const orderDirents = dirents => {
     }
     return [parent, ...children];
   };
-  const topLevelDirents = dirents.filter(isTopLevel);
+  const topLevelDirents = dirents.filter(dirent => dirent.depth === minDepth);
   const processed = new Set();
   const ordered = topLevelDirents.flatMap(dirent => withDeepChildren(dirent, processed));
   return ordered;
@@ -1981,7 +1998,7 @@ const validateFileName2 = (name, siblingFileNames = []) => {
   }
 
   // Disallow reserved directory names
-  if (name === '.' || name === '..' || name === '...') {
+  if (['.', '..', '...'].includes(name)) {
     return theNameIsNotValid();
   }
 
@@ -2060,14 +2077,23 @@ const computeExplorerRenamedDirentUpdate = (root, parentPath, oldUri, children,
   const relativeOldPath = oldUri.slice(rootLength);
   const relativeNewUri = newUri.slice(rootLength);
   const update = Object.create(null);
-  update[relativeDirname] = children;
   const oldItems = tree[relativeOldPath] || [];
+  update[relativeDirname] = children.map(child => {
+    if (oldItems.length > 0 && child.path === newUri && child.type === Directory) {
+      return {
+        ...child,
+        type: DirectoryExpanded
+      };
+    }
+    return child;
+  });
   update[relativeNewUri] = oldItems;
   for (const [key, value] of Object.entries(tree)) {
-    if (key.startsWith(`${relativeOldPath}/`)) {
-      const newKey = `${relativeNewUri}` + key.slice(relativeOldPath.length);
-      update[newKey] = value;
+    if (!key.startsWith(`${relativeOldPath}/`)) {
+      continue;
     }
+    const newKey = relativeNewUri + key.slice(relativeOldPath.length);
+    update[newKey] = value;
   }
   return update;
 };
@@ -2244,6 +2270,10 @@ const cancelTypeAhead = state => {
   };
 };
 
+const isTopLevel = dirent => {
+  return dirent.depth === 1;
+};
+
 const toCollapsedDirent = dirent => {
   if (dirent.type === DirectoryExpanded) {
     return {
@@ -2384,7 +2414,7 @@ const getPaths = items => {
 };
 
 const getSimpleIconRequestType = direntType => {
-  if (direntType === Directory || direntType === DirectoryExpanded || direntType === EditingDirectoryExpanded || direntType === EditingFolder) {
+  if ([Directory, DirectoryExpanded, EditingDirectoryExpanded, EditingFolder].includes(direntType)) {
     return 2;
   }
   return 1;
@@ -2625,12 +2655,12 @@ const getChildrenWithCount = (nodes, startIndex, childCount) => {
 };
 
 const compareNodes = (oldNode, newNode) => {
-  const patches = [];
   // Check if node type changed - return null to signal incompatible nodes
   // (caller should handle this with a Replace operation)
   if (oldNode.type !== newNode.type) {
     return null;
   }
+  const patches = [];
   // Handle reference nodes - special handling for uid changes
   if (oldNode.type === Reference) {
     if (oldNode.uid !== newNode.uid) {
@@ -2666,7 +2696,7 @@ const compareNodes = (oldNode, newNode) => {
   }
   // Check for removed attributes
   for (const key of oldKeys) {
-    if (!(key in newNode)) {
+    if (!Object.hasOwn(newNode, key)) {
       patches.push({
         type: RemoveAttribute,
         key
@@ -2684,11 +2714,78 @@ const treeToArray = node => {
   return result;
 };
 
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  return nextChildIndex;
+};
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
 const diffChildren = (oldChildren, newChildren, patches) => {
   const maxLength = Math.max(oldChildren.length, newChildren.length);
-  // Track where we are: -1 means at parent, >= 0 means at child index
   let currentChildIndex = -1;
-  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
   const indicesToRemove = [];
   for (let i = 0; i < maxLength; i++) {
     const oldNode = oldChildren[i];
@@ -2697,88 +2794,17 @@ const diffChildren = (oldChildren, newChildren, patches) => {
       continue;
     }
     if (!oldNode) {
-      // Add new node - we should be at the parent
-      if (currentChildIndex >= 0) {
-        // Navigate back to parent
-        patches.push({
-          type: NavigateParent
-        });
-        currentChildIndex = -1;
-      }
-      // Flatten the entire subtree so renderInternal can handle it
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Add,
-        nodes: flatNodes
-      });
-    } else if (newNode) {
-      // Compare nodes to see if we need any patches
-      const nodePatches = compareNodes(oldNode.node, newNode.node);
-      // If nodePatches is null, the node types are incompatible - need to replace
-      if (nodePatches === null) {
-        // Navigate to this child
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Replace the entire subtree
-        const flatNodes = treeToArray(newNode);
-        patches.push({
-          type: Replace,
-          nodes: flatNodes
-        });
-        // After replace, we're at the new element (same position)
-        continue;
-      }
-      // Check if we need to recurse into children
-      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-      // Only navigate to this element if we need to do something
-      if (nodePatches.length > 0 || hasChildrenToCompare) {
-        // Navigate to this child if not already there
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Apply node patches (these apply to the current element, not children)
-        if (nodePatches.length > 0) {
-          patches.push(...nodePatches);
-        }
-        // Compare children recursively
-        if (hasChildrenToCompare) {
-          diffChildren(oldNode.children, newNode.children, patches);
-        }
-      }
-    } else {
-      // Remove old node - collect the index for later removal
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
       indicesToRemove.push(i);
+      continue;
     }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
   }
-  // Navigate back to parent if we ended at a child
-  if (currentChildIndex >= 0) {
-    patches.push({
-      type: NavigateParent
-    });
-  }
-  // Add remove patches in reverse order (highest index first)
-  // This ensures indices remain valid as we remove
+  navigateToParent(patches, currentChildIndex);
   for (let j = indicesToRemove.length - 1; j >= 0; j--) {
     patches.push({
       type: RemoveChild,
@@ -2787,33 +2813,11 @@ const diffChildren = (oldChildren, newChildren, patches) => {
   }
 };
 const diffTrees = (oldTree, newTree, patches, path) => {
-  // At the root level (path.length === 0), we're already AT the element
-  // So we compare the root node directly, then compare its children
   if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    const oldNode = oldTree[0];
-    const newNode = newTree[0];
-    // Compare root nodes
-    const nodePatches = compareNodes(oldNode.node, newNode.node);
-    // If nodePatches is null, the root node types are incompatible - need to replace
-    if (nodePatches === null) {
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Replace,
-        nodes: flatNodes
-      });
-      return;
-    }
-    if (nodePatches.length > 0) {
-      patches.push(...nodePatches);
-    }
-    // Compare children
-    if (oldNode.children.length > 0 || newNode.children.length > 0) {
-      diffChildren(oldNode.children, newNode.children, patches);
-    }
-  } else {
-    // Non-root level or multiple root elements - use the regular comparison
-    diffChildren(oldTree, newTree, patches);
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
   }
+  diffChildren(oldTree, newTree, patches);
 };
 
 const removeTrailingNavigationPatches = patches => {
@@ -2892,6 +2896,12 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
   for (let i = minLineY; i < Math.min(maxLineY, items.length); i++) {
     const item = items[i];
     let chevron = getChevronType(item.type, useChevrons);
+    const isEditing = i === editingIndex;
+    let icon = icons[iconIndex++];
+    if (isEditing) {
+      icon = editingIcon;
+      chevron = getEditingChevron(item.type);
+    }
     const isFocused = i === focusedIndex;
     const id = isFocused ? 'TreeItemActive' : undefined;
     const isSelected = item.selected;
@@ -2903,12 +2913,6 @@ const getVisibleExplorerItems = (items, minLineY, maxLineY, focusedIndex, editin
     const className = getTreeItemClassName(isSelected, isFocused, isDropping, useChevrons, indent, decoration);
     const expanded = getExpandedType(item.type);
     const ariaExpanded = ariaExpandedValues[expanded];
-    const isEditing = i === editingIndex;
-    let icon = icons[iconIndex++];
-    if (isEditing) {
-      icon = editingIcon;
-      chevron = getEditingChevron(item.type);
-    }
     visible.push({
       ...item,
       ariaExpanded,
@@ -2937,6 +2941,9 @@ const {
   set,
   wrapGetter
 } = create$a();
+const hasSameVisibleExplorerItemInputs = (oldState, newState) => {
+  return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.height === newState.height && oldState.itemHeight === newState.itemHeight && oldState.focusedIndex === newState.focusedIndex && oldState.editingIndex === newState.editingIndex && oldState.editingIcon === newState.editingIcon && oldState.cutItems === newState.cutItems && oldState.editingErrorMessage === newState.editingErrorMessage && oldState.dropTargets === newState.dropTargets && oldState.fileIconCache === newState.fileIconCache && oldState.decorations === newState.decorations && oldState.useChevrons === newState.useChevrons && oldState.sourceControlIgnoredUris === newState.sourceControlIgnoredUris;
+};
 const wrapListItemCommand = fn => {
   const wrappedCommand = async (id, ...args) => {
     const {
@@ -2964,10 +2971,10 @@ const wrapListItemCommand = fn => {
     } = updatedState;
     const intermediate = get(id);
     set(id, intermediate.oldState, updatedState);
-    const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, items.length);
-    if (items === intermediate.newState.items && minLineY === intermediate.newState.minLineY && height === intermediate.newState.height && itemHeight === intermediate.newState.itemHeight && editingIcon === intermediate.newState.editingIcon && cutItems === intermediate.newState.cutItems && editingErrorMessage === intermediate.newState.editingErrorMessage && dropTargets === intermediate.newState.dropTargets && fileIconCache === intermediate.newState.fileIconCache && decorations === intermediate.newState.decorations) {
+    if (hasSameVisibleExplorerItemInputs(intermediate.newState, updatedState)) {
       return;
     }
+    const maxLineY = getExplorerMaxLineY(minLineY, height, itemHeight, items.length);
     const visible = items.slice(minLineY, maxLineY);
     const {
       icons,
@@ -3139,25 +3146,26 @@ const expandAll = async state => {
   } = dirent;
   const newDirents = [...items];
   // TODO fetch child dirents in parallel
-  for (const dirent of newDirents) {
-    if (dirent.depth === depth && dirent.type === Directory) {
-      // TODO expand
-      // TODO avoid mutating state here
-      // @ts-ignore
-      dirent.type = DirectoryExpanding;
-      // TODO handle error
-      // TODO race condition
-      const childDirents = await getChildDirents(pathSeparator, dirent.path, dirent.depth);
-      const newIndex = newDirents.indexOf(dirent);
-      if (newIndex === -1) {
-        continue;
-      }
-      newDirents.splice(newIndex + 1, 0, ...childDirents);
-      // TODO avoid mutating state here
-      // @ts-ignore
-      dirent.type = DirectoryExpanded;
-      // await expand(state, dirent.index)
+  for (const dirent of items) {
+    if (dirent.depth !== depth || dirent.type !== Directory) {
+      continue;
     }
+    // TODO expand
+    // TODO avoid mutating state here
+    // @ts-ignore
+    dirent.type = DirectoryExpanding;
+    // TODO handle error
+    // TODO race condition
+    const childDirents = await getChildDirents(pathSeparator, dirent.path, dirent.depth);
+    const newIndex = newDirents.indexOf(dirent);
+    if (newIndex === -1) {
+      continue;
+    }
+    newDirents.splice(newIndex + 1, 0, ...childDirents);
+    // TODO avoid mutating state here
+    // @ts-ignore
+    dirent.type = DirectoryExpanded;
+    // await expand(state, dirent.index)
   }
   return {
     ...state,
@@ -3316,11 +3324,7 @@ const lastIndex = array => {
   return array.length - 1;
 };
 const fromAsync = async asyncIterable => {
-  const children = [];
-  for await (const value of asyncIterable) {
-    children.push(value);
-  }
-  return children;
+  return Array.fromAsync(asyncIterable);
 };
 
 const focusLast = state => {
@@ -3845,7 +3849,7 @@ const OpenFolder = 'OpenFolder';
 const Refresh$1 = 'Refresh';
 
 const isFolder = direntType => {
-  return direntType === Directory || direntType === DirectoryExpanded || direntType === SymLinkFolder;
+  return [Directory, DirectoryExpanded, SymLinkFolder].includes(direntType);
 };
 const getFittingIndex = (dirents, startIndex) => {
   for (let i = startIndex; i >= 0; i--) {
@@ -4320,12 +4324,19 @@ const handleContextMenuAtIndex = async (state, index, x, y) => {
   number(x);
   number(y);
   const {
+    items,
     uid
   } = state;
+  const contextMenuItem = items[index];
+  const newItems = contextMenuItem && !contextMenuItem.selected ? items.map(item => ({
+    ...item,
+    selected: false
+  })) : items;
   const newState = {
     ...state,
     focused: false,
-    focusedIndex: index
+    focusedIndex: index,
+    items: newItems
   };
   set(uid, state, newState);
   await show2(uid, Explorer, x, y, {
@@ -4386,6 +4397,7 @@ const handleCopy = async state => {
   await writeNativeFiles('copy', files);
   return {
     ...state,
+    cutItems: [],
     pasteShouldMove: false
   };
 };
@@ -4874,11 +4886,7 @@ const getDroppedName = item => {
   return item.name;
 };
 const getFileSystemHandlesNormalized = fileSystemHandles => {
-  const normalized = [];
-  for (const item of fileSystemHandles) {
-    normalized.push(getFileSystemHandle(item));
-  }
-  return normalized;
+  return Array.from(fileSystemHandles, getFileSystemHandle);
 };
 const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) => {
   if (fileSystemHandles.length === 0) {
@@ -5258,7 +5266,7 @@ const isAscii = key => {
   return RE_ASCII.test(key);
 };
 
-let timeout;
+const typeAheadTimeout = {};
 const handleKeyDown = (state, key) => {
   const {
     focusedIndex,
@@ -5275,10 +5283,10 @@ const handleKeyDown = (state, key) => {
   const newFocusWord = focusWord + key.toLowerCase();
   const itemNames = items.map(item => item.name);
   const matchingIndex = filterByFocusWord(itemNames, focusedIndex, newFocusWord);
-  if (timeout) {
-    clearTimeout(timeout);
+  if (typeAheadTimeout.value) {
+    clearTimeout(typeAheadTimeout.value);
   }
-  timeout = setTimeout(async () => {
+  typeAheadTimeout.value = setTimeout(async () => {
     await invoke$2('Explorer.cancelTypeAhead');
   }, focusWordTimeout);
   if (matchingIndex === -1) {
@@ -5601,13 +5609,14 @@ const handleUpload = async (state, dirents) => {
     // TODO switch
     // TODO symlink might not be possible to be copied
     // TODO create folder if type is 2
-    if (dirent.type === /* File */1) {
-      // TODO reading text might be inefficient for binary files
-      // but not sure how else to send them via jsonrpc
-      const content = await dirent.file.text();
-      const absolutePath = [root, dirent.file.name].join(pathSeparator);
-      await writeFile(absolutePath, content);
+    if (dirent.type !== /* File */1) {
+      continue;
     }
+    // TODO reading text might be inefficient for binary files
+    // but not sure how else to send them via jsonrpc
+    const content = await dirent.file.text();
+    const absolutePath = [root, dirent.file.name].join(pathSeparator);
+    await writeFile(absolutePath, content);
   }
 };
 
@@ -5667,7 +5676,7 @@ const getContainingFolder = (root, dirents, focusedIndex, pathSeparator) => {
   const dirent = dirents[focusedIndex];
   const direntPath = dirent.path;
   const direntParentPath = direntPath.slice(0, -(dirent.name.length + 1));
-  const path = `${direntParentPath}`;
+  const path = direntParentPath;
   return path;
 };
 
@@ -5690,7 +5699,7 @@ const confirmDelete = async paths => {
   // TODO use i18n string
   const message = paths.length === 1 ? `Are you sure you want to delete "${paths[0]}"?` : `Are you sure you want to delete ${paths.length} items?`;
   const result = await confirm(message);
-  return result === true;
+  return result;
 };
 
 const showErrorAlert = async errorMessage => {
@@ -5893,7 +5902,7 @@ const getDragLabel = urls => {
   if (urls.length === 1) {
     return getBaseName('/', urls[0]);
   }
-  return `${urls.length}`;
+  return String(urls.length);
 };
 
 const toUri = path => {
@@ -6633,7 +6642,17 @@ const revealItemHidden = async (state, uri) => {
   const pathPartsChildrenFlat = pathPartsChildren.flat();
   const orderedPathParts = orderDirents(pathPartsChildrenFlat);
   const mergedDirents = mergeVisibleWithHiddenItems(items, orderedPathParts);
-  const index = getIndex(mergedDirents, uri);
+  const expandedPaths = new Set(pathPartsToReveal.map(pathPart => pathPart.path));
+  const newDirents = mergedDirents.map(item => {
+    if (expandedPaths.has(item.path) && item.type === Directory) {
+      return {
+        ...item,
+        type: DirectoryExpanded
+      };
+    }
+    return item;
+  });
+  const index = getIndex(newDirents, uri);
   if (index === -1) {
     throw new Error(`File not found in explorer ${uri}`);
   }
@@ -6645,7 +6664,7 @@ const revealItemHidden = async (state, uri) => {
     ...state,
     focused: true,
     focusedIndex: index,
-    items: mergedDirents,
+    items: newDirents,
     maxLineY: newMaxLineY,
     minLineY: newMinLineY
   };
@@ -6709,6 +6728,8 @@ const saveState = state => {
   };
 };
 
+// TODO select all should only select all items in the current folder
+// and when calling it next item, expand selection to its parent folder
 const selectAll = state => {
   const {
     items
@@ -6810,7 +6831,7 @@ const getEditingIcon = async (editingType, value, direntType) => {
         name: value
       });
     }
-    if (direntType === Directory || direntType === EditingFolder || direntType === EditingDirectoryExpanded) {
+    if (direntType !== undefined && [Directory, EditingFolder, EditingDirectoryExpanded].includes(direntType)) {
       return invoke$2('IconTheme.getFolderIcon', {
         name: value
       });

package/package.json

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