@reformer/core 5.0.0 → 6.0.0

package/dist/core/validation/core/apply.d.ts

@@ -1,52 +0,0 @@
-import { FieldPathNode, FieldPath } from '../../types';
-import { ValidationSchemaFn } from '../../types/validation-schema';
-/**
- * Применить validation схему к корневому path формы
- *
- * Используется для композиции схем на уровне всей формы.
- *
- * @group Validation
- * @category Core Functions
- *
- * @param path - Корневой FieldPath формы (весь объект путей)
- * @param validationSchema - Схема валидации
- *
- * @example
- * ```typescript
- * const creditApplicationValidation: ValidationSchemaFn<CreditApplicationForm> = (path) => {
- *   apply(path, basicInfoValidation);
- *   apply(path, contactInfoValidation);
- * };
- * ```
- */
-export declare function apply<TForm>(path: FieldPath<TForm>, validationSchema: ValidationSchemaFn<TForm>): void;
-/**
- * Применить validation схему к вложенному полю или полям
- *
- * Поддерживает:
- * - Одно поле или массив полей
- * - Одну схему или массив схем
- * - Все комбинации (поле + схема, поле + схемы, поля + схема, поля + схемы)
- *
- * @param fields - Одно поле или массив полей
- * @param validationSchemas - Одна схема или массив схем
- *
- * @example
- * ```typescript
- * // Одна схема к одному полю
- * apply(path.registrationAddress, addressValidation);
- *
- * // Одна схема к нескольким полям
- * apply([path.homeAddress, path.workAddress], addressValidation);
- *
- * // Несколько схем к одному полю
- * apply(path.email, [emailValidation, uniqueEmailValidation]);
- *
- * // Несколько схем к нескольким полям
- * apply(
- *   [path.email, path.confirmEmail],
- *   [emailValidation, matchValidation]
- * );
- * ```
- */
-export declare function apply<TForm, TField>(fields: FieldPathNode<TForm, TField> | Array<FieldPathNode<TForm, TField> | undefined> | undefined, validationSchemas: ValidationSchemaFn<TField> | Array<ValidationSchemaFn<TField>>): void;

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

@@ -1,8 +0,0 @@
-/**
- * Core validation functions
- */
-export { validate } from './validate';
-export { validateAsync } from './validate-async';
-export { validateTree } from './validate-tree';
-export { applyWhen } from './apply-when';
-export { apply } from './apply';

package/dist/core/validation/core/validate-async.d.ts

@@ -1,36 +0,0 @@
-import { ContextualAsyncValidatorFn, ValidateAsyncOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
-/**
- * Зарегистрировать асинхронный валидатор для поля
- *
- * @group Validation
- * @category Core Functions
- *
- * @example
- * ```typescript
- * validateAsync(
- *   path.inn,
- *   async (ctx: ValidationContext<TForm, TField>) => {
- *     const inn = ctx.value();
- *     if (!inn) return null;
- *
- *     const response = await fetch('/api/validate-inn', {
- *       method: 'POST',
- *       body: JSON.stringify({ inn }),
- *     });
- *
- *     const data = await response.json();
- *     if (!data.valid) {
- *       return {
- *         code: 'invalidInn',
- *         message: 'ИНН не найден в базе данных ФНС',
- *       };
- *     }
- *
- *     return null;
- *   },
- *   { debounce: 1000 }
- * );
- * ```
- */
-export declare function validateAsync<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, validatorFn: ContextualAsyncValidatorFn<TForm, TField>, options?: ValidateAsyncOptions): void;

package/dist/core/validation/core/validate-tree.d.ts

