honkit 3.6.21

package/lib/parse/parseReadme.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 parseStructureFile_1 = __importDefault(require("./parseStructureFile"));
+const readme_1 = __importDefault(require("../models/readme"));
+const error_1 = __importDefault(require("../utils/error"));
+/**
+ Parse readme from book
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseReadme(book) {
+    const logger = book.getLogger();
+    return parseStructureFile_1.default(book, "readme").spread((file, result) => {
+        if (!file) {
+            throw new error_1.default.FileNotFoundError({ filename: "README" });
+        }
+        logger.debug.ln("readme found at", file.getPath());
+        const readme = readme_1.default.create(file, result);
+        return book.set("readme", readme);
+    });
+}
+exports.default = parseReadme;

package/lib/parse/parseStructureFile.js

@@ -0,0 +1,64 @@
+"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 error_1 = __importDefault(require("../utils/error"));
+const lookupStructureFile_1 = __importDefault(require("./lookupStructureFile"));
+/**
+ Parse a ParsableFile using a specific method
+
+ @param {FS} fs
+ @param {ParsableFile} file
+ @param {string} type
+ @return {Promise<Array<String, List|Map>>}
+ */
+function parseFile(fs, file, type) {
+    const filepath = file.getPath();
+    const parser = file.getParser();
+    if (!parser) {
+        return promise_1.default.reject(error_1.default.FileNotParsableError({
+            filename: filepath,
+        }));
+    }
+    return fs
+        .readAsString(filepath)
+        .then((content) => {
+        if (type === "readme") {
+            return parser.parseReadme(content);
+        }
+        else if (type === "glossary") {
+            return parser.parseGlossary(content);
+        }
+        else if (type === "summary") {
+            return parser.parseSummary(content);
+        }
+        else if (type === "langs") {
+            return parser.parseLanguages(content);
+        }
+        else {
+            throw new Error(`Parsing invalid type "${type}"`);
+        }
+    })
+        .then((result) => {
+        return [file, result];
+    });
+}
+/**
+ Parse a structure file (ex: SUMMARY.md, GLOSSARY.md).
+ It uses the configuration to find the specified file.
+
+ @param {Book} book
+ @param {string} type: one of ["glossary", "readme", "summary"]
+ @return {Promise<List|Map>}
+ */
+function parseStructureFile(book, type) {
+    const fs = book.getContentFS();
+    return lookupStructureFile_1.default(book, type).then((file) => {
+        if (!file)
+            return [undefined, undefined];
+        return parseFile(fs, file, type);
+    });
+}
+exports.default = parseStructureFile;

package/lib/parse/parseSummary.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseStructureFile_1 = __importDefault(require("./parseStructureFile"));
+const summary_1 = __importDefault(require("../models/summary"));
+const modifiers_1 = __importDefault(require("../modifiers"));
+const SummaryModifier = modifiers_1.default.Summary;
+/**
+ Parse summary in a book, the summary can only be parsed
+ if the readme as be detected before.
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseSummary(book) {
+    const readme = book.getReadme();
+    const logger = book.getLogger();
+    const readmeFile = readme.getFile();
+    return parseStructureFile_1.default(book, "summary").spread((file, result) => {
+        let summary;
+        if (!file) {
+            logger.warn.ln("no summary file in this book");
+            summary = new summary_1.default();
+        }
+        else {
+            logger.debug.ln("summary file found at", file.getPath());
+            summary = summary_1.default.createFromParts(file, result.parts);
+        }
+        // Insert readme as first entry if not in SUMMARY.md
+        const readmeArticle = summary.getByPath(readmeFile.getPath());
+        if (readmeFile.exists() && !readmeArticle) {
+            summary = SummaryModifier.unshiftArticle(summary, {
+                title: "Introduction",
+                ref: readmeFile.getPath(),
+            });
+        }
+        // Set new summary
+        return book.setSummary(summary);
+    });
+}
+exports.default = parseSummary;

package/lib/parse/validateConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsonschema_1 = __importDefault(require("jsonschema"));
+const json_schema_defaults_1 = __importDefault(require("json-schema-defaults"));
+const configSchema_1 = __importDefault(require("../constants/configSchema"));
+const error_1 = __importDefault(require("../utils/error"));
+const mergeDefaults_1 = __importDefault(require("../utils/mergeDefaults"));
+/**
+ Validate a book.json content
+ And return a mix with the default value
+
+ @param {Object} bookJson
+ @return {Object}
+ */
+function validateConfig(bookJson) {
+    const v = new jsonschema_1.default.Validator();
+    const result = v.validate(bookJson, configSchema_1.default, {
+        propertyName: "config",
+    });
+    // Throw error
+    if (result.errors.length > 0) {
+        throw new error_1.default.ConfigurationError(new Error(result.errors[0].stack));
+    }
+    // Insert default values
+    const defaults = json_schema_defaults_1.default(configSchema_1.default);
+    return mergeDefaults_1.default(bookJson, defaults);
+}
+exports.default = validateConfig;

