@reformer/core 1.1.0 → 2.0.0-beta.3

package/dist/core/validation/field-path.js

@@ -1,147 +0,0 @@
-/**
- * FieldPath proxy - типобезопасный доступ к путям полей формы
- */
-/**
- * Создать FieldPath proxy для формы
- *
- * @example
- * ```typescript
- * const path = createFieldPath<MyForm>();
- * console.log(path.email.__path); // 'email'
- * console.log(path.personalData.firstName.__path); // 'personalData.firstName'
- * ```
- */
-export function createFieldPath() {
-    return createFieldPathProxy('');
-}
-/**
- * Внутренняя функция для создания прокси с отслеживанием пути
- * @private
- */
-function createFieldPathProxy(basePath) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop === 'symbol') {
-                return undefined;
-            }
-            // Специальные свойства для метаинформации
-            if (prop === '__path') {
-                return basePath || prop;
-            }
-            if (prop === '__key') {
-                const parts = basePath.split('.');
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return (parts[parts.length - 1] || prop);
-            }
-            // Игнорируем некоторые служебные свойства
-            if (prop === 'then' ||
-                prop === 'catch' ||
-                prop === 'finally' ||
-                prop === 'constructor' ||
-                prop === 'toString' ||
-                prop === 'valueOf' ||
-                prop === 'toJSON') {
-                return undefined;
-            }
-            // Создаем новый proxy для вложенного свойства
-            const newPath = basePath ? `${basePath}.${prop}` : prop;
-            // Возвращаем объект, который ведет себя и как значение, и как прокси
-            const node = {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                __key: prop,
-                __path: newPath,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                __formType: undefined,
-                __fieldType: undefined,
-            };
-            // Создаем прокси, который содержит и метаинформацию, и позволяет дальнейшую навигацию
-            return new Proxy(node, {
-                get(_nodeTarget, nodeProp) {
-                    if (typeof nodeProp === 'symbol') {
-                        return undefined;
-                    }
-                    // Если запрашивают метаинформацию, возвращаем её
-                    if (nodeProp === '__path')
-                        return newPath;
-                    if (nodeProp === '__key')
-                        return prop;
-                    if (nodeProp === '__formType')
-                        return undefined;
-                    if (nodeProp === '__fieldType')
-                        return undefined;
-                    // Игнорируем служебные свойства
-                    if (nodeProp === 'then' ||
-                        nodeProp === 'catch' ||
-                        nodeProp === 'finally' ||
-                        nodeProp === 'constructor' ||
-                        nodeProp === 'toString' ||
-                        nodeProp === 'valueOf' ||
-                        nodeProp === 'toJSON') {
-                        return undefined;
-                    }
-                    // Иначе создаем еще более вложенный proxy
-                    return createFieldPathProxy(`${newPath}.${nodeProp}`);
-                },
-            });
-        },
-    });
-}
-/**
- * Извлечь путь из FieldPathNode
- */
-export function extractPath(node) {
-    // Fallback для строк
-    if (typeof node === 'string') {
-        return node;
-    }
-    // Проверка для Proxy и обычных объектов
-    if (node && typeof node === 'object') {
-        // Пытаемся получить __path напрямую (работает для Proxy)
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const path = node.__path;
-        if (typeof path === 'string') {
-            return path;
-        }
-    }
-    throw new Error('Invalid field path node: ' + JSON.stringify(node));
-}
-/**
- * Преобразовать FieldPathNode в FieldPath для переиспользования схем
- *
- * Позволяет композировать validation schemas:
- *
- * @example
- * ```typescript
- * const personalDataValidation = (path: FieldPath<PersonalData>) => {
- *   required(path.firstName, { message: 'Имя обязательно' });
- *   required(path.lastName, { message: 'Фамилия обязательна' });
- * };
- *
- * const mainValidation = (path: FieldPath<MyForm>) => {
- *   //  Переиспользуем схему
- *   personalDataValidation(toFieldPath(path.personalData));
- *   required(path.email);
- * };
- * ```
- */
-export function toFieldPath(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-node) {
-    const basePath = extractPath(node);
-    return createFieldPathProxy(basePath);
-}
-/**
- * Извлечь ключ поля из FieldPathNode
- */
-export function extractKey(node) {
-    if (node && typeof node === 'object' && '__key' in node) {
-        return node.__key;
-    }
-    // Fallback для строк
-    if (typeof node === 'string') {
-        const parts = node.split('.');
-        return parts[parts.length - 1];
-    }
-    throw new Error('Invalid field path node');
-}

