ejv 2.1.0 → 2.1.2

package/build/cjs/ejv.js

@@ -0,0 +1,1341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ejv = void 0;
+const interfaces_1 = require("./interfaces.js");
+const constants_1 = require("./constants.js");
+const tester_1 = require("./tester.js");
+const util_1 = require("./util.js");
+function _getEffectiveTypes(scheme) {
+    let result;
+    if ((0, tester_1.definedTester)(scheme.type)) {
+        result = ((0, tester_1.arrayTester)(scheme.type)
+            ? scheme.type
+            : [scheme.type]);
+    }
+    else if ((0, tester_1.definedTester)(scheme.parent)) {
+        result = _getEffectiveTypes(scheme.parent);
+    }
+    return result;
+}
+const _ejv = (data, schemes, options) => {
+    var _a, _b, _c, _d, _e;
+    // check schemes
+    if (!(0, tester_1.definedTester)(schemes) || schemes === null) {
+        return new interfaces_1.EjvError({
+            type: constants_1.ERROR_TYPE.NO_SCHEME,
+            message: constants_1.ERROR_MESSAGE.NO_SCHEME,
+            data: data,
+            errorScheme: schemes,
+            isSchemeError: true
+        });
+    }
+    if (!(0, tester_1.arrayTester)(schemes)) {
+        return new interfaces_1.EjvError({
+            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+            message: constants_1.ERROR_MESSAGE.NO_ARRAY_SCHEME,
+            data: data,
+            errorScheme: schemes,
+            isSchemeError: true
+        });
+    }
+    if (!(0, tester_1.arrayTypeOfTester)(schemes, constants_1.DATA_TYPE.OBJECT)) {
+        return new interfaces_1.EjvError({
+            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+            message: constants_1.ERROR_MESSAGE.NO_OBJECT_ARRAY_SCHEME,
+            data: data,
+            errorScheme: schemes,
+            isSchemeError: true
+        });
+    }
+    if (!(0, tester_1.minLengthTester)(schemes, 1)) {
+        return new interfaces_1.EjvError({
+            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+            message: constants_1.ERROR_MESSAGE.EMPTY_SCHEME,
+            data: data,
+            errorScheme: schemes,
+            isSchemeError: true
+        });
+    }
+    // check data by schemes
+    let result = null;
+    // use for() instead of forEach() to stop
+    for (const scheme of schemes) {
+        const key = scheme.key;
+        const _options = (0, util_1.clone)(options); // divide instance
+        let value;
+        if (key) {
+            value = data[key];
+            _options.path.push(key);
+        }
+        const types = _getEffectiveTypes(scheme);
+        if (!(0, tester_1.definedTester)(types)) {
+            return new interfaces_1.EjvError({
+                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                message: constants_1.ERROR_MESSAGE.SCHEMES_SHOULD_HAVE_TYPE,
+                data: data,
+                errorScheme: scheme,
+                isSchemeError: true
+            });
+        }
+        const allDataType = Object.values(constants_1.DATA_TYPE);
+        const typeError = types.find((type) => {
+            return !(0, tester_1.definedTester)(type)
+                || !(0, tester_1.stringTester)(type)
+                || !(0, tester_1.enumTester)(type, allDataType);
+        });
+        if (typeError) {
+            return new interfaces_1.EjvError({
+                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.SCHEMES_HAS_INVALID_TYPE, {
+                    placeholders: [typeError]
+                }),
+                data: data,
+                errorScheme: scheme,
+                isSchemeError: true
+            });
+        }
+        if (!(0, tester_1.uniqueItemsTester)(types)) {
+            const notUniqueItems = types.filter((type) => {
+                return types.filter((_type) => _type === type).length > 1;
+            });
+            const notUniqueItemsSifted = (0, util_1.sift)(notUniqueItems);
+            return new interfaces_1.EjvError({
+                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.SCHEMES_HAS_DUPLICATED_TYPE, {
+                    placeholders: [notUniqueItemsSifted.join(', ')]
+                }),
+                data: data,
+                errorScheme: scheme,
+                isSchemeError: true
+            });
+        }
+        if (!(0, tester_1.definedTester)(value)) {
+            if (scheme.optional !== true) {
+                result = new interfaces_1.EjvError({
+                    type: constants_1.ERROR_TYPE.REQUIRED,
+                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.REQUIRED),
+                    data,
+                    path: _options.path,
+                    errorScheme: scheme,
+                    errorData: value
+                });
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        if (value === null) {
+            if (scheme.nullable !== true) {
+                result = new interfaces_1.EjvError({
+                    type: constants_1.ERROR_TYPE.REQUIRED,
+                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.REQUIRED),
+                    data,
+                    path: _options.path,
+                    errorScheme: scheme,
+                    errorData: value
+                });
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        const typeResolved = types.find((type) => {
+            return (0, tester_1.typeTester)(value, type);
+        });
+        if (typeResolved) {
+            if ((0, tester_1.definedTester)(scheme.type)) {
+                if (!(0, tester_1.arrayTester)(scheme.type)) {
+                    if (scheme.type !== typeResolved) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.TYPE_MISMATCH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH, {
+                                placeholders: [scheme.type]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: scheme,
+                            errorData: value
+                        });
+                    }
+                }
+                else {
+                    if (!scheme.type.includes(typeResolved)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.TYPE_MISMATCH_ONE_OF,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH_ONE_OF, {
+                                placeholders: [JSON.stringify(scheme.type)]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: scheme,
+                            errorData: value
+                        });
+                    }
+                }
+            }
+            // else do additional validation
+        }
+        else {
+            // type is not resolved
+            const typesForMsg = scheme.type || ((_a = scheme.parent) === null || _a === void 0 ? void 0 : _a.type);
+            if (!(0, tester_1.arrayTester)(typesForMsg)) {
+                result = new interfaces_1.EjvError({
+                    type: constants_1.ERROR_TYPE.TYPE_MISMATCH,
+                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH, {
+                        placeholders: [typesForMsg]
+                    }),
+                    data,
+                    path: _options.path,
+                    errorScheme: scheme,
+                    errorData: value
+                });
+            }
+            else {
+                result = new interfaces_1.EjvError({
+                    type: constants_1.ERROR_TYPE.TYPE_MISMATCH_ONE_OF,
+                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH_ONE_OF, {
+                        placeholders: [JSON.stringify(typesForMsg)]
+                    }),
+                    data,
+                    path: _options.path,
+                    errorScheme: scheme,
+                    errorData: value
+                });
+            }
+            break;
+        }
+        // additional check for type resolved
+        switch (typeResolved) {
+            case constants_1.DATA_TYPE.NUMBER: {
+                const valueAsNumber = value;
+                const numberScheme = scheme;
+                if ((0, tester_1.definedTester)(numberScheme.enum)) {
+                    if (!(0, tester_1.arrayTester)(numberScheme.enum)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const enumArr = numberScheme.enum;
+                    if (!(0, tester_1.arrayTypeOfTester)(enumArr, constants_1.DATA_TYPE.NUMBER)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ENUM_SHOULD_BE_NUMBERS),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.enumTester)(valueAsNumber, enumArr)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.ONE_VALUE_OF,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ONE_VALUE_OF, {
+                                placeholders: [JSON.stringify(enumArr)]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: numberScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(numberScheme.notEnum)) {
+                    if (!(0, tester_1.arrayTester)(numberScheme.notEnum)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const enumArr = numberScheme.notEnum;
+                    if (!(0, tester_1.arrayTypeOfTester)(enumArr, constants_1.DATA_TYPE.NUMBER)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_NUMBERS),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.notEnumTester)(valueAsNumber, enumArr)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.NOT_ONE_VALUE_OF,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ONE_VALUE_OF, {
+                                placeholders: [JSON.stringify(enumArr)]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: numberScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(numberScheme.min)
+                    || (0, tester_1.definedTester)((_b = scheme.parent) === null || _b === void 0 ? void 0 : _b.min)) {
+                    const effectiveMin = (0, tester_1.definedTester)(numberScheme.min)
+                        ? numberScheme.min
+                        : (_c = scheme.parent) === null || _c === void 0 ? void 0 : _c.min;
+                    if (!(0, tester_1.numberTester)(effectiveMin)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_SHOULD_BE_NUMBER),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if ((0, tester_1.definedTester)(numberScheme.exclusiveMin)) {
+                        if (!(0, tester_1.booleanTester)(numberScheme.exclusiveMin)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN),
+                                data: data,
+                                errorScheme: numberScheme,
+                                isSchemeError: true
+                            });
+                        }
+                    }
+                    if (numberScheme.exclusiveMin) {
+                        if (!(0, tester_1.exclusiveMinNumberTester)(valueAsNumber, effectiveMin)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.BIGGER_THAN,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.BIGGER_THAN, {
+                                    placeholders: [effectiveMin]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                    else {
+                        if (!(0, tester_1.minNumberTester)(valueAsNumber, effectiveMin)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.BIGGER_THAN_OR_EQUAL,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.BIGGER_THAN_OR_EQUAL, {
+                                    placeholders: [effectiveMin]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                }
+                if ((0, tester_1.definedTester)(numberScheme.max)
+                    || (0, tester_1.definedTester)((_d = scheme.parent) === null || _d === void 0 ? void 0 : _d.max)) {
+                    const effectiveMax = (0, tester_1.definedTester)(numberScheme.max)
+                        ? numberScheme.max
+                        : (_e = scheme.parent) === null || _e === void 0 ? void 0 : _e.max;
+                    if (!(0, tester_1.numberTester)(effectiveMax)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_SHOULD_BE_NUMBER),
+                            data: data,
+                            errorScheme: numberScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if ((0, tester_1.definedTester)(numberScheme.exclusiveMax)) {
+                        if (!(0, tester_1.booleanTester)(numberScheme.exclusiveMax)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN),
+                                data: data,
+                                errorScheme: numberScheme,
+                                isSchemeError: true
+                            });
+                        }
+                    }
+                    if (numberScheme.exclusiveMax) {
+                        if (!(0, tester_1.exclusiveMaxNumberTester)(valueAsNumber, effectiveMax)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.SMALLER_THAN,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.SMALLER_THAN, {
+                                    placeholders: [effectiveMax]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                    else {
+                        if (!(0, tester_1.maxNumberTester)(valueAsNumber, effectiveMax)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.SMALLER_THAN_OR_EQUAL,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.SMALLER_THAN_OR_EQUAL, {
+                                    placeholders: [effectiveMax]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                }
+                if ((0, tester_1.definedTester)(numberScheme.format)) {
+                    let formats;
+                    const allNumberFormat = Object.values(constants_1.NUMBER_FORMAT);
+                    if (!(0, tester_1.arrayTester)(numberScheme.format)) {
+                        const formatAsString = numberScheme.format;
+                        if (!(0, tester_1.enumTester)(formatAsString, allNumberFormat)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
+                                    placeholders: [formatAsString]
+                                }),
+                                data: data,
+                                errorScheme: numberScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        formats = [numberScheme.format];
+                    }
+                    else {
+                        const formatAsArray = numberScheme.format;
+                        const errorFormat = formatAsArray.find((format) => {
+                            return !(0, tester_1.enumTester)(format, allNumberFormat);
+                        });
+                        if (errorFormat) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_NUMBER_FORMAT, {
+                                    placeholders: [errorFormat]
+                                }),
+                                data: data,
+                                errorScheme: numberScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        formats = numberScheme.format;
+                    }
+                    const someFormatIsWrong = formats.some((format) => {
+                        let valid = false;
+                        switch (format) {
+                            case constants_1.NUMBER_FORMAT.INTEGER:
+                                valid = (0, tester_1.integerTester)(valueAsNumber);
+                                break;
+                            case constants_1.NUMBER_FORMAT.INDEX:
+                                valid = (0, tester_1.indexTester)(valueAsNumber);
+                                break;
+                        }
+                        return valid;
+                    });
+                    if (!someFormatIsWrong) {
+                        if (!(0, tester_1.arrayTester)(numberScheme.format)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.FORMAT,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.FORMAT, {
+                                    placeholders: [numberScheme.format]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                        }
+                        else {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.FORMAT_ONE_OF,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.FORMAT_ONE_OF, {
+                                    placeholders: [JSON.stringify(numberScheme.format)]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: numberScheme,
+                                errorData: value
+                            });
+                        }
+                        break;
+                    }
+                }
+                break;
+            }
+            case constants_1.DATA_TYPE.STRING: {
+                const valueAsString = value;
+                const stringScheme = scheme;
+                if ((0, tester_1.definedTester)(stringScheme.enum)) {
+                    if (!(0, tester_1.arrayTester)(stringScheme.enum)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ENUM_SHOULD_BE_ARRAY),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const enumArr = stringScheme.enum;
+                    if (!(0, tester_1.arrayTypeOfTester)(enumArr, constants_1.DATA_TYPE.STRING)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ENUM_SHOULD_BE_STRINGS),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.enumTester)(valueAsString, enumArr)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.ONE_VALUE_OF,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ONE_VALUE_OF, {
+                                placeholders: [JSON.stringify(stringScheme.enum)]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: stringScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.notEnum)) {
+                    if (!(0, tester_1.arrayTester)(stringScheme.notEnum)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_ARRAY),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const enumArr = stringScheme.notEnum;
+                    if (!(0, tester_1.arrayTypeOfTester)(enumArr, constants_1.DATA_TYPE.STRING)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ENUM_SHOULD_BE_STRINGS),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.notEnumTester)(valueAsString, enumArr)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.NOT_ONE_VALUE_OF,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.NOT_ONE_VALUE_OF, {
+                                placeholders: [JSON.stringify(stringScheme.notEnum)]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: stringScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.length)) {
+                    const length = stringScheme.length;
+                    if (!((0, tester_1.numberTester)(length) && (0, tester_1.integerTester)(length))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.lengthTester)(valueAsString, length)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.LENGTH, {
+                                placeholders: [length]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: stringScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.minLength)) {
+                    const minLength = stringScheme.minLength;
+                    if (!((0, tester_1.numberTester)(minLength) && (0, tester_1.integerTester)(minLength))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.minLengthTester)(valueAsString, minLength)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.MIN_LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_LENGTH, {
+                                placeholders: ['' + minLength]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: stringScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.maxLength)) {
+                    const maxLength = stringScheme.maxLength;
+                    if (!((0, tester_1.numberTester)(maxLength) && (0, tester_1.integerTester)(maxLength))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.maxLengthTester)(valueAsString, maxLength)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.MAX_LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_LENGTH, {
+                                placeholders: ['' + maxLength]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: stringScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.format)) {
+                    let formats;
+                    const allStringFormat = Object.values(constants_1.STRING_FORMAT);
+                    if (!(0, tester_1.arrayTester)(stringScheme.format)) {
+                        const formatAsString = stringScheme.format;
+                        if (!(0, tester_1.enumTester)(formatAsString, allStringFormat)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_FORMAT, {
+                                    placeholders: [formatAsString]
+                                }),
+                                data: data,
+                                errorScheme: stringScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        formats = [stringScheme.format];
+                    }
+                    else {
+                        const formatAsArray = stringScheme.format;
+                        const errorFormat = formatAsArray.find((format) => {
+                            return !(0, tester_1.enumTester)(format, allStringFormat);
+                        });
+                        if (errorFormat) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_FORMAT, {
+                                    placeholders: [errorFormat]
+                                }),
+                                data: data,
+                                errorScheme: stringScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        formats = stringScheme.format;
+                    }
+                    const foundFormatMatching = formats.some((format) => {
+                        let valid = false;
+                        switch (format) {
+                            case constants_1.STRING_FORMAT.EMAIL:
+                                valid = (0, tester_1.emailTester)(valueAsString);
+                                break;
+                            case constants_1.STRING_FORMAT.JSON:
+                                valid = (0, tester_1.jsonStrTester)(valueAsString);
+                                break;
+                            case constants_1.STRING_FORMAT.DATE:
+                                valid = (0, tester_1.dateFormatTester)(valueAsString);
+                                break;
+                            case constants_1.STRING_FORMAT.TIME:
+                                valid = (0, tester_1.timeFormatTester)(valueAsString);
+                                break;
+                            case constants_1.STRING_FORMAT.DATE_TIME:
+                                valid = (0, tester_1.dateTimeFormatTester)(valueAsString);
+                                break;
+                        }
+                        return valid;
+                    });
+                    if (!foundFormatMatching) {
+                        if (!(0, tester_1.arrayTester)(stringScheme.format)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.FORMAT,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.FORMAT, {
+                                    placeholders: [stringScheme.format]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: stringScheme,
+                                errorData: value
+                            });
+                        }
+                        else {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.FORMAT_ONE_OF,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.FORMAT_ONE_OF, {
+                                    placeholders: [JSON.stringify(stringScheme.format)]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: stringScheme,
+                                errorData: value
+                            });
+                        }
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(stringScheme.pattern)) {
+                    // check parameter
+                    if (stringScheme.pattern === null) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_PATTERN, {
+                                placeholders: ['null']
+                            }),
+                            data: data,
+                            errorScheme: stringScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const isValidPattern = (pattern) => {
+                        return ((0, tester_1.stringTester)(pattern) && (0, tester_1.minLengthTester)(pattern, 1))
+                            || ((0, tester_1.regExpTester)(pattern) && pattern.toString() !== '/(?:)/' && pattern.toString() !== '/null/');
+                    };
+                    const patternToString = (pattern) => {
+                        let regExpStr;
+                        if (pattern === null) {
+                            regExpStr = '/null/';
+                        }
+                        else if ((0, tester_1.stringTester)(pattern)) {
+                            if ((0, tester_1.minLengthTester)(pattern, 1)) {
+                                regExpStr = new RegExp(pattern).toString();
+                            }
+                            else {
+                                regExpStr = '//';
+                            }
+                        }
+                        else {
+                            regExpStr = pattern.toString();
+                        }
+                        // empty regular expression
+                        if (regExpStr === '/(?:)/') {
+                            regExpStr = '//';
+                        }
+                        return regExpStr;
+                    };
+                    const createArrayErrorMsg = (patternsAsArray) => {
+                        return '[' + patternsAsArray.map((onePattern) => {
+                            return patternToString(onePattern);
+                        }).join(', ') + ']';
+                    };
+                    if ((0, tester_1.arrayTester)(stringScheme.pattern)) {
+                        const patternsAsArray = stringScheme.pattern;
+                        if (!(0, tester_1.minLengthTester)(patternsAsArray, 1)) { // empty array
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_PATTERN, {
+                                    placeholders: [createArrayErrorMsg(patternsAsArray)]
+                                }),
+                                data: data,
+                                errorScheme: stringScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        try {
+                            const regExpPatterns = patternsAsArray.map((pattern) => {
+                                if (!isValidPattern(pattern)) {
+                                    throw new Error((0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_PATTERN, {
+                                        placeholders: [createArrayErrorMsg(patternsAsArray)]
+                                    }));
+                                }
+                                return new RegExp(pattern);
+                            });
+                            // check value
+                            const foundMatchPattern = regExpPatterns.some((regexp) => {
+                                return (0, tester_1.stringRegExpTester)(valueAsString, regexp);
+                            });
+                            if (!foundMatchPattern) {
+                                result = new interfaces_1.EjvError({
+                                    type: constants_1.ERROR_TYPE.PATTERN_ONE_OF,
+                                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.PATTERN_ONE_OF, {
+                                        placeholders: [createArrayErrorMsg(patternsAsArray)]
+                                    }),
+                                    data,
+                                    path: _options.path,
+                                    errorScheme: stringScheme,
+                                    errorData: value
+                                });
+                                break;
+                            }
+                        }
+                        catch (e) { // eslint-disable-line @typescript-eslint/no-unused-vars
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_PATTERN, {
+                                    placeholders: [createArrayErrorMsg(patternsAsArray)]
+                                }),
+                                data: data,
+                                errorScheme: stringScheme,
+                                isSchemeError: true
+                            });
+                        }
+                    }
+                    else {
+                        const patternAsOne = stringScheme.pattern;
+                        if (!isValidPattern(patternAsOne)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_STRING_PATTERN, {
+                                    placeholders: [patternToString(patternAsOne)]
+                                }),
+                                data: data,
+                                errorScheme: stringScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        // check value
+                        const regExp = new RegExp(patternAsOne);
+                        if (!(0, tester_1.stringRegExpTester)(valueAsString, regExp)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.PATTERN,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.PATTERN, {
+                                    placeholders: [patternToString(patternAsOne)]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: stringScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                }
+                break;
+            }
+            case constants_1.DATA_TYPE.OBJECT: {
+                const valueAsObject = value;
+                const objectScheme = scheme;
+                if ((0, tester_1.definedTester)(objectScheme.allowNoProperty)) {
+                    if (!(0, tester_1.booleanTester)(objectScheme.allowNoProperty)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ALLOW_NO_PROPERTY_SHOULD_BE_BOOLEAN),
+                            data: data,
+                            errorScheme: objectScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!objectScheme.allowNoProperty && !(0, tester_1.hasPropertyTester)(valueAsObject)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.PROPERTY,
+                            message: constants_1.ERROR_MESSAGE.PROPERTY,
+                            data,
+                            path: _options.path,
+                            errorScheme: objectScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(objectScheme.properties)) {
+                    if (!(0, tester_1.arrayTester)(objectScheme.properties)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.PROPERTIES_SHOULD_BE_ARRAY),
+                            data: data,
+                            errorScheme: objectScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const properties = objectScheme.properties;
+                    if (!(0, tester_1.minLengthTester)(properties, 1)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.PROPERTIES_SHOULD_HAVE_ITEMS),
+                            data: data,
+                            errorScheme: objectScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.arrayTypeOfTester)(properties, constants_1.DATA_TYPE.OBJECT)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.PROPERTIES_SHOULD_BE_ARRAY_OF_OBJECT),
+                            data: data,
+                            errorScheme: objectScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.objectTester)(value)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.TYPE_MISMATCH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH, {
+                                placeholders: ['object']
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: objectScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                    const partialData = data[key];
+                    const partialScheme = objectScheme.properties;
+                    scheme.parent = objectScheme;
+                    // call recursively
+                    result = _ejv(partialData, partialScheme, _options);
+                    if (result) {
+                        // inject original data
+                        result.data = data;
+                    }
+                }
+                break;
+            }
+            case constants_1.DATA_TYPE.DATE: {
+                const valueAsDate = value;
+                const dateScheme = scheme;
+                const parentDateScheme = scheme.parent;
+                if ((0, tester_1.definedTester)(dateScheme.min)
+                    || (0, tester_1.definedTester)(parentDateScheme === null || parentDateScheme === void 0 ? void 0 : parentDateScheme.min)) {
+                    const minDateCandidate = dateScheme.min || (parentDateScheme === null || parentDateScheme === void 0 ? void 0 : parentDateScheme.min);
+                    if (!(((0, tester_1.stringTester)(minDateCandidate)
+                        && ((0, tester_1.dateFormatTester)(minDateCandidate)
+                            || (0, tester_1.dateTimeFormatTester)(minDateCandidate)))
+                        || (0, tester_1.dateTester)(minDateCandidate))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_DATE_SHOULD_BE_DATE_OR_STRING),
+                            data: data,
+                            errorScheme: dateScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const effectiveMin = new Date(minDateCandidate);
+                    if ((0, tester_1.definedTester)(dateScheme.exclusiveMin)) {
+                        if (!(0, tester_1.booleanTester)(dateScheme.exclusiveMin)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN),
+                                data: data,
+                                errorScheme: dateScheme,
+                                isSchemeError: true
+                            });
+                        }
+                        if (dateScheme.exclusiveMin) {
+                            if (!(0, tester_1.exclusiveMinDateTester)(valueAsDate, effectiveMin)) {
+                                result = new interfaces_1.EjvError({
+                                    type: constants_1.ERROR_TYPE.AFTER_DATE,
+                                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.AFTER_DATE, {
+                                        placeholders: [effectiveMin.toISOString()]
+                                    }),
+                                    data,
+                                    path: _options.path,
+                                    errorScheme: dateScheme,
+                                    errorData: value
+                                });
+                                break;
+                            }
+                        }
+                        else {
+                            if (!(0, tester_1.minDateTester)(valueAsDate, effectiveMin)) {
+                                result = new interfaces_1.EjvError({
+                                    type: constants_1.ERROR_TYPE.AFTER_OR_SAME_DATE,
+                                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.AFTER_OR_SAME_DATE, {
+                                        placeholders: [effectiveMin.toISOString()]
+                                    }),
+                                    data,
+                                    path: _options.path,
+                                    errorScheme: dateScheme,
+                                    errorData: value
+                                });
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        if (!(0, tester_1.minDateTester)(valueAsDate, effectiveMin)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.AFTER_OR_SAME_DATE,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.AFTER_OR_SAME_DATE, {
+                                    placeholders: [effectiveMin.toISOString()]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: dateScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                }
+                if ((0, tester_1.definedTester)(dateScheme.max)
+                    || (0, tester_1.definedTester)(parentDateScheme === null || parentDateScheme === void 0 ? void 0 : parentDateScheme.max)) {
+                    const maxDateCandidate = dateScheme.max || (parentDateScheme === null || parentDateScheme === void 0 ? void 0 : parentDateScheme.max);
+                    if (!(((0, tester_1.stringTester)(maxDateCandidate)
+                        && ((0, tester_1.dateFormatTester)(maxDateCandidate)
+                            || (0, tester_1.dateTimeFormatTester)(maxDateCandidate)))
+                        || (0, tester_1.dateTester)(maxDateCandidate))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_DATE_SHOULD_BE_DATE_OR_STRING),
+                            data: data,
+                            errorScheme: dateScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    const effectiveMax = new Date(maxDateCandidate);
+                    if ((0, tester_1.definedTester)(dateScheme.exclusiveMax)) {
+                        if (!(0, tester_1.booleanTester)(dateScheme.exclusiveMax)) {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN),
+                                data: data,
+                                errorScheme: dateScheme,
+                                isSchemeError: true
+                            });
+                        }
+                    }
+                    if (dateScheme.exclusiveMax) {
+                        if (!(0, tester_1.exclusiveMaxDateTester)(valueAsDate, effectiveMax)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.BEFORE_DATE,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.BEFORE_DATE, {
+                                    placeholders: [effectiveMax.toISOString()]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: dateScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                    else {
+                        if (!(0, tester_1.maxDateTester)(valueAsDate, effectiveMax)) {
+                            result = new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.BEFORE_OR_SAME_DATE,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.BEFORE_OR_SAME_DATE, {
+                                    placeholders: [effectiveMax.toISOString()]
+                                }),
+                                data,
+                                path: _options.path,
+                                errorScheme: dateScheme,
+                                errorData: value
+                            });
+                            break;
+                        }
+                    }
+                }
+                break;
+            }
+            case constants_1.DATA_TYPE.ARRAY: {
+                const valueAsArray = value;
+                const arrayScheme = scheme;
+                if ((0, tester_1.definedTester)(arrayScheme.length)) {
+                    const length = arrayScheme.length;
+                    if (!((0, tester_1.numberTester)(length) && (0, tester_1.integerTester)(length))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: arrayScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.lengthTester)(valueAsArray, length)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.LENGTH, {
+                                placeholders: ['' + length]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: arrayScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(arrayScheme.minLength)) {
+                    const minLength = arrayScheme.minLength;
+                    if (!((0, tester_1.numberTester)(arrayScheme.minLength) && (0, tester_1.integerTester)(minLength))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: arrayScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.minLengthTester)(valueAsArray, minLength)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.MIN_LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MIN_LENGTH, {
+                                placeholders: ['' + minLength]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: arrayScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(arrayScheme.maxLength)) {
+                    const maxLength = arrayScheme.maxLength;
+                    if (!((0, tester_1.numberTester)(arrayScheme.maxLength) && (0, tester_1.integerTester)(maxLength))) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_LENGTH_SHOULD_BE_INTEGER),
+                            data: data,
+                            errorScheme: arrayScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (!(0, tester_1.maxLengthTester)(valueAsArray, maxLength)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.MAX_LENGTH,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.MAX_LENGTH, {
+                                placeholders: ['' + maxLength]
+                            }),
+                            data,
+                            path: _options.path,
+                            errorScheme: arrayScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(arrayScheme.unique)) {
+                    if (!(0, tester_1.booleanTester)(arrayScheme.unique)) {
+                        return new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                            message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.UNIQUE_SHOULD_BE_BOOLEAN),
+                            data: data,
+                            errorScheme: arrayScheme,
+                            isSchemeError: true
+                        });
+                    }
+                    if (arrayScheme.unique && !(0, tester_1.uniqueItemsTester)(valueAsArray)) {
+                        result = new interfaces_1.EjvError({
+                            type: constants_1.ERROR_TYPE.UNIQUE_ITEMS,
+                            message: constants_1.ERROR_MESSAGE.UNIQUE_ITEMS,
+                            data,
+                            path: _options.path,
+                            errorScheme: arrayScheme,
+                            errorData: value
+                        });
+                        break;
+                    }
+                }
+                if ((0, tester_1.definedTester)(arrayScheme.items)) {
+                    // convert array to object
+                    if (valueAsArray.length > 0) {
+                        const now = new Date();
+                        const tempKeyArr = valueAsArray.map((_value, i) => {
+                            return '' + (+now + i);
+                        });
+                        if ((0, tester_1.stringTester)(arrayScheme.items) // by DataType
+                            || ((0, tester_1.arrayTester)(arrayScheme.items) && (0, tester_1.arrayTypeOfTester)(arrayScheme.items, constants_1.DATA_TYPE.STRING)) // by DataType[]
+                        ) {
+                            const itemTypes = ((0, tester_1.arrayTester)(arrayScheme.items)
+                                ? arrayScheme.items
+                                : [arrayScheme.items]);
+                            const itemTypeError = itemTypes.find((type) => {
+                                return !(0, tester_1.definedTester)(type)
+                                    || !(0, tester_1.stringTester)(type)
+                                    || !(0, tester_1.enumTester)(type, allDataType);
+                            });
+                            if (itemTypeError) {
+                                return new interfaces_1.EjvError({
+                                    type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                    message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.SCHEMES_HAS_INVALID_TYPE, {
+                                        placeholders: [itemTypeError]
+                                    }),
+                                    data: data,
+                                    errorScheme: scheme,
+                                    isSchemeError: true
+                                });
+                            }
+                            const partialData = {};
+                            const partialSchemes = [];
+                            tempKeyArr.forEach((tempKey, i) => {
+                                partialData[tempKey] = valueAsArray[i];
+                                partialSchemes.push({
+                                    key: tempKey,
+                                    type: itemTypes
+                                });
+                            });
+                            scheme.parent = arrayScheme;
+                            // call recursively
+                            const partialResult = _ejv(partialData, partialSchemes, _options);
+                            // convert new EjvError
+                            if (partialResult) {
+                                let errorMsg;
+                                if ((0, tester_1.arrayTester)(arrayScheme.items)) {
+                                    errorMsg = (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ITEMS_TYPE, {
+                                        placeholders: [JSON.stringify(itemTypes)]
+                                    });
+                                }
+                                else {
+                                    errorMsg = (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ITEMS_TYPE, {
+                                        placeholders: [arrayScheme.items]
+                                    });
+                                }
+                                const partialKeys = (partialResult.path || '').split('/');
+                                const partialKey = partialKeys[partialKeys.length - 1];
+                                const partialScheme = partialSchemes.find((_scheme) => {
+                                    return _scheme.key === partialKey;
+                                });
+                                const partialKeyIndex = partialSchemes.indexOf(partialScheme);
+                                result = new interfaces_1.EjvError({
+                                    type: constants_1.ERROR_TYPE.ITEMS_TYPE,
+                                    message: errorMsg,
+                                    data,
+                                    path: [..._options.path, '' + partialKeyIndex],
+                                    errorScheme: partialScheme,
+                                    errorData: partialData[partialKey]
+                                });
+                            }
+                            break;
+                        }
+                        else if (((0, tester_1.objectTester)(arrayScheme.items) && arrayScheme.items !== null) // by Scheme
+                            || ((0, tester_1.arrayTester)(arrayScheme.items) && (0, tester_1.arrayTypeOfTester)(arrayScheme.items, constants_1.DATA_TYPE.OBJECT)) // by Scheme[]
+                        ) {
+                            const itemsAsSchemes = (0, tester_1.arrayTester)(arrayScheme.items)
+                                ? arrayScheme.items
+                                : [arrayScheme.items];
+                            let partialError = null;
+                            // use for() instead of forEach() to break
+                            const valueLength = valueAsArray.length;
+                            for (let arrIndex = 0; arrIndex < valueLength; arrIndex++) {
+                                const oneValue = valueAsArray[arrIndex];
+                                const partialData = {};
+                                const partialSchemes = [];
+                                const tempKeyForThisValue = tempKeyArr[arrIndex];
+                                partialData[tempKeyForThisValue] = oneValue;
+                                partialSchemes.push(...itemsAsSchemes.map((oneScheme) => {
+                                    const newScheme = (0, util_1.clone)(oneScheme); // divide instance
+                                    newScheme.key = tempKeyForThisValue;
+                                    return newScheme;
+                                }));
+                                const partialResults = partialSchemes.map((partialScheme) => {
+                                    // call recursively
+                                    const partialResult = _ejv(partialData, [partialScheme], _options);
+                                    if (partialResult) {
+                                        partialResult.path = (partialResult.path || '').replace(tempKeyForThisValue, '' + arrIndex);
+                                    }
+                                    return partialResult;
+                                });
+                                if (!partialResults.some((oneResult) => oneResult === null)) {
+                                    partialError = partialResults.find((oneResult) => {
+                                        return !!oneResult;
+                                    });
+                                    break;
+                                }
+                            }
+                            if (partialError) {
+                                let errorType;
+                                let errorMsg;
+                                if (!!itemsAsSchemes && itemsAsSchemes.length > 1) {
+                                    errorType = constants_1.ERROR_TYPE.ITEMS_SCHEMES;
+                                    errorMsg = (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.ITEMS_SCHEMES, {
+                                        placeholders: [JSON.stringify(itemsAsSchemes)]
+                                    });
+                                }
+                                else {
+                                    errorType = partialError.type;
+                                    errorMsg = partialError.message;
+                                    if (errorType === constants_1.ERROR_TYPE.REQUIRED) {
+                                        // REQUIRED in array is TYPE_MISMATCH except with nullable === true
+                                        errorType = constants_1.ERROR_TYPE.TYPE_MISMATCH;
+                                        errorMsg = (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.TYPE_MISMATCH, {
+                                            placeholders: [JSON.stringify(arrayScheme.items)]
+                                        });
+                                    }
+                                }
+                                result = new interfaces_1.EjvError({
+                                    type: errorType,
+                                    message: errorMsg,
+                                    data
+                                });
+                                if (errorType === constants_1.ERROR_TYPE.INVALID_SCHEMES) {
+                                    result.errorScheme = arrayScheme;
+                                    result.isSchemeError = true;
+                                    result.isDataError = false;
+                                }
+                                else {
+                                    result.path = partialError.path;
+                                    result.errorData = partialError.errorData;
+                                }
+                                break;
+                            }
+                        }
+                        else {
+                            return new interfaces_1.EjvError({
+                                type: constants_1.ERROR_TYPE.INVALID_SCHEMES,
+                                message: (0, util_1.createErrorMsg)(constants_1.ERROR_MESSAGE.INVALID_ITEMS_SCHEME, {
+                                    placeholders: [JSON.stringify(arrayScheme.items)]
+                                }),
+                                data: data,
+                                errorScheme: arrayScheme,
+                                isSchemeError: true
+                            });
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        if (result) {
+            break;
+        }
+    }
+    if (result !== null && (0, tester_1.definedTester)(options.customErrorMsg)) {
+        const customErrorMsgObj = options.customErrorMsg;
+        // override error message
+        const customMsg = customErrorMsgObj[result.type];
+        if ((0, tester_1.definedTester)(customMsg)) {
+            result.message = customMsg;
+        }
+    }
+    return result;
+};
+const ejv = (data, schemes, options) => {
+    // check data itself
+    if (!(0, tester_1.definedTester)(data) || !(0, tester_1.objectTester)(data) || data === null) {
+        return new interfaces_1.EjvError({
+            type: constants_1.ERROR_TYPE.NO_DATA,
+            message: constants_1.ERROR_MESSAGE.NO_DATA,
+            data: data,
+            path: undefined,
+            errorScheme: undefined,
+            errorData: data,
+            isSchemeError: false
+        });
+    }
+    const internalOption = (options
+        ? Object.assign({}, options) : {});
+    if (!(0, tester_1.definedTester)(internalOption.path)) {
+        internalOption.path = [];
+    }
+    return _ejv(data, schemes, internalOption);
+};
+exports.ejv = ejv;
+//# sourceMappingURL=ejv.js.map