@allurereport/directory-watcher 3.15.0 → 3.16.1

package/dist/index.d.ts

@@ -5,4 +5,4 @@ declare const watchDirectory: (directory: string, handler: (eventName: EventName
 }) => () => Promise<void>;
 export default watchDirectory;
 export type { Watcher } from "./watcher.js";
-export { findMatching, newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";
+export { findMatching, difference, watch, newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";

package/dist/index.js

@@ -12,4 +12,4 @@ const watchDirectory = (directory, handler, options = {}) => {
     return () => watcher.close();
 };
 export default watchDirectory;
-export { findMatching, newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";
+export { findMatching, difference, watch, newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";

package/dist/watcher.d.ts

@@ -1,7 +1,7 @@
 import type { Dirent } from "node:fs";
 export declare const isFileNotFoundError: (e: unknown) => e is Error;
 export declare const difference: (before: Set<string>, after: Set<string>) => [Set<string>, Set<string>];
-export declare const findMatching: (watchDirectory: string, existingResults: Set<string>, match: (dirent: Dirent) => boolean, maximumDepth?: number) => Promise<void>;
+export declare const findMatching: (watchDirectory: string, existingResults: Set<string>, match: (dirent: Dirent) => boolean, maximumDepth?: number, signal?: AbortSignal) => Promise<boolean>;
 interface WatchOptions {
     indexDelay?: number;
     abortController?: AbortController;
@@ -11,6 +11,7 @@ export interface Watcher {
     initialScan: () => Promise<void>;
     watchEnd: () => Promise<void>;
 }
+export declare const watch: (initialCallback: () => Promise<void>, iterationCallback: () => Promise<void>, doneCallback: () => Promise<void>, options?: WatchOptions) => Watcher;
 interface WatchNewFilesOptions extends WatchOptions {
     recursive?: boolean;
     maximumDepth?: number;

package/dist/watcher.js

@@ -18,39 +18,58 @@ export const difference = (before, after) => {
     }
     return [added, deleted];
 };
-export const findMatching = async (watchDirectory, existingResults, match, maximumDepth = 5) => {
-    try {
-        const dir = await opendir(watchDirectory);
-        for await (const dirent of dir) {
-            const path = join(dirent.parentPath ?? dirent.path, dirent.name);
-            if (dirent.name.at(0) === "." || dirent.name === "node_modules") {
-                continue;
-            }
-            if (existingResults.has(path)) {
-                continue;
-            }
-            if (match(dirent)) {
-                existingResults.add(path);
-                continue;
-            }
-            if (dirent.isDirectory() && maximumDepth > 0) {
-                await findMatching(path, existingResults, match, maximumDepth - 1);
+export const findMatching = async (watchDirectory, existingResults, match, maximumDepth = 5, signal) => {
+    const scan = async (directory, remainingDepth, isRoot) => {
+        if (signal?.aborted) {
+            return false;
+        }
+        try {
+            const dir = await opendir(directory);
+            for await (const dirent of dir) {
+                if (signal?.aborted) {
+                    return false;
+                }
+                const path = join(dirent.parentPath ?? dirent.path, dirent.name);
+                if (dirent.name.at(0) === "." || dirent.name === "node_modules") {
+                    continue;
+                }
+                if (existingResults.has(path)) {
+                    continue;
+                }
+                if (match(dirent)) {
+                    existingResults.add(path);
+                    continue;
+                }
+                if (dirent.isDirectory() && remainingDepth > 0) {
+                    const completed = await scan(path, remainingDepth - 1, false);
+                    if (!completed) {
+                        return false;
+                    }
+                }
             }
+            return !signal?.aborted;
         }
-    }
-    catch (e) {
-        if (isFileNotFoundError(e)) {
-            existingResults.clear();
-            return;
+        catch (e) {
+            if (isFileNotFoundError(e)) {
+                if (isRoot) {
+                    existingResults.clear();
+                }
+                return true;
+            }
+            console.error("can't read directory", e);
+            return false;
         }
-        console.error("can't read directory", e);
-    }
+    };
+    return scan(watchDirectory, maximumDepth, true);
 };
-const findFiles = async (watchDirectory, existingResults, onNewFile, recursive, maximumDepth = 10) => {
+const findFiles = async (watchDirectory, existingResults, onNewFile, recursive, maximumDepth = 10, signal) => {
     const scanDirectory = async (directory, isRoot, remainingDepth) => {
         try {
             const dir = await opendir(directory);
             for await (const dirent of dir) {
+                if (signal?.aborted) {
+                    return;
+                }
                 const path = join(dirent.parentPath ?? dirent.path, dirent.name);
                 if (dirent.isDirectory()) {
                     if (recursive && remainingDepth > 0) {
@@ -100,7 +119,7 @@ const repeatedIteration = async (indexInterval, callback, ...ac) => {
         .then(() => repeatedIteration(indexInterval, callback, ...ac));
 };
 const noop = async () => { };
-const watch = (initialCallback, iterationCallback, doneCallback, options = {}) => {
+export const watch = (initialCallback, iterationCallback, doneCallback, options = {}) => {
     const { indexDelay = 300, abortController: haltAc = new AbortController() } = options;
     const gracefulShutdownAc = new AbortController();
     const init = singleIteration(initialCallback, haltAc);
@@ -132,26 +151,30 @@ const watch = (initialCallback, iterationCallback, doneCallback, options = {}) =
     };
 };
 export const newFilesInDirectoryWatcher = (directory, onNewFile, options = {}) => {
-    const { recursive = true, maximumDepth = 10, ignoreInitial = false, ...rest } = options;
+    const { recursive = true, maximumDepth = 10, ignoreInitial = false, abortController = new AbortController(), ...rest } = options;
     const indexedFiles = new Set();
     const initialCallback = async () => {
-        await findFiles(directory, indexedFiles, ignoreInitial ? noop : onNewFile, recursive, maximumDepth);
+        await findFiles(directory, indexedFiles, ignoreInitial ? noop : onNewFile, recursive, maximumDepth, abortController.signal);
     };
     const iterationCallback = async () => {
-        await findFiles(directory, indexedFiles, onNewFile, recursive, maximumDepth);
+        await findFiles(directory, indexedFiles, onNewFile, recursive, maximumDepth, abortController.signal);
     };
-    return watch(initialCallback, iterationCallback, iterationCallback, rest);
+    return watch(initialCallback, iterationCallback, iterationCallback, { ...rest, abortController });
 };
 export const allureResultsDirectoriesWatcher = (directory, update, options = {}) => {
+    const { abortController = new AbortController(), ...rest } = options;
     let previousAllureResults = new Set();
     const callback = async () => {
         const currentAllureResults = new Set();
-        await findMatching(directory, currentAllureResults, (dirent) => dirent.isDirectory() && dirent.name === "allure-results");
+        const completed = await findMatching(directory, currentAllureResults, (dirent) => dirent.isDirectory() && dirent.name === "allure-results", undefined, abortController.signal);
+        if (!completed) {
+            return;
+        }
         const [added, deleted] = difference(previousAllureResults, currentAllureResults);
         await update(added, deleted);
         previousAllureResults = currentAllureResults;
     };
-    return watch(callback, callback, callback, options);
+    return watch(callback, callback, callback, { ...rest, abortController });
 };
 const calculateInfo = async (file) => {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/directory-watcher",
-  "version": "3.15.0",
+  "version": "3.16.1",
   "description": "File system watcher for directories",
   "keywords": [
     "allure",