ascertain 0.13.4 → 0.14.0

package/build/index.cjs

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+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;
+    }
+    toString() {
+        return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;
+    }
+};
+function findFirstError(array, map) {
+    for(let i = 0; i < array.length; i++){
+        const error = map(array[i], i);
+        if (error) {
+            return error;
+        }
+    }
+    return false;
+}
+function findNotError(array, map) {
+    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((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;
+}
+const optional = (schema)=>{
+    return new Optional(schema);
+};
+const and = (...schema)=>{
+    return new And(schema);
+};
+const or = (...schema)=>{
+    return new Or(schema);
+};
+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
+};
+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;
+        }
+    }
+};
+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);
+    }
+    const 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, (schema)=>certain(target, schema, 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));
+    }
+    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);
+        }
+    } 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}`));
+        });
+    } 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}`));
+        }
+    } else if (target !== schema) {
+        return new AssertError(target, schema, path);
+    }
+}
+const ascertain = (schema, data, rootName = '[root]')=>{
+    const result = certain(data, schema, rootName);
+    if (result instanceof AssertError) {
+        throw new TypeError(result.toString());
+    }
+};
+const _default = ascertain;
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.js"],"sourcesContent":["class AssertError {\n  constructor(value, expected, path, subject = 'value') {\n    this.value = value;\n    this.expected = expected;\n    this.path = path;\n    this.subject = subject;\n  }\n\n  toString() {\n    return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;\n  }\n}\n\nfunction findFirstError(array, map) {\n  for (let i = 0; i < array.length; i++) {\n    const error = map(array[i], i);\n    if (error) {\n      return error;\n    }\n  }\n  return false;\n}\n\nfunction findNotError(array, map) {\n  const errors = [];\n  for (let i = 0; i < array.length; i++) {\n    const error = map(array[i], i);\n    if (!error) {\n      return false;\n    } else {\n      errors.push(error);\n    }\n  }\n  return errors.reduce((result, error) => {\n    return new AssertError(result.value, [result.expected, error.expected].join(' or '), result.path, result.string);\n  });\n}\n\nfunction Optional(schema) {\n  this.schema = schema;\n}\n\nfunction And(schema) {\n  this.schema = schema;\n}\n\nfunction Or(schema) {\n  this.schema = schema;\n}\n\nexport const optional = (schema) => {\n  return new Optional(schema);\n};\n\nexport const and = (...schema) => {\n  return new And(schema);\n};\n\nexport const or = (...schema) => {\n  return new Or(schema);\n};\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\n\nexport const fromBase64 =\n  typeof Buffer === 'undefined' ? (value) => atob(value) : (value) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const as = {\n  string: (value) => {\n    return typeof value === 'string' ? value : undefined;\n  },\n  number: (value) => {\n    const result = parseFloat(value);\n    return Number.isFinite(result) ? result : undefined;\n  },\n  date: (value) => {\n    const result = Date.parse(value);\n    return Number.isFinite(result) ? new Date(result) : undefined;\n  },\n  time: (value) => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [_, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit];\n    }\n    return undefined;\n  },\n  boolean: (value) => (/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined),\n  array: (value, delimiter) => value?.split(delimiter) ?? undefined,\n  json: (value) => {\n    try {\n      return JSON.parse(value);\n    } catch (e) {\n      return undefined;\n    }\n  },\n  base64: (value) => {\n    try {\n      return fromBase64(value);\n    } catch (e) {\n      return undefined;\n    }\n  },\n};\n\nfunction certain(target, schema, path, optional) {\n  if (schema === null || typeof schema === 'undefined') {\n    return new AssertError(schema, 'any value', path, 'schema value');\n  }\n  if (schema instanceof Optional) {\n    return certain(target, schema.schema, path, true);\n  }\n  const isValue = target !== null && typeof target !== 'undefined';\n  if (!isValue && optional) {\n    return;\n  }\n  if (schema instanceof Or) {\n    if (!schema.schema.length) {\n      return new AssertError(target, 'values', path, 'OR schema');\n    }\n    return findNotError(schema.schema, (schema) => certain(target, schema, path));\n  }\n  if (schema instanceof And) {\n    if (!schema.schema.length) {\n      return new AssertError(target, 'values', path, 'AND schema');\n    }\n    return findFirstError(schema.schema, (schema) => certain(target, schema, path));\n  }\n\n  if (typeof schema === 'function') {\n    if (!isValue) {\n      return new AssertError(target, schema.name, path);\n    }\n    if (typeof target === 'object' && !(target instanceof schema)) {\n      return new AssertError(target, schema.name, path);\n    }\n    if (typeof target !== 'object' && target.constructor !== schema) {\n      return new AssertError(target, schema.name, path);\n    }\n  } else if (Array.isArray(schema)) {\n    if (!Array.isArray(target)) {\n      return new AssertError(target, schema.constructor.name, path);\n    }\n    return findFirstError(target, (value, idx) => {\n      return findNotError(schema, (itemSchemaType) => certain(value, itemSchemaType, `${path}.${idx}`));\n    });\n  } else if (typeof schema === 'object') {\n    if (schema instanceof RegExp) {\n      if (!schema.test('' + target)) {\n        return new AssertError(target, `matching /${schema.source}/`, path);\n      }\n    } else {\n      if (typeof target !== 'object') {\n        return new AssertError(target, schema.constructor.name, path);\n      }\n      if (target === null) {\n        return new AssertError(target, 'an object', path);\n      }\n      if ($keys in schema) {\n        const targetKeys = Object.keys(target);\n        const assertError = findFirstError(targetKeys, (targetKey) =>\n          certain(targetKey, schema[$keys], `${path}.${targetKey}`)\n        );\n        if (assertError) {\n          return assertError;\n        }\n      }\n      if ($values in schema) {\n        const targetKeys = Object.keys(target);\n        const assertError = findFirstError(targetKeys, (targetKey) =>\n          certain(target[targetKey], schema[$values], `${path}.${targetKey}`)\n        );\n        if (assertError) {\n          return assertError;\n        }\n      }\n      return findFirstError(Object.keys(schema), (key) => certain(target[key], schema[key], `${path}.${key}`));\n    }\n  } else if (target !== schema) {\n    return new AssertError(target, schema, path);\n  }\n}\n\nexport const ascertain = (schema, data, rootName = '[root]') => {\n  const result = certain(data, schema, rootName);\n  if (result instanceof AssertError) {\n    throw new TypeError(result.toString());\n  }\n};\n\nexport default ascertain;\n"],"names":["$keys","$values","and","as","ascertain","fromBase64","optional","or","AssertError","constructor","value","expected","path","subject","toString","JSON","stringify","findFirstError","array","map","i","length","error","findNotError","errors","push","reduce","result","join","string","Optional","schema","And","Or","Symbol","for","Buffer","atob","from","MULTIPLIERS","ms","s","m","h","d","w","undefined","number","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","_","amount","unit","parseInt","boolean","test","delimiter","split","json","e","base64","certain","target","isValue","name","Array","isArray","idx","itemSchemaType","RegExp","source","targetKeys","Object","keys","assertError","targetKey","key","data","rootName","TypeError"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IA8DaA,KAAK;eAALA;;IACAC,OAAO;eAAPA;;IATAC,GAAG;eAAHA;;IAuBAC,EAAE;eAAFA;;IAoHAC,SAAS;eAATA;;IAOb,OAAyB;eAAzB;;IAvIaC,UAAU;eAAVA;;IAfAC,QAAQ;eAARA;;IAQAC,EAAE;eAAFA;;;AA1Db,IAAA,AAAMC,cAAN,MAAMA;IACJC,YAAYC,KAAK,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,UAAU,OAAO,CAAE;QACpD,IAAI,CAACH,KAAK,GAAGA;QACb,IAAI,CAACC,QAAQ,GAAGA;QAChB,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,OAAO,GAAGA;IACjB;IAEAC,WAAW;QACT,OAAO,CAAC,QAAQ,EAAE,IAAI,CAACD,OAAO,CAAC,CAAC,EAAEE,KAAKC,SAAS,CAAC,IAAI,CAACN,KAAK,EAAE,mBAAmB,EAAE,IAAI,CAACE,IAAI,CAAC,UAAU,EAAE,IAAI,CAACD,QAAQ,CAAC,CAAC;IACzH;AACF;AAEA,SAASM,eAAeC,KAAK,EAAEC,GAAG;IAChC,IAAK,IAAIC,IAAI,GAAGA,IAAIF,MAAMG,MAAM,EAAED,IAAK;QACrC,MAAME,QAAQH,IAAID,KAAK,CAACE,EAAE,EAAEA;QAC5B,IAAIE,OAAO;YACT,OAAOA;QACT;IACF;IACA,OAAO;AACT;AAEA,SAASC,aAAaL,KAAK,EAAEC,GAAG;IAC9B,MAAMK,SAAS,EAAE;IACjB,IAAK,IAAIJ,IAAI,GAAGA,IAAIF,MAAMG,MAAM,EAAED,IAAK;QACrC,MAAME,QAAQH,IAAID,KAAK,CAACE,EAAE,EAAEA;QAC5B,IAAI,CAACE,OAAO;YACV,OAAO;QACT,OAAO;YACLE,OAAOC,IAAI,CAACH;QACd;IACF;IACA,OAAOE,OAAOE,MAAM,CAAC,CAACC,QAAQL;QAC5B,OAAO,IAAId,YAAYmB,OAAOjB,KAAK,EAAE;YAACiB,OAAOhB,QAAQ;YAAEW,MAAMX,QAAQ;SAAC,CAACiB,IAAI,CAAC,SAASD,OAAOf,IAAI,EAAEe,OAAOE,MAAM;IACjH;AACF;AAEA,SAASC,SAASC,MAAM;IACtB,IAAI,CAACA,MAAM,GAAGA;AAChB;AAEA,SAASC,IAAID,MAAM;IACjB,IAAI,CAACA,MAAM,GAAGA;AAChB;AAEA,SAASE,GAAGF,MAAM;IAChB,IAAI,CAACA,MAAM,GAAGA;AAChB;AAEO,MAAMzB,WAAW,CAACyB;IACvB,OAAO,IAAID,SAASC;AACtB;AAEO,MAAM7B,MAAM,CAAC,GAAG6B;IACrB,OAAO,IAAIC,IAAID;AACjB;AAEO,MAAMxB,KAAK,CAAC,GAAGwB;IACpB,OAAO,IAAIE,GAAGF;AAChB;AAEO,MAAM/B,QAAQkC,OAAOC,GAAG,CAAC;AACzB,MAAMlC,UAAUiC,OAAOC,GAAG,CAAC;AAE3B,MAAM9B,aACX,OAAO+B,WAAW,cAAc,CAAC1B,QAAU2B,KAAK3B,SAAS,CAACA,QAAU0B,OAAOE,IAAI,CAAC5B,OAAO,UAAUI,QAAQ,CAAC;AAE5G,MAAMyB,cAAc;IAClBC,IAAI;IACJC,GAAG;IACHC,GAAG;IACHC,GAAG;IACHC,GAAG;IACHC,GAAG;AACL;AAEO,MAAM1C,KAAK;IAChB0B,QAAQ,CAACnB;QACP,OAAO,OAAOA,UAAU,WAAWA,QAAQoC;IAC7C;IACAC,QAAQ,CAACrC;QACP,MAAMiB,SAASqB,WAAWtC;QAC1B,OAAOuC,OAAOC,QAAQ,CAACvB,UAAUA,SAASmB;IAC5C;IACAK,MAAM,CAACzC;QACL,MAAMiB,SAASyB,KAAKC,KAAK,CAAC3C;QAC1B,OAAOuC,OAAOC,QAAQ,CAACvB,UAAU,IAAIyB,KAAKzB,UAAUmB;IACtD;IACAQ,MAAM,CAAC5C;QACL,MAAM6C,UAAU7C,OAAO8C,MAAM;QAC7B,IAAID,SAAS;YACX,MAAM,CAACE,GAAGC,QAAQC,OAAO,IAAI,CAAC,GAAGJ;YACjC,OAAOK,SAASF,QAAQ,MAAMnB,WAAW,CAACoB,KAAK;QACjD;QACA,OAAOb;IACT;IACAe,SAAS,CAACnD,QAAW,uCAAuCoD,IAAI,CAACpD,SAAS,sBAAsBoD,IAAI,CAACpD,SAASoC;IAC9G5B,OAAO,CAACR,OAAOqD,YAAcrD,OAAOsD,MAAMD,cAAcjB;IACxDmB,MAAM,CAACvD;QACL,IAAI;YACF,OAAOK,KAAKsC,KAAK,CAAC3C;QACpB,EAAE,OAAOwD,GAAG;YACV,OAAOpB;QACT;IACF;IACAqB,QAAQ,CAACzD;QACP,IAAI;YACF,OAAOL,WAAWK;QACpB,EAAE,OAAOwD,GAAG;YACV,OAAOpB;QACT;IACF;AACF;AAEA,SAASsB,QAAQC,MAAM,EAAEtC,MAAM,EAAEnB,IAAI,EAAEN,QAAQ;IAC7C,IAAIyB,WAAW,QAAQ,OAAOA,WAAW,aAAa;QACpD,OAAO,IAAIvB,YAAYuB,QAAQ,aAAanB,MAAM;IACpD;IACA,IAAImB,kBAAkBD,UAAU;QAC9B,OAAOsC,QAAQC,QAAQtC,OAAOA,MAAM,EAAEnB,MAAM;IAC9C;IACA,MAAM0D,UAAUD,WAAW,QAAQ,OAAOA,WAAW;IACrD,IAAI,CAACC,WAAWhE,UAAU;QACxB;IACF;IACA,IAAIyB,kBAAkBE,IAAI;QACxB,IAAI,CAACF,OAAOA,MAAM,CAACV,MAAM,EAAE;YACzB,OAAO,IAAIb,YAAY6D,QAAQ,UAAUzD,MAAM;QACjD;QACA,OAAOW,aAAaQ,OAAOA,MAAM,EAAE,CAACA,SAAWqC,QAAQC,QAAQtC,QAAQnB;IACzE;IACA,IAAImB,kBAAkBC,KAAK;QACzB,IAAI,CAACD,OAAOA,MAAM,CAACV,MAAM,EAAE;YACzB,OAAO,IAAIb,YAAY6D,QAAQ,UAAUzD,MAAM;QACjD;QACA,OAAOK,eAAec,OAAOA,MAAM,EAAE,CAACA,SAAWqC,QAAQC,QAAQtC,QAAQnB;IAC3E;IAEA,IAAI,OAAOmB,WAAW,YAAY;QAChC,IAAI,CAACuC,SAAS;YACZ,OAAO,IAAI9D,YAAY6D,QAAQtC,OAAOwC,IAAI,EAAE3D;QAC9C;QACA,IAAI,OAAOyD,WAAW,YAAY,CAAEA,CAAAA,kBAAkBtC,MAAK,GAAI;YAC7D,OAAO,IAAIvB,YAAY6D,QAAQtC,OAAOwC,IAAI,EAAE3D;QAC9C;QACA,IAAI,OAAOyD,WAAW,YAAYA,OAAO5D,WAAW,KAAKsB,QAAQ;YAC/D,OAAO,IAAIvB,YAAY6D,QAAQtC,OAAOwC,IAAI,EAAE3D;QAC9C;IACF,OAAO,IAAI4D,MAAMC,OAAO,CAAC1C,SAAS;QAChC,IAAI,CAACyC,MAAMC,OAAO,CAACJ,SAAS;YAC1B,OAAO,IAAI7D,YAAY6D,QAAQtC,OAAOtB,WAAW,CAAC8D,IAAI,EAAE3D;QAC1D;QACA,OAAOK,eAAeoD,QAAQ,CAAC3D,OAAOgE;YACpC,OAAOnD,aAAaQ,QAAQ,CAAC4C,iBAAmBP,QAAQ1D,OAAOiE,gBAAgB,CAAC,EAAE/D,KAAK,CAAC,EAAE8D,IAAI,CAAC;QACjG;IACF,OAAO,IAAI,OAAO3C,WAAW,UAAU;QACrC,IAAIA,kBAAkB6C,QAAQ;YAC5B,IAAI,CAAC7C,OAAO+B,IAAI,CAAC,KAAKO,SAAS;gBAC7B,OAAO,IAAI7D,YAAY6D,QAAQ,CAAC,UAAU,EAAEtC,OAAO8C,MAAM,CAAC,CAAC,CAAC,EAAEjE;YAChE;QACF,OAAO;YACL,IAAI,OAAOyD,WAAW,UAAU;gBAC9B,OAAO,IAAI7D,YAAY6D,QAAQtC,OAAOtB,WAAW,CAAC8D,IAAI,EAAE3D;YAC1D;YACA,IAAIyD,WAAW,MAAM;gBACnB,OAAO,IAAI7D,YAAY6D,QAAQ,aAAazD;YAC9C;YACA,IAAIZ,SAAS+B,QAAQ;gBACnB,MAAM+C,aAAaC,OAAOC,IAAI,CAACX;gBAC/B,MAAMY,cAAchE,eAAe6D,YAAY,CAACI,YAC9Cd,QAAQc,WAAWnD,MAAM,CAAC/B,MAAM,EAAE,CAAC,EAAEY,KAAK,CAAC,EAAEsE,UAAU,CAAC;gBAE1D,IAAID,aAAa;oBACf,OAAOA;gBACT;YACF;YACA,IAAIhF,WAAW8B,QAAQ;gBACrB,MAAM+C,aAAaC,OAAOC,IAAI,CAACX;gBAC/B,MAAMY,cAAchE,eAAe6D,YAAY,CAACI,YAC9Cd,QAAQC,MAAM,CAACa,UAAU,EAAEnD,MAAM,CAAC9B,QAAQ,EAAE,CAAC,EAAEW,KAAK,CAAC,EAAEsE,UAAU,CAAC;gBAEpE,IAAID,aAAa;oBACf,OAAOA;gBACT;YACF;YACA,OAAOhE,eAAe8D,OAAOC,IAAI,CAACjD,SAAS,CAACoD,MAAQf,QAAQC,MAAM,CAACc,IAAI,EAAEpD,MAAM,CAACoD,IAAI,EAAE,CAAC,EAAEvE,KAAK,CAAC,EAAEuE,IAAI,CAAC;QACxG;IACF,OAAO,IAAId,WAAWtC,QAAQ;QAC5B,OAAO,IAAIvB,YAAY6D,QAAQtC,QAAQnB;IACzC;AACF;AAEO,MAAMR,YAAY,CAAC2B,QAAQqD,MAAMC,WAAW,QAAQ;IACzD,MAAM1D,SAASyC,QAAQgB,MAAMrD,QAAQsD;IACrC,IAAI1D,kBAAkBnB,aAAa;QACjC,MAAM,IAAI8E,UAAU3D,OAAOb,QAAQ;IACrC;AACF;MAEA,WAAeV"}

