honkit 3.6.21

package/lib/utils/error.js

@@ -0,0 +1,88 @@
+"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 typed_1 = __importDefault(require("error/typed"));
+const wrapped_1 = __importDefault(require("error/wrapped"));
+// Enforce as an Error object, and cleanup message
+function enforce(err) {
+    if (is_1.default.string(err))
+        err = new Error(err);
+    err.message = err.message.replace(/^Error: /, "");
+    return err;
+}
+// Random error wrappers during parsing/generation
+const ParsingError = wrapped_1.default({
+    message: "Parsing Error: {origMessage}",
+    type: "parse",
+});
+const OutputError = wrapped_1.default({
+    message: "Output Error: {origMessage}",
+    type: "generate",
+});
+// A file does not exists
+const FileNotFoundError = typed_1.default({
+    type: "file.not-found",
+    message: 'No "{filename}" file (or is ignored)',
+    filename: null,
+});
+// A file cannot be parsed
+const FileNotParsableError = typed_1.default({
+    type: "file.not-parsable",
+    message: '"{filename}" file cannot be parsed',
+    filename: null,
+});
+// A file is outside the scope
+const FileOutOfScopeError = typed_1.default({
+    type: "file.out-of-scope",
+    message: '"{filename}" not in "{root}"',
+    filename: null,
+    root: null,
+    code: "EACCESS",
+});
+// A file is outside the scope
+const RequireInstallError = typed_1.default({
+    type: "install.required",
+    message: '"{cmd}" is not installed.\n{install}',
+    cmd: null,
+    code: "ENOENT",
+    install: "",
+});
+// Error for nunjucks templates
+const TemplateError = wrapped_1.default({
+    message: 'Error compiling template "{filename}": {origMessage}',
+    type: "template",
+    filename: null,
+});
+// Error for nunjucks templates
+const PluginError = wrapped_1.default({
+    message: 'Error with plugin "{plugin}": {origMessage}',
+    type: "plugin",
+    plugin: null,
+});
+// Error with the book's configuration
+const ConfigurationError = wrapped_1.default({
+    message: "Error with book's configuration: {origMessage}",
+    type: "configuration",
+});
+// Error during ebook generation
+const EbookError = wrapped_1.default({
+    message: "Error during ebook generation: {origMessage}\n{stdout}",
+    type: "ebook",
+    stdout: "",
+});
+exports.default = {
+    enforce: enforce,
+    ParsingError: ParsingError,
+    OutputError: OutputError,
+    RequireInstallError: RequireInstallError,
+    FileNotParsableError: FileNotParsableError,
+    FileNotFoundError: FileNotFoundError,
+    FileOutOfScopeError: FileOutOfScopeError,
+    TemplateError: TemplateError,
+    PluginError: PluginError,
+    ConfigurationError: ConfigurationError,
+    EbookError: EbookError,
+};

