honkit 3.6.21

package/lib/output/ebook/getCoverPath.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 path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("../../utils/fs"));
+/**
+ Resolve path to cover file to use
+
+ @param {Output}
+ @return {string}
+ */
+function getCoverPath(output) {
+    const outputRoot = output.getRoot();
+    const book = output.getBook();
+    const config = book.getConfig();
+    const coverName = config.getValue("cover", "cover.jpg");
+    // Resolve to absolute
+    let cover = fs_1.default.pickFile(outputRoot, coverName);
+    if (cover) {
+        return cover;
+    }
+    // Multilingual? try parent folder
+    if (book.isLanguageBook()) {
+        cover = fs_1.default.pickFile(path_1.default.join(outputRoot, ".."), coverName);
+    }
+    return cover;
+}
+exports.default = getCoverPath;

package/lib/output/ebook/getPDFTemplate.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const juice_1 = __importDefault(require("juice"));
+const website_1 = __importDefault(require("../website"));
+const json_1 = __importDefault(require("../../json"));
+const templating_1 = __importDefault(require("../../templating"));
+const promise_1 = __importDefault(require("../../utils/promise"));
+/**
+ Generate PDF header/footer templates
+
+ @param {Output} output
+ @param {string} type
+ @return {string}
+ */
+function getPDFTemplate(output, type) {
+    const filePath = `pdf_${type}.html`;
+    const outputRoot = output.getRoot();
+    const engine = website_1.default.createTemplateEngine(output, filePath);
+    // Generate context
+    const context = json_1.default.encodeOutput(output);
+    // @ts-expect-error ts-migrate(2339) FIXME: Property 'page' does not exist on type '{ summary:... Remove this comment to see the full error message
+    context.page = {
+        num: "_PAGENUM_",
+        title: "_SECTION_",
+    };
+    // Render the theme
+    return (templating_1.default.renderFile(engine, `ebook/${filePath}`, context)
+        // Inline css and assets
+        .then((tplOut) => {
+        return promise_1.default.nfcall(juice_1.default.juiceResources, tplOut.getContent(), {
+            webResources: {
+                relativeTo: outputRoot,
+            },
+        });
+    }));
+}
+exports.default = getPDFTemplate;

package/lib/output/ebook/index.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 extend_1 = __importDefault(require("extend"));
+const website_1 = __importDefault(require("../website"));
+const options_1 = __importDefault(require("./options"));
+const onPage_1 = __importDefault(require("./onPage"));
+const onFinish_1 = __importDefault(require("./onFinish"));
+exports.default = extend_1.default({}, website_1.default, {
+    name: "ebook",
+    Options: options_1.default,
+    onPage: onPage_1.default,
+    onFinish: onFinish_1.default,
+});

package/lib/output/ebook/onFinish.js

