@reformer/core 5.0.0 → 6.0.0

package/dist/core/behavior/types.d.ts

@@ -1,146 +0,0 @@
-import { GroupNode } from '../nodes/group-node';
-import { FieldPath } from '../types/field-path';
-import { FormContext } from '../types/form-context';
-/**
- * Тип функции behavior схемы
- * Принимает FieldPath и описывает поведение формы
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export type BehaviorSchemaFn<T> = (path: FieldPath<T>) => void;
-/**
- * Контекст для behavior callback функций
- * Алиас для FormContext
- *
- * @group Behaviors
- * @category Behavior Types
- *
- * @example
- * ```typescript
- * watchField(path.country, async (country, ctx) => {
- *   // Прямой типизированный доступ к полям
- *   const cities = await fetchCities(country);
- *   ctx.form.city.updateComponentProps({ options: cities });
- *
- *   // Безопасная установка значения (без циклов)
- *   ctx.setFieldValue('city', null);
- * });
- * ```
- */
-export type BehaviorContext<TForm> = FormContext<TForm>;
-/**
- * Функция-handler для behavior
- *
- * Создает effect подписку для реактивного поведения формы.
- *
- * @group Behaviors
- * @category Behavior Types
- *
- * @template TForm - Тип формы
- * @param form - Корневой узел формы (GroupNode)
- * @param context - Контекст для работы с формой
- * @param withDebounce - Функция-обертка для debounce
- * @returns Функция cleanup для отписки от effect или null
- *
- * @example
- * ```typescript
- * const handler: BehaviorHandlerFn<MyForm> = (form, context, withDebounce) => {
- *   const sourceNode = form.getFieldByPath('email');
- *
- *   return effect(() => {
- *     const value = sourceNode.value.value;
- *     withDebounce(() => {
- *       // Логика behavior
- *     });
- *   });
- * };
- * ```
- */
-export type BehaviorHandlerFn<TForm> = (form: GroupNode<TForm>, context: BehaviorContext<TForm>, withDebounce: (callback: () => void) => void) => (() => void) | null;
-/**
- * Общие опции для behavior
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface BehaviorOptions {
-    /** Debounce в миллисекундах */
-    debounce?: number;
-}
-/**
- * Опции для copyFrom
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface CopyFromOptions<TSource, TForm = unknown> {
-    /** Условие копирования */
-    when?: (form: TForm) => boolean;
-    /** Какие поля копировать (для групп) */
-    fields?: (keyof TSource)[] | 'all';
-    /** Трансформация значения */
-    transform?: (value: TSource) => unknown;
-    /** Debounce в мс */
-    debounce?: number;
-}
-/**
- * Опции для enableWhen/disableWhen
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface EnableWhenOptions {
-    /** Сбросить значение при disable */
-    resetOnDisable?: boolean;
-    /** Debounce в мс */
-    debounce?: number;
-}
-/**
- * Опции для computeFrom
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface ComputeFromOptions<TForm> {
-    /** Когда вычислять */
-    trigger?: 'change' | 'blur';
-    /** Debounce в мс */
-    debounce?: number;
-    /** Условие применения */
-    condition?: (form: TForm) => boolean;
-}
-/**
- * Опции для watchField
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface WatchFieldOptions {
-    /** Debounce в мс */
-    debounce?: number;
-    /** Вызвать сразу при инициализации */
-    immediate?: boolean;
-}
-/**
- * Опции для revalidateWhen
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface RevalidateWhenOptions {
-    /** Debounce в мс */
-    debounce?: number;
-}
-/**
- * Опции для syncFields
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface SyncFieldsOptions<T> {
-    /** Трансформация значения */
-    transform?: (value: T) => T;
-    /** Debounce в мс */
-    debounce?: number;
-}

package/dist/core/types/field-path.d.ts

