@lvce-editor/explorer-view 7.6.0 → 7.9.0

package/dist/explorerViewWorkerMain.js

@@ -3,10 +3,67 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$a = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
@@ -26,6 +83,7 @@ const create$a = () => {
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -43,14 +101,27 @@ const create$a = () => {
       Object.assign(commandMapRef, commandMap);
     },
     set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
         oldState,
         scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -59,6 +130,9 @@ const create$a = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -83,6 +157,7 @@ const create$a = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -97,6 +172,11 @@ const create$a = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -112,6 +192,51 @@ const create$a = () => {
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -284,7 +409,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -438,7 +562,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -742,8 +873,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -754,55 +887,77 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    error.stack = error.stack + NewLine + currentStack;
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  restoredError.stack = parentStack + NewLine + currentStack;
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+    return;
+  }
+  if (error.data.stack) {
+    restoredError.stack = error.data.stack;
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  if (!error.data) {
+    return;
+  }
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1262,9 +1417,175 @@ const create$1 = rpcId => {
   };
 };
 
+const Audio = 0;
+const Button$4 = 1;
+const Col = 2;
+const ColGroup = 3;
+const Div$1 = 4;
+const H1 = 5;
+const Input$2 = 6;
+const Kbd = 7;
+const Span = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
 const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
+const Img$1 = 17;
+const Root = 0;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P$1 = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea = 62;
+const Select = 63;
+const Option = 64;
+const Code = 65;
+const Label$1 = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
 const Reference = 100;
 
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Abbr,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button: Button$4,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div: Div$1,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img: Img$1,
+  Input: Input$2,
+  Ins,
+  Kbd,
+  Label: Label$1,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option,
+  P: P$1,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference,
+  Root,
+  Search,
+  Section,
+  Select,
+  Span,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table,
+  Td,
+  Text,
+  TextArea,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
+};
+
 const Button$3 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
@@ -1393,6 +1714,9 @@ const remove = async dirent => {
 const readDirWithFileTypes = async uri => {
   return invoke('FileSystem.readDirWithFileTypes', uri);
 };
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
 const getPathSeparator$1 = async root => {
   return invoke('FileSystem.getPathSeparator', root);
 };
@@ -1951,15 +2275,15 @@ const Slash$1 = '/';
 const BackSlash = '\\';
 
 const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
   if (placeholders === emptyObject) {
     return key;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  let result = key;
+  for (const [placeholder, replacement] of Object.entries(placeholders)) {
+    result = result.split(`{${placeholder}}`).join(String(replacement));
+  }
+  return result;
 };
 
 const CollapseAllFoldersInExplorer = 'Collapse All Folders in Explorer';
@@ -2575,6 +2899,215 @@ const getFileIcons = async (dirents, fileIconCache) => {
   };
 };
 
