@astral/validations 4.24.3 → 4.24.4

package/array/array.d.ts

@@ -12,4 +12,4 @@ import { type ValidationRule, type ValidationTypes } from '../core';
  * validateArray(value);
  * ```
  */
-export declare const array: <TItem extends ValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<Array<TItem>, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;
+export declare const array: <TItem extends ValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<TItem[], TLastSchemaValues>[]) => import("../core").IGuard<TLastSchemaValues, {}>;

package/boolean/boolean.d.ts

@@ -10,4 +10,4 @@ import { type ValidationRule } from '../core';
  *  validate(true);
  * ```
  */
-export declare const boolean: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<boolean, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;
+export declare const boolean: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<boolean, TLastSchemaValues>[]) => import("../core").IGuard<TLastSchemaValues, {}>;

package/containsPunctuationMarks/containsPunctuationMarks.js

@@ -9,7 +9,7 @@ import { CONTAINS_PUNCTUATION_MARKS_ERROR_CODE } from './constants';
  * ```
  */
 export const containsPunctuationMarks = (params) => createRule((value, ctx) => {
-    const containsPunctuationMarksRegex = /(?=.*[!$%&’”'"()+,-.\/:;<=>?@\[\]^_{|}])/;
+    const containsPunctuationMarksRegex = /(?=.*[!$%&’”'"()+,-./:;<=>?@[\]^_{|}])/;
     if (!containsPunctuationMarksRegex.test(value)) {
         return ctx.createError({
             code: CONTAINS_PUNCTUATION_MARKS_ERROR_CODE,

package/core/compose/compose.d.ts

@@ -3,4 +3,4 @@ import { type IndependentValidationRule, type ValidationRule } from '../rule';
  * Объединяет переданные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
  * @example compose(min(), max());
  */
-export declare const compose: <ValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: Array<IndependentValidationRule<ValidationType, TLastSchemaValues> | ValidationRule<ValidationType, TLastSchemaValues>>) => IndependentValidationRule<ValidationType, Record<string, unknown>>;
+export declare const compose: <TValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: Array<IndependentValidationRule<TValidationType, TLastSchemaValues> | ValidationRule<TValidationType, TLastSchemaValues>>) => IndependentValidationRule<TValidationType, Record<string, unknown>>;

package/core/composeAsync/composeAsync.d.ts

@@ -3,4 +3,4 @@ import { type AsyncIndependentValidationRule, type AsyncValidationRule, type Ind
  * Объединяет переданные асинхронные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
  * @example composeAsync(stringAsync(), max());
  */
-export declare const composeAsync: <ValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: Array<IndependentValidationRule<ValidationType, TLastSchemaValues> | AsyncIndependentValidationRule<ValidationType, TLastSchemaValues> | ValidationRule<ValidationType, TLastSchemaValues> | AsyncValidationRule<ValidationType, TLastSchemaValues>>) => AsyncIndependentValidationRule<ValidationType, Record<string, unknown>>;
+export declare const composeAsync: <TValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: Array<IndependentValidationRule<TValidationType, TLastSchemaValues> | AsyncIndependentValidationRule<TValidationType, TLastSchemaValues> | ValidationRule<TValidationType, TLastSchemaValues> | AsyncValidationRule<TValidationType, TLastSchemaValues>>) => AsyncIndependentValidationRule<TValidationType, Record<string, unknown>>;

package/core/context/createContext/createContext.d.ts

@@ -1,6 +1,6 @@
 import { type DeepPartial } from 'utility-types';
-import { type ValidationContext } from '../types';
 import { type ValidationTypes } from '../../types';
+import { type ValidationContext } from '../types';
 type Params<TLastSchemaValues extends Record<string, unknown>> = {
     /**
      * Value последнего валидируемого объекта

package/core/errors/ArrayError/ArrayError.d.ts

@@ -8,7 +8,7 @@ export type ValidationArrayErrorCause = {
      * Массив ошибок элементов валидируемого массива.
      * Индекс errorArray соответвует индексу валидируемого элемента массива
      */
-    errorArray: Array<ValidationResult>;
+    errorArray: ValidationResult[];
 };
 /**
  * Array ошибок для массива

package/core/errors/ErrorMap/ErrorMap.d.ts

@@ -1,5 +1,5 @@
-import { type ValidationErrorData, ValidationSimpleError } from '../SimpleError';
 import { type ValidationResult } from '../../types';
+import { type ValidationErrorData, ValidationSimpleError } from '../SimpleError';
 /**
  * Map, которое содержит результат валидации свойств
  */

package/core/errors/ErrorMap/index.d.ts

@@ -1,2 +1,2 @@
-export * from './ErrorMap';
 export * from './createErrorMap';
+export * from './ErrorMap';

package/core/errors/ErrorMap/index.js

@@ -1,2 +1,2 @@
-export * from './ErrorMap';
 export * from './createErrorMap';
+export * from './ErrorMap';

package/core/errors/SimpleError/SimpleError.d.ts

@@ -2,15 +2,15 @@ import { type ErrorCode } from '../types';
 /**
  * Причина ошибки валидации
  */
-export type ValidationErrorData<AddCause extends Record<string, unknown>> = {
-    cause: AddCause & {
+export type ValidationErrorData<TAddCause extends Record<string, unknown>> = {
+    cause: TAddCause & {
         code: ErrorCode;
     };
 };
 /**
  * Простая ошибка правил валидации. Не имеет вложенных ошибок
  */
-export declare class ValidationSimpleError<AddCause extends Record<string, unknown> = {}> extends Error {
-    cause: ValidationErrorData<AddCause>['cause'];
-    constructor(message: string, data: ValidationErrorData<AddCause>);
+export declare class ValidationSimpleError<TAddCause extends Record<string, unknown> = {}> extends Error {
+    cause: ValidationErrorData<TAddCause>['cause'];
+    constructor(message: string, data: ValidationErrorData<TAddCause>);
 }

package/core/errors/SimpleError/createSimpleError/createSimpleError.d.ts

@@ -1,5 +1,5 @@
-import { ValidationSimpleError } from '../SimpleError';
 import { type ErrorInfo } from '../../types';
+import { ValidationSimpleError } from '../SimpleError';
 /**
  * Создает простую ошибки валидации. Используется в обычных rules
  */

package/core/errors/SimpleError/index.d.ts

@@ -1,2 +1,2 @@
-export * from './SimpleError';
 export * from './createSimpleError';
+export * from './SimpleError';

package/core/errors/SimpleError/index.js

@@ -1,2 +1,2 @@
-export * from './SimpleError';
 export * from './createSimpleError';
+export * from './SimpleError';

package/core/errors/index.d.ts

@@ -1,6 +1,6 @@
-export * from './SimpleError';
 export * from './ArrayError';
+export * from './constants';
+export * from './createErrorCode';
 export * from './ErrorMap';
+export * from './SimpleError';
 export * from './types';
-export * from './createErrorCode';
-export * from './constants';

package/core/errors/index.js

@@ -1,6 +1,6 @@
-export * from './SimpleError';
 export * from './ArrayError';
+export * from './constants';
+export * from './createErrorCode';
 export * from './ErrorMap';
+export * from './SimpleError';
 export * from './types';
-export * from './createErrorCode';
-export * from './constants';

package/core/errors/types.d.ts

@@ -1,6 +1,6 @@
+import { type ValidationArrayError } from './ArrayError';
 import { type ValidationErrorMap } from './ErrorMap';
 import { type ValidationSimpleError } from './SimpleError';
-import { type ValidationArrayError } from './ArrayError';
 /**
  * Уникальный код ошибки валидации
  */

package/core/guard/createGuard/createGuard.d.ts

@@ -1,6 +1,6 @@
-import { type ValidationResult } from '../../types';
 import { type ValidationContext } from '../../context';
-export type GuardDefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
+import { type ValidationResult } from '../../types';
+export type GuardDefOptions<TAddDefOptions extends Record<string, unknown>> = Partial<TAddDefOptions> & {
     /**
      * Переопределяет дефолтное сообщения ошибки для required
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
@@ -21,35 +21,35 @@ export type GuardValue = unknown;
 /**
  * Интерфейс функции guard, которая в прототипе содержит метод define
  */
-export interface Guard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+export interface IGuard<TLastSchemaValues extends Record<string, unknown> = {}, TAddDefOptions extends Record<string, unknown> = {}> {
     (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): ValidationResult;
     /**
      * Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
      * @param options - параметры, позволяющие переопределить дефолтные настройки guard
      * @example string(inn()).define({ requiredMessage: 'ИНН не может быть пустым' })
      */
-    define<TDefineLastSchemaValues extends Record<string, unknown> = {}>(options: GuardDefOptions<AddDefOptions>): Guard<TDefineLastSchemaValues, AddDefOptions>;
+    define<TDefineLastSchemaValues extends Record<string, unknown> = {}>(options: GuardDefOptions<TAddDefOptions>): IGuard<TDefineLastSchemaValues, TAddDefOptions>;
 }
 /**
  * Интерфейс асинхронной функции guard, которая в прототипе содержит метод define
  */
-export interface AsyncGuard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+export interface IAsyncGuard<TLastSchemaValues extends Record<string, unknown> = {}, TAddDefOptions extends Record<string, unknown> = {}> {
     (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): Promise<ValidationResult>;
     /**
      * Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
      * @param options - параметры, позволяющие переопределить дефолтные настройки guard
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
      */
-    define(options: GuardDefOptions<AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
+    define(options: GuardDefOptions<TAddDefOptions>): IAsyncGuard<TLastSchemaValues, TAddDefOptions>;
 }
 /**
  * Функция, которая позволяет определять частную логику для guard
  */
-type GuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => ValidationResult;
+type GuardExecutor<TLastSchemaValues extends Record<string, unknown>, TAddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<TAddDefOptions>) => ValidationResult;
 /**
  * Функция, которая позволяет определять частную логику для guard
  */
-type AsyncGuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => Promise<ValidationResult>;
+type AsyncGuardExecutor<TLastSchemaValues extends Record<string, unknown>, TAddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<TAddDefOptions>) => Promise<ValidationResult>;
 /**
  * Создает guard. Guard - функция, проверяющая тип значения
  * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
@@ -66,6 +66,6 @@ type AsyncGuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDe
  *   });
  * ```
  */
