honkit 3.6.21

package/lib/api/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const decodeGlobal_1 = require("./decodeGlobal");
+const encodePage_1 = __importDefault(require("./encodePage"));
+const decodePage_1 = __importDefault(require("./decodePage"));
+const encodeGlobal_1 = __importDefault(require("./encodeGlobal"));
+exports.default = {
+    encodePage: encodePage_1.default,
+    decodePage: decodePage_1.default,
+    encodeGlobal: encodeGlobal_1.default,
+    decodeGlobal: decodeGlobal_1.decodeGlobal,
+};

package/lib/bin.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 });
+exports.run = void 0;
+const assert_1 = __importDefault(require("assert"));
+const commander_1 = require("commander");
+const index_1 = __importDefault(require("./index"));
+const pkg = require("../package.json");
+const run = (argv = process.argv) => {
+    const program = new commander_1.Command();
+    return new Promise((resolve, reject) => {
+        program.version(pkg.version);
+        index_1.default.commands.forEach((spec) => {
+            let subcommand = program.command(spec.name).description(spec.description);
+            const options = spec.options || [];
+            options.forEach((spec) => {
+                if (spec.values) {
+                    const template = `--${spec.name} <${spec.name}>`;
+                    const description = `${spec.description} (${spec.values.map(JSON.stringify).join(", ")})`;
+                    subcommand = subcommand.option(template, description, (value, _dummyPrevious) => {
+                        assert_1.default(spec.values.includes(value), `Invalid value ${value} for ${spec.name}`);
+                        return value;
+                    }, spec.defaults);
+                }
+                else {
+                    subcommand = subcommand.option(spec.defaults ? `--${spec.name} <type>` : `--${spec.name}`, spec.description, spec.defaults);
+                }
+            });
+            subcommand = subcommand.action((...joinedArgs) => {
+                const args = joinedArgs.slice(0, -1);
+                const kwargs = joinedArgs.slice(-1)[0];
+                spec.exec(args, kwargs)
+                    .then(() => {
+                    resolve();
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            });
+        });
+        program.parse(argv);
+    });
+};
+exports.run = run;

package/lib/browser.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 modifiers_1 = __importDefault(require("./modifiers"));
+const parse_1 = __importDefault(require("./parse"));
+const book_1 = __importDefault(require("./models/book"));
+const fs_1 = __importDefault(require("./models/fs"));
+const file_1 = __importDefault(require("./models/file"));
+const summary_1 = __importDefault(require("./models/summary"));
+const glossary_1 = __importDefault(require("./models/glossary"));
+const config_1 = __importDefault(require("./models/config"));
+const page_1 = __importDefault(require("./models/page"));
+const pluginDependency_1 = __importDefault(require("./models/pluginDependency"));
+const configFiles_1 = __importDefault(require("./constants/configFiles"));
+const ignoreFiles_1 = __importDefault(require("./constants/ignoreFiles"));
+const defaultPlugins_1 = __importDefault(require("./constants/defaultPlugins"));
+const extsMarkdown_1 = __importDefault(require("./constants/extsMarkdown"));
+const extsAsciidoc_1 = __importDefault(require("./constants/extsAsciidoc"));
+exports.default = {
+    Parse: parse_1.default,
+    // Models
+    Book: book_1.default,
+    FS: fs_1.default,
+    File: file_1.default,
+    Summary: summary_1.default,
+    Glossary: glossary_1.default,
+    Config: config_1.default,
+    Page: page_1.default,
+    PluginDependency: pluginDependency_1.default,
+    // Modifiers
+    SummaryModifier: modifiers_1.default.Summary,
+    ConfigModifier: modifiers_1.default.Config,
+    // Constants
+    CONFIG_FILES: configFiles_1.default,
+    IGNORE_FILES: ignoreFiles_1.default,
+    DEFAULT_PLUGINS: defaultPlugins_1.default,
+    EXTENSIONS_MARKDOWN: extsMarkdown_1.default,
+    EXTENSIONS_ASCIIDOC: extsAsciidoc_1.default,
+};

package/lib/cli/build.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 parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const getOutputFolder_1 = __importDefault(require("./getOutputFolder"));
+const page_cache_1 = require("../output/page-cache");
+exports.default = {
+    name: "build [book] [output]",
+    description: "build a book",
+    options: [options_1.default.log, options_1.default.format, options_1.default.timing, options_1.default.reload],
+    exec: function (args, kwargs) {
+        const book = getBook_1.default(args, kwargs);
+        const outputFolder = getOutputFolder_1.default(args);
+        const Generator = output_1.default.getGenerator(kwargs.format);
+        if (kwargs.reload) {
+            book.getLogger().info.ok(`Clear cache`);
+            page_cache_1.clearCache();
+        }
+        return parse_1.default.parseBook(book)
+            .then((resultBook) => {
+            return output_1.default.generate(Generator, resultBook, {
+                root: outputFolder,
+            });
+        })
+            .fin(() => {
+            if (kwargs.timing)
+                timing_1.default.dump(book.getLogger());
+        });
+    },
+};

package/lib/cli/buildEbook.js

@@ -0,0 +1,63 @@
+"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 tmp_1 = __importDefault(require("tmp"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const page_cache_1 = require("../output/page-cache");
+function default_1(format) {
+    return {
+        name: `${format} [book] [output]`,
+        description: "build a book into an ebook file",
+        options: [options_1.default.log],
+        exec: function (args, kwargs) {
+            const extension = `.${format}`;
+            // Output file will be stored in
+            const outputFile = args[1] || `book${extension}`;
+            // Create temporary directory
+            const outputFolder = tmp_1.default.dirSync().name;
+            const book = getBook_1.default(args, kwargs);
+            const logger = book.getLogger();
+            const Generator = output_1.default.getGenerator("ebook");
+            if (kwargs.reload) {
+                page_cache_1.clearCache();
+            }
+            return (parse_1.default.parseBook(book)
+                .then((resultBook) => {
+                return output_1.default.generate(Generator, resultBook, {
+                    root: outputFolder,
+                    format: format,
+                });
+            })
+                // Extract ebook file
+                .then((output) => {
+                const book = output.getBook();
+                const languages = book.getLanguages();
+                if (book.isMultilingual()) {
+                    return promise_1.default.forEach(languages.getList(), (lang) => {
+                        const langID = lang.getID();
+                        const langOutputFile = path_1.default.join(path_1.default.dirname(outputFile), `${path_1.default.basename(outputFile, extension)}_${langID}${extension}`);
+                        return fs_1.default.copy(path_1.default.resolve(outputFolder, langID, `index${extension}`), langOutputFile);
+                    }).thenResolve(languages.getCount());
+                }
+                else {
+                    return fs_1.default.copy(path_1.default.resolve(outputFolder, `index${extension}`), outputFile).thenResolve(1);
+                }
+            })
+                // Log end
+                .then((count) => {
+                logger.info.ok(`${count} file(s) generated`);
+                logger.debug("cleaning up... ");
+                return logger.debug.promise(fs_1.default.rmDir(outputFolder));
+            }));
+        },
+    };
+}
+exports.default = default_1;

package/lib/cli/getBook.js

@@ -0,0 +1,24 @@
+"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 book_1 = __importDefault(require("../models/book"));
+const node_1 = __importDefault(require("../fs/node"));
+/**
+ Return a book instance to work on from
+ command line args/kwargs
+
+ @param {Array} args
+ @param {Object} kwargs
+ @return {Book}
+ */
+function getBook(args, kwargs) {
+    const input = path_1.default.resolve(args[0] || process.cwd());
+    const logLevel = kwargs.log;
+    const fs = node_1.default(input);
+    const book = book_1.default.createForFS(fs);
+    return book.setLogLevel(logLevel);
+}
+exports.default = getBook;

package/lib/cli/getOutputFolder.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"));
+/**
+ Return path to output folder
+
+ @param {Array} args
+ @return {string}
+ */
+function getOutputFolder(args) {
+    const bookRoot = path_1.default.resolve(args[0] || process.cwd());
+    const defaultOutputRoot = path_1.default.join(bookRoot, "_book");
+    const outputFolder = args[1] ? path_1.default.resolve(process.cwd(), args[1]) : defaultOutputRoot;
+    return outputFolder;
+}
+exports.default = getOutputFolder;

package/lib/cli/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildEbook_1 = __importDefault(require("./buildEbook"));
+const build_1 = __importDefault(require("./build"));
+const serve_1 = __importDefault(require("./serve"));
+const parse_1 = __importDefault(require("./parse"));
+const init_1 = __importDefault(require("./init"));
+exports.default = [build_1.default, serve_1.default, parse_1.default, init_1.default, buildEbook_1.default("pdf"), buildEbook_1.default("epub"), buildEbook_1.default("mobi")];

package/lib/cli/init.js

@@ -0,0 +1,17 @@
+"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 options_1 = __importDefault(require("./options"));
+const init_1 = __importDefault(require("../init"));
+exports.default = {
+    name: "init [book]",
+    description: "setup and create files for chapters",
+    options: [options_1.default.log],
+    exec: function (args, kwargs) {
+        const bookRoot = path_1.default.resolve(process.cwd(), args[0] || "./");
+        return init_1.default(bookRoot);
+    },
+};

package/lib/cli/options.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 logger_1 = __importDefault(require("../utils/logger"));
+const logOptions = {
+    name: "log",
+    description: "Minimum log level to display",
+    values: logger_1.default.LEVELS.keySeq()
+        .map((s) => {
+        return s.toLowerCase();
+    })
+        .toJS(),
+    defaults: "info",
+};
+const formatOption = {
+    name: "format",
+    description: "Format to build to",
+    values: ["website", "json", "ebook"],
+    defaults: "website",
+};
+const timingOption = {
+    name: "timing",
+    description: "Print timing debug information",
+    defaults: false,
+};
+const reloadOption = {
+    name: "reload",
+    description: "Prune cache. Remove file cache",
+    defaults: false,
+};
+exports.default = {
+    log: logOptions,
+    format: formatOption,
+    timing: timingOption,
+    reload: reloadOption,
+};

package/lib/cli/parse.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const parse_1 = __importDefault(require("../parse"));
+function printBook(book) {
+    const logger = book.getLogger();
+    const config = book.getConfig();
+    const configFile = config.getFile();
+    const summary = book.getSummary();
+    const summaryFile = summary.getFile();
+    const readme = book.getReadme();
+    const readmeFile = readme.getFile();
+    const glossary = book.getGlossary();
+    const glossaryFile = glossary.getFile();
+    if (configFile.exists()) {
+        logger.info.ln("Configuration file is", configFile.getPath());
+    }
+    if (readmeFile.exists()) {
+        logger.info.ln("Introduction file is", readmeFile.getPath());
+    }
+    if (glossaryFile.exists()) {
+        logger.info.ln("Glossary file is", glossaryFile.getPath());
+    }
+    if (summaryFile.exists()) {
+        logger.info.ln("Table of Contents file is", summaryFile.getPath());
+    }
+}
+function printMultingualBook(book) {
+    const logger = book.getLogger();
+    const languages = book.getLanguages();
+    const books = book.getBooks();
+    logger.info.ln(`${languages.size} languages`);
+    languages.forEach((lang) => {
+        logger.info.ln("Language:", lang.getTitle());
+        printBook(books.get(lang.getID()));
+        logger.info.ln("");
+    });
+}
+exports.default = {
+    name: "parse [book]",
+    description: "parse and print debug information about a book",
+    options: [options_1.default.log],
+    exec: function (args, kwargs) {
+        const book = getBook_1.default(args, kwargs);
+        const logger = book.getLogger();
+        return parse_1.default.parseBook(book).then((resultBook) => {
+            const rootFolder = book.getRoot();
+            const contentFolder = book.getContentRoot();
+            logger.info.ln("Book located in:", rootFolder);
+            if (contentFolder != rootFolder) {
+                logger.info.ln("Content located in:", contentFolder);
+            }
+            if (resultBook.isMultilingual()) {
+                printMultingualBook(resultBook);
+            }
+            else {
+                printBook(resultBook);
+            }
+        });
+    },
+};

package/lib/cli/serve.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiny_lr_1 = __importDefault(require("tiny-lr"));
+const open_1 = __importDefault(require("open"));
+const immutable_1 = __importDefault(require("immutable"));
+const parse_1 = __importDefault(require("../parse"));
+const output_1 = __importDefault(require("../output"));
+const modifiers_1 = __importDefault(require("../modifiers"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const options_1 = __importDefault(require("./options"));
+const getBook_1 = __importDefault(require("./getBook"));
+const getOutputFolder_1 = __importDefault(require("./getOutputFolder"));
+const server_1 = __importDefault(require("./server"));
+const watch_1 = __importDefault(require("./watch"));
+const page_cache_1 = require("../output/page-cache");
+let server, lrServer, lrPath;
+function waitForCtrlC() {
+    const d = promise_1.default.defer();
+    process.on("SIGINT", () => {
+        d.resolve();
+    });
+    return d.promise;
+}
+function startServer(args, kwargs) {
+    const outputFolder = getOutputFolder_1.default(args);
+    const port = kwargs.port;
+    const browser = kwargs["browser"];
+    const book = getBook_1.default(args, kwargs);
+    const hasWatch = kwargs["watch"];
+    const hasOpen = kwargs["open"];
+    const hasLiveReloading = kwargs["live"];
+    const reload = kwargs["reload"];
+    const Generator = output_1.default.getGenerator(kwargs.format);
+    console.log("Starting server ...");
+    let lastOutput = null;
+    return promise_1.default.all([
+        server.start(outputFolder, port),
+        generateBook({
+            book,
+            outputFolder,
+            hasLiveReloading,
+            Generator,
+            reload,
+        }).then((output) => {
+            lastOutput = output;
+            return output;
+        }),
+    ])
+        .then(() => {
+        console.log(`Serving book on http://localhost:${port}`);
+        if (hasOpen) {
+            open_1.default(`http://localhost:${port}`, { app: browser });
+        }
+    })
+        .then(() => {
+        if (!hasWatch) {
+            return waitForCtrlC();
+        }
+        // update book immutably. does not use book again
+        return watch_1.default(book.getRoot(), (error, filepath) => {
+            if (error) {
+                console.error(error);
+                return;
+            }
+            // set livereload path
+            lrPath = filepath;
+            // TODO: use parse extension
+            // Incremental update for pages
+            if (lastOutput && filepath.endsWith(".md")) {
+                console.log("Reload after change in file", 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],
+                            },
+                        });
+                    }
+                });
+            }
+            console.log("Rebuild after change in file", filepath);
+            return generateBook({
+                book,
+                outputFolder,
+                hasLiveReloading,
+                Generator,
+                reload,
+            }).then((output) => {
+                lastOutput = output;
+            });
+        });
+    });
+}
+function generateBook({ book, outputFolder, hasLiveReloading, Generator, reload }) {
+    // Stop server if running
+    if (reload) {
+        book.getLogger().info.ok(`Clear cache`);
+        page_cache_1.clearCache();
+    }
+    return parse_1.default.parseBook(book).then((resultBook) => {
+        if (hasLiveReloading) {
+            // Enable livereload plugin
+            let config = resultBook.getConfig();
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+            config = modifiers_1.default.Config.addPlugin(config, "livereload");
+            resultBook = resultBook.set("config", config);
+        }
+        return output_1.default.generate(Generator, resultBook, {
+            root: outputFolder,
+        });
+    });
+}
+function incrementalBuild({ output, Generator }) {
+    return output_1.default.incrementalBuild(Generator, output);
+}
+exports.default = {
+    name: "serve [book] [output]",
+    description: "serve the book as a website for testing",
+    options: [
+        {
+            name: "port",
+            description: "Port for server to listen on",
+            defaults: 4000,
+        },
+        {
+            name: "lrport",
+            description: "Port for livereload server to listen on",
+            defaults: 35729,
+        },
+        {
+            name: "watch",
+            description: "Enable file watcher and live reloading",
+            defaults: true,
+        },
+        {
+            name: "live",
+            description: "Enable live reloading",
+            defaults: true,
+        },
+        {
+            name: "open",
+            description: "Enable opening book in browser",
+            defaults: false,
+        },
+        {
+            name: "browser",
+            description: "Specify browser for opening book",
+            defaults: "",
+        },
+        options_1.default.log,
+        options_1.default.format,
+        options_1.default.reload,
+    ],
+    exec: function (args, kwargs) {
+        server = new server_1.default();
+        const hasWatch = kwargs["watch"];
+        const hasLiveReloading = kwargs["live"];
+        return promise_1.default()
+            .then(() => {
+            if (!hasWatch || !hasLiveReloading) {
+                return;
+            }
+            lrServer = tiny_lr_1.default({});
+            return promise_1.default.nfcall(lrServer.listen.bind(lrServer), kwargs.lrport).then(() => {
+                console.log("Live reload server started on port:", kwargs.lrport);
+                console.log("Press CTRL+C to quit ...");
+                console.log("");
+            });
+        })
+            .then(() => {
+            return startServer(args, kwargs);
+        });
+    },
+};