honkit 3.6.21

package/lib/templating/render.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 promise_1 = __importDefault(require("../utils/promise"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const templateOutput_1 = __importDefault(require("../models/templateOutput"));
+const replaceShortcuts_1 = __importDefault(require("./replaceShortcuts"));
+/**
+ * Render a template
+ *
+ * @param {TemplateEngine} engine
+ * @param {string} filePath: absolute path for the loader
+ * @param {string} content
+ * @param {Object} context (optional)
+ * @return {Promise<TemplateOutput>}
+ */
+function renderTemplate(engine, filePath, content, context) {
+    context = context || {};
+    // Mutable objects to contains all blocks requiring post-processing
+    const blocks = {};
+    // Create nunjucks environment
+    const env = engine.toNunjucks(blocks);
+    // Replace shortcuts from plugin's blocks
+    content = replaceShortcuts_1.default(engine.getBlocks(), filePath, content);
+    return timing_1.default.measure("template.render", promise_1.default.nfcall(env.renderString.bind(env), content, context, {
+        path: filePath,
+    })
+        .then((content) => {
+        return templateOutput_1.default.create(content, blocks);
+    })
+        .catch((error) => {
+        console.log("env:", env);
+        console.log("context:", context);
+        console.log("content:", content);
+        console.error("rendering error:", error);
+        return promise_1.default.reject(error);
+    }));
+}
+exports.default = renderTemplate;

package/lib/templating/renderFile.js

@@ -0,0 +1,39 @@
+"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"));
+const error_1 = __importDefault(require("../utils/error"));
+const render_1 = __importDefault(require("./render"));
+/**
+ * Render a template
+ *
+ * @param {TemplateEngine} engine
+ * @param {string} filePath
+ * @param {Object} context
+ * @return {Promise<TemplateOutput>}
+ */
+function renderTemplateFile(engine, filePath, context) {
+    const loader = engine.getLoader();
+    // Resolve the filePath
+    const resolvedFilePath = loader.resolve(null, filePath);
+    return promise_1.default()
+        .then(() => {
+        if (!loader.async) {
+            return loader.getSource(resolvedFilePath);
+        }
+        const deferred = promise_1.default.defer();
+        loader.getSource(resolvedFilePath, deferred.makeNodeResolver());
+        return deferred.promise;
+    })
+        .then((result) => {
+        if (!result) {
+            throw error_1.default.TemplateError(new Error("Not found"), {
+                filename: filePath,
+            });
+        }
+        return render_1.default(engine, result.path, result.src, context);
+    });
+}
+exports.default = renderTemplateFile;

package/lib/templating/replaceShortcuts.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 escape_string_regexp_1 = __importDefault(require("escape-string-regexp"));
+const listShortcuts_1 = __importDefault(require("./listShortcuts"));
+/**
+ * Apply a shortcut of block to a template
+ * @param {string} content
+ * @param {Shortcut} shortcut
+ * @return {string}
+ */
+function applyShortcut(content, shortcut) {
+    const start = shortcut.getStart();
+    const end = shortcut.getEnd();
+    const tagStart = shortcut.getStartTag();
+    const tagEnd = shortcut.getEndTag();
+    const regex = new RegExp(`${escape_string_regexp_1.default(start)}([\\s\\S]*?[^\\$])${escape_string_regexp_1.default(end)}`, "g");
+    return content.replace(regex, (all, match) => {
+        return `{% ${tagStart} %}${match}{% ${tagEnd} %}`;
+    });
+}
+/**
+ * Replace shortcuts from blocks in a string
+ *
+ * @param {List<TemplateBlock>} engine
+ * @param {string} filePath
+ * @param {string} content
+ * @return {string}
+ */
+function replaceShortcuts(blocks, filePath, content) {
+    const shortcuts = listShortcuts_1.default(blocks, filePath);
+    return shortcuts.reduce(applyShortcut, content);
+}
+exports.default = replaceShortcuts;

package/lib/templating/themesLoader.js

