honkit 3.6.21

package/lib/output/website/onPage.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onPage = void 0;
+const path_1 = __importDefault(require("path"));
+const omit_keys_1 = __importDefault(require("omit-keys"));
+const templating_1 = __importDefault(require("../../templating"));
+const plugins_1 = __importDefault(require("../../plugins"));
+const json_1 = __importDefault(require("../../json"));
+const location_1 = __importDefault(require("../../utils/location"));
+const modifiers_1 = __importDefault(require("../modifiers"));
+const writeFile_1 = __importDefault(require("../helper/writeFile"));
+const getModifiers_1 = __importDefault(require("../getModifiers"));
+const createTemplateEngine_1 = __importDefault(require("./createTemplateEngine"));
+const fileToOutput_1 = __importDefault(require("../helper/fileToOutput"));
+/**
+ * Write a page as a json file
+ *
+ * @param {Output} output
+ * @param {Page} page
+ */
+function onPage(output, page) {
+    const options = output.getOptions();
+    const prefix = options.get("prefix");
+    const file = page.getFile();
+    const book = output.getBook();
+    const plugins = output.getPlugins();
+    const state = output.getState();
+    const resources = state.getResources();
+    const engine = createTemplateEngine_1.default(output, page.getPath());
+    // Output file path
+    const filePath = fileToOutput_1.default(output, file.getPath());
+    // Calcul relative path to the root
+    const outputDirName = path_1.default.dirname(filePath);
+    const basePath = location_1.default.normalize(path_1.default.relative(outputDirName, "./"));
+    return modifiers_1.default.modifyHTML(page, getModifiers_1.default(output, page)).then((resultPage) => {
+        // Generate the context
+        const context = json_1.default.encodeOutputWithPage(output, resultPage);
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'plugins' does not exist on type '{ summa... Remove this comment to see the full error message
+        context.plugins = {
+            resources: plugins_1.default.listResources(plugins, resources).toJS(),
+        };
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'template' does not exist on type '{ summ... Remove this comment to see the full error message
+        context.template = {
+            getJSContext: function () {
+                return {
+                    // @ts-expect-error ts-migrate(2339) FIXME: Property 'page' does not exist on type '{ summary:... Remove this comment to see the full error message
+                    page: omit_keys_1.default(context.page, "content"),
+                    config: context.config,
+                    // @ts-expect-error ts-migrate(2339) FIXME: Property 'file' does not exist on type '{ summary:... Remove this comment to see the full error message
+                    file: context.file,
+                    gitbook: context.gitbook,
+                    basePath: basePath,
+                    book: {
+                        language: book.getLanguage(),
+                    },
+                };
+            },
+        };
+        // We should probabbly move it to "template" or a "site" namespace
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'basePath' does not exist on type '{ summ... Remove this comment to see the full error message
+        context.basePath = basePath;
+        // Render the theme
+        return (templating_1.default.renderFile(engine, `${prefix}/page.html`, context)
+            // Write it to the disk
+            .then((tplOut) => {
+            return writeFile_1.default(output, filePath, tplOut.getContent());
+        }));
+    });
+}
+exports.onPage = onPage;

package/lib/output/website/options.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 immutable_1 = __importDefault(require("immutable"));
+const Options = immutable_1.default.Record({
+    // Root folder for the output
+    root: String(),
+    // Prefix for generation
+    prefix: String("website"),
+    // Use directory index url instead of "index.html"
+    directoryIndex: Boolean(true),
+});
+exports.default = Options;

package/lib/output/website/prepareI18n.js

@@ -0,0 +1,28 @@
+"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"));
+const promise_1 = __importDefault(require("../../utils/promise"));
+const listSearchPaths_1 = __importDefault(require("./listSearchPaths"));
+/**
+ * Prepare i18n, load translations from plugins and book
+ *
+ * @param {Output}
+ * @return {Promise<Output>}
+ */
+function prepareI18n(output) {
+    const state = output.getState();
+    const i18n = state.getI18n();
+    const searchPaths = listSearchPaths_1.default(output);
+    searchPaths.reverse().forEach((searchPath) => {
+        const i18nRoot = path_1.default.resolve(searchPath, "_i18n");
+        if (!fs_1.default.existsSync(i18nRoot))
+            return;
+        i18n.load(i18nRoot);
+    });
+    return promise_1.default(output);
+}
+exports.default = prepareI18n;

