@lvce-editor/file-system-process 5.15.1 → 5.16.0

package/dist/index.js

@@ -666,7 +666,7 @@ const isWebSocketOpen = async webSocket => {
 };
 
 // @ts-ignore
-const serialize = message => {
+const serialize$1 = message => {
   return JSON.stringify(message);
 };
 
@@ -734,7 +734,7 @@ const wrap$9 = webSocket => {
     },
     // @ts-ignore
     send(message) {
-      const stringifiedMessage = serialize(message);
+      const stringifiedMessage = serialize$1(message);
       wrap.webSocket.send(stringifiedMessage);
     },
     start() {
@@ -778,10 +778,10 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const get$1 = id => {
+const get$2 = id => {
   return callbacks[id];
 };
-const remove$2 = id => {
+const remove$3 = id => {
   delete callbacks[id];
 };
 class JsonRpcError extends Error {
@@ -968,14 +968,14 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
-  remove$2(id);
+  remove$3(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -1402,13 +1402,13 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$2 = (id, rpc) => {
+const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete rpcs[id];
 };
 
@@ -1416,18 +1416,18 @@ const remove$1 = id => {
 const create$1 = rpcId => {
   return {
     async dispose() {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
+      const rpc = get$1(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1435,16 +1435,16 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$2(rpcId, mockRpc);
+      set$3(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
-        remove$1(rpcId);
+        remove$2(rpcId);
       };
       // @ts-ignore
       return mockRpc;
     },
     set(rpc) {
-      set$2(rpcId, rpc);
+      set$3(rpcId, rpc);
     }
   };
 };
@@ -1455,20 +1455,20 @@ const SharedProcess = 1492;
 
 const {
   invoke: invoke$1,
-  set: set$1
+  set: set$2
 } = create$1(MainProcess);
 
 const {
   invoke,
   invokeAndTransfer,
-  set
+  set: set$1
 } = create$1(SharedProcess);
 
-const state = {
+const state$1 = {
   id: 0
 };
 const create = () => {
-  return ++state.id;
+  return ++state$1.id;
 };
 
 const ports = Object.create(null);
@@ -1513,7 +1513,7 @@ const initializeMainProcessRpc = async () => {
       await invokeAndTransfer('TemporaryMessagePort.sendToElectron', port, MainProcess, FileSystemProcess);
     }
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const assertUri = uri => {
@@ -1529,6 +1529,149 @@ const ENOENT = 'ENOENT';
 const EROFS = 'EROFS';
 const EXDEV = 'EXDEV';
 
+const cacheVersion = 1;
+const maxEntries = 50_000;
+const cacheFolderName = 'file-system-process';
+const cacheFileName = 'file-hashes-v1.json';
+const state = {
+  cacheFilePath: '',
+  cacheFolderPath: '',
+  entries: new Map(),
+  loadPromise: undefined,
+  persistedRevision: 0,
+  revision: 0,
+  writePromise: undefined
+};
+const isSerializedCache = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const candidate = value;
+  return candidate.version === cacheVersion && Array.isArray(candidate.entries);
+};
+const isSerializedEntry = value => {
+  return Array.isArray(value) && value.length === 3 && typeof value[0] === 'string' && typeof value[1] === 'string' && typeof value[2] === 'string' && /^[\da-f]{64}$/.test(value[2]);
+};
+const parseCache = content => {
+  const parsed = JSON.parse(content);
+  if (!isSerializedCache(parsed) || !parsed.entries.every(isSerializedEntry)) {
+    return undefined;
+  }
+  return parsed.entries.slice(-maxEntries);
+};
+const load = async () => {
+  if (!state.cacheFilePath) {
+    return;
+  }
+  try {
+    const content = await fs.readFile(state.cacheFilePath, 'utf8');
+    const cachedEntries = parseCache(content);
+    if (!cachedEntries) {
+      return;
+    }
+    for (const [path, fingerprint, hash] of cachedEntries) {
+      state.entries.delete(path);
+      state.entries.set(path, {
+        fingerprint,
+        hash
+      });
+    }
+  } catch {
+    // A persistent cache miss must fall back to hashing the source files.
+  }
+};
+const configure = cacheDirectory => {
+  state.entries.clear();
+  state.cacheFolderPath = cacheDirectory ? join(cacheDirectory, cacheFolderName) : '';
+  state.cacheFilePath = state.cacheFolderPath ? join(state.cacheFolderPath, cacheFileName) : '';
+  state.loadPromise = undefined;
+  state.persistedRevision = 0;
+  state.revision = 0;
+  state.writePromise = undefined;
+};
+const ensureLoaded = async () => {
+  state.loadPromise ||= load();
+  await state.loadPromise;
+};
+const get = (path, fingerprint) => {
+  const entry = state.entries.get(path);
+  if (!entry || entry.fingerprint !== fingerprint) {
+    return undefined;
+  }
+  state.entries.delete(path);
+  state.entries.set(path, entry);
+  return entry.hash;
+};
+const set = (path, fingerprint, hash) => {
+  const previous = state.entries.get(path);
+  state.entries.delete(path);
+  state.entries.set(path, {
+    fingerprint,
+    hash
+  });
+  if (!previous || previous.fingerprint !== fingerprint || previous.hash !== hash) {
+    state.revision++;
+  }
+  if (state.entries.size <= maxEntries) {
+    return;
+  }
+  const oldestPath = state.entries.keys().next().value;
+  if (oldestPath !== undefined) {
+    state.entries.delete(oldestPath);
+    state.revision++;
+  }
+};
+const remove$1 = path => {
+  if (state.entries.delete(path)) {
+    state.revision++;
+  }
+};
+const serialize = () => {
+  const serializedEntries = Array.from(state.entries, ([path, entry]) => [path, entry.fingerprint, entry.hash]);
+  return JSON.stringify({
+    entries: serializedEntries,
+    version: cacheVersion
+  });
+};
+const writeCurrentState = async () => {
+  while (state.cacheFilePath && state.persistedRevision !== state.revision) {
+    const snapshotRevision = state.revision;
+    const temporaryPath = `${state.cacheFilePath}.${process.pid}.tmp`;
+    try {
+      await fs.mkdir(state.cacheFolderPath, {
+        recursive: true
+      });
+      await fs.writeFile(temporaryPath, serialize());
+      await fs.rename(temporaryPath, state.cacheFilePath);
+      state.persistedRevision = snapshotRevision;
+    } catch {
+      try {
+        await fs.rm(temporaryPath, {
+          force: true
+        });
+      } catch {
+        // Best-effort cleanup only.
+      }
+      return;
+    }
+  }
+};
+const flush = async () => {
+  await ensureLoaded();
+  if (!state.cacheFilePath) {
+    return;
+  }
+  const writePromise = state.writePromise || writeCurrentState();
+  state.writePromise = writePromise;
+  try {
+    await writePromise;
+  } finally {
+    if (state.writePromise === writePromise) {
+      state.writePromise = undefined;
+    }
+  }
+};
+
 const getDisplayPath = path => {
   if (path === '') {
     return '<empty string>';
@@ -1682,44 +1825,21 @@ const readFile = async (uri, encoding = Utf8) => {
     throw new VError(error, `Failed to read file "${uri}"`);
   }
 };
-const fileHashCache = new Map();
-const maxFileHashCacheEntries = 50_000;
 const getFileFingerprint = stats => {
   return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeNs}:${stats.ctimeNs}`;
 };
-const getCachedFileHash = (path, fingerprint) => {
-  const entry = fileHashCache.get(path);
-  if (!entry || entry.fingerprint !== fingerprint) {
-    return undefined;
-  }
-  fileHashCache.delete(path);
-  fileHashCache.set(path, entry);
-  return entry.hash;
-};
-const setCachedFileHash = (path, fingerprint, hash) => {
-  fileHashCache.delete(path);
-  fileHashCache.set(path, {
-    fingerprint,
-    hash
-  });
-  if (fileHashCache.size <= maxFileHashCacheEntries) {
-    return;
-  }
-  const oldestPath = fileHashCache.keys().next().value;
-  if (oldestPath) {
-    fileHashCache.delete(oldestPath);
-  }
-};
 const getFileHash = async uri => {
+  let path = '';
   try {
     string(uri);
     assertUri(uri);
-    const path = fileURLToPath(uri);
+    path = fileURLToPath(uri);
+    await ensureLoaded();
     const statsBeforeRead = await fs.stat(path, {
       bigint: true
     });
     const fingerprintBeforeRead = getFileFingerprint(statsBeforeRead);
-    const cachedHash = getCachedFileHash(path, fingerprintBeforeRead);
+    const cachedHash = get(path, fingerprintBeforeRead);
     if (cachedHash) {
       return cachedHash;
     }
@@ -1730,11 +1850,14 @@ const getFileHash = async uri => {
     });
     const fingerprintAfterRead = getFileFingerprint(statsAfterRead);
     if (fingerprintBeforeRead === fingerprintAfterRead) {
-      setCachedFileHash(path, fingerprintAfterRead, hash);
+      set(path, fingerprintAfterRead, hash);
     }
     return hash;
   } catch (error) {
     if (isEnoentError(error)) {
+      if (path) {
+        remove$1(path);
+      }
       throw new FileNotFoundError(uri);
     }
     throw new VError(error, `Failed to hash file "${uri}"`);
@@ -1768,6 +1891,7 @@ const getFileHashes = async uris => {
   await Promise.all(Array.from({
     length: workerCount
   }, hashNext));
+  await flush();
   return hashes;
 };
 const writeFile = async (uri, content, encoding = Utf8) => {
@@ -2009,7 +2133,7 @@ const handleElectronMessagePort = async (messagePort, rpcId) => {
     requiresSocket: false
   });
   if (rpcId) {
-    set$2(rpcId, rpc);
+    set$3(rpcId, rpc);
   }
 };
 
@@ -2027,8 +2151,8 @@ const handleWebSocket = async (handle, request) => {
   });
 };
 
-const initialize = async () => {
-  // TODO this function is not needed anymore
+const initialize = async cacheDirectory => {
+  configure(cacheDirectory);
 };
 
 const commandMap = {
@@ -2080,7 +2204,7 @@ const getRpc = argv => {
 const initializeParentProcessRpc = async argv => {
   const rpc = await getRpc(argv);
   // TODO we don't know at this point if we have been launched by shared process or electron main process
-  set(rpc);
+  set$1(rpc);
 };
 
 const listen = async argv => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-process",
-  "version": "5.15.1",
+  "version": "5.16.0",
   "description": "File System Process",
   "keywords": [
     "Lvce Editor",
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "trash": "^10.1.1",
-    "ws": "^8.21.1"
+    "ws": "^8.21.3"
   },
   "engines": {
     "node": ">=24"