honkit 3.6.21

package/lib/api/encodeConfig.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const object_path_1 = __importDefault(require("object-path"));
+const deprecate_1 = __importDefault(require("./deprecate"));
+/**
+ Encode a config object into a JS config api
+
+ @param {Output} output
+ @param {Config} config
+ @return {Object}
+ */
+function encodeConfig(output, config) {
+    const result = {
+        values: config.getValues().toJS(),
+        get: function (key, defaultValue) {
+            return object_path_1.default.get(result.values, key, defaultValue);
+        },
+        set: function (key, value) {
+            return object_path_1.default.set(result.values, key, value);
+        },
+    };
+    deprecate_1.default.field(output, "config.options", result, "options", result.values, '"config.options" property is deprecated, use "config.get(key)" instead');
+    deprecate_1.default.field(output, "config.options.generator", result.values, "generator", output.getGenerator(), '"options.generator" property is deprecated, use "output.name" instead');
+    deprecate_1.default.field(output, "config.options.generator", result.values, "output", output.getRoot(), '"options.output" property is deprecated, use "output.root()" instead');
+    return result;
+}
+exports.default = encodeConfig;

package/lib/api/encodeGlobal.js

@@ -0,0 +1,226 @@
+"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 promise_1 = __importDefault(require("../utils/promise"));
+const path_2 = __importDefault(require("../utils/path"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const plugins_1 = __importDefault(require("../plugins"));
+const deprecate_1 = __importDefault(require("./deprecate"));
+const fileToURL_1 = __importDefault(require("../output/helper/fileToURL"));
+const defaultBlocks_1 = __importDefault(require("../constants/defaultBlocks"));
+const honkit_1 = __importDefault(require("../honkit"));
+const parsers_1 = __importDefault(require("../parsers"));
+const encodeConfig_1 = __importDefault(require("./encodeConfig"));
+const encodeSummary_1 = __importDefault(require("./encodeSummary"));
+const encodeNavigation_1 = __importDefault(require("./encodeNavigation"));
+const encodePage_1 = __importDefault(require("./encodePage"));
+/**
+ Encode a global context into a JS object
+ It's the context for page's hook, etc
+
+ @param {Output} output
+ @return {Object}
+ */
+function encodeGlobal(output) {
+    const book = output.getBook();
+    const bookFS = book.getContentFS();
+    const logger = output.getLogger();
+    const outputFolder = output.getRoot();
+    const plugins = output.getPlugins();
+    const blocks = plugins_1.default.listBlocks(plugins);
+    const result = {
+        log: logger,
+        config: encodeConfig_1.default(output, book.getConfig()),
+        summary: encodeSummary_1.default(output, book.getSummary()),
+        /**
+         Check if the book is a multilingual book
+
+         @return {boolean}
+         */
+        isMultilingual: function () {
+            return book.isMultilingual();
+        },
+        /**
+         Check if the book is a language book for a multilingual book
+
+         @return {boolean}
+         */
+        isLanguageBook: function () {
+            return book.isLanguageBook();
+        },
+        /**
+         Read a file from the book
+
+         @param {string} fileName
+         @return {Promise<Buffer>}
+         */
+        readFile: function (fileName) {
+            return bookFS.read(fileName);
+        },
+        /**
+         Read a file from the book as a string
+
+         @param {string} fileName
+         @return {Promise<String>}
+         */
+        readFileAsString: function (fileName) {
+            return bookFS.readAsString(fileName);
+        },
+        /**
+         Resolve a file from the book root
+
+         @param {string} fileName
+         @return {string}
+         */
+        resolve: function (fileName) {
+            return path_1.default.resolve(book.getContentRoot(), fileName);
+        },
+        /**
+         Resolve a page by it path
+
+         @param {string} filePath
+         @return {string}
+         */
+        getPageByPath: function (filePath) {
+            const page = output.getPage(filePath);
+            if (!page)
+                return undefined;
+            return encodePage_1.default(output, page);
+        },
+        /**
+         Render a block of text (markdown/asciidoc)
+
+         @param {string} type
+         @param {string} text
+         @return {Promise<String>}
+         */
+        renderBlock: function (type, text) {
+            const parser = parsers_1.default.get(type);
+            return parser.parsePage(text).get("content");
+        },
+        /**
+         Render an inline text (markdown/asciidoc)
+
+         @param {string} type
+         @param {string} text
+         @return {Promise<String>}
+         */
+        renderInline: function (type, text) {
+            const parser = parsers_1.default.get(type);
+            return parser.parseInline(text).get("content");
+        },
+        template: {
+            /**
+             Apply a templating block and returns its result
+
+             @param {string} name
+             @param {Object} blockData
+             @return {Promise|Object}
+             */
+            applyBlock: function (name, blockData) {
+                const block = blocks.get(name) || defaultBlocks_1.default.get(name);
+                return promise_1.default(block.applyBlock(blockData, result));
+            },
+        },
+        output: {
+            /**
+             Name of the generator being used
+             {string}
+             */
+            name: output.getGenerator(),
+            /**
+             Return absolute path to the root folder of output
+             @return {string}
+             */
+            root: function () {
+                return outputFolder;
+            },
+            /**
+             Resolve a file from the output root
+
+             @param {string} fileName
+             @return {string}
+             */
+            resolve: function (fileName) {
+                return path_1.default.resolve(outputFolder, fileName);
+            },
+            /**
+             Convert a filepath into an url
+             @return {string}
+             */
+            toURL: function (filePath) {
+                return fileToURL_1.default(output, filePath);
+            },
+            /**
+             Check that a file exists.
+
+             @param {string} fileName
+             @return {Promise}
+             */
+            hasFile: function (fileName, content) {
+                return promise_1.default().then(() => {
+                    // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 2.
+                    const filePath = path_2.default.resolveInRoot(outputFolder, fileName);
+                    return fs_1.default.exists(filePath);
+                });
+            },
+            /**
+             Write a file to the output folder,
+             It creates the required folder
+
+             @param {string} fileName
+             @param {Buffer} content
+             @return {Promise}
+             */
+            writeFile: function (fileName, content) {
+                return promise_1.default().then(() => {
+                    // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 2.
+                    const filePath = path_2.default.resolveInRoot(outputFolder, fileName);
+                    return fs_1.default.ensureFile(filePath).then(() => {
+                        return fs_1.default.writeFile(filePath, content);
+                    });
+                });
+            },
+            /**
+             Copy a file to the output folder
+             It creates the required folder.
+
+             @param {string} inputFile
+             @param {string} outputFile
+             @param {Buffer} content
+             @return {Promise}
+             */
+            copyFile: function (inputFile, outputFile, content) {
+                return promise_1.default().then(() => {
+                    // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 2.
+                    const outputFilePath = path_2.default.resolveInRoot(outputFolder, outputFile);
+                    return fs_1.default.ensureFile(outputFilePath).then(() => {
+                        return fs_1.default.copy(inputFile, outputFilePath);
+                    });
+                });
+            },
+        },
+        gitbook: {
+            version: honkit_1.default.version,
+        },
+        honkit: {
+            version: honkit_1.default.version,
+        },
+    };
+    // Deprecated properties
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 6 arguments, but got 5.
+    deprecate_1.default.renamedMethod(output, "this.isSubBook", result, "isSubBook", "isLanguageBook");
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 6 arguments, but got 5.
+    deprecate_1.default.renamedMethod(output, "this.contentLink", result, "contentLink", "output.toURL");
+    deprecate_1.default.field(output, "this.generator", result, "generator", output.getGenerator(), '"this.generator" property is deprecated, use "this.output.name" instead');
+    deprecate_1.default.field(output, "this.navigation", result, "navigation", () => {
+        return encodeNavigation_1.default(output);
+    }, '"navigation" property is deprecated');
+    deprecate_1.default.field(output, "this.book", result, "book", result, '"book" property is deprecated, use "this" directly instead');
+    deprecate_1.default.field(output, "this.options", result, "options", result.config.values, '"options" property is deprecated, use config.get(key) instead');
+    return result;
+}
+exports.default = encodeGlobal;

package/lib/api/encodeNavigation.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"));
+/**
+ Encode an article for next/prev
+
+ @param {Map<String:Page>}
+ @param {Article}
+ @return {Object}
+ */
+function encodeArticle(pages, article) {
+    const articlePath = article.getPath();
+    return {
+        path: articlePath,
+        title: article.getTitle(),
+        level: article.getLevel(),
+        exists: articlePath && pages.has(articlePath),
+        external: article.isExternal(),
+    };
+}
+/**
+ this.navigation is a deprecated property from GitBook v2
+
+ @param {Output}
+ @return {Object}
+ */
+function encodeNavigation(output) {
+    const book = output.getBook();
+    const pages = output.getPages();
+    const summary = book.getSummary();
+    const articles = summary.getArticlesAsList();
+    const navigation = articles
+        .map((article, i) => {
+        const ref = article.getRef();
+        if (!ref) {
+            return undefined;
+        }
+        const prev = articles.get(i - 1);
+        const next = articles.get(i + 1);
+        return [
+            ref,
+            {
+                index: i,
+                title: article.getTitle(),
+                introduction: i === 0,
+                prev: prev ? encodeArticle(pages, prev) : undefined,
+                next: next ? encodeArticle(pages, next) : undefined,
+                level: article.getLevel(),
+            },
+        ];
+    })
+        .filter((e) => {
+        return Boolean(e);
+    });
+    return immutable_1.default.Map(navigation).toJS();
+}
+exports.default = encodeNavigation;

package/lib/api/encodePage.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_1 = __importDefault(require("../json"));
+const deprecate_1 = __importDefault(require("./deprecate"));
+const encodeProgress_1 = __importDefault(require("./encodeProgress"));
+/**
+ Encode a page in a context to a JS API
+
+ @param {Output} output
+ @param {Page} page
+ @return {Object}
+ */
+function encodePage(output, page) {
+    const book = output.getBook();
+    const summary = book.getSummary();
+    const fs = book.getContentFS();
+    const file = page.getFile();
+    // JS Page is based on the JSON output
+    const result = json_1.default.encodePage(page, summary);
+    result.type = file.getType();
+    result.path = file.getPath();
+    result.rawPath = fs.resolve(result.path);
+    deprecate_1.default.field(output, "page.progress", result, "progress", () => {
+        return encodeProgress_1.default(output, page);
+    }, '"page.progress" property is deprecated');
+    deprecate_1.default.field(output, "page.sections", result, "sections", [
+        {
+            content: result.content,
+            type: "normal",
+        },
+    ], '"sections" property is deprecated, use page.content instead');
+    return result;
+}
+exports.default = encodePage;

package/lib/api/encodeProgress.js

@@ -0,0 +1,58 @@
+"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 encodeNavigation_1 = __importDefault(require("./encodeNavigation"));
+/**
+ page.progress is a deprecated property from GitBook v2
+
+ @param {Output}
+ @param {Page}
+ @return {Object}
+ */
+function encodeProgress(output, page) {
+    const current = page.getPath();
+    let navigation = encodeNavigation_1.default(output);
+    navigation = immutable_1.default.Map(navigation);
+    const n = navigation.size;
+    let percent = 0, prevPercent = 0, currentChapter = null;
+    let done = true;
+    const chapters = navigation
+        .map((nav, chapterPath) => {
+        nav.path = chapterPath;
+        return nav;
+    })
+        .valueSeq()
+        .sortBy((nav) => {
+        return nav.index;
+    })
+        .map((nav, i) => {
+        // Calcul percent
+        nav.percent = (i * 100) / Math.max(n - 1, 1);
+        // Is it done
+        nav.done = done;
+        if (nav.path == current) {
+            currentChapter = nav;
+            percent = nav.percent;
+            done = false;
+        }
+        else if (done) {
+            prevPercent = nav.percent;
+        }
+        return nav;
+    })
+        .toJS();
+    return {
+        // Previous percent
+        prevPercent: prevPercent,
+        // Current percent
+        percent: percent,
+        // List of chapter with progress
+        chapters: chapters,
+        // Current chapter
+        current: currentChapter,
+    };
+}
+exports.default = encodeProgress;

package/lib/api/encodeSummary.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 encodeSummaryArticle_1 = __importDefault(require("../json/encodeSummaryArticle"));
+/**
+ Encode summary to provide an API to plugin
+
+ @param {Output} output
+ @param {Config} config
+ @return {Object}
+ */
+function encodeSummary(output, summary) {
+    const result = {
+        /**
+         Iterate over the summary, it stops when the "iter" returns false
+
+         @param {Function} iter
+         */
+        walk: function (iter) {
+            summary.getArticle((article) => {
+                const jsonArticle = encodeSummaryArticle_1.default(article, false);
+                return iter(jsonArticle);
+            });
+        },
+        /**
+         Get an article by its level
+
+         @param {string} level
+         @return {Object}
+         */
+        getArticleByLevel: function (level) {
+            const article = summary.getByLevel(level);
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+            return article ? encodeSummaryArticle_1.default(article) : undefined;
+        },
+        /**
+         Get an article by its path
+
+         @param {string} level
+         @return {Object}
+         */
+        getArticleByPath: function (level) {
+            const article = summary.getByPath(level);
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+            return article ? encodeSummaryArticle_1.default(article) : undefined;
+        },
+    };
+    return result;
+}
+exports.default = encodeSummary;