package/lib/parse/walkSummary.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 promise_1 = __importDefault(require("../utils/promise"));
+/**
+ Walk over a list of articles
+
+ @param {List<Article>} articles
+ @param {Function(article)}
+ @return {Promise}
+ */
+function walkArticles(articles, fn) {
+    return promise_1.default.forEach(articles, (article) => {
+        return promise_1.default(fn(article)).then(() => {
+            return walkArticles(article.getArticles(), fn);
+        });
+    });
+}
+/**
+ Walk over summary and execute "fn" on each article
+
+ @param {Summary} summary
+ @param {Function(article)}
+ @return {Promise}
+ */
+function walkSummary(summary, fn) {
+    const parts = summary.getParts();
+    return promise_1.default.forEach(parts, (part) => {
+        return walkArticles(part.getArticles(), fn);
+    });
+}
+exports.default = walkSummary;

package/lib/parsers.js

@@ -0,0 +1,60 @@
+"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 immutable_1 = __importDefault(require("immutable"));
+const markdown_legacy_1 = __importDefault(require("@honkit/markdown-legacy"));
+const asciidoc_1 = __importDefault(require("@honkit/asciidoc"));
+const extsMarkdown_1 = __importDefault(require("./constants/extsMarkdown"));
+const extsAsciidoc_1 = __importDefault(require("./constants/extsAsciidoc"));
+const parser_1 = __importDefault(require("./models/parser"));
+// This list is ordered by priority of parsers to use
+const parsers = immutable_1.default.List([
+    parser_1.default.create("markdown", extsMarkdown_1.default, markdown_legacy_1.default),
+    parser_1.default.create("asciidoc", extsAsciidoc_1.default, asciidoc_1.default),
+]);
+/**
+ * Return a specific parser by its name
+ *
+ * @param {string} name
+ * @return {Parser|undefined}
+ */
+function getParser(name) {
+    return parsers.find((parser) => {
+        return parser.getName() === name;
+    });
+}
+/**
+ * Return a specific parser according to an extension
+ *
+ * @param {string} ext
+ * @return {Parser|undefined}
+ */
+function getParserByExt(ext) {
+    return parsers.find((parser) => {
+        return parser.matchExtension(ext);
+    });
+}
+/**
+ * Return parser for a file
+ *
+ * @param {string} ext
+ * @return {Parser|undefined}
+ */
+function getParserForFile(filename) {
+    return getParserByExt(path_1.default.extname(filename));
+}
+// List all parsable extensions
+const extensions = parsers
+    .map((parser) => {
+    return parser.getExtensions();
+})
+    .flatten();
+exports.default = {
+    extensions: extensions,
+    get: getParser,
+    getByExt: getParserByExt,
+    getForFile: getParserForFile,
+};

package/lib/plugins/PluginResolver.js

