@lvce-editor/file-system-worker 5.16.0 → 5.18.0

package/dist/fileSystemWorkerMain.js

@@ -1256,6 +1256,34 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
 const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
@@ -1291,34 +1319,6 @@ const create$5 = async ({
   });
 };
 
-const createSharedLazyRpc = factory => {
-  let rpcPromise;
-  const getOrCreate = () => {
-    if (!rpcPromise) {
-      rpcPromise = factory();
-    }
-    return rpcPromise;
-  };
-  return {
-    async dispose() {
-      const rpc = await getOrCreate();
-      await rpc.dispose();
-    },
-    async invoke(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    async send(method, ...params) {
-      const rpc = await getOrCreate();
-      rpc.send(method, ...params);
-    }
-  };
-};
-
 const create$4 = async ({
   commandMap,
   isMessagePortOpen,
@@ -1506,6 +1506,9 @@ const create = rpcId => {
   };
 };
 
+const Directory$1 = 3;
+const File$3 = 7;
+
 const DebugWorker = 55;
 const ExtensionHostWorker = 44;
 const FileSystemProcess$1 = 210;
@@ -1596,58 +1599,101 @@ const FileSystemProcess = {
    writeFile: writeFile$4
 };
 
-const {
-  set: set$2
-} = create(RendererProcess);
-
-const {
-  invoke: invoke$2,
-  invokeAndTransfer,
-  set: set$1
-} = create(RendererWorker);
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const sendMessagePortToFileSystemProcess$1 = async (port, rpcId) => {
-  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
-};
-
 const createLazyRpc = rpcId => {
-  let rpcPromise;
+  let activeRpc;
   let factory;
-  const createRpc = async () => {
+  let generation = 0;
+  let rpcPromise;
+  const resetListeners = new Set();
+  const createRpc = async expectedGeneration => {
     const rpc = await factory();
+    if (generation !== expectedGeneration) {
+      await rpc.dispose();
+      throw new Error('Lazy RPC launch was superseded');
+    }
+    activeRpc = rpc;
     set$5(rpcId, rpc);
+    return rpc;
   };
   const ensureRpc = async () => {
+    if (activeRpc) {
+      return activeRpc;
+    }
     if (!rpcPromise) {
-      rpcPromise = createRpc();
+      const pending = createRpc(generation);
+      rpcPromise = pending;
+      void pending.catch(() => {
+        if (rpcPromise === pending) {
+          rpcPromise = undefined;
+        }
+      });
     }
-    await rpcPromise;
+    return rpcPromise;
+  };
+  const clear = async (reason, notify) => {
+    generation++;
+    const rpc = activeRpc;
+    activeRpc = undefined;
+    rpcPromise = undefined;
+    if (rpc && get(rpcId) === rpc) {
+      remove$5(rpcId);
+    }
+    if (notify) {
+      for (const listener of resetListeners) {
+        listener(reason);
+      }
+    }
+    await rpc?.dispose();
   };
   return {
+    dispose() {
+      return clear(undefined, false);
+    },
     async invoke(method, ...params) {
-      await ensureRpc();
-      const rpc = get(rpcId);
+      const rpc = await ensureRpc();
       return rpc.invoke(method, ...params);
     },
     async invokeAndTransfer(method, ...params) {
-      await ensureRpc();
-      const rpc = get(rpcId);
+      const rpc = await ensureRpc();
       return rpc.invokeAndTransfer(method, ...params);
     },
+    onDidReset(listener) {
+      resetListeners.add(listener);
+      return () => {
+        resetListeners.delete(listener);
+      };
+    },
+    reset(reason) {
+      return clear(reason, true);
+    },
     setFactory(value) {
       factory = value;
     }
   };
 };
 
+const {
+  set: set$2
+} = create(RendererProcess);
+
+const {
+  invoke: invoke$2,
+  invokeAndTransfer,
+  set: set$1
+} = create(RendererWorker);
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const sendMessagePortToFileSystemProcess$1 = async (port, rpcId) => {
+  const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
+};
+
 const remove$3 = async dirent => {
   throw new Error('not implemented');
 };
@@ -1740,6 +1786,9 @@ const assertUri = uri => {
 const getFileHash$1 = async uri => {
   return invoke$3('FileSystem.getFileHash', uri);
 };
+const getFileHashes$1 = async uris => {
+  return invoke$3('FileSystem.getFileHashes', uris);
+};
 const {
   appendFile: appendFile$1,
   copy: copy$2,
@@ -1981,6 +2030,9 @@ const readFile = async uri => {
 const getFileHash = async uri => {
   return getFileHash$1(uri);
 };
+const getFileHashes = async uris => {
+  return getFileHashes$1(uris);
+};
 const appendFile = async (uri, text) => {
   return appendFile$1(uri, text);
 };
@@ -2097,6 +2149,7 @@ const FileSystemDisk = {
    createFile,
    exists,
    getFileHash,
+   getFileHashes,
    getFolderSize,
    getPathSeparator,
    getRealPath,
@@ -2113,6 +2166,250 @@ const FileSystemDisk = {
    writeFile
 };
 
+const createGlobImplementation = () => {
+  const batchSize = 32;
+  /* eslint-disable unicorn/consistent-function-scoping -- Keep implementation helpers lazy to stay within the worker memory budget. */
+
+  const joinPath = (base, name) => {
+    return base ? `${base}/${name}` : name;
+  };
+  const joinUri = (base, name) => {
+    return base.endsWith('/') ? `${base}${name}` : `${base}/${name}`;
+  };
+  const escapeRegexCharacter = character => {
+    return /[\\^$.*+?()[\]|{}]/.test(character) ? `\\${character}` : character;
+  };
+  const getCharacterClass = (pattern, index) => {
+    const endIndex = pattern.indexOf(']', index + 1);
+    if (endIndex === -1) {
+      return undefined;
+    }
+    let contents = pattern.slice(index + 1, endIndex).replaceAll('\\', '\\\\');
+    if (contents.startsWith('!')) {
+      contents = `^${contents.slice(1)}`;
+    }
+    return {
+      endIndex,
+      source: `[${contents}]`
+    };
+  };
+  const getAsteriskToken = (pattern, index) => {
+    if (pattern[index + 1] !== '*') {
+      return {
+        endIndex: index,
+        source: '[^/]*'
+      };
+    }
+    if (pattern[index + 2] === '/') {
+      return {
+        endIndex: index + 2,
+        source: '(?:.*/)?'
+      };
+    }
+    return {
+      endIndex: index + 1,
+      source: '.*'
+    };
+  };
+  const getCharacterClassToken = (pattern, index) => {
+    return getCharacterClass(pattern, index) || {
+      endIndex: index,
+      source: '\\['
+    };
+  };
+  const getEscapeToken = (pattern, index) => {
+    const nextCharacter = pattern[index + 1];
+    if (!nextCharacter) {
+      return {
+        endIndex: index,
+        source: '\\\\'
+      };
+    }
+    return {
+      endIndex: index + 1,
+      source: escapeRegexCharacter(nextCharacter)
+    };
+  };
+  const getGlobToken = (pattern, index) => {
+    const character = pattern[index];
+    switch (character) {
+      case '?':
+        return {
+          endIndex: index,
+          source: '[^/]'
+        };
+      case '[':
+        return getCharacterClassToken(pattern, index);
+      case '*':
+        return getAsteriskToken(pattern, index);
+      case '\\':
+        return getEscapeToken(pattern, index);
+      default:
+        return {
+          endIndex: index,
+          source: escapeRegexCharacter(character)
+        };
+    }
+  };
+  const globToRegexSource = pattern => {
+    let source = '';
+    let index = 0;
+    while (index < pattern.length) {
+      const token = getGlobToken(pattern, index);
+      source += token.source;
+      index = token.endIndex + 1;
+    }
+    return source;
+  };
+  const compileGlob = pattern => {
+    const regex = new RegExp(`^${globToRegexSource(pattern)}$`);
+    return path => regex.test(path);
+  };
+  const compileIgnoreRule = line => {
+    let pattern = line.trimEnd();
+    if (!pattern || pattern.startsWith('#')) {
+      return undefined;
+    }
+    let ignored = true;
+    if (pattern.startsWith('!')) {
+      ignored = false;
+      pattern = pattern.slice(1);
+    } else if (pattern.startsWith('\\!') || pattern.startsWith('\\#')) {
+      pattern = pattern.slice(1);
+    }
+    const directoryOnly = pattern.endsWith('/');
+    if (directoryOnly) {
+      pattern = pattern.slice(0, -1);
+    }
+    const anchored = pattern.startsWith('/');
+    if (anchored) {
+      pattern = pattern.slice(1);
+    }
+    if (!pattern) {
+      return undefined;
+    }
+    const prefix = anchored || pattern.includes('/') ? '^' : '(?:^|/)';
+    return {
+      directoryOnly,
+      ignored,
+      regex: new RegExp(`${prefix}${globToRegexSource(pattern)}$`)
+    };
+  };
+  const parseGitIgnore = contents => {
+    const rules = [];
+    for (const line of contents.split(/\r?\n/)) {
+      const rule = compileIgnoreRule(line);
+      if (rule) {
+        rules.push(rule);
+      }
+    }
+    return rules;
+  };
+  const getPathForLayer = (relativePath, layerBasePath) => {
+    if (!layerBasePath) {
+      return relativePath;
+    }
+    return relativePath.slice(layerBasePath.length + 1);
+  };
+  const isIgnored = (relativePath, isDirectory, ignoreLayers) => {
+    let ignored = false;
+    for (const layer of ignoreLayers) {
+      if (layer.basePath && relativePath !== layer.basePath && !relativePath.startsWith(`${layer.basePath}/`)) {
+        continue;
+      }
+      const pathForLayer = getPathForLayer(relativePath, layer.basePath);
+      for (const rule of layer.rules) {
+        const {
+          directoryOnly,
+          ignored: ruleIgnored,
+          regex
+        } = rule;
+        if ((!directoryOnly || isDirectory) && regex.test(pathForLayer)) {
+          ignored = ruleIgnored;
+        }
+      }
+    }
+    return ignored;
+  };
+  const readIgnoreLayer = async (fileSystem, uri, relativePath, entries) => {
+    const gitIgnore = entries.find(entry => entry.name === '.gitignore' && entry.type === File$3);
+    if (!gitIgnore) {
+      return undefined;
+    }
+    try {
+      const contents = await fileSystem.readFile(joinUri(uri, gitIgnore.name));
+      return {
+        basePath: relativePath,
+        rules: parseGitIgnore(contents)
+      };
+    } catch {
+      return undefined;
+    }
+  };
+  const scanDirectory = async (fileSystem, task, isMatch) => {
+    const entries = await fileSystem.readDirWithFileTypes(task.uri);
+    const ignoreLayer = await readIgnoreLayer(fileSystem, task.uri, task.relativePath, entries);
+    const ignoreLayers = ignoreLayer ? [...task.ignoreLayers, ignoreLayer] : task.ignoreLayers;
+    const directories = [];
+    const matches = [];
+    const sortedEntries = entries.toSorted((left, right) => left.name.localeCompare(right.name));
+    for (const entry of sortedEntries) {
+      const relativePath = joinPath(task.relativePath, entry.name);
+      if (entry.type === Directory$1) {
+        if (entry.name !== '.git' && !isIgnored(relativePath, true, ignoreLayers)) {
+          directories.push({
+            ignoreLayers,
+            relativePath,
+            uri: joinUri(task.uri, entry.name)
+          });
+        }
+      } else if (entry.type === File$3 && isMatch(relativePath) && !isIgnored(relativePath, false, ignoreLayers)) {
+        matches.push(joinUri(task.uri, entry.name));
+      }
+    }
+    return {
+      directories,
+      matches
+    };
+  };
+  const globWithFileSystemImplementation = async (fileSystem, root, pattern) => {
+    const isMatch = compileGlob(pattern);
+    const matches = [];
+    let pending = [{
+      ignoreLayers: [],
+      relativePath: '',
+      uri: root
+    }];
+    while (pending.length > 0) {
+      const next = [];
+      for (let index = 0; index < pending.length; index += batchSize) {
+        const batch = pending.slice(index, index + batchSize);
+        const results = await Promise.all(batch.map(task => scanDirectory(fileSystem, task, isMatch)));
+        for (const result of results) {
+          next.push(...result.directories);
+          matches.push(...result.matches);
+        }
+      }
+      pending = next;
+    }
+    return matches.toSorted((left, right) => left.localeCompare(right));
+  };
+
+  /* eslint-enable unicorn/consistent-function-scoping */
+  return globWithFileSystemImplementation;
+};
+const createLazyGlobImplementation = () => {
+  let implementation;
+  return async (fileSystem, root, pattern) => {
+    implementation ||= createGlobImplementation();
+    return implementation(fileSystem, root, pattern);
+  };
+};
+const globWithFileSystem = createLazyGlobImplementation();
+const glob = async (root, pattern) => {
+  return globWithFileSystem(FileSystemDisk, root, pattern);
+};
+
 const handleMessagePort = async (port, rpcId) => {
   const rpc = await create$6({
     commandMap: {},
@@ -2310,9 +2607,11 @@ const commandMap = {
   'FileSystem.executeWatchCallback': executeWatchCallback,
   'FileSystem.exists': exists,
   'FileSystem.getFileHash': getFileHash,
+  'FileSystem.getFileHashes': getFileHashes,
   'FileSystem.getFolderSize': getFolderSize,
   'FileSystem.getPathSeparator': getPathSeparator,
   'FileSystem.getRealPath': getRealPath,
+  'FileSystem.glob': glob,
   'FileSystem.handleMessagePort': handleMessagePort,
   'FileSystem.isReadonly': isReadonly,
   'FileSystem.mkdir': mkdir,
@@ -2353,7 +2652,7 @@ const initializeExtensionHostWorker = async () => {
   try {
     const rpc = await create$4({
       commandMap: {},
-      send: sendMessagePortToExtensionHostWorker
+      send: port => sendMessagePortToExtensionManagementWorker(port, 0)
     });
     set$4(rpc);
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "5.16.0",
+  "version": "5.18.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"