honkit 3.6.21

package/lib/models/templateEngine.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const immutable_1 = __importDefault(require("immutable"));
+class TemplateEngine extends immutable_1.default.Record({
+    // Map of {TemplateBlock}
+    blocks: immutable_1.default.Map(),
+    // Map of Extension
+    extensions: immutable_1.default.Map(),
+    // Map of filters: {string} name -> {Function} fn
+    filters: immutable_1.default.Map(),
+    // Map of globals: {string} name -> {Mixed}
+    globals: immutable_1.default.Map(),
+    // Context for filters / blocks
+    context: Object(),
+    // Nunjucks loader
+    loader: new nunjucks_1.default.FileSystemLoader("views"),
+}, "TemplateEngine") {
+    getBlocks() {
+        return this.get("blocks");
+    }
+    getGlobals() {
+        return this.get("globals");
+    }
+    getFilters() {
+        return this.get("filters");
+    }
+    getShortcuts() {
+        return this.get("shortcuts");
+    }
+    getLoader() {
+        return this.get("loader");
+    }
+    getContext() {
+        return this.get("context");
+    }
+    getExtensions() {
+        return this.get("extensions");
+    }
+    /**
+     Return a block by its name (or undefined)
+
+     @param {string} name
+     @return {TemplateBlock}
+     */
+    getBlock(name) {
+        const blocks = this.getBlocks();
+        return blocks.find((block) => {
+            return block.getName() === name;
+        });
+    }
+    /**
+     Return a nunjucks environment from this configuration
+     */
+    toNunjucks(blocksOutput) {
+        const loader = this.getLoader();
+        const blocks = this.getBlocks();
+        const filters = this.getFilters();
+        const globals = this.getGlobals();
+        const extensions = this.getExtensions();
+        const context = this.getContext();
+        const env = new nunjucks_1.default.Environment(loader, {
+            // Escaping is done after by the asciidoc/markdown parser
+            autoescape: false,
+            // Syntax
+            tags: {
+                blockStart: "{%",
+                blockEnd: "%}",
+                variableStart: "{{",
+                variableEnd: "}}",
+                commentStart: "{###",
+                commentEnd: "###}",
+            },
+        });
+        // Add filters
+        filters.forEach((filterFn, filterName) => {
+            env.addFilter(filterName, filterFn.bind(context));
+        });
+        // Add blocks
+        blocks.forEach((block) => {
+            const extName = block.getExtensionName();
+            const Ext = block.toNunjucksExt(context, blocksOutput);
+            env.addExtension(extName, new Ext());
+        });
+        // Add globals
+        globals.forEach((globalValue, globalName) => {
+            env.addGlobal(globalName, globalValue);
+        });
+        // Add other extensions
+        extensions.forEach((ext, extName) => {
+            env.addExtension(extName, ext);
+        });
+        return env;
+    }
+    /**
+     Create a template engine
+
+     @param {Object} def
+     @return {TemplateEngine}
+     */
+    static create(def) {
+        return new TemplateEngine({
+            blocks: immutable_1.default.List(def.blocks || []),
+            extensions: immutable_1.default.Map(def.extensions || {}),
+            filters: immutable_1.default.Map(def.filters || {}),
+            globals: immutable_1.default.Map(def.globals || {}),
+            context: def.context,
+            loader: def.loader,
+        });
+    }
+}
+exports.default = TemplateEngine;

package/lib/models/templateOutput.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 immutable_1 = __importDefault(require("immutable"));
+class TemplateOutput extends immutable_1.default.Record({
+    // Text content of the template
+    content: String(),
+    // Map of blocks to replace / post process
+    blocks: immutable_1.default.Map(),
+}, "TemplateOutput") {
+    getContent() {
+        return this.get("content");
+    }
+    getBlocks() {
+        return this.get("blocks");
+    }
+    /**
+     * Update content of this output
+     */
+    setContent(content) {
+        return this.set("content", content);
+    }
+    /**
+     * Create a TemplateOutput from a text content
+     * and an object containing block definition
+     */
+    static create(content, blocks) {
+        return new TemplateOutput({
+            content: content,
+            blocks: immutable_1.default.fromJS(blocks),
+        });
+    }
+}
+exports.default = TemplateOutput;