package/build/index.js

@@ -1,42 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-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;
@@ -83,18 +44,18 @@ function And(schema) {
 function Or(schema) {
     this.schema = schema;
 }
-const optional = (schema)=>{
+export const optional = (schema)=>{
     return new Optional(schema);
 };
-const and = (...schema)=>{
+export const and = (...schema)=>{
     return new And(schema);
 };
-const or = (...schema)=>{
+export const or = (...schema)=>{
     return new Or(schema);
 };
-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');
+export const $keys = Symbol.for('@@keys');
+export const $values = Symbol.for('@@values');
+export const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
 const MULTIPLIERS = {
     ms: 1,
     s: 1000,
@@ -103,7 +64,7 @@ const MULTIPLIERS = {
     d: 86400000,
     w: 604800000
 };
-const as = {
+export const as = {
     string: (value)=>{
         return typeof value === 'string' ? value : undefined;
     },
@@ -212,10 +173,12 @@ function certain(target, schema, path, optional) {
         return new AssertError(target, schema, path);
     }
 }
-const ascertain = (schema, data, rootName = '[root]')=>{
+export const ascertain = (schema, data, rootName = '[root]')=>{
     const result = certain(data, schema, rootName);
     if (result instanceof AssertError) {
         throw new TypeError(result.toString());
     }
 };
-const _default = ascertain;
+export default ascertain;
+
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.js"],"sourcesContent":["class AssertError {\n  constructor(value, expected, path, subject = 'value') {\n    this.value = value;\n    this.expected = expected;\n    this.path = path;\n    this.subject = subject;\n  }\n\n  toString() {\n    return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;\n  }\n}\n\nfunction findFirstError(array, map) {\n  for (let i = 0; i < array.length; i++) {\n    const error = map(array[i], i);\n    if (error) {\n      return error;\n    }\n  }\n  return false;\n}\n\nfunction findNotError(array, map) {\n  const errors = [];\n  for (let i = 0; i < array.length; i++) {\n    const error = map(array[i], i);\n    if (!error) {\n      return false;\n    } else {\n      errors.push(error);\n    }\n  }\n  return errors.reduce((result, error) => {\n    return new AssertError(result.value, [result.expected, error.expected].join(' or '), result.path, result.string);\n  });\n}\n\nfunction Optional(schema) {\n  this.schema = schema;\n}\n\nfunction And(schema) {\n  this.schema = schema;\n}\n\nfunction Or(schema) {\n  this.schema = schema;\n}\n\nexport const optional = (schema) => {\n  return new Optional(schema);\n};\n\nexport const and = (...schema) => {\n  return new And(schema);\n};\n\nexport const or = (...schema) => {\n  return new Or(schema);\n};\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\n\nexport const fromBase64 =\n  typeof Buffer === 'undefined' ? (value) => atob(value) : (value) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n  ms: 1,\n  s: 1000,\n  m: 60000,\n  h: 3600000,\n  d: 86400000,\n  w: 604800000,\n};\n\nexport const as = {\n  string: (value) => {\n    return typeof value === 'string' ? value : undefined;\n  },\n  number: (value) => {\n    const result = parseFloat(value);\n    return Number.isFinite(result) ? result : undefined;\n  },\n  date: (value) => {\n    const result = Date.parse(value);\n    return Number.isFinite(result) ? new Date(result) : undefined;\n  },\n  time: (value) => {\n    const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n    if (matches) {\n      const [_, amount, unit = 'ms'] = matches;\n      return parseInt(amount, 10) * MULTIPLIERS[unit];\n    }\n    return undefined;\n  },\n  boolean: (value) => (/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined),\n  array: (value, delimiter) => value?.split(delimiter) ?? undefined,\n  json: (value) => {\n    try {\n      return JSON.parse(value);\n    } catch (e) {\n      return undefined;\n    }\n  },\n  base64: (value) => {\n    try {\n      return fromBase64(value);\n    } catch (e) {\n      return undefined;\n    }\n  },\n};\n\nfunction certain(target, schema, path, optional) {\n  if (schema === null || typeof schema === 'undefined') {\n    return new AssertError(schema, 'any value', path, 'schema value');\n  }\n  if (schema instanceof Optional) {\n    return certain(target, schema.schema, path, true);\n  }\n  const isValue = target !== null && typeof target !== 'undefined';\n  if (!isValue && optional) {\n    return;\n  }\n  if (schema instanceof Or) {\n    if (!schema.schema.length) {\n      return new AssertError(target, 'values', path, 'OR schema');\n    }\n    return findNotError(schema.schema, (schema) => certain(target, schema, path));\n  }\n  if (schema instanceof And) {\n    if (!schema.schema.length) {\n      return new AssertError(target, 'values', path, 'AND schema');\n    }\n    return findFirstError(schema.schema, (schema) => certain(target, schema, path));\n  }\n\n  if (typeof schema === 'function') {\n    if (!isValue) {\n      return new AssertError(target, schema.name, path);\n    }\n    if (typeof target === 'object' && !(target instanceof schema)) {\n      return new AssertError(target, schema.name, path);\n    }\n    if (typeof target !== 'object' && target.constructor !== schema) {\n      return new AssertError(target, schema.name, path);\n    }\n  } else if (Array.isArray(schema)) {\n    if (!Array.isArray(target)) {\n      return new AssertError(target, schema.constructor.name, path);\n    }\n    return findFirstError(target, (value, idx) => {\n      return findNotError(schema, (itemSchemaType) => certain(value, itemSchemaType, `${path}.${idx}`));\n    });\n  } else if (typeof schema === 'object') {\n    if (schema instanceof RegExp) {\n      if (!schema.test('' + target)) {\n        return new AssertError(target, `matching /${schema.source}/`, path);\n      }\n    } else {\n      if (typeof target !== 'object') {\n        return new AssertError(target, schema.constructor.name, path);\n      }\n      if (target === null) {\n        return new AssertError(target, 'an object', path);\n      }\n      if ($keys in schema) {\n        const targetKeys = Object.keys(target);\n        const assertError = findFirstError(targetKeys, (targetKey) =>\n          certain(targetKey, schema[$keys], `${path}.${targetKey}`)\n        );\n        if (assertError) {\n          return assertError;\n        }\n      }\n      if ($values in schema) {\n        const targetKeys = Object.keys(target);\n        const assertError = findFirstError(targetKeys, (targetKey) =>\n          certain(target[targetKey], schema[$values], `${path}.${targetKey}`)\n        );\n        if (assertError) {\n          return assertError;\n        }\n      }\n      return findFirstError(Object.keys(schema), (key) => certain(target[key], schema[key], `${path}.${key}`));\n    }\n  } else if (target !== schema) {\n    return new AssertError(target, schema, path);\n  }\n}\n\nexport const ascertain = (schema, data, rootName = '[root]') => {\n  const result = certain(data, schema, rootName);\n  if (result instanceof AssertError) {\n    throw new TypeError(result.toString());\n  }\n};\n\nexport default ascertain;\n"],"names":["AssertError","constructor","value","expected","path","subject","toString","JSON","stringify","findFirstError","array","map","i","length","error","findNotError","errors","push","reduce","result","join","string","Optional","schema","And","Or","optional","and","or","$keys","Symbol","for","$values","fromBase64","Buffer","atob","from","MULTIPLIERS","ms","s","m","h","d","w","as","undefined","number","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","_","amount","unit","parseInt","boolean","test","delimiter","split","json","e","base64","certain","target","isValue","name","Array","isArray","idx","itemSchemaType","RegExp","source","targetKeys","Object","keys","assertError","targetKey","key","ascertain","data","rootName","TypeError"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "ascertain",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "description": "0-Deps, simple, fast, for browser and node js object schema validator",
-  "main": "build/index.js",
+  "type": "module",
   "types": "build/index.d.ts",
-  "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"
+  "main": "build/index.cjs",
+  "module": "build/index.js",
+  "exports": {
+    "require": "./build/index.cjs",
+    "import": "./build/index.js"
   },
+  "files": [
+    "build",
+    "src/index.js"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/3axap4eHko/ascertain.git"
@@ -36,6 +41,13 @@
     "@swc/cli": "^0.3.12",
     "@swc/core": "^1.4.12",
     "@swc/jest": "^0.2.36",
+    "inop": "^0.6.0",
     "jest": "^29.7.0"
+  },
+  "scripts": {
+    "build": "rm -rf build && NODE_ENV=production inop src/ build -t js -i __tests__ && cp src/index.d.ts build",
+    "build:2": "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"
   }
-}
+}

package/src/index.js

@@ -0,0 +1,201 @@
+class AssertError {
+  constructor(value, expected, path, subject = 'value') {
+    this.value = value;
+    this.expected = expected;
+    this.path = path;
+    this.subject = subject;
+  }
+
+  toString() {
+    return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;
+  }
+}
+
+function findFirstError(array, map) {
+  for (let i = 0; i < array.length; i++) {
+    const error = map(array[i], i);
+    if (error) {
+      return error;
+    }
+  }
+  return false;
+}
+
+function findNotError(array, map) {
+  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((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;
+}
+
+export const optional = (schema) => {
+  return new Optional(schema);
+};
+
+export const and = (...schema) => {
+  return new And(schema);
+};
+
+export const or = (...schema) => {
+  return new Or(schema);
+};
+
+export const $keys = Symbol.for('@@keys');
+export const $values = Symbol.for('@@values');
+
+export 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,
+};
+
+export 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;
+    }
+  },
+};
+
+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);
+  }
+  const 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, (schema) => certain(target, schema, 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));
+  }
+
+  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);
+    }
+  } 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}`));
+    });
+  } 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}`));
+    }
+  } else if (target !== schema) {
+    return new AssertError(target, schema, path);
+  }
+}
+
+export const ascertain = (schema, data, rootName = '[root]') => {
+  const result = certain(data, schema, rootName);
+  if (result instanceof AssertError) {
+    throw new TypeError(result.toString());
+  }
+};
+
+export default ascertain;

package/.swcrc

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