honkit 6.0.4 → 6.1.5

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/lib/constants/__tests__/configSchema.d.ts

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

package/lib/constants/__tests__/configSchema.d.ts.map

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

package/lib/constants/__tests__/configSchema.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonschema_1 = __importDefault(require("jsonschema"));
+const configSchema_1 = __importDefault(require("../configSchema"));
+describe("configSchema", () => {
+    function validate(cfg) {
+        const v = new jsonschema_1.default.Validator();
+        return v.validate(cfg, configSchema_1.default, {
+            propertyName: "config",
+        });
+    }
+    describe("structure", () => {
+        test("should accept dot in filename", () => {
+            const result = validate({
+                structure: {
+                    readme: "book-intro.adoc",
+                },
+            });
+            expect(result.errors.length).toBe(0);
+        });
+        test("should accept uppercase in filename", () => {
+            const result = validate({
+                structure: {
+                    readme: "BOOK.adoc",
+                },
+            });
+            expect(result.errors.length).toBe(0);
+        });
+        test("should not accept filepath", () => {
+            const result = validate({
+                structure: {
+                    readme: "folder/myFile.md",
+                },
+            });
+            expect(result.errors.length).toBe(1);
+        });
+    });
+});

package/lib/fs/__tests__/mock.d.ts

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

package/lib/fs/__tests__/mock.d.ts.map

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

package/lib/fs/__tests__/mock.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_1 = __importDefault(require("../mock"));
+describe("MockFS", () => {
+    const fs = (0, mock_1.default)({
+        "README.md": "Hello World",
+        "SUMMARY.md": "# Summary",
+        folder: {
+            "test.md": "Cool",
+            folder2: {
+                "hello.md": "Hello",
+                "world.md": "World"
+            }
+        }
+    });
+    describe("exists", () => {
+        test("must return true for a file", () => {
+            return fs.exists("README.md").then((result) => {
+                expect(result).toBeTruthy();
+            });
+        });
+        test("must return false for a non existing file", () => {
+            return fs.exists("README_NOTEXISTS.md").then((result) => {
+                expect(result).toBeFalsy();
+            });
+        });
+        test("must return true for a directory", () => {
+            return fs.exists("folder").then((result) => {
+                expect(result).toBeTruthy();
+            });
+        });
+        test("must return true for a deep file", () => {
+            return fs.exists("folder/test.md").then((result) => {
+                expect(result).toBeTruthy();
+            });
+        });
+        test("must return true for a deep file (2)", () => {
+            return fs.exists("folder/folder2/hello.md").then((result) => {
+                expect(result).toBeTruthy();
+            });
+        });
+    });
+    describe("readAsString", () => {
+        test("must return content for a file", () => {
+            return fs.readAsString("README.md").then((result) => {
+                expect(result).toBe("Hello World");
+            });
+        });
+        test("must return content for a deep file", () => {
+            return fs.readAsString("folder/test.md").then((result) => {
+                expect(result).toBe("Cool");
+            });
+        });
+    });
+    describe("readDir", () => {
+        test("must return content for a directory", () => {
+            return fs.readDir("./").then((files) => {
+                expect(files.size).toBe(3);
+                expect(files.includes("README.md")).toBeTruthy();
+                expect(files.includes("SUMMARY.md")).toBeTruthy();
+                expect(files.includes("folder/")).toBeTruthy();
+            });
+        });
+    });
+});

package/lib/models/__tests__/config.d.ts

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

package/lib/models/__tests__/config.d.ts.map

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