@@ -0,0 +1,84 @@
+// LICENSE : MIT
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginResolver = void 0;
+const path_1 = __importDefault(require("path"));
+const util = __importStar(require("./package-name-util"));
+const try_resolve_1 = __importDefault(require("try-resolve"));
+const SPECIAL_PACKAGE_NAME = [
+    "highlight",
+    "theme-default", // → @honkit/honkit-plugin-theme-default
+];
+/**
+ * This class aim to resolve honkit's package name and get the module path.
+ *
+ * Define
+ *
+ * - `package` is npm package
+ * - `module` is package's main module
+ *
+ * ## Support
+ *
+ * - honkit-plugin-*
+ * - gitbook-plugin-*
+ */
+class PluginResolver {
+    constructor(config = {}) {
+        /**
+         * @type {string} baseDirectory for resolving
+         */
+        this.baseDirectory = config && config.baseDirectory ? config.baseDirectory : "";
+    }
+    /**
+     * Take package name, and return path to module.
+     * @param {string} packageName
+     * @returns {string} return path to module
+     */
+    resolvePluginPackageName(packageName) {
+        const baseDir = this.baseDirectory;
+        const honkitFullPackageName = util.createFullPackageName("honkit-plugin-", packageName);
+        // honkit > gitbook > normal
+        const gitbookFullPackageName = util.createFullPackageName("gitbook-plugin-", packageName);
+        // special case for backward-compatible
+        // e.g.) load theme-default as @honkit/honkit-plugins-theme-default
+        const honkitScopePackageName = `@honkit/${honkitFullPackageName}`;
+        // In sometimes, HonKit package has not main field - so search package.json
+        const pkgPath = try_resolve_1.default(path_1.default.join(baseDir, honkitFullPackageName, "/package.json")) ||
+            try_resolve_1.default(path_1.default.join(baseDir, gitbookFullPackageName, "/package.json")) ||
+            try_resolve_1.default(path_1.default.join(baseDir, packageName, "/package.json")) ||
+            (SPECIAL_PACKAGE_NAME.includes(packageName) &&
+                try_resolve_1.default(path_1.default.join(baseDir, honkitScopePackageName, "/package.json")));
+        if (!pkgPath) {
+            throw new ReferenceError(`Failed to load HonKit's plugin module: "${packageName}" is not found.
+
+cwd: ${process.cwd()}
+baseDir: ${baseDir}
+
+`);
+        }
+        return pkgPath.substring(0, pkgPath.length - "/package.json".length);
+    }
+}
+exports.PluginResolver = PluginResolver;

package/lib/plugins/__tests__/findInstalled.js

@@ -0,0 +1,25 @@
+"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 immutable_1 = __importDefault(require("immutable"));
+const findInstalled_1 = __importDefault(require("../findInstalled"));
+describe("findInstalled", () => {
+    test.skip("must list default plugins for gitbook directory", () => {
+        // Read gitbook-plugins from package.json
+        const pkg = require(path_1.default.resolve(__dirname, "../../../package.json"));
+        const gitbookPlugins = immutable_1.default.Seq(pkg.dependencies)
+            .filter((v, k) => {
+            return k.indexOf("gitbook-plugin") === 0;
+        })
+            // @ts-expect-error
+            .cacheResult();
+        return findInstalled_1.default(path_1.default.resolve(__dirname, "../../../")).then((plugins) => {
+            expect(plugins.size >= gitbookPlugins.size).toBeTruthy();
+            expect(plugins.has("fontsettings")).toBe(true);
+            expect(plugins.has("search")).toBe(true);
+        });
+    });
+});

package/lib/plugins/__tests__/listDependencies.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 pluginDependency_1 = __importDefault(require("../../models/pluginDependency"));
+const listDependencies_1 = __importDefault(require("../listDependencies"));
+const toNames_1 = __importDefault(require("../toNames"));
+describe("listDependencies", () => {
+    test("must list default", () => {
+        const deps = pluginDependency_1.default.listFromString("ga,great");
+        const plugins = listDependencies_1.default(deps);
+        const names = toNames_1.default(plugins);
+        expect(names).toEqual(["ga", "great", "highlight", "search", "lunr", "fontsettings", "theme-default"]);
+    });
+    test("must list from array with -", () => {
+        const deps = pluginDependency_1.default.listFromString("ga,-great");
+        const plugins = listDependencies_1.default(deps);
+        const names = toNames_1.default(plugins);
+        expect(names).toEqual(["ga", "highlight", "search", "lunr", "fontsettings", "theme-default"]);
+    });
+    test("must remove default plugins using -", () => {
+        const deps = pluginDependency_1.default.listFromString("ga,-search");
+        const plugins = listDependencies_1.default(deps);
+        const names = toNames_1.default(plugins);
+        expect(names).toEqual(["ga", "highlight", "lunr", "fontsettings", "theme-default"]);
+    });
+});

