ascertain 0.12.33 → 0.13.1

package/.swcrc

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/swcrc",
+  "module": {
+    "type": "commonjs",
+    "strict": true,
+    "strictMode": true
+  },
+  "jsc": {
+    "target": "es2022",
+    "parser": {
+      "syntax": "ecmascript"
+    },
+    "externalHelpers": false,
+    "keepClassNames": true
+  }
+}

package/build/index.d.ts

@@ -16,6 +16,8 @@ export function or<T = any>(...schemas: Schema<T>[]): Schema<any>;
 interface As {
     string: (value: string | undefined) => string,
     number: (value: string | undefined) => number,
+    date: (value: string | undefined) => Date,
+    time: (value: string | undefined) => number,
     boolean: (value: string | undefined) => boolean,
     array: (value: string | undefined, delimiter: string | RegExp) => string[];
     json: <T>(value: string | undefined) => T;

package/build/index.js

@@ -1,209 +1,221 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.toggle = exports.or = exports.optional = exports.default = exports.ascertain = exports.as = exports.and = exports.$values = exports.$keys = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-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 _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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-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);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    $keys: function() {
+        return $keys;
+    },
+    $values: function() {
+        return $values;
+    },
+    and: function() {
+        return and;
+    },
+    as: function() {
+        return as;
+    },
+    ascertain: function() {
+        return ascertain;
+    },
+    default: function() {
+        return _default;
+    },
+    fromBase64: function() {
+        return fromBase64;
+    },
+    optional: function() {
+        return optional;
+    },
+    or: function() {
+        return or;
+    }
+});
+let AssertError = class AssertError {
+    constructor(value, expected, path, subject = 'value'){
+        this.value = value;
+        this.expected = expected;
+        this.path = path;
+        this.subject = subject;
     }
-  }]);
-  return AssertError;
-}();
+    toString() {
+        return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;
+    }
+};
 function findFirstError(array, map) {
-  for (var i = 0; i < array.length; i++) {
-    var error = map(array[i], i);
-    if (error) {
-      return error;
+    for(let i = 0; i < array.length; i++){
+        const error = map(array[i], i);
+        if (error) {
+            return error;
+        }
     }
-  }
-  return false;
+    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);
+    const errors = [];
+    for(let i = 0; i < array.length; i++){
+        const 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);
-  });
+    return errors.reduce((result, error)=>{
+        return new AssertError(result.value, [
+            result.expected,
+            error.expected
+        ].join(' or '), result.path, result.string);
+    });
 }
 function Optional(schema) {
-  this.schema = schema;
+    this.schema = schema;
 }
 function And(schema) {
-  this.schema = schema;
+    this.schema = schema;
 }
 function Or(schema) {
-  this.schema = schema;
+    this.schema = schema;
 }
-var optional = exports.optional = function optional(schema) {
-  return new Optional(schema);
+const optional = (schema)=>{
+    return new Optional(schema);
 };
-var and = exports.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);
+const and = (...schema)=>{
+    return new And(schema);
 };
-var or = exports.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);
+const or = (...schema)=>{
+    return new Or(schema);
 };
