insync/build/util.js

Higher-order functions and common patterns for asynchronous code. Node specific port of async.

'use strict';

// Load modules

// Declare internals

var internals = {};

internals.consoleFn = function (name) {

    return function (fn) {
        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
        }

        fn.apply(null, args.concat([function (err) {

            if (err) {
                return console.error(err);
            }

            var consoleFn = console[name];

            if (typeof consoleFn === 'function') {
                for (var i = 1, il = arguments.length; i < il; ++i) {
                    consoleFn(arguments[i]);
                }
            }
        }]));
    };
};

module.exports.noop = function noop() {};

module.exports.onlyOnce = function (fn) {

    var called = false;

    return function () {

        if (called) {
            throw new Error('Callback was already called.');
        }

        called = true;

        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
        }

        fn.apply(global, args);
    };
};

module.exports.ensureAsync = function (fn) {

    return function () {
        for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            args[_key3] = arguments[_key3];
        }

        var callback = args.pop();

        if (typeof callback !== 'function') {
            throw new TypeError('Last argument must be a function.');
        }

        var sync = true;

        args.push(function () {
            for (var _len4 = arguments.length, innerArgs = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
                innerArgs[_key4] = arguments[_key4];
            }

            if (sync) {
                setImmediate(function () {

                    callback.apply(null, innerArgs);
                });
            } else {
                callback.apply(null, innerArgs);
            }
        });

        fn.apply(this, args);
        sync = false;
    };
};

module.exports.isArrayLike = function (arr) {

    return Array.isArray(arr) || typeof arr === 'object' && arr !== null && arr.length >= 0 && arr.length >>> 0 === arr.length;
};

module.exports.memoize = function (fn, hasher) {

    hasher = hasher || function (item) {

        return item;
    };

    var memo = {};
    var queues = {};

    var memoized = function memoized() {
        for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
            args[_key5] = arguments[_key5];
        }

        var callback = args.pop();
        var key = hasher.apply(null, args);

        if (key in memo) {
            process.nextTick(function () {

                callback.apply(null, memo[key]);
            });
        } else if (key in queues) {
            queues[key].push(callback);
        } else {
            queues[key] = [callback];
            fn.apply(null, args.concat([function () {
                for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
                    args[_key6] = arguments[_key6];
                }

                memo[key] = args;
                var q = queues[key];
                delete queues[key];

                for (var i = 0, l = q.length; i < l; i++) {
                    q[i].apply(null, args);
                }
            }]));
        }
    };

    memoized.memo = memo;
    memoized.unmemoized = fn;

    return memoized;
};

module.exports.unmemoize = function (fn) {

    return function () {
        for (var _len7 = arguments.length, args = Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
            args[_key7] = arguments[_key7];
        }

        return (fn.unmemoized || fn).apply(null, args);
    };
};

module.exports.log = internals.consoleFn('log');

module.exports.dir = internals.consoleFn('dir');