package/lib/plugins/__tests__/sortDependencies.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 pluginDependency_1 = __importDefault(require("../../models/pluginDependency"));
+const sortDependencies_1 = __importDefault(require("../sortDependencies"));
+const toNames_1 = __importDefault(require("../toNames"));
+describe("sortDependencies", () => {
+    test("must load themes after plugins", () => {
+        const allPlugins = pluginDependency_1.default.listFromArray(["hello", "theme-test", "world"]);
+        const sorted = sortDependencies_1.default(allPlugins);
+        const names = toNames_1.default(sorted);
+        expect(names).toEqual(["hello", "world", "theme-test"]);
+    });
+    test("must keep order of themes", () => {
+        const allPlugins = pluginDependency_1.default.listFromArray([
+            "theme-test",
+            "theme-test1",
+            "hello",
+            "theme-test2",
+            "world",
+        ]);
+        const sorted = sortDependencies_1.default(allPlugins);
+        const names = toNames_1.default(sorted);
+        expect(names).toEqual(["hello", "world", "theme-test", "theme-test1", "theme-test2"]);
+    });
+});

package/lib/plugins/__tests__/validatePlugin.js

@@ -0,0 +1,99 @@
+"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"));
+const plugin_1 = __importDefault(require("../../models/plugin"));
+const validatePlugin_1 = __importDefault(require("../validatePlugin"));
+describe("validatePlugin", () => {
+    test("must not validate a not loaded plugin", () => {
+        const plugin = plugin_1.default.createFromString("test");
+        return validatePlugin_1.default(plugin).then(() => {
+            throw new Error("Should not be validate");
+        }, (err) => {
+            return promise_1.default();
+        });
+    });
+    test("alpha plugin can loaded plugin", () => {
+        const testPkgRequireAlphaVersion = {
+            title: "Disqus",
+            name: "gitbook-plugin-disqus",
+            description: "Disqus comments thread in the footer of your pages",
+            icon: "./icon.png",
+            main: "index.js",
+            browser: "./_assets/plugin.js",
+            version: "1.0.1",
+            engines: {
+                gitbook: ">=4.0.0-alpha",
+            },
+            dependencies: {
+                react: "^15.3.2",
+                "react-disqus-thread": "^0.4.0",
+            },
+            devDependencies: {
+                "gitbook-plugin": "^4.0.0-alpha.0",
+                eslint: "3.7.1",
+                "eslint-config-gitbook": "1.4.0",
+            },
+            homepage: "https://github.com/GitbookIO/plugin-disqus",
+            repository: {
+                type: "git",
+                url: "https://github.com/GitbookIO/plugin-disqus.git",
+            },
+            license: "Apache-2.0",
+            bugs: {
+                url: "https://github.com/GitbookIO/plugin-disqus/issues",
+            },
+            keywords: ["gitbook:social"],
+            scripts: {
+                "build-js": "gitbook-plugin build ./src/index.js ./_assets/plugin.js",
+                prepublish: "npm run build-js",
+            },
+            gitbook: {
+                properties: {
+                    shortName: {
+                        type: "string",
+                        title: "Website Shortname",
+                        description: "Unique identifier for your website as registered on Disqus",
+                        required: true,
+                    },
+                    useIdentifier: {
+                        type: "boolean",
+                        title: "Pass page identifier option to Disqus",
+                        default: false,
+                    },
+                },
+                page: {
+                    title: "Disqus configuration for this page",
+                    properties: {
+                        disqus: {
+                            type: "object",
+                            properties: {
+                                enabled: {
+                                    type: "boolean",
+                                    title: "Enable Disqus comments for this page.",
+                                    default: true,
+                                },
+                                identifier: {
+                                    type: "string",
+                                    title: "Identifier for this page.",
+                                    description: "Tells the Disqus service how to identify the current page",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const plugin = new plugin_1.default({
+            name: "test",
+            version: "4.0.0",
+            path: "/",
+            package: immutable_1.default.fromJS(testPkgRequireAlphaVersion),
+            content: immutable_1.default.fromJS({}),
+        });
+        return validatePlugin_1.default(plugin);
+    });
+});