nope-validator/lib/amd/NopeArray.js

Fast and simple JS validator

define(['exports', './NopePrimitive', './utils'], (function (exports, NopePrimitive, utils) { 'use strict';

  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;

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

}));
//# sourceMappingURL=NopeArray.js.map