@@ -1,42 +0,0 @@
-import { AnyFunction } from './index';
-/**
- * FieldPath предоставляет типобезопасный доступ к путям полей формы
- *
- * Рекурсивно обрабатывает вложенные объекты для поддержки вложенных форм.
- *
- * Использование:
- * ```typescript
- * const validation = (path: FieldPath<MyForm>) => {
- *   required(path.email, { message: 'Email обязателен' });
- *
- *   // Вложенные объекты
- *   required(path.registrationAddress.city);
- *   minLength(path.registrationAddress.street, 3);
- *
- *   applyWhen(
- *     path.loanType,
- *     (type) => type === 'mortgage',
- *     (path) => {
- *       required(path.propertyValue, { message: 'Укажите стоимость' });
- *     }
- *   );
- * };
- * ```
- */
-export type FieldPath<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends Array<unknown> ? FieldPathNode<T, T[K], K> : NonNullable<T[K]> extends Date | File | Blob | AnyFunction ? FieldPathNode<T, T[K], K> : NonNullable<T[K]> extends object ? FieldPathNode<T, T[K], K> & FieldPath<NonNullable<T[K]>> : FieldPathNode<T, T[K], K>;
-};
-/**
- * Узел в пути поля
- * Содержит метаинформацию о поле для валидации
- */
-export interface FieldPathNode<TForm, TField, TKey = unknown> {
-    /** Ключ поля */
-    readonly __key: TKey;
-    /** Путь к полю (для вложенных объектов) */
-    readonly __path: string;
-    /** Тип формы */
-    readonly __formType?: TForm;
-    /** Тип поля */
-    readonly __fieldType?: TField;
-}

package/dist/core/types/form-context.d.ts

@@ -1,89 +0,0 @@
-import { FormProxy } from './form-proxy';
-import { FieldPathNode } from './field-path';
-import { FormNode } from '../nodes/form-node';
-import { FormValue } from './index';
-/**
- * Единый контекст для работы с формой
- *
- * Предоставляет:
- * - `form` - типизированный Proxy-доступ к полям формы
- * - `setFieldValue` - безопасная установка значения (emitEvent: false)
- */
-export interface FormContext<TForm> {
-    /**
-     * Форма с типизированным Proxy-доступом к полям
-     *
-     * Позволяет обращаться к полям напрямую через точечную нотацию:
-     * - `ctx.form.email` → FieldNode
-     * - `ctx.form.address.city` → FieldNode (вложенный)
-     * - `ctx.form.items` → ArrayNode
-     *
-     * @example
-     * ```typescript
-     * // Получить значение
-     * ctx.form.email.value.value
-     *
-     * // Установить значение (⚠️ может вызвать цикл в behavior!)
-     * ctx.form.email.setValue('new@mail.com')
-     *
-     * // Безопасно установить значение
-     * ctx.form.email.setValue('new@mail.com', { emitEvent: false })
-     *
-     * // Обновить пропсы компонента
-     * ctx.form.city.updateComponentProps({ options: cities })
-     *
-     * // Валидация поля
-     * await ctx.form.email.validate()
-     *
-     * // Работа с массивами
-     * ctx.form.items.push({ title: 'New' })
-     * ctx.form.items.clear()
-     * ```
-     */
-    readonly form: FormProxy<TForm>;
-    /**
-     * Безопасно установить значение поля по строковому пути или FieldPath
-     *
-     * Автоматически использует `emitEvent: false` для предотвращения
-     * бесконечных циклов в behavior схемах.
-     *
-     * @param path - Путь к полю (строка или FieldPath)
-     * @param value - Новое значение
-     *
-     * @example
-     * ```typescript
-     * // Сброс города при смене страны (строковый путь)
-     * watchField(path.country, (country, ctx) => {
-     *   ctx.setFieldValue('city', null);
-     * });
-     *
-     * // Использование FieldPath напрямую (более типобезопасно)
-     * watchField(path.country, (country, ctx) => {
-     *   ctx.setFieldValue(path.city, null);
-     * });
-     * ```
-     */
-    setFieldValue(path: string | FieldPathNode<TForm, unknown>, value: unknown): void;
-    /**
-     * Получить поле формы по строковому пути
-     *
-     * Используется для динамического доступа к вложенным полям,
-     * особенно в модульных behavior схемах, применяемых через apply().
-     *
-     * @param path - Строковый путь к полю (например "address.city")
-     * @returns FormNode или undefined если поле не найдено
-     *
-     * @example
-     * ```typescript
-     * // В модульной behavior схеме, применяемой к вложенному полю:
-     * // apply([path.registrationAddress, path.residenceAddress], addressBehavior)
-     *
-     * watchField(path.region, (region, ctx) => {
-     *   // path.city.__path = "registrationAddress.city" или "residenceAddress.city"
-     *   const cityField = ctx.getFieldByPath(path.city.__path);
-     *   cityField?.updateComponentProps({ options: cities });
-     * });
-     * ```
-     */
-    getFieldByPath(path: string): FormNode<FormValue> | undefined;
-}

