honkit 3.6.21

package/lib/plugins/toNames.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Return list of plugin names. This method is nly used in unit tests.
+ *
+ * @param {OrderedMap<String:Plugin} plugins
+ * @return {Array<String>}
+ */
+function toNames(plugins) {
+    return plugins
+        .map((plugin) => {
+        return plugin.getName();
+    })
+        .toArray();
+}
+exports.default = toNames;

package/lib/plugins/validateConfig.js

@@ -0,0 +1,60 @@
+"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 jsonschema_1 = __importDefault(require("jsonschema"));
+const json_schema_defaults_1 = __importDefault(require("json-schema-defaults"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const error_1 = __importDefault(require("../utils/error"));
+const mergeDefaults_1 = __importDefault(require("../utils/mergeDefaults"));
+/**
+ Validate one plugin for a book and update book's confiration
+
+ @param {Book}
+ @param {Plugin}
+ @return {Book}
+ */
+function validatePluginConfig(book, plugin) {
+    let config = book.getConfig();
+    const packageInfos = plugin.getPackage();
+    const configKey = ["pluginsConfig", plugin.getName()].join(".");
+    let pluginConfig = config.getValue(configKey, {}).toJS();
+    const schema = (packageInfos.get("gitbook") || immutable_1.default.Map()).toJS();
+    if (!schema)
+        return book;
+    // Normalize schema
+    schema.id = `/${configKey}`;
+    schema.type = "object";
+    // Validate and throw if invalid
+    const v = new jsonschema_1.default.Validator();
+    const result = v.validate(pluginConfig, schema, {
+        propertyName: configKey,
+    });
+    // Throw error
+    if (result.errors.length > 0) {
+        throw new error_1.default.ConfigurationError(new Error(result.errors[0].stack));
+    }
+    // Insert default values
+    const defaults = json_schema_defaults_1.default(schema);
+    pluginConfig = mergeDefaults_1.default(pluginConfig, defaults);
+    // Update configuration
+    config = config.setValue(configKey, pluginConfig);
+    // Return new book
+    return book.set("config", config);
+}
+/**
+ Validate a book configuration for plugins and
+ returns an update configuration with default values.
+
+ @param {Book}
+ @param {OrderedMap<String:Plugin>}
+ @return {Promise<Book>}
+ */
+function validateConfig(book, plugins) {
+    return promise_1.default.reduce(plugins, (newBook, plugin) => {
+        return validatePluginConfig(newBook, plugin);
+    }, book);
+}
+exports.default = validateConfig;

package/lib/plugins/validatePlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const honkit_1 = __importDefault(require("../honkit"));
+const promise_1 = __importDefault(require("../utils/promise"));
+/**
+ Validate a plugin
+
+ @param {Plugin} plugin
+ @return {Promise<Plugin>}
+ */
+function validatePlugin(plugin) {
+    const packageInfos = plugin.getPackage();
+    const isValid = plugin.isLoaded() &&
+        packageInfos &&
+        packageInfos.get("name") &&
+        packageInfos.get("engines") &&
+        (packageInfos.get("engines").get("gitbook") || packageInfos.get("engines").get("honkit"));
+    const pluginName = packageInfos.get("name") || "unknown plugin";
+    if (!isValid) {
+        return promise_1.default.reject(new Error(`Error loading plugin "${pluginName}" at "${plugin.getPath()}"`));
+    }
+    const gitbookVersion = packageInfos.get("engines").get("gitbook");
+    const honkitVersion = packageInfos.get("engines").get("honkit");
+    // support "gitbook" and "honkit"
+    if (gitbookVersion && !honkit_1.default.satisfies(gitbookVersion)) {
+        return promise_1.default.reject(new Error(`HonKit doesn't satisfy the requirements of this plugin: ${pluginName} require ${honkitVersion}`));
+    }
+    if (honkitVersion && !honkit_1.default.satisfies(honkitVersion)) {
+        return promise_1.default.reject(new Error(`HonKit doesn't satisfy the requirements of this plugin: ${pluginName} require ${honkitVersion}`));
+    }
+    return promise_1.default(plugin);
+}
+exports.default = validatePlugin;

package/lib/templating/__tests__/conrefsLoader.js

@@ -0,0 +1,93 @@
+"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 templateEngine_1 = __importDefault(require("../../models/templateEngine"));
+const render_1 = __importDefault(require("../render"));
+const conrefsLoader_1 = __importDefault(require("../conrefsLoader"));
+describe("ConrefsLoader", () => {
+    const dirName = `${__dirname}/`;
+    const fileName = path_1.default.join(dirName, "test.md");
+    describe("Git", () => {
+        const engine = new templateEngine_1.default({
+            // @ts-expect-error: Expected 0 arguments, but got 1.
+            loader: new conrefsLoader_1.default(dirName),
+        });
+        test("should include content from git", () => {
+            jest.setTimeout(20 * 1000);
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+            return render_1.default(engine, fileName, '{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md" %}').then((out) => {
+                expect(out.getContent()).toBe("Hello from git");
+            });
+        });
+        test("should handle deep inclusion (1)", () => {
+            jest.setTimeout(20 * 1000);
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+            return render_1.default(engine, fileName, '{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test2.md" %}').then((out) => {
+                expect(out.getContent()).toBe("First Hello. Hello from git");
+            });
+        });
+        test("should handle deep inclusion (2)", () => {
+            jest.setTimeout(20 * 1000);
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+            return render_1.default(engine, fileName, '{% include "git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test3.md" %}').then((out) => {
+                expect(out.getContent()).toBe("First Hello. Hello from git");
+            });
+        });
+    });
+    describe("Local", () => {
+        const engine = new templateEngine_1.default({
+            // @ts-expect-error: Expected 0 arguments, but got 1.
+            loader: new conrefsLoader_1.default(dirName),
+        });
+        describe("Relative", () => {
+            test("should resolve basic relative filepath", () => {
+                // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+                return render_1.default(engine, fileName, '{% include "include.md" %}').then((out) => {
+                    expect(out.getContent()).toBe("Hello World");
+                });
+            });
+            test("should resolve basic parent filepath", () => {
+                // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+                return render_1.default(engine, path_1.default.join(dirName, "hello/test.md"), '{% include "../include.md" %}').then((out) => {
+                    expect(out.getContent()).toBe("Hello World");
+                });
+            });
+        });
+        describe("Absolute", () => {
+            test("should resolve absolute filepath", () => {
+                // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+                return render_1.default(engine, fileName, '{% include "/include.md" %}').then((out) => {
+                    expect(out.getContent()).toBe("Hello World");
+                });
+            });
+            test("should resolve absolute filepath when in a directory", () => {
+                // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+                return render_1.default(engine, path_1.default.join(dirName, "hello/test.md"), '{% include "/include.md" %}').then((out) => {
+                    expect(out.getContent()).toBe("Hello World");
+                });
+            });
+        });
+    });
+    describe("transform", () => {
+        function transform(filePath, source) {
+            expect(typeof filePath).toBe("string");
+            expect(typeof source).toBe("string");
+            expect(filePath).toBe(path_1.default.resolve(__dirname, "include.md"));
+            expect(source).toBe("Hello World");
+            return `test-${source}-endtest`;
+        }
+        const engine = new templateEngine_1.default({
+            // @ts-expect-error: Expected 0 arguments, but got 1.
+            loader: new conrefsLoader_1.default(dirName, transform),
+        });
+        test("should transform included content", () => {
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+            return render_1.default(engine, fileName, '{% include "include.md" %}').then((out) => {
+                expect(out.getContent()).toBe("test-Hello World-endtest");
+            });
+        });
+    });
+});