@@ -0,0 +1,98 @@
+"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 nunjucks_1 = __importDefault(require("nunjucks"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const path_2 = __importDefault(require("../utils/path"));
+const ThemesLoader = nunjucks_1.default.Loader.extend({
+    // @ts-expect-error: Property 'extend' does not exist on type 'typeof Loader'.
+    init: function (searchPaths) {
+        this.searchPaths = immutable_1.default.List(searchPaths).map(path_1.default.normalize);
+    },
+    /**
+     * Read source of a resolved filepath
+     * @param {string}
+     * @return {Object}
+     */
+    getSource: function (fullpath) {
+        if (!fullpath)
+            return null;
+        fullpath = this.resolve(null, fullpath);
+        const templateName = this.getTemplateName(fullpath);
+        if (!fullpath) {
+            return null;
+        }
+        let src = fs_1.default.readFileSync(fullpath, "utf-8");
+        src = `{% do %}var template = template || {}; template.stack = template.stack || []; template.stack.push(template.self); template.self = ${JSON.stringify(templateName)}{% enddo %}\n${src}\n{% do %}template.self = template.stack.pop();{% enddo %}`;
+        return {
+            src: src,
+            path: fullpath,
+            noCache: true,
+        };
+    },
+    /**
+     * Nunjucks calls "isRelative" to determine when to call "resolve".
+     * We handle absolute paths ourselves in ".resolve" so we always return true
+     */
+    isRelative: function () {
+        return true;
+    },
+    /**
+     * Get original search path containing a template
+     * @param {string} filepath
+     * @return {string} searchPath
+     */
+    getSearchPath: function (filepath) {
+        return this.searchPaths
+            .sortBy((s) => {
+            return -s.length;
+        })
+            .find((basePath) => {
+            return filepath && filepath.indexOf(basePath) === 0;
+        });
+    },
+    /**
+     * Get template name from a filepath
+     * @param {string} filepath
+     * @return {string} name
+     */
+    getTemplateName: function (filepath) {
+        const originalSearchPath = this.getSearchPath(filepath);
+        return originalSearchPath ? path_1.default.relative(originalSearchPath, filepath) : null;
+    },
+    /**
+     * Resolve a template from a current template
+     * @param {String|null} from
+     * @param {string} to
+     * @return {String|null}
+     */
+    resolve: function (from, to) {
+        let searchPaths = this.searchPaths;
+        // Relative template like "./test.html"
+        if (path_2.default.isPureRelative(to) && from) {
+            return path_1.default.resolve(path_1.default.dirname(from), to);
+        }
+        // Determine in which search folder we currently are
+        const originalSearchPath = this.getSearchPath(from);
+        const originalFilename = this.getTemplateName(from);
+        // If we are including same file from a different search path
+        // Slice the search paths to avoid including from previous ones
+        if (originalFilename == to) {
+            const currentIndex = searchPaths.indexOf(originalSearchPath);
+            searchPaths = searchPaths.slice(currentIndex + 1);
+        }
+        // Absolute template to resolve in root folder
+        const resultFolder = searchPaths.find((basePath) => {
+            const p = path_1.default.resolve(basePath, to);
+            return p.indexOf(basePath) === 0 && fs_1.default.existsSync(p);
+        });
+        if (!resultFolder)
+            return null;
+        return path_1.default.resolve(resultFolder, to);
+    },
+});
+exports.default = ThemesLoader;

package/lib/utils/__tests__/git.js

@@ -0,0 +1,47 @@
+"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 git_1 = __importDefault(require("../git"));
+describe("Git", () => {
+    jest.setTimeout(30 * 1000);
+    describe("URL parsing", () => {
+        test("should correctly validate git urls", () => {
+            // HTTPS
+            expect(git_1.default.isUrl("git+https://github.com/Hello/world.git")).toBeTruthy();
+            // SSH
+            expect(git_1.default.isUrl("git+git@github.com:GitbookIO/gitbook.git/directory/README.md#e1594cde2c32e4ff48f6c4eff3d3d461743d74e1")).toBeTruthy();
+            // Non valid
+            expect(git_1.default.isUrl("https://github.com/Hello/world.git")).toBeFalsy();
+            expect(git_1.default.isUrl("README.md")).toBeFalsy();
+        });
+        test("should parse HTTPS urls", () => {
+            const parts = git_1.default.parseUrl("git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md");
+            expect(parts.host).toBe("https://gist.github.com/69ea4542e4c8967d2fa7.git");
+            expect(parts.ref).toBe(null);
+            expect(parts.filepath).toBe("test.md");
+        });
+        test("should parse HTTPS urls with a reference", () => {
+            const parts = git_1.default.parseUrl("git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md#1.0.0");
+            expect(parts.host).toBe("https://gist.github.com/69ea4542e4c8967d2fa7.git");
+            expect(parts.ref).toBe("1.0.0");
+            expect(parts.filepath).toBe("test.md");
+        });
+        test("should parse SSH urls", () => {
+            const parts = git_1.default.parseUrl("git+git@github.com:GitbookIO/gitbook.git/directory/README.md#e1594cde2c32e4ff48f6c4eff3d3d461743d74e1");
+            expect(parts.host).toBe("git@github.com:GitbookIO/gitbook.git");
+            expect(parts.ref).toBe("e1594cde2c32e4ff48f6c4eff3d3d461743d74e1");
+            expect(parts.filepath).toBe("directory/README.md");
+        });
+    });
+    describe("Cloning and resolving", () => {
+        test("should clone an HTTPS url", () => {
+            const git = new git_1.default();
+            return git.resolve("git+https://gist.github.com/69ea4542e4c8967d2fa7.git/test.md").then((filename) => {
+                expect(path_1.default.extname(filename)).toBe(".md");
+            });
+        });
+    });
+});

