@reformer/core 5.0.0 → 6.0.0

package/dist/core/behavior/behaviors/enable-when.d.ts

@@ -1,118 +0,0 @@
-import { FieldPathNode } from '../../types';
-import { EnableWhenOptions } from '../types';
-/**
- * Условное включение поля на основе значений других полей
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для включения/выключения
- * @param condition - Функция условия (true = enable, false = disable)
- * @param options - Опции (`resetOnDisable`, `debounce`)
- *
- * @example Базовый сценарий с `resetOnDisable: true`
- * ```typescript
- * import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface LoanForm {
- *   loanType: 'mortgage' | 'consumer' | 'car';
- *   propertyValue: number;
- *   initialPayment: number;
- * }
- *
- * export const loanBehavior: BehaviorSchemaFn<LoanForm> = (path) => {
- *   // Поля ипотеки активны только для loanType === 'mortgage'.
- *   // resetOnDisable: true гарантирует чистые initial values при переключении.
- *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage', {
- *     resetOnDisable: true,
- *   });
- *   enableWhen(path.initialPayment, (form) => form.loanType === 'mortgage', {
- *     resetOnDisable: true,
- *   });
- * };
- * ```
- *
- * @example Множественные independent условия + cycle prevention
- * ```typescript
- * import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface ProfileForm {
- *   sameAsRegistration: boolean;
- *   employmentStatus: 'employed' | 'selfEmployed' | 'unemployed';
- *   residenceAddress: { city: string; street: string };
- *   companyName: string;
- *   companyInn: string;
- *   businessType: string;
- * }
- *
- * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
- *   // Адрес проживания: enabled, когда НЕ совпадает с регистрационным
- *   enableWhen(path.residenceAddress, (form) => form.sameAsRegistration === false, {
- *     resetOnDisable: true,
- *   });
- *
- *   // Поля работодателя: только для employed
- *   enableWhen(path.companyName, (form) => form.employmentStatus === 'employed', {
- *     resetOnDisable: true,
- *   });
- *   enableWhen(path.companyInn, (form) => form.employmentStatus === 'employed', {
- *     resetOnDisable: true,
- *   });
- *
- *   // ИП-поля: только для selfEmployed
- *   enableWhen(path.businessType, (form) => form.employmentStatus === 'selfEmployed', {
- *     resetOnDisable: true,
- *   });
- *
- *   // ВАЖНО: condition не должен читать значение САМОГО поля — иначе цикл.
- *   // condition зависит ТОЛЬКО от независимых триггеров (loanType, employmentStatus, ...).
- * };
- * ```
- *
- * @see [docs/llms/22-cycle-detection.md](../../../../docs/llms/22-cycle-detection.md)
- */
-export declare function enableWhen<TForm>(field: FieldPathNode<TForm, any>, condition: (form: TForm) => boolean, options?: EnableWhenOptions): void;
-/**
- * Условное выключение поля (инверсия enableWhen)
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для выключения
- * @param condition - Функция условия (true = disable, false = enable)
- * @param options - Опции (`resetOnDisable`, `debounce`)
- *
- * @example Базовый сценарий — readonly после подтверждения
- * ```typescript
- * import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface ConfirmForm {
- *   isConfirmed: boolean;
- *   editableField: string;
- * }
- *
- * export const confirmBehavior: BehaviorSchemaFn<ConfirmForm> = (path) => {
- *   // Поле блокируется после установки чекбокса подтверждения
- *   disableWhen(path.editableField, (form) => form.isConfirmed === true);
- *   // resetOnDisable НЕ ставим — сохраняем введённый текст
- * };
- * ```
- *
- * @example С `resetOnDisable` для очистки заблокированного поля
- * ```typescript
- * import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface PromoForm {
- *   loanType: 'mortgage' | 'consumer';
- *   promoCode: string;
- * }
- *
- * export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
- *   // Промокод недоступен для потребительских кредитов и сбрасывается
- *   disableWhen(path.promoCode, (form) => form.loanType === 'consumer', {
- *     resetOnDisable: true,
- *   });
- * };
- * ```
- */
-export declare function disableWhen<TForm>(field: FieldPathNode<TForm, any>, condition: (form: TForm) => boolean, options?: EnableWhenOptions): void;

