@allurereport/directory-watcher 3.8.2 → 3.9.0

package/dist/watcher.d.ts

@@ -13,6 +13,7 @@ export interface Watcher {
 }
 interface WatchNewFilesOptions extends WatchOptions {
     recursive?: boolean;
+    maximumDepth?: number;
     indexDelay?: number;
     ignoreInitial?: boolean;
     abortController?: AbortController;

package/dist/watcher.js

@@ -46,35 +46,43 @@ export const findMatching = async (watchDirectory, existingResults, match, maxim
         console.error("can't read directory", e);
     }
 };
-const findFiles = async (watchDirectory, existingResults, onNewFile, recursive) => {
-    try {
-        const dir = await opendir(watchDirectory, { recursive });
-        for await (const dirent of dir) {
-            if (dirent.isDirectory()) {
-                continue;
-            }
-            const path = join(dirent.parentPath ?? dirent.path, dirent.name);
-            if (existingResults.has(path)) {
-                continue;
-            }
-            try {
-                await onNewFile(path, dirent);
-                existingResults.add(path);
-            }
-            catch (e) {
-                if (!isFileNotFoundError(e)) {
-                    console.error("can't process file", path, e);
+const findFiles = async (watchDirectory, existingResults, onNewFile, recursive, maximumDepth = 10) => {
+    const scanDirectory = async (directory, isRoot, remainingDepth) => {
+        try {
+            const dir = await opendir(directory);
+            for await (const dirent of dir) {
+                const path = join(dirent.parentPath ?? dirent.path, dirent.name);
+                if (dirent.isDirectory()) {
+                    if (recursive && remainingDepth > 0) {
+                        await scanDirectory(path, false, remainingDepth - 1);
+                    }
+                    continue;
+                }
+                if (existingResults.has(path)) {
+                    continue;
+                }
+                try {
+                    await onNewFile(path, dirent);
+                    existingResults.add(path);
+                }
+                catch (e) {
+                    if (!isFileNotFoundError(e)) {
+                        console.error("can't process file", path, e);
+                    }
                 }
             }
         }
-    }
-    catch (e) {
-        if (isFileNotFoundError(e)) {
-            existingResults.clear();
-            return;
+        catch (e) {
+            if (isFileNotFoundError(e)) {
+                if (isRoot) {
+                    existingResults.clear();
+                }
+                return;
+            }
+            console.error("can't read directory", e);
         }
-        console.error("can't read directory", e);
-    }
+    };
+    await scanDirectory(watchDirectory, true, maximumDepth);
 };
 const singleIteration = async (callback, ...ac) => {
     return setImmediate(undefined, { signal: AbortSignal.any(ac.map((c) => c.signal)) })
@@ -124,13 +132,13 @@ const watch = (initialCallback, iterationCallback, doneCallback, options = {}) =
     };
 };
 export const newFilesInDirectoryWatcher = (directory, onNewFile, options = {}) => {
-    const { recursive = true, ignoreInitial = false, ...rest } = options;
+    const { recursive = true, maximumDepth = 10, ignoreInitial = false, ...rest } = options;
     const indexedFiles = new Set();
     const initialCallback = async () => {
-        await findFiles(directory, indexedFiles, ignoreInitial ? noop : onNewFile, recursive);
+        await findFiles(directory, indexedFiles, ignoreInitial ? noop : onNewFile, recursive, maximumDepth);
     };
     const iterationCallback = async () => {
-        await findFiles(directory, indexedFiles, onNewFile, recursive);
+        await findFiles(directory, indexedFiles, onNewFile, recursive, maximumDepth);
     };
     return watch(initialCallback, iterationCallback, iterationCallback, rest);
 };
@@ -174,7 +182,12 @@ const waitUntilFileStopChanging = async (file, info, options) => {
         }
         const sinceChange = now - prev.timestamp;
         if (sinceChange < minWait) {
-            await setTimeout(Math.min(0, maxWait, minWait - sinceChange + 1));
+            const maxDelay = maxWait - (now - start);
+            if (maxDelay <= 0) {
+                return false;
+            }
+            await setTimeout(Math.min(maxDelay, minWait - sinceChange + 1));
+            continue;
         }
         const current = await calculateInfo(file);
         if (!current) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/directory-watcher",
-  "version": "3.8.2",
+  "version": "3.9.0",
   "description": "File system watcher for directories",
   "keywords": [
     "allure",
@@ -35,6 +35,7 @@
   "devDependencies": {
     "@types/node": "^20.17.9",
     "@vitest/runner": "^2.1.9",
+    "allure-js-commons": "^3.3.3",
     "allure-vitest": "^3.3.3",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",