lazy-ass/dist/index.js

Lazy assertions without performance penalty

"use strict";
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.lazyAssync = exports.lazyAss = void 0;
function isArrayLike(a) {
    return a && typeof a.length === 'number';
}
function toStringArray(arr) {
    return ('array with ' +
        arr.length +
        ' items.\n[' +
        arr.map(toString).join(',') +
        ']\n');
}
function isPrimitive(arg) {
    return (typeof arg === 'string' ||
        typeof arg === 'number' ||
        typeof arg === 'boolean');
}
function isError(e) {
    return e instanceof Error;
}
/*
  custom JSON.stringify replacer to make sure we do not
  hide properties that have value "undefined"
  var o = {
    foo: 42,
    bar: undefined
  }

  standard JSON.stringify returns
    '{"foo": 42}'
  this replacer returns
    '{"foo": 42, "bar": null}'
*/
function replacer(key, value) {
    if (value === undefined) {
        return null;
    }
    return value;
}
function toString(arg, k) {
    if (arg === null) {
        return 'null';
    }
    if (arg === undefined) {
        return 'undefined';
    }
    if (isPrimitive(arg)) {
        return JSON.stringify(arg);
    }
    if (arg instanceof Error) {
        return arg.name + ' ' + arg.message;
    }
    if (Array.isArray(arg)) {
        return toStringArray(arg);
    }
    if (isArrayLike(arg)) {
        return toStringArray(Array.prototype.slice.call(arg, 0));
    }
    var argString;
    try {
        argString = JSON.stringify(arg, replacer, 2);
    }
    catch (err) {
        argString =
            '{ cannot stringify arg ' + k + ', it has type "' + typeof arg + '"';
        if (typeof arg === 'object') {
            argString += ' with keys ' + Object.keys(arg).join(', ') + ' }';
        }
        else {
            argString += ' }';
        }
    }
    return argString;
}
function endsWithNewLine(s) {
    return /\n$/.test(s);
}
function formMessage(args) {
    var msg = args.reduce(function (total, arg, k) {
        if (k && !endsWithNewLine(total)) {
            total += ' ';
        }
        if (typeof arg === 'string') {
            return total + arg;
        }
        if (typeof arg === 'function') {
            var fnResult;
            try {
                fnResult = arg();
            }
            catch (err) {
                // ignore the error
                fnResult = '[function ' + arg.name + ' threw error!]';
            }
            return total + fnResult;
        }
        var argString = toString(arg, k);
        return total + argString;
    }, '');
    return msg;
}
function lazyAssLogic(condition) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    if (isError(condition)) {
        return condition;
    }
    var fn = typeof condition === 'function' ? condition : null;
    if (fn) {
        condition = fn();
    }
    if (!condition) {
        // var args = [].slice.call(arguments, 1);
        if (fn) {
            args.unshift(fn.toString());
        }
        return new Error(formMessage(args));
    }
}
exports.lazyAss = (function lazyAss(condition) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    var err = lazyAssLogic.apply(void 0, __spreadArray([condition], args, false));
    if (err) {
        throw err;
    }
});
var lazyAssync = function lazyAssync(condition) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    var err = lazyAssLogic.apply(void 0, __spreadArray([condition], args, false));
    if (err) {
        setTimeout(function () {
            throw err;
        }, 0);
    }
};
exports.lazyAssync = lazyAssync;
exports.lazyAss.async = exports.lazyAssync;
exports.default = exports.lazyAss;