package/dist/core/behavior/behaviors/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Behavior rules
- */
-export { copyFrom } from './copy-from';
-export { enableWhen, disableWhen } from './enable-when';
-export { computeFrom } from './compute-from';
-export { watchField } from './watch-field';
-export { revalidateWhen } from './revalidate-when';
-export { syncFields } from './sync-fields';
-export { resetWhen, type ResetWhenOptions } from './reset-when';
-export { transformValue, createTransformer, transformers, type TransformValueOptions, } from './transform-value';

package/dist/core/behavior/behaviors/reset-when.d.ts

@@ -1,64 +0,0 @@
-import { FieldPathNode, FormFields, FormValue } from '../../types';
-/**
- * Опции для resetWhen
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface ResetWhenOptions {
-    /** Значение для сброса (по умолчанию null) */
-    resetValue?: FormValue;
-    /** Сбросить только если поле dirty */
-    onlyIfDirty?: boolean;
-}
-/**
- * Условный сброс поля при выполнении условия
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для сброса
- * @param condition - Функция условия (true = reset)
- * @param options - Опции (`resetValue`, `onlyIfDirty`, `debounce`)
- *
- * @example Сброс зависимого поля при смене типа платежа
- * ```typescript
- * import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface CheckoutForm {
- *   paymentType: 'card' | 'cash';
- *   cardNumber: string;
- * }
- *
- * export const checkoutBehavior: BehaviorSchemaFn<CheckoutForm> = (path) => {
- *   // Когда выбрано НЕ card — обнуляем номер карты в пустую строку
- *   resetWhen(path.cardNumber, (form) => form.paymentType !== 'card', {
- *     resetValue: '',
- *   });
- * };
- * ```
- *
- * @example `onlyIfDirty` — не трогаем нетронутые initial значения
- * ```typescript
- * import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface CarForm {
- *   loanType: 'mortgage' | 'car' | 'consumer';
- *   carPrice: number;
- * }
- *
- * export const carBehavior: BehaviorSchemaFn<CarForm> = (path) => {
- *   // Если пользователь не вводил carPrice — оставляем default из схемы.
- *   // Сбрасываем только если поле dirty (была пользовательская правка).
- *   resetWhen(path.carPrice, (form) => form.loanType !== 'car', {
- *     resetValue: 0,
- *     onlyIfDirty: true,
- *   });
- * };
- * ```
- *
- * @see [docs/llms/25-reset-when.md](../../../../docs/llms/25-reset-when.md)
- */
-export declare function resetWhen<TForm extends FormFields>(field: FieldPathNode<TForm, FormValue>, condition: (form: TForm) => boolean, options?: ResetWhenOptions & {
-    debounce?: number;
-}): void;

package/dist/core/behavior/behaviors/revalidate-when.d.ts

@@ -1,53 +0,0 @@
-import { FieldPathNode, FormValue } from '../../types';
-import { RevalidateWhenOptions } from '../types';
-/**
- * Перевалидирует поле при изменении других полей
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param target - Поле для перевалидации
- * @param triggers - Поля-триггеры (НЕ должно содержать `target`)
- * @param options - Опции (`debounce`)
- *
- * @example Парная перевалидация — confirmPassword при смене password
- * ```typescript
- * import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- * import { equalTo } from '@reformer/core/validators';
- * import type { FieldPath } from '@reformer/core';
- *
- * interface RegistrationForm { password: string; confirmPassword: string }
- *
- * export const validation = (path: FieldPath<RegistrationForm>) => {
- *   equalTo(path.confirmPassword, path.password, { message: 'Пароли не совпадают' });
- * };
- *
- * export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
- *   // Если пользователь сначала ввёл confirm, потом меняет password —
- *   // без revalidateWhen ошибка confirmPassword останется устаревшей.
- *   revalidateWhen(path.confirmPassword, [path.password]);
- * };
- * ```
- *
- * @example Несколько триггеров + `debounce` для async-валидаторов
- * ```typescript
- * import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface MortgageForm {
- *   propertyValue: number;
- *   loanAmount: number;
- *   initialPayment: number; // правило: initialPayment >= propertyValue * 0.2 - loanAmount
- * }
- *
- * export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
- *   revalidateWhen(
- *     path.initialPayment,
- *     [path.propertyValue, path.loanAmount],
- *     { debounce: 300 }, // не дёргаем сервер на каждый keystroke
- *   );
- * };
- * ```
- *
- * @see [docs/llms/27-revalidate-when.md](../../../../docs/llms/27-revalidate-when.md)
- */
-export declare function revalidateWhen<TForm>(target: FieldPathNode<TForm, FormValue>, triggers: FieldPathNode<TForm, FormValue>[], options?: RevalidateWhenOptions): void;