package/dist/core/utils/field-path-navigator.d.ts

@@ -1,240 +0,0 @@
-import { UnknownRecord } from '../types';
-/**
- * Сегмент пути к полю формы
- *
- * Представляет один сегмент в пути к полю, например:
- * - `"email" → { key: 'email' }`
- * - `"items[0]" → { key: 'items', index: 0 }`
- *
- * @internal
- *
- * @example
- * ```typescript
- * // Путь "items[0].name" разбивается на:
- * [
- *   { key: 'items', index: 0 },
- *   { key: 'name' }
- * ]
- * ```
- */
-export interface PathSegment {
-    /**
-     * Ключ поля
-     */
-    key: string;
-    /**
-     * Индекс в массиве (опционально)
-     * Присутствует только для сегментов вида "items[0]"
-     */
-    index?: number;
-}
-/**
- * Навигация по путям к полям формы
- *
- * Централизует логику парсинга и навигации по путям к полям формы.
- * Используется в ValidationContext, BehaviorContext, GroupNode для единообразной
- * обработки путей вида "address.city" или "items[0].name".
- *
- * Устраняет дублирование логики парсинга путей в 4 местах кодовой базы.
- *
- * @internal
- *
- * @example
- * ```typescript
- * const navigator = new FieldPathNavigator();
- *
- * // Парсинг пути
- * const segments = navigator.parsePath('items[0].title');
- * // [{ key: 'items', index: 0 }, { key: 'title' }]
- *
- * // Получение значения из объекта
- * const obj = { items: [{ title: 'Item 1' }] };
- * const value = navigator.getValueByPath(obj, 'items[0].title');
- * // 'Item 1'
- *
- * // Получение узла формы
- * const titleNode = navigator.getNodeByPath(form, 'items[0].title');
- * titleNode?.setValue('New Title');
- * ```
- */
-export declare class FieldPathNavigator {
-    /**
-     * Парсит путь в массив сегментов
-     *
-     * Поддерживаемые форматы:
-     * - Простые пути: "name", "email"
-     * - Вложенные пути: "address.city", "user.profile.avatar"
-     * - Массивы: "items[0]", "items[0].name", "tags[1][0]"
-     * - Комбинации: "orders[0].items[1].price"
-     *
-     * @param path Путь к полю (строка с точками и квадратными скобками)
-     * @returns Массив сегментов пути
-     *
-     * @example
-     * ```typescript
-     * navigator.parsePath('email');
-     * // [{ key: 'email' }]
-     *
-     * navigator.parsePath('address.city');
-     * // [{ key: 'address' }, { key: 'city' }]
-     *
-     * navigator.parsePath('items[0].name');
-     * // [{ key: 'items', index: 0 }, { key: 'name' }]
-     * ```
-     */
-    parsePath(path: string): PathSegment[];
-    /**
-     * Добавляет сегмент в массив, обрабатывая массивы
-     * @private
-     */
-    private addSegment;
-    /**
-     * Получает значение по пути из объекта
-     *
-     * Проходит по всем сегментам пути и возвращает конечное значение.
-     * Если путь не найден, возвращает undefined.
-     *
-     * @param obj Объект для навигации
-     * @param path Путь к значению
-     * @returns Значение или undefined, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const obj = {
-     *   email: 'test@mail.com',
-     *   address: { city: 'Moscow' },
-     *   items: [{ title: 'Item 1' }]
-     * };
-     *
-     * navigator.getValueByPath(obj, 'email');
-     * // 'test@mail.com'
-     *
-     * navigator.getValueByPath(obj, 'address.city');
-     * // 'Moscow'
-     *
-     * navigator.getValueByPath(obj, 'items[0].title');
-     * // 'Item 1'
-     *
-     * navigator.getValueByPath(obj, 'invalid.path');
-     * // undefined
-     * ```
-     */
-    getValueByPath(obj: UnknownRecord, path: string): unknown;
-    /**
-     * Устанавливает значение по пути в объекте (мутирует объект)
-     *
-     * Создает промежуточные объекты, если они не существуют.
-     * Выбрасывает ошибку, если ожидается массив, но его нет.
-     *
-     * @param obj Объект для модификации
-     * @param path Путь к значению
-     * @param value Новое значение
-     *
-     * @throws {Error} Если ожидается массив по пути, но его нет
-     *
-     * @example
-     * ```typescript
-     * const obj = { address: { city: '' } };
-     * navigator.setValueByPath(obj, 'address.city', 'Moscow');
-     * // obj.address.city === 'Moscow'
-     *
-     * const obj2: UnknownRecord = {};
-     * navigator.setValueByPath(obj2, 'address.city', 'Moscow');
-     * // Создаст { address: { city: 'Moscow' } }
-     *
-     * const obj3 = { items: [{ title: 'Old' }] };
-     * navigator.setValueByPath(obj3, 'items[0].title', 'New');
-     * // obj3.items[0].title === 'New'
-     * ```
-     */
-    setValueByPath(obj: UnknownRecord, path: string, value: unknown): void;
-    /**
-     * Получить значение из FormNode по пути
-     *
-     * Автоматически извлекает значение из FormNode (через .value.value).
-     * Используется в ValidationContext и BehaviorContext для единообразного
-     * доступа к значениям полей формы.
-     *
-     * @param form Корневой узел формы (обычно GroupNode)
-     * @param path Путь к полю
-     * @returns Значение поля или undefined, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: 'test@mail.com', component: Input },
-     *   address: {
-     *     city: { value: 'Moscow', component: Input }
-     *   },
-     *   items: [{ title: { value: 'Item 1', component: Input } }]
-     * });
-     *
-     * navigator.getFormNodeValue(form, 'email');
-     * // 'test@mail.com'
-     *
-     * navigator.getFormNodeValue(form, 'address.city');
-     * // 'Moscow'
-     *
-     * navigator.getFormNodeValue(form, 'items[0].title');
-     * // 'Item 1'
-     *
-     * navigator.getFormNodeValue(form, 'invalid.path');
-     * // undefined
-     * ```
-     */
-    getFormNodeValue(form: unknown, path: string): unknown;
-    /**
-     * Type guard для проверки, является ли объект FormNode
-     *
-     * Проверяет наличие характерных свойств FormNode:
-     * - value (Signal)
-     * - value.value (значение Signal)
-     *
-     * @param obj Объект для проверки
-     * @returns true, если объект является FormNode
-     * @private
-     */
-    private isFormNode;
-    /**
-     * Получает узел формы по пути
-     *
-     * Навигирует по структуре FormNode (GroupNode/FieldNode/ArrayNode)
-     * и возвращает узел по указанному пути.
-     *
-     * Поддерживает:
-     * - Доступ к полям GroupNode через fields Map
-     * - Доступ к элементам ArrayNode через индекс
-     * - Proxy-доступ к полям (для обратной совместимости)
-     *
-     * @param form Корневой узел формы (обычно GroupNode)
-     * @param path Путь к узлу
-     * @returns Узел формы или null, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: '', component: Input },
-     *   address: {
-     *     city: { value: '', component: Input }
-     *   },
-     *   items: [{ title: { value: '', component: Input } }]
-     * });
-     *
-     * const emailNode = navigator.getNodeByPath(form, 'email');
-     * // FieldNode
-     *
-     * const cityNode = navigator.getNodeByPath(form, 'address.city');
-     * // FieldNode
-     *
-     * const itemNode = navigator.getNodeByPath(form, 'items[0]');
-     * // GroupNode
-     *
-     * const titleNode = navigator.getNodeByPath(form, 'items[0].title');
-     * // FieldNode
-     *
-     * const invalidNode = navigator.getNodeByPath(form, 'invalid.path');
-     * // null
-     * ```
-     */
-    getNodeByPath(form: unknown, path: string): unknown | null;
-}