+const directoryTypes = new Set([DirectoryExpanded, DirectoryExpanding, EditingDirectoryExpanded]);
+const getParentPath = (path, pathSeparator) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return '';
+  }
+  return path.slice(0, index);
+};
+const getGitIgnoreCandidateDirs = (root, items, pathSeparator) => {
+  const dirs = new Set([root]);
+  for (const item of items) {
+    if (directoryTypes.has(item.type)) {
+      dirs.add(item.path);
+    }
+    const parent = getParentPath(item.path, pathSeparator);
+    if (parent && parent.startsWith(root)) {
+      dirs.add(parent);
+    }
+  }
+  return [...dirs];
+};
+
+const trimLeadingSeparator = path => {
+  return path.startsWith('/') ? path.slice(1) : path;
+};
+const toSlashPath = (path, pathSeparator) => {
+  if (pathSeparator === '/') {
+    return path;
+  }
+  return path.replaceAll(pathSeparator, '/');
+};
+const getGitIgnoreRelativePath = (root, path, pathSeparator) => {
+  const slashRoot = toSlashPath(root, pathSeparator);
+  const slashPath = toSlashPath(path, pathSeparator);
+  if (slashPath === slashRoot) {
+    return '';
+  }
+  if (slashRoot.endsWith('/')) {
+    return slashPath.slice(slashRoot.length);
+  }
+  return trimLeadingSeparator(slashPath.slice(slashRoot.length));
+};
+
+const joinPath = (parent, child, pathSeparator) => {
+  if (parent.endsWith(pathSeparator)) {
+    return `${parent}${child}`;
+  }
+  return `${parent}${pathSeparator}${child}`;
+};
+
+const lineSeparatorRegex = /\r?\n/;
+const stripTrailingSpaces = line => {
+  let end = line.length;
+  while (end > 0 && line[end - 1] === ' ' && line[end - 2] !== '\\') {
+    end--;
+  }
+  return line.slice(0, end).replaceAll('\\ ', ' ');
+};
+const parseLine = (basePath, line) => {
+  line = stripTrailingSpaces(line);
+  if (!line || line.startsWith('#')) {
+    return undefined;
+  }
+  let negative = false;
+  if (line.startsWith('\\!')) {
+    line = line.slice(1);
+  } else if (line.startsWith('!')) {
+    negative = true;
+    line = line.slice(1);
+  }
+  const anchored = line.startsWith('/');
+  line = line.replaceAll('\\#', '#').replaceAll('\\!', '!');
+  const directoryOnly = line.endsWith('/');
+  if (directoryOnly) {
+    line = line.slice(0, -1);
+  }
+  while (line.startsWith('/')) {
+    line = line.slice(1);
+  }
+  if (!line) {
+    return undefined;
+  }
+  return {
+    anchored,
+    basePath,
+    directoryOnly,
+    hasSlash: line.includes('/'),
+    negative,
+    pattern: line
+  };
+};
+const parseGitIgnore = (basePath, content) => {
+  const patterns = [];
+  for (const line of content.split(lineSeparatorRegex)) {
+    const pattern = parseLine(basePath, line);
+    if (pattern) {
+      patterns.push(pattern);
+    }
+  }
+  return patterns;
+};
+
+const readGitIgnoreFile = async (root, dir, pathSeparator) => {
+  try {
+    const content = await readFile(joinPath(dir, '.gitignore', pathSeparator));
+    const basePath = getGitIgnoreRelativePath(root, dir, pathSeparator);
+    return parseGitIgnore(basePath, content);
+  } catch {
+    return [];
+  }
+};
+const getGitIgnoreFiles = async (root, items, pathSeparator) => {
+  const dirs = getGitIgnoreCandidateDirs(root, items, pathSeparator);
+  const nestedPatterns = await Promise.all(dirs.map(dir => {
+    return readGitIgnoreFile(root, dir, pathSeparator);
+  }));
+  return nestedPatterns.flat();
+};
+
+const regexSpecialCharacters = /[|\\{}()[\]^$+?.]/g;
+const escapeRegex = text => {
+  return text.replaceAll(regexSpecialCharacters, '\\$&');
+};
+const globToRegex = glob => {
+  let regex = '^';
+  for (let i = 0; i < glob.length; i++) {
+    const char = glob[i];
+    const next = glob[i + 1];
+    if (char === '*' && next === '*') {
+      if (glob[i + 2] === '/') {
+        regex += '(?:.*/)?';
+        i += 2;
+      } else {
+        regex += '.*';
+        i++;
+      }
+    } else if (char === '*') {
+      regex += '[^/]*';
+    } else if (char === '?') {
+      regex += '[^/]';
+    } else {
+      regex += escapeRegex(char);
+    }
+  }
+  regex += '$';
+  return new RegExp(regex);
+};
+const isWithinBase = (relativePath, basePath) => {
+  return !basePath || relativePath === basePath || relativePath.startsWith(`${basePath}/`);
+};
+const getBaseRelativePath = (relativePath, basePath) => {
+  if (!basePath) {
+    return relativePath;
+  }
+  if (relativePath === basePath) {
+    return '';
+  }
+  return relativePath.slice(basePath.length + 1);
+};
+const matchesDirectoryPattern = (baseRelativePath, pattern) => {
+  if (pattern.hasSlash || pattern.anchored) {
+    return baseRelativePath === pattern.pattern || baseRelativePath.startsWith(`${pattern.pattern}/`);
+  }
+  return baseRelativePath.split('/').includes(pattern.pattern);
+};
+const matchesPathPattern = (baseRelativePath, pattern) => {
+  const regex = globToRegex(pattern.pattern);
+  if (pattern.hasSlash || pattern.anchored) {
+    return regex.test(baseRelativePath);
+  }
+  return baseRelativePath.split('/').some(part => regex.test(part));
+};
+const matchesPattern = (baseRelativePath, pattern) => {
+  if (!baseRelativePath) {
+    return false;
+  }
+  if (pattern.directoryOnly) {
+    return matchesDirectoryPattern(baseRelativePath, pattern);
+  }
+  return matchesPathPattern(baseRelativePath, pattern);
+};
+const isGitIgnored = (relativePath, patterns) => {
+  let ignored = false;
+  for (const pattern of patterns) {
+    if (!isWithinBase(relativePath, pattern.basePath)) {
+      continue;
+    }
+    const baseRelativePath = getBaseRelativePath(relativePath, pattern.basePath);
+    if (matchesPattern(baseRelativePath, pattern)) {
+      ignored = !pattern.negative;
+    }
+  }
+  return ignored;
+};
+
+const getGitIgnoredUris = async (root, items, pathSeparator, enabled) => {
+  if (!enabled || !root || items.length === 0) {
+    return [];
+  }
+  const patterns = await getGitIgnoreFiles(root, items, pathSeparator);
+  if (patterns.length === 0) {
+    return [];
+  }
+  return items.filter(item => {
+    const relativePath = getGitIgnoreRelativePath(root, item.path, pathSeparator);
+    return isGitIgnored(relativePath, patterns);
+  }).map(item => item.path);
+};
+
 // TODO optimize this function to return the minimum number
 // of visible items needed, e.g. when not scrolled 5 items with
 // 20px fill 100px but when scrolled 6 items are needed