package/dist/core/behavior/behaviors/sync-fields.d.ts

@@ -1,48 +0,0 @@
-import { FieldPathNode, FormFields, FormValue } from '../../types';
-import { SyncFieldsOptions } from '../types';
-/**
- * Двусторонняя синхронизация двух полей
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field1 - Первое поле
- * @param field2 - Второе поле
- * @param options - Опции (`transform` асимметричен — применяется только field1 → field2; `debounce`)
- *
- * @example Базовый mirror двух текстовых полей
- * ```typescript
- * import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface MirrorForm {
- *   syncField1: string;
- *   syncField2: string;
- * }
- *
- * export const mirrorBehavior: BehaviorSchemaFn<MirrorForm> = (path) => {
- *   syncFields(path.syncField1, path.syncField2);
- * };
- * ```
- *
- * @example С `transform` (асимметричный) и `debounce` для защиты от частых перезаписей
- * ```typescript
- * import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface CodeForm {
- *   internalCode: string;  // канонический формат
- *   displayCode: string;   // показываем пользователю
- * }
- *
- * export const codeBehavior: BehaviorSchemaFn<CodeForm> = (path) => {
- *   // internalCode → displayCode: применяется toUpperCase
- *   // displayCode → internalCode: пишется как есть
- *   syncFields(path.internalCode, path.displayCode, {
- *     transform: (value) => (typeof value === 'string' ? value.toUpperCase() : value),
- *     debounce: 150, // сглаживает дёргание каретки
- *   });
- * };
- * ```
- *
- * @see [docs/llms/24-sync-fields.md](../../../../docs/llms/24-sync-fields.md)
- */
-export declare function syncFields<TForm extends FormFields, T extends FormValue>(field1: FieldPathNode<TForm, T>, field2: FieldPathNode<TForm, T>, options?: SyncFieldsOptions<T>): void;

package/dist/core/behavior/behaviors/transform-value.d.ts

