honkit 6.1.4 → 6.1.5

package/lib/cli/__tests__/watch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watch.test.d.ts.map

package/lib/cli/__tests__/watch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.test.d.ts","sourceRoot":"","sources":["../../../src/cli/__tests__/watch.test.ts"],"names":[],"mappings":""}

package/lib/cli/__tests__/watch.test.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const watch_1 = __importDefault(require("../watch"));
+/**
+ * Normalize path separators to forward slashes for cross-platform comparison
+ */
+function normalizePath(filepath) {
+    return filepath.replace(/\\/g, "/");
+}
+describe("watch", () => {
+    // Increase timeout for file system operations (Windows may need more time)
+    jest.setTimeout(30000);
+    let tempDir;
+    let watchers = [];
+    beforeEach(() => {
+        tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "honkit-watch-test-"));
+    });
+    afterEach(async () => {
+        // Close all watchers
+        await Promise.all(watchers.map((w) => w.close()));
+        watchers = [];
+        // Cleanup temp directory
+        if (tempDir && fs_1.default.existsSync(tempDir)) {
+            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    function createFile(relativePath, content = "# Test") {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        const dir = path_1.default.dirname(filePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    function modifyFile(relativePath, content) {
+        const filePath = path_1.default.join(tempDir, relativePath);
+        fs_1.default.writeFileSync(filePath, content);
+        return filePath;
+    }
+    /**
+     * Wait for watcher to be ready and stable
+     */
+    async function waitForReady(watcher) {
+        await new Promise((resolve) => {
+            watcher.on("ready", resolve);
+        });
+        // Give the watcher a moment to stabilize after ready event
+        // Windows needs more time for file system operations
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    /**
+     * Wait for a file change to be detected that matches the predicate
+     * Paths are normalized to forward slashes for cross-platform compatibility
+     */
+    function waitForChange(watcher, predicate, timeoutMs = 20000) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Timeout waiting for file change after ${timeoutMs}ms`));
+            }, timeoutMs);
+            const handler = (_event, filepath) => {
+                const fullPath = normalizePath(path_1.default.resolve(tempDir, filepath));
+                if (predicate(fullPath)) {
+                    clearTimeout(timeout);
+                    watcher.off("all", handler);
+                    resolve(fullPath);
+                }
+            };
+            watcher.on("all", handler);
+        });
+    }
+    describe("issue #491 - custom output folder handling", () => {
+        it("should detect changes in custom output folder when not specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITHOUT specifying output folder
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify file in output folder and wait for detection
+            modifyFile("output/orphan.md", "# Modified");
+            const detected = await waitForChange(watcher, (f) => f.includes("output/orphan.md"));
+            expect(detected).toContain("output/orphan.md");
+        });
+        it("should NOT detect changes in custom output folder when specified in options", async () => {
+            createFile("README.md", "# README");
+            createFile("output/orphan.md", "# Orphan in output folder");
+            const detectedFiles = [];
+            // Start watching WITH output folder specified - it should be ignored
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: "output",
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files - output should be ignored, README should be detected
+            modifyFile("output/orphan.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change to be detected (proves watcher is working)
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify output folder change was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+        it("should handle absolute output folder paths", async () => {
+            createFile("README.md", "# README");
+            createFile("docs-output/file.md", "# File");
+            const detectedFiles = [];
+            const absoluteOutputPath = path_1.default.join(tempDir, "docs-output");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                outputFolder: absoluteOutputPath,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // Modify both files
+            modifyFile("docs-output/file.md", "# Modified");
+            modifyFile("README.md", "# Modified README");
+            // Wait for README change
+            await waitForChange(watcher, (f) => f.includes("README.md"));
+            // Verify docs-output was NOT detected
+            const outputChanges = detectedFiles.filter((f) => f.includes("docs-output/"));
+            expect(outputChanges).toHaveLength(0);
+        });
+    });
+    describe("default _book folder", () => {
+        it("should NOT detect changes in _book folder", async () => {
+            createFile("file1.md", "# File 1");
+            createFile("file2.md", "# File 2");
+            createFile("_book/output.md", "# Output");
+            const detectedFiles = [];
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: (error, filepath) => {
+                    if (error || !filepath)
+                        return;
+                    detectedFiles.push(normalizePath(filepath));
+                }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            // First modify file1 to ensure watcher is working
+            modifyFile("file1.md", "# Modified File 1");
+            await waitForChange(watcher, (f) => f.includes("file1.md"));
+            // Now modify _book file (should be ignored)
+            modifyFile("_book/output.md", "# Modified");
+            // Modify file2 to confirm watcher still works
+            modifyFile("file2.md", "# Modified File 2");
+            await waitForChange(watcher, (f) => f.includes("file2.md"));
+            // Verify _book was NOT detected
+            const bookChanges = detectedFiles.filter((f) => f.includes("_book"));
+            expect(bookChanges).toHaveLength(0);
+        });
+    });
+    describe("source files", () => {
+        it("should detect changes to markdown files in source directory", async () => {
+            createFile("README.md", "# README");
+            createFile("orphan.md", "# Orphan - not in SUMMARY");
+            const watcher = (0, watch_1.default)({
+                watchDir: tempDir,
+                callback: () => { }
+            });
+            watchers.push(watcher);
+            await waitForReady(watcher);
+            modifyFile("orphan.md", "# Modified orphan");
+            const detected = await waitForChange(watcher, (f) => f.includes("orphan.md"));
+            expect(detected).toContain("orphan.md");
+        });
+    });
+});

package/lib/cli/serve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4IA,wBA6DE"}
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkJA,wBA6DE"}

package/lib/cli/serve.js

@@ -62,51 +62,57 @@ function startServer(args, kwargs) {
             return waitForCtrlC();
         }
         // update book immutably. does not use book again
-        return (0, watch_1.default)(book.getRoot(), (error, filepath) => {
-            if (error) {
-                console.error(error);
-                return;
-            }
-            // If the file does not exist in file system, show a warning and skip
-            // Probably, the file has been deleted
-            if (!fs_1.default.existsSync(filepath)) {
-                logger.warn.ok(`${filepath} does not exist in file system.`);
-                return;
-            }
-            // set livereload path
-            lrPath = filepath;
-            // TODO: use parse extension
-            // Incremental update for pages
-            if (lastOutput && filepath.endsWith(".md")) {
-                logger.warn.ok("Rebuild " + filepath);
-                const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
-                    incrementalChangeFileSet: immutable_1.default.Set([filepath])
-                });
-                return incrementalBuild({
-                    output: changedOutput,
-                    Generator
-                }).then(() => {
-                    if (lrPath && hasLiveReloading) {
-                        // trigger livereload
-                        lrServer.changed({
-                            body: {
-                                files: [lrPath]
-                            }
-                        });
-                    }
+        // Pass outputFolder to watch to prevent infinite rebuild loops
+        // https://github.com/honkit/honkit/issues/491
+        (0, watch_1.default)({
+            watchDir: book.getRoot(),
+            outputFolder,
+            callback: (error, filepath) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                // If the file does not exist in file system, show a warning and skip
+                // Probably, the file has been deleted
+                if (!fs_1.default.existsSync(filepath)) {
+                    logger.warn.ok(`${filepath} does not exist in file system.`);
+                    return;
+                }
+                // set livereload path
+                lrPath = filepath;
+                // TODO: use parse extension
+                // Incremental update for pages
+                if (lastOutput && filepath.endsWith(".md")) {
+                    logger.warn.ok("Rebuild " + filepath);
+                    const changedOutput = lastOutput.reloadPage(lastOutput.book.getContentRoot(), filepath).merge({
+                        incrementalChangeFileSet: immutable_1.default.Set([filepath])
+                    });
+                    return incrementalBuild({
+                        output: changedOutput,
+                        Generator
+                    }).then(() => {
+                        if (lrPath && hasLiveReloading) {
+                            // trigger livereload
+                            lrServer.changed({
+                                body: {
+                                    files: [lrPath]
+                                }
+                            });
+                        }
+                    });
+                }
+                // Asciidoc files are not supported for incremental build
+                logger.info.ok("Rebuild " + filepath);
+                return generateBook({
+                    book,
+                    outputFolder,
+                    hasLiveReloading,
+                    Generator,
+                    reload
+                }).then((output) => {
+                    lastOutput = output;
                 });
             }
-            // Asciidoc files are not supported for incremental build
-            logger.info.ok("Rebuild " + filepath);
-            return generateBook({
-                book,
-                outputFolder,
-                hasLiveReloading,
-                Generator,
-                reload
-            }).then((output) => {
-                lastOutput = output;
-            });
         });
     });
 }

package/lib/cli/watch.d.ts

@@ -1,10 +1,26 @@
+import { FSWatcher } from "chokidar";
+export interface WatchOptions {
+    /**
+     * Directory to watch
+     */
+    watchDir: string;
+    /**
+     * Callback when a file is modified
+     */
+    callback: (error: Error | null, filepath?: string) => void;
+    /**
+     * Output folder to ignore (in addition to _book and node_modules)
+     * This prevents infinite rebuild loops when using custom output folders
+     * @see https://github.com/honkit/honkit/issues/491
+     */
+    outputFolder?: string;
+}
 /**
- Watch a folder and resolve promise once a file is modified
-
- @param {string} dir
- @param callback
- @return {Promise}
+ * Watch a folder and call callback when a file is modified
+ *
+ * @param {WatchOptions} options
+ * @return {FSWatcher} The chokidar watcher instance
  */
-declare function watch(dir: any, callback: any): void;
+declare function watch(options: WatchOptions): FSWatcher;
 export default watch;
 //# sourceMappingURL=watch.d.ts.map

package/lib/cli/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,iBAAS,KAAK,CAAC,GAAG,KAAA,EAAE,QAAQ,KAAA,QAwB3B;AAED,eAAe,KAAK,CAAC"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/cli/watch.ts"],"names":[],"mappings":"AACA,OAAiB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAG/C,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3D;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,iBAAS,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CA0C/C;AAED,eAAe,KAAK,CAAC"}

package/lib/cli/watch.js

@@ -7,24 +7,37 @@ const path_1 = __importDefault(require("path"));
 const chokidar_1 = __importDefault(require("chokidar"));
 const parsers_1 = __importDefault(require("../parsers"));
 /**
- Watch a folder and resolve promise once a file is modified
-
- @param {string} dir
- @param callback
- @return {Promise}
+ * Watch a folder and call callback when a file is modified
+ *
+ * @param {WatchOptions} options
+ * @return {FSWatcher} The chokidar watcher instance
  */
-function watch(dir, callback) {
-    dir = path_1.default.resolve(dir);
+function watch(options) {
+    const { callback, outputFolder } = options;
+    const dir = path_1.default.resolve(options.watchDir);
     const toWatch = ["book.json", "book.js", "_layouts/**"];
     // Watch all parsable files
     parsers_1.default.extensions.forEach((ext) => {
         toWatch.push(`**/*${ext}`);
     });
+    // Build ignored patterns
+    // Always ignore _book and node_modules
+    // https://github.com/honkit/honkit/issues/269
+    const ignored = ["_book/**", "node_modules/**"];
+    // If a custom output folder is specified, ignore it too
+    // This prevents infinite rebuild loops when output folder is inside the watched directory
+    // https://github.com/honkit/honkit/issues/491
+    if (outputFolder) {
+        // Convert to forward slashes for glob pattern (Windows compatibility)
+        const outputRelative = path_1.default.relative(dir, path_1.default.resolve(dir, outputFolder)).replace(/\\/g, "/");
+        // Only add to ignored if the output folder is inside the watched directory
+        if (outputRelative && !outputRelative.startsWith("..") && !path_1.default.isAbsolute(outputRelative)) {
+            ignored.push(`${outputRelative}/**`);
+        }
+    }
     const watcher = chokidar_1.default.watch(toWatch, {
         cwd: dir,
-        // prevent infinity loop
-        // https://github.com/honkit/honkit/issues/269
-        ignored: ["_book/**", "node_modules/**"],
+        ignored: ignored,
         ignoreInitial: true
     });
     watcher.on("all", (e, filepath) => {
@@ -33,5 +46,6 @@ function watch(dir, callback) {
     watcher.on("error", (err) => {
         callback(err);
     });
+    return watcher;
 }
 exports.default = watch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honkit",
-  "version": "6.1.4",
+  "version": "6.1.5",
   "description": "HonKit is building beautiful books using Markdown.",
   "keywords": [
     "git",
@@ -74,12 +74,12 @@
     "tiny-lr": "^1.1.1",
     "tmp": "0.2.4",
     "urijs": "^1.19.11",
-    "@honkit/asciidoc": "6.1.4",
-    "@honkit/honkit-plugin-fontsettings": "6.1.4",
-    "@honkit/honkit-plugin-theme-default": "6.1.4",
-    "@honkit/honkit-plugin-highlight": "6.1.4",
-    "@honkit/html": "6.1.4",
-    "@honkit/markdown-legacy": "6.1.4"
+    "@honkit/asciidoc": "6.1.5",
+    "@honkit/honkit-plugin-fontsettings": "6.1.5",
+    "@honkit/honkit-plugin-highlight": "6.1.5",
+    "@honkit/honkit-plugin-theme-default": "6.1.5",
+    "@honkit/markdown-legacy": "6.1.5",
+    "@honkit/html": "6.1.5"
   },
   "devDependencies": {
     "@relmify/jest-serializer-strip-ansi": "^1.0.2",
@@ -90,7 +90,7 @@
     "jest-mock-process": "^2.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.6.2",
-    "@honkit/internal-test-utils": "6.1.4"
+    "@honkit/internal-test-utils": "6.1.5"
   },
   "scripts": {
     "build": "tsc -p .",