@reformer/core 1.1.0 → 2.0.0-beta.10

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

@@ -1,81 +0,0 @@
-/**
- * Условное включение/отключение полей
- *
- * @group Behaviors
- * @category Behavior Rules
- * @module behaviors/enableWhen
- */
-import { effect } from '@preact/signals-core';
-import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
-/**
- * Условное включение поля на основе значений других полей
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для включения/выключения
- * @param condition - Функция условия (true = enable, false = disable)
- * @param options - Опции
- *
- * @example
- * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // Включить поле только для ипотеки
- *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage', {
- *     resetOnDisable: true
- *   });
- * };
- * ```
- */
-export function enableWhen(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-field, condition, options) {
-    const { debounce, resetOnDisable = false } = options || {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const handler = (form, _context, withDebounce) => {
-        const targetNode = form.getFieldByPath(field.__path);
-        if (!targetNode)
-            return null;
-        return effect(() => {
-            const formValue = form.value.value;
-            withDebounce(() => {
-                const shouldEnable = condition(formValue);
-                if (shouldEnable) {
-                    targetNode.enable();
-                }
-                else {
-                    targetNode.disable();
-                    if (resetOnDisable) {
-                        targetNode.reset();
-                    }
-                }
-            });
-        });
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getCurrentBehaviorRegistry().register(handler, { debounce });
-}
-/**
- * Условное выключение поля (инверсия enableWhen)
- *
- * @group Behaviors
- * @category Behavior Rules
- *
- * @param field - Поле для выключения
- * @param condition - Функция условия (true = disable, false = enable)
- * @param options - Опции
- *
- * @example
- * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // Выключить поле для потребительского кредита
- *   disableWhen(path.propertyValue, (form) => form.loanType === 'consumer');
- * };
- * ```
- */
-export function disableWhen(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-field, condition, options) {
-    // Инвертируем условие
-    enableWhen(field, (form) => !condition(form), options);
-}

package/dist/core/behavior/behaviors/index.js

@@ -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 } from './reset-when';
-export { transformValue, createTransformer, transformers, } from './transform-value';

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

@@ -1,63 +0,0 @@
-/**
- * Условный сброс полей
- *
- * @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.js

@@ -1,51 +0,0 @@
-/**
- * Перевалидация полей при изменениях
- *
- * @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.js

@@ -1,66 +0,0 @@
-/**
- * Двусторонняя синхронизация полей
- *
- * @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.js

@@ -1,110 +0,0 @@
-/**
- * Трансформация значений полей
- *
- * @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.js

@@ -1,56 +0,0 @@
-/**
- * Отслеживание изменений поля
- *
- * @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.js

@@ -1,166 +0,0 @@
-/**
- * Композиция behavior схем
- *
- * Предоставляет функции для переиспользования behavior схем:
- * - toBehaviorFieldPath: преобразование FieldPath во вложенный путь
- * - apply: применение схемы к полям
- * - applyWhen: условное применение схемы
- *
- * Аналог toFieldPath и applyWhen из validation API.
- */
-import { createFieldPath } from './create-field-path';
-import { watchField } from './behaviors/watch-field';
-// ============================================================================
-// toBehaviorFieldPath - Преобразование FieldPath во вложенный путь
-// ============================================================================
-/**
- * Преобразовать 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 function toBehaviorFieldPath(fieldPath) {
-    if (!fieldPath) {
-        return createFieldPath();
-    }
-    const basePath = fieldPath.__path;
-    return createNestedBehaviorFieldPath(basePath);
-}
-/**
- * Создать вложенный FieldPath с базовым префиксом
- * @private
- */
-function createNestedBehaviorFieldPath(basePath) {
-    return new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop === 'symbol')
-                return undefined;
-            const fullPath = basePath ? `${basePath}.${prop}` : prop;
-            return {
-                __path: fullPath,
-                __key: prop,
-            };
-        },
-    });
-}
-// ============================================================================
-// apply - Применение behavior схемы к полям
-// ============================================================================
-/**
- * Применить 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 function apply(fields, behaviors) {
-    // Нормализуем inputs в массивы
-    const fieldArray = (Array.isArray(fields) ? fields : [fields]).filter(Boolean);
-    const behaviorArray = Array.isArray(behaviors) ? behaviors : [behaviors];
-    // Применяем все схемы ко всем полям
-    for (const field of fieldArray) {
-        const nestedPath = toBehaviorFieldPath(field);
-        for (const behavior of behaviorArray) {
-            behavior(nestedPath);
-        }
-    }
-}
-// ============================================================================
-// applyWhen - Условное применение behavior схемы
-// ============================================================================
-/**
- * Условное применение 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 function applyWhen(conditionField, condition, callback) {
-    if (!conditionField)
-        return;
-    //  ИСПРАВЛЕНО: Регистрируем behaviors только ОДИН РАЗ
-    // вне watchField callback, чтобы избежать утечки памяти
-    let hasRegistered = false;
-    watchField(conditionField, (value, _ctx) => {
-        // Регистрируем behaviors только при первом срабатывании
-        // когда условие выполнено
-        if (!hasRegistered && condition(value)) {
-            const fieldPath = createFieldPath();
-            callback(fieldPath);
-            hasRegistered = true;
-        }
-        // TODO: В будущем можно добавить поддержку деактивации behaviors
-        // при изменении условия, но это требует изменений в BehaviorRegistry
-    }, { immediate: true });
-}

package/dist/core/behavior/create-field-path.d.ts

@@ -1,20 +0,0 @@
-/**
- * Создание типизированного FieldPath для Behavior Schema
- * Аналогично createFieldPath из validators
- */
-import type { FieldPath } from '../types';
-/**
- * Создать типизированный путь к полям формы
- * Используется для декларативного описания behavior схем
- *
- * @example
- * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // path.email, path.address.city и т.д. - типизированы
- *   copyFrom(path.residenceAddress, path.registrationAddress, {
- *     when: (form) => form.sameAsRegistration
- *   });
- * };
- * ```
- */
-export declare function createFieldPath<T>(): FieldPath<T>;