bundilio/util.js

const FileSystem = require('fs');
const Path = require('path');
const Util = require('util');

/**
 * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
 *
 * @param {Function} nodeFunction
 * @returns {Function}
 */

function promisify(nodeFunction) {
    return function(...args) {
        return new Promise((resolve, reject) => {
            nodeFunction(...args, function(err, data) {
                if(err) {
                    reject(err);
                } else {
                    resolve(data);
                }
            })
        });
    };
}

const readDirAsync = promisify(FileSystem.readdir);
const readDir = path => readDirAsync(path).then(entries => entries.map(e => Path.join(path, e)));
const fileStat = promisify(FileSystem.stat);
const fileAccess = promisify(FileSystem.access);
const fileExists = file => fileAccess(file, FileSystem.F_OK);
const readFile = promisify(FileSystem.readFile);
const readText = file => readFile(file, {encoding: 'utf8'});

async function filterAsync(array, callback) {
    let results = await Promise.all(array.map(callback));
    return array.filter((_,i) => results[i]);
}

function getFiles(dir) {
    return readDir(dir).then(entries => filterAsync(entries, e => fileStat(e).then(s => s.isFile())));
}


function readDirR(dir) {
    return FileSystem.statSync(dir).isDirectory()
        ? Array.prototype.concat(...FileSystem.readdirSync(dir).map(f => readDirR(Path.join(dir, f))))
        : dir;
}


function copyFile(source, target) {
    return new Promise((resolve,reject) => {
        const rd = FileSystem.createReadStream(source);
        rd.on('error', err => reject(err));
        const wr = FileSystem.createWriteStream(target);
        wr.on('error', err => reject(err));
        wr.on('close', () => resolve());
        rd.pipe(wr);
    });
}


function format(...args) {
    if(args.length === 1 && Object.prototype.toString.call(args[0]) === '[object String]') {
        return args[0];
    }
    return args.map(o => Util.inspect(o, {colors: true, depth: 3, showHidden: false})).join(' ');
}

function log(...args) {
    return console.log(format(...args));
}

function splice(str, index, count, add) {
    // We cannot pass negative indexes dirrectly to the 2nd slicing operation.
    if (index < 0) {
        index = str.length + index;
        if (index < 0) {
            index = 0;
        }
    }

    return str.slice(0, index) + (add || "") + str.slice(index + count);
}

function mapToObject(array, callback) {
    let result = Object.create(null);
    for(let i = 0; i<array.length; ++i) {
        let pair = callback(array[i], i);
        result[pair[0]] = pair[1];
    }
    return result;
}

function isObject(obj) {
    return obj !== null && typeof obj === 'object';
}


function isPlainObject(obj) {
    return isObject(obj) && (
        obj.constructor === Object  // obj = {}
        || obj.constructor === undefined // obj = Object.create(null)
    );
}

function mergeDeep(target, ...sources) {
    if (!sources.length) return target;
    const source = sources.shift();

    if(Array.isArray(target)) {
        if(Array.isArray(source)) {
            target.push(...source);
        } else {
            target.push(source);
        }
    } else if(isPlainObject(target)) {
        if(isPlainObject(source)) {
            for(let key of Object.keys(source)) {
                if(!target[key]) {
                    target[key] = source[key];
                } else {
                    mergeDeep(target[key], source[key]);
                }
            }
        } else {
            throw new Error(`Cannot merge object with non-object`);
        }
    } else {
        target = source;
    }

    return mergeDeep(target, ...sources);
}

function forAll(array, callback) {
    return Promise.all(array.map(callback));
}

Object.assign(exports, {readDir, fileStat, fileAccess, fileExists, promisify, mergeDeep, mapToObject, splice, log, copyFile, getFiles, readDirR, readText, forAll});