@reformer/core 1.0.0-beta.1

package/dist/core/validation/validation-context.d.ts

@@ -0,0 +1,86 @@
+import { GroupNode } from '../nodes/group-node';
+import { FieldNode } from '../nodes/field-node';
+import { FormProxy } from '../types/form-proxy';
+import { FormContext } from '../types/form-context';
+/**
+ * Базовый класс контекста валидации
+ * Содержит общую логику для всех типов контекстов
+ * @internal
+ */
+declare abstract class BaseValidationContext<TForm> implements FormContext<TForm> {
+    protected readonly _form: GroupNode<TForm>;
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    readonly form: FormProxy<TForm>;
+    constructor(form: GroupNode<TForm>);
+    /**
+     * Безопасно установить значение поля по строковому пути
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path: string, value: unknown): void;
+    /**
+     * Получить поле формы по строковому пути
+     */
+    getFieldByPath(path: string): import('../..').FormNode<import('../types').FormValue> | undefined;
+}
+/**
+ * Контекст валидации одного поля. Создаётся фреймворком и передаётся в валидаторы
+ * (`required`, `validate`, …) — напрямую инстанцировать не нужно.
+ *
+ * @example
+ * ```typescript
+ * import { validate } from '@reformer/core/validators';
+ *
+ * validate(path.password, (value, ctx) => {
+ *   // ctx — экземпляр ValidationContextImpl, доступ к ctx.form для cross-field логики
+ *   if (value !== ctx.form.confirmPassword.value) {
+ *     return { code: 'mismatch', message: 'Пароли не совпадают' };
+ *   }
+ *   return null;
+ * });
+ * ```
+ */
+export declare class ValidationContextImpl<TForm, TField> extends BaseValidationContext<TForm> {
+    private control;
+    constructor(form: GroupNode<TForm>, _fieldKey: keyof TForm, control: FieldNode<TField>);
+    /**
+     * Получить текущее значение поля (внутренний метод для validation-applicator)
+     * @internal
+     */
+    value(): TField;
+}
+/**
+ * Контекст cross-field валидации. Передаётся в `validateTree`/`validateForm`
+ * callback'и — напрямую инстанцировать не нужно.
+ *
+ * @example
+ * ```typescript
+ * import { validateForm } from '@reformer/core';
+ *
+ * validateForm(form, (ctx) => {
+ *   // ctx — экземпляр TreeValidationContextImpl
+ *   if (ctx.form.startDate.value > ctx.form.endDate.value) {
+ *     return [{ code: 'date-range', message: 'Дата начала позже даты окончания' }];
+ *   }
+ *   return [];
+ * });
+ * ```
+ */
+export declare class TreeValidationContextImpl<TForm> extends BaseValidationContext<TForm> {
+    constructor(form: GroupNode<TForm>);
+}
+/**
+ * Контекст валидации для ArrayNode
+ * Предоставляет доступ к значению массива
+ */
+export declare class ArrayValidationContextImpl<TForm, TItem> extends BaseValidationContext<TForm> {
+    private arrayValue;
+    constructor(form: GroupNode<TForm>, _fieldKey: keyof TForm, arrayValue: TItem[]);
+    /**
+     * Получить текущее значение массива (для валидатора)
+     * @internal
+     */
+    value(): TItem[];
+}
+export {};

package/dist/core/validation/validation-registry.d.ts

@@ -0,0 +1,142 @@
+import { GroupNode } from '../nodes/group-node';
+import { FormFields } from '../types';
+import { AbstractRegistry } from '../utils/abstract-registry';
+import { ValidatorRegistration, ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions } from '../types/validation-schema';
+/**
+ * Контекст регистрации валидаторов
+ * Управляет condition stack для условных валидаторов
+ */
+declare class RegistrationContext {
+    private validators;
+    private conditionStack;
+    /**
+     * Добавить валидатор в контекст
+     */
+    addValidator(registration: ValidatorRegistration): void;
+    /**
+     * Войти в условный блок
+     */
+    enterCondition(fieldPath: string, conditionFn: ConditionFn<unknown>): void;
+    /**
+     * Выйти из условного блока
+     */
+    exitCondition(): void;
+    /**
+     * Получить все зарегистрированные валидаторы
+     */
+    getValidators(): ValidatorRegistration[];
+}
+/**
+ * Реестр валидаторов для формы
+ *
+ * Каждый экземпляр GroupNode создает собственный реестр (композиция).
+ * Устраняет race conditions и изолирует формы друг от друга.
+ *
+ * Наследует AbstractRegistry для унификации:
+ * - Управления global stack
+ * - Template methods begin/end registration
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly validationRegistry = new ValidationRegistry();
+ *
+ *   applyValidationSchema(schemaFn) {
+ *     this.validationRegistry.beginRegistration(); // Pushes this to global stack
+ *     schemaFn(createFieldPath(this));             // Uses getCurrent()
+ *     this.validationRegistry.endRegistration(this); // Pops from global stack
+ *   }
+ * }
+ * ```
+ */
+export declare class ValidationRegistry extends AbstractRegistry<ValidatorRegistration> {
+    /** Внутренний стек контекстов для управления condition blocks */
+    private contextStack;
+    /** Финальные валидаторы после завершения регистрации */
+    private validators;
+    /**
+     * Получить текущий активный реестр из global stack
+     *
+     * @returns Текущий активный реестр или null
+     *
+     * @example
+     * ```typescript
+     * // В schema-validators.ts
+     * export function required(...) {
+     *   const registry = ValidationRegistry.getCurrent();
+     *   if (registry) {
+     *     registry.registerSync(...);
+     *   }
+     * }
+     * ```
+     */
+    static getCurrent(): ValidationRegistry | null;
+    /**
+     * Начать регистрацию валидаторов для формы
+     *
+     * Помещает this в global stack для изоляции форм
+     * Создает новый RegistrationContext для condition management
+     */
+    beginRegistration(): RegistrationContext;
+    /**
+     * Завершить регистрацию и применить валидаторы к GroupNode
+     *
+     * Извлекает this из global stack
+     *
+     * Сохраняет валидаторы в локальном состоянии (this.validators) вместо глобального WeakMap.
+     */
+    endRegistration<T extends FormFields>(form: GroupNode<T>): void;
+    /**
+     * Отменить регистрацию без применения валидаторов
+     * Используется для временной валидации (например, в validateForm)
+     *
+     * Извлекает this из global stack
+     */
+    cancelRegistration(): void;
+    /**
+     * Получить текущий контекст регистрации
+     */
+    getCurrentContext(): RegistrationContext | undefined;
+    /**
+     * Зарегистрировать синхронный валидатор
+     */
+    registerSync<TForm = unknown, TField = unknown>(fieldPath: string, validator: ContextualValidatorFn<TForm, TField>, options?: ValidateOptions): void;
+    /**
+     * Зарегистрировать асинхронный валидатор
+     */
+    registerAsync<TForm = unknown, TField = unknown>(fieldPath: string, validator: ContextualAsyncValidatorFn<TForm, TField>, options?: ValidateAsyncOptions): void;
+    /**
+     * Зарегистрировать tree валидатор
+     */
+    registerTree<TForm = unknown>(validator: TreeValidatorFn<TForm>, options?: ValidateTreeOptions): void;
+    /**
+     * Войти в условный блок
+     */
+    enterCondition(fieldPath: string, conditionFn: ConditionFn<unknown>): void;
+    /**
+     * Выйти из условного блока
+     */
+    exitCondition(): void;
+    /**
+     * Зарегистрировать validation schema для элементов массива
+     *
+     * Используется функцией validateItems() для регистрации схемы валидации,
+     * которая будет применяться к каждому элементу ArrayNode.
+     *
+     * @param fieldPath - Путь к ArrayNode полю
+     * @param itemSchemaFn - Validation schema для элемента массива
+     */
+    registerArrayItemValidation(fieldPath: string, itemSchemaFn: unknown): void;
+    /**
+     * Получить зарегистрированные валидаторы для этого реестра
+     *
+     * Возвращает локальный массив валидаторов (без аргумента form).
+     */
+    getValidators(): ValidatorRegistration[];
+    /**
+     * Применить array-items validators к ArrayNode элементам
+     * @private
+     */
+    private applyArrayItemValidators;
+}
+export {};

