@lvce-editor/file-watcher-process 4.13.0 → 4.14.1

package/dist/index.js

@@ -1,7 +1,9 @@
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as fs from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { FSWatcher } from 'chokidar';
-import { join } from 'node:path';
+import ignore from 'ignore';
+import { join, relative } from 'node:path';
 
 const handleUncaughtExceptionMonitor = error => {
   console.error(`[file-watcher-process] Uncaught Exception: ${error}`);
@@ -1253,7 +1255,7 @@ const normalizeEvent = (eventName, path) => {
   };
 };
 
-const waitForWatcherToBeReady = async watcher => {
+const waitForWatcherToBeReady = async (watcher, signal) => {
   const {
     promise,
     reject,
@@ -1262,6 +1264,7 @@ const waitForWatcherToBeReady = async watcher => {
   const cleanup = () => {
     watcher.off('ready', handleReady);
     watcher.off('error', handleError);
+    signal?.removeEventListener('abort', handleAbort);
   };
   const handleReady = () => {
     cleanup();
@@ -1271,6 +1274,13 @@ const waitForWatcherToBeReady = async watcher => {
     cleanup();
     reject(error);
   };
+  const handleAbort = () => {
+    handleError(signal?.reason);
+  };
+  signal?.throwIfAborted();
+  signal?.addEventListener('abort', handleAbort, {
+    once: true
+  });
   watcher.on('ready', handleReady);
   watcher.on('error', handleError);
   await promise;
@@ -1324,7 +1334,7 @@ const callBackInternal = async (eventName, path, stats) => {
 const callback = (eventName, path, stats) => {
   void callBackInternal(eventName, path);
 };
-const errorCallback$1 = error => {
+const errorCallback = error => {
   console.error(`[file-watcher-process] ${error}`);
 };
 const watchFolder = async uri => {
@@ -1333,7 +1343,7 @@ const watchFolder = async uri => {
     const path = fileURLToPath(uri);
     watcher = new FSWatcher();
     watcher.on('all', callback);
-    watcher.on('error', errorCallback$1);
+    watcher.on('error', errorCallback);
     const readyPromise = waitForWatcherToBeReady(watcher);
     watcher.add(path);
     await readyPromise;
@@ -1388,43 +1398,99 @@ const normalizeEvent2 = (id, eventName, path) => {
   };
 };
 
-const errorCallback = error => {
-  console.error(`[file-watcher-process] ${error}`);
+const createIgnore = ignore;
+const loadGitIgnore = async (root, enabled) => {
+  try {
+    const content = await readFile(`${root}/.gitignore`, 'utf8');
+    return createIgnore().add(content);
+  } catch {
+    return undefined;
+  }
 };
-const createIgnored = exclude => {
+const createExcludedNamesFilter = exclude => {
   const excludedNames = new Set(exclude);
-  return path => {
-    return path.split(/[\\/]/).some(part => excludedNames.has(part));
+  return path => path.split(/[\\/]/).some(part => excludedNames.has(part));
+};
+const createIgnored = async (root, exclude, useGitIgnore) => {
+  const isExcludedName = createExcludedNamesFilter(exclude);
+  const gitIgnore = await loadGitIgnore(root);
+  return (path, stats) => {
+    if (isExcludedName(path)) {
+      return true;
+    }
+    if (!gitIgnore) {
+      return false;
+    }
+    const relativePath = relative(root, path).replaceAll('\\', '/');
+    if (!relativePath || relativePath.startsWith('../')) {
+      return false;
+    }
+    const candidate = stats?.isDirectory() ? `${relativePath}/` : relativePath;
+    return gitIgnore.ignores(candidate);
   };
 };
+const send = event => {
+  void invoke('FileWatcher.handleChange', event).catch(error => {
+    console.error(`[file-watcher-process] ${error}`);
+  });
+};
 const watchFolders = async ({
   exclude,
   id,
-  roots
+  roots,
+  useGitIgnore = false
 }) => {
-  const callBackInternal = async (eventName, path, stats) => {
-    const event = normalizeEvent2(id, eventName, path);
-
-    // TODO maybe just use send instead of invoke or
-    // send the message to a websocket or message channel directly
-    // instead of routing events through shared process
-    // which might lock up the shared process in case there are many events
-    await invoke('FileWatcher.handleChange', event);
+  if (has(id)) {
+    return fromError(new Error(`watcher ${id} is already registered`));
+  }
+  const controller = new AbortController();
+  const watcherEntries = [];
+  let ready = false;
+  let closing;
+  const callback = (eventName, path) => {
+    if (!controller.signal.aborted) {
+      send(normalizeEvent2(id, eventName, path));
+    }
   };
-  const callback = (eventName, path, stats) => {
-    void callBackInternal(eventName, path);
+  const errorCallback = error => {
+    console.error(`[file-watcher-process] ${error}`);
+    if (controller.signal.aborted) return;
+    if (ready) {
+      send({
+        ...fromError(error),
+        eventName: 'error',
+        id,
+        uri: ''
+      });
+    }
+    controller.abort(error);
   };
-  const watcherEntries = [];
+  controller.signal.addEventListener('abort', () => {
+    remove(id);
+    closing = Promise.allSettled(watcherEntries.map(({
+      watcher
+    }) => watcher.close()));
+  }, {
+    once: true
+  });
+  // Register before asynchronous setup so disposal also cancels a pending watch.
+  add(id, controller);
   try {
     for (const root of roots) {
+      controller.signal.throwIfAborted();
       const path = fileURLToPath(root);
+      const ignored = useGitIgnore ? await createIgnored(path, exclude, true) : createExcludedNamesFilter(exclude);
+      controller.signal.throwIfAborted();
       const watcher = new FSWatcher({
-        ignored: createIgnored(exclude),
+        ignored,
         ignoreInitial: true,
-        ignorePermissionErrors: true
+        ignorePermissionErrors: false
       });
       watcher.on('error', errorCallback);
-      const readyPromise = waitForWatcherToBeReady(watcher);
+      watcher.on('all', callback);
+      const readyPromise = waitForWatcherToBeReady(watcher, controller.signal);
+      // Later roots can fail before Promise.all is reached.
+      void readyPromise.catch(() => {});
       watcherEntries.push({
         readyPromise,
         watcher
@@ -1434,31 +1500,16 @@ const watchFolders = async ({
     await Promise.all(watcherEntries.map(({
       readyPromise
     }) => readyPromise));
+    controller.signal.throwIfAborted();
+    ready = true;
+    const inotifyWatchCount = await getInotifyWatchCount();
+    controller.signal.throwIfAborted();
+    return inotifyWatchCount === undefined ? success : successWithInotifyWatchCount(inotifyWatchCount);
   } catch (error) {
-    await Promise.allSettled(watcherEntries.map(({
-      watcher
-    }) => watcher.close()));
+    controller.abort(error);
+    await closing;
     return fromError(error);
   }
-  for (const {
-    watcher
-  } of watcherEntries) {
-    watcher.on('all', callback);
-  }
-  const controller = new AbortController();
-  controller.signal.addEventListener('abort', () => {
-    void Promise.allSettled(watcherEntries.map(({
-      watcher
-    }) => watcher.close()));
-  }, {
-    once: true
-  });
-  add(id, controller);
-  const inotifyWatchCount = await getInotifyWatchCount();
-  if (inotifyWatchCount === undefined) {
-    return success;
-  }
-  return successWithInotifyWatchCount(inotifyWatchCount);
 };
 
 const commandMap = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-watcher-process",
-  "version": "4.13.0",
+  "version": "4.14.1",
   "description": "File Watcher Process",
   "keywords": [
     "Lvce Editor",
@@ -19,7 +19,8 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.5.1",
-    "chokidar": "^5.0.0"
+    "chokidar": "^5.0.0",
+    "ignore": "^5.3.2"
   },
   "engines": {
     "node": ">=22"