package/lib/models/__tests__/config.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const config_1 = __importDefault(require("../config"));
+describe("Config", () => {
+    const config = config_1.default.createWithValues({
+        hello: {
+            world: 1,
+            test: "Hello",
+            isFalse: false,
+        },
+    });
+    describe("getValue", () => {
+        test("must return value as immutable", () => {
+            const value = config.getValue("hello");
+            expect(immutable_1.default.Map.isMap(value)).toBeTruthy();
+        });
+        test("must return deep value", () => {
+            const value = config.getValue("hello.world");
+            expect(value).toBe(1);
+        });
+        test("must return default value if non existant", () => {
+            const value = config.getValue("hello.nonExistant", "defaultValue");
+            expect(value).toBe("defaultValue");
+        });
+        test("must not return default value for falsy values", () => {
+            const value = config.getValue("hello.isFalse", "defaultValue");
+            expect(value).toBe(false);
+        });
+    });
+    describe("setValue", () => {
+        test("must set value as immutable", () => {
+            const testConfig = config.setValue("hello", {
+                cool: 1,
+            });
+            const value = testConfig.getValue("hello");
+            expect(immutable_1.default.Map.isMap(value)).toBeTruthy();
+            expect(value.size).toBe(1);
+            expect(value.has("cool")).toBeTruthy();
+        });
+        test("must set deep value", () => {
+            const testConfig = config.setValue("hello.world", 2);
+            const hello = testConfig.getValue("hello");
+            const world = testConfig.getValue("hello.world");
+            expect(immutable_1.default.Map.isMap(hello)).toBeTruthy();
+            expect(hello.size).toBe(3);
+            expect(world).toBe(2);
+        });
+    });
+    describe("toReducedVersion", () => {
+        test("must only return diffs for simple values", () => {
+            const _config = config_1.default.createWithValues({
+                gitbook: "3.0.0",
+            });
+            const reducedVersion = _config.toReducedVersion();
+            expect(reducedVersion.toJS()).toEqual({
+                gitbook: "3.0.0",
+            });
+        });
+        test("must only return diffs for deep values", () => {
+            const _config = config_1.default.createWithValues({
+                structure: {
+                    readme: "intro.md",
+                },
+            });
+            const reducedVersion = _config.toReducedVersion();
+            expect(reducedVersion.toJS()).toEqual({
+                structure: {
+                    readme: "intro.md",
+                },
+            });
+        });
+    });
+    describe("getPluginDependencies", () => {
+        const config = config_1.default.createWithValues({
+            plugins: [
+                "example",
+                "honkit-plugin-example",
+                "@example/example",
+                "@example/honkit-plugin-example",
+                "@honkit/honkit-plugin-example",
+                "-no-use",
+                "-honkit-plugin-no-use",
+                "-@honkit/honkit-plugin-no-use",
+                // GitBook logic - deprecated
+                "example-v@1.0.0",
+                "gitbook-plugin-example-v@1.0.0",
+                "example@git+ssh://samy@github.com/GitbookIO/plugin-ga.git",
+            ],
+        });
+        const dependencies = config.getPluginDependencies();
+        expect(dependencies.toJS()).toEqual([
+            {
+                enabled: true,
+                name: "example",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: true,
+                name: "honkit-plugin-example",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: true,
+                name: "@example/example",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: true,
+                name: "@example/honkit-plugin-example",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: true,
+                name: "@honkit/honkit-plugin-example",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: false,
+                name: "no-use",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: false,
+                name: "honkit-plugin-no-use",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: false,
+                name: "@honkit/honkit-plugin-no-use",
+                path: "",
+                version: "*",
+            },
+            {
+                enabled: true,
+                name: "example-v",
+                path: "",
+                version: "1.0.0",
+            },
+            {
+                enabled: true,
+                name: "gitbook-plugin-example-v",
+                path: "",
+                version: "1.0.0",
+            },
+            {
+                enabled: true,
+                name: "example",
+                path: "",
+                version: "git+ssh://samy@github.com/GitbookIO/plugin-ga.git",
+            },
+        ]);
+    });
+});

package/lib/models/__tests__/glossary.d.ts

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

package/lib/models/__tests__/glossary.d.ts.map

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

package/lib/models/__tests__/glossary.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_1 = __importDefault(require("../file"));
+const glossary_1 = __importDefault(require("../glossary"));
+const glossaryEntry_1 = __importDefault(require("../glossaryEntry"));
+describe("Glossary", () => {
+    const glossary = glossary_1.default.createFromEntries(new file_1.default(), [
+        {
+            name: "Hello World",
+            description: "Awesome!",
+        },
+        {
+            name: "JavaScript",
+            description: "This is a cool language",
+        },
+    ]);
+    describe("createFromEntries", () => {
+        test("must add all entries", () => {
+            const entries = glossary.getEntries();
+            expect(entries.size).toBe(2);
+        });
+        test("must add entries as GlossaryEntries", () => {
+            const entries = glossary.getEntries();
+            const entry = entries.get("hello-world");
+            expect(entry instanceof glossaryEntry_1.default).toBeTruthy();
+        });
+    });
+    describe("toText", () => {
+        test("return as markdown", () => {
+            return glossary.toText(".md").then((text) => {
+                expect(text).toContain("# Glossary");
+            });
+        });
+    });
+});

package/lib/models/__tests__/glossaryEntry.d.ts

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

package/lib/models/__tests__/glossaryEntry.d.ts.map

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

package/lib/models/__tests__/glossaryEntry.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glossaryEntry_1 = __importDefault(require("../glossaryEntry"));
+describe("GlossaryEntry", () => {
+    describe("getID", () => {
+        test("must return a normalized ID", () => {
+            const entry = new glossaryEntry_1.default({
+                name: "Hello World",
+            });
+            expect(entry.getID()).toBe("hello-world");
+        });
+    });
+});