package/lib/templating/__tests__/postRender.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const templateEngine_1 = __importDefault(require("../../models/templateEngine"));
+const templateBlock_1 = __importDefault(require("../../models/templateBlock"));
+const render_1 = __importDefault(require("../render"));
+const postRender_1 = __importDefault(require("../postRender"));
+describe("postRender", () => {
+    let testPost;
+    const engine = templateEngine_1.default.create({
+        blocks: [
+            templateBlock_1.default.create("lower", (blk) => {
+                return blk.body.toLowerCase();
+            }),
+            templateBlock_1.default.create("prefix", (blk) => {
+                return {
+                    body: `_${blk.body}_`,
+                    post: function () {
+                        testPost = true;
+                    },
+                };
+            }),
+        ],
+    });
+    test("should correctly replace block", () => {
+        // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+        return render_1.default(engine, "README.md", "Hello {% lower %}Samy{% endlower %}")
+            .then((output) => {
+            expect(output.getContent()).toMatch(/Hello \{\{\-([\S]+)\-\}\}/);
+            expect(output.getBlocks().size).toBe(1);
+            return postRender_1.default(engine, output);
+        })
+            .then((result) => {
+            expect(result).toBe("Hello samy");
+        });
+    });
+    test("should correctly replace blocks", () => {
+        // @ts-expect-error ts-migrate(2554) FIXME: Expected 4 arguments, but got 3.
+        return render_1.default(engine, "README.md", "Hello {% lower %}Samy{% endlower %}{% prefix %}Pesse{% endprefix %}")
+            .then((output) => {
+            expect(output.getContent()).toMatch(/Hello \{\{\-([\S]+)\-\}\}\{\{\-([\S]+)\-\}\}/);
+            expect(output.getBlocks().size).toBe(2);
+            return postRender_1.default(engine, output);
+        })
+            .then((result) => {
+            expect(result).toBe("Hello samy_Pesse_");
+            expect(testPost).toBe(true);
+        });
+    });
+});

