nope-validator/lib/amd/NopeObject.js

Fast and simple JS validator

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

  var NopeObject = /** @class */ (function () {
      function NopeObject(objectShape) {
          this.validationRules = [];
          this._type = 'object';
          this.objectShape = objectShape || {};
      }
      NopeObject.prototype.getType = function () {
          return this._type;
      };
      NopeObject.prototype.shape = function (shape) {
          Object.assign(this.objectShape, shape);
          return this;
      };
      NopeObject.prototype.extend = function (Base) {
          Object.assign(this.objectShape, Base.objectShape);
          return this;
      };
      NopeObject.prototype.noUnknown = function (message) {
          var _this = this;
          if (message === void 0) { message = 'Input contains invalid keys'; }
          var rule = function (entry) {
              var objectIsDefined = false;
              // eslint-disable-next-line @typescript-eslint/no-unused-vars
              for (var _ in _this.objectShape) {
                  objectIsDefined = true;
                  break;
              }
              if (!objectIsDefined) {
                  throw Error('noUnknown must be used with a schema');
              }
              var unknownKeys = false;
              for (var key in entry) {
                  unknownKeys = unknownKeys || !(key in _this.objectShape);
              }
              if (unknownKeys) {
                  return message;
              }
          };
          this.validationRules.push(rule);
          return this;
      };
      NopeObject.prototype.validate = function (entry, context, options) {
          for (var _i = 0, _a = this.validationRules; _i < _a.length; _i++) {
              var rule = _a[_i];
              var localErrors = rule(entry);
              if (localErrors) {
                  return localErrors;
              }
          }
          var areErrors = false;
          var abortEarly = options === null || options === void 0 ? void 0 : options.abortEarly;
          var errors = {};
          var ctx = Object.assign({ ___parent: context }, entry);
          for (var key in this.objectShape) {
              var validator = this.objectShape[key];
              var error = validator.validate(entry[key], ctx, options);
              if (error) {
                  areErrors = true;
                  errors[key] = error;
                  if (abortEarly) {
                      return errors;
                  }
              }
          }
          if (areErrors) {
              return errors;
          }
          return undefined;
      };
      NopeObject.prototype.validateAsync = function (entry, context, options) {
          var _this = this;
          return utils.runValidators(this.validationRules, entry, context).then(function (localError) {
              if (localError) {
                  return localError;
              }
              var keys = [];
              var results = [];
              var ctx = Object.assign({ ___parent: context }, entry);
              for (var key in _this.objectShape) {
                  var validator = _this.objectShape[key];
                  var error = validator.validateAsync(entry[key], ctx, options);
                  keys.push(key);
                  results.push(error);
              }
              return Promise.all(results).then(function (resolvedErrors) {
                  var errors = {};
                  var areErrors = false;
                  for (var i = 0; i < keys.length; i++) {
                      var error = resolvedErrors[i];
                      if (error) {
                          areErrors = true;
                          errors[keys[i]] = error;
                      }
                  }
                  if (areErrors) {
                      return errors;
                  }
                  return undefined;
              });
          });
      };
      NopeObject.prototype.validateAt = function (path, entry) {
          var _a, _b;
          var arrayPath = utils.pathToArray(path);
          var validator = this.objectShape;
          for (var _i = 0, arrayPath_1 = arrayPath; _i < arrayPath_1.length; _i++) {
              var p = arrayPath_1[_i];
              if (!isNaN(parseInt(p, 10))) {
                  continue;
              }
              if ((_a = validator[p]) === null || _a === void 0 ? void 0 : _a.objectShape) {
                  validator = validator[p].objectShape;
              }
              else if ((_b = validator[p]) === null || _b === void 0 ? void 0 : _b.ofShape) {
                  validator = validator[p].ofShape.objectShape || validator[p].ofShape;
              }
              else {
                  validator = validator[p];
              }
          }
          var parentValue = utils.getFromPath(path, entry, true);
          var value = utils.getFromPath(path, entry);
          return validator.validate(value, parentValue);
      };
      return NopeObject;
  }());

  exports.NopeObject = NopeObject;

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

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