@allurereport/directory-watcher 3.0.0-beta.10

package/README.md

@@ -0,0 +1,25 @@
+# Directory Watcher
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+Directory Watcher is an utility to track file system changes which supports wildcard patterns.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/directory-watcher
+yarn add @allurereport/directory-watcher
+pnpm add @allurereport/directory-watcher
+```

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+declare const watchDirectory: (directory: string, handler: (eventName: "add" | "addDir" | "change" | "unlink" | "unlinkDir", path: string) => void | Promise<void>, options?: {
+    usePolling?: boolean;
+    ignoreInitial?: boolean;
+}) => () => Promise<void>;
+export default watchDirectory;
+export type { Watcher } from "./watcher.js";
+export { newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";

package/dist/index.js

@@ -0,0 +1,15 @@
+import { watch as chokidarWatch } from "chokidar";
+import console from "node:console";
+const watchDirectory = (directory, handler, options = {}) => {
+    const { usePolling = false, ignoreInitial = false } = options;
+    const watcher = chokidarWatch(directory, { persistent: true, usePolling, ignoreInitial });
+    watcher.on("all", async (eventName, path) => {
+        await handler(eventName, path);
+    });
+    watcher.on("error", (error) => {
+        console.log("error", error);
+    });
+    return () => watcher.close();
+};
+export default watchDirectory;
+export { newFilesInDirectoryWatcher, allureResultsDirectoriesWatcher, delayedFileProcessingWatcher, } from "./watcher.js";

package/dist/watcher.d.ts

@@ -0,0 +1,30 @@
+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>;
+interface WatchOptions {
+    indexDelay?: number;
+    abortController?: AbortController;
+}
+export interface Watcher {
+    abort: (immediately?: boolean) => Promise<void>;
+    initialScan: () => Promise<void>;
+    watchEnd: () => Promise<void>;
+}
+interface WatchNewFilesOptions extends WatchOptions {
+    recursive?: boolean;
+    indexDelay?: number;
+    ignoreInitial?: boolean;
+    abortController?: AbortController;
+}
+export declare const newFilesInDirectoryWatcher: (directory: string, onNewFile: (file: string, dirent: Dirent) => Promise<void>, options?: WatchNewFilesOptions) => Watcher;
+export declare const allureResultsDirectoriesWatcher: (directory: string, update: (newAllureResults: Set<string>, deletedAllureResults: Set<string>) => Promise<void>, options?: WatchOptions) => Watcher;
+interface FileContentWatcherOptions extends WatchOptions {
+    minProcessingDelay?: number;
+    maxProcessingDelay?: number;
+}
+export declare const delayedFileProcessingWatcher: (processFile: (file: string) => Promise<void>, options?: FileContentWatcherOptions) => Watcher & {
+    addFile: (file: string) => Promise<void>;
+};
+export declare const md5File: (path: string) => Promise<string>;
+export {};

package/dist/watcher.js

@@ -0,0 +1,277 @@
+import console from "node:console";
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { opendir, realpath, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { setImmediate, setTimeout } from "node:timers/promises";
+export const isFileNotFoundError = (e) => e instanceof Error && "code" in e && e.code === "ENOENT";
+export const difference = (before, after) => {
+    const added = new Set();
+    const deleted = new Set(before);
+    for (const value of after) {
+        if (!deleted.has(value)) {
+            added.add(value);
+        }
+        else {
+            deleted.delete(value);
+        }
+    }
+    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);
+            }
+        }
+    }
+    catch (e) {
+        if (isFileNotFoundError(e)) {
+            existingResults.clear();
+            return;
+        }
+        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);
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (isFileNotFoundError(e)) {
+            existingResults.clear();
+            return;
+        }
+        console.error("can't read directory", e);
+    }
+};
+const singleIteration = async (callback, ...ac) => {
+    return setImmediate(undefined, { signal: AbortSignal.any(ac.map((c) => c.signal)) })
+        .then(() => callback())
+        .catch((err) => {
+        if (err.name === "AbortError") {
+            return;
+        }
+        console.error("can't execute callback", err);
+    });
+};
+const repeatedIteration = async (indexInterval, callback, ...ac) => {
+    return setTimeout(indexInterval, undefined, { signal: AbortSignal.any(ac.map((c) => c.signal)) })
+        .then(() => callback())
+        .then(() => repeatedIteration(indexInterval, callback, ...ac));
+};
+const noop = async () => { };
+const watch = (initialCallback, iterationCallback, doneCallback, options = {}) => {
+    const { indexDelay = 300, abortController: haltAc = new AbortController() } = options;
+    const gracefulShutdownAc = new AbortController();
+    const init = singleIteration(initialCallback, haltAc);
+    const timeout = init
+        .then(() => repeatedIteration(indexDelay, iterationCallback, haltAc, gracefulShutdownAc))
+        .catch((err) => {
+        if (err.name === "AbortError") {
+            return;
+        }
+        console.error("can't execute callback", err);
+    })
+        .then(() => singleIteration(doneCallback, haltAc));
+    return {
+        abort: async (immediately = false) => {
+            if (immediately) {
+                haltAc.abort();
+            }
+            else {
+                gracefulShutdownAc.abort();
+            }
+            await timeout;
+        },
+        initialScan: async () => {
+            await init;
+        },
+        watchEnd: async () => {
+            await timeout;
+        },
+    };
+};
+export const newFilesInDirectoryWatcher = (directory, onNewFile, options = {}) => {
+    const { recursive = true, ignoreInitial = false, ...rest } = options;
+    const indexedFiles = new Set();
+    const initialCallback = async () => {
+        await findFiles(directory, indexedFiles, ignoreInitial ? noop : onNewFile, recursive);
+    };
+    const iterationCallback = async () => {
+        await findFiles(directory, indexedFiles, onNewFile, recursive);
+    };
+    return watch(initialCallback, iterationCallback, iterationCallback, rest);
+};
+export const allureResultsDirectoriesWatcher = (directory, update, options = {}) => {
+    let previousAllureResults = new Set();
+    const callback = async () => {
+        const currentAllureResults = new Set();
+        await findMatching(directory, currentAllureResults, (dirent) => dirent.isDirectory() && dirent.name === "allure-results");
+        const [added, deleted] = difference(previousAllureResults, currentAllureResults);
+        await update(added, deleted);
+        previousAllureResults = currentAllureResults;
+    };
+    return watch(callback, callback, callback, options);
+};
+const calculateInfo = async (file) => {
+    try {
+        const stats = await stat(file);
+        if (!stats.isFile()) {
+            return null;
+        }
+        const size = stats.size;
+        const mtimeMs = stats.mtimeMs;
+        const timestamp = Date.now();
+        return { size, mtimeMs, timestamp };
+    }
+    catch (e) {
+        if (isFileNotFoundError(e)) {
+            return null;
+        }
+        throw e;
+    }
+};
+const waitUntilFileStopChanging = async (file, info, options) => {
+    const start = Date.now();
+    const { maxWait, minWait } = options;
+    const prev = { ...info };
+    while (true) {
+        const now = Date.now();
+        if (now - start > maxWait) {
+            return false;
+        }
+        const sinceChange = now - prev.timestamp;
+        if (sinceChange < minWait) {
+            await setTimeout(Math.min(0, maxWait, minWait - sinceChange + 1));
+        }
+        const current = await calculateInfo(file);
+        if (!current) {
+            return false;
+        }
+        const sameSize = current.size === prev.size;
+        const sameMtimeMs = current.mtimeMs === prev.mtimeMs;
+        if (sameSize && sameMtimeMs) {
+            return true;
+        }
+        prev.size = current.size;
+        prev.mtimeMs = current.mtimeMs;
+        prev.timestamp = current.timestamp;
+    }
+};
+export const delayedFileProcessingWatcher = (processFile, options = {}) => {
+    const { minProcessingDelay = 200, maxProcessingDelay = 10000, ...rest } = options;
+    const files = new Map();
+    const success = new Set();
+    const errors = new Set();
+    const addFile = async (file) => {
+        try {
+            const filePath = await realpath(file, { encoding: "utf-8" });
+            const info = await calculateInfo(filePath);
+            if (!info) {
+                return;
+            }
+            files.set(filePath, info);
+        }
+        catch (e) {
+            if (isFileNotFoundError(e)) {
+                return;
+            }
+            throw e;
+        }
+    };
+    const callback = async () => {
+        for (const [file, info] of files) {
+            const now = Date.now();
+            const sinceChange = now - info.timestamp;
+            if (sinceChange < minProcessingDelay) {
+                continue;
+            }
+            try {
+                await processFile(file);
+            }
+            catch (e) {
+                if (!isFileNotFoundError(e)) {
+                    console.log(`could not process file ${file}`, e);
+                }
+                errors.add(file);
+            }
+            files.delete(file);
+            success.add(file);
+        }
+    };
+    const doneCallback = async () => {
+        for (const [file, info] of files) {
+            const waitedSuccessfully = await waitUntilFileStopChanging(file, info, {
+                minWait: minProcessingDelay,
+                maxWait: maxProcessingDelay,
+            });
+            if (waitedSuccessfully) {
+                try {
+                    await processFile(file);
+                }
+                catch (e) {
+                    if (!isFileNotFoundError(e)) {
+                        console.log(`could not process file ${file}`, e);
+                    }
+                    errors.add(file);
+                }
+                files.delete(file);
+                success.add(file);
+            }
+            else {
+                console.error(`can't process file ${file}: file deleted or contents keep changing`);
+                errors.add(file);
+            }
+        }
+    };
+    const watcher = watch(callback, callback, doneCallback, rest);
+    return {
+        ...watcher,
+        addFile,
+    };
+};
+export const md5File = async (path) => {
+    return new Promise((resolve, reject) => {
+        const output = createHash("md5");
+        const input = createReadStream(path);
+        input.on("error", (err) => {
+            reject(err);
+        });
+        output.once("readable", () => {
+            resolve(output.read().toString("hex"));
+        });
+        input.pipe(output);
+    });
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@allurereport/directory-watcher",
+  "version": "3.0.0-beta.10",
+  "description": "File system watcher for directories",
+  "keywords": [
+    "allure",
+    "testing",
+    "fs",
+    "watcher",
+    "fsevents"
+  ],
+  "repository": "https://github.com/allure-framework/allure3",
+  "license": "Apache-2.0",
+  "author": "Qameta Software",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "run clean && tsc --project ./tsconfig.json",
+    "clean": "rimraf ./dist",
+    "eslint": "eslint ./src/**/*.{js,jsx,ts,tsx}",
+    "eslint:format": "eslint --fix ./src/**/*.{js,jsx,ts,tsx}",
+    "pretest": "rimraf ./out",
+    "test": "rimraf ./out && vitest run"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.1"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2.6.1",
+    "@types/eslint": "^8.56.11",
+    "@types/node": "^20.17.9",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/runner": "^2.1.8",
+    "allure-vitest": "^3.0.9",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^50.0.0",
+    "eslint-plugin-n": "^17.10.1",
+    "eslint-plugin-no-null": "^1.0.2",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}