@reformer/core 1.0.0-beta.3

package/dist/core/validation/validation-registry.js

@@ -0,0 +1,298 @@
+/**
+ * ValidationRegistry - система регистрации и применения валидаторов
+ *
+ * Работает как стек контекстов:
+ * 1. При вызове validation schema функции создается новый контекст
+ * 2. Все вызовы validate(), applyWhen() и т.д. регистрируют валидаторы в текущем контексте
+ * 3. После завершения схемы валидаторы применяются к GroupNode
+ */
+import { RegistryStack } from '../utils/registry-stack';
+/**
+ * Контекст регистрации валидаторов
+ */
+class RegistrationContext {
+    validators = [];
+    conditionStack = [];
+    /**
+     * Добавить валидатор в контекст
+     */
+    addValidator(registration) {
+        // Если есть активные условия, добавляем их к валидатору
+        if (this.conditionStack.length > 0) {
+            const condition = this.conditionStack[this.conditionStack.length - 1];
+            registration.condition = condition;
+        }
+        this.validators.push(registration);
+    }
+    /**
+     * Войти в условный блок
+     */
+    enterCondition(fieldPath, conditionFn) {
+        this.conditionStack.push({ fieldPath, conditionFn });
+    }
+    /**
+     * Выйти из условного блока
+     */
+    exitCondition() {
+        this.conditionStack.pop();
+    }
+    /**
+     * Получить все зарегистрированные валидаторы
+     */
+    getValidators() {
+        return this.validators;
+    }
+}
+/**
+ * Реестр валидаторов для формы
+ *
+ * Каждый экземпляр GroupNode создает собственный реестр (композиция).
+ * Устраняет race conditions и изолирует формы друг от друга.
+ *
+ * Context stack используется для tracking текущего активного реестра:
+ * - beginRegistration() помещает this в global stack
+ * - endRegistration() извлекает из global stack
+ * - getCurrent() возвращает текущий активный реестр
+ *
+ * @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 class ValidationRegistry {
+    /**
+     * Global stack активных реестров
+     * Используется для изоляции форм друг от друга
+     */
+    static registryStack = new RegistryStack();
+    contextStack = [];
+    validators = [];
+    /**
+     * Получить текущий активный реестр из global stack
+     *
+     * @returns Текущий активный реестр или null
+     *
+     * @example
+     * ```typescript
+     * // В schema-validators.ts
+     * export function required(...) {
+     *   const registry = ValidationRegistry.getCurrent();
+     *   if (registry) {
+     *     registry.registerSync(...);
+     *   }
+     * }
+     * ```
+     */
+    static getCurrent() {
+        return ValidationRegistry.registryStack.getCurrent();
+    }
+    /**
+     * Начать регистрацию валидаторов для формы
+     *
+     * Помещает this в global stack для изоляции форм
+     */
+    beginRegistration() {
+        const context = new RegistrationContext();
+        this.contextStack.push(context);
+        // Помещаем this в global stack для tracking текущего активного реестра
+        ValidationRegistry.registryStack.push(this);
+        return context;
+    }
+    /**
+     * Завершить регистрацию и применить валидаторы к GroupNode
+     *
+     * Извлекает this из global stack
+     *
+     * Сохраняет валидаторы в локальном состоянии (this.validators) вместо глобального WeakMap.
+     */
+    endRegistration(form) {
+        const context = this.contextStack.pop();
+        if (!context) {
+            throw new Error('No active registration context');
+        }
+        // Извлекаем из global stack с проверкой
+        ValidationRegistry.registryStack.verify(this, 'ValidationRegistry');
+        // Сохраняем валидаторы в локальном состоянии
+        this.validators = context.getValidators();
+        // Применяем валидаторы к полям
+        this.applyValidators(form, this.validators);
+        // Применяем array-items validators к ArrayNode элементам
+        this.applyArrayItemValidators(form, this.validators);
+    }
+    /**
+     * Отменить регистрацию без применения валидаторов
+     * Используется для временной валидации (например, в validateForm)
+     *
+     * Извлекает this из global stack
+     */
+    cancelRegistration() {
+        const context = this.contextStack.pop();
+        if (!context) {
+            throw new Error('No active registration context to cancel');
+        }
+        // Извлекаем из global stack с проверкой
+        ValidationRegistry.registryStack.verify(this, 'ValidationRegistry');
+        // Просто выбрасываем контекст без сохранения
+    }
+    /**
+     * Получить текущий контекст регистрации
+     */
+    getCurrentContext() {
+        return this.contextStack[this.contextStack.length - 1];
+    }
+    /**
+     * Зарегистрировать синхронный валидатор
+     */
+    registerSync(fieldPath, validator, options) {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('Validators can only be registered inside a validation schema function');
+        }
+        context.addValidator({
+            fieldPath,
+            type: 'sync',
+            validator: validator,
+            options,
+        });
+    }
+    /**
+     * Зарегистрировать асинхронный валидатор
+     */
+    registerAsync(fieldPath, validator, options) {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('Validators can only be registered inside a validation schema function');
+        }
+        context.addValidator({
+            fieldPath,
+            type: 'async',
+            validator: validator,
+            options,
+        });
+    }
+    /**
+     * Зарегистрировать tree валидатор
+     */
+    registerTree(validator, options) {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('Validators can only be registered inside a validation schema function');
+        }
+        context.addValidator({
+            fieldPath: options?.targetField || '__tree__',
+            type: 'tree',
+            validator: validator,
+            options,
+        });
+    }
+    /**
+     * Войти в условный блок
+     */
+    enterCondition(fieldPath, conditionFn) {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('Conditions can only be used inside a validation schema function');
+        }
+        context.enterCondition(fieldPath, conditionFn);
+    }
+    /**
+     * Выйти из условного блока
+     */
+    exitCondition() {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('No active condition');
+        }
+        context.exitCondition();
+    }
+    /**
+     * Зарегистрировать validation schema для элементов массива
+     *
+     * Используется функцией validateItems() для регистрации схемы валидации,
+     * которая будет применяться к каждому элементу ArrayNode.
+     *
+     * @param fieldPath - Путь к ArrayNode полю
+     * @param itemSchemaFn - Validation schema для элемента массива
+     */
+    registerArrayItemValidation(fieldPath, itemSchemaFn // ValidationSchemaFn<TItem>
+    ) {
+        const context = this.getCurrentContext();
+        if (!context) {
+            throw new Error('Array item validators can only be registered inside a validation schema function');
+        }
+        context.addValidator({
+            fieldPath,
+            type: 'array-items',
+            validator: itemSchemaFn,
+            options: {},
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+    }
+    /**
+     * Получить зарегистрированные валидаторы для этого реестра
+     *
+     * Возвращает локальный массив валидаторов (без аргумента form).
+     */
+    getValidators() {
+        return this.validators;
+    }
+    /**
+     * Применить зарегистрированные валидаторы к GroupNode
+     * @private
+     */
+    applyValidators(form, validators) {
+        // Группируем валидаторы по полям
+        const validatorsByField = new Map();
+        for (const registration of validators) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (registration.type === 'tree' || registration.type === 'array-items') {
+                // Tree и array-items валидаторы обрабатываются отдельно
+                continue;
+            }
+            const existing = validatorsByField.get(registration.fieldPath) || [];
+            existing.push(registration);
+            validatorsByField.set(registration.fieldPath, existing);
+        }
+        // Валидаторы сохранены в локальном массиве this.validators
+        // Они будут применяться при вызове GroupNode.validate()
+        if (import.meta.env.DEV) {
+            console.log(`Registered ${validators.length} validators for GroupNode`);
+        }
+    }
+    /**
+     * Применить array-items validators к ArrayNode элементам
+     * @private
+     */
+    applyArrayItemValidators(form, validators) {
+        // Фильтруем array-items validators
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const arrayItemValidators = validators.filter((v) => v.type === 'array-items');
+        if (arrayItemValidators.length === 0) {
+            return;
+        }
+        // Применяем validation schema к каждому ArrayNode
+        for (const registration of arrayItemValidators) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const arrayNode = form[registration.fieldPath.split('.')[0]];
+            if (arrayNode && 'applyValidationSchema' in arrayNode) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const itemSchemaFn = registration.validator;
+                arrayNode.applyValidationSchema(itemSchemaFn);
+                if (import.meta.env.DEV) {
+                    console.log(`Applied validation schema to ArrayNode: ${registration.fieldPath}`);
+                }
+            }
+            else if (import.meta.env.DEV) {
+                console.warn(`Field ${registration.fieldPath} is not an ArrayNode or doesn't exist`);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Валидаторы для массивов
+ *
+ * Предоставляет специализированные функции для валидации ArrayNode:
+ * - notEmpty: проверка что массив не пустой
+ * - validateItems: применение validation schema к каждому элементу
+ *
+ * @group Validation
+ * @category Validators
+ */
+import type { ValidateOptions, ValidationSchemaFn } from '../../types/validation-schema';
+import type { 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/array-validators.js

@@ -0,0 +1,86 @@
+/**
+ * Валидаторы для массивов
+ *
+ * Предоставляет специализированные функции для валидации ArrayNode:
+ * - notEmpty: проверка что массив не пустой
+ * - validateItems: применение validation schema к каждому элементу
+ *
+ * @group Validation
+ * @category Validators
+ */
+import { getCurrentValidationRegistry } from '../../utils/registry-helpers';
+import { extractPath } from '../field-path';
+import { minLength } from './min-length';
+// ============================================================================
+// notEmpty - Проверка что массив не пустой
+// ============================================================================
+/**
+ * Проверить что массив содержит хотя бы один элемент
+ *
+ * Это удобный алиас для `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 function notEmpty(fieldPath, options) {
+    if (!fieldPath)
+        return;
+    // Используем minLength как базовую реализацию
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    minLength(fieldPath, 1, {
+        message: options?.message || 'Массив не должен быть пустым',
+        params: { minLength: 1, ...options?.params },
+    });
+}
+// ============================================================================
+// validateItems - Валидация элементов массива
+// ============================================================================
+/**
+ * Применить 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 function validateItems(fieldPath, itemSchemaFn) {
+    if (!fieldPath)
+        return;
+    const path = extractPath(fieldPath);
+    // Регистрируем схему валидации для элементов массива
+    //  Используем текущий активный реестр из context stack
+    getCurrentValidationRegistry().registerArrayItemValidation(path, itemSchemaFn);
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Валидатор даты
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/date
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Адаптер для date валидатора
+ * Проверяет, что значение является валидной датой и соответствует ограничениям
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * date(path.birthDate);
+ * date(path.birthDate, { maxDate: new Date() }); // Не позже сегодня
+ * date(path.eventDate, { minDate: new Date(), message: 'Дата не может быть в прошлом' });
+ * date(path.age, { minAge: 18, maxAge: 100 });
+ * ```
+ */
+export declare function date<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Минимальная дата (включительно) */
+    minDate?: Date;
+    /** Максимальная дата (включительно) */
+    maxDate?: Date;
+    /** Минимальный возраст (для дат рождения) */
+    minAge?: number;
+    /** Максимальный возраст (для дат рождения) */
+    maxAge?: number;
+    /** Не разрешать будущие даты */
+    noFuture?: boolean;
+    /** Не разрешать прошлые даты */
+    noPast?: boolean;
+}): void;

package/dist/core/validation/validators/date.js

@@ -0,0 +1,117 @@
+/**
+ * Валидатор даты
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/date
+ */
+import { validate } from '../core/validate';
+/**
+ * Адаптер для date валидатора
+ * Проверяет, что значение является валидной датой и соответствует ограничениям
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * date(path.birthDate);
+ * date(path.birthDate, { maxDate: new Date() }); // Не позже сегодня
+ * date(path.eventDate, { minDate: new Date(), message: 'Дата не может быть в прошлом' });
+ * date(path.age, { minAge: 18, maxAge: 100 });
+ * ```
+ */
+export function date(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        // Пропускаем null/undefined
+        if (!value) {
+            return null;
+        }
+        // Конвертируем в Date
+        let dateValue;
+        if (value instanceof Date) {
+            dateValue = value;
+        }
+        else if (typeof value === 'string') {
+            dateValue = new Date(value);
+        }
+        else {
+            return {
+                code: 'date_invalid',
+                message: options?.message || 'Неверный формат даты',
+                params: options?.params,
+            };
+        }
+        // Проверка на валидность даты
+        if (isNaN(dateValue.getTime())) {
+            return {
+                code: 'date_invalid',
+                message: options?.message || 'Неверный формат даты',
+                params: options?.params,
+            };
+        }
+        const now = new Date();
+        now.setHours(0, 0, 0, 0);
+        // Проверка минимальной даты
+        if (options?.minDate) {
+            const minDate = new Date(options.minDate);
+            minDate.setHours(0, 0, 0, 0);
+            if (dateValue < minDate) {
+                return {
+                    code: 'date_min',
+                    message: options?.message || `Дата должна быть не ранее ${minDate.toLocaleDateString()}`,
+                    params: { minDate: options.minDate, ...options?.params },
+                };
+            }
+        }
+        // Проверка максимальной даты
+        if (options?.maxDate) {
+            const maxDate = new Date(options.maxDate);
+            maxDate.setHours(0, 0, 0, 0);
+            if (dateValue > maxDate) {
+                return {
+                    code: 'date_max',
+                    message: options?.message || `Дата должна быть не позднее ${maxDate.toLocaleDateString()}`,
+                    params: { maxDate: options.maxDate, ...options?.params },
+                };
+            }
+        }
+        // Проверка на будущую дату
+        if (options?.noFuture && dateValue > now) {
+            return {
+                code: 'date_future',
+                message: options?.message || 'Дата не может быть в будущем',
+                params: options?.params,
+            };
+        }
+        // Проверка на прошлую дату
+        if (options?.noPast && dateValue < now) {
+            return {
+                code: 'date_past',
+                message: options?.message || 'Дата не может быть в прошлом',
+                params: options?.params,
+            };
+        }
+        // Проверка возраста
+        if (options?.minAge !== undefined || options?.maxAge !== undefined) {
+            const age = Math.floor((now.getTime() - dateValue.getTime()) / (365.25 * 24 * 60 * 60 * 1000));
+            if (options?.minAge !== undefined && age < options.minAge) {
+                return {
+                    code: 'date_min_age',
+                    message: options?.message || `Минимальный возраст: ${options.minAge} лет`,
+                    params: { minAge: options.minAge, currentAge: age, ...options?.params },
+                };
+            }
+            if (options?.maxAge !== undefined && age > options.maxAge) {
+                return {
+                    code: 'date_max_age',
+                    message: options?.message || `Максимальный возраст: ${options.maxAge} лет`,
+                    params: { maxAge: options.maxAge, currentAge: age, ...options?.params },
+                };
+            }
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Валидатор формата email
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/email
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { 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 | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;