honkit 3.6.21

package/lib/models/parser.js

@@ -0,0 +1,102 @@
+"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 promise_1 = __importDefault(require("../utils/promise"));
+class Parser extends immutable_1.default.Record({
+    name: String(),
+    // List of extensions that can be processed using this parser
+    extensions: immutable_1.default.List(),
+    // Parsing functions
+    readme: Function(),
+    langs: Function(),
+    summary: Function(),
+    glossary: Function(),
+    page: Function(),
+    inline: Function(),
+}) {
+    getName() {
+        return this.get("name");
+    }
+    getExtensions() {
+        return this.get("extensions");
+    }
+    // PARSE
+    parseReadme(content) {
+        const readme = this.get("readme");
+        return promise_1.default(readme(content));
+    }
+    parseSummary(content) {
+        const summary = this.get("summary");
+        return promise_1.default(summary(content));
+    }
+    parseGlossary(content) {
+        const glossary = this.get("glossary");
+        return promise_1.default(glossary(content));
+    }
+    preparePage(content) {
+        const page = this.get("page");
+        if (!page.prepare) {
+            return promise_1.default(content);
+        }
+        return promise_1.default(page.prepare(content));
+    }
+    parsePage(content) {
+        const page = this.get("page");
+        return promise_1.default(page(content));
+    }
+    parseInline(content) {
+        const inline = this.get("inline");
+        return promise_1.default(inline(content));
+    }
+    parseLanguages(content) {
+        const langs = this.get("langs");
+        return promise_1.default(langs(content));
+    }
+    // TO TEXT
+    renderLanguages(content) {
+        const langs = this.get("langs");
+        return promise_1.default(langs.toText(content));
+    }
+    renderSummary(content) {
+        const summary = this.get("summary");
+        return promise_1.default(summary.toText(content));
+    }
+    renderGlossary(content) {
+        const glossary = this.get("glossary");
+        return promise_1.default(glossary.toText(content));
+    }
+    /**
+     Test if this parser matches an extension
+
+     @param {string} ext
+     @return {boolean}
+     */
+    matchExtension(ext) {
+        const exts = this.getExtensions();
+        return exts.includes(ext.toLowerCase());
+    }
+    /**
+     Create a new parser using a module (gitbook-markdown, etc)
+
+     @param {string} name
+     @param {Array<String>} extensions
+     @param {Object} module
+     @return {Parser}
+     */
+    static create(name, extensions, module) {
+        return new Parser({
+            name: name,
+            extensions: immutable_1.default.List(extensions),
+            readme: module.readme,
+            langs: module.langs,
+            summary: module.summary,
+            glossary: module.glossary,
+            page: module.page,
+            inline: module.inline,
+        });
+    }
+}
+exports.default = Parser;

package/lib/models/plugin.js