-var $keys = exports.$keys = Symbol.for('@@keys');
-var $values = exports.$values = Symbol.for('@@values');
-var fromBase64 = typeof Buffer === 'undefined' ? function (value) {
-  return atob(value);
-} : function (value) {
-  return Buffer.from(value, 'base64').toString('utf-8');
+const $keys = Symbol.for('@@keys');
+const $values = Symbol.for('@@values');
+const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
+const MULTIPLIERS = {
+    ms: 1,
+    s: 1000,
+    m: 60000,
+    h: 3600000,
+    d: 86400000,
+    w: 604800000
 };
-var as = exports.as = {
-  string: function string(value) {
-    return typeof value === "string" ? value : undefined;
-  },
-  number: function number(value) {
-    var result = parseFloat(value);
-    return Number.isFinite(result) ? result : undefined;
-  },
-  boolean: function boolean(value) {
-    return /^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined;
-  },
-  array: function array(value, delimiter) {
-    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 {
-      return JSON.parse(value);
-    } catch (e) {
-      return undefined;
-    }
-  },
-  base64: function base64(value) {
-    try {
-      return fromBase64(value);
-    } catch (e) {
-      return undefined;
+const as = {
+    string: (value)=>{
+        return typeof value === 'string' ? value : undefined;
+    },
+    number: (value)=>{
+        const result = parseFloat(value);
+        return Number.isFinite(result) ? result : undefined;
+    },
+    date: (value)=>{
+        const result = Date.parse(value);
+        return Number.isFinite(result) ? new Date(result) : undefined;
+    },
+    time: (value)=>{
+        const matches = value?.match(/^(\d+)(ms|s|m|h|d|w)?$/);
+        if (matches) {
+            const [_, amount, unit = 'ms'] = matches;
+            return parseInt(amount, 10) * MULTIPLIERS[unit];
+        }
+        return undefined;
+    },
+    boolean: (value)=>/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined,
+    array: (value, delimiter)=>value?.split(delimiter) ?? undefined,
+    json: (value)=>{
+        try {
+            return JSON.parse(value);
+        } catch (e) {
+            return undefined;
+        }
+    },
+    base64: (value)=>{
+        try {
+            return fromBase64(value);
+        } catch (e) {
+            return undefined;
+        }
     }
-  }
-};
-var toggle = exports.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;
 };
 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');
+    if (schema === null || typeof schema === 'undefined') {
+        return new AssertError(schema, 'any value', path, 'schema value');
     }
-    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 (schema instanceof Optional) {
+        return certain(target, schema.schema, path, true);
     }
-    if (_typeof(target) === 'object' && !(target instanceof schema)) {
-      return new AssertError(target, schema.name, path);
+    const isValue = target !== null && typeof target !== 'undefined';
+    if (!isValue && optional) {
+        return;
     }
-    if (_typeof(target) !== 'object' && target.constructor !== schema) {
-      return new AssertError(target, schema.name, path);
+    if (schema instanceof Or) {
+        if (!schema.schema.length) {
+            return new AssertError(target, 'values', path, 'OR schema');
+        }
+        return findNotError(schema.schema, (schema)=>certain(target, schema, path));
     }
-  } else if (Array.isArray(schema)) {
-    if (!Array.isArray(target)) {
-      return new AssertError(target, schema.constructor.name, path);
+    if (schema instanceof And) {
+        if (!schema.schema.length) {
+            return new AssertError(target, 'values', path, 'AND schema');
+        }
+        return findFirstError(schema.schema, (schema)=>certain(target, schema, path));
     }
-    return findFirstError(target, function (value, idx) {
-      return findNotError(schema, function (itemSchemaType) {
-        return certain(value, itemSchemaType, "".concat(path, ".").concat(idx));
-      });
-    });
-  } else if (_typeof(schema) === 'object') {
-    if (schema instanceof RegExp) {
-      if (!schema.test('' + target)) {
-        return new AssertError(target, "matching /".concat(schema.source, "/"), path);
-      }
-    } else {
-      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 (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 ($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 (typeof target !== 'object' && target.constructor !== schema) {
+            return new AssertError(target, schema.name, path);
+        }
+    } else if (Array.isArray(schema)) {
+        if (!Array.isArray(target)) {
+            return new AssertError(target, schema.constructor.name, path);
+        }
+        return findFirstError(target, (value, idx)=>{
+            return findNotError(schema, (itemSchemaType)=>certain(value, itemSchemaType, `${path}.${idx}`));
         });
-        if (_assertError) {
-          return _assertError;
+    } else if (typeof schema === 'object') {
+        if (schema instanceof RegExp) {
+            if (!schema.test('' + target)) {
+                return new AssertError(target, `matching /${schema.source}/`, path);
+            }
+        } else {
+            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) {
+                const targetKeys = Object.keys(target);
+                const assertError = findFirstError(targetKeys, (targetKey)=>certain(targetKey, schema[$keys], `${path}.${targetKey}`));
+                if (assertError) {
+                    return assertError;
+                }
+            }
+            if ($values in schema) {
+                const targetKeys = Object.keys(target);
+                const assertError = findFirstError(targetKeys, (targetKey)=>certain(target[targetKey], schema[$values], `${path}.${targetKey}`));
+                if (assertError) {
+                    return assertError;
+                }
+            }
+            return findFirstError(Object.keys(schema), (key)=>certain(target[key], schema[key], `${path}.${key}`));
         }
-      }
-      return findFirstError(Object.keys(schema), function (key) {
-        return certain(target[key], schema[key], "".concat(path, ".").concat(key));
-      });
+    } else if (target !== schema) {
+        return new AssertError(target, schema, path);
     }
-  } else if (target !== schema) {
-    return new AssertError(target, schema, path);
-  }
 }
-var ascertain = exports.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());
-  }
+const ascertain = (schema, data, rootName = '[root]')=>{
+    const result = certain(data, schema, rootName);
+    if (result instanceof AssertError) {
+        throw new TypeError(result.toString());
+    }
 };
-var _default = exports.default = ascertain;
+const _default = ascertain;

package/package.json

@@ -1,14 +1,9 @@
 {
   "name": "ascertain",
-  "version": "0.12.33",
+  "version": "0.13.1",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
   "main": "build/index.js",
   "types": "build/index.d.ts",
-  "scripts": {
-    "build": "NODE_ENV=production babel src --out-dir build --ignore **/__tests__,**/__fixtures__ && cp src/index.d.ts build",
-    "test": "NODE_ENV=test jest",
-    "test:cov": "COVERAGE=1 NODE_ENV=test jest"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/3axap4eHko/ascertain.git"
@@ -33,11 +28,14 @@
   },
   "homepage": "https://github.com/3axap4eHko/ascertain#readme",
   "devDependencies": {
-    "@babel/cli": "^7.23.9",
-    "@babel/core": "^7.24.0",
-    "@babel/preset-env": "^7.24.0",
-    "babel-jest": "^29.7.0",
+    "@swc/cli": "^0.3.10",
+    "@swc/core": "^1.4.8",
+    "@swc/jest": "^0.2.36",
     "jest": "^29.7.0"
   },
-  "dependencies": {}
-}
+  "scripts": {
+    "build": "NODE_ENV=production swc src/index.js -d build --ignore **/__tests__,**/__fixtures__ --strip-leading-paths && cp src/index.d.ts build",
+    "test": "NODE_ENV=test jest",
+    "test:cov": "COVERAGE=1 NODE_ENV=test jest"
+  }
+}