package/dist/core/utils/field-path.d.ts

@@ -1,60 +0,0 @@
-import { FieldPath, FieldPathNode } from '../types';
-/**
- * Создать FieldPath proxy для формы
- *
- * @example
- * ```typescript
- * const path = createFieldPath<MyForm>();
- * console.log(path.email.__path); // 'email'
- * console.log(path.personalData.firstName.__path); // 'personalData.firstName'
- * ```
- */
-export declare function createFieldPath<T>(): FieldPath<T>;
-/**
- * Извлечь строковый путь из {@link FieldPathNode}.
- *
- * @param node - Узел `FieldPathNode` либо строка-путь.
- * @returns Путь вида `"a.b.c"`.
- *
- * @example
- * ```typescript
- * import { extractPath } from '@reformer/core';
- *
- * const path = (renderPath) => extractPath(renderPath.user.email); // → 'user.email'
- * ```
- */
-export declare function extractPath(node: FieldPathNode<unknown, unknown> | unknown): string;
-/**
- * Преобразовать 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 declare function toFieldPath<T>(node: FieldPathNode<unknown, T, never> | FieldPathNode<any, T, any>): FieldPath<T>;
-/**
- * Извлечь имя последнего сегмента ({@link FieldPathSegment}) пути.
- *
- * @param node - Узел `FieldPathNode` либо строка-путь.
- * @returns Имя поля без префикса родителя (последний сегмент).
- *
- * @example
- * ```typescript
- * import { extractKey } from '@reformer/core';
- *
- * extractKey(path.user.email); // → 'email'
- * ```
- */
-export declare function extractKey(node: FieldPathNode<unknown, unknown> | unknown): string;