@@ -0,0 +1,139 @@
+"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 templateBlock_1 = __importDefault(require("./templateBlock"));
+const pluginDependency_1 = __importDefault(require("./pluginDependency"));
+const themePrefix_1 = __importDefault(require("../constants/themePrefix"));
+const DEFAULT_VERSION = "*";
+class Plugin extends immutable_1.default.Record({
+    name: String(),
+    // Requirement version (ex: ">1.0.0")
+    version: String(DEFAULT_VERSION),
+    // Path to load this plugin
+    path: String(),
+    // Depth of this plugin in the dependency tree
+    depth: Number(0),
+    // Parent depending on this plugin
+    parent: String(),
+    // Content of the "package.json"
+    package: immutable_1.default.Map(),
+    // Content of the package itself
+    content: immutable_1.default.Map(),
+}, "Plugin") {
+    getName() {
+        return this.get("name");
+    }
+    getPath() {
+        return this.get("path");
+    }
+    getVersion() {
+        return this.get("version");
+    }
+    getPackage() {
+        return this.get("package");
+    }
+    getContent() {
+        return this.get("content");
+    }
+    getDepth() {
+        return this.get("depth");
+    }
+    getParent() {
+        return this.get("parent");
+    }
+    /**
+     * Return the ID on NPM for this plugin
+     * @return {string}
+     */
+    getNpmID() {
+        return pluginDependency_1.default.nameToNpmID(this.getName());
+    }
+    /**
+     * Check if a plugin is loaded
+     * @return {boolean}
+     */
+    isLoaded() {
+        return Boolean(this.getPackage().size > 0);
+    }
+    /**
+     * Check if a plugin is a theme given its name
+     * @return {boolean}
+     */
+    isTheme() {
+        const name = this.getName();
+        return name && name.indexOf(themePrefix_1.default) === 0;
+    }
+    /**
+     * Return map of hooks
+     */
+    getHooks() {
+        return this.getContent().get("hooks") || immutable_1.default.Map();
+    }
+    /**
+     * Return infos about resources for a specific type
+     * @param {string} type
+     * @return {Map<String:Mixed>}
+     */
+    getResources(type) {
+        if (type != "website" && type != "ebook") {
+            throw new Error(`Invalid assets type ${type}`);
+        }
+        const content = this.getContent();
+        return content.get(type) || (type == "website" ? content.get("book") : null) || immutable_1.default.Map();
+    }
+    /**
+     * Return map of filters
+     * @return {Map<String:Function>}
+     */
+    getFilters() {
+        return this.getContent().get("filters");
+    }
+    /**
+     * Return map of blocks
+     * @return {Map<String:TemplateBlock>}
+     */
+    getBlocks() {
+        let blocks = this.getContent().get("blocks");
+        blocks = blocks || immutable_1.default.Map();
+        return blocks.map((block, blockName) => {
+            return templateBlock_1.default.create(blockName, block);
+        });
+    }
+    /**
+     * Return a specific hook
+     * @param {string} name
+     * @return {Function|undefined}
+     */
+    getHook(name) {
+        return this.getHooks().get(name);
+    }
+    /**
+     * Create a plugin from a string
+     * @param {string}
+     * @return {Plugin}
+     */
+    static createFromString(s) {
+        const parts = s.split("@");
+        const name = parts[0];
+        const version = parts.slice(1).join("@");
+        return new Plugin({
+            name: name,
+            version: version || DEFAULT_VERSION,
+        });
+    }
+    /**
+     * Create a plugin from a dependency
+     * @return {Plugin}
+     */
+    static createFromDep(dep) {
+        return new Plugin({
+            name: dep.getName(),
+            version: dep.getVersion(),
+        });
+    }
+}
+Plugin.nameToNpmID = pluginDependency_1.default.nameToNpmID;
+exports.default = Plugin;

package/lib/models/pluginDependency.js