package/lib/models/__tests__/page.d.ts

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

package/lib/models/__tests__/page.d.ts.map

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

package/lib/models/__tests__/page.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const page_1 = __importDefault(require("../page"));
+describe("Page", () => {
+    describe("toText", () => {
+        test("must not prepend frontmatter if no attributes", () => {
+            const page = new page_1.default().merge({
+                content: "Hello World",
+            });
+            expect(page.toText()).toBe("Hello World");
+        });
+        test("must prepend frontmatter if attributes", () => {
+            const page = new page_1.default().merge({
+                content: "Hello World",
+                attributes: immutable_1.default.fromJS({
+                    hello: "world",
+                }),
+            });
+            expect(page.toText()).toBe("---\nhello: world\n---\n\nHello World");
+        });
+    });
+});

package/lib/models/__tests__/plugin.d.ts

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

package/lib/models/__tests__/plugin.d.ts.map

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

package/lib/models/__tests__/plugin.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = __importDefault(require("../plugin"));
+const immutable_1 = __importDefault(require("immutable"));
+describe("Plugin", () => {
+    describe("createFromString", () => {
+        test("must parse name", () => {
+            const plugin = plugin_1.default.createFromString("hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("*");
+        });
+        test("must parse version", () => {
+            const plugin = plugin_1.default.createFromString("hello@1.0.0");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("1.0.0");
+        });
+    });
+    describe("getNpmId", () => {
+        it("should return package's name", () => {
+            const plugin = new plugin_1.default({
+                name: "testplugin",
+                version: "*",
+                path: "test.js",
+                package: immutable_1.default.fromJS({
+                    name: "testplugin-name"
+                }),
+                content: immutable_1.default.fromJS({
+                    hooks: {
+                        "page:before": function (page) {
+                            return page;
+                        },
+                        page: function (page) {
+                            return page;
+                        }
+                    }
+                })
+            });
+            expect(plugin.getNpmID()).toBe("testplugin-name");
+        });
+    });
+    describe("isLoaded", () => {
+        test("must return false for empty plugin", () => {
+            const plugin = plugin_1.default.createFromString("hello");
+            expect(plugin.isLoaded()).toBe(false);
+        });
+    });
+});

package/lib/models/__tests__/pluginDependency.d.ts

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

package/lib/models/__tests__/pluginDependency.d.ts.map

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

package/lib/models/__tests__/pluginDependency.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const pluginDependency_1 = __importDefault(require("../pluginDependency"));
+describe("PluginDependency", () => {
+    describe("createFromString", () => {
+        test("must parse name", () => {
+            const plugin = pluginDependency_1.default.createFromString("hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("*");
+        });
+        test("must parse state", () => {
+            const plugin = pluginDependency_1.default.createFromString("-hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.isEnabled()).toBe(false);
+        });
+        describe("Version", () => {
+            test("must parse version", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@1.0.0");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("1.0.0");
+            });
+            test("must parse semver", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@>=4.0.0");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe(">=4.0.0");
+            });
+        });
+        describe("GIT Version", () => {
+            test("must handle HTTPS urls", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@git+https://github.com/GitbookIO/plugin-ga.git");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("git+https://github.com/GitbookIO/plugin-ga.git");
+            });
+            test("must handle SSH urls", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+            });
+        });
+        describe("listToArray", () => {
+            test("must create an array from a list of plugin dependencies", () => {
+                const list = pluginDependency_1.default.listToArray(immutable_1.default.List([
+                    pluginDependency_1.default.createFromString("hello@1.0.0"),
+                    pluginDependency_1.default.createFromString("noversion"),
+                    pluginDependency_1.default.createFromString("-disabled"),
+                ]));
+                expect(list).toEqual(["hello@1.0.0", "noversion", "-disabled"]);
+            });
+        });
+        describe("listFromArray", () => {
+            test("must create an array from a list of plugin dependencies", () => {
+                const arr = immutable_1.default.fromJS([
+                    "hello@1.0.0",
+                    {
+                        name: "plugin-ga",
+                        version: "git+ssh://samy@github.com/GitbookIO/plugin-ga.git",
+                    },
+                ]);
+                const list = pluginDependency_1.default.listFromArray(arr);
+                expect(list.first().getName()).toBe("hello");
+                expect(list.first().getVersion()).toBe("1.0.0");
+                expect(list.last().getName()).toBe("plugin-ga");
+                expect(list.last().getVersion()).toBe("git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+            });
+        });
+    });
+});

package/lib/models/__tests__/summary.d.ts

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

package/lib/models/__tests__/summary.d.ts.map

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