@reformer/core 1.0.0-beta.3

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

@@ -0,0 +1,217 @@
+/**
+ * Применение валидаторов к форме
+ *
+ * Извлечено из GroupNode для соблюдения SRP (Single Responsibility Principle).
+ * Отвечает только за логику применения валидаторов к полям формы.
+ *
+ * @template T Тип формы
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly validationApplicator = new ValidationApplicator(this);
+ *
+ *   async applyContextualValidators(validators: ValidatorRegistration[]) {
+ *     await this.validationApplicator.apply(validators);
+ *   }
+ * }
+ * ```
+ */
+import { ValidationContextImpl, TreeValidationContextImpl } from './validation-context';
+import { isFieldNode } from '../utils/type-guards';
+import { FormErrorHandler, ErrorStrategy } from '../utils/error-handler';
+/**
+ * Класс для применения валидаторов к форме
+ *
+ * Выполняет:
+ * - Группировку валидаторов по полям
+ * - Фильтрацию по условиям (condition)
+ * - Применение sync/async валидаторов к FieldNode
+ * - Применение tree валидаторов (кросс-полевая валидация)
+ *
+ * @template T Тип формы (объект)
+ */
+export class ValidationApplicator {
+    form;
+    constructor(form) {
+        this.form = form;
+    }
+    /**
+     * Применить валидаторы к полям формы
+     *
+     * Этапы применения:
+     * 1. Разделение валидаторов на field и tree
+     * 2. Применение field валидаторов (sync/async)
+     * 3. Применение tree валидаторов (кросс-полевая валидация)
+     *
+     * @param validators Зарегистрированные валидаторы
+     */
+    async apply(validators) {
+        // 1. Группировка валидаторов
+        const { validatorsByField, treeValidators } = this.groupValidators(validators);
+        // 2. Применение field валидаторов
+        await this.applyFieldValidators(validatorsByField);
+        // 3. Применение tree валидаторов
+        this.applyTreeValidators(treeValidators);
+    }
+    /**
+     * Группировка валидаторов по типам
+     *
+     * Разделяет валидаторы на:
+     * - Field validators (sync/async) - группируются по fieldPath
+     * - Tree validators - применяются ко всей форме
+     *
+     * @param validators Все зарегистрированные валидаторы
+     * @returns Сгруппированные валидаторы
+     */
+    groupValidators(validators) {
+        const validatorsByField = new Map();
+        const treeValidators = [];
+        for (const registration of validators) {
+            if (registration.type === 'tree') {
+                treeValidators.push(registration);
+            }
+            else {
+                const existing = validatorsByField.get(registration.fieldPath) || [];
+                existing.push(registration);
+                validatorsByField.set(registration.fieldPath, existing);
+            }
+        }
+        return { validatorsByField, treeValidators };
+    }
+    /**
+     * Применение field валидаторов к полям
+     *
+     * Для каждого поля:
+     * 1. Найти FieldNode по пути
+     * 2. Проверить условия (condition)
+     * 3. Выполнить sync/async валидаторы
+     * 4. Установить ошибки на поле
+     *
+     * @param validatorsByField Валидаторы, сгруппированные по полям
+     */
+    async applyFieldValidators(validatorsByField) {
+        for (const [fieldPath, fieldValidators] of validatorsByField) {
+            // Поддержка вложенных путей (например, "personalData.lastName")
+            const control = this.form.getFieldByPath(fieldPath);
+            if (!control) {
+                if (import.meta.env.DEV) {
+                    throw new Error(`Field "${fieldPath}" not found in GroupNode`);
+                }
+                console.warn(`Field ${fieldPath} not found in GroupNode`);
+                continue;
+            }
+            // Валидация работает только с FieldNode
+            if (!isFieldNode(control)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    console.warn(`Validation can only run on FieldNode, skipping ${fieldPath}`);
+                }
+                continue;
+            }
+            const errors = [];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const context = new ValidationContextImpl(this.form, fieldPath, control);
+            // Выполнение валидаторов с учетом условий
+            for (const registration of fieldValidators) {
+                // Проверка условия (condition)
+                if (registration.condition) {
+                    const shouldApply = this.checkCondition(registration.condition);
+                    if (!shouldApply) {
+                        continue;
+                    }
+                }
+                // Выполнение валидатора
+                // Новый паттерн: (value, ctx) => ValidationError | null
+                try {
+                    let error = null;
+                    const value = context.value();
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const validator = registration.validator;
+                    if (registration.type === 'sync') {
+                        error = validator(value, context);
+                    }
+                    else if (registration.type === 'async') {
+                        error = await validator(value, context);
+                    }
+                    if (error) {
+                        errors.push(error);
+                    }
+                }
+                catch (e) {
+                    FormErrorHandler.handle(e, `ValidationApplicator: validator for ${fieldPath}`, ErrorStrategy.LOG);
+                }
+            }
+            // Установка ошибок на поле
+            if (errors.length > 0) {
+                control.setErrors(errors);
+            }
+            else {
+                // Очистить ошибки, если они были contextual
+                if (control.errors.value.length > 0 &&
+                    !control.errors.value.some((e) => e.code !== 'contextual')) {
+                    control.clearErrors();
+                }
+            }
+        }
+    }
+    /**
+     * Применение tree валидаторов (кросс-полевая валидация)
+     *
+     * Tree валидаторы имеют доступ ко всей форме через TreeValidationContext.
+     * Ошибки устанавливаются на targetField (если указано).
+     *
+     * @param treeValidators Список tree валидаторов
+     */
+    applyTreeValidators(treeValidators) {
+        for (const registration of treeValidators) {
+            const context = new TreeValidationContextImpl(this.form);
+            // Проверка условия (condition)
+            if (registration.condition) {
+                const shouldApply = this.checkCondition(registration.condition);
+                if (!shouldApply) {
+                    continue;
+                }
+            }
+            // Выполнение tree валидатора
+            try {
+                // Tree валидаторы должны использовать TreeValidatorFn
+                if (registration.type !== 'tree') {
+                    continue;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const error = registration.validator(context);
+                if (error && registration.options && 'targetField' in registration.options) {
+                    const targetField = registration.options.targetField;
+                    if (targetField) {
+                        const targetControl = this.form.getFieldByPath(String(targetField));
+                        if (targetControl && isFieldNode(targetControl)) {
+                            const existingErrors = targetControl.errors.value;
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            targetControl.setErrors([...existingErrors, error]);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                FormErrorHandler.handle(e, 'ValidationApplicator: tree validator', ErrorStrategy.LOG);
+            }
+        }
+    }
+    /**
+     * Проверка условия (condition) для валидатора
+     *
+     * Условие определяет, должен ли валидатор выполняться.
+     * Использует getFieldByPath для поддержки вложенных путей.
+     *
+     * @param condition Условие валидатора
+     * @returns true, если условие выполнено
+     */
+    checkCondition(condition) {
+        const conditionField = this.form.getFieldByPath(condition.fieldPath);
+        if (!conditionField) {
+            return false;
+        }
+        const conditionValue = conditionField.value.value;
+        return condition.conditionFn(conditionValue);
+    }
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Реализация контекста валидации
+ */
+import type { GroupNode } from '../nodes/group-node';
+import type { FieldNode } from '../nodes/field-node';
+import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormContext } from '../types/form-context';
+/**
+ * Реализация контекста валидации для отдельного поля
+ * Реализует FormContext
+ */
+export declare class ValidationContextImpl<TForm, TField> implements FormContext<TForm> {
+    private _form;
+    private control;
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    readonly form: GroupNodeWithControls<TForm>;
+    constructor(form: GroupNode<TForm>, _fieldKey: keyof TForm, control: FieldNode<TField>);
+    /**
+     * Получить текущее значение поля (внутренний метод для validation-applicator)
+     * @internal
+     */
+    value(): TField;
+    /**
+     * Безопасно установить значение поля по строковому пути
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path: string, value: unknown): void;
+}
+/**
+ * Реализация контекста для cross-field валидации
+ * Реализует FormContext
+ */
+export declare class TreeValidationContextImpl<TForm> implements FormContext<TForm> {
+    private _form;
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    readonly form: GroupNodeWithControls<TForm>;
+    constructor(form: GroupNode<TForm>);
+    /**
+     * Безопасно установить значение поля по строковому пути
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path: string, value: unknown): void;
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Реализация контекста валидации
+ */
+import { isFormNode } from '../utils/type-guards';
+// ============================================================================
+// Field Validation Context (для обычных валидаторов)
+// ============================================================================
+/**
+ * Реализация контекста валидации для отдельного поля
+ * Реализует FormContext
+ */
+export class ValidationContextImpl {
+    _form;
+    control;
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    form;
+    constructor(form, _fieldKey, control) {
+        this._form = form;
+        this.control = control;
+        // Получаем Proxy для типизированного доступа
+        this.form = (form
+            ._proxyInstance || form.getProxy());
+    }
+    /**
+     * Получить текущее значение поля (внутренний метод для validation-applicator)
+     * @internal
+     */
+    value() {
+        return this.control.value.value;
+    }
+    /**
+     * Безопасно установить значение поля по строковому пути
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path, value) {
+        const node = this._form.getFieldByPath(path);
+        if (node && isFormNode(node)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node.setValue(value, { emitEvent: false });
+        }
+    }
+}
+// ============================================================================
+// Tree Validation Context (для cross-field валидаторов)
+// ============================================================================
+/**
+ * Реализация контекста для cross-field валидации
+ * Реализует FormContext
+ */
+export class TreeValidationContextImpl {
+    _form;
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    form;
+    constructor(form) {
+        this._form = form;
+        // Получаем Proxy для типизированного доступа
+        this.form = (form
+            ._proxyInstance || form.getProxy());
+    }
+    /**
+     * Безопасно установить значение поля по строковому пути
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path, value) {
+        const node = this._form.getFieldByPath(path);
+        if (node && isFormNode(node)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node.setValue(value, { emitEvent: false });
+        }
+    }
+}

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

@@ -0,0 +1,156 @@
+/**
+ * ValidationRegistry - система регистрации и применения валидаторов
+ *
+ * Работает как стек контекстов:
+ * 1. При вызове validation schema функции создается новый контекст
+ * 2. Все вызовы validate(), applyWhen() и т.д. регистрируют валидаторы в текущем контексте
+ * 3. После завершения схемы валидаторы применяются к GroupNode
+ */
+import type { GroupNode } from '../nodes/group-node';
+import { FormFields } from '../types';
+import type { ValidatorRegistration, ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions } from '../types/validation-schema';
+/**
+ * Контекст регистрации валидаторов
+ */
+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 и изолирует формы друг от друга.
+ *
+ * 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 declare class ValidationRegistry {
+    /**
+     * Global stack активных реестров
+     * Используется для изоляции форм друг от друга
+     */
+    private static registryStack;
+    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 для изоляции форм
+     */
+    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[];
+    /**
+     * Применить зарегистрированные валидаторы к GroupNode
+     * @private
+     */
+    private applyValidators;
+    /**
+     * Применить array-items validators к ArrayNode элементам
+     * @private
+     */
+    private applyArrayItemValidators;
+}
+export {};