validno 0.2.4 → 0.2.6

package/dist/Schema.js

@@ -1,18 +1,14 @@
+import { ESchemaFields } from "./constants/schema.js";
 import validate from "./validate.js";
-export const defaultSchemaKeys = [
-    "required",
-    "type",
-    "eachType",
-    "rules",
-    "title",
-    "customMessage",
-    "joinErrors"
-];
+export const defaultSchemaKeys = Object.values(ESchemaFields);
 export class Schema {
-    constructor(inputSchema) {
-        this.schema = inputSchema;
+    constructor(inputSchemaDefinition) {
+        if (!inputSchemaDefinition || typeof inputSchemaDefinition !== 'object') {
+            throw new Error("Invalid schema input");
+        }
+        this.schema = inputSchemaDefinition;
     }
-    validate(data, keys) {
-        return validate.call(this, this, data, keys);
+    validate(inputData, validationKeys) {
+        return validate.call(this, inputData, validationKeys);
     }
 }

package/dist/ValidnoResult.js

@@ -9,6 +9,10 @@ class ValidnoResult {
         this.byKeys = (results === null || results === void 0 ? void 0 : results.byKeys) || {};
         this.errorsByKeys = (results === null || results === void 0 ? void 0 : results.errorsByKeys) || {};
     }
+    setNoData() {
+        this.ok = false;
+        this.errors = ['Отсутствует объект для проверки'];
+    }
     setKeyStatus(key, result) {
         this.byKeys[key] = result;
     }
@@ -68,7 +72,7 @@ class ValidnoResult {
         }
     }
     finish() {
-        if (this.failed.length)
+        if (this.failed.length || this.errors.length)
             this.ok = false;
         else
             this.ok = true;
@@ -86,5 +90,8 @@ class ValidnoResult {
             errorsByKeys: this.errorsByKeys,
         };
     }
+    isValid() {
+        return this.ok === true;
+    }
 }
 export default ValidnoResult;

package/dist/constants/details.js

@@ -1,6 +1,11 @@
-export var ErrorKeywords;
-(function (ErrorKeywords) {
-    ErrorKeywords["Missing"] = "missing";
-    ErrorKeywords["Type"] = "type";
-    ErrorKeywords["Rule"] = "rule";
-})(ErrorKeywords || (ErrorKeywords = {}));
+export var EValidationId;
+(function (EValidationId) {
+    EValidationId["Missing"] = "missing";
+    EValidationId["Type"] = "type";
+    EValidationId["Rule"] = "rule";
+})(EValidationId || (EValidationId = {}));
+export var EValidationDetails;
+(function (EValidationDetails) {
+    EValidationDetails["OK"] = "ok";
+    EValidationDetails["INVALID_DATE"] = "\u0414\u0430\u0442\u0430 \u043D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
+})(EValidationDetails || (EValidationDetails = {}));

package/dist/constants/schema.js

@@ -0,0 +1,10 @@
+export var ESchemaFields;
+(function (ESchemaFields) {
+    ESchemaFields["Required"] = "required";
+    ESchemaFields["Type"] = "type";
+    ESchemaFields["EachType"] = "eachType";
+    ESchemaFields["Rules"] = "rules";
+    ESchemaFields["Title"] = "title";
+    ESchemaFields["CustomMessage"] = "customMessage";
+    ESchemaFields["JoinErrors"] = "joinErrors";
+})(ESchemaFields || (ESchemaFields = {}));

package/dist/dev.js

@@ -1,51 +1,30 @@
 import { Schema } from "./Schema.js";