@@ -2696,6 +3229,8 @@ const text = data => {
   };
 };
 
+new Set(Object.values(VirtualDomElements));
+
 const SetText = 1;
 const Replace = 2;
 const SetAttribute = 3;
@@ -3053,18 +3588,55 @@ const {
   set,
   wrapGetter
 } = create$a();
+const commandQueues = new Map();
+const runQueuedCommand = async (previousCommand, command) => {
+  try {
+    await previousCommand;
+  } catch {
+    // Keep the queue usable after returning the error to the command caller
+  }
+  await command();
+};
+const enqueueCommand = async (id, command) => {
+  const currentCommand = runQueuedCommand(commandQueues.get(id), command);
+  commandQueues.set(id, currentCommand);
+  try {
+    await currentCommand;
+  } finally {
+    if (commandQueues.get(id) === currentCommand) {
+      commandQueues.delete(id);
+    }
+  }
+};
 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 maybeUpdateGitIgnoredUris = async (oldState, newState) => {
+  if (oldState.items === newState.items || oldState.sourceControlIgnoredUris !== newState.sourceControlIgnoredUris) {
+    return newState;
+  }
+  const {
+    gitIgnoreDecorations,
+    items,
+    pathSeparator,
+    root
+  } = newState;
+  const sourceControlIgnoredUris = await getGitIgnoredUris(root, items, pathSeparator, gitIgnoreDecorations);
+  return {
+    ...newState,
+    sourceControlIgnoredUris
+  };
+};
+const wrapListItemCommandInternal = (fn, queued) => {
+  const runCommand = async (id, ...args) => {
     const {
       newState
     } = get(id);
-    const updatedState = await fn(newState, ...args);
-    if (newState === updatedState) {
+    const rawUpdatedState = await fn(newState, ...args);
+    if (newState === rawUpdatedState) {
       return;
     }
+    const updatedState = await maybeUpdateGitIgnoredUris(newState, rawUpdatedState);
     const {
       cutItems,
       decorations,
@@ -3103,8 +3675,22 @@ const wrapListItemCommand = fn => {
     const intermediate2 = get(id);
     set(id, intermediate2.oldState, finalState);
   };
+  if (!queued) {
+    return runCommand;
+  }
+  const wrappedCommand = async (id, ...args) => {
+    await enqueueCommand(id, async () => {
+      await runCommand(id, ...args);
+    });
+  };
   return wrappedCommand;
 };
+const wrapListItemCommand = fn => {
+  return wrapListItemCommandInternal(fn, true);
+};
+const wrapListItemCommandImmediate = fn => {
+  return wrapListItemCommandInternal(fn, false);
+};
 
 const ListItem = 22;
 
@@ -3144,6 +3730,7 @@ const create = (id, uri, x, y, width, height, args, parentUid, platform = 0, ass
     focusedIndex: -1,
     focusWord: '',
     focusWordTimeout: 800,
+    gitIgnoreDecorations: false,
     handleOffset: 0,
     hasError: false,
     height,
@@ -4240,7 +4827,9 @@ const refresh = async state => {
   const {
     excluded,
     focusedIndex,
+    gitIgnoreDecorations,
     items,
+    pathSeparator,
     root
   } = state;
   const expandedDirents = getExpandedDirents(items);
@@ -4253,10 +4842,12 @@ const refresh = async state => {
   if (focusedIndex >= newItems.length) {
     newFocusedIndex = newItems.length - 1;
   }
+  const sourceControlIgnoredUris = await getGitIgnoredUris(root, newItems, pathSeparator, gitIgnoreDecorations);
   return {
     ...state,
     focusedIndex: newFocusedIndex,
-    items: newItems
+    items: newItems,
+    sourceControlIgnoredUris
   };
 };
 
@@ -4438,15 +5029,21 @@ const handleRangeSelection = (state, startIndex, endIndex) => {
 
 const handleClickAtRangeSelection = async (state, index) => {
   const {
+    focusedIndex,
     items
   } = state;
   const firstSelectedIndex = items.findIndex(item => item.selected);
-  if (firstSelectedIndex === -1) {
-    return handleRangeSelection(state, index, index);
+  let anchorIndex = firstSelectedIndex;
+  if (anchorIndex === -1) {
+    anchorIndex = focusedIndex === -1 ? index : focusedIndex;
   }
-  const min = Math.min(firstSelectedIndex, index);
-  const max = Math.min(firstSelectedIndex, index);
-  return handleRangeSelection(state, min, max);
+  const min = Math.min(anchorIndex, index);
+  const max = Math.max(anchorIndex, index);
+  const newState = handleRangeSelection(state, min, max);
+  return {
+    ...newState,
+    focusedIndex: index
+  };
 };
 
 const toggleIndividualSelection = async (state, index) => {
@@ -4835,12 +5432,15 @@ const getSettings = async () => {
   const confirmPaste = confirmPasteRaw === false ? false : false;
   const excludedRaw = await invoke$2('Preferences.get', 'files.exclude');
   const excluded = getExcluded(excludedRaw);
+  const gitIgnoreDecorationsRaw = await invoke$2('Preferences.get', 'explorer.gitIgnoreDecorations');
+  const gitIgnoreDecorations = gitIgnoreDecorationsRaw === false ? false : true;
   const sourceControlDecorationsRaw = await invoke$2('Preferences.get', 'explorer.sourceControlDecorations');
   const sourceControlDecorations = sourceControlDecorationsRaw === false ? false : true;
   return {
     confirmDelete,
     confirmPaste,
     excluded,
+    gitIgnoreDecorations,
     sourceControlDecorations,
     useChevrons
   };
@@ -4954,6 +5554,7 @@ const loadContent = async (state, savedState) => {
   const {
     confirmDelete,
     excluded,
+    gitIgnoreDecorations,
     sourceControlDecorations,
     useChevrons
   } = await getSettings();
@@ -4971,6 +5572,7 @@ const loadContent = async (state, savedState) => {
     const minLineY = Math.round(deltaY / itemHeight);
     const scheme = getScheme(root);
     const decorations = await getFileDecorations(scheme, root, restoredDirents.filter(item => item.depth === 1).map(item => item.path), sourceControlDecorations, assetDir, platform);
+    const sourceControlIgnoredUris = await getGitIgnoredUris(root, restoredDirents, pathSeparator, gitIgnoreDecorations);
     return {
       ...state,
       confirmDelete,
@@ -4979,6 +5581,7 @@ const loadContent = async (state, savedState) => {
       errorCode: '',
       errorMessage: '',
       excluded,
+      gitIgnoreDecorations,
       hasError: false,
       initial: false,
       isReadonly: isReadonly$1,
@@ -4987,6 +5590,7 @@ const loadContent = async (state, savedState) => {
       minLineY,
       pathSeparator,
       root,
+      sourceControlIgnoredUris,
       useChevrons
     };
   } catch (error) {
@@ -4997,6 +5601,7 @@ const loadContent = async (state, savedState) => {
       confirmDelete,
       errorCode,
       errorMessage,
+      gitIgnoreDecorations,
       hasError: true,
       initial: false,
       isReadonly: false,
@@ -5856,13 +6461,13 @@ const handleWheel = (state, deltaMode, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const handleWorkspaceChange = async state => {
+const handleWorkspaceChange = async (state, _workspacePath, savedState) => {
   const newRoot = await getWorkspacePath();
   const state1 = {
     ...state,
     root: newRoot
   };
-  const newState = await loadContent(state1, undefined);
+  const newState = await loadContent(state1, savedState);
   return newState;
 };
 
@@ -6852,8 +7457,9 @@ const revealItemHidden = async (state, uri) => {
   const pathPartsChildrenFlat = pathPartsChildren.flat();
   const orderedPathParts = orderDirents(pathPartsChildrenFlat);
   const mergedDirents = mergeVisibleWithHiddenItems(items, orderedPathParts);
+  const orderedDirents = orderDirents(mergedDirents);
   const expandedPaths = new Set(pathPartsToReveal.map(pathPart => pathPart.path));
-  const newDirents = mergedDirents.map(item => {
+  const newDirents = orderedDirents.map(item => {
     if (expandedPaths.has(item.path) && item.type === Directory) {
       return {
         ...item,
@@ -7116,8 +7722,8 @@ const commandMap = {
   'Explorer.handleResize': wrapListItemCommand(handleResize),
   'Explorer.handleUpload': wrapListItemCommand(handleUpload),
   'Explorer.handleWheel': wrapListItemCommand(handleWheel),
-  'Explorer.handleWorkspaceChange': wrapListItemCommand(handleWorkspaceChange),
-  'Explorer.handleWorkspaceRefresh': wrapListItemCommand(handleWorkspaceRefresh),
+  'Explorer.handleWorkspaceChange': wrapListItemCommandImmediate(handleWorkspaceChange),
+  'Explorer.handleWorkspaceRefresh': wrapListItemCommandImmediate(handleWorkspaceRefresh),
   'Explorer.initialize': initialize,
   'Explorer.loadContent': wrapListItemCommand(loadContent),
   'Explorer.newFile': wrapListItemCommand(newFile),

package/package.json

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