package/lib/output/website/prepareResources.js

@@ -0,0 +1,49 @@
+"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 immutable_1 = __importDefault(require("immutable"));
+const promise_1 = __importDefault(require("../../utils/promise"));
+const api_1 = __importDefault(require("../../api"));
+/**
+ Prepare plugins resources, add all output corresponding type resources
+
+ @param {Output}
+ @return {Promise<Output>}
+ */
+function prepareResources(output) {
+    const plugins = output.getPlugins();
+    const options = output.getOptions();
+    const type = options.get("prefix");
+    let state = output.getState();
+    const context = api_1.default.encodeGlobal(output);
+    let result = immutable_1.default.Map();
+    return promise_1.default.forEach(plugins, (plugin) => {
+        const pluginResources = plugin.getResources(type);
+        return promise_1.default()
+            .then(() => {
+            // Apply resources if is a function
+            if (is_1.default.fn(pluginResources)) {
+                return promise_1.default().then(pluginResources.bind(context));
+            }
+            else {
+                return pluginResources;
+            }
+        })
+            .then((resources) => {
+            result = result.set(plugin.getName(), immutable_1.default.Map(resources));
+        });
+    }).then(() => {
+        // Set output resources
+        state = state.merge({
+            resources: result,
+        });
+        output = output.merge({
+            state: state,
+        });
+        return output;
+    });
+}
+exports.default = prepareResources;

package/lib/output/website/state.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const i18n_t_1 = __importDefault(require("i18n-t"));
+const immutable_1 = __importDefault(require("immutable"));
+class GeneratorState extends immutable_1.default.Record({
+    i18n: i18n_t_1.default(),
+    // List of plugins' resources
+    resources: immutable_1.default.Map(),
+}) {
+    getI18n() {
+        return this.get("i18n");
+    }
+    getResources() {
+        return this.get("resources");
+    }
+}
+exports.default = GeneratorState;