package/lib/utils/fs.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const destroy_1 = __importDefault(require("destroy"));
+const tmp_1 = __importDefault(require("tmp"));
+const request_1 = __importDefault(require("request"));
+const path_1 = __importDefault(require("path"));
+const cp_1 = __importDefault(require("cp"));
+const cpr_1 = __importDefault(require("cpr"));
+const promise_1 = __importDefault(require("./promise"));
+// Write a stream to a file
+function writeStream(filename, st) {
+    const d = promise_1.default.defer();
+    const wstream = fs_1.default.createWriteStream(filename);
+    const cleanup = function () {
+        destroy_1.default(wstream);
+        wstream.removeAllListeners();
+    };
+    wstream.on("finish", () => {
+        cleanup();
+        d.resolve();
+    });
+    wstream.on("error", (err) => {
+        cleanup();
+        d.reject(err);
+    });
+    st.on("error", (err) => {
+        cleanup();
+        d.reject(err);
+    });
+    st.pipe(wstream);
+    return d.promise;
+}
+// Return a promise resolved with a boolean
+function fileExists(filename) {
+    const d = promise_1.default.defer();
+    fs_1.default.stat(filename, (error) => {
+        if (error) {
+            d.resolve(false);
+        }
+        else {
+            d.resolve(true);
+        }
+    });
+    return d.promise;
+}
+// Generate temporary file
+function genTmpFile(opts) {
+    return promise_1.default.nfcall(tmp_1.default.file, opts).get(0);
+}
+// Generate temporary dir
+function genTmpDir(opts) {
+    return promise_1.default.nfcall(tmp_1.default.dir, opts).get(0);
+}
+// Download an image
+function download(uri, dest) {
+    return writeStream(dest, request_1.default(uri));
+}
+// Find a filename available in a folder
+function uniqueFilename(base, filename) {
+    const ext = path_1.default.extname(filename);
+    filename = path_1.default.resolve(base, filename);
+    filename = path_1.default.join(path_1.default.dirname(filename), path_1.default.basename(filename, ext));
+    let _filename = filename + ext;
+    let i = 0;
+    while (fs_1.default.existsSync(filename)) {
+        _filename = `${filename}_${i}${ext}`;
+        i = i + 1;
+    }
+    return promise_1.default(path_1.default.relative(base, _filename));
+}
+// Create all required folder to create a file
+function ensureFile(filename) {
+    const base = path_1.default.dirname(filename);
+    return promise_1.default(mkdirp_1.default(base));
+}
+// Remove a folder
+function rmDir(base) {
+    return promise_1.default.nfcall(fs_1.default.rmdir, base, {
+        recursive: true,
+    });
+}
+/**
+ Assert a file, if it doesn't exist, call "generator"
+
+ @param {string} filePath
+ @param {Function} generator
+ @return {Promise}
+ */
+function assertFile(filePath, generator) {
+    return fileExists(filePath).then((exists) => {
+        if (exists)
+            return;
+        return generator();
+    });
+}
+/**
+ Pick a file, returns the absolute path if exists, undefined otherwise
+
+ @param {string} rootFolder
+ @param {string} fileName
+ @return {string}
+ */
+function pickFile(rootFolder, fileName) {
+    const result = path_1.default.join(rootFolder, fileName);
+    if (fs_1.default.existsSync(result)) {
+        return result;
+    }
+    return undefined;
+}
+/**
+ Ensure that a directory exists and is empty
+
+ @param {string} folder
+ @return {Promise}
+ */
+function ensureFolder(rootFolder) {
+    return rmDir(rootFolder)
+        .fail(() => {
+        return promise_1.default();
+    })
+        .then(() => {
+        return promise_1.default(mkdirp_1.default(rootFolder));
+    });
+}
+exports.default = {
+    exists: fileExists,
+    existsSync: fs_1.default.existsSync,
+    mkdirp: mkdirp_1.default,
+    readFile: promise_1.default.nfbind(fs_1.default.readFile),
+    writeFile: (filePath, content) => {
+        const d = promise_1.default.defer();
+        fs_1.default.writeFile(filePath, content, (error) => {
+            if (error) {
+                d.reject(error);
+            }
+            else {
+                d.resolve();
+            }
+        });
+        return d.promise;
+    },
+    assertFile: assertFile,
+    pickFile: pickFile,
+    stat: promise_1.default.nfbind(fs_1.default.lstat),
+    statSync: fs_1.default.lstatSync,
+    readdir: promise_1.default.nfbind(fs_1.default.readdir),
+    writeStream: writeStream,
+    readStream: fs_1.default.createReadStream,
+    copy: promise_1.default.nfbind(cp_1.default),
+    copyDir: promise_1.default.nfbind(cpr_1.default),
+    tmpFile: genTmpFile,
+    tmpDir: genTmpDir,
+    download: download,
+    uniqueFilename: uniqueFilename,
+    ensureFile: ensureFile,
+    ensureFolder: ensureFolder,
+    rmDir: rmDir,
+};

package/lib/utils/genKey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let lastKey = 0;
+/*
+    Generate a random key
+    @return {string}
+*/
+function generateKey() {
+    lastKey += 1;
+    const str = lastKey.toString(16);
+    return "00000".slice(str.length) + str;
+}
+exports.default = generateKey;

package/lib/utils/git.js