package/lib/models/templateShortcut.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 immutable_1 = __importDefault(require("immutable"));
+/*
+    A TemplateShortcut is defined in plugin's template blocks
+    to replace content with a templating block using delimiters.
+*/
+class TemplateShortcut extends immutable_1.default.Record({
+    // List of parser names accepting this shortcut
+    parsers: immutable_1.default.Map(),
+    start: String(),
+    end: String(),
+    startTag: String(),
+    endTag: String(),
+}, "TemplateShortcut") {
+    getStart() {
+        return this.get("start");
+    }
+    getEnd() {
+        return this.get("end");
+    }
+    getStartTag() {
+        return this.get("startTag");
+    }
+    getEndTag() {
+        return this.get("endTag");
+    }
+    getParsers() {
+        return this.get("parsers");
+    }
+    /**
+     Test if this shortcut accept a parser
+
+     @param {Parser|String} parser
+     @return {boolean}
+     */
+    acceptParser(parser) {
+        if (typeof parser !== "string") {
+            parser = parser.getName();
+        }
+        const parserNames = this.get("parsers");
+        return parserNames.includes(parser);
+    }
+    /**
+     Create a shortcut for a block
+
+     @param {TemplateBlock} block
+     @param {Map} details
+     @return {TemplateShortcut}
+     */
+    static createForBlock(block, details) {
+        details = immutable_1.default.fromJS(details);
+        return new TemplateShortcut({
+            parsers: details.get("parsers"),
+            start: details.get("start"),
+            end: details.get("end"),
+            startTag: block.getName(),
+            endTag: block.getEndTag(),
+        });
+    }
+}
+exports.default = TemplateShortcut;

package/lib/modifiers/config/__tests__/addPlugin.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 addPlugin_1 = __importDefault(require("../addPlugin"));
+const config_1 = __importDefault(require("../../../models/config"));
+describe("addPlugin", () => {
+    const config = config_1.default.createWithValues({
+        plugins: ["hello", "world", "-disabled"],
+    });
+    test("should have correct state of dependencies", () => {
+        const disabledDep = config.getPluginDependency("disabled");
+        expect(disabledDep).toBeDefined();
+        expect(disabledDep.getVersion()).toEqual("*");
+        expect(disabledDep.isEnabled()).toBeFalsy();
+    });
+    test("should add the plugin to the list", () => {
+        // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+        const newConfig = addPlugin_1.default(config, "test");
+        const testDep = newConfig.getPluginDependency("test");
+        expect(testDep).toBeDefined();
+        expect(testDep.getVersion()).toEqual("*");
+        expect(testDep.isEnabled()).toBeTruthy();
+        const disabledDep = newConfig.getPluginDependency("disabled");
+        expect(disabledDep).toBeDefined();
+        expect(disabledDep.getVersion()).toEqual("*");
+        expect(disabledDep.isEnabled()).toBeFalsy();
+    });
+});

package/lib/modifiers/config/__tests__/removePlugin.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const removePlugin_1 = __importDefault(require("../removePlugin"));
+const config_1 = __importDefault(require("../../../models/config"));
+describe("removePlugin", () => {
+    const config = config_1.default.createWithValues({
+        plugins: ["hello", "world", "-disabled"],
+    });
+    test("should remove the plugin from the list", () => {
+        const newConfig = removePlugin_1.default(config, "hello");
+        const testDep = newConfig.getPluginDependency("hello");
+        expect(testDep).toBeUndefined();
+    });
+    test("should remove the disabled plugin from the list", () => {
+        const newConfig = removePlugin_1.default(config, "disabled");
+        const testDep = newConfig.getPluginDependency("disabled");
+        expect(testDep).toBeUndefined();
+    });
+    test("should disable default plugin", () => {
+        const newConfig = removePlugin_1.default(config, "search");
+        const disabledDep = newConfig.getPluginDependency("search");
+        expect(disabledDep).toBeDefined();
+        expect(disabledDep.getVersion()).toEqual("*");
+        expect(disabledDep.isEnabled()).toBeFalsy();
+    });
+});

package/lib/modifiers/config/__tests__/togglePlugin.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 togglePlugin_1 = __importDefault(require("../togglePlugin"));
+const config_1 = __importDefault(require("../../../models/config"));
+describe("togglePlugin", () => {
+    const config = config_1.default.createWithValues({
+        plugins: ["hello", "world", "-disabled"],
+    });
+    test("should enable plugin", () => {
+        // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+        const newConfig = togglePlugin_1.default(config, "disabled");
+        const testDep = newConfig.getPluginDependency("disabled");
+        expect(testDep).toBeDefined();
+        expect(testDep.getVersion()).toEqual("*");
+        expect(testDep.isEnabled()).toBeTruthy();
+    });
+    test("should disable plugin", () => {
+        // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+        const newConfig = togglePlugin_1.default(config, "world");
+        const testDep = newConfig.getPluginDependency("world");
+        expect(testDep).toBeDefined();
+        expect(testDep.getVersion()).toEqual("*");
+        expect(testDep.isEnabled()).toBeFalsy();
+    });
+});