@@ -0,0 +1,84 @@
+"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 website_1 = __importDefault(require("../website"));
+const json_1 = __importDefault(require("../../json"));
+const templating_1 = __importDefault(require("../../templating"));
+const promise_1 = __importDefault(require("../../utils/promise"));
+const error_1 = __importDefault(require("../../utils/error"));
+const command_1 = __importDefault(require("../../utils/command"));
+const writeFile_1 = __importDefault(require("../helper/writeFile"));
+const getConvertOptions_1 = __importDefault(require("./getConvertOptions"));
+const SUMMARY_FILE = "SUMMARY.html";
+/**
+ Write the SUMMARY.html
+
+ @param {Output}
+ @return {Output}
+ */
+function writeSummary(output) {
+    const options = output.getOptions();
+    const prefix = options.get("prefix");
+    const filePath = SUMMARY_FILE;
+    const engine = website_1.default.createTemplateEngine(output, filePath);
+    const context = json_1.default.encodeOutput(output);
+    // Render the theme
+    return (templating_1.default.renderFile(engine, `${prefix}/summary.html`, context)
+        // Write it to the disk
+        .then((tplOut) => {
+        return writeFile_1.default(output, filePath, tplOut.getContent());
+    }));
+}
+/**
+ Generate the ebook file as "index.pdf"
+
+ @param {Output}
+ @return {Output}
+ */
+function runEbookConvert(output) {
+    const logger = output.getLogger();
+    const options = output.getOptions();
+    const format = options.get("format");
+    const outputFolder = output.getRoot();
+    if (!format) {
+        return promise_1.default(output);
+    }
+    return getConvertOptions_1.default(output)
+        .then((options) => {
+        const cmd = [
+            "ebook-convert",
+            path_1.default.resolve(outputFolder, SUMMARY_FILE),
+            path_1.default.resolve(outputFolder, `index.${format}`),
+            command_1.default.optionsToShellArgs(options),
+        ].join(" ");
+        return (command_1.default
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+            .exec(cmd)
+            .progress((data) => {
+            logger.debug(data);
+        })
+            .fail((err) => {
+            if (err.code == 127) {
+                throw error_1.default.RequireInstallError({
+                    cmd: "ebook-convert",
+                    install: "Install it from Calibre: https://calibre-ebook.com",
+                });
+            }
+            throw error_1.default.EbookError(err);
+        }));
+    })
+        .thenResolve(output);
+}
+/**
+ Finish the generation, generates the SUMMARY.html
+
+ @param {Output}
+ @return {Output}
+ */
+function onFinish(output) {
+    return writeSummary(output).then(runEbookConvert);
+}
+exports.default = onFinish;

package/lib/output/ebook/onPage.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const website_1 = __importDefault(require("../website"));
+const modifiers_1 = __importDefault(require("../modifiers"));
+/**
+ Write a page for ebook output
+
+ @param {Output} output
+ @param {Output}
+ */
+function onPage(output, page) {
+    const options = output.getOptions();
+    // Inline assets
+    return (modifiers_1.default.modifyHTML(page, [modifiers_1.default.inlineAssets(options.get("root"), page.getFile().getPath())])
+        // Write page using website generator
+        .then((resultPage) => {
+        return website_1.default.onPage(output, resultPage);
+    }));
+}
+exports.default = onPage;

package/lib/output/ebook/options.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 immutable_1 = __importDefault(require("immutable"));
+const Options = immutable_1.default.Record({
+    // Root folder for the output
+    root: String(),
+    // Prefix for generation
+    prefix: String("ebook"),
+    // Format to generate using ebook-convert
+    format: String(),
+    // Force use of absolute urls ("index.html" instead of "/")
+    directoryIndex: Boolean(false),
+});
+exports.default = Options;

package/lib/output/generateAssets.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 promise_1 = __importDefault(require("../utils/promise"));
+/**
+ Output all assets using a generator
+
+ @param {Generator} generator
+ @param {Output} output
+ @return {Promise<Output>}
+ */
+function generateAssets(generator, output) {
+    const assets = output.getAssets();
+    const logger = output.getLogger();
+    // Is generator ignoring assets?
+    if (!generator.onAsset) {
+        return promise_1.default(output);
+    }
+    return promise_1.default.reduce(assets, (out, assetFile) => {
+        logger.debug.ln(`copy asset "${assetFile}"`);
+        return generator.onAsset(out, assetFile);
+    }, output);
+}
+exports.default = generateAssets;