@@ -0,0 +1,116 @@
+"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 path_1 = __importDefault(require("path"));
+const crc_1 = __importDefault(require("crc"));
+const urijs_1 = __importDefault(require("urijs"));
+const path_2 = __importDefault(require("./path"));
+const promise_1 = __importDefault(require("./promise"));
+const command_1 = __importDefault(require("./command"));
+const fs_1 = __importDefault(require("./fs"));
+const GIT_PREFIX = "git+";
+function Git() {
+    this.tmpDir;
+    this.cloned = {};
+}
+// Return an unique ID for a combinaison host/ref
+Git.prototype.repoID = function (host, ref) {
+    return crc_1.default.crc32(`${host}#${ref || ""}`).toString(16);
+};
+// Allocate a temporary folder for cloning repos in it
+Git.prototype.allocateDir = function () {
+    const that = this;
+    if (this.tmpDir)
+        return promise_1.default();
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 1 arguments, but got 0.
+    return fs_1.default.tmpDir().then((dir) => {
+        that.tmpDir = dir;
+    });
+};
+// Clone a git repository if non existant
+Git.prototype.clone = function (host, ref) {
+    const that = this;
+    return (this.allocateDir()
+        // Return or clone the git repo
+        .then(() => {
+        // Unique ID for repo/ref combinaison
+        const repoId = that.repoID(host, ref);
+        // Absolute path to the folder
+        const repoPath = path_1.default.join(that.tmpDir, repoId);
+        if (that.cloned[repoId])
+            return repoPath;
+        // Clone repo
+        return (command_1.default
+            // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 1.
+            .exec(`git clone ${host} ${repoPath}`)
+            // Checkout reference if specified
+            .then(() => {
+            that.cloned[repoId] = true;
+            if (!ref)
+                return;
+            return command_1.default.exec(`git checkout ${ref}`, { cwd: repoPath });
+        })
+            .thenResolve(repoPath));
+    }));
+};
+// Get file from a git repo
+Git.prototype.resolve = function (giturl) {
+    // Path to a file in a git repo?
+    if (!Git.isUrl(giturl)) {
+        if (this.resolveRoot(giturl))
+            return promise_1.default(giturl);
+        return promise_1.default(null);
+    }
+    if (is_1.default.string(giturl))
+        giturl = Git.parseUrl(giturl);
+    if (!giturl)
+        return promise_1.default(null);
+    // Clone or get from cache
+    return this.clone(giturl.host, giturl.ref).then((repo) => {
+        return path_1.default.resolve(repo, giturl.filepath);
+    });
+};
+// Return root of git repo from a filepath
+Git.prototype.resolveRoot = function (filepath) {
+    // No git repo cloned, or file is not in a git repository
+    if (!this.tmpDir || !path_2.default.isInRoot(this.tmpDir, filepath))
+        return null;
+    // Extract first directory (is the repo id)
+    const relativeToGit = path_1.default.relative(this.tmpDir, filepath);
+    const repoId = relativeToGit.split(path_1.default.sep)[0];
+    if (!repoId) {
+        return;
+    }
+    // Return an absolute file
+    return path_1.default.resolve(this.tmpDir, repoId);
+};
+// Check if an url is a git dependency url
+Git.isUrl = function (giturl) {
+    return giturl.indexOf(GIT_PREFIX) === 0;
+};
+// Parse and extract infos
+Git.parseUrl = function (giturl) {
+    if (!Git.isUrl(giturl))
+        return null;
+    giturl = giturl.slice(GIT_PREFIX.length);
+    const uri = new urijs_1.default(giturl);
+    const ref = uri.fragment() || null;
+    uri.fragment(null);
+    // Extract file inside the repo (after the .git)
+    const fileParts = uri.path().split(".git");
+    let filepath = fileParts.length > 1 ? fileParts.slice(1).join(".git") : "";
+    if (filepath[0] == "/") {
+        filepath = filepath.slice(1);
+    }
+    // Recreate pathname without the real filename
+    uri.path(`${fileParts[0]}.git`);
+    return {
+        host: uri.toString(),
+        ref: ref,
+        filepath: filepath,
+    };
+};
+exports.default = Git;

package/lib/utils/images.js

@@ -0,0 +1,22 @@
+"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("./promise"));
+const fs_1 = __importDefault(require("./fs"));
+// Converts a inline data: to png file
+function convertInlinePNG(source, dest) {
+    if (!/^data:image\/png/.test(source))
+        return promise_1.default.reject(new Error("Source is not a PNG data-uri"));
+    const base64data = source.split("data:image/png;base64,")[1];
+    const buf = Buffer.from(base64data, "base64");
+    return fs_1.default.writeFile(dest, buf).then(() => {
+        if (fs_1.default.existsSync(dest))
+            return;
+        throw new Error(`Error converting ${source} into ${dest}`);
+    });
+}
+exports.default = {
+    convertInlinePNG: convertInlinePNG,
+};

