ascertain 0.9.8 → 0.10.0

package/README.md

@@ -52,6 +52,7 @@ const data = {
   parsedBoolean: as.boolean('false'),
   parsedArray: as.array('1,2,3,4,5', ','),
   parsedJSON: as.json('{ "number": 1 }'),
+  parsedBase64: as.base64('dGVzdA=='),
 };
 
 // create data schema
@@ -82,6 +83,7 @@ const schema: Schema<typeof data> = {
   parsedJSON: {
     number: 1,
   },
+  parsedBase64: String,
 };
 
 // validate

package/build/index.d.ts

@@ -18,6 +18,7 @@ interface As {
     boolean: (value: string | undefined) => boolean,
     array: (value: string | undefined, delimiter: string | RegExp) => string[];
     json: <T>(value: string | undefined) => T;
+    base64: (value: string | undefined) => string | undefined;
 }
 
 export const as: As;

package/build/index.js

@@ -3,82 +3,114 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.or = exports.optional = exports.default = exports.ascertain = exports.as = exports.and = exports.$values = exports.$keys = void 0;
+exports.toggle = 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;
 var $values = Symbol.for('@@values');
 exports.$values = $values;
+var fromBase64 = typeof Buffer === 'undefined' ? function (value) {
+  return atob(value);
+} : function (value) {
+  return Buffer.from(value, 'base64').toString('utf-8');
+};
 var as = {
   number: function number(value) {
     var result = parseFloat(value);
@@ -96,43 +128,69 @@ var as = {
     } catch (e) {
       return undefined;
     }
+  },
+  base64: function base64(value) {
+    try {
+      return fromBase64(value);
+    } catch (e) {
+      return undefined;
+    }
   }
 };
 exports.as = as;
+
+var toggle = function toggle(key, cases, defaultKey) {
+  var _ref, _cases$key;
+
+  return (_ref = (_cases$key = cases[key]) !== null && _cases$key !== void 0 ? _cases$key : cases[defaultKey]) !== null && _ref !== void 0 ? _ref : undefined;
+};
+
+exports.toggle = toggle;
+
 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);
     }
@@ -140,6 +198,7 @@ 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));
@@ -154,27 +213,34 @@ 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));
       });
@@ -183,13 +249,16 @@ 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.8",
+  "version": "0.10.0",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
   "main": "build/index.js",
   "types": "build/index.d.ts",