package/lib/parse/__tests__/listAssets.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 immutable_1 = __importDefault(require("immutable"));
+const mock_1 = __importDefault(require("../../fs/mock"));
+const book_1 = __importDefault(require("../../models/book"));
+const listAssets_1 = __importDefault(require("../listAssets"));
+const parseGlossary_1 = __importDefault(require("../parseGlossary"));
+const parseBook_1 = __importDefault(require("../parseBook"));
+describe("listAssets", () => {
+    test("should not list glossary as asset", () => {
+        const fs = mock_1.default({
+            "GLOSSARY.md": "# Glossary\n\n## Hello\nDescription for hello",
+            "assetFile.js": "",
+            assets: {
+                "file.js": "",
+            },
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseGlossary_1.default(book)
+            .then((resultBook) => {
+            return listAssets_1.default(resultBook, immutable_1.default.Map());
+        })
+            .then((assets) => {
+            expect(assets.size).toBe(2);
+            expect(assets.includes("assetFile.js"));
+            expect(assets.includes("assets/file.js"));
+        });
+    });
+    test("should not list README.md of pages as asset", () => {
+        const fs = mock_1.default({
+            "book.json": JSON.stringify({
+                root: "./test",
+            }),
+            test: {
+                "SUMMARY.md": `# Summary
+
+* [top](README.md)
+* [sub](sub/README-sub.md)
+* [subsub](sub/sub/README-subsub.md)
+
+`,
+                "README.md": "top",
+                "sub/README-sub.md": "in sub",
+                "sub/sub/README-subsub.md": "in sub/sub",
+            },
+        });
+        const pages = new Map()
+            .set("README.md", "top")
+            .set("sub/README-sub.md", "sub")
+            .set("sub/sub/README-subsub.md", "sub/sub");
+        const book = book_1.default.createForFS(fs);
+        return parseBook_1.default(book)
+            .then((resultBook) => {
+            return listAssets_1.default(resultBook, pages);
+        })
+            .then((assets) => {
+            expect(assets.size).toBe(0);
+        });
+    });
+});

package/lib/parse/__tests__/parseBook.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const book_1 = __importDefault(require("../../models/book"));
+const mock_1 = __importDefault(require("../../fs/mock"));
+const parseBook_1 = __importDefault(require("../parseBook"));
+describe("parseBook", () => {
+    test("should parse multilingual book", () => {
+        const fs = mock_1.default({
+            "LANGS.md": "# Languages\n\n* [en](en)\n* [fr](fr)",
+            en: {
+                "README.md": "Hello",
+            },
+            fr: {
+                "README.md": "Bonjour",
+            },
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseBook_1.default(book).then((resultBook) => {
+            const languages = resultBook.getLanguages();
+            const books = resultBook.getBooks();
+            expect(resultBook.isMultilingual()).toBe(true);
+            expect(languages.getList().size).toBe(2);
+            expect(books.size).toBe(2);
+        });
+    });
+    test("should extend configuration for multilingual book", () => {
+        const fs = mock_1.default({
+            "LANGS.md": "# Languages\n\n* [en](en)\n* [fr](fr)",
+            "book.json": '{ "title": "Test", "author": "HonKit" }',
+            en: {
+                "README.md": "Hello",
+                "book.json": '{ "title": "Test EN" }',
+            },
+            fr: {
+                "README.md": "Bonjour",
+            },
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseBook_1.default(book).then((resultBook) => {
+            const books = resultBook.getBooks();
+            expect(resultBook.isMultilingual()).toBe(true);
+            expect(books.size).toBe(2);
+            const en = books.get("en");
+            const fr = books.get("fr");
+            const enConfig = en.getConfig();
+            const frConfig = fr.getConfig();
+            expect(enConfig.getValue("title")).toBe("Test EN");
+            expect(enConfig.getValue("author")).toBe("HonKit");
+            expect(frConfig.getValue("title")).toBe("Test");
+            expect(frConfig.getValue("author")).toBe("HonKit");
+        });
+    });
+    test("should parse book in a directory", () => {
+        const fs = mock_1.default({
+            "book.json": JSON.stringify({
+                root: "./test",
+            }),
+            test: {
+                "README.md": "Hello World",
+                "SUMMARY.md": "# Summary\n\n* [Page](page.md)\n",
+                "page.md": "Page",
+            },
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseBook_1.default(book).then((resultBook) => {
+            const readme = resultBook.getReadme();
+            const summary = resultBook.getSummary();
+            const articles = summary.getArticlesAsList();
+            expect(summary.getFile().exists()).toBe(true);
+            expect(readme.getFile().exists()).toBe(true);
+            expect(articles.size).toBe(2);
+        });
+    });
+});

package/lib/parse/__tests__/parseGlossary.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const book_1 = __importDefault(require("../../models/book"));
+const mock_1 = __importDefault(require("../../fs/mock"));
+const parseGlossary_1 = __importDefault(require("../parseGlossary"));
+describe("parseGlossary", () => {
+    test("should parse glossary if exists", () => {
+        const fs = mock_1.default({
+            "GLOSSARY.md": "# Glossary\n\n## Hello\nDescription for hello",
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseGlossary_1.default(book).then((resultBook) => {
+            const glossary = resultBook.getGlossary();
+            const file = glossary.getFile();
+            const entries = glossary.getEntries();
+            expect(file.exists()).toBeTruthy();
+            expect(entries.size).toBe(1);
+        });
+    });
+    test("should not fail if doesn't exist", () => {
+        const fs = mock_1.default({});
+        const book = book_1.default.createForFS(fs);
+        return parseGlossary_1.default(book).then((resultBook) => {
+            const glossary = resultBook.getGlossary();
+            const file = glossary.getFile();
+            expect(file.exists()).toBeFalsy();
+        });
+    });
+});

package/lib/parse/__tests__/parseIgnore.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 book_1 = __importDefault(require("../../models/book"));
+const mock_1 = __importDefault(require("../../fs/mock"));
+const parseIgnore_1 = __importDefault(require("../parseIgnore"));
+describe("parseIgnore", () => {
+    const fs = mock_1.default({
+        ".ignore": "test-1.js",
+        ".gitignore": "test-2.js\ntest-3.js",
+        ".bookignore": "!test-3.js",
+        "test-1.js": "1",
+        "test-2.js": "2",
+        "test-3.js": "3",
+    });
+    function getBook() {
+        const book = book_1.default.createForFS(fs);
+        return parseIgnore_1.default(book);
+    }
+    test("should load rules from .ignore", () => {
+        return getBook().then((book) => {
+            expect(book.isFileIgnored("test-1.js")).toBeTruthy();
+        });
+    });
+    test("should load rules from .gitignore", () => {
+        return getBook().then((book) => {
+            expect(book.isFileIgnored("test-2.js")).toBeTruthy();
+        });
+    });
+    test("should load rules from .bookignore", () => {
+        return getBook().then((book) => {
+            expect(book.isFileIgnored("test-3.js")).toBeFalsy();
+        });
+    });
+});

package/lib/parse/__tests__/parsePageFromString.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parsePageFromString_1 = __importDefault(require("../parsePageFromString"));
+const page_1 = __importDefault(require("../../models/page"));
+describe("parsePageFromString", () => {
+    const page = new page_1.default();
+    test("should parse YAML frontmatter", () => {
+        const CONTENT = "---\nhello: true\nworld: \"cool\"\n---\n# Hello World\n";
+        const newPage = parsePageFromString_1.default(page, CONTENT);
+        expect(newPage.getDir()).toBe("ltr");
+        expect(newPage.getContent()).toBe("# Hello World\n");
+        const attrs = newPage.getAttributes();
+        expect(attrs.size).toBe(2);
+        expect(attrs.get("hello")).toBe(true);
+        expect(attrs.get("world")).toBe("cool");
+    });
+    test("should parse text direction (english)", () => {
+        const CONTENT = "Hello World";
+        const newPage = parsePageFromString_1.default(page, CONTENT);
+        expect(newPage.getDir()).toBe("ltr");
+        expect(newPage.getContent()).toBe("Hello World");
+        expect(newPage.getAttributes().size).toBe(0);
+    });
+    test("should parse text direction (arab)", () => {
+        const CONTENT = "مرحبا بالعالم";
+        const newPage = parsePageFromString_1.default(page, CONTENT);
+        expect(newPage.getDir()).toBe("rtl");
+        expect(newPage.getContent()).toBe("مرحبا بالعالم");
+        expect(newPage.getAttributes().size).toBe(0);
+    });
+});

package/lib/parse/__tests__/parseReadme.js

@@ -0,0 +1,33 @@
+"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 mock_1 = __importDefault(require("../../fs/mock"));
+const book_1 = __importDefault(require("../../models/book"));
+const parseReadme_1 = __importDefault(require("../parseReadme"));
+describe("parseReadme", () => {
+    test("should parse summary if exists", () => {
+        const fs = mock_1.default({
+            "README.md": "# Hello\n\nAnd here is the description.",
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseReadme_1.default(book).then((resultBook) => {
+            const readme = resultBook.getReadme();
+            const file = readme.getFile();
+            expect(file.exists()).toBeTruthy();
+            expect(readme.getTitle()).toBe("Hello");
+            expect(readme.getDescription()).toBe("And here is the description.");
+        });
+    });
+    test("should fail if doesn't exist", () => {
+        const fs = mock_1.default({});
+        const book = book_1.default.createForFS(fs);
+        return parseReadme_1.default(book).then((resultBook) => {
+            throw new Error("It should have fail");
+        }, () => {
+            return promise_1.default();
+        });
+    });
+});