package/lib/utils/location.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const url_1 = __importDefault(require("url"));
+const path_1 = __importDefault(require("path"));
+// Is the url an external url
+function isExternal(href) {
+    try {
+        return Boolean(url_1.default.parse(href).protocol) && !isDataURI(href);
+    }
+    catch (err) {
+        return false;
+    }
+}
+// Is the url an iniline data-uri
+function isDataURI(href) {
+    try {
+        return Boolean(url_1.default.parse(href).protocol) && url_1.default.parse(href).protocol === "data:";
+    }
+    catch (err) {
+        return false;
+    }
+}
+// Inverse of isExternal
+function isRelative(href) {
+    return !isExternal(href);
+}
+// Return true if the link is an achor
+function isAnchor(href) {
+    try {
+        const parsed = url_1.default.parse(href);
+        return !!(!parsed.protocol && !parsed.path && parsed.hash);
+    }
+    catch (err) {
+        return false;
+    }
+}
+// Normalize a path to be a link
+function normalize(s) {
+    return path_1.default.normalize(s).replace(/\\/g, "/");
+}
+/**
+ * Flatten a path, it removes the leading "/"
+ *
+ * @param {string} href
+ * @return {string}
+ */
+function flatten(href) {
+    href = normalize(href);
+    if (href[0] == "/") {
+        href = normalize(href.slice(1));
+    }
+    return href;
+}
+/**
+ * Convert a relative path to absolute
+ *
+ * @param {string} _href
+ * @param {string} dir: directory parent of the file currently in rendering process
+ * @param {string} outdir: directory parent from the html output
+ * @return {string}
+ */
+function toAbsolute(_href, dir, outdir) {
+    if (isExternal(_href) || isDataURI(_href)) {
+        return _href;
+    }
+    outdir = outdir == undefined ? dir : outdir;
+    _href = normalize(_href);
+    dir = normalize(dir);
+    outdir = normalize(outdir);
+    // Path "_href" inside the base folder
+    let hrefInRoot = normalize(path_1.default.join(dir, _href));
+    if (_href[0] == "/") {
+        hrefInRoot = normalize(_href.slice(1));
+    }
+    // Make it relative to output
+    _href = path_1.default.relative(outdir, hrefInRoot);
+    // Normalize windows paths
+    _href = normalize(_href);
+    return _href;
+}
+/**
+ * Convert an absolute path to a relative path for a specific folder (dir)
+ * ('test/', 'hello.md') -> '../hello.md'
+ *
+ * @param {string} dir: current directory
+ * @param {string} file: absolute path of file
+ * @return {string}
+ */
+function relative(dir, file) {
+    const isDirectory = file.slice(-1) === "/";
+    return normalize(path_1.default.relative(dir, file)) + (isDirectory ? "/" : "");
+}
+/**
+ * Convert an absolute path to a relative path for a specific folder (dir)
+ * ('test/test.md', 'hello.md') -> '../hello.md'
+ *
+ * @param {string} baseFile: current file
+ * @param {string} file: absolute path of file
+ * @return {string}
+ */
+function relativeForFile(baseFile, file) {
+    return relative(path_1.default.dirname(baseFile), file);
+}
+/**
+ * Compare two paths, return true if they are identical
+ * ('README.md', './README.md') -> true
+ *
+ * @param {string} p1: first path
+ * @param {string} p2: second path
+ * @return {boolean}
+ */
+function areIdenticalPaths(p1, p2) {
+    return normalize(p1) === normalize(p2);
+}
+exports.default = {
+    areIdenticalPaths: areIdenticalPaths,
+    isDataURI: isDataURI,
+    isExternal: isExternal,
+    isRelative: isRelative,
+    isAnchor: isAnchor,
+    normalize: normalize,
+    toAbsolute: toAbsolute,
+    relative: relative,
+    relativeForFile: relativeForFile,
+    flatten: flatten,
+};