-const validateConfig = (cfg) => {
-    const cfgSchema = new Schema({
-        str1: {
-            type: String,
+const testSchema = new Schema({
+    parent: {
+        collection: {
+            type: [String, Array],
             required: true
-        },
-        str2: {
-            deep1: {
-                type: String,
-                required: true,
-            }
         }
-    });
-    const res = cfgSchema.validate(cfg);
-    console.log(res);
-};
-const uniTestService = {
-    str1: 'xxxx'
-};
-validateConfig(uniTestService);
-console.log(uniTestService);
-console.log(uniTestService);
-const obj = {
-    top: {
-        mid1: {
-            low1a: false,
-            low1b: false
-        },
-        mid2: {
-            low2a: false
-        }
-    },
-    top2: false
-};
-const setNestedValue = (linkedObj, keysLevels, curLevel, valueToSet) => {
-    const lvKey = keysLevels[curLevel];
-    if (curLevel < keysLevels.length - 1) {
-        if (!linkedObj[lvKey] || typeof linkedObj[lvKey] !== 'object') {
-            linkedObj[lvKey] = {};
-        }
-        return setNestedValue(linkedObj[lvKey], keysLevels, curLevel + 1, valueToSet);
     }
-    else {
-        linkedObj[lvKey] = valueToSet;
+});
+const testObj = {
+    parent: {
+        collection: ['xxxx']
+    }
+};
+const testObj2 = {
+    parent: {
+        collection: false
     }
 };
-const setDeepValue = (obj, keysChain, valueToSet) => {
-    const keysLevels = keysChain.split('.');
-    setNestedValue(obj, keysLevels, 0, valueToSet);
+const testObj3 = {
+    parent: {
+        collection: 'str'
+    }
 };
+const res = testSchema.validate(testObj);
+console.log(res.ok === true ? '#1 ✅' : '#1 ❌');
+const res2 = testSchema.validate(testObj2);
+console.log(res2.ok === false ? '#2 ✅' : '#2 ❌');
+const res3 = testSchema.validate(testObj3);
+console.log(res3.ok === true ? '#3 ✅' : '#3 ❌');

package/dist/index.js

@@ -1,2 +1,4 @@
 import { Schema } from "./Schema.js";
+import _validations from "./utils/validations.js";
+export const validations = _validations;
 export default Schema;

package/dist/utils/validateType.js

@@ -0,0 +1,11 @@
+import { EValidationDetails } from "../constants/details.js";
+const _validateType = {
+    getResult: (key, passed, details = EValidationDetails.OK) => {
+        return {
+            key: key,
+            passed: passed,
+            details: details,
+        };
+    }
+};
+export default _validateType;

package/dist/utils/validations.js

@@ -32,7 +32,7 @@ _validations.isNullOrUndefined = (value) => {
     return value === undefined || value === null;
 };
 _validations.isEmail = (value) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    const emailRegex = /^(?!.*\.\.)[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return emailRegex.test(value);
 };
 _validations.isDateYYYYMMDD = (value) => {

package/dist/validate.js

@@ -1,114 +1,142 @@
-import checkType from "./checkType.js";
+import checkType from "./validateType.js";
 import _errors from "./utils/errors.js";
-import checkRules from "./checkRules.js";
+import checkRules from "./validateRules.js";
 import _helpers from "./utils/helpers.js";
-import { ErrorKeywords } from "./constants/details.js";
+import { EValidationId } from "./constants/details.js";
 import ValidnoResult from "./ValidnoResult.js";
-function generateMsg(input) {
-    let { key, deepKey, data, reqs } = input;
-    const keyForMsg = deepKey || key;
-    const keyTitle = 'title' in reqs ? reqs.title : keyForMsg;
-    if (!reqs.customMessage)
-        return _errors.getMissingError(keyForMsg);
-    const errMsg = reqs.customMessage({
-        keyword: ErrorKeywords.Missing,
+function handleMissingKey(schema, input) {
+    const { key, nestedKey, data, reqs } = input;
+    const messageKey = nestedKey || key;
+    const messageTitle = reqs.title || messageKey;
+    if (!reqs.customMessage) {
+        return _errors.getMissingError(messageKey);
+    }
+    const errorMessage = reqs.customMessage({
+        keyword: EValidationId.Missing,
         value: data[key],
-        key: keyForMsg,
-        title: keyTitle,
-        reqs: reqs,
-        schema: this.schema
+        key: messageKey,
+        title: messageTitle,
+        reqs,
+        schema,
     });
-    return errMsg;
+    return errorMessage;
 }
-function handleDeepKey(input) {
-    const { results, key, deepKey, data, reqs } = input;
-    const nesctedKeys = Object.keys(reqs);
+function validateNestedKey(input) {
+    const { results, key, nestedKey, data, reqs } = input;
+    const nestedKeys = Object.keys(reqs);
     const nestedResults = [];
-    let i = 0;
-    while (i < nesctedKeys.length) {
-        const nestedKey = nesctedKeys[i];
+    for (const itemKey of nestedKeys) {
         const deepParams = {
-            key: nestedKey,
+            key: itemKey,
             data: data[key],
-            reqs: reqs[nestedKey],
-            deepKey: `${deepKey}.${nestedKey}`
+            reqs: reqs[itemKey],
+            nestedKey: `${nestedKey}.${itemKey}`
         };
-        const deepResults = handleKey.call(this, deepParams);
+        const deepResults = validateKey.call(this, deepParams);
         nestedResults.push(deepResults.ok);
         results.merge(deepResults);
-        i++;
     }
-    results.fixParentByChilds(deepKey, nestedResults);
+    results.fixParentByChilds(nestedKey, nestedResults);
     return results;
 }
-export function handleKey(input) {
-    let { results, key, deepKey, data, reqs } = input;
+function validateKey(input) {
+    let { results, key, nestedKey, data, reqs } = input;
+    if (data === undefined) {
+        const noDataResult = new ValidnoResult();
+        noDataResult.setNoData();
+        noDataResult.finish();
+        return noDataResult;
+    }
     if (!results)
         results = new ValidnoResult();
-    if (!deepKey)
-        deepKey = key;
-    const hasNested = _helpers.checkIsNested(reqs);
+    if (!nestedKey)
+        nestedKey = key;
     const hasMissing = _helpers.hasMissing(input);
-    const missedCheck = [];
-    const typeChecked = [];
-    const rulesChecked = [];
     if (_helpers.checkNestedIsMissing(reqs, data)) {
-        results.setMissing(deepKey);
-        return results;
+        return handleMissingNestedKey(results, nestedKey);
     }
-    if (hasNested) {
-        return handleDeepKey.call(this, { results, key, data, reqs, deepKey });
+    if (_helpers.checkIsNested(reqs)) {
+        return validateNestedKey.call(this, { results, key, data, reqs, nestedKey });
     }
+    return validateKeyDetails.call(this, {
+        results,
+        key,
+        nestedKey,
+        data,
+        reqs,
+        hasMissing,
+    });
+}
+function handleMissingNestedKey(results, nestedKey) {
+    results.setMissing(nestedKey);
+    return results;
+}
+function validateKeyDetails(params) {
+    const { results, key, nestedKey, data, reqs, hasMissing } = params;
+    const missedCheck = [];
+    const typeChecked = [];
+    const rulesChecked = [];
     if (hasMissing) {
-        let errMsg = generateMsg.call(this, input);
-        missedCheck.push(false);
-        results.setMissing(deepKey, errMsg);
-        return results;
+        return handleMissingKeyValidation(this.schema, { results, key, nestedKey, data, reqs }, missedCheck);
     }
-    const typeCheck = checkType(key, data[key], reqs, deepKey);
-    typeCheck.forEach(res => {
-        if (res.passed === false) {
-            typeChecked.push(res.passed);
-            results.errors.push(res.details);
+    checkValueType(results, key, data[key], reqs, nestedKey, typeChecked);
+    checkRulesForKey.call(this, results, nestedKey, data[key], reqs, data, rulesChecked);
+    return finalizeValidation(results, nestedKey, missedCheck, typeChecked, rulesChecked);
+}
+function handleMissingKeyValidation(schema, params, missedCheck) {
+    const { results, key, nestedKey, data, reqs } = params;
+    const errMsg = handleMissingKey(schema, { key, nestedKey, data, reqs });
+    missedCheck.push(false);
+    results.setMissing(nestedKey, errMsg);
+    return results;
+}
+function checkValueType(results, key, value, reqs, nestedKey, typeChecked) {
+    const typeCheck = checkType(key, value, reqs, nestedKey);
+    typeCheck.forEach((res) => {
+        if (!res.passed) {
+            typeChecked.push(false);
+            results.errors.push(res.details || '');
         }
     });
-    const ruleCheck = checkRules.call(this, deepKey, data[key], reqs, data);
+}
+function checkRulesForKey(results, nestedKey, value, reqs, data, rulesChecked) {
+    const ruleCheck = checkRules.call(this, nestedKey, value, reqs, data);
     if (!ruleCheck.ok) {
         rulesChecked.push(false);
         ruleCheck.details.forEach((el) => {
-            if (deepKey in results.errorsByKeys)
-                results.errorsByKeys[deepKey] = [];
+            if (!(nestedKey in results.errorsByKeys))
+                results.errorsByKeys[nestedKey] = [];
             results.errors.push(el);
-            results.errorsByKeys[deepKey] = ['1'];
+            results.errorsByKeys[nestedKey] = ['1'];
         });
     }
+}
+function finalizeValidation(results, nestedKey, missedCheck, typeChecked, rulesChecked) {
     if (missedCheck.length)
-        results.setMissing(deepKey);
-    const isPassed = (!typeChecked.length && !rulesChecked.length && !missedCheck.length);
+        results.setMissing(nestedKey);
+    const isPassed = !typeChecked.length && !rulesChecked.length && !missedCheck.length;
     if (!isPassed) {
-        results.setFailed(deepKey);
-        results.errorsByKeys[deepKey] = [
-            ...results.errors
-        ];
+        results.setFailed(nestedKey);
+        results.errorsByKeys[nestedKey] = [...results.errors];
     }
     else {
-        results.setPassed(deepKey);
+        results.setPassed(nestedKey);
     }
     return results.finish();
 }
-function validate(schema, data, keysToCheck) {
+function validateSchema(data, keysToCheck) {
     const output = new ValidnoResult();
     const hasKeysToCheck = _helpers.areKeysLimited(keysToCheck);
-    const schemaKeys = Object.entries(schema.schema);
+    const schemaKeys = Object.entries(this.schema);
     for (const [key, reqs] of schemaKeys) {
         const toBeValidated = _helpers.needValidation(key, hasKeysToCheck, keysToCheck);
         if (!toBeValidated)
             continue;
-        const keyResult = handleKey.call(this, { key, data, reqs });
+        const keyResult = validateKey.call(this, { key, data, reqs });
         output.merge(keyResult);
     }
     output.finish();
     return output;
 }
 ;
-export default validate;
+export default validateSchema;

package/dist/{checkRules.js → validateRules.js}

@@ -110,7 +110,7 @@ const rulesFunctions = {
         return output;
     }
 };
-function checkRules(key, value, requirements, inputObj) {
+function validateRules(key, value, requirements, inputObj) {
     const result = {
         ok: true,
         details: []
@@ -156,4 +156,4 @@ function checkRules(key, value, requirements, inputObj) {
     return result;
 }
 ;
-export default checkRules;
+export default validateRules;

package/dist/validateType.js

@@ -0,0 +1,124 @@
+import { EValidationDetails, EValidationId } from "./constants/details.js";
+import _validations from "./utils/validations.js";
+import _errors from "./utils/errors.js";
+import _validateType from "./utils/validateType.js";
+const validateUnionType = (key, value, requirements, keyName = key) => {
+    const typeList = Array.isArray(requirements.type)
+        ? requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el))
+        : [];
+    const results = [];
+    for (let i = 0; i < typeList.length; i++) {
+        const requirementsRe = Object.assign(Object.assign({}, requirements), { type: requirements.type[i] });
+        const result = validateType(key, value, requirementsRe);
+        results.push(result[0].passed);
+        if (results[i] === true)
+            return _validateType.getResult(keyName, true);
+    }
+    const isPassed = results.some((r) => r === true);
+    const result = _validateType.getResult(keyName, isPassed, isPassed ? null : _errors.getErrorDetails(keyName, typeList.join('/'), value));
+    return result;
+};
+const validateType = (key, value, requirements, keyName = key) => {
+    var _a;
+    const isNotNull = value !== null;
+    const keyTitle = 'title' in requirements ? requirements.title : keyName;
+    const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function';
+    if (value === undefined && requirements.required) {
+        return [_validateType.getResult(keyName, false, _errors.getMissingError(keyName))];
+    }
+    if (Array.isArray(requirements.type)) {
+        return [validateUnionType(key, value, requirements)];
+    }
+    if (value === undefined && requirements.required !== true) {
+        return [_validateType.getResult(keyName, true)];
+    }
+    const customErrDetails = hasCustomMessage ?
+        requirements.customMessage({
+            keyword: EValidationId.Type,
+            value: value,
+            key: keyName,
+            title: keyTitle,
+            reqs: requirements,
+            schema: null
+        }) :
+        null;
+    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
+    const getDetails = (isOK, errorText) => isOK ?
+        EValidationDetails.OK :
+        errorText || customErrDetails || baseErrDetails;
+    const typeBySchema = requirements.type;
+    const result = [];
+    switch (typeBySchema) {
+        case 'any': {
+            result.push(_validateType.getResult(keyName, true, getDetails(true)));
+            break;
+        }
+        case Number: {
+            const isNumber = isNotNull && value.constructor === Number;
+            result.push(_validateType.getResult(keyName, isNumber, getDetails(isNumber)));
+            break;
+        }
+        case String: {
+            const isString = isNotNull && value.constructor === String;
+            result.push(_validateType.getResult(keyName, isString, getDetails(isString)));
+            break;
+        }
+        case Date: {
+            const isDate = isNotNull && value.constructor === Date;
+            const isValid = isDate && !isNaN(value.getTime());
+            const isValidDate = isDate && isValid;
+            result.push(_validateType.getResult(keyName, isValidDate, getDetails(isValidDate, EValidationDetails.INVALID_DATE)));
+            break;
+        }
+        case Boolean: {
+            const isBoolean = isNotNull && value.constructor === Boolean;
+            result.push(_validateType.getResult(keyName, isBoolean, getDetails(isBoolean)));
+            break;
+        }
+        case Array: {
+            const isArray = isNotNull && value.constructor === Array;
+            if (!isArray) {
+                result.push(_validateType.getResult(keyName, false, getDetails(isArray)));
+                break;
+            }
+            let isEachChecked = { passed: true, details: "" };
+            if ('eachType' in requirements) {
+                for (const el of value) {
+                    const result = validateType('each of ' + key, el, { type: requirements.eachType, required: true });
+                    if (!result[0].passed) {
+                        isEachChecked.passed = false;
+                        isEachChecked.details = result[0].details || '';
+                        break;
+                    }
+                }
+            }
+            const isOk = isArray && isEachChecked.passed;
+            const details = !isEachChecked.passed ? isEachChecked.details : getDetails(isOk);
+            result.push(_validateType.getResult(keyName, isOk, details));
+            break;
+        }
+        case Object: {
+            const isObject = _validations.isObject(value) && value.constructor === Object;
+            result.push(_validateType.getResult(keyName, isObject, getDetails(isObject)));
+            break;
+        }
+        case RegExp: {
+            const isRegex = _validations.isRegex(value);
+            result.push(_validateType.getResult(keyName, isRegex, getDetails(isRegex)));
+            break;
+        }
+        case null: {
+            const isNull = value === null;
+            result.push(_validateType.getResult(keyName, isNull, getDetails(isNull)));
+            break;
+        }
+        default: {
+            const isInstanceOf = typeof typeBySchema === 'function' && value instanceof typeBySchema;
+            const isConstructorSame = typeof typeBySchema === 'function' && ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === (typeBySchema === null || typeBySchema === void 0 ? void 0 : typeBySchema.name);
+            const isOK = isInstanceOf && isConstructorSame;
+            result.push(_validateType.getResult(keyName, isOK, getDetails(isOK)));
+        }
+    }
+    return result;
+};
+export default validateType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/dist/checkType.js

@@ -1,163 +0,0 @@
-import { ErrorKeywords } from "./constants/details.js";
-import _validations from "./utils/validations.js";
-import _errors from "./utils/errors.js";
-const checkTypeMultiple = (key, value, requirements, keyName = key) => {
-    const constructorNames = requirements.type.map((el) => String((el === null || el === void 0 ? void 0 : el.name) || el));
-    const result = {
-        key: keyName,
-        passed: false,
-        details: _errors.getErrorDetails(keyName, constructorNames.join('/'), value)
-    };
-    let i = 0;
-    while (i < requirements.type.length) {
-        const requirementsRe = Object.assign(Object.assign({}, requirements), { type: requirements.type[i] });
-        const check = checkType(key, value, requirementsRe);
-        if (check[0].passed === true) {
-            result.passed = true;
-            result.details = 'OK';
-            return result;
-        }
-        i++;
-    }
-    return result;
-};
-const checkType = (key, value, requirements, keyName = key) => {
-    var _a;
-    const isNotNull = value !== null;
-    const keyTitle = 'title' in requirements ? requirements.title : keyName;
-    const hasCustomMessage = requirements.customMessage && typeof requirements.customMessage === 'function';
-    if (value === undefined && requirements.required) {
-        return [{ key: keyName, passed: false, details: `Значение "${keyName}" отсутствует` }];
-    }
-    let result = [];
-    if (Array.isArray(requirements.type)) {
-        return [checkTypeMultiple(key, value, requirements)];
-    }
-    if (value === undefined && requirements.required !== true) {
-        result.push({
-            key: keyName,
-            passed: true,
-            details: 'OK'
-        });
-        return result;
-    }
-    const customErrDetails = hasCustomMessage ?
-        requirements.customMessage({
-            keyword: ErrorKeywords.Type,
-            value: value,
-            key: keyName,
-            title: keyTitle,
-            reqs: requirements,
-            schema: null
-        }) :
-        null;
-    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
-    const getDetails = (isOK) => isOK ? 'OK' : customErrDetails || baseErrDetails;
-    const typeBySchema = requirements.type;
-    switch (typeBySchema) {
-        case 'any':
-            result.push({
-                key: keyName,
-                passed: true,
-                details: 'OK'
-            });
-            break;
-        case Number:
-            const isNumber = isNotNull && value.constructor === Number;
-            result.push({
-                key: keyName,
-                passed: isNumber,
-                details: getDetails(isNumber)
-            });
-            break;
-        case String:
-            const isString = isNotNull && value.constructor === String;
-            result.push({
-                key: keyName,
-                passed: isString,
-                details: getDetails(isString)
-            });
-            break;
-        case Date:
-            const isDate = isNotNull && value.constructor === Date;
-            const isValid = isDate && !isNaN(value.getTime());
-            const errorMsg = isValid ? getDetails(isDate) : 'Дата невалидна';
-            result.push({
-                key: keyName,
-                passed: isDate && isValid,
-                details: isDate && isValid ? 'OK' : errorMsg
-            });
-            break;
-        case Boolean:
-            const isBoolean = isNotNull && value.constructor === Boolean;
-            result.push({
-                key: keyName,
-                passed: isBoolean,
-                details: isBoolean ? 'OK' : getDetails(isBoolean)
-            });
-            break;
-        case Array:
-            const isArray = isNotNull && value.constructor === Array;
-            if (!isArray) {
-                result.push({
-                    key: keyName,
-                    passed: false,
-                    details: getDetails(isArray)
-                });
-                break;
-            }
-            let isEachChecked = { passed: true, details: "" };
-            if ('eachType' in requirements) {
-                isEachChecked.passed = value.every((el) => {
-                    const checkResult = checkType('each of ' + key, el, { type: requirements.eachType, required: true });
-                    if (!checkResult[0].passed) {
-                        isEachChecked.details = checkResult[0].details;
-                        isEachChecked.passed = false;
-                    }
-                    return true;
-                });
-            }
-            const isOk = isArray && isEachChecked.passed;
-            result.push({
-                key: keyName,
-                passed: isOk,
-                details: isOk ? 'OK' : !isEachChecked.passed ? isEachChecked.details : getDetails(isOk)
-            });
-            break;
-        case Object:
-            const isObject = _validations.isObject(value) && value.constructor === Object;
-            result.push({
-                key: keyName,
-                passed: isObject,
-                details: isObject ? 'OK' : getDetails(isObject)
-            });
-            break;
-        case RegExp:
-            const isRegex = _validations.isRegex(value);
-            result.push({
-                key: keyName,
-                passed: isRegex,
-                details: isRegex ? 'OK' : getDetails(isRegex)
-            });
-            break;
-        case null:
-            const isNull = value === null;
-            result.push({
-                key: keyName,
-                passed: isNull,
-                details: isNull ? 'OK' : getDetails(isNull)
-            });
-            break;
-        default:
-            const isInstanceOf = value instanceof typeBySchema;
-            const isConstructorSame = ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === (typeBySchema === null || typeBySchema === void 0 ? void 0 : typeBySchema.name);
-            const checked = isInstanceOf && isConstructorSame;
-            result.push({
-                key: keyName,
-                passed: checked,
-                details: getDetails(checked)
-            });
-    }
-    return result;
-};
-export default checkType;

package/dist/utils/nested.js

@@ -1 +0,0 @@
-"use strict";