package/lib/modifiers/config/addPlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluginDependency_1 = __importDefault(require("../../models/pluginDependency"));
+const togglePlugin_1 = __importDefault(require("./togglePlugin"));
+const isDefaultPlugin_1 = __importDefault(require("./isDefaultPlugin"));
+/**
+ * Add a plugin to a book's configuration
+ * @param {Config} config
+ * @param {string} pluginName
+ * @param {string} version (optional)
+ * @return {Config}
+ */
+function addPlugin(config, pluginName, version) {
+    // For default plugin, we only ensure it is enabled
+    if (isDefaultPlugin_1.default(pluginName, version)) {
+        return togglePlugin_1.default(config, pluginName, true);
+    }
+    let deps = config.getPluginDependencies();
+    // @ts-expect-error ts-migrate(2339) FIXME: Property 'create' does not exist on type 'Class'.
+    const dep = pluginDependency_1.default.create(pluginName, version);
+    deps = deps.push(dep);
+    return config.setPluginDependencies(deps);
+}
+exports.default = addPlugin;

package/lib/modifiers/config/editPlugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Edit configuration of a plugin
+ * @param {Config} config
+ * @param {string} plugin
+ * @param {Object} pluginConfig
+ * @return {Config}
+ */
+function editPlugin(config, pluginName, pluginConfig) {
+    return config.setValue(`pluginsConfig.${pluginName}`, pluginConfig);
+}
+exports.default = editPlugin;

package/lib/modifiers/config/getPluginConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Return the configuration for a plugin
+ * @param {Config} config
+ * @param {string} pluginName
+ * @return {Object}
+ */
+function getPluginConfig(config, pluginName) {
+    const pluginsConfig = config.getValues().get("pluginsConfig");
+    if (pluginsConfig === undefined) {
+        return {};
+    }
+    const pluginConf = pluginsConfig.get(pluginName);
+    if (pluginConf === undefined) {
+        return {};
+    }
+    else {
+        return pluginConf.toJS();
+    }
+}
+exports.default = getPluginConfig;

package/lib/modifiers/config/hasPlugin.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Test if a plugin is listed
+ * @param { {List<PluginDependency}} deps
+ * @param {string} plugin
+ * @param {string} version
+ * @return {boolean}
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function hasPlugin(deps, pluginName, version) {
+    return !!deps.find((dep) => {
+        return dep.getName() === pluginName && (!version || dep.getVersion() === version);
+    });
+}
+exports.default = hasPlugin;

package/lib/modifiers/config/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const addPlugin_1 = __importDefault(require("./addPlugin"));
+const removePlugin_1 = __importDefault(require("./removePlugin"));
+const togglePlugin_1 = __importDefault(require("./togglePlugin"));
+const editPlugin_1 = __importDefault(require("./editPlugin"));
+const hasPlugin_1 = __importDefault(require("./hasPlugin"));
+const getPluginConfig_1 = __importDefault(require("./getPluginConfig"));
+const isDefaultPlugin_1 = __importDefault(require("./isDefaultPlugin"));
+exports.default = {
+    addPlugin: addPlugin_1.default,
+    removePlugin: removePlugin_1.default,
+    togglePlugin: togglePlugin_1.default,
+    editPlugin: editPlugin_1.default,
+    hasPlugin: hasPlugin_1.default,
+    getPluginConfig: getPluginConfig_1.default,
+    isDefaultPlugin: isDefaultPlugin_1.default,
+};

package/lib/modifiers/config/isDefaultPlugin.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 defaultPlugins_1 = __importDefault(require("../../constants/defaultPlugins"));
+const hasPlugin_1 = __importDefault(require("./hasPlugin"));
+/**
+ * Test if a plugin is a default one
+ * @param {string} plugin
+ * @param {string} version
+ * @return {boolean}
+ */
+function isDefaultPlugin(pluginName, version) {
+    return hasPlugin_1.default(defaultPlugins_1.default, pluginName, version);
+}
+exports.default = isDefaultPlugin;

package/lib/modifiers/config/removePlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const togglePlugin_1 = __importDefault(require("./togglePlugin"));
+const isDefaultPlugin_1 = __importDefault(require("./isDefaultPlugin"));
+/**
+ * Remove a plugin from a book's configuration
+ * @param {Config} config
+ * @param {string} plugin
+ * @return {Config}
+ */
+function removePlugin(config, pluginName) {
+    let deps = config.getPluginDependencies();
+    // For default plugin, we have to disable it instead of removing from the list
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+    if (isDefaultPlugin_1.default(pluginName)) {
+        return togglePlugin_1.default(config, pluginName, false);
+    }
+    // Remove the dependency from the list
+    deps = deps.filterNot((dep) => {
+        return dep.getName() === pluginName;
+    });
+    return config.setPluginDependencies(deps);
+}
+exports.default = removePlugin;