package/dist/core/utils/registry-helpers.d.ts

@@ -1,43 +0,0 @@
-import { ValidationRegistry } from '../validation/validation-registry';
-import { BehaviorRegistry } from '../behavior/behavior-registry';
-/**
- * Получить текущий активный ValidationRegistry из context stack
- *
- * Используется внутри validation schema функций (validate, validateAsync, required и т.д.)
- * для регистрации валидаторов в активном контексте GroupNode
- *
- * @returns Текущий ValidationRegistry или заглушка в production
- * @throws Error если нет активного контекста (только в DEV режиме)
- *
- * @internal
- *
- * @example
- * ```typescript
- * function required(fieldPath, options) {
- *   const registry = getCurrentValidationRegistry();
- *   registry.registerSync(path, validator, options);
- * }
- * ```
- */
-export declare function getCurrentValidationRegistry(): ValidationRegistry;
-/**
- * Получить текущий активный BehaviorRegistry из context stack
- *
- * Используется внутри behavior schema функций (copyFrom, enableWhen, computeFrom и т.д.)
- * для регистрации поведений в активном контексте GroupNode
- *
- * @returns Текущий BehaviorRegistry или заглушка в production
- * @throws Error если нет активного контекста (только в DEV режиме)
- *
- * @internal
- *
- * @example
- * ```typescript
- * function copyFrom(target, source, options) {
- *   const registry = getCurrentBehaviorRegistry();
- *   const handler = createCopyBehavior(target, source, options);
- *   registry.register(handler, { debounce: options?.debounce });
- * }
- * ```
- */
-export declare function getCurrentBehaviorRegistry(): BehaviorRegistry;

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

@@ -1,22 +0,0 @@
-import { FieldPath } from '../../types/field-path';
-import { ConditionFn } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
-/**
- * Применить валидацию только при выполнении условия
- *
- * @group Validation
- * @category Core Functions
- *
- * @example
- * ```typescript
- * applyWhen(
- *   path.loanType,
- *   (type) => type === 'mortgage',
- *   (path) => {
- *     required(path.propertyValue, { message: 'Укажите стоимость' });
- *     min(path.propertyValue, 1000000);
- *   }
- * );
- * ```
- */
-export declare function applyWhen<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, condition: ConditionFn<TField>, validationFn: (path: FieldPath<TForm>) => void): void;