package/lib/utils/__tests__/location.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const location_1 = __importDefault(require("../location"));
+describe("LocationUtils", () => {
+    test("should correctly test external location", () => {
+        expect(location_1.default.isExternal("http://google.fr")).toBe(true);
+        expect(location_1.default.isExternal("https://google.fr")).toBe(true);
+        expect(location_1.default.isExternal("test.md")).toBe(false);
+        expect(location_1.default.isExternal("folder/test.md")).toBe(false);
+        expect(location_1.default.isExternal("/folder/test.md")).toBe(false);
+        expect(location_1.default.isExternal("data:image/png")).toBe(false);
+    });
+    test("should correctly test data:uri location", () => {
+        expect(location_1.default.isDataURI("data:image/png")).toBe(true);
+        expect(location_1.default.isDataURI("http://google.fr")).toBe(false);
+        expect(location_1.default.isDataURI("https://google.fr")).toBe(false);
+        expect(location_1.default.isDataURI("test.md")).toBe(false);
+        expect(location_1.default.isDataURI("data.md")).toBe(false);
+    });
+    test("should correctly detect anchor location", () => {
+        expect(location_1.default.isAnchor("#test")).toBe(true);
+        expect(location_1.default.isAnchor(" #test")).toBe(true);
+        expect(location_1.default.isAnchor("https://google.fr#test")).toBe(false);
+        expect(location_1.default.isAnchor("test.md#test")).toBe(false);
+    });
+    describe(".relative", () => {
+        test("should resolve to a relative path (same folder)", () => {
+            expect(location_1.default.relative("links/", "links/test.md")).toBe("test.md");
+        });
+        test("should resolve to a relative path (parent folder)", () => {
+            expect(location_1.default.relative("links/", "test.md")).toBe("../test.md");
+        });
+        test("should resolve to a relative path (child folder)", () => {
+            expect(location_1.default.relative("links/", "links/hello/test.md")).toBe("hello/test.md");
+        });
+    });
+    describe(".flatten", () => {
+        test("should remove leading slash", () => {
+            expect(location_1.default.flatten("/test.md")).toBe("test.md");
+            expect(location_1.default.flatten("/hello/cool.md")).toBe("hello/cool.md");
+        });
+        test("should remove leading slashes", () => {
+            expect(location_1.default.flatten("///test.md")).toBe("test.md");
+        });
+        test("should not break paths", () => {
+            expect(location_1.default.flatten("hello/cool.md")).toBe("hello/cool.md");
+        });
+    });
+    describe(".toAbsolute", () => {
+        test("should correctly transform as absolute", () => {
+            // @ts-expect-error
+            expect(location_1.default.toAbsolute("http://google.fr")).toBe("http://google.fr");
+            expect(location_1.default.toAbsolute("test.md", "./", "./")).toBe("test.md");
+            expect(location_1.default.toAbsolute("folder/test.md", "./", "./")).toBe("folder/test.md");
+        });
+        test("should correctly handle windows path", () => {
+            expect(location_1.default.toAbsolute("folder\\test.md", "./", "./")).toBe("folder/test.md");
+        });
+        test("should correctly handle absolute path", () => {
+            expect(location_1.default.toAbsolute("/test.md", "./", "./")).toBe("test.md");
+            expect(location_1.default.toAbsolute("/test.md", "test", "test")).toBe("../test.md");
+            expect(location_1.default.toAbsolute("/sub/test.md", "test", "test")).toBe("../sub/test.md");
+            expect(location_1.default.toAbsolute("/test.png", "folder", "")).toBe("test.png");
+        });
+        test("should correctly handle absolute path (windows)", () => {
+            expect(location_1.default.toAbsolute("\\test.png", "folder", "")).toBe("test.png");
+        });
+        test("should resolve path starting by \"/\" in root directory", () => {
+            expect(location_1.default.toAbsolute("/test/hello.md", "./", "./")).toBe("test/hello.md");
+        });
+        test("should resolve path starting by \"/\" in child directory", () => {
+            expect(location_1.default.toAbsolute("/test/hello.md", "./hello", "./")).toBe("test/hello.md");
+        });
+        test("should resolve path starting by \"/\" in child directory, with same output directory", () => {
+            expect(location_1.default.toAbsolute("/test/hello.md", "./hello", "./hello")).toBe("../test/hello.md");
+        });
+    });
+});