@@ -1,35 +0,0 @@
-import { TreeValidatorFn, ValidateTreeOptions } from '../../types';
-/**
- * Зарегистрировать cross-field валидатор
- *
- * Используется для валидации, которая зависит от нескольких полей
- *
- * @group Validation
- * @category Core Functions
- *
- * @remarks
- * Параметр `ctx` в callback требует явной типизации для корректного вывода типов:
- * ```typescript
- * validateTree((ctx: { form: MyFormType }) => { ... });
- * ```
- *
- * @example
- * ```typescript
- * // Явная типизация ctx для избежания implicit any
- * validateTree(
- *   (ctx: { form: MyForm }) => {
- *     if (ctx.form.initialPayment && ctx.form.propertyValue) {
- *       if (ctx.form.initialPayment > ctx.form.propertyValue) {
- *         return {
- *           code: 'initialPaymentTooHigh',
- *           message: 'Первоначальный взнос не может превышать стоимость',
- *         };
- *       }
- *     }
- *     return null;
- *   },
- *   { targetField: 'initialPayment' }
- * );
- * ```
- */
-export declare function validateTree<TForm>(validatorFn: TreeValidatorFn<TForm>, options?: ValidateTreeOptions): void;

package/dist/core/validation/core/validate.d.ts

@@ -1,26 +0,0 @@
-import { ContextualValidatorFn, FieldPathNode, ValidateOptions } from '../../types';
-/**
- * Зарегистрировать кастомный синхронный валидатор для поля
- * Поддерживает опциональные поля
- *
- * @group Validation
- * @category Core Functions
- *
- * @example
- * ```typescript
- * validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
- *   const birthDate = new Date(ctx.value());
- *   const age = calculateAge(birthDate);
- *
- *   if (age < 18) {
- *     return {
- *       code: 'tooYoung',
- *       message: 'Заемщику должно быть не менее 18 лет',
- *     };
- *   }
- *
- *   return null;
- * });
- * ```
- */
-export declare function validate<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, validatorFn: ContextualValidatorFn<TForm, TField>, options?: ValidateOptions): void;

package/dist/core/validation/validate-form.d.ts

@@ -1,48 +0,0 @@
-import { GroupNode } from '../nodes/group-node';
-import { ValidationSchemaFn, FormFields } from '../types';
-/**
- * Валидировать форму в соответствии с указанной схемой
- *
- * Функция создает временный контекст валидации, применяет валидаторы
- * из схемы и очищает контекст без сохранения в реестр.
- *
- * @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 declare function validateForm<T extends FormFields>(form: GroupNode<T>, schema: ValidationSchemaFn<T>): Promise<boolean>;

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

@@ -1,70 +0,0 @@
-import { GroupNode } from '../nodes/group-node';
-import { ValidatorRegistration } from '../types';
-/**
- * Класс для применения валидаторов к форме
- *
- * Выполняет:
- * - Группировку валидаторов по полям
- * - Фильтрацию по условиям (condition)
- * - Применение sync/async валидаторов к FieldNode
- * - Применение tree валидаторов (кросс-полевая валидация)
- *
- * @template T Тип формы (объект)
- */
-export declare class ValidationApplicator<T> {
-    private readonly form;
-    constructor(form: GroupNode<T>);
-    /**
-     * Применить валидаторы к полям формы
-     *
-     * Этапы применения:
-     * 1. Разделение валидаторов на field и tree
-     * 2. Применение field валидаторов (sync/async)
-     * 3. Применение tree валидаторов (кросс-полевая валидация)
-     *
-     * @param validators Зарегистрированные валидаторы
-     */
-    apply(validators: ValidatorRegistration[]): Promise<void>;
-    /**
-     * Группировка валидаторов по типам
-     *
-     * Разделяет валидаторы на:
-     * - Field validators (sync/async) - группируются по fieldPath
-     * - Tree validators - применяются ко всей форме
-     *
-     * @param validators Все зарегистрированные валидаторы
-     * @returns Сгруппированные валидаторы
-     */
-    private groupValidators;
-    /**
-     * Применение field валидаторов к полям
-     *
-     * Для каждого поля:
-     * 1. Найти FieldNode по пути
-     * 2. Проверить условия (condition)
-     * 3. Выполнить sync/async валидаторы
-     * 4. Установить ошибки на поле
-     *
-     * @param validatorsByField Валидаторы, сгруппированные по полям
-     */
-    private applyFieldValidators;
-    /**
-     * Применение tree валидаторов (кросс-полевая валидация)
-     *
-     * Tree валидаторы имеют доступ ко всей форме через TreeValidationContext.
-     * Ошибки устанавливаются на targetField (если указано).
-     *
-     * @param treeValidators Список tree валидаторов
-     */
-    private applyTreeValidators;
-    /**
-     * Проверка условия (condition) для валидатора
-     *
-     * Условие определяет, должен ли валидатор выполняться.
-     * Использует getFieldByPath для поддержки вложенных путей.
-     *
-     * @param condition Условие валидатора
-     * @returns true, если условие выполнено
-     */
-    private checkCondition;
-}

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

