vdev/dist/utils.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Path = require("path");
const fs = require("fs-extra-plus");
const jsyaml = require("js-yaml");
const stripJsonComments = require("strip-json-comments");
/**
 * Split the eventual comman deliminated string as array of trim items.
 * If array just return the array, if null, return empty array
 * @param srcNames comma deliminated, single name, or array of names
 */
function asNames(srcNames) {
    if (srcNames) {
        if (typeof srcNames === 'string') {
            return srcNames.split(',').map((s) => s.trim());
        }
        else {
            return srcNames;
        }
    }
    else {
        return [];
    }
}
exports.asNames = asNames;
// --------- /Lang & Type Utils --------- //
// --------- Utils --------- //
async function yaml(content) {
    const yamlObj = jsyaml.load(content);
    if (!yamlObj) {
        throw new Error(`Could not load yaml`);
    }
    return yamlObj;
}
exports.yaml = yaml;
async function loadYaml(path) {
    const yamlContent = await fs.readFile(path, 'utf8');
    return yaml(yamlContent);
}
exports.loadYaml = loadYaml;
async function readJsonFileWithComments(path) {
    const content = await fs.readFile(path, 'utf8');
    return JSON.parse(stripJsonComments(content));
}
exports.readJsonFileWithComments = readJsonFileWithComments;
async function saferRemove(relPath, log) {
    log = (log !== false); // default is true
    const baseDir = Path.resolve('./');
    const fullPath = Path.resolve(relPath);
    if (!fullPath.startsWith(baseDir)) {
        throw new Error(`Path to be removed does not look safe (nothing done): ${fullPath}`);
    }
    const exists = await fs.pathExists(fullPath);
    if (exists) {
        if (log) {
            console.log(`Deleting: ${relPath}`);
        }
        return fs.remove(fullPath);
    }
    else {
        if (log) {
            console.log(`Already deleted: ${relPath}`);
        }
    }
}
exports.saferRemove = saferRemove;
async function wait(ms) {
    return new Promise(function (resolve) {
        setTimeout(() => { resolve(); }, ms);
    });
}
exports.wait = wait;
// return now in milliseconds using high precision
function now() {
    var hrTime = process.hrtime();
    return hrTime[0] * 1000 + hrTime[1] / 1000000;
}
exports.now = now;
async function printLog(txt, dist, start) {
    const timeStr = Math.round(now() - start) + 'ms';
    let msg = `${txt} - `;
    if (dist) {
        let size = (await fs.stat(dist)).size;
        size = Math.round(size / 1000.0);
        msg += `${dist} - ${timeStr} - ${size} kb`;
    }
    else {
        msg += `${timeStr}`;
    }
    console.log(msg);
}
exports.printLog = printLog;
async function prompt(message) {
    // console.log(`\n${message}: `);
    process.stdout.write(`\n${message}: `);
    return new Promise(function (resolve, reject) {
        process.stdin.resume();
        process.stdin.setEncoding('utf8');
        process.stdin.on('data', function (text) {
            process.stdin.pause();
            resolve(text.trim());
        });
    });
}
exports.prompt = prompt;
/** Attempted to return the obj value given a dottedNamePath (i.e. 'author.name').
 * @returns undefined if nothing found or obj or dottedNamePath is null/undefined. Return obj if dottedNamePath == ''.
 **/
function findVal(obj, dottedNamePath) {
    if (obj == null || dottedNamePath == null) {
        return;
    }
    if (dottedNamePath.trim() === '') {
        return obj;
    }
    let val = obj;
    const names = dottedNamePath.split('.');
    for (let name of names) {
        val = val[name];
        if (val == null) { // if null or undefined, stop and return
            return val;
        }
    }
    return val;
}
exports.findVal = findVal;
// --------- /Utils --------- //