validno 0.1.11 → 0.2.1

package/dist/checkType.js

@@ -1,31 +1,12 @@
 import { ErrorKeywords } from "./constants/details.js";
 import _validations from "./utils/validations.js";
-const getErrorDetails = (key, expectedType, receivedValue) => {
-    let receivedType = '';
-    if (typeof receivedValue === 'string')
-        receivedType = 'String';
-    else if (typeof receivedValue === 'number')
-        receivedType = 'Number';
-    else if (typeof receivedValue === 'boolean')
-        receivedType = 'Noolean';
-    else if (receivedValue === null)
-        receivedType = 'null';
-    else if (Array.isArray(receivedValue))
-        receivedType = 'Array';
-    else if (_validations.isDate(receivedValue))
-        receivedType = 'Date';
-    else if (_validations.isObject(receivedValue))
-        receivedType = 'Object';
-    else if (receivedValue === undefined)
-        receivedType = 'undefined';
-    return `Проверьте тип "${key}": ожидался ${(expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType}, получен ${receivedType || 'unknown'}`;
-};
+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: getErrorDetails(keyName, constructorNames.join('/'), value)
+        details: _errors.getErrorDetails(keyName, constructorNames.join('/'), value)
     };
     let i = 0;
     while (i < requirements.type.length) {
@@ -41,6 +22,7 @@ const checkTypeMultiple = (key, value, requirements, keyName = key) => {
     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';
@@ -69,9 +51,10 @@ const checkType = (key, value, requirements, keyName = key) => {
             schema: null
         }) :
         null;
-    const baseErrDetails = getErrorDetails(keyName, requirements.type, value);
+    const baseErrDetails = _errors.getErrorDetails(keyName, requirements.type, value);
     const getDetails = (isOK) => isOK ? 'OK' : customErrDetails || baseErrDetails;
-    switch (requirements.type) {
+    const typeBySchema = requirements.type;
+    switch (typeBySchema) {
         case 'any':
             result.push({
                 key: keyName,
@@ -166,10 +149,13 @@ const checkType = (key, value, requirements, keyName = key) => {
             });
             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: false,
-                details: `Тип '${keyName}' не определен`
+                passed: checked,
+                details: getDetails(checked)
             });
     }
     return result;

package/dist/dev.js

@@ -1,41 +1,105 @@
-import { Schema } from "./Schema.js";
-const schema = new Schema({
-    ops1: {
-        type: Number,
-        required: true,
-        title: 'titl',
-        customMessage: (input) => {
-            return 'Wrong type 1 msg ' + input.keyword;
-        }
-    },
-    ops2: {
-        type: String,
-        required: true,
-        title: 'titl',
-        customMessage: (input) => {
-            return 'Missing msg ' + input.keyword;
-        }
-    },
-    miss: {
-        type: String,
-        required: true,
-        title: 'titl',
-        customMessage: (input) => {
-            return 'Missing msg ' + input.keyword;
+import { isDeepStrictEqual } from 'node:util';
+import _validations from './utils/validations.js';
+const listSame = [];
+const TEST_MAX = 1 * 1000000;
+const TYPES = [
+    'json',
+    'date',
+    'string',
+    'number',
+    'array',
+    'null',
+    'boolean'
+];
+const str = 'string';
+const date = () => new Date(2025, 0, 1, 0, 0, 0, 0);
+const json = () => {
+    return {
+        "surname": "Иванов",
+        "name": "Иван",
+        "patronymic": "Иванович",
+        "birthdate": "01.01.1990",
+        "birthplace": "Москва",
+        "phone": "8 926 766 48 48"
+    };
+};
+console.time('autofill');
+let i = 0;
+while (i < TEST_MAX) {
+    if (TYPES.includes('null'))
+        listSame.push(null);
+    if (TYPES.includes('boolean'))
+        listSame.push(true);
+    if (TYPES.includes('json'))
+        listSame.push(() => json());
+    if (TYPES.includes('date'))
+        listSame.push(() => date());
+    if (TYPES.includes('string'))
+        listSame.push(str);
+    if (TYPES.includes('number'))
+        listSame.push(Math.random());
+    if (TYPES.includes('array'))
+        listSame.push(() => [{ x: 1, y: { z: 0 } }, { x: 1 }, { x: 1 }]);
+    if (TYPES.includes('array'))
+        listSame.push(() => [1234451, 5535433, 7839262, 2134573, 10239752]);
+    if (TYPES.includes('array'))
+        listSame.push(() => [true, true, false, true, false]);
+    if (TYPES.includes('array'))
+        listSame.push(() => ['true', 'true', 'false', 'true', 'false']);
+    i++;
+}
+console.timeEnd('autofill');
+const compareArrs = (v1, v2) => {
+    if (v1.length !== v2.length)
+        return false;
+    return v1.every((el, i) => {
+        if (_validations.isObject(el)) {
+            return JSON.stringify(el) === JSON.stringify(v2[i]);
         }
+        return v2[i] === el;
+    });
+};
+const is = (value, compareTo) => {
+    if (value === compareTo) {
+        return true;
+    }
+    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
+    if (bothArrays) {
+        return compareArrs(value, compareTo);
+    }
+    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
+    if (bothObjects) {
+        const valueStr = JSON.stringify(value);
+        const compareToStr = JSON.stringify(compareTo);
+        return valueStr === compareToStr;
     }
-});
-const obj = {
-    ops1: 'String',
-    ops2: 123
+    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
+    if (bothDates) {
+        return value.getTime() === compareTo.getTime();
+    }
+    return value === compareTo;
+};
+const is2 = (value, compareTo) => {
+    return true;
+};
+const is3 = (v1, v2) => {
+    return isDeepStrictEqual(v1, v2);
 };
-const obj2 = {
-    ops1: 222,
-    ops2: 'str',
-    miss: 'here'
+const doTest = (func) => {
+    console.time('test ' + func.name);
+    let y = 0;
+    while (y < TEST_MAX) {
+        const v1 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
+        const v2 = typeof listSame[y] === 'function' ? listSame[y]() : listSame[y];
+        const result = func(v1, v2);
+        if (result !== true) {
+            console.log(v1);
+            console.log(v2);
+            throw new Error('RESULT != TRUE');
+        }
+        y++;
+    }
+    console.timeEnd('test ' + func.name);
 };
-const res = schema.validate(obj);
-const res2 = schema.validate(obj2);
-console.log('finalResult');
-console.log(res2);
-console.log(res2.joinErrors());
+doTest(is);
+doTest(is3);

package/dist/utils/errors.js

@@ -1,3 +1,17 @@
 const _errors = {};
 _errors.getMissingError = (key) => `Ключ '${key}' отсутствует`;
+_errors.getErrorDetails = (key, expectedType, receivedValue) => {
+    var _a;
+    let receivedType = '';
+    if (receivedValue === undefined)
+        receivedType = 'undefined';
+    else if (receivedValue === null)
+        receivedType = 'null';
+    else
+        receivedType = ((_a = receivedValue.constructor) === null || _a === void 0 ? void 0 : _a.name) || typeof receivedValue || 'na';
+    return `Проверьте тип "${key}": ожидался ${(expectedType === null || expectedType === void 0 ? void 0 : expectedType.name) || expectedType}, получен ${receivedType || 'unknown'}`;
+};
+_errors.joinErrors = (errorsArr, separator = '; ') => {
+    return (errorsArr === null || errorsArr === void 0 ? void 0 : errorsArr.join(`${separator}`)) || '';
+};
 export default _errors;

package/dist/utils/validations.js

@@ -2,86 +2,127 @@ const _validations = {};
 _validations.isString = (value) => {
     return typeof value === 'string';
 };
-_validations.isDate = (value) => {
-    return value instanceof Date && String(value) !== 'Invalid Date';
-};
 _validations.isNumber = (value) => {
     return typeof value === 'number';
 };
-_validations.isNumberGte = (value, gte) => {
-    return typeof value === 'number' && value >= gte;
-};
-_validations.isNumberLte = (value, lte) => {
-    return typeof value === 'number' && value <= lte;
-};
 _validations.isArray = (value) => {
     return Array.isArray(value);
 };
 _validations.isObject = (value) => {
-    return typeof value === 'object' && !Array.isArray(value) && value !== null;
+    var _a;
+    return value !== null && typeof value === 'object' && ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Object' && !Array.isArray(value);
+};
+_validations.isDate = (value) => {
+    return value instanceof Date && String(value) !== 'Invalid Date';
+};
+_validations.isRegex = (value) => {
+    return value instanceof RegExp;
+};
+_validations.isBoolean = (value) => {
+    return typeof value === 'boolean';
+};
+_validations.isNull = (value) => {
+    return value === null;
+};
+_validations.isUndefined = (value) => {
+    return value === undefined;
+};
+_validations.isNullOrUndefined = (value) => {
+    return value === undefined || value === null;
+};
+_validations.isEmail = (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(value);
+};
+_validations.isDateYYYYMMDD = (value) => {
+    const regex = /^\d{4}-\d{2}-\d{2}$/;
+    return regex.test(value);
+};
+_validations.isHex = (value) => {
+    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+    return regex.test(value);
 };
 _validations.lengthIs = (value, length) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof length !== 'number')
+        return false;
     return value.length === length;
 };
 _validations.lengthNot = (value, length) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof length !== 'number')
+        return false;
     return value.length !== length;
 };
 _validations.lengthMin = (value, min) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof min !== 'number')
