@reformer/core 1.1.0 → 2.0.0-beta.3

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

@@ -1,298 +0,0 @@
-/**
- * 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.js

@@ -1,86 +0,0 @@
-/**
- * Валидаторы для массивов
- *
- * Предоставляет специализированные функции для валидации 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.js

@@ -1,117 +0,0 @@
-/**
- * Валидатор даты
- *
- * @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.js

@@ -1,60 +0,0 @@
-/**
- * Валидатор формата email
- *
- * @group Validation
- * @category Validators
- * @module validators/email
- */
-import { validate } from '../core/validate';
-/**
- * Валидатор формата 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 function email(fieldPath, options) {
-    if (!fieldPath)
-        return; // Защита от undefined fieldPath
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    validate(fieldPath, (value) => {
-        if (!value) {
-            return null;
-        }
-        if (!emailRegex.test(value)) {
-            return {
-                code: 'email',
-                message: options?.message || 'Неверный формат email',
-                params: options?.params,
-            };
-        }
-        return null;
-    });
-}

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

@@ -1,14 +0,0 @@
-/**
- * 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 } from './phone';
-export { number } from './number';
-export { date } from './date';

package/dist/core/validation/validators/max-length.js

@@ -1,60 +0,0 @@
-/**
- * Валидатор максимальной длины строки
- *
- * @group Validation
- * @category Validators
- * @module validators/maxLength
- */
-import { validate } from '../core/validate';
-/**
- * Валидатор максимальной длины строки
- *
- * Проверяет, что длина строки не превышает указанный максимум.
- * Пустые значения пропускаются (используйте `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 function maxLength(fieldPath, maxLen, options) {
-    if (!fieldPath)
-        return; // Защита от undefined fieldPath
-    validate(fieldPath, (value) => {
-        if (!value) {
-            return null;
-        }
-        if (value.length > maxLen) {
-            return {
-                code: 'maxLength',
-                message: options?.message || `Максимальная длина: ${maxLen} символов`,
-                params: { maxLength: maxLen, actualLength: value.length, ...options?.params },
-            };
-        }
-        return null;
-    });
-}