@@ -0,0 +1,192 @@
+"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 semver_1 = __importDefault(require("semver"));
+const immutable_1 = __importDefault(require("immutable"));
+const pluginPrefix_1 = __importDefault(require("../constants/pluginPrefix"));
+const DEFAULT_VERSION = "*";
+/*
+ * PluginDependency represents the informations about a plugin
+ * stored in config.plugins
+ */
+class PluginDependency extends immutable_1.default.Record({
+    name: String(),
+    // Requirement version (ex: ">1.0.0")
+    version: String(DEFAULT_VERSION),
+    // path to package
+    path: String(),
+    // Is this plugin enabled or disabled?
+    enabled: Boolean(true),
+}, "PluginDependency") {
+    getName() {
+        return this.get("name");
+    }
+    getVersion() {
+        return this.get("version");
+    }
+    getPath() {
+        return this.get("path");
+    }
+    isEnabled() {
+        return this.get("enabled");
+    }
+    /**
+     * Toggle this plugin state
+     * @return {PluginDependency}
+     */
+    toggle(state) {
+        if (state === undefined) {
+            state = !this.isEnabled();
+        }
+        return this.set("enabled", state);
+    }
+    /**
+     * Return NPM ID for the dependency
+     * @return {string}
+     */
+    getNpmID() {
+        return PluginDependency.nameToNpmID(this.getName());
+    }
+    /**
+     * Is the plugin using a git dependency
+     * @return {boolean}
+     */
+    isGitDependency() {
+        return !semver_1.default.validRange(this.getVersion());
+    }
+    /**
+     * Create a plugin with a name and a plugin
+     * @param {string}
+     * @return {Plugin|undefined}
+     */
+    static create(name, version, enabled) {
+        if (is_1.default.undefined(enabled)) {
+            enabled = true;
+        }
+        return new PluginDependency({
+            name: name,
+            version: version || DEFAULT_VERSION,
+            enabled: Boolean(enabled),
+        });
+    }
+    /**
+     * Create a plugin from a string
+     * @param {string} s
+     * @return {Plugin|undefined}
+     */
+    static createFromString(s) {
+        /*
+        HonKit will support following format
+         pkg
+         @scope/pkg
+         -pkg               - Disable package
+         -@scope/pkg        - Disable package
+        */
+        const packagePattern = /^(?<disabled>-)?(?<name>.+)$/;
+        const scopedPackagePattern = /^(?<disabled>-)?(?<name>@[^/]+\/.+)$/;
+        if (packagePattern.test(s) && !s.includes("@")) {
+            const match = s.match(packagePattern);
+            const enabled = !match.groups.disabled;
+            return new PluginDependency({
+                name: match.groups.name,
+                version: DEFAULT_VERSION,
+                enabled: enabled,
+            });
+        }
+        else if (scopedPackagePattern.test(s)) {
+            const match = s.match(scopedPackagePattern);
+            const enabled = !match.groups.disabled;
+            return new PluginDependency({
+                name: match.groups.name,
+                version: DEFAULT_VERSION,
+                enabled: enabled,
+            });
+        }
+        else {
+            /*
+             Deprecated It is only for backward compatible
+             This is original GitBook logic supports
+
+             pkg@version          - backward compatible with GitBook
+             pkg@>=version        - backward compatible with GitBook
+             hello@git+ssh://samy@github.com/GitbookIO/plugin-ga.git
+
+             Note: This logic does not support scoped module
+             */
+            const parts = s.split("@");
+            let name = parts[0];
+            const version = parts.slice(1).join("@");
+            let enabled = true;
+            if (name[0] === "-") {
+                enabled = false;
+                name = name.slice(1);
+            }
+            return new PluginDependency({
+                name: name,
+                version: version || DEFAULT_VERSION,
+                enabled: enabled,
+            });
+        }
+    }
+    /**
+     * Create a PluginDependency from a string
+     * @param {string}
+     * @return {List<PluginDependency>}
+     */
+    static listFromString(s) {
+        const parts = s.split(",");
+        return PluginDependency.listFromArray(parts);
+    }
+    /**
+     * Create a PluginDependency from an array
+     */
+    static listFromArray(arr) {
+        return immutable_1.default.List(arr)
+            .map((entry) => {
+            if (typeof entry === "string") {
+                return PluginDependency.createFromString(entry);
+            }
+            else {
+                return new PluginDependency({
+                    name: entry.get("name"),
+                    version: entry.get("version"),
+                });
+            }
+        })
+            .filter((dep) => {
+            return Boolean(dep.getName());
+        });
+    }
+    /**
+     * Export plugin dependencies as an array
+     * @param {List<PluginDependency>} list
+     * @return {Array<String>}
+     */
+    static listToArray(list) {
+        return list
+            .map((dep) => {
+            let result = "";
+            if (!dep.isEnabled()) {
+                result += "-";
+            }
+            result += dep.getName();
+            if (dep.getVersion() !== DEFAULT_VERSION) {
+                result += `@${dep.getVersion()}`;
+            }
+            return result;
+        })
+            .toJS();
+    }
+    /**
+     * Return NPM id for a plugin name
+     * @param {string}
+     * @return {string}
+     */
+    static nameToNpmID(s) {
+        return pluginPrefix_1.default + s;
+    }
+}
+exports.default = PluginDependency;

package/lib/models/readme.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 immutable_1 = __importDefault(require("immutable"));
+const file_1 = __importDefault(require("./file"));
+class Readme extends immutable_1.default.Record({
+    file: new file_1.default(),
+    title: String(),
+    description: String(),
+}) {
+    getFile() {
+        return this.get("file");
+    }
+    getTitle() {
+        return this.get("title");
+    }
+    getDescription() {
+        return this.get("description");
+    }
+    /**
+     Create a new readme
+
+     @param {File} file
+     @param {Object} def
+     @return {Readme}
+     */
+    static create(file, def) {
+        def = def || {};
+        return new Readme({
+            file: file,
+            title: def.title || "",
+            description: def.description || "",
+        });
+    }
+}
+exports.default = Readme;