+        return false;
     return value.length >= min;
 };
 _validations.lengthMax = (value, max) => {
+    if (typeof value !== 'string' && !Array.isArray(value))
+        return false;
+    if (typeof max !== 'number')
+        return false;
     return value.length <= max;
 };
-_validations.isEmail = (value) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(value);
+_validations.isNumberGte = (value, gte) => {
+    return typeof value === 'number' && value >= gte;
 };
-_validations.isRegex = (value) => {
-    return value instanceof RegExp;
+_validations.isNumberLte = (value, lte) => {
+    return typeof value === 'number' && value <= lte;
 };
 _validations.hasKey = (obj, key) => {
+    if (_validations.isObject(obj) === false)
+        return false;
     return key in obj;
 };
-_validations.isNot = (value, not) => {
-    if (typeof not === 'object' && Array.isArray(not)) {
-        for (let i = 0; i < not.length; i++) {
-            if (value === not[i])
-                return false;
+const compareArrs = (v1, v2) => {
+    if (v1.length !== v2.length)
+        return false;
+    return v1.every((el, i) => {
+        if (_validations.isObject(el)) {
+            return JSON.stringify(el) === JSON.stringify(v2[i]);
         }
-        return true;
-    }
-    return value !== not;
+        return v2[i] === el;
+    });
 };
 _validations.is = (value, compareTo) => {
-    if (typeof compareTo === 'object' && Array.isArray(compareTo)) {
-        for (let i = 0; i < compareTo.length; i++) {
-            if (value === compareTo[i])
-                return true;
-        }
-        return false;
+    if (value === compareTo) {
+        return true;
+    }
+    const bothArrays = _validations.isArray(value) && _validations.isArray(compareTo);
+    if (bothArrays) {
+        return compareArrs(value, compareTo);
+    }
+    const bothObjects = _validations.isObject(value) && _validations.isObject(compareTo);
+    if (bothObjects) {
+        const valueStr = JSON.stringify(value);
+        const compareToStr = JSON.stringify(compareTo);
+        return valueStr === compareToStr;
+    }
+    const bothDates = _validations.isDate(value) && _validations.isDate(compareTo);
+    if (bothDates) {
+        return value.getTime() === compareTo.getTime();
     }
     return value === compareTo;
 };
-_validations.isDateYYYYMMDD = (value) => {
-    const regex = /^\d{4}-\d{2}-\d{2}$/;
-    return regex.test(value);
-};
-_validations.regexTested = (value, regex) => {
-    if (!regex)
-        throw new Error('regex argument is not defined');
-    return regex.test(value);
-};
-_validations.isHex = (value) => {
-    const regex = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
-    return regex.test(value);
-};
-_validations.isBoolean = (value) => {
-    return typeof value === 'boolean';
-};
-_validations.isNull = (value) => {
-    return value === null;
+_validations.not = (value, not) => {
+    return !_validations.is(value, not);
 };
-_validations.isUndefined = (value) => {
-    return value === undefined;
+_validations.isNot = _validations.not;
+_validations.ne = _validations.not;
+_validations.regexTested = (value, regexp) => {
+    if (!regexp || regexp instanceof RegExp !== true) {
+        throw new Error('regexp argument is incorrect');
+    }
+    return regexp.test(value);
 };
+_validations.regex = _validations.regexTested;
+_validations.regexp = _validations.regexTested;
+_validations.test = _validations.regexTested;
 export default _validations;

package/dist/validate.js

@@ -4,10 +4,6 @@ import checkRules from "./checkRules.js";
 import _validations from "./utils/validations.js";
 import { ErrorKeywords } from "./constants/details.js";
 import { defaultSchemaKeys } from "./Schema.js";
-function joinErrors(separator = ';') {
-    var _a;
-    return ((_a = this.errors) === null || _a === void 0 ? void 0 : _a.join(`${separator} `)) || '';
-}
 export const getResultDefaults = () => {
     return {
         ok: null,
@@ -66,7 +62,9 @@ export function handleReqKey(key, data, reqs, deepKey = key) {
         }
         return results;
     }
-    if (reqs.required === true && key in data === false || data === undefined) {
+    if (reqs.required === true &&
+        (key in data === false || data === undefined || data[key] === undefined)) {
+        console.log(data);
         let errMsg = _errors.getMissingError(deepKey);
         if (reqs.customMessage && typeof reqs.customMessage === 'function') {
             errMsg = reqs.customMessage({
@@ -151,8 +149,7 @@ class ValidnoResult {
         this.byKeys = results.byKeys;
     }
     joinErrors(separator = '; ') {
-        var _a;
-        return ((_a = this.errors) === null || _a === void 0 ? void 0 : _a.join(`${separator} `)) || '';
+        return _errors.joinErrors(this.errors, separator);
     }
 }
 export default validate;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "validno",
-  "version": "0.1.11",
+  "version": "0.2.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "tsc": "tsc -b src/",
     "tsc-watch": "tsc --b --watch src/",
+    "tscw": "tsc --b --watch src/",
     "dev": "nodemon dist/dev.js",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },