ascertain 0.9.7 → 0.9.8

package/build/index.js

@@ -4,103 +4,76 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.or = exports.optional = exports.default = exports.ascertain = exports.as = exports.and = exports.$values = exports.$keys = void 0;
-
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
-
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
 var AssertError = /*#__PURE__*/function () {
   function AssertError(value, expected, path) {
     var subject = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'value';
-
     _classCallCheck(this, AssertError);
-
     this.value = value;
     this.expected = expected;
     this.path = path;
     this.subject = subject;
   }
-
   _createClass(AssertError, [{
     key: "toString",
     value: function toString() {
       return "Invalid ".concat(this.subject, " ").concat(JSON.stringify(this.value), " specified by path ").concat(this.path, " expected ").concat(this.expected);
     }
   }]);
-
   return AssertError;
 }();
-
 function findFirstError(array, map) {
   for (var i = 0; i < array.length; i++) {
     var error = map(array[i], i);
-
     if (error) {
       return error;
     }
   }
-
   return false;
 }
-
 function findNotError(array, map) {
   var errors = [];
-
   for (var i = 0; i < array.length; i++) {
     var error = map(array[i], i);
-
     if (!error) {
       return false;
     } else {
       errors.push(error);
     }
   }
-
   return errors.reduce(function (result, error) {
     return new AssertError(result.value, [result.expected, error.expected].join(' or '), result.path, result.string);
   });
 }
-
 function Optional(schema) {
   this.schema = schema;
 }
-
 function And(schema) {
   this.schema = schema;
 }
-
 function Or(schema) {
   this.schema = schema;
 }
-
 var optional = function optional(schema) {
   return new Optional(schema);
 };
-
 exports.optional = optional;
-
 var and = function and() {
   for (var _len = arguments.length, schema = new Array(_len), _key = 0; _key < _len; _key++) {
     schema[_key] = arguments[_key];
   }
-
   return new And(schema);
 };
-
 exports.and = and;
-
 var or = function or() {
   for (var _len2 = arguments.length, schema = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
     schema[_key2] = arguments[_key2];
   }
-
   return new Or(schema);
 };
-
 exports.or = or;
 var $keys = Symbol.for('@@keys');
 exports.$keys = $keys;
@@ -126,51 +99,40 @@ var as = {
   }
 };
 exports.as = as;
-
 function certain(target, schema, path, optional) {
   if (schema === null || typeof schema === 'undefined') {
     return new AssertError(schema, 'any value', path, 'schema value');
   }
-
   if (schema instanceof Optional) {
     return certain(target, schema.schema, path, true);
   }
-
   var isValue = target !== null && typeof target !== 'undefined';
-
   if (!isValue && optional) {
     return;
   }
-
   if (schema instanceof Or) {
     if (!schema.schema.length) {
       return new AssertError(target, 'values', path, 'OR schema');
     }
-
     return findNotError(schema.schema, function (schema) {
       return certain(target, schema, path);
     });
   }
-
   if (schema instanceof And) {
     if (!schema.schema.length) {
       return new AssertError(target, 'values', path, 'AND schema');
     }
-
     return findFirstError(schema.schema, function (schema) {
       return certain(target, schema, path);
     });
   }
-
   if (typeof schema === 'function') {
     if (!isValue) {
       return new AssertError(target, schema.name, path);
     }
-
     if (_typeof(target) === 'object' && !(target instanceof schema)) {
       return new AssertError(target, schema.name, path);
     }
-
     if (_typeof(target) !== 'object' && target.constructor !== schema) {
       return new AssertError(target, schema.name, path);
     }
@@ -178,7 +140,6 @@ function certain(target, schema, path, optional) {
     if (!Array.isArray(target)) {
       return new AssertError(target, schema.constructor.name, path);
     }
-
     return findFirstError(target, function (value, idx) {
       return findNotError(schema, function (itemSchemaType) {
         return certain(value, itemSchemaType, "".concat(path, ".").concat(idx));
@@ -193,34 +154,27 @@ function certain(target, schema, path, optional) {
       if (_typeof(target) !== 'object') {
         return new AssertError(target, schema.constructor.name, path);
       }
-
       if (target === null) {
         return new AssertError(target, 'an object', path);
       }
-
       if ($keys in schema) {
         var targetKeys = Object.keys(target);
         var assertError = findFirstError(targetKeys, function (targetKey) {
           return certain(targetKey, schema[$keys], "".concat(path, ".").concat(targetKey));
         });
-
         if (assertError) {
           return assertError;
         }
       }
-
       if ($values in schema) {
         var _targetKeys = Object.keys(target);
-
         var _assertError = findFirstError(_targetKeys, function (targetKey) {
           return certain(target[targetKey], schema[$values], "".concat(path, ".").concat(targetKey));
         });
-
         if (_assertError) {
           return _assertError;
         }
       }
-
       return findFirstError(Object.keys(schema), function (key) {
         return certain(target[key], schema[key], "".concat(path, ".").concat(key));
       });
@@ -229,16 +183,13 @@ function certain(target, schema, path, optional) {
     return new AssertError(target, schema, path);
   }
 }
-
 var ascertain = function ascertain(schema, data) {
   var rootName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '[root]';
   var result = certain(data, schema, rootName);
-
   if (result instanceof AssertError) {
     throw new TypeError(result.toString());
   }
 };
-
 exports.ascertain = ascertain;
 var _default = ascertain;
 exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ascertain",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
   "main": "build/index.js",
   "types": "build/index.d.ts",