honkit 3.6.21

package/lib/plugins/findInstalled.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const read_installed_1 = __importDefault(require("read-installed"));
+const immutable_1 = __importDefault(require("immutable"));
+const path_1 = __importDefault(require("path"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const fs_1 = __importDefault(require("../utils/fs"));
+const plugin_1 = __importDefault(require("../models/plugin"));
+const pluginPrefix_1 = __importDefault(require("../constants/pluginPrefix"));
+/**
+ * Validate if a package name is a GitBook/HonKit plugin
+ *
+ * @return {boolean}
+ */
+function validateId(name) {
+    return name && name.indexOf(pluginPrefix_1.default) === 0;
+}
+/**
+ * List all packages installed inside a folder
+ *
+ * @param {string} folder
+ * @return {OrderedMap<String:Plugin>}
+ */
+function findInstalled(folder) {
+    const options = {
+        dev: false,
+        log: function () { },
+        depth: 4,
+    };
+    let results = immutable_1.default.OrderedMap();
+    function onPackage(pkg, parent) {
+        if (!pkg.name)
+            return;
+        const name = pkg.name;
+        const version = pkg.version;
+        const pkgPath = pkg.realPath;
+        const depth = pkg.depth;
+        const dependencies = pkg.dependencies;
+        const pluginName = name.slice(pluginPrefix_1.default.length);
+        if (!validateId(name)) {
+            if (parent)
+                return;
+        }
+        else {
+            results = results.set(pluginName, new plugin_1.default({
+                name: pluginName,
+                version: version,
+                path: pkgPath,
+                depth: depth,
+                parent: parent,
+            }));
+        }
+        immutable_1.default.Map(dependencies).forEach((dep) => {
+            onPackage(dep, pluginName);
+        });
+    }
+    // Search for gitbook-plugins in node_modules folder
+    const node_modules = path_1.default.join(folder, "node_modules");
+    // List all folders in node_modules
+    return fs_1.default
+        .readdir(node_modules)
+        .fail(() => {
+        return promise_1.default([]);
+    })
+        .then((modules) => {
+        return promise_1.default.serie(modules, (module) => {
+            // Not a gitbook-plugin
+            if (!validateId(module)) {
+                return promise_1.default();
+            }
+            // Read gitbook-plugin package details
+            const module_folder = path_1.default.join(node_modules, module);
+            return promise_1.default.nfcall(read_installed_1.default, module_folder, options).then((data) => {
+                // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+                onPackage(data);
+            });
+        });
+    })
+        .then(() => {
+        // Return installed plugins
+        return results;
+    });
+}
+exports.default = findInstalled;

package/lib/plugins/index.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 loadForBook_1 = __importDefault(require("./loadForBook"));
+const validateConfig_1 = __importDefault(require("./validateConfig"));
+const listResources_1 = __importDefault(require("./listResources"));
+const listBlocks_1 = __importDefault(require("./listBlocks"));
+const listFilters_1 = __importDefault(require("./listFilters"));
+exports.default = {
+    loadForBook: loadForBook_1.default,
+    validateConfig: validateConfig_1.default,
+    listResources: listResources_1.default,
+    listBlocks: listBlocks_1.default,
+    listFilters: listFilters_1.default,
+};

package/lib/plugins/listBlocks.js

@@ -0,0 +1,19 @@
+"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"));
+/**
+ List blocks from a list of plugins
+
+ @param {OrderedMap<String:Plugin>}
+ @return {Map<String:TemplateBlock>}
+ */
+function listBlocks(plugins) {
+    return plugins.reverse().reduce((result, plugin) => {
+        const blocks = plugin.getBlocks();
+        return result.merge(blocks);
+    }, immutable_1.default.Map());
+}
+exports.default = listBlocks;

package/lib/plugins/listDependencies.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 defaultPlugins_1 = __importDefault(require("../constants/defaultPlugins"));
+const sortDependencies_1 = __importDefault(require("./sortDependencies"));
+/**
+ * List all dependencies for a book, including default plugins.
+ * It returns a concat with default plugins and remove disabled ones.
+ *
+ * @param {List<PluginDependency>} deps
+ * @return {List<PluginDependency>}
+ */
+function listDependencies(deps) {
+    // Extract list of plugins to disable (starting with -)
+    const toRemove = deps
+        .filter((plugin) => {
+        return !plugin.isEnabled();
+    })
+        .map((plugin) => {
+        return plugin.getName();
+    });
+    // Concat with default plugins
+    deps = deps.concat(defaultPlugins_1.default);
+    // Remove plugins
+    deps = deps.filterNot((plugin) => {
+        return toRemove.includes(plugin.getName());
+    });
+    // Sort
+    return sortDependencies_1.default(deps);
+}
+exports.default = listDependencies;

