@astral/validations 2.26.0 → 3.0.0-beta.0

package/innIP/constants.js

@@ -0,0 +1,8 @@
+import { createErrorCode } from '../core';
+export const INN_IP_ERROR_INFO = {
+    code: createErrorCode('innIP'),
+    message: 'Некорректный ИНН ИП',
+};
+export const INN_IP_LENGTH = 12;
+export const FIRST_INN_IP_DECODING = [7, 2, 4, 10, 3, 5, 9, 4, 6, 8];
+export const SECOND_INN_IP_DECODING = [3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8];

package/innIP/index.d.ts

@@ -0,0 +1,2 @@
+export * from './innIP';
+export * from './constants';

package/innIP/index.js

@@ -0,0 +1,2 @@
+export * from './innIP';
+export * from './constants';

package/innIP/innIP.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type InnIPParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валиден ли ИНН ИП
+ * @example
+ * ```ts
+ * const validate = string(innIP());
+ * validate('384212952720');
+ * ```
+ */
+export declare const innIP: <TValues>(params?: InnIPParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/innIP/innIP.js

@@ -0,0 +1,40 @@
+import { createRule, isStringOfZeros } from '../core';
+import { FIRST_INN_IP_DECODING, INN_IP_ERROR_INFO, INN_IP_LENGTH, SECOND_INN_IP_DECODING, } from './constants';
+const calcFirstCheckSumForInnIP = (arrSymbols) => (arrSymbols
+    .slice(0, -2)
+    .reduce((sum, symbol, index) => FIRST_INN_IP_DECODING[index] * Number(symbol) + sum, 0) %
+    11) %
+    10;
+const calcSecondCheckSumForInnIP = (arrSymbols) => (arrSymbols
+    .slice(0, -1)
+    .reduce((sum, symbol, index) => SECOND_INN_IP_DECODING[index] * Number(symbol) + sum, 0) %
+    11) %
+    10;
+/**
+ * @description Проверяет валиден ли ИНН ИП
+ * @example
+ * ```ts
+ * const validate = string(innIP());
+ * validate('384212952720');
+ * ```
+ */
+export const innIP = (params) => createRule((value, ctx) => {
+    const createInnIPError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || INN_IP_ERROR_INFO.message,
+        code: INN_IP_ERROR_INFO.code,
+    });
+    if (isStringOfZeros(value)) {
+        return createInnIPError();
+    }
+    if (value.length !== INN_IP_LENGTH) {
+        return createInnIPError();
+    }
+    const arrSymbols = value.split('');
+    const firstChecksum = calcFirstCheckSumForInnIP(arrSymbols);
+    const secondChecksum = calcSecondCheckSumForInnIP(arrSymbols);
+    if (Number(value[10]) !== firstChecksum &&
+        Number(value[11]) !== secondChecksum) {
+        return createInnIPError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/innUL/constants.d.ts

@@ -0,0 +1,4 @@
+import { ErrorInfo } from '../core';
+export declare const INN_UL_ERROR_INFO: ErrorInfo;
+export declare const INN_UL_LENGTH = 10;
+export declare const INN_UL_DECODING: number[];

package/innUL/constants.js

@@ -0,0 +1,7 @@
+import { createErrorCode } from '../core';
+export const INN_UL_ERROR_INFO = {
+    code: createErrorCode('innUL'),
+    message: 'Некорректный ИНН ЮЛ',
+};
+export const INN_UL_LENGTH = 10;
+export const INN_UL_DECODING = [2, 4, 10, 3, 5, 9, 4, 6, 8];

package/innUL/index.d.ts

@@ -0,0 +1,2 @@
+export * from './innUL';
+export * from './constants';

package/innUL/index.js

@@ -0,0 +1,2 @@
+export * from './innUL';
+export * from './constants';

package/innUL/innUL.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type InnULParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валиден ли ИНН ЮЛ
+ * @example
+ * ```ts
+ * const validate = string(innUL());
+ * validate('7728168971');
+ * ```
+ */
+export declare const innUL: <TValues>(params?: InnULParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/innUL/innUL.js

@@ -0,0 +1,36 @@
+import { createRule, isStringOfZeros } from '../core';
+import { INN_UL_DECODING, INN_UL_ERROR_INFO, INN_UL_LENGTH } from './constants';
+const calcCheckSumForInnUl = (arrSymbols) => (arrSymbols
+    .slice(0, -1)
+    .reduce((sum, symbol, index) => INN_UL_DECODING[index] * Number(symbol) + sum, 0) %
+    11) %
+    10;
+/**
+ * @description Проверяет валиден ли ИНН ЮЛ
+ * @example
+ * ```ts
+ * const validate = string(innUL());
+ * validate('7728168971');
+ * ```
+ */
+export const innUL = (params) => createRule((value, ctx) => {
+    const createInnUlError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || INN_UL_ERROR_INFO.message,
+        code: INN_UL_ERROR_INFO.code,
+    });
+    if (isStringOfZeros(value)) {
+        return createInnUlError();
+    }
+    if (value.length !== INN_UL_LENGTH) {
+        return createInnUlError();
+    }
+    const arrSymbols = value.split('');
+    if (arrSymbols.some((symbol) => isNaN(Number(symbol)))) {
+        return createInnUlError();
+    }
+    const checksum = calcCheckSumForInnUl(arrSymbols);
+    if (Number(value[9]) !== checksum) {
+        return createInnUlError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/kpp/constants.d.ts

@@ -0,0 +1,3 @@
+import { ErrorInfo } from '../core';
+export declare const INVALID_KPP_ERROR_INFO: ErrorInfo;
+export declare const KPP_REGEX: RegExp;

package/kpp/constants.js

@@ -0,0 +1,6 @@
+import { createErrorCode } from '../core';
+export const INVALID_KPP_ERROR_INFO = {
+    code: createErrorCode('kpp-invalid'),
+    message: 'Некорректный КПП',
+};
+export const KPP_REGEX = /^(\d{4}([A-Z]|\d){2}\d{3})$/;

package/kpp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './kpp';

package/kpp/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './kpp';

package/kpp/kpp.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type KPPParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валидность кода КПП
+ * @example
+ * ```ts
+ * const validate = string(kpp());
+ * validate('770201001');
+ * ```
+ */
+export declare const kpp: <TValues>(params?: KPPParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/kpp/kpp.js

@@ -0,0 +1,16 @@
+import { createRule, isStringOfZeros } from '../core';
+import { INVALID_KPP_ERROR_INFO, KPP_REGEX } from './constants';
+/**
+ * @description Проверяет валидность кода КПП
+ * @example
+ * ```ts
+ * const validate = string(kpp());
+ * validate('770201001');
+ * ```
+ */
+export const kpp = (params) => createRule((value, ctx) => {
+    if (isStringOfZeros(value) || !KPP_REGEX.test(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, INVALID_KPP_ERROR_INFO), { message: (params === null || params === void 0 ? void 0 : params.message) || INVALID_KPP_ERROR_INFO.message }));
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/max/constants.d.ts

@@ -0,0 +1,5 @@
+import { ErrorCode } from '../core';
+export declare const STRING_MAX_ERROR_CODE: ErrorCode;
+export declare const NUMBER_MAX_ERROR_CODE: ErrorCode;
+export declare const DATE_MAX_ERROR_CODE: ErrorCode;
+export declare const ARRAY_MAX_ERROR_CODE: ErrorCode;

package/max/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const STRING_MAX_ERROR_CODE = createErrorCode('string-max');
+export const NUMBER_MAX_ERROR_CODE = createErrorCode('number-max');
+export const DATE_MAX_ERROR_CODE = createErrorCode('date-max');
+export const ARRAY_MAX_ERROR_CODE = createErrorCode('array-max');

package/max/index.d.ts

@@ -0,0 +1,2 @@
+export * from './max';
+export * from './constants';

package/max/index.js

@@ -0,0 +1,2 @@
+export * from './max';
+export * from './constants';

package/max/max.d.ts

@@ -0,0 +1,26 @@
+import { ValidationContext, createRule } from '../core';
+type BaseMaxValidationTypes = number | string | Array<unknown>;
+type CommonThreshold = number | Date;
+type MaxParams<ValidationType> = {
+    /**
+     * @description Сообщение ошибки
+     */
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+};
+/**
+ * @description Проверяет значение на соответствие максимуму. Работает с: string, array, Date, number
+ * @param threshold - верхний доступный порог value
+ * @example
+ * ```ts
+ *  string(max(22));
+ *
+ *  number(max(22));
+ *
+ *  array(max(2)));
+ *
+ *  date(max(new Date())));
+ * ```
+ */
+export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
+export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes, unknown>>;
+export {};

package/max/max.js

@@ -0,0 +1,42 @@
+import { createRule, resetTime } from '../core';
+import { ARRAY_MAX_ERROR_CODE, DATE_MAX_ERROR_CODE, NUMBER_MAX_ERROR_CODE, STRING_MAX_ERROR_CODE, } from './constants';
+export function max(threshold, params) {
+    return createRule((value, ctx) => {
+        const getMessage = (typeMessage) => (params === null || params === void 0 ? void 0 : params.getMessage)
+            ? params.getMessage(threshold, value, ctx)
+            : typeMessage;
+        if (value instanceof Date && threshold instanceof Date) {
+            return resetTime(value) <= resetTime(threshold)
+                ? undefined
+                : ctx.createError({
+                    code: DATE_MAX_ERROR_CODE,
+                    message: getMessage(`Не позднее ${threshold.toLocaleDateString('ru')}`),
+                });
+        }
+        if (threshold instanceof Date) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            const isError = value.trim().length > threshold;
+            return isError
+                ? ctx.createError({
+                    code: STRING_MAX_ERROR_CODE,
+                    message: getMessage(`Макс. символов: ${threshold}`),
+                })
+                : undefined;
+        }
+        if (Array.isArray(value) && value.length > threshold) {
+            return ctx.createError({
+                code: ARRAY_MAX_ERROR_CODE,
+                message: getMessage(`Не меньше ${threshold}`),
+            });
+        }
+        if (typeof value === 'number' && value > threshold) {
+            return ctx.createError({
+                code: NUMBER_MAX_ERROR_CODE,
+                message: getMessage(`Не меньше ${threshold}`),
+            });
+        }
+        return undefined;
+    });
+}

package/min/constants.d.ts

@@ -0,0 +1,5 @@
+import { ErrorCode } from '../core';
+export declare const STRING_MIN_ERROR_CODE: ErrorCode;
+export declare const NUMBER_MIN_ERROR_CODE: ErrorCode;
+export declare const DATE_MIN_ERROR_CODE: ErrorCode;
+export declare const ARRAY_MIN_ERROR_CODE: ErrorCode;

package/min/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const STRING_MIN_ERROR_CODE = createErrorCode('string-min');
+export const NUMBER_MIN_ERROR_CODE = createErrorCode('number-min');
+export const DATE_MIN_ERROR_CODE = createErrorCode('date-min');
+export const ARRAY_MIN_ERROR_CODE = createErrorCode('array-min');

package/min/index.d.ts

@@ -0,0 +1,2 @@
+export * from './min';
+export * from './constants';

package/min/index.js

@@ -0,0 +1,2 @@
+export * from './min';
+export * from './constants';

package/min/min.d.ts

@@ -0,0 +1,26 @@
+import { ValidationContext, createRule } from '../core';
+type BaseMinValidationTypes = number | string | Array<unknown>;
+type CommonThreshold = number | Date;
+type MinParams<ValidationType> = {
+    /**
+     * @description Сообщение ошибки
+     */
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+};
+/**
+ * @description Проверяет значение на соответствие минимуму. Работает с: string, array, Date, number
+ * @param threshold - нижний доступный порог value
+ * @example
+ * ```ts
+ *  string(min(22));
+ *
+ *  number(min(22));
+ *
+ *  array(min(2)));
+ *
+ *  date(min(new Date())));
+ * ```
+ */
+export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
+export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes, unknown>>;
+export {};

package/min/min.js

@@ -0,0 +1,42 @@
+import { createRule, resetTime } from '../core';
+import { ARRAY_MIN_ERROR_CODE, DATE_MIN_ERROR_CODE, NUMBER_MIN_ERROR_CODE, STRING_MIN_ERROR_CODE, } from './constants';
+export function min(threshold, params) {
+    return createRule((value, ctx) => {
+        const getMessage = (typeMessage) => (params === null || params === void 0 ? void 0 : params.getMessage)
+            ? params.getMessage(threshold, value, ctx)
+            : typeMessage;
+        if (value instanceof Date && threshold instanceof Date) {
+            return resetTime(value) >= resetTime(threshold)
+                ? undefined
+                : ctx.createError({
+                    code: DATE_MIN_ERROR_CODE,
+                    message: getMessage(`Не раньше ${threshold.toLocaleDateString('ru')}`),
+                });
+        }
+        if (threshold instanceof Date) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            const isError = value.trim().length < threshold;
+            return isError
+                ? ctx.createError({
+                    code: STRING_MIN_ERROR_CODE,
+                    message: getMessage(`Мин. символов: ${threshold}`),
+                })
+                : undefined;
+        }
+        if (Array.isArray(value) && value.length < threshold) {
+            return ctx.createError({
+                code: ARRAY_MIN_ERROR_CODE,
+                message: getMessage(`Не больше ${threshold}`),
+            });
+        }
+        if (typeof value === 'number' && value < threshold) {
+            return ctx.createError({
+                code: NUMBER_MIN_ERROR_CODE,
+                message: getMessage(`Не больше ${threshold}`),
+            });
+        }
+        return undefined;
+    });
+}

package/mobilePhone/constants.d.ts

@@ -0,0 +1,3 @@
+import { ErrorInfo } from '../core';
+export declare const MOBILE_PHONE_ERROR_INFO: ErrorInfo;
+export declare const MOBILE_PHONE_REGEX: RegExp;

package/mobilePhone/constants.js

@@ -0,0 +1,6 @@
+import { createErrorCode } from '../core';
+export const MOBILE_PHONE_ERROR_INFO = {
+    code: createErrorCode('mobilePhone'),
+    message: 'Некорректный номер телефона',
+};
+export const MOBILE_PHONE_REGEX = /^(79)\d{9}$/;

package/mobilePhone/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mobilePhone';
+export * from './constants';

package/mobilePhone/index.js

@@ -0,0 +1,2 @@
+export * from './mobilePhone';
+export * from './constants';

package/mobilePhone/mobilePhone.d.ts

@@ -0,0 +1,27 @@
+import { CommonRuleParams } from '../core';
+type MobilePhoneParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description
+ * Проверяет валиден ли мобильный телефон.
+ * Валидный телефон начинается с "79" и не содержит символов, кроме цифр.
+ * @example
+ * ```ts
+ * const validate = string(mobilePhone());
+ * validate('79999999999');
+ * ```
+ */
+export declare const mobilePhone: <TValues>(params?: MobilePhoneParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/mobilePhone/mobilePhone.js

@@ -0,0 +1,21 @@
+import { createRule } from '../core';
+import { MOBILE_PHONE_ERROR_INFO, MOBILE_PHONE_REGEX } from './constants';
+/**
+ * @description
+ * Проверяет валиден ли мобильный телефон.
+ * Валидный телефон начинается с "79" и не содержит символов, кроме цифр.
+ * @example
+ * ```ts
+ * const validate = string(mobilePhone());
+ * validate('79999999999');
+ * ```
+ */
+export const mobilePhone = (params) => createRule((value, ctx) => {
+    if (!MOBILE_PHONE_REGEX.test(value)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || MOBILE_PHONE_ERROR_INFO.message,
+            code: MOBILE_PHONE_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/number/constants.d.ts

@@ -0,0 +1,4 @@
+import { ErrorInfo } from '../core';
+export declare const NUMBER_TYPE_ERROR_INFO: ErrorInfo;
+export declare const NAN_NUMBER_ERROR_INFO: ErrorInfo;
+export declare const INFINITY_NUMBER_ERROR_INFO: ErrorInfo;

package/number/constants.js

@@ -0,0 +1,13 @@
+import { createErrorCode } from '../core';
+export const NUMBER_TYPE_ERROR_INFO = {
+    code: createErrorCode('number-type'),
+    message: 'Не число',
+};
+export const NAN_NUMBER_ERROR_INFO = {
+    code: createErrorCode('number-nan'),
+    message: 'Некорректное число',
+};
+export const INFINITY_NUMBER_ERROR_INFO = {
+    code: createErrorCode('number-infinity'),
+    message: 'Бесконечное число',
+};

package/number/index.d.ts

@@ -0,0 +1,2 @@
+export * from './number';
+export * from './constants';

package/number/index.js

@@ -0,0 +1,2 @@
+export * from './number';
+export * from './constants';

package/number/number.d.ts

@@ -0,0 +1,19 @@
+import { ValidationRule } from '../core';
+type AdditionalDefOptions = {
+    nanErrorMessage?: string;
+    infinityErrorMessage?: string;
+};
+/**
+ * @description Guard для number. Проверяет значение на тип number и NaN, Infinity
+ * Для NaN и Infinity возвращаются отдельные ошибки
+ * @param rules - правила, валидирующие number или unknown value
+ * @example
+ * ```ts
+ *  const validate = number(min(22));
+ *
+ *  // undefined
+ *  validate(24);
+ * ```
+ */
+export declare const number: <TValues>(...rules: ValidationRule<number, TValues>[]) => import("../core").Guard<number, TValues, AdditionalDefOptions>;
+export {};

package/number/number.js

@@ -0,0 +1,26 @@
+import { compose, createGuard } from '../core';
+import { INFINITY_NUMBER_ERROR_INFO, NAN_NUMBER_ERROR_INFO, NUMBER_TYPE_ERROR_INFO, } from './constants';
+/**
+ * @description Guard для number. Проверяет значение на тип number и NaN, Infinity
+ * Для NaN и Infinity возвращаются отдельные ошибки
+ * @param rules - правила, валидирующие number или unknown value
+ * @example
+ * ```ts
+ *  const validate = number(min(22));
+ *
+ *  // undefined
+ *  validate(24);
+ * ```
+ */
+export const number = (...rules) => createGuard((value, ctx, { typeErrorMessage, nanErrorMessage, infinityErrorMessage }) => {
+    if (typeof value !== 'number') {
+        return ctx.createError(Object.assign(Object.assign({}, NUMBER_TYPE_ERROR_INFO), { message: typeErrorMessage || NUMBER_TYPE_ERROR_INFO.message }));
+    }
+    if (Number.isNaN(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, NAN_NUMBER_ERROR_INFO), { message: nanErrorMessage || NAN_NUMBER_ERROR_INFO.message }));
+    }
+    if (!Number.isFinite(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, INFINITY_NUMBER_ERROR_INFO), { message: infinityErrorMessage || INFINITY_NUMBER_ERROR_INFO.message }));
+    }
+    return compose(...rules)(value, ctx);
+});

package/object/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorInfo } from '../core';
+export declare const OBJECT_TYPE_ERROR_INFO: ErrorInfo;

package/object/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const OBJECT_TYPE_ERROR_INFO = {
+    code: createErrorCode('object'),
+    message: 'Не является объектом',
+};

package/object/index.d.ts

@@ -0,0 +1,2 @@
+export * from './object';
+export * from './constants';

package/object/index.js

@@ -0,0 +1,2 @@
+export * from './object';
+export * from './constants';

package/object/isEmptyErrors/index.d.ts

@@ -0,0 +1 @@
+export * from './isEmptyErrors';

package/object/isEmptyErrors/index.js

@@ -0,0 +1 @@
+export * from './isEmptyErrors';

package/object/isEmptyErrors/isEmptyErrors.d.ts

@@ -0,0 +1,5 @@
+import { ErrorMap } from '../../core';
+/**
+ * @description Проверяет есть ли errorMap ошибки
+ */
+export declare const isEmptyErrors: (errorMap: ErrorMap) => boolean;

package/object/isEmptyErrors/isEmptyErrors.js

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет есть ли errorMap ошибки
+ */
+export const isEmptyErrors = (errorMap) => Object.values(errorMap).every((error) => error === undefined);