honkit 3.6.21

package/lib/utils/logger.js

@@ -0,0 +1,158 @@
+"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 util_1 = __importDefault(require("util"));
+const bash_color_1 = __importDefault(require("bash-color"));
+const immutable_1 = __importDefault(require("immutable"));
+const LEVELS = immutable_1.default.Map({
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    DISABLED: 10,
+});
+const COLORS = immutable_1.default.Map({
+    DEBUG: bash_color_1.default.purple,
+    INFO: bash_color_1.default.cyan,
+    WARN: bash_color_1.default.yellow,
+    ERROR: bash_color_1.default.red,
+});
+function Logger(write, logLevel) {
+    // @ts-expect-error ts-migrate(2350) FIXME: Only a void function can be called with the 'new' ... Remove this comment to see the full error message
+    if (!(this instanceof Logger))
+        return new Logger(write, logLevel);
+    this._write =
+        write ||
+            function (msg) {
+                if (process.stdout) {
+                    process.stdout.write(msg);
+                }
+            };
+    this.lastChar = "\n";
+    this.setLevel(logLevel || "info");
+    // Create easy-to-use method like "logger.debug.ln('....')"
+    LEVELS.forEach(function (level, levelKey) {
+        if (levelKey === "DISABLED") {
+            return;
+        }
+        levelKey = levelKey.toLowerCase();
+        this[levelKey] = this.log.bind(this, level);
+        this[levelKey].ln = this.logLn.bind(this, level);
+        this[levelKey].ok = this.ok.bind(this, level);
+        this[levelKey].fail = this.fail.bind(this, level);
+        this[levelKey].promise = this.promise.bind(this, level);
+    }, this);
+}
+/**
+ Change minimum level
+
+ @param {string} logLevel
+ */
+Logger.prototype.setLevel = function (logLevel) {
+    if (is_1.default.string(logLevel)) {
+        logLevel = logLevel.toUpperCase();
+        logLevel = LEVELS.get(logLevel);
+    }
+    this.logLevel = logLevel;
+};
+/**
+ Return minimum logging level
+
+ @return {number}
+ */
+Logger.prototype.getLevel = function (logLevel) {
+    return this.logLevel;
+};
+/**
+ Print a simple string
+
+ @param {string}
+ */
+Logger.prototype.write = function (msg) {
+    msg = msg.toString();
+    this.lastChar = msg[msg.length - 1];
+    return this._write(msg);
+};
+/**
+ Format a string using the first argument as a printf-like format.
+ */
+Logger.prototype.format = function () {
+    return util_1.default.format.apply(util_1.default, arguments);
+};
+/**
+ Print a line
+
+ @param {string}
+ */
+Logger.prototype.writeLn = function (msg) {
+    return this.write(`${msg || ""}\n`);
+};
+/**
+ Log/Print a message if level is allowed
+
+ @param {number} level
+ */
+Logger.prototype.log = function (level) {
+    if (level < this.logLevel)
+        return;
+    const levelKey = LEVELS.findKey((v) => {
+        return v === level;
+    });
+    const args = Array.prototype.slice.apply(arguments, [1]);
+    let msg = this.format.apply(this, args);
+    if (this.lastChar == "\n") {
+        msg = `${COLORS.get(levelKey)(`${levelKey.toLowerCase()}:`)} ${msg}`;
+    }
+    return this.write(msg);
+};
+/**
+ Log/Print a line if level is allowed
+ */
+Logger.prototype.logLn = function () {
+    if (this.lastChar != "\n")
+        this.write("\n");
+    const args = Array.prototype.slice.apply(arguments);
+    args.push("\n");
+    return this.log.apply(this, args);
+};
+/**
+ Log a confirmation [OK]
+ */
+Logger.prototype.ok = function (level) {
+    const args = Array.prototype.slice.apply(arguments, [1]);
+    const msg = this.format.apply(this, args);
+    if (arguments.length > 1) {
+        this.logLn(level, bash_color_1.default.green(">> ") + msg.trim().replace(/\n/g, bash_color_1.default.green("\n>> ")));
+    }
+    else {
+        this.log(level, bash_color_1.default.green("OK"), "\n");
+    }
+};
+/**
+ Log a "FAIL"
+ */
+Logger.prototype.fail = function (level) {
+    return this.log(level, `${bash_color_1.default.red("ERROR")}\n`);
+};
+/**
+ Log state of a promise
+
+ @param {number} level
+ @param {Promise}
+ @return {Promise}
+ */
+Logger.prototype.promise = function (level, p) {
+    const that = this;
+    return p.then((st) => {
+        that.ok(level);
+        return st;
+    }, (err) => {
+        that.fail(level);
+        throw err;
+    });
+};
+Logger.LEVELS = LEVELS;
+exports.default = Logger;