package/lib/plugins/listDepsForBook.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 listDependencies_1 = __importDefault(require("./listDependencies"));
+/**
+ * List all plugin requirements for a book.
+ * It can be different from the final list of plugins,
+ * since plugins can have their own dependencies
+ *
+ * @param {Book}
+ * @return {List<PluginDependency>}
+ */
+function listDepsForBook(book) {
+    const config = book.getConfig();
+    const plugins = config.getPluginDependencies();
+    return listDependencies_1.default(plugins);
+}
+exports.default = listDepsForBook;

package/lib/plugins/listFilters.js

@@ -0,0 +1,18 @@
+"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"));
+/**
+ List filters from a list of plugins
+
+ @param {OrderedMap<String:Plugin>}
+ @return {Map<String:Function>}
+ */
+function listFilters(plugins) {
+    return plugins.reverse().reduce((result, plugin) => {
+        return result.merge(plugin.getFilters());
+    }, immutable_1.default.Map());
+}
+exports.default = listFilters;

package/lib/plugins/listResources.js

@@ -0,0 +1,44 @@
+"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 path_1 = __importDefault(require("path"));
+const location_1 = __importDefault(require("../utils/location"));
+const pluginResources_1 = __importDefault(require("../constants/pluginResources"));
+/**
+ List all resources from a list of plugins
+
+ @param {OrderedMap<String:Plugin>}
+ @param {string} type
+ @return {Map<String:List<{url, path}>}
+ */
+function listResources(plugins, resources) {
+    return plugins.reduce((result, plugin) => {
+        const npmId = plugin.getNpmID();
+        const pluginResources = resources.get(plugin.getName());
+        pluginResources_1.default.forEach((resourceType) => {
+            let assets = pluginResources.get(resourceType);
+            if (!assets)
+                return;
+            let list = result.get(resourceType) || immutable_1.default.List();
+            assets = assets.map((assetFile) => {
+                if (location_1.default.isExternal(assetFile)) {
+                    return {
+                        url: assetFile,
+                    };
+                }
+                else {
+                    return {
+                        path: location_1.default.normalize(path_1.default.join(npmId, assetFile)),
+                    };
+                }
+            });
+            list = list.concat(assets);
+            result = result.set(resourceType, list);
+        });
+        return result;
+    }, immutable_1.default.Map());
+}
+exports.default = listResources;

package/lib/plugins/loadForBook.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 listDepsForBook_1 = __importDefault(require("./listDepsForBook"));
+const loadPlugin_1 = require("./loadPlugin");
+const PluginResolver_1 = require("./PluginResolver");
+/**
+ * Load all plugins in a book
+ *
+ * @param {Book}
+ * @return {Promise<Map<String:Plugin>}
+ */
+function loadForBook(book) {
+    const logger = book.getLogger();
+    // List the dependencies are defined in book.js
+    /**
+     * @type {List<PluginDependency>}
+     */
+    const requirements = listDepsForBook_1.default(book);
+    const pluginResolver = new PluginResolver_1.PluginResolver();
+    const installedPlugins = requirements.map((dep) => {
+        const name = dep.getName();
+        return dep.merge({
+            path: pluginResolver.resolvePluginPackageName(name),
+        });
+    });
+    // Log state
+    logger.info.ln(`${installedPlugins.size} plugins are installed`);
+    if (requirements.size !== installedPlugins.length) {
+        logger.info.ln(`${requirements.size} explicitly listed`);
+    }
+    return Promise.all(installedPlugins.map((plugin) => {
+        return loadPlugin_1.loadPlugin(book, plugin);
+    }));
+}
+exports.default = loadForBook;

