ascertain 0.9.23 → 0.11.0

package/README.md

@@ -49,6 +49,7 @@ const data = {
   },
   // fault tolernat type casting
   parsedNumber: as.number('1'),
+  parsedString: as.number('string'),
   parsedBoolean: as.boolean('false'),
   parsedArray: as.array('1,2,3,4,5', ','),
   parsedJSON: as.json('{ "number": 1 }'),
@@ -78,6 +79,7 @@ const schema: Schema<typeof data> = {
     [$values]: Number
   },
   parsedNumber: Number,
+  parsedString: String,
   parsedBoolean: Boolean,
   parsedArray: [String],
   parsedJSON: {

package/build/index.d.ts

@@ -14,11 +14,12 @@ export function and<T = any>(...schema: Schema<T>[]): Schema<any>;
 export function or<T = any>(...schemas: Schema<T>[]): Schema<any>;
 
 interface As {
+    string: (value: string | undefined) => string,
     number: (value: string | undefined) => number,
     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;
+    base64: (value: string | undefined) => string;
 }
 
 export const as: As;

package/build/index.js

@@ -4,78 +4,103 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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, _toPropertyKey(descriptor.key), descriptor); } }
+
+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; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
 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;
@@ -87,15 +112,20 @@ var fromBase64 = typeof Buffer === 'undefined' ? function (value) {
   return Buffer.from(value, 'base64').toString('utf-8');
 };
 var as = {
+  string: function string(value) {
+    return typeof value === "string" ? value : undefined;
+  },
   number: function number(value) {
     var result = parseFloat(value);
-    return Number.isNaN(result) ? undefined : result;
+    return Number.isFinite(result) ? result : undefined;
   },
   boolean: function boolean(value) {
-    return value ? !/^(0|false)$/i.test(value) : !!value;
+    return /^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined;
   },
   array: function array(value, delimiter) {
-    return value ? value.split(delimiter) : undefined;
+    var _value$split;
+
+    return (_value$split = value === null || value === void 0 ? void 0 : value.split(delimiter)) !== null && _value$split !== void 0 ? _value$split : undefined;
   },
   json: function json(value) {
     try {
@@ -113,45 +143,59 @@ var as = {
   }
 };
 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);
     }
@@ -159,6 +203,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));
@@ -173,27 +218,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));
       });
@@ -202,13 +254,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.23",
+  "version": "0.11.0",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
   "main": "build/index.js",
   "types": "build/index.d.ts",