package/lib/utils/mergeDefaults.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"));
+/**
+ * Merge
+ * @param  {Object|Map} obj
+ * @param  {Object|Map} src
+ * @return {Object}
+ */
+function mergeDefaults(obj, src) {
+    const objValue = immutable_1.default.fromJS(obj);
+    const srcValue = immutable_1.default.fromJS(src);
+    return srcValue.mergeDeep(objValue).toJS();
+}
+exports.default = mergeDefaults;

package/lib/utils/path.js

@@ -0,0 +1,62 @@
+"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 error_1 = __importDefault(require("./error"));
+// Normalize a filename
+function normalizePath(filename) {
+    return path_1.default.normalize(filename);
+}
+// Return true if file path is inside a folder
+function isInRoot(root, filename) {
+    root = path_1.default.normalize(root);
+    filename = path_1.default.normalize(filename);
+    if (root === ".") {
+        return true;
+    }
+    if (root[root.length - 1] != path_1.default.sep) {
+        root = root + path_1.default.sep;
+    }
+    return filename.substr(0, root.length) === root;
+}
+// Resolve paths in a specific folder
+// Throw error if file is outside this folder
+function resolveInRoot(root) {
+    const args = Array.prototype.slice.call(arguments, 1);
+    const input = args.reduce((current, p) => {
+        // Handle path relative to book root ("/README.md")
+        if (p[0] == "/" || p[0] == "\\")
+            return p.slice(1);
+        return current ? path_1.default.join(current, p) : path_1.default.normalize(p);
+    }, "");
+    const result = path_1.default.resolve(root, input);
+    if (!isInRoot(root, result)) {
+        throw new error_1.default.FileOutOfScopeError({
+            filename: result,
+            root: root,
+        });
+    }
+    return result;
+}
+// Chnage extension of a file
+function setExtension(filename, ext) {
+    return path_1.default.join(path_1.default.dirname(filename), path_1.default.basename(filename, path_1.default.extname(filename)) + ext);
+}
+/*
+    Return true if a filename is relative.
+
+    @param {string}
+    @return {boolean}
+*/
+function isPureRelative(filename) {
+    return filename.indexOf("./") === 0 || filename.indexOf("../") === 0;
+}
+exports.default = {
+    isInRoot: isInRoot,
+    resolveInRoot: resolveInRoot,
+    normalize: normalizePath,
+    setExtension: setExtension,
+    isPureRelative: isPureRelative,
+};

package/lib/utils/promise.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.some = exports.serie = exports.map = exports.reduce = exports.forEach = void 0;
+const q_1 = __importDefault(require("q"));
+const immutable_1 = __importDefault(require("immutable"));
+// Debugging for long stack traces
+if (process.env.DEBUG || process.env.CI) {
+    q_1.default.longStackSupport = true;
+}
+/**
+ * Reduce an array to a promise
+ *
+ * @param {Array|List} arr
+ * @param {Function(value, element, index)} iter
+ * @param {Array|List} base
+ * @return {Promise<Mixed>}
+ */
+function reduce(arr, iter, base) {
+    arr = immutable_1.default.Iterable.isIterable(arr) ? arr : immutable_1.default.List(arr);
+    return arr.reduce((prev, elem, key) => {
+        return prev.then((val) => {
+            return iter(val, elem, key);
+        });
+    }, q_1.default(base));
+}
+exports.reduce = reduce;
+/**
+ * Iterate over an array using an async iter
+ *
+ * @param {Array|List} arr
+ * @param {Function(value, element, index)}
+ * @return {Promise}
+ */
+function forEach(arr, iter) {
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 3 arguments, but got 2.
+    return reduce(arr, (val, el, key) => {
+        return iter(el, key);
+    });
+}
+exports.forEach = forEach;
+/**
+ * Transform an array
+ *
+ * @param {Array|List} arr
+ * @param {Function(value, element, index)}
+ * @return {Promise}
+ */
+function serie(arr, iter, base) {
+    return reduce(arr, (before, item, key) => {
+        return q_1.default(iter(item, key)).then((r) => {
+            before.push(r);
+            return before;
+        });
+    }, []);
+}
+exports.serie = serie;
+/**
+ * Iter over an array and return first result (not null)
+ *
+ * @param {Array|List} arr
+ * @param {Function(element, index)}
+ * @return {Promise<Mixed>}
+ */
+function some(arr, iter) {
+    arr = immutable_1.default.List(arr);
+    return arr.reduce((prev, elem, i) => {
+        return prev.then((val) => {
+            if (val)
+                return val;
+            return iter(elem, i);
+        });
+    }, q_1.default());
+}
+exports.some = some;
+/**
+ * Map an array using an async (promised) iterator
+ *
+ * @param {Array|List} arr
+ * @param {Function(element, index)}
+ * @return {Promise<List>}
+ */
+function mapAsList(arr, iter) {
+    return reduce(arr, (prev, entry, i) => {
+        return q_1.default(iter(entry, i)).then((out) => {
+            prev.push(out);
+            return prev;
+        });
+    }, []);
+}
+/**
+ * Map an array or map
+ *
+ * @param {Array|List|Map|OrderedMap} arr
+ * @param {Function(element, key)}
+ * @return {Promise<List|Map|OrderedMap>}
+ */
+function map(arr, iter) {
+    if (immutable_1.default.Map.isMap(arr)) {
+        let type = "Map";
+        if (immutable_1.default.OrderedMap.isOrderedMap(arr)) {
+            type = "OrderedMap";
+        }
+        return mapAsList(arr, (value, key) => {
+            return q_1.default(iter(value, key)).then((result) => {
+                return [key, result];
+            });
+        }).then((result) => {
+            return immutable_1.default[type](result);
+        });
+    }
+    else {
+        return mapAsList(arr, iter).then((result) => {
+            return immutable_1.default.List(result);
+        });
+    }
+}
+exports.map = map;
+/**
+ * Wrap a function in a promise
+ *
+ * @param {Function} func
+ * @return {Funciton}
+ */
+function wrap(func) {
+    return function () {
+        const args = Array.prototype.slice.call(arguments, 0);
+        return q_1.default().then(() => {
+            return func.apply(null, args);
+        });
+    };
+}
+exports.wrap = wrap;
+q_1.default.forEach = forEach;
+q_1.default.reduce = reduce;
+q_1.default.map = map;
+q_1.default.serie = serie;
+q_1.default.some = some;
+q_1.default.wrap = wrap;
+exports.default = q_1.default;