package/dist/core/validation/validators/array-validators.d.ts

@@ -0,0 +1,53 @@
+import { ValidateOptions, ValidationSchemaFn } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверить что массив содержит хотя бы один элемент
+ *
+ * Это удобный алиас для `minLength(field, 1)`, оптимизированный для массивов.
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Поле-массив для валидации
+ * @param options - Опции валидации (message, params и т.д.)
+ *
+ * @example
+ * ```typescript
+ * // Простая проверка
+ * notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
+ *
+ * // С дополнительными параметрами
+ * notEmpty(path.coBorrowers, {
+ *   message: 'Требуется хотя бы один созаемщик',
+ *   params: { minItems: 1 }
+ * });
+ * ```
+ */
+export declare function notEmpty<TForm, TItem>(fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined, options?: ValidateOptions): void;
+/**
+ * Применить validation schema к каждому элементу массива
+ *
+ * Регистрирует схему валидации, которая будет автоматически применяться
+ * к каждому элементу ArrayNode (как существующим, так и новым).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Поле-массив для валидации элементов
+ * @param itemSchemaFn - Validation schema для одного элемента
+ *
+ * @example
+ * ```typescript
+ * import { propertyValidation } from './property-validation';
+ *
+ * // В additionalValidation
+ * applyWhen(path.hasProperty, (value) => value === true, (path) => {
+ *   // Проверка что массив не пустой
+ *   notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
+ *
+ *   // Валидация каждого элемента
+ *   validateItems(path.properties, propertyValidation);
+ * });
+ * ```
+ */
+export declare function validateItems<TForm, TItem>(fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined, itemSchemaFn: ValidationSchemaFn<TItem>): void;

package/dist/core/validation/validators/date-utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Утилиты для работы с датами в валидаторах
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/date-utils
+ */
+/**
+ * Парсит значение в объект Date
+ *
+ * @param value - Значение для парсинга (Date, string или undefined)
+ * @returns Date объект или null если парсинг не удался
+ */
+export declare function parseDate(value: string | Date | null | undefined): Date | null;
+/**
+ * Возвращает сегодняшнюю дату с обнулённым временем
+ */
+export declare function getToday(): Date;
+/**
+ * Нормализует дату, обнуляя время
+ */
+export declare function normalizeDate(date: Date): Date;
+/**
+ * Вычисляет возраст на основе даты рождения
+ */
+export declare function calculateAge(birthDate: Date): number;

package/dist/core/validation/validators/email.d.ts