package/lib/templating/__tests__/replaceShortcuts.js

@@ -0,0 +1,27 @@
+"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 templateBlock_1 = __importDefault(require("../../models/templateBlock"));
+const replaceShortcuts_1 = __importDefault(require("../replaceShortcuts"));
+describe("replaceShortcuts", () => {
+    const blocks = immutable_1.default.List([
+        templateBlock_1.default.create("math", {
+            shortcuts: {
+                start: "$$",
+                end: "$$",
+                parsers: ["markdown"],
+            },
+        }),
+    ]);
+    test("should correctly replace inline matches by block", () => {
+        const content = replaceShortcuts_1.default(blocks, "test.md", "Hello $$a = b$$");
+        expect(content).toBe("Hello {% math %}a = b{% endmath %}");
+    });
+    test("should correctly replace block matches", () => {
+        const content = replaceShortcuts_1.default(blocks, "test.md", "Hello\n$$\na = b\n$$\n");
+        expect(content).toBe("Hello\n{% math %}\na = b\n{% endmath %}\n");
+    });
+});

package/lib/templating/conrefsLoader.js

@@ -0,0 +1,88 @@
+"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 nunjucks_1 = __importDefault(require("nunjucks"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const git_1 = __importDefault(require("../utils/git"));
+const location_1 = __importDefault(require("../utils/location"));
+const path_2 = __importDefault(require("../utils/path"));
+/**
+ * Template loader resolving both:
+ *      - relative url ("./test.md")
+ *      - absolute url ("/test.md")
+ *      - git url ("")
+ *
+ * @param {string} rootFolder
+ * @param {Function(filePath, source)} transformFn (optional)
+ * @param {Logger} logger (optional)
+ */
+const ConrefsLoader = nunjucks_1.default.Loader.extend({
+    async: true,
+    init: function (rootFolder, transformFn, logger) {
+        this.rootFolder = rootFolder;
+        this.transformFn = transformFn;
+        this.logger = logger;
+        this.git = new git_1.default();
+    },
+    // @ts-expect-error: Property 'extend' does not exist on type 'typeof Loader'.
+    getSource: function (sourceURL, callback) {
+        const that = this;
+        this.git
+            .resolve(sourceURL)
+            .then((filepath) => {
+            // Is local file
+            if (!filepath) {
+                filepath = path_1.default.resolve(sourceURL);
+            }
+            else {
+                if (that.logger)
+                    that.logger.debug.ln("resolve from git", sourceURL, "to", filepath);
+            }
+            // Read file from absolute path
+            return fs_1.default
+                .readFile(filepath)
+                .then((source) => {
+                source = source.toString("utf8");
+                if (that.transformFn) {
+                    return that.transformFn(filepath, source);
+                }
+                return source;
+            })
+                .then((source) => {
+                return {
+                    src: source,
+                    path: filepath,
+                };
+            });
+        })
+            .nodeify(callback);
+    },
+    resolve: function (from, to) {
+        // If origin is in the book, we enforce result file to be in the book
+        if (path_2.default.isInRoot(this.rootFolder, from)) {
+            // Path of current template in the rootFolder (not absolute to fs)
+            const fromRelative = path_1.default.relative(this.rootFolder, from);
+            // Resolve "to" to a filepath relative to rootFolder
+            const href = location_1.default.toAbsolute(to, path_1.default.dirname(fromRelative), "");
+            // Return absolute path
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 2.
+            return path_2.default.resolveInRoot(this.rootFolder, href);
+        }
+        // If origin is in a git repository, we resolve file in the git repository
+        const gitRoot = this.git.resolveRoot(from);
+        if (gitRoot) {
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 2.
+            return path_2.default.resolveInRoot(gitRoot, to);
+        }
+        // If origin is not in the book (include from a git content ref)
+        return path_1.default.resolve(path_1.default.dirname(from), to);
+    },
+    // Handle all files as relative, so that nunjucks pass responsability to 'resolve'
+    isRelative: function (filename) {
+        return location_1.default.isRelative(filename);
+    },
+});
+exports.default = ConrefsLoader;