@@ -1,192 +0,0 @@
-import { FieldPathNode, FormFields, FormValue } from '../../types';
-/**
- * Опции для transformValue
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export interface TransformValueOptions {
-    /** Трансформировать только при изменении пользователем (не программно) */
-    onUserChangeOnly?: boolean;
-    /** Триггерить событие изменения после трансформации */
-    emitEvent?: boolean;
-}
-/**
- * Трансформация значения поля при изменении
- * Позволяет автоматически форматировать или преобразовывать значения
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для трансформации
- * @param transformer - Функция трансформации (ОБЯЗАТЕЛЬНО идемпотентная: f(f(x)) === f(x))
- * @param options - Опции (`onUserChangeOnly`, `emitEvent`, `debounce`)
- *
- * @example Базовая нормализация — uppercase + trim email
- * ```typescript
- * import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface RegistrationForm {
- *   promoCode: string;
- *   email: string;
- * }
- *
- * export const registrationBehavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
- *   // Идемпотентно: toUpperCase(toUpperCase(x)) === toUpperCase(x) ✓
- *   transformValue(path.promoCode, (value) => (value ?? '').toUpperCase());
- *   transformValue(path.email, (value) => (value ?? '').trim().toLowerCase());
- * };
- * ```
- *
- * @example `onUserChangeOnly` + idempotent guard для не-тривиальных форматов
- * ```typescript
- * import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface ProfileForm {
- *   inn: string; // ИНН — только цифры
- *   prefixedCode: string; // должен иметь префикс "ID-"
- * }
- *
- * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
- *   // Цифры из ИНН: трансформер идемпотентный естественно
- *   transformValue(path.inn, (v) => (v ?? '').replace(/\D/g, ''));
- *
- *   // Префикс — ВАЖНО guard «уже преобразовано», иначе бесконечный цикл
- *   // f("ID-123") должно === "ID-123", а не "ID-ID-123"
- *   transformValue(
- *     path.prefixedCode,
- *     (v) => (v?.startsWith('ID-') ? v : `ID-${v ?? ''}`),
- *     {
- *       onUserChangeOnly: true, // не трогаем значение из patchValue/preload
- *       debounce: 200,
- *     },
- *   );
- * };
- * ```
- *
- * @see [docs/llms/26-transform-value.md](../../../../docs/llms/26-transform-value.md)
- */
-export declare function transformValue<TForm extends FormFields, TValue extends FormValue = FormValue>(field: FieldPathNode<TForm, TValue>, transformer: (value: TValue) => TValue, options?: TransformValueOptions & {
-    debounce?: number;
-}): void;
-/**
- * Хелпер для создания переиспользуемых трансформаций
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param transformer - Идемпотентная функция преобразования значения
- * @param defaultOptions - Опции, применяемые ко всем вызовам созданного трансформера
- *
- * @example Доменно-специфичные трансформеры (банковский счёт, СНИЛС)
- * ```typescript
- * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * // Сохраняем только цифры и форматируем СНИЛС: 000-000-000 00
- * const formatSnils = createTransformer<string>((v) => {
- *   const d = (v ?? '').replace(/\D/g, '').slice(0, 11);
- *   if (d.length < 9) return d;
- *   return `${d.slice(0, 3)}-${d.slice(3, 6)}-${d.slice(6, 9)}${d.length > 9 ? ' ' + d.slice(9) : ''}`;
- * });
- *
- * interface ProfileForm { snils: string }
- *
- * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
- *   formatSnils(path.snils, { debounce: 100 });
- * };
- * ```
- *
- * @example С `defaultOptions` — единые настройки на серию полей
- * ```typescript
- * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * // Все коды должны быть uppercase, но только после правки пользователем
- * const upperOnUserEdit = createTransformer<string>(
- *   (v) => (v ?? '').toUpperCase(),
- *   { onUserChangeOnly: true, debounce: 100 },
- * );
- *
- * interface PromoForm { promoCode: string; partnerCode: string }
- *
- * export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
- *   upperOnUserEdit(path.promoCode);
- *   upperOnUserEdit(path.partnerCode);
- * };
- * ```
- */
-export declare function createTransformer<TValue extends FormValue = FormValue>(transformer: (value: TValue) => TValue, defaultOptions?: TransformValueOptions): <TForm extends FormFields>(field: FieldPathNode<TForm, TValue>, options?: TransformValueOptions & {
-    debounce?: number;
-}) => void;
-/**
- * Готовые трансформеры для частых случаев. Все идемпотентны и безопасны для повторного применения.
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @example Готовые трансформеры в схеме формы
- * ```typescript
- * import { transformers, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface RegistrationForm {
- *   username: string;
- *   email: string;
- *   promoCode: string;
- *   inn: string;
- *   amount: number;
- * }
- *
- * export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
- *   transformers.trim(path.username);
- *   transformers.toLowerCase(path.email);
- *   transformers.toUpperCase(path.promoCode);
- *   transformers.digitsOnly(path.inn);
- *   transformers.roundTo2(path.amount);
- * };
- * ```
- *
- * @example Композиция готовых трансформеров через createTransformer
- * ```typescript
- * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * // trim + lowercase в одном трансформере (применяется как одна операция)
- * const normalizeEmail = createTransformer<string>(
- *   (v) => (v ?? '').trim().toLowerCase(),
- * );
- *
- * interface ContactForm { email: string }
- *
- * export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
- *   normalizeEmail(path.email);
- * };
- * ```
- */
-export declare const transformers: {
-    /** Перевести в верхний регистр */
-    toUpperCase: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Перевести в нижний регистр */
-    toLowerCase: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Удалить пробелы с краев */
-    trim: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Удалить все пробелы */
-    removeSpaces: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Оставить только цифры */
-    digitsOnly: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Округлить число */
-    round: <TForm extends FormFields>(field: FieldPathNode<TForm, number, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-    /** Округлить до 2 знаков после запятой */
-    roundTo2: <TForm extends FormFields>(field: FieldPathNode<TForm, number, unknown>, options?: (TransformValueOptions & {
-        debounce?: number;
-    }) | undefined) => void;
-};

package/dist/core/behavior/behaviors/watch-field.d.ts

@@ -1,80 +0,0 @@
-import { FieldPathNode } from '../../types';
-import { BehaviorContext, WatchFieldOptions } from '../types';
-/**
- * Выполняет callback при изменении поля
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для отслеживания
- * @param callback - Функция обратного вызова
- * @param options - Опции (`debounce`, `immediate`)
- *
- * @example Async loader with try/catch + guard + debounce
- * ```typescript
- * import { watchField, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface AddressForm { region: string; city: string }
- *
- * export const addressBehavior: BehaviorSchemaFn<AddressForm> = (path) => {
- *   watchField(
- *     path.region,
- *     async (region, ctx) => {
- *       if (!region) {
- *         ctx.form.city.updateComponentProps({ options: [] });
- *         return; // guard: пустое значение не триггерит fetch
- *       }
- *       try {
- *         const { data: cities } = await fetchCities(region);
- *         ctx.form.city.updateComponentProps({ options: cities });
- *       } catch (error) {
- *         console.error('[addressBehavior] failed to load cities:', error);
- *         ctx.form.city.updateComponentProps({ options: [] });
- *       }
- *     },
- *     { immediate: false, debounce: 300 }, // обязательные опции для async
- *   );
- * };
- * ```
- *
- * @example Sync handler с консолидацией нескольких зависимостей в один watcher
- * ```typescript
- * import { watchField, type BehaviorSchemaFn } from '@reformer/core/behaviors';
- *
- * interface InsuranceForm {
- *   insuranceType: 'casco' | 'osago' | 'property' | '';
- *   vehicleVin: string;
- *   propertyType: string;
- * }
- *
- * export const insuranceBehavior: BehaviorSchemaFn<InsuranceForm> = (path) => {
- *   // ОДИН watchField на trigger-поле — несколько watcher'ов на одно поле = "Cycle detected"
- *   watchField(
- *     path.insuranceType,
- *     (type, ctx) => {
- *       const isVehicle = type === 'casco' || type === 'osago';
- *       const isProperty = type === 'property';
- *
- *       // Guard — ставим только если состояние реально меняется
- *       if (isVehicle) {
- *         if (ctx.form.vehicleVin.disabled.value) ctx.form.vehicleVin.enable();
- *       } else {
- *         if (!ctx.form.vehicleVin.disabled.value) ctx.form.vehicleVin.disable();
- *         if (ctx.form.vehicleVin.getValue() !== '') ctx.form.vehicleVin.setValue('');
- *       }
- *
- *       if (isProperty) {
- *         if (ctx.form.propertyType.disabled.value) ctx.form.propertyType.enable();
- *       } else {
- *         if (!ctx.form.propertyType.disabled.value) ctx.form.propertyType.disable();
- *         if (ctx.form.propertyType.getValue() !== '') ctx.form.propertyType.setValue('');
- *       }
- *     },
- *     { immediate: false }, // CRITICAL: предотвращает запуск во время инициализации
- *   );
- * };
- * ```
- *
- * @see [docs/llms/22-cycle-detection.md](../../../../docs/llms/22-cycle-detection.md)
- */
-export declare function watchField<TForm, TField>(field: FieldPathNode<TForm, TField>, callback: (value: TField, ctx: BehaviorContext<TForm>) => void | Promise<void>, options?: WatchFieldOptions): void;

package/dist/core/behavior/compose-behavior.d.ts

@@ -1,96 +0,0 @@
-import { FieldPath, FieldPathNode, FormFields, FormValue } from '../types';
-import { BehaviorSchemaFn } from './types';
-/**
- * Преобразовать FieldPath во вложенный путь для композиции behavior схем
- *
- * Аналог toFieldPath из validation API.
- *
- * @param fieldPath - Поле для преобразования
- * @returns Вложенный FieldPath
- *
- * @example
- * ```typescript
- * // address-behavior.ts
- * export const addressBehavior = (path: FieldPath<Address>) => {
- *   watchField(path.country, async (country, ctx) => {
- *     const regions = await fetchRegions(country);
- *     ctx.updateComponentProps(path.region, { options: regions });
- *   });
- * };
- *
- * // user-behavior.ts
- * export const userBehavior = (path: FieldPath<User>) => {
- *   // Композиция: применяем addressBehavior к вложенному полю
- *   addressBehavior(toBehaviorFieldPath(path.address));
- * };
- * ```
- */
-export declare function toBehaviorFieldPath<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined): FieldPath<TField>;
-/**
- * Применить behavior схему к вложенному полю или полям
- *
- * Поддерживает:
- * - Одно поле или массив полей
- * - Одну схему или массив схем
- * - Все комбинации (поле + схема, поле + схемы, поля + схема, поля + схемы)
- *
- * @param fields - Одно поле или массив полей
- * @param behaviors - Одна схема или массив схем
- *
- * @example
- * ```typescript
- * // Одна схема к одному полю
- * apply(path.registrationAddress, addressBehavior);
- *
- * // Одна схема к нескольким полям
- * apply([path.registrationAddress, path.residenceAddress], addressBehavior);
- *
- * // Несколько схем к одному полю
- * apply(path.properties, [propertyBehavior, arrayBehavior]);
- *
- * // Несколько схем к нескольким полям
- * apply(
- *   [path.registrationAddress, path.residenceAddress],
- *   [addressBehavior, validationBehavior]
- * );
- * ```
- */
-export declare function apply<TForm, TField>(fields: FieldPathNode<TForm, TField> | Array<FieldPathNode<TForm, TField> | undefined> | undefined, behaviors: BehaviorSchemaFn<TField> | Array<BehaviorSchemaFn<TField>>): void;
-/**
- * Условное применение behavior схем (аналог applyWhen из validation API)
- *
- * ⚠️ ВАЖНО: Эта функция НЕ создаёт новые behaviors при каждом изменении условия!
- * Вместо этого behaviors регистрируются ОДИН РАЗ при первом вызове и затем
- * просто не выполняются, если условие не выполнено.
- *
- * Это отличается от старой реализации, которая создавала утечку памяти,
- * регистрируя behaviors при каждом изменении conditionField.
- *
- * @param conditionField - Поле для проверки условия
- * @param condition - Функция проверки условия
- * @param callback - Callback для применения behavior схем
- *
- * @example
- * ```typescript
- * // Применить addressBehavior только когда sameAsRegistration === false
- * applyWhen(
- *   path.sameAsRegistration,
- *   (value) => value === false,
- *   (path) => {
- *     apply(path.residenceAddress, addressBehavior);
- *   }
- * );
- *
- * // Или с прямым использованием path
- * applyWhen(
- *   path.hasProperty,
- *   (value) => value === true,
- *   (path) => {
- *     apply(path.properties, propertyBehavior);
- *     // Можно применить несколько схем
- *     apply([path.properties, path.items], arrayBehavior);
- *   }
- * );
- * ```
- */
-export declare function applyWhen<TForm extends FormFields, TValue extends FormValue>(conditionField: FieldPathNode<TForm, TValue> | undefined, condition: (value: TValue) => boolean, callback: (path: FieldPath<TForm>) => void): void;

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

@@ -1,11 +0,0 @@
-/**
- * Behavior Schema API - Декларативное описание реактивного поведения форм
- *
- * @group Behaviors
- * @module behaviors
- */
-export type { BehaviorSchemaFn, BehaviorContext, BehaviorHandlerFn, BehaviorOptions, CopyFromOptions, EnableWhenOptions, ComputeFromOptions, WatchFieldOptions, RevalidateWhenOptions, SyncFieldsOptions, } from './types';
-export * from './behaviors';
-export { apply, applyWhen, toBehaviorFieldPath } from './compose-behavior';
-export { BehaviorRegistry } from './behavior-registry';
-export { BehaviorContextImpl } from './behavior-context';