package/lib/plugins/loadPlugin.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const resolve_1 = __importDefault(require("resolve"));
+const immutable_1 = __importDefault(require("immutable"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const error_1 = __importDefault(require("../utils/error"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const validatePlugin_1 = __importDefault(require("./validatePlugin"));
+const plugin_1 = __importDefault(require("../models/plugin"));
+// Return true if an error is a "module not found"
+// Wait on https://github.com/substack/node-resolve/pull/81 to be merged
+function isModuleNotFound(err) {
+    return err.code == "MODULE_NOT_FOUND" || err.message.indexOf("Cannot find module") >= 0;
+}
+/**
+ Load a plugin in a book
+
+ @param {Book} book
+ @param {PluginDependency[]} plugin
+ @param {string} pkgPath (optional)
+ @return {Promise<Plugin>}
+ */
+function loadPlugin(book, plugin) {
+    const logger = book.getLogger();
+    const name = plugin.getName();
+    let pkgPath = plugin.getPath();
+    // Try loading plugins from different location
+    let p = promise_1.default()
+        .then(() => {
+        let packageContent;
+        let packageMain;
+        let content;
+        // Locate plugin and load package.json
+        try {
+            const res = resolve_1.default.sync("./package.json", { basedir: pkgPath });
+            pkgPath = path_1.default.dirname(res);
+            packageContent = require(res);
+        }
+        catch (err) {
+            if (!isModuleNotFound(err))
+                throw err;
+            packageContent = undefined;
+            content = undefined;
+            return;
+        }
+        // Locate the main package
+        try {
+            const indexJs = path_1.default.normalize(packageContent.main || "index.js");
+            packageMain = resolve_1.default.sync(`./${indexJs}`, { basedir: pkgPath });
+        }
+        catch (err) {
+            if (!isModuleNotFound(err))
+                throw err;
+            packageMain = undefined;
+        }
+        // Load plugin JS content
+        if (packageMain) {
+            try {
+                content = require(packageMain);
+            }
+            catch (err) {
+                throw new error_1.default.PluginError(err, {
+                    plugin: name,
+                });
+            }
+        }
+        // Update plugin
+        return new plugin_1.default({
+            name: name,
+            version: packageContent.version || "*",
+            path: pkgPath,
+            package: immutable_1.default.fromJS(packageContent),
+            content: immutable_1.default.fromJS(content || {}),
+        });
+    })
+        .then((plugin) => validatePlugin_1.default(plugin))
+        .then((plugin) => {
+        logger.info(`plugin "${plugin.get("name")}" is loaded\n`);
+        return plugin;
+    });
+    p = timing_1.default.measure("plugin.load", p);
+    return p;
+}
+exports.loadPlugin = loadPlugin;

package/lib/plugins/package-name-util.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removePrefixFromPackageName = exports.createFullPackageName = void 0;
+/**
+ * Remove `prefix` from `text`.
+ */
+const removePrefixFromPackageName = (prefixList, packageName) => {
+    for (let i = 0; i < prefixList.length; i++) {
+        const prefix = prefixList[i];
+        // @scope/name -> @scope/name
+        // @scope/textlint-rule-name -> @scope/name
+        if (packageName.charAt(0) === "@") {
+            const [namespace, name] = packageName.split("/");
+            if (name.startsWith(prefix)) {
+                return `${namespace}/${name.slice(prefix.length)}`;
+            }
+        }
+        // name -> name
+        // textlint-rule-name -> name
+        else if (packageName.startsWith(prefix)) {
+            return packageName.slice(prefix.length);
+        }
+    }
+    // No match
+    return packageName;
+};
+exports.removePrefixFromPackageName = removePrefixFromPackageName;
+/**
+ * Create full package name and return
+ * @param {string} prefix
+ * @param {string} name
+ * @returns {string}
+ */
+const createFullPackageName = (prefix, name) => {
+    if (name.charAt(0) === "@") {
+        const scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`);
+        // if @scope/<name> -> @scope/<prefix><name>
+        if (!scopedPackageNameRegex.test(name.split("/")[1])) {
+            /*
+             * for scoped packages, insert the textlint-rule after the first / unless
+             * the path is already @scope/<name> or @scope/textlint-rule-<name>
+             */
+            return name.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}$2`);
+        }
+    }
+    return `${prefix}${name}`;
+};
+exports.createFullPackageName = createFullPackageName;

package/lib/plugins/sortDependencies.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 immutable_1 = __importDefault(require("immutable"));
+const themePrefix_1 = __importDefault(require("../constants/themePrefix"));
+const TYPE_PLUGIN = "plugin";
+const TYPE_THEME = "theme";
+/**
+ * Returns the type of a plugin given its name
+ * @param {Plugin} plugin
+ * @return {string}
+ */
+function pluginType(plugin) {
+    const name = plugin.getName();
+    return name && name.indexOf(themePrefix_1.default) === 0 ? TYPE_THEME : TYPE_PLUGIN;
+}
+/**
+ * Sort the list of dependencies to match list in book.json
+ * The themes should always be loaded after the plugins
+ *
+ * @param {List<PluginDependency>} deps
+ * @return {List<PluginDependency>}
+ */
+function sortDependencies(plugins) {
+    const byTypes = plugins.groupBy(pluginType);
+    return byTypes.get(TYPE_PLUGIN, immutable_1.default.List()).concat(byTypes.get(TYPE_THEME, immutable_1.default.List()));
+}
+exports.default = sortDependencies;