-export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: GuardExecutor<TLastSchemaValues, AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
-export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: AsyncGuardExecutor<TLastSchemaValues, AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, TAddDefOptions extends Record<string, unknown> = {}>(executor: GuardExecutor<TLastSchemaValues, TAddDefOptions>): IGuard<TLastSchemaValues, TAddDefOptions>;
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, TAddDefOptions extends Record<string, unknown> = {}>(executor: AsyncGuardExecutor<TLastSchemaValues, TAddDefOptions>): IAsyncGuard<TLastSchemaValues, TAddDefOptions>;
 export {};

package/core/guard/createGuard/createGuard.js

@@ -1,5 +1,5 @@
-import { required } from '../../rule';
 import { createContext } from '../../context';
+import { required } from '../../rule';
 export function createGuard(executor) {
     // выделено в отдельную именованную функцию для того, чтобы ее можно было рекурсивно вызывать в define
     const createInnerGuard = (defOptions = {}) => {

package/core/index.d.ts

@@ -1,9 +1,9 @@
-export * from './types';
-export * from './errors';
+export * from './compose';
+export * from './composeAsync';
 export * from './context';
 export * from './errors';
+export * from './errors';
 export * from './guard';
 export * from './rule';
-export * from './compose';
-export * from './composeAsync';
+export * from './types';
 export * from './utils';

package/core/index.js

@@ -1,9 +1,9 @@
-export * from './types';
-export * from './errors';
+export * from './compose';
+export * from './composeAsync';
 export * from './context';
 export * from './errors';
+export * from './errors';
 export * from './guard';
 export * from './rule';
-export * from './compose';
-export * from './composeAsync';
+export * from './types';
 export * from './utils';

package/core/logger/logger.js

@@ -2,6 +2,7 @@ class Logger {
     constructor() {
         this.packageName = '@astral/validations';
         this.error = (message, err) => {
+            // biome-ignore lint/suspicious/noConsole: <>
             console.error(`${this.packageName}: ${message}`, err);
         };
     }

package/core/rule/callAsyncRule/callAsyncRule.d.ts

@@ -1,6 +1,6 @@
-import { type AsyncValidationRule, type ValidationRule } from '../types';
-import { type ValidationResult } from '../../types';
 import { type ValidationContext } from '../../context';
+import { type ValidationResult } from '../../types';
+import { type AsyncValidationRule, type ValidationRule } from '../types';
 /**
  * Позволяет рекурсивно вызывать асинхронные правила. Rule может возвращать другой rule
  * Если один из rule выбросит exception, то функция его обработает и вернет дефолтную ошибку

package/core/rule/callRule/callRule.d.ts

@@ -1,6 +1,6 @@
-import { type ValidationRule } from '../types';
-import { type ValidationResult } from '../../types';
 import { type ValidationContext } from '../../context';
+import { type ValidationResult } from '../../types';
+import { type ValidationRule } from '../types';
 /**
  * Позволяет рекурсивно вызывать правила. Rule может возвращать другой rule
  */

package/core/rule/createRule/createRule.d.ts

@@ -1,19 +1,19 @@
-import { type ValidationResult, type ValidationTypes } from '../../types';
 import { type ValidationContext } from '../../context';
+import { type ValidationResult, type ValidationTypes } from '../../types';
 import { type IndependentValidationRule } from '../types';
 /**
  * Единые параметры для всех правил
  */
-export type CommonRuleParams<ValidationType extends ValidationTypes> = {
+export type CommonRuleParams<TValidationType extends ValidationTypes> = {
     /**
      * Функция, позволяющая для каждого правила указать исключение
      */
-    exclude?: (value: ValidationType, ctx: ValidationContext) => boolean;
+    exclude?: (value: TValidationType, ctx: ValidationContext) => boolean;
 };
 /**
  * Функция, которая позволяет определять частную логику для guard
  */
-type RuleExecutor<ValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>> = (value: ValidationType, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;
+type RuleExecutor<TValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>> = (value: TValidationType, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;
 /**
  * Создает правила валидации, которые можно использовать внутри guard или по отдельности
  * @param executor - функция, которая позволяет определять частную логику для guard
@@ -30,5 +30,5 @@ type RuleExecutor<ValidationType extends ValidationTypes, TLastSchemaValues exte
  *   }, params);
  * ```
  */
-export declare const createRule: <ValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(executor: RuleExecutor<ValidationType, TLastSchemaValues>, commonParams?: CommonRuleParams<ValidationType>) => (value: Parameters<IndependentValidationRule<ValidationType, TLastSchemaValues>>[0], prevCtx?: Parameters<IndependentValidationRule<ValidationType, TLastSchemaValues>>[1]) => ReturnType<IndependentValidationRule<ValidationType, TLastSchemaValues>>;
+export declare const createRule: <TValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(executor: RuleExecutor<TValidationType, TLastSchemaValues>, commonParams?: CommonRuleParams<TValidationType>) => (value: Parameters<IndependentValidationRule<TValidationType, TLastSchemaValues>>[0], prevCtx?: Parameters<IndependentValidationRule<TValidationType, TLastSchemaValues>>[1]) => ReturnType<IndependentValidationRule<TValidationType, TLastSchemaValues>>;
 export {};

package/core/rule/index.d.ts

@@ -1,5 +1,5 @@
+export * from './callAsyncRule';
+export * from './callRule';
 export * from './createRule';
-export * from './types';
 export * from './required';
-export * from './callRule';
-export * from './callAsyncRule';
+export * from './types';

package/core/rule/index.js

@@ -1,5 +1,5 @@
+export * from './callAsyncRule';
+export * from './callRule';
 export * from './createRule';
-export * from './types';
 export * from './required';
-export * from './callRule';
-export * from './callAsyncRule';
+export * from './types';

package/core/rule/required/index.d.ts

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

package/core/rule/required/index.js

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

package/core/rule/required/required.js

@@ -4,7 +4,9 @@ import { REQUIRED_ERROR_INFO } from './constants';
  * Проверяет value на пустоту. Если значение пустое, то возвращает ошибку.
  * Правило универсально для всех типов данных
  */
-export const required = ({ message, } = {}) => createRule((value, ctx) => {
+export const required = ({ message, } = {}) => 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <>
+createRule((value, ctx) => {
     const createRequiredError = () => ctx.createError(Object.assign(Object.assign({}, REQUIRED_ERROR_INFO), { message: message || REQUIRED_ERROR_INFO.message }));
     if (value === null) {
         return createRequiredError();

package/core/types.d.ts

@@ -6,4 +6,4 @@ export type ValidationResult = ValidationError | undefined;
 /**
  * Доступные для валидации типы value
  */
-export type ValidationTypes = unknown | object | string | number | Date | Array<unknown>;
+export type ValidationTypes = unknown | object | string | number | Date | unknown[];

package/core/utils/index.d.ts

@@ -5,5 +5,5 @@ export * from './isNoDoubleZeroStart';
 export * from './isStartsWithAndEndsWithLetter';
 export * from './isStringOfZeros';
 export * from './isValidFullNameLength';
-export * from './resetTime';
 export * from './removeNonDigits';
+export * from './resetTime';

package/core/utils/index.js

@@ -5,5 +5,5 @@ export * from './isNoDoubleZeroStart';
 export * from './isStartsWithAndEndsWithLetter';
 export * from './isStringOfZeros';
 export * from './isValidFullNameLength';
-export * from './resetTime';
 export * from './removeNonDigits';
+export * from './resetTime';

package/core/utils/isHasConsecutiveChars/isHasConsecutiveChars.js

@@ -1,4 +1,4 @@
 /**
  * Проверяет, что текст не может содержать последовательно два спецсимвола/пробела
  */
-export const isHasConsecutiveChars = (value) => /([`~!@#$%^&*()\-_=+[{\]}\|;:'",<.>/?\s])([`~!@#$%^&*()\-_=+[{\]}\|;:'",<.>/?\s])/.test(value);
+export const isHasConsecutiveChars = (value) => /([`~!@#$%^&*()\-_=+[{\]}|;:'",<.>/?\s])([`~!@#$%^&*()\-_=+[{\]}|;:'",<.>/?\s])/.test(value);

package/core/utils/isStringOfZeros/isStringOfZeros.js

@@ -3,7 +3,7 @@
  */
 export const isStringOfZeros = (value) => {
     if (value) {
-        return !Boolean(value.replace(/0/g, ''));
+        return !value.replace(/0/g, '');
     }
     return false;
 };

package/date/date.d.ts

@@ -15,5 +15,5 @@ type AdditionalDefOptions = {
  *  validate(new Date('22.22.2022'));
  * ```
  */
-export declare const date: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<Date, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, AdditionalDefOptions>;
+export declare const date: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<Date, TLastSchemaValues>[]) => import("../core").IGuard<TLastSchemaValues, AdditionalDefOptions>;
 export {};

package/deepPartial/deepPartial.d.ts

@@ -1,4 +1,4 @@
-import { type Guard } from '../core';
+import { type IGuard } from '../core';
 /**
  * Делает partial все object в схеме, независимо от уровня вложенности правил
  * @param guard - любой guard
@@ -18,4 +18,4 @@ import { type Guard } from '../core';
  *     const result = validate({ info: { info: {} } });
  * ```
  */
-export declare const deepPartial: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => ReturnType<import("../core").IndependentValidationRule<unknown, TLastSchemaValues>>;
+export declare const deepPartial: <TLastSchemaValues extends Record<string, unknown>>(guard: IGuard<TLastSchemaValues>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => ReturnType<import("../core").IndependentValidationRule<unknown, TLastSchemaValues>>;

package/email/email.js

@@ -10,7 +10,9 @@ import { ALLOWED_HOSTNAME_START_SYMBOL_REGEXP, ALLOWED_USERNAME_START_SYMBOL_REG
  *  validate('example@mail.ru');
  * ```
  */
-export const email = (params) => createRule((value, ctx) => {
+export const email = (params) => 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <>
+createRule((value, ctx) => {
     const invalidEmailError = ctx.createError(Object.assign(Object.assign({}, INVALID_EMAIL_ERROR_INFO), { message: (params === null || params === void 0 ? void 0 : params.message) || INVALID_EMAIL_ERROR_INFO.message }));
     const emailRegexp = (params === null || params === void 0 ? void 0 : params.allowCyrillic)
         ? EMAIL_CYRILLIC_PUNYCODE_REGEXP

package/emailOrPhone/constants.js

@@ -1,4 +1,4 @@
-import { REQUIRED_ERROR_INFO, createErrorCode } from '../core';
+import { createErrorCode, REQUIRED_ERROR_INFO } from '../core';
 export const EMAIL_OR_PHONE_ERROR_INFO = {
     code: createErrorCode('mobileOrPhone'),
     message: 'Некорректный формат',

package/emailOrPhone/emailOrPhone.js

@@ -14,11 +14,10 @@ import { EMAIL_OR_PHONE_ERROR_INFO, EMAIL_OR_PHONE_REQUIRED_ERROR_INFO, } from '
  * ```
  */
 // Отдельная функциональная обертка необходима для работы с guard optional
-export const emailOrPhone = () => (value, ctx) => createGuard((_, innerCtx) => {
-    const requiredValue = value &&
-        typeof value === 'object' &&
-        'value' in value &&
-        !Boolean(value.value);
+export const emailOrPhone = () => (value, ctx) => 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <>
+createGuard((_, innerCtx) => {
+    const requiredValue = value && typeof value === 'object' && 'value' in value && !value.value;
     const checkValidObject = !value ||
         typeof value !== 'object' ||
         !('value' in value) ||

package/index.d.ts

@@ -1,54 +1,54 @@
-export { object, objectAsync, OBJECT_TYPE_ERROR_INFO, type Schema, type SchemaValue, type ObjectGuard, type ObjectAsyncGuard, } from './object';
-export { optional, optionalAsync } from './optional';
-export { string, STRING_TYPE_ERROR_INFO, stringAsync } from './string';
-export { textField, INVALID_TEXT_FIELD_ERROR_INFO, LENGTH_TEXT_FIELD_ERROR_INFO, } from './textField';
-export { date, INVALID_DATE_ERROR_INFO, DATE_TYPE_ERROR_INFO } from './date';
-export { number, NAN_NUMBER_ERROR_INFO, NUMBER_TYPE_ERROR_INFO, INFINITY_NUMBER_ERROR_INFO, } from './number';
-export { boolean, BOOLEAN_TYPE_ERROR_INFO } from './boolean';
-export { array, ARRAY_TYPE_ERROR_INFO } from './array';
+export { any } from './any';
+export { ARRAY_TYPE_ERROR_INFO, array } from './array';
 export { arrayItem } from './arrayItem';
+export { BOOLEAN_TYPE_ERROR_INFO, boolean } from './boolean';
+export { CONTAINS_DIFFERENT_CASES_ERROR_CODE, containsDifferentCases, } from './containsDifferentCases';
+export { CONTAINS_NUMBERS_ERROR_CODE, containsNumbers, } from './containsNumbers';
+export { CONTAINS_PUNCTUATION_MARKS_ERROR_CODE, containsPunctuationMarks, } from './containsPunctuationMarks';
+export { createRule, REQUIRED_ERROR_INFO, type ValidationRule } from './core';
+export { DATE_TYPE_ERROR_INFO, date, INVALID_DATE_ERROR_INFO } from './date';
 export { deepPartial } from './deepPartial';
-export { partial } from './partial';
-export { minYearsOld, BIRTH_DATE_MIN_ERROR_CODE, BIRTH_DATE_MAX_ERROR_CODE, } from './minYearsOld';
-export { min, STRING_MIN_ERROR_CODE, ARRAY_MIN_ERROR_CODE, DATE_MIN_ERROR_CODE, NUMBER_MIN_ERROR_CODE, } from './min';
-export { max, STRING_MAX_ERROR_CODE, ARRAY_MAX_ERROR_CODE, DATE_MAX_ERROR_CODE, NUMBER_MAX_ERROR_CODE, } from './max';
-export { integer, INTEGER_ERROR_INFO } from './integer';
-export { positiveNumber, POSITIVE_NUMBER_ERROR_INFO } from './positiveNumber';
-export { or } from './or';
-export { pattern, PATTERN_ERROR_CODE } from './pattern';
-export { onlyNumber, ONLY_NUMBER_ERROR_CODE } from './onlyNumber';
-export { containsNumbers, CONTAINS_NUMBERS_ERROR_CODE, } from './containsNumbers';
-export { containsPunctuationMarks, CONTAINS_PUNCTUATION_MARKS_ERROR_CODE, } from './containsPunctuationMarks';
-export { containsDifferentCases, CONTAINS_DIFFERENT_CASES_ERROR_CODE, } from './containsDifferentCases';
-export { toPlainError } from './toPlainError';
-export { email, LENGTH_EMAIL_ERROR_INFO, INVALID_EMAIL_ERROR_INFO, } from './email';
-export { emailOrPhone, EMAIL_OR_PHONE_ERROR_INFO } from './emailOrPhone';
+export { email, INVALID_EMAIL_ERROR_INFO, LENGTH_EMAIL_ERROR_INFO, } from './email';
+export { EMAIL_OR_PHONE_ERROR_INFO, emailOrPhone } from './emailOrPhone';
+export { enabled } from './enabled';
 export { guid, INVALID_GUID_ERROR_INFO } from './guid';
+export { INN_FL_ERROR_INFO, innFL } from './innFL';
+export { INN_IP_ERROR_INFO, innIP } from './innIP';
+export { INN_12_SYMBOLS_ERROR_INFO, innTwelveSymbols, } from './innTwelveSymbols';
+export { INN_UL_ERROR_INFO, innUL } from './innUL';
+export { INTEGER_ERROR_INFO, integer } from './integer';
+export { INVALID_KPP_ERROR_INFO, KPP_DOUBLE_ZERO_START_ERROR_INFO, KPP_ZEROS_ONLY_ERROR_INFO, kpp, } from './kpp';
 export { length, STRING_LENGTH_ERROR_CODE } from './length';
-export { mobilePhone, MOBILE_PHONE_ERROR_INFO } from './mobilePhone';
-export { innUL, INN_UL_ERROR_INFO } from './innUL';
-export { innTwelveSymbols, INN_12_SYMBOLS_ERROR_INFO, } from './innTwelveSymbols';
-export { innIP, INN_IP_ERROR_INFO } from './innIP';
-export { innFL, INN_FL_ERROR_INFO } from './innFL';
-export { kpp, INVALID_KPP_ERROR_INFO, KPP_DOUBLE_ZERO_START_ERROR_INFO, KPP_ZEROS_ONLY_ERROR_INFO, } from './kpp';
-export { snils, SNILS_ERROR_INFO } from './snils';
-export { createRule, REQUIRED_ERROR_INFO, type ValidationRule } from './core';
-export { ogrnUL, OGRN_UL_ERROR_INFO } from './ogrnUL';
-export { ogrnIP, OGRN_IP_ERROR_INFO } from './ogrnIP';
-export { personName, PERSON_NAME_ERROR_INFO } from './personName';
-export { personSurname, PERSON_SURNAME_ERROR_INFO } from './personSurname';
-export { passportSeries, PASSPORT_SERIES_ERROR_INFO, PASSPORT_SERIES_ERROR_LENGTH_INFO, PASSPORT_SERIES_ONLY_DIGITS_ERROR_INFO, } from './passportSeries';
-export { passportNumber, PASSPORT_NUMBER_ERROR_INFO, PASSPORT_NUMBER_LENGTH_ERROR_INFO, PASSPORT_NUMBER_ONLY_DIGITS_ERROR_INFO, } from './passportNumber';
-export { passportCode, PASSPORT_CODE_ERROR_INFO, PASSPORT_CODE_LENGTH_ERROR_INFO, PASSPORT_CODE_ONLY_DIGITS_ERROR_INFO, } from './passportCode';
-export { personPatronymic, PERSON_PATRONYMIC_ERROR_INFO, } from './personPatronymic';
-export { any } from './any';
-export { when } from './when';
+export { ARRAY_MAX_ERROR_CODE, DATE_MAX_ERROR_CODE, max, NUMBER_MAX_ERROR_CODE, STRING_MAX_ERROR_CODE, } from './max';
+export { ARRAY_MIN_ERROR_CODE, DATE_MIN_ERROR_CODE, min, NUMBER_MIN_ERROR_CODE, STRING_MIN_ERROR_CODE, } from './min';
+export { BIRTH_DATE_MAX_ERROR_CODE, BIRTH_DATE_MIN_ERROR_CODE, minYearsOld, } from './minYearsOld';
+export { MOBILE_PHONE_ERROR_INFO, mobilePhone } from './mobilePhone';
+export { INFINITY_NUMBER_ERROR_INFO, NAN_NUMBER_ERROR_INFO, NUMBER_TYPE_ERROR_INFO, number, } from './number';
+export { OBJECT_TYPE_ERROR_INFO, type ObjectAsyncGuard, type ObjectGuard, object, objectAsync, type Schema, type SchemaValue, } from './object';
+export { OGRN_IP_ERROR_INFO, ogrnIP } from './ogrnIP';
+export { OGRN_UL_ERROR_INFO, ogrnUL } from './ogrnUL';
+export { ONLY_NUMBER_ERROR_CODE, onlyNumber } from './onlyNumber';
+export { optional, optionalAsync } from './optional';
+export { or } from './or';
+export { partial } from './partial';
+export { PASSPORT_CODE_ERROR_INFO, PASSPORT_CODE_LENGTH_ERROR_INFO, PASSPORT_CODE_ONLY_DIGITS_ERROR_INFO, passportCode, } from './passportCode';
+export { PASSPORT_NUMBER_ERROR_INFO, PASSPORT_NUMBER_LENGTH_ERROR_INFO, PASSPORT_NUMBER_ONLY_DIGITS_ERROR_INFO, passportNumber, } from './passportNumber';
+export { PASSPORT_SERIES_ERROR_INFO, PASSPORT_SERIES_ERROR_LENGTH_INFO, PASSPORT_SERIES_ONLY_DIGITS_ERROR_INFO, passportSeries, } from './passportSeries';
+export { PATTERN_ERROR_CODE, pattern } from './pattern';
+export { PERSON_NAME_ERROR_INFO, personName } from './personName';
+export { PERSON_PATRONYMIC_ERROR_INFO, personPatronymic, } from './personPatronymic';
+export { PERSON_SURNAME_ERROR_INFO, personSurname } from './personSurname';
+export { POSITIVE_NUMBER_ERROR_INFO, positiveNumber } from './positiveNumber';
+export { RANGE_DATE_END_EARLIER_START_ERROR_INFO, RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_END_REQUIRED_ERROR_INFO, RANGE_DATE_REQUIRED_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, RANGE_DATE_START_REQUIRED_ERROR_INFO, rangeDate, } from './rangeDate';
+export { RANGE_DATE_INTERVAL_ERROR_INFO, rangeDateInterval, } from './rangeDateInterval';
+export { RANGE_DATE_MAX_ERROR_INFO, RANGE_DATE_MIN_ERROR_INFO, rangeDateMinMax, } from './rangeDateMinMax';
+export { RANGE_DATE_NOT_EQUAL_ERROR_INFO, rangeDateNotEqual, } from './rangeDateNotEqual';
+export { SNILS_ERROR_INFO, snils } from './snils';
+export { STRING_TYPE_ERROR_INFO, string, stringAsync } from './string';
+export { INVALID_TEXT_FIELD_ERROR_INFO, LENGTH_TEXT_FIELD_ERROR_INFO, textField, } from './textField';
+export { toPlainError } from './toPlainError';
 export { toPrettyError } from './toPrettyError';
 export { transform } from './transform';
-export { enabled } from './enabled';
-export { rangeDate, RANGE_DATE_END_EARLIER_START_ERROR_INFO, RANGE_DATE_END_INVALID_ERROR_INFO, RANGE_DATE_END_REQUIRED_ERROR_INFO, RANGE_DATE_REQUIRED_ERROR_INFO, RANGE_DATE_START_INVALID_ERROR_INFO, RANGE_DATE_START_REQUIRED_ERROR_INFO, } from './rangeDate';
-export { rangeDateInterval, RANGE_DATE_INTERVAL_ERROR_INFO, } from './rangeDateInterval';
-export { rangeDateMinMax, RANGE_DATE_MAX_ERROR_INFO, RANGE_DATE_MIN_ERROR_INFO, } from './rangeDateMinMax';
-export { rangeDateNotEqual, RANGE_DATE_NOT_EQUAL_ERROR_INFO, } from './rangeDateNotEqual';
-export { uploadedFile, FILE_UPLOAD_ERROR_INFO, FILE_LOADING_ERROR_INFO, FILE_REQUIRED_ERROR_INFO, FILE_RESTRICTION_ERROR_INFO, } from './uploadedFile';
-export { uploadedFileList, FILE_LIST_NOT_ARRAY_ERROR_INFO, } from './uploadedFileList';
+export { FILE_LOADING_ERROR_INFO, FILE_REQUIRED_ERROR_INFO, FILE_RESTRICTION_ERROR_INFO, FILE_UPLOAD_ERROR_INFO, uploadedFile, } from './uploadedFile';
+export { FILE_LIST_NOT_ARRAY_ERROR_INFO, uploadedFileList, } from './uploadedFileList';
+export { when } from './when';