package/lib/output/generateBook.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementalBuild = exports.generateBook = void 0;
+const path_1 = __importDefault(require("path"));
+const immutable_1 = __importDefault(require("immutable"));
+const output_1 = __importDefault(require("../models/output"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const callHook_1 = __importDefault(require("./callHook"));
+const preparePlugins_1 = __importDefault(require("./preparePlugins"));
+const preparePages_1 = __importDefault(require("./preparePages"));
+const prepareAssets_1 = __importDefault(require("./prepareAssets"));
+const generateAssets_1 = __importDefault(require("./generateAssets"));
+const generatePages_1 = __importDefault(require("./generatePages"));
+/**
+ * Process an output to generate the book
+ *
+ * @param {Generator} generator
+ * @param {Output} output
+ * @return {Promise<Output>}
+ */
+function processOutput(generator, output) {
+    return promise_1.default(output)
+        .then(preparePlugins_1.default)
+        .then(preparePages_1.default)
+        .then(prepareAssets_1.default)
+        .then(callHook_1.default.bind(null, "config", (output) => {
+        const book = output.getBook();
+        const config = book.getConfig();
+        const values = config.getValues();
+        return values.toJS();
+    }, (output, result) => {
+        let book = output.getBook();
+        let config = book.getConfig();
+        config = config.updateValues(result);
+        book = book.set("config", config);
+        return output.set("book", book);
+    }))
+        .then(callHook_1.default.bind(null, "init", (output) => {
+        return {};
+    }, (output) => {
+        return output;
+    }))
+        .then((output) => {
+        if (!generator.onInit) {
+            return output;
+        }
+        return generator.onInit(output);
+    })
+        .then((output) => generateAssets_1.default(generator, output))
+        .then((output) => generatePages_1.default(generator, output))
+        .tap((output) => {
+        const book = output.getBook();
+        if (!book.isMultilingual()) {
+            return;
+        }
+        const logger = book.getLogger();
+        const books = book.getBooks();
+        const outputRoot = output.getRoot();
+        const plugins = output.getPlugins();
+        const state = output.getState();
+        const options = output.getOptions();
+        const bookList = books.map((langBook) => {
+            // Inherits plugins list, options and state
+            const langOptions = options.set("root", path_1.default.join(outputRoot, langBook.getLanguage()));
+            const langOutput = new output_1.default({
+                book: langBook,
+                options: langOptions,
+                state: state,
+                generator: generator.name,
+                plugins: plugins,
+            });
+            logger.info.ln("");
+            logger.info.ln(`generating language "${langBook.getLanguage()}"`);
+            return processOutput(generator, langOutput);
+        });
+        return promise_1.default.all(bookList.toArray()).thenResolve(output);
+    })
+        .then(callHook_1.default.bind(null, "finish:before", (output) => {
+        return {};
+    }, (output) => {
+        return output;
+    }))
+        .then((output) => {
+        if (!generator.onFinish) {
+            return output;
+        }
+        return generator.onFinish(output);
+    })
+        .then(callHook_1.default.bind(null, "finish", (output) => {
+        return {};
+    }, (output) => {
+        return output;
+    }));
+}
+/**
+ * Generate a book using a generator.
+ *
+ * The overall process is:
+ *     1. List and load plugins for this book
+ *     2. Call hook "config"
+ *     3. Call hook "init"
+ *     4. Initialize generator
+ *     5. List all assets and pages
+ *     6. Copy all assets to output
+ *     7. Generate all pages
+ *     8. Call hook "finish:before"
+ *     9. Finish generation
+ *     10. Call hook "finish"
+ *
+ *
+ * @param {Generator} generator
+ * @param {Book} book
+ * @param {Object} [options = {}]
+ * @return {Promise<Output>}
+ */
+function generateBook(generator, book, options = {}) {
+    options = generator.Options(options);
+    const state = generator.State ? new generator.State({}) : immutable_1.default.Map();
+    const start = Date.now();
+    return (promise_1.default(new output_1.default({
+        book: book,
+        options: options,
+        state: state,
+        generator: generator.name,
+    }))
+        // Cleanup output folder
+        .then((output) => {
+        const logger = output.getLogger();
+        const rootFolder = output.getRoot();
+        logger.debug.ln(`cleanup folder "${rootFolder}"`);
+        return fs_1.default.ensureFolder(rootFolder).thenResolve(output);
+    })
+        .then(processOutput.bind(null, generator))
+        // Log duration and end message
+        .then((output) => {
+        const logger = output.getLogger();
+        const end = Date.now();
+        const duration = (end - start) / 1000;
+        logger.info.ok(`generation finished with success in ${duration.toFixed(1)}s !`);
+        return output;
+    }));
+}
+exports.generateBook = generateBook;
+/**
+ * Incremental build for pages
+ * output should be prepared plugins
+ * @param generator
+ * @param output
+ * @returns {Promise<Promise<Output>>}
+ */
+function incrementalBuild(generator, output) {
+    const start = Date.now();
+    return generateAssets_1.default(generator, output)
+        .then((output) => generatePages_1.default(generator, output))
+        .then((output) => {
+        const logger = output.getLogger();
+        const end = Date.now();
+        const duration = (end - start) / 1000;
+        logger.info.ok(`generation finished with success in ${duration.toFixed(1)}s !`);
+        return output;
+    });
+}
+exports.incrementalBuild = incrementalBuild;

package/lib/output/generatePage.js

@@ -0,0 +1,90 @@
+"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 error_1 = __importDefault(require("../utils/error"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const templating_1 = __importDefault(require("../templating"));
+const json_1 = __importDefault(require("../json"));
+const createTemplateEngine_1 = __importDefault(require("./createTemplateEngine"));
+const callPageHook_1 = __importDefault(require("./callPageHook"));
+const page_cache_1 = require("./page-cache");
+const page_1 = __importDefault(require("../models/page"));
+/**
+ * Prepare and generate HTML for a page
+ *
+ * @param {Output} output
+ * @param {Page} page
+ * @return {Promise<Page>}
+ */
+function generatePage(output, page) {
+    const book = output.getBook();
+    const engine = createTemplateEngine_1.default(output);
+    const cache = page_cache_1.getCache();
+    return timing_1.default.measure("page.generate", promise_1.default(page).then((resultPage) => {
+        const file = resultPage.getFile();
+        const filePath = file.getPath();
+        const parser = file.getParser();
+        const context = json_1.default.encodeOutputWithPage(output, resultPage);
+        if (!parser) {
+            return promise_1.default.reject(error_1.default.FileNotParsableError({
+                filename: filePath,
+            }));
+        }
+        // Call hook "page:before"
+        // const start = Date.now();
+        return (callPageHook_1.default("page:before", output, resultPage)
+            // Escape code blocks with raw tags
+            .then((currentPage) => {
+            // console.log("page:before", Date.now() - start);
+            return parser.preparePage(currentPage.getContent());
+        })
+            // Render templating syntax
+            .then(async (content) => {
+            // console.log("page:preparePage", Date.now() - start);
+            const absoluteFilePath = path_1.default.join(book.getContentRoot(), filePath);
+            // if has compiled pages, use it instead of compiling page
+            const pageHash = page.hash();
+            const cachedPage = cache.getKey(pageHash);
+            if (cachedPage) {
+                return page_1.default.fromJSON(output);
+            }
+            try {
+                const output = await templating_1.default.render(engine, absoluteFilePath, content, context);
+                // update cache
+                cache.setKey(pageHash, page_1.default.toJSON(output));
+                return output;
+            }
+            catch (error) {
+                console.error("Template Rendering Error", error);
+                console.log("Template content", content);
+                throw error;
+            }
+        })
+            .then((output) => {
+            // console.log("page:render", Date.now() - start);
+            const content = output.getContent();
+            return parser.parsePage(content).then((result) => {
+                return output.setContent(result.content);
+            });
+        })
+            // Post processing for templating syntax
+            .then((output) => {
+            // console.log("page:parsePage", Date.now() - start);
+            return templating_1.default.postRender(engine, output);
+        })
+            // Return new page
+            .then((content) => {
+            // console.log("page:postRender", Date.now() - start);
+            return resultPage.set("content", content);
+        })
+            // Call final hook
+            .then((currentPage) => {
+            return callPageHook_1.default("page", output, currentPage);
+        }));
+    }));
+}
+exports.default = generatePage;