@@ -0,0 +1,37 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор формата email
+ *
+ * Проверяет, что значение соответствует формату email адреса.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   required(path.email),
+ *   email(path.email),
+ * ]
+ *
+ * // С кастомным сообщением
+ * email(path.email, { message: 'Введите корректный email адрес' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'email',
+ *   message: 'Неверный формат email',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function email<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/future-date.d.ts

@@ -0,0 +1,35 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата находится в будущем (не в прошлом)
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - дата события должна быть в будущем
+ * validationSchema: (path) => [
+ *   futureDate(path.eventDate),
+ * ]
+ *
+ * // С кастомным сообщением
+ * futureDate(path.appointmentDate, { message: 'Дата записи должна быть в будущем' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_past',
+ *   message: 'Дата не может быть в прошлом',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function futureDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Reusable validators
+ */
+export { required } from './required';
+export { min } from './min';
+export { max } from './max';
+export { minLength } from './min-length';
+export { maxLength } from './max-length';
+export { email } from './email';
+export { pattern } from './pattern';
+export { url } from './url';
+export { phone, type PhoneFormat } from './phone';
+export { number } from './number';
+export { isDate } from './is-date';
+export { minDate } from './min-date';
+export { maxDate } from './max-date';
+export { pastDate } from './past-date';
+export { futureDate } from './future-date';
+export { minAge } from './min-age';
+export { maxAge } from './max-age';

package/dist/core/validation/validators/is-date.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что значение является валидной датой
+ *
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   isDate(path.birthDate),
+ *   isDate(path.eventDate),
+ * ]
+ *
+ * // С кастомным сообщением
+ * isDate(path.birthDate, { message: 'Введите корректную дату' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_invalid',
+ *   message: 'Неверный формат даты',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function isDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-age.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что возраст (вычисленный из даты рождения) не больше указанного
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации (дата рождения)
+ * @param maxAgeValue - Максимально допустимый возраст в годах
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - максимум 65 лет
+ * validationSchema: (path) => [
+ *   maxAge(path.birthDate, 65),
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxAge(path.birthDate, 100, { message: 'Проверьте правильность даты рождения' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_max_age',
+ *   message: 'Максимальный возраст: 65 лет',
+ *   params: { maxAge: 65, currentAge: 70 }
+ * }
+ * ```
+ */
+export declare function maxAge<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxAgeValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-date.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата не позже указанной максимальной
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxDateValue - Максимально допустимая дата (включительно)
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   maxDate(path.birthDate, new Date()), // Не позже сегодня
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxDate(path.endDate, new Date('2025-12-31'), { message: 'Дата не может быть позже конца года' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_max',
+ *   message: 'Дата должна быть не позднее 31.12.2025',
+ *   params: { maxDate: Date }
+ * }
+ * ```
+ */
+export declare function maxDate<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxDateValue: Date, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-length.d.ts

@@ -0,0 +1,38 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор максимальной длины строки
+ *
+ * Проверяет, что длина строки не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxLen - Максимальная допустимая длина строки
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   maxLength(path.name, 50),
+ *   maxLength(path.bio, 500),
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxLength(path.bio, 500, { message: 'Максимум 500 символов' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'maxLength',
+ *   message: 'Максимальная длина: 500 символов',
+ *   params: { maxLength: 500, actualLength: 512 }
+ * }
+ * ```
+ */
+export declare function maxLength<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxLen: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max.d.ts

@@ -0,0 +1,38 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор максимального числового значения
+ *
+ * Проверяет, что числовое значение не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxValue - Максимально допустимое значение
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   max(path.quantity, 100),
+ *   max(path.discount, 50),
+ * ]
+ *
+ * // С кастомным сообщением
+ * max(path.quantity, 100, { message: 'Максимум 100 единиц' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'max',
+ *   message: 'Максимальное значение: 100',
+ *   params: { max: 100, actual: 150 }
+ * }
+ * ```
+ */
+export declare function max<TForm, TField extends number | null | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-age.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что возраст (вычисленный из даты рождения) не меньше указанного
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации (дата рождения)
+ * @param minAgeValue - Минимально допустимый возраст в годах
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - минимум 18 лет
+ * validationSchema: (path) => [
+ *   minAge(path.birthDate, 18),
+ * ]
+ *
+ * // С кастомным сообщением
+ * minAge(path.birthDate, 21, { message: 'Вам должно быть не менее 21 года' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_min_age',
+ *   message: 'Минимальный возраст: 18 лет',
+ *   params: { minAge: 18, currentAge: 16 }
+ * }
+ * ```
+ */
+export declare function minAge<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minAgeValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-date.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата не раньше указанной минимальной
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param minDateValue - Минимально допустимая дата (включительно)
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   minDate(path.eventDate, new Date('2024-01-01')),
+ * ]
+ *
+ * // С кастомным сообщением
+ * minDate(path.startDate, new Date(), { message: 'Дата должна быть не раньше сегодня' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_min',
+ *   message: 'Дата должна быть не ранее 01.01.2024',
+ *   params: { minDate: Date }
+ * }
+ * ```
+ */
+export declare function minDate<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minDateValue: Date, options?: ValidateOptions): void;