nope-validator/lib/cjs/NopeArray.js

Fast and simple JS validator

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var NopePrimitive = require('./NopePrimitive.js');
var utils = require('./utils.js');

function ofType(entry, primitive) {
    var done = false;
    return entry.reduce(function (previous, next) {
        if (done) {
            return previous;
        }
        return previous.then(function (error) {
            if (error) {
                done = true;
                return error;
            }
            return primitive.validateAsync(next);
        });
    }, Promise.resolve());
}
var NopeArray = /** @class */ (function () {
    function NopeArray() {
        this._type = 'object';
        this.validationRules = [];
        this.ofShape = null;
    }
    NopeArray.prototype.getType = function () {
        return this._type;
    };
    NopeArray.prototype.required = function (message) {
        if (message === void 0) { message = 'This field is required'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.of = function (primitive, message) {
        if (message === void 0) { message = 'One or more elements are of invalid type'; }
        this.ofShape = primitive;
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.some(function (value) { return primitive.getType() !== typeof value; })) {
                return message;
            }
            var error = entry.find(function (value) { return primitive.validate(value); });
            if (error) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.ofAsync = function (primitive, message) {
        if (message === void 0) { message = 'One or more elements are of invalid type'; }
        this.ofShape = primitive;
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.some(function (value) { return primitive.getType() !== typeof value; })) {
                return message;
            }
            return ofType(entry, primitive).then(function (error) { return (error && message) || undefined; });
        };
        return this.test(rule);
    };
    NopeArray.prototype.minLength = function (length, message) {
        if (message === void 0) { message = 'Input is too short'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.length <= length) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.maxLength = function (length, message) {
        if (message === void 0) { message = 'Input is too long'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.length >= length) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.mustContain = function (value, message) {
        if (message === void 0) { message = 'Input does not contain required value'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.indexOf(value) === -1) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.hasOnly = function (values, message) {
        if (message === void 0) { message = 'Input elements must correspond to value values'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.some(function (value) {
                if (typeof value === 'object') {
                    return !values.find(function (v) { return utils.deepEquals(value, v); });
                }
                return values.indexOf(value) === -1;
            })) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.every = function (callback, message) {
        if (message === void 0) { message = 'Input does not satisfy condition'; }
        var rule = function (entry) {
            if (utils.isNil(entry)) {
                return;
            }
            if (entry.some(function (value) { return !callback(value); })) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.some = function (callback, message) {
        if (message === void 0) { message = 'Input does not satisfy condition'; }
        var rule = function (entry) {
            if (utils.isNil(entry) || entry.length === 0) {
                return;
            }
            if (!entry.some(function (value) { return callback(value); })) {
                return message;
            }
        };
        return this.test(rule);
    };
    NopeArray.prototype.test = function (rule) {
        this.validationRules.push(rule);
        return this;
    };
    NopeArray.prototype.validate = function (entry, context) {
        for (var _i = 0, _a = this.validationRules; _i < _a.length; _i++) {
            var rule = _a[_i];
            var error = rule(entry, context);
            if (error instanceof NopePrimitive.NopePrimitive) {
                return error.validate(entry, context);
            }
            else if (error) {
                return "".concat(error);
            }
        }
    };
    NopeArray.prototype.validateAsync = function (entry, context) {
        return utils.runValidators(this.validationRules, entry, context).then(function (error) {
            if (error instanceof NopePrimitive.NopePrimitive) {
                return error.validateAsync(entry, context);
            }
            else if (error) {
                return error;
            }
        });
    };
    return NopeArray;
}());

exports.NopeArray = NopeArray;
//# sourceMappingURL=NopeArray.js.map