@@ -1,86 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/number.d.ts

@@ -1,31 +0,0 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
-/**
- * Адаптер для number валидатора
- * Проверяет, что значение является числом и соответствует заданным ограничениям
- *
- * @group Validation
- * @category Validators
- *
- * @example
- * ```typescript
- * number(path.age);
- * number(path.price, { min: 0, max: 1000000 });
- * number(path.percentage, { min: 0, max: 100, integer: true });
- * number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
- * ```
- */
-export declare function number<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
-    /** Минимальное значение (включительно) */
-    min?: number;
-    /** Максимальное значение (включительно) */
-    max?: number;
-    /** Требовать целое число */
-    integer?: boolean;
-    /** Значение должно быть кратно этому числу */
-    multipleOf?: number;
-    /** Разрешить отрицательные числа (по умолчанию true) */
-    allowNegative?: boolean;
-    /** Разрешить ноль (по умолчанию true) */
-    allowZero?: boolean;
-}): void;

package/dist/field-path-DuKdGcIE.js

@@ -1,66 +0,0 @@
-function c() {
-  return _("");
-}
-function _(t) {
-  return new Proxy({}, {
-    get(r, i) {
-      if (typeof i == "symbol")
-        return;
-      if (i === "__path" || i === "__fieldPath")
-        return t || i;
-      if (i === "__key") {
-        const n = t.split(".");
-        return n[n.length - 1] || i;
-      }
-      if (i === "then" || i === "catch" || i === "finally" || i === "constructor" || i === "toString" || i === "valueOf" || i === "toJSON")
-        return;
-      const f = t ? `${t}.${i}` : i, a = {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        __key: i,
-        __path: f,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        __formType: void 0,
-        __fieldType: void 0
-      };
-      return new Proxy(a, {
-        get(n, e) {
-          if (typeof e != "symbol") {
-            if (e === "__path" || e === "__fieldPath") return f;
-            if (e === "__key") return i;
-            if (e !== "__formType" && e !== "__fieldType" && !(e === "then" || e === "catch" || e === "finally" || e === "constructor" || e === "toString" || e === "valueOf" || e === "toJSON"))
-              return _(`${f}.${e}`);
-          }
-        }
-      });
-    }
-  });
-}
-function u(t) {
-  if (typeof t == "string")
-    return t;
-  if (t && typeof t == "object") {
-    const r = t.__path;
-    if (typeof r == "string")
-      return r;
-  }
-  throw new Error("Invalid field path node: " + JSON.stringify(t));
-}
-function y(t) {
-  const r = u(t);
-  return _(r);
-}
-function l(t) {
-  if (t && typeof t == "object" && "__key" in t)
-    return t.__key;
-  if (typeof t == "string") {
-    const r = t.split(".");
-    return r[r.length - 1];
-  }
-  throw new Error("Invalid field path node");
-}
-export {
-  l as a,
-  c,
-  u as e,
-  y as t
-};