package/lib/templating/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const render_1 = __importDefault(require("./render"));
+const postRender_1 = __importDefault(require("./postRender"));
+const renderFile_1 = __importDefault(require("./renderFile"));
+const replaceShortcuts_1 = __importDefault(require("./replaceShortcuts"));
+const conrefsLoader_1 = __importDefault(require("./conrefsLoader"));
+const themesLoader_1 = __importDefault(require("./themesLoader"));
+exports.default = {
+    render: render_1.default,
+    renderFile: renderFile_1.default,
+    postRender: postRender_1.default,
+    replaceShortcuts: replaceShortcuts_1.default,
+    ConrefsLoader: conrefsLoader_1.default,
+    ThemesLoader: themesLoader_1.default,
+};

package/lib/templating/listShortcuts.js

@@ -0,0 +1,29 @@
+"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 parsers_1 = __importDefault(require("../parsers"));
+/**
+ * Return a list of all shortcuts that can apply
+ * to a file for a TemplatEngine
+ *
+ * @param {List<TemplateBlock>} engine
+ * @param {string} filePath
+ * @return {List<TemplateShortcut>}
+ */
+function listShortcuts(blocks, filePath) {
+    const parser = parsers_1.default.getForFile(filePath);
+    if (!parser) {
+        return immutable_1.default.List();
+    }
+    return blocks
+        .map((block) => {
+        return block.getShortcuts();
+    })
+        .filter((shortcuts) => {
+        return shortcuts && shortcuts.acceptParser(parser.getName());
+    });
+}
+exports.default = listShortcuts;

package/lib/templating/postRender.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promise_1 = __importDefault(require("../utils/promise"));
+/**
+ * Replace position markers of blocks by body after processing
+ * This is done to avoid that markdown/asciidoc processer parse the block content
+ *
+ * @param {string} content
+ * @return {Object} {blocks: Set, content: String}
+ */
+function replaceBlocks(content, blocks) {
+    const newContent = content.replace(/\{\{\-\%([\s\S]+?)\%\-\}\}/g, (match, key) => {
+        let replacedWith = match;
+        const block = blocks.get(key);
+        if (block) {
+            replacedWith = replaceBlocks(block.get("body"), blocks);
+        }
+        return replacedWith;
+    });
+    return newContent;
+}
+/**
+ * Post render a template:
+ *     - Execute "post" for blocks
+ *     - Replace block content
+ *
+ * @param {TemplateEngine} engine
+ * @param {TemplateOutput} content
+ * @return {Promise<String>}
+ */
+function postRender(engine, output) {
+    const content = output.getContent();
+    const blocks = output.getBlocks();
+    const result = replaceBlocks(content, blocks);
+    return promise_1.default.forEach(blocks, (block) => {
+        const post = block.get("post");
+        if (!post) {
+            return;
+        }
+        return post();
+    }).thenResolve(result);
+}
+exports.default = postRender;