package/dist/core/validation/index.js

@@ -1,33 +0,0 @@
-// ============================================================================
-// Validation Schema API
-// ============================================================================
-// Core validation functions
-export { validate } from './core/validate';
-export { validateAsync } from './core/validate-async';
-export { validateTree } from './core/validate-tree';
-export { apply } from './core/apply';
-export { applyWhen } from './core/apply-when';
-// Reusable validators
-export { required } from './validators/required';
-export { min } from './validators/min';
-export { max } from './validators/max';
-export { minLength } from './validators/min-length';
-export { maxLength } from './validators/max-length';
-export { email } from './validators/email';
-export { pattern } from './validators/pattern';
-export { url } from './validators/url';
-export { phone } from './validators/phone';
-export { number } from './validators/number';
-export { date } from './validators/date';
-// Валидаторы для массивов
-export { notEmpty, validateItems } from './validators/array-validators';
-// Утилиты для FieldPath
-export { createFieldPath, extractPath, extractKey, toFieldPath } from './field-path';
-// Утилита для валидации формы по схеме
-export { validateForm } from './validate-form';
-// ValidationRegistry (для внутреннего использования)
-// Примечание: ValidationRegistry (глобальный singleton) был удален в пользу
-// локальных экземпляров ValidationRegistry в каждом GroupNode
-export { ValidationRegistry } from './validation-registry';
-// Контексты валидации
-export { ValidationContextImpl, TreeValidationContextImpl } from './validation-context';

package/dist/core/validation/validate-form.js