package/lib/utils/__tests__/path.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 path_1 = __importDefault(require("path"));
+const path_2 = __importDefault(require("../path"));
+describe("Paths", () => {
+    describe("setExtension", () => {
+        test("should correctly change extension of filename", () => {
+            expect(path_2.default.setExtension("test.md", ".html")).toBe("test.html");
+            expect(path_2.default.setExtension("test.md", ".json")).toBe("test.json");
+        });
+        test("should correctly change extension of path", () => {
+            expect(path_2.default.setExtension("hello/test.md", ".html")).toBe(path_1.default.normalize("hello/test.html"));
+            expect(path_2.default.setExtension("hello/test.md", ".json")).toBe(path_1.default.normalize("hello/test.json"));
+        });
+    });
+});

package/lib/utils/command.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = __importDefault(require("is"));
+const child_process_1 = __importDefault(require("child_process"));
+const spawn_cmd_1 = require("spawn-cmd");
+const promise_1 = __importDefault(require("./promise"));
+/**
+ Execute a command
+
+ @param {string} command
+ @param {Object} options
+ @return {Promise}
+ */
+function exec(command, options) {
+    const d = promise_1.default.defer();
+    const child = child_process_1.default.exec(command, options, (err, stdout, stderr) => {
+        if (!err) {
+            return d.resolve();
+        }
+        err.message = stdout.toString("utf8") + stderr.toString("utf8");
+        d.reject(err);
+    });
+    child.stdout.on("data", (data) => {
+        d.notify(data);
+    });
+    child.stderr.on("data", (data) => {
+        d.notify(data);
+    });
+    return d.promise;
+}
+/**
+ Spawn an executable
+
+ @param {string} command
+ @param {Array} args
+ @param {Object} options
+ @return {Promise}
+ */
+function spawnCmd(command, args, options) {
+    const d = promise_1.default.defer();
+    const child = spawn_cmd_1.spawn(command, args, options);
+    child.on("error", (error) => {
+        return d.reject(error);
+    });
+    child.stdout.on("data", (data) => {
+        d.notify(data);
+    });
+    child.stderr.on("data", (data) => {
+        d.notify(data);
+    });
+    child.on("close", (code) => {
+        if (code === 0) {
+            d.resolve();
+        }
+        else {
+            d.reject(new Error(`Error with command "${command}"`));
+        }
+    });
+    return d.promise;
+}
+/**
+ Transform an option object to a command line string
+
+ @param {String|number} value
+ @param {string}
+ */
+function escapeShellArg(value) {
+    if (is_1.default.number(value)) {
+        return value;
+    }
+    value = String(value);
+    value = value.replace(/"/g, '\\"');
+    return `"${value}"`;
+}
+/**
+ Transform a map of options into a command line arguments string
+
+ @param {Object} options
+ @return {string}
+ */
+function optionsToShellArgs(options) {
+    const result = [];
+    for (const key in options) {
+        const value = options[key];
+        if (value === null || value === undefined || value === false) {
+            continue;
+        }
+        if (typeof value === "boolean") {
+            result.push(key);
+        }
+        else {
+            result.push(`${key}=${escapeShellArg(value)}`);
+        }
+    }
+    return result.join(" ");
+}
+exports.default = {
+    exec: exec,
+    spawn: spawnCmd,
+    optionsToShellArgs: optionsToShellArgs,
+};