@reformer/core 1.0.0-beta.3

package/dist/core/behavior/behaviors/reset-when.js

@@ -0,0 +1,63 @@
+/**
+ * Условный сброс полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/resetWhen
+ */
+import { effect } from '@preact/signals-core';
+import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
+/**
+ * Условный сброс поля при выполнении условия
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для сброса
+ * @param condition - Функция условия (true = reset)
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Сбросить поле при изменении типа кредита
+ *   resetWhen(path.propertyValue, (form) => form.loanType !== 'mortgage');
+ *
+ *   // Сбросить с кастомным значением
+ *   resetWhen(path.initialPayment, (form) => !form.propertyValue, {
+ *     resetValue: 0
+ *   });
+ *
+ *   // Сбросить только если поле было изменено пользователем
+ *   resetWhen(path.carPrice, (form) => form.loanType !== 'car', {
+ *     onlyIfDirty: true
+ *   });
+ * };
+ * ```
+ */
+export function resetWhen(field, condition, options) {
+    const { debounce, resetValue = null, onlyIfDirty = false } = options || {};
+    const handler = (form, _context, withDebounce) => {
+        const targetNode = form.getFieldByPath(field.__path);
+        if (!targetNode)
+            return null;
+        return effect(() => {
+            const formValue = form.value.value;
+            withDebounce(() => {
+                const shouldReset = condition(formValue);
+                if (shouldReset) {
+                    // Проверяем onlyIfDirty опцию
+                    if (onlyIfDirty && !targetNode.dirty.value) {
+                        return;
+                    }
+                    // Сбрасываем значение
+                    targetNode.setValue(resetValue);
+                    // Сбрасываем флаги dirty и touched
+                    targetNode.markAsPristine();
+                    targetNode.markAsUntouched();
+                }
+            });
+        });
+    };
+    getCurrentBehaviorRegistry().register(handler, { debounce });
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Перевалидация полей при изменениях
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/revalidateWhen
+ */
+import type { FieldPathNode, FormValue } from '../../types';
+import type { RevalidateWhenOptions } from '../types';
+/**
+ * Перевалидирует поле при изменении других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param target - Поле для перевалидации
+ * @param triggers - Поля-триггеры
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Перевалидировать initialPayment при изменении propertyValue
+ *   revalidateWhen(path.initialPayment, [path.propertyValue], {
+ *     debounce: 300
+ *   });
+ * };
+ * ```
+ */
+export declare function revalidateWhen<TForm>(target: FieldPathNode<TForm, FormValue>, triggers: FieldPathNode<TForm, FormValue>[], options?: RevalidateWhenOptions): void;

package/dist/core/behavior/behaviors/revalidate-when.js

@@ -0,0 +1,51 @@
+/**
+ * Перевалидация полей при изменениях
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/revalidateWhen
+ */
+import { effect } from '@preact/signals-core';
+import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
+/**
+ * Перевалидирует поле при изменении других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param target - Поле для перевалидации
+ * @param triggers - Поля-триггеры
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Перевалидировать initialPayment при изменении propertyValue
+ *   revalidateWhen(path.initialPayment, [path.propertyValue], {
+ *     debounce: 300
+ *   });
+ * };
+ * ```
+ */
+export function revalidateWhen(target, triggers, options) {
+    const { debounce } = options || {};
+    const handler = (form, _context, withDebounce) => {
+        const targetNode = form.getFieldByPath(target.__path);
+        if (!targetNode)
+            return null;
+        const sourceNodes = triggers
+            .map((field) => form.getFieldByPath(field.__path))
+            .filter((node) => node !== undefined);
+        if (sourceNodes.length === 0)
+            return null;
+        return effect(() => {
+            // Отслеживаем изменения source полей
+            sourceNodes.forEach((node) => node.value.value);
+            withDebounce(() => {
+                // Перезапускаем валидацию target поля
+                targetNode.validate();
+            });
+        });
+    };
+    getCurrentBehaviorRegistry().register(handler, { debounce });
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Двусторонняя синхронизация полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/syncFields
+ */
+import type { FieldPathNode, FormFields, FormValue } from '../../types';
+import type { SyncFieldsOptions } from '../types';
+/**
+ * Двусторонняя синхронизация двух полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field1 - Первое поле
+ * @param field2 - Второе поле
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Синхронизировать два поля
+ *   syncFields(path.email, path.emailCopy);
+ * };
+ * ```
+ */
+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/sync-fields.js

@@ -0,0 +1,66 @@
+/**
+ * Двусторонняя синхронизация полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/syncFields
+ */
+import { effect } from '@preact/signals-core';
+import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
+/**
+ * Двусторонняя синхронизация двух полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field1 - Первое поле
+ * @param field2 - Второе поле
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Синхронизировать два поля
+ *   syncFields(path.email, path.emailCopy);
+ * };
+ * ```
+ */
+export function syncFields(field1, field2, options) {
+    const { debounce, transform } = options || {};
+    const handler = (form, _context, withDebounce) => {
+        const sourceNode = form.getFieldByPath(field1.__path);
+        const targetNode = form.getFieldByPath(field2.__path);
+        if (!sourceNode || !targetNode)
+            return null;
+        // Флаг для предотвращения циклических обновлений
+        let isUpdating = false;
+        const dispose1 = effect(() => {
+            const sourceValue = sourceNode.value.value;
+            if (isUpdating)
+                return;
+            withDebounce(() => {
+                isUpdating = true;
+                const finalValue = transform ? transform(sourceValue) : sourceValue;
+                targetNode.setValue(finalValue, { emitEvent: false });
+                isUpdating = false;
+            });
+        });
+        const dispose2 = effect(() => {
+            const targetValue = targetNode.value.value;
+            if (isUpdating)
+                return;
+            withDebounce(() => {
+                isUpdating = true;
+                // Обратная синхронизация (без трансформации)
+                sourceNode.setValue(targetValue, { emitEvent: false });
+                isUpdating = false;
+            });
+        });
+        // Возвращаем комбинированный cleanup
+        return () => {
+            dispose1();
+            dispose2();
+        };
+    };
+    getCurrentBehaviorRegistry().register(handler, { debounce });
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Трансформация значений полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/transformValue
+ */
+import type { 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 - Функция трансформации
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Автоматически переводить текст в верхний регистр
+ *   transformValue(path.code, (value) => value?.toUpperCase());
+ *
+ *   // Форматировать номер телефона
+ *   transformValue(path.phone, (value) => {
+ *     if (!value) return value;
+ *     const digits = value.replace(/\D/g, '');
+ *     if (digits.length === 11) {
+ *       return `+7 (${digits.slice(1, 4)}) ${digits.slice(4, 7)}-${digits.slice(7, 9)}-${digits.slice(9)}`;
+ *     }
+ *     return value;
+ *   });
+ *
+ *   // Удалять пробелы из email
+ *   transformValue(path.email, (value) => value?.trim().toLowerCase());
+ *
+ *   // Округлять числа
+ *   transformValue(path.amount, (value) => {
+ *     return typeof value === 'number' ? Math.round(value) : value;
+ *   });
+ * };
+ * ```
+ */
+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
+ *
+ * @example
+ * ```typescript
+ * // Создаем переиспользуемые трансформеры
+ * const toUpperCase = createTransformer<string>((value) => value?.toUpperCase());
+ * const toLowerCase = createTransformer<string>((value) => value?.toLowerCase());
+ * const trim = createTransformer<string>((value) => value?.trim());
+ *
+ * // Используем в форме
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   toUpperCase(path.code);
+ *   toLowerCase(path.email);
+ *   trim(path.username);
+ * };
+ * ```
+ */
+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
+ */
+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/transform-value.js

@@ -0,0 +1,110 @@
+/**
+ * Трансформация значений полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/transformValue
+ */
+import { watchField } from './watch-field';
+/**
+ * Трансформация значения поля при изменении
+ * Позволяет автоматически форматировать или преобразовывать значения
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для трансформации
+ * @param transformer - Функция трансформации
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Автоматически переводить текст в верхний регистр
+ *   transformValue(path.code, (value) => value?.toUpperCase());
+ *
+ *   // Форматировать номер телефона
+ *   transformValue(path.phone, (value) => {
+ *     if (!value) return value;
+ *     const digits = value.replace(/\D/g, '');
+ *     if (digits.length === 11) {
+ *       return `+7 (${digits.slice(1, 4)}) ${digits.slice(4, 7)}-${digits.slice(7, 9)}-${digits.slice(9)}`;
+ *     }
+ *     return value;
+ *   });
+ *
+ *   // Удалять пробелы из email
+ *   transformValue(path.email, (value) => value?.trim().toLowerCase());
+ *
+ *   // Округлять числа
+ *   transformValue(path.amount, (value) => {
+ *     return typeof value === 'number' ? Math.round(value) : value;
+ *   });
+ * };
+ * ```
+ */
+export function transformValue(field, transformer, options) {
+    const { onUserChangeOnly = false, emitEvent = true, debounce } = options || {};
+    watchField(field, (currentValue, ctx) => {
+        const targetNode = ctx.form.getFieldByPath(field.__path);
+        if (!targetNode)
+            return;
+        // Если нужно трансформировать только при изменении пользователем
+        if (onUserChangeOnly && !targetNode.touched.value) {
+            return;
+        }
+        const transformedValue = transformer(currentValue);
+        // Применяем трансформацию только если значение изменилось
+        if (transformedValue !== currentValue) {
+            targetNode.setValue(transformedValue, { emitEvent });
+        }
+    }, { debounce });
+}
+/**
+ * Хелпер для создания переиспользуемых трансформаций
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @example
+ * ```typescript
+ * // Создаем переиспользуемые трансформеры
+ * const toUpperCase = createTransformer<string>((value) => value?.toUpperCase());
+ * const toLowerCase = createTransformer<string>((value) => value?.toLowerCase());
+ * const trim = createTransformer<string>((value) => value?.trim());
+ *
+ * // Используем в форме
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   toUpperCase(path.code);
+ *   toLowerCase(path.email);
+ *   trim(path.username);
+ * };
+ * ```
+ */
+export function createTransformer(transformer, defaultOptions) {
+    return (field, options) => {
+        transformValue(field, transformer, { ...defaultOptions, ...options });
+    };
+}
+/**
+ * Готовые трансформеры для частых случаев
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ */
+export const transformers = {
+    /** Перевести в верхний регистр */
+    toUpperCase: createTransformer((value) => value?.toUpperCase()),
+    /** Перевести в нижний регистр */
+    toLowerCase: createTransformer((value) => value?.toLowerCase()),
+    /** Удалить пробелы с краев */
+    trim: createTransformer((value) => value?.trim()),
+    /** Удалить все пробелы */
+    removeSpaces: createTransformer((value) => value?.replace(/\s/g, '')),
+    /** Оставить только цифры */
+    digitsOnly: createTransformer((value) => value?.replace(/\D/g, '')),
+    /** Округлить число */
+    round: createTransformer((value) => typeof value === 'number' ? Math.round(value) : value),
+    /** Округлить до 2 знаков после запятой */
+    roundTo2: createTransformer((value) => typeof value === 'number' ? Math.round(value * 100) / 100 : value),
+};

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

@@ -0,0 +1,35 @@
+/**
+ * Отслеживание изменений поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/watchField
+ */
+import type { FieldPathNode } from '../../types';
+import type { BehaviorContext, WatchFieldOptions } from '../types';
+/**
+ * Выполняет callback при изменении поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для отслеживания
+ * @param callback - Функция обратного вызова
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Динамическая загрузка городов при изменении страны
+ *   watchField(path.registrationAddress.country, async (country, ctx) => {
+ *     if (country) {
+ *       const cities = await fetchCities(country);
+ *       ctx.updateComponentProps(path.registrationAddress.city, {
+ *         options: cities
+ *       });
+ *     }
+ *   });
+ * };
+ * ```
+ */
+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/behaviors/watch-field.js

@@ -0,0 +1,56 @@
+/**
+ * Отслеживание изменений поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/watchField
+ */
+import { effect } from '@preact/signals-core';
+import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
+/**
+ * Выполняет callback при изменении поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для отслеживания
+ * @param callback - Функция обратного вызова
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Динамическая загрузка городов при изменении страны
+ *   watchField(path.registrationAddress.country, async (country, ctx) => {
+ *     if (country) {
+ *       const cities = await fetchCities(country);
+ *       ctx.updateComponentProps(path.registrationAddress.city, {
+ *         options: cities
+ *       });
+ *     }
+ *   });
+ * };
+ * ```
+ */
+export function watchField(field, callback, options) {
+    const { debounce, immediate = false } = options || {};
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler = (form, context, withDebounce) => {
+        const node = form.getFieldByPath(field.__path);
+        if (!node)
+            return null;
+        // Вызвать сразу если immediate: true
+        if (immediate) {
+            const value = node.value.value;
+            callback(value, context);
+        }
+        return effect(() => {
+            const value = node.value.value;
+            withDebounce(() => {
+                callback(value, context);
+            });
+        });
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getCurrentBehaviorRegistry().register(handler, { debounce });
+}

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

@@ -0,0 +1,106 @@
+/**
+ * Композиция behavior схем
+ *
+ * Предоставляет функции для переиспользования behavior схем:
+ * - toBehaviorFieldPath: преобразование FieldPath во вложенный путь
+ * - apply: применение схемы к полям
+ * - applyWhen: условное применение схемы
+ *
+ * Аналог toFieldPath и applyWhen из validation API.
+ */
+import type { FieldPath, FieldPathNode, FormFields, FormValue } from '../types';
+import type { 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;