@@ -1,152 +0,0 @@
-/**
- * validateForm - утилита для валидации формы в соответствии со схемой
- *
- * Позволяет применить validation schema к форме без изменения
- * зарегистрированной схемы в ValidationRegistry.
- *
- * ## Использование
- *
- * - **Multi-step формы**: валидация только полей текущего шага
- * - **Условная валидация**: применение разных схем в зависимости от состояния
- * - **Временная валидация**: проверка без сохранения в реестр
- *
- * ## Как это работает
- *
- * 1. Создаётся временный ValidationRegistry для схемы
- * 2. Валидируются все FieldNode (field-level валидаторы из FieldConfig)
- * 3. Применяются ТОЛЬКО contextual validators из переданной схемы
- * 4. Временный реестр отменяется (не сохраняется в форму)
- *
- * ## Важно для multi-step форм
- *
- * Форма может быть создана С полной схемой валидации:
- * ```typescript
- * createForm({
- *   form: schema,
- *   validation: fullValidation, // Полная схема
- * });
- * ```
- *
- * При этом `validateForm(form, stepSchema)` будет применять
- * только валидаторы из `stepSchema`, игнорируя валидаторы
- * из других шагов.
- *
- * @see docs/multi-step-validation.md для подробной документации
- *
- * @module validation
- */
-import { GroupNode } from '../nodes/group-node';
-import { FieldNode } from '../nodes/field-node';
-import { ArrayNode } from '../nodes/array-node';
-import { ValidationRegistry } from './validation-registry';
-import { createFieldPath } from './field-path';
-/**
- * Рекурсивно собирает все FieldNode из дерева формы
- *
- * Пропускает GroupNode и ArrayNode как узлы, но обходит их детей.
- * Это необходимо для validateForm, чтобы избежать триггера
- * contextual validators из validationRegistry вложенных групп.
- *
- * @param node - Корневой узел для обхода
- * @returns Массив всех FieldNode в дереве
- */
-function collectAllFieldNodes(node) {
-    if (node instanceof FieldNode) {
-        return [node];
-    }
-    if (node instanceof GroupNode) {
-        return Array.from(node.getAllFields()).flatMap(collectAllFieldNodes);
-    }
-    if (node instanceof ArrayNode) {
-        // items приватный, используем публичный метод map()
-        return node.map((item) => collectAllFieldNodes(item)).flat();
-    }
-    return [];
-}
-/**
- * Валидировать форму в соответствии с указанной схемой
- *
- * Функция создает временный контекст валидации, применяет валидаторы
- * из схемы и очищает контекст без сохранения в реестр.
- *
- * @param form - GroupNode для валидации
- * @param schema - Схема валидации (ValidationSchemaFn)
- * @returns Promise<boolean> - `true` если форма валидна, `false` если есть ошибки
- *
- * @example Multi-step форма: валидация текущего шага
- * ```typescript
- * const goToNextStep = async () => {
- *   const isValid = await validateForm(form, step1LoanValidation);
- *
- *   if (!isValid) {
- *     form.markAsTouched(); // Показать ошибки
- *     return false;
- *   }
- *
- *   setCurrentStep(2);
- *   return true;
- * };
- * ```
- *
- * @example Полная валидация перед submit
- * ```typescript
- * const handleSubmit = async () => {
- *   const isValid = await validateForm(form, fullValidationSchema);
- *
- *   if (isValid) {
- *     await form.submit(onSubmit);
- *   }
- * };
- * ```
- *
- * @example Условная валидация
- * ```typescript
- * const schema = isBusinessAccount
- *   ? businessValidation
- *   : personalValidation;
- *
- * const isValid = await validateForm(form, schema);
- * ```
- */
-export async function validateForm(form, schema) {
-    //  Создаем временный реестр для этой валидации
-    // Это изолирует валидацию от других форм и не затрагивает постоянный реестр формы
-    const tempRegistry = new ValidationRegistry();
-    // Начинаем регистрацию валидаторов в временном реестре
-    tempRegistry.beginRegistration();
-    let tempValidators = [];
-    let cancelled = false;
-    try {
-        // Регистрируем валидаторы из схемы
-        // schema() будет использовать tempRegistry через getCurrent() из context stack
-        const path = createFieldPath();
-        schema(path);
-        // Получаем валидаторы БЕЗ сохранения в реестр
-        const context = tempRegistry.getCurrentContext();
-        tempValidators = context?.getValidators() || [];
-        // Отменяем регистрацию (не сохраняем в реестр формы)
-        tempRegistry.cancelRegistration();
-        cancelled = true;
-        // Очищаем текущие ошибки полей
-        form.clearErrors();
-        // Валидируем все FieldNode (field-level валидация)
-        // ВАЖНО: Используем collectAllFieldNodes вместо getAllFields,
-        // чтобы избежать вызова validate() на вложенных GroupNode/ArrayNode,
-        // которые триггерят свой validationRegistry с полной схемой валидации
-        const allFieldNodes = collectAllFieldNodes(form);
-        await Promise.all(allFieldNodes.map((field) => field.validate()));
-        // Применяем contextual validators
-        if (tempValidators.length > 0) {
-            await form.applyContextualValidators(tempValidators);
-        }
-        // Проверяем результат
-        return form.valid.value;
-    }
-    catch (error) {
-        // В случае ошибки отменяем регистрацию только если еще не отменили
-        if (!cancelled) {
-            tempRegistry.cancelRegistration();
-        }
-        throw error;
-    }
-}

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

@@ -1,217 +0,0 @@
-/**
- * Применение валидаторов к форме
- *
- * Извлечено из 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.js

@@ -1,75 +0,0 @@
-/**
- * Реализация контекста валидации
- */
-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 });
-        }
-    }
-}