package/lib/utils/reducedObject.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 immutable_1 = __importDefault(require("immutable"));
+/**
+ *  Reduce the difference between a map and its default version
+ *  @param {Map} defaultVersion
+ *  @param {Map} currentVersion
+ *  @return {Map} The properties of currentVersion that differs from defaultVersion
+ */
+function reducedObject(defaultVersion, currentVersion) {
+    if (defaultVersion === undefined) {
+        return currentVersion;
+    }
+    return currentVersion.reduce((result, value, key) => {
+        const defaultValue = defaultVersion.get(key);
+        if (immutable_1.default.Map.isMap(value)) {
+            const diffs = reducedObject(defaultValue, value);
+            if (diffs.size > 0) {
+                return result.set(key, diffs);
+            }
+        }
+        if (immutable_1.default.is(defaultValue, value)) {
+            return result;
+        }
+        return result.set(key, value);
+    }, immutable_1.default.Map());
+}
+exports.default = reducedObject;

package/lib/utils/timing.js

@@ -0,0 +1,90 @@
+"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 is_1 = __importDefault(require("is"));
+const timers = {};
+const startDate = Date.now();
+/**
+ Mesure an operation
+
+ @parqm {string} type
+ @param {Promise} p
+ @return {Promise}
+ */
+function measure(type, p) {
+    timers[type] = timers[type] || {
+        type: type,
+        count: 0,
+        total: 0,
+        min: undefined,
+        max: 0,
+    };
+    const start = Date.now();
+    return p.fin(() => {
+        const end = Date.now();
+        const duration = end - start;
+        timers[type].count++;
+        timers[type].total += duration;
+        if (is_1.default.undefined(timers[type].min)) {
+            timers[type].min = duration;
+        }
+        else {
+            timers[type].min = Math.min(timers[type].min, duration);
+        }
+        timers[type].max = Math.max(timers[type].max, duration);
+    });
+}
+/**
+ Return a milliseconds number as a second string
+
+ @param {number} ms
+ @return {string}
+ */
+function time(ms) {
+    if (ms < 1000) {
+        return `${ms.toFixed(0)}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+/**
+ Dump all timers to a logger
+
+ @param {Logger} logger
+ */
+function dump(logger) {
+    const prefix = "    > ";
+    let measured = 0;
+    const totalDuration = Date.now() - startDate;
+    // Enable debug logging
+    const logLevel = logger.getLevel();
+    logger.setLevel("debug");
+    immutable_1.default.Map(timers)
+        .valueSeq()
+        .sortBy((timer) => {
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'total' does not exist on type 'unknown'.
+        measured += timer.total;
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'total' does not exist on type 'unknown'.
+        return timer.total;
+    })
+        .forEach((timer) => {
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'total' does not exist on type 'unknown'.
+        const percent = (timer.total * 100) / totalDuration;
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'type' does not exist on type 'unknown'.
+        logger.debug.ln(`${percent.toFixed(1)}% of time spent in "${timer.type}" (${timer.count} times) :`);
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'total' does not exist on type 'unknown'.
+        logger.debug.ln(`${prefix}Total: ${time(timer.total)} | Average: ${time(timer.total / timer.count)}`);
+        // @ts-expect-error ts-migrate(2339) FIXME: Property 'min' does not exist on type 'unknown'.
+        logger.debug.ln(`${prefix}Min: ${time(timer.min)} | Max: ${time(timer.max)}`);
+        logger.debug.ln("---------------------------");
+    });
+    logger.debug.ln(`${time(totalDuration - measured)} spent in non-mesured sections`);
+    // Rollback to previous level
+    logger.setLevel(logLevel);
+}
+exports.default = {
+    measure: measure,
+    dump: dump,
+};