@reformer/core 1.0.0-beta.3

package/dist/core/behavior/behavior-registry.js

@@ -0,0 +1,198 @@
+/**
+ * BehaviorRegistry - регистрация и управление behavior схемами
+ *
+ * Аналогично ValidationRegistry, но для реактивного поведения форм
+ */
+import { BehaviorContextImpl } from './behavior-context';
+import { RegistryStack } from '../utils/registry-stack';
+/**
+ * Реестр behaviors для формы
+ *
+ * Каждый экземпляр GroupNode создает собственный реестр (композиция).
+ * Устраняет race conditions и изолирует формы друг от друга.
+ *
+ * Context stack используется для tracking текущего активного реестра:
+ * - beginRegistration() помещает this в stack
+ * - endRegistration() извлекает из stack
+ * - getCurrent() возвращает текущий активный реестр
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly behaviorRegistry = new BehaviorRegistry();
+ *
+ *   applyBehaviorSchema(schemaFn) {
+ *     this.behaviorRegistry.beginRegistration(); // Pushes this to stack
+ *     schemaFn(createBehaviorFieldPath(this));   // Uses getCurrent()
+ *     return this.behaviorRegistry.endRegistration(this); // Pops from stack
+ *   }
+ * }
+ * ```
+ */
+export class BehaviorRegistry {
+    /**
+     * Stack активных контекстов регистрации
+     * Используется для изоляции форм друг от друга
+     */
+    static contextStack = new RegistryStack();
+    registrations = [];
+    isRegistering = false;
+    /**
+     * Получить текущий активный реестр из context stack
+     *
+     * @returns Текущий активный реестр или null
+     *
+     * @example
+     * ```typescript
+     * // В schema-behaviors.ts
+     * export function copyFrom(...) {
+     *   const registry = BehaviorRegistry.getCurrent();
+     *   if (registry) {
+     *     registry.register({ ... });
+     *   }
+     * }
+     * ```
+     */
+    static getCurrent() {
+        return BehaviorRegistry.contextStack.getCurrent();
+    }
+    /**
+     * Начать регистрацию behaviors
+     * Вызывается перед применением схемы
+     *
+     * Помещает this в context stack для изоляции форм
+     */
+    beginRegistration() {
+        this.isRegistering = true;
+        this.registrations = [];
+        // Помещаем this в stack для tracking текущего активного реестра
+        BehaviorRegistry.contextStack.push(this);
+    }
+    /**
+     * Зарегистрировать behavior handler
+     * Вызывается функциями из schema-behaviors.ts
+     *
+     * @param handler - BehaviorHandlerFn функция
+     * @param options - Опции behavior (debounce)
+     *
+     * @example
+     * ```typescript
+     * const handler = createCopyBehavior(target, source, { when: ... });
+     * registry.register(handler, { debounce: 300 });
+     * ```
+     */
+    register(handler, options) {
+        if (!this.isRegistering) {
+            if (import.meta.env.DEV) {
+                throw new Error('BehaviorRegistry: call beginRegistration() before registering behaviors');
+            }
+            return;
+        }
+        this.registrations.push({
+            // Type assertion безопасен: handler будет вызван с правильным типом формы в createEffect
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            handler: handler,
+            debounce: options?.debounce,
+        });
+    }
+    /**
+     * Завершить регистрацию и применить behaviors к форме
+     * Создает effect подписки для всех зарегистрированных behaviors
+     *
+     * Извлекает this из context stack
+     *
+     * @param form - GroupNode формы
+     * @returns Количество зарегистрированных behaviors и функция cleanup
+     */
+    endRegistration(form) {
+        this.isRegistering = false;
+        // Извлекаем из stack с проверкой
+        BehaviorRegistry.contextStack.verify(this, 'BehaviorRegistry');
+        const context = new BehaviorContextImpl(form);
+        const disposeCallbacks = [];
+        // Создаем effect подписки для каждого behavior
+        for (const registered of this.registrations) {
+            const dispose = this.createEffect(registered, form, context);
+            if (dispose) {
+                disposeCallbacks.push(dispose);
+            }
+        }
+        // Функция cleanup для отписки от всех effects
+        const cleanup = () => {
+            disposeCallbacks.forEach((dispose) => dispose());
+        };
+        return {
+            count: this.registrations.length,
+            cleanup,
+        };
+    }
+    /**
+     * Создать effect подписку для behavior
+     * @private
+     */
+    createEffect(registered, form, context) {
+        const { handler, debounce: debounceMs = 0 } = registered;
+        let debounceTimer = null;
+        // Обертка для debounce
+        const withDebounce = (callback) => {
+            if (debounceMs > 0) {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(callback, debounceMs);
+            }
+            else {
+                callback();
+            }
+        };
+        // Cleanup функция для debounce таймера
+        const cleanupDebounce = () => {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = null;
+            }
+        };
+        // Вызываем handler напрямую
+        // Type assertion необходим из-за contravariance: handler хранится как
+        // BehaviorHandlerFn<FormFields>, но вызывается с более специфичным типом T.
+        // Используем any для обхода ограничений TypeScript при хранении generic handlers в массиве.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const effectDispose = handler(form, context, withDebounce);
+        if (!effectDispose) {
+            return null;
+        }
+        // Возвращаем комбинированный cleanup
+        // который очищает и effect, и debounce таймер
+        return () => {
+            cleanupDebounce();
+            if (effectDispose) {
+                effectDispose();
+            }
+        };
+    }
+}
+// ============================================================================
+// Глобальный экземпляр BehaviorRegistry УДАЛЕН
+// ============================================================================
+//
+// Ранее здесь был глобальный Singleton экземпляр BehaviorRegistry,
+// который создавал race conditions и нарушал изоляцию форм.
+//
+//  Теперь каждый GroupNode создает собственный экземпляр BehaviorRegistry:
+//
+// @example
+// ```typescript
+// class GroupNode {
+//   private readonly behaviorRegistry = new BehaviorRegistry();
+//
+//   applyBehaviorSchema(schemaFn) {
+//     this.behaviorRegistry.beginRegistration();
+//     schemaFn(createBehaviorFieldPath(this));
+//     return this.behaviorRegistry.endRegistration(this);
+//   }
+// }
+// ```
+//
+// Это обеспечивает:
+// - Полную изоляцию форм друг от друга
+// - Отсутствие race conditions при параллельной регистрации
+// - Возможность применять разные behavior схемы к разным формам одновременно

package/dist/core/behavior/behaviors/compute-from.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Вычисляемые поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/computeFrom
+ */
+import type { FieldPathNode } from '../../types';
+import type { ComputeFromOptions } from '../types';
+/**
+ * Автоматически вычисляет значение поля на основе других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param sources - Массив полей-зависимостей
+ * @param target - Поле для записи результата
+ * @param computeFn - Функция вычисления (принимает объект с именами полей)
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Автоматический расчет минимального взноса
+ *   computeFrom(
+ *     [path.propertyValue],
+ *     path.initialPayment,
+ *     (values) => values.propertyValue ? values.propertyValue * 0.2 : null,
+ *     { debounce: 300 }
+ *   );
+ *
+ *   // Общая стоимость = цена * количество
+ *   computeFrom(
+ *     [path.price, path.quantity],
+ *     path.total,
+ *     (values) => values.price * values.quantity
+ *   );
+ * };
+ * ```
+ */
+export declare function computeFrom<TForm, TTarget>(sources: FieldPathNode<TForm, any>[], target: FieldPathNode<TForm, TTarget>, computeFn: (values: TForm) => TTarget, options?: ComputeFromOptions<TForm>): void;

package/dist/core/behavior/behaviors/compute-from.js

@@ -0,0 +1,84 @@
+/**
+ * Вычисляемые поля
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/computeFrom
+ */
+import { effect } from '@preact/signals-core';
+import { getCurrentBehaviorRegistry } from '../../utils/registry-helpers';
+/**
+ * Автоматически вычисляет значение поля на основе других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param sources - Массив полей-зависимостей
+ * @param target - Поле для записи результата
+ * @param computeFn - Функция вычисления (принимает объект с именами полей)
+ * @param options - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Автоматический расчет минимального взноса
+ *   computeFrom(
+ *     [path.propertyValue],
+ *     path.initialPayment,
+ *     (values) => values.propertyValue ? values.propertyValue * 0.2 : null,
+ *     { debounce: 300 }
+ *   );
+ *
+ *   // Общая стоимость = цена * количество
+ *   computeFrom(
+ *     [path.price, path.quantity],
+ *     path.total,
+ *     (values) => values.price * values.quantity
+ *   );
+ * };
+ * ```
+ */
+export function computeFrom(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+sources, target, computeFn, options) {
+    const { debounce, condition } = options || {};
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler = (form, _context, withDebounce) => {
+        const targetNode = form.getFieldByPath(target.__path);
+        if (!targetNode)
+            return null;
+        // Разрешаем source узлы
+        const sourceNodes = sources
+            .map((field) => form.getFieldByPath(field.__path))
+            .filter((node) => node !== undefined);
+        if (sourceNodes.length === 0)
+            return null;
+        return effect(() => {
+            // Читаем значения всех source полей
+            const sourceValues = sourceNodes.map((node) => node.value.value);
+            withDebounce(() => {
+                // Проверка условия
+                if (condition) {
+                    const formValue = form.getValue();
+                    if (!condition(formValue))
+                        return;
+                }
+                // Создаем объект с именами полей для computeFn
+                // computeFn ожидает объект вида { fieldName: value, ... }
+                const sourceValuesObject = {};
+                sources.forEach((source, index) => {
+                    // Извлекаем имя поля из пути (последний сегмент)
+                    const fieldName = source.__path.split('.').pop() || source.__path;
+                    sourceValuesObject[fieldName] = sourceValues[index];
+                });
+                // Вычисляем новое значение
+                const computedValue = computeFn(sourceValuesObject);
+                // Устанавливаем значение без триггера событий
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                targetNode.setValue(computedValue, { emitEvent: false });
+            });
+        });
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getCurrentBehaviorRegistry().register(handler, { debounce });
+}

package/dist/core/behavior/behaviors/copy-from.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Копирование значений между полями
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/copyFrom
+ */
+import type { FieldPathNode } from '../../types';
+import type { CopyFromOptions } from '../types';
+/**
+ * Копирует значения из одного поля/группы в другое при выполнении условия
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param source - Откуда копировать
+ * @param target - Куда копировать
+ * @param options - Опции копирования
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Копировать адрес регистрации в адрес проживания
+ *   copyFrom(path.registrationAddress, path.residenceAddress, {
+ *     when: (form) => form.sameAsRegistration === true,
+ *     fields: 'all'
+ *   });
+ * };
+ * ```
+ */
+export declare function copyFrom<TForm, TSource, TTarget>(source: FieldPathNode<TForm, TSource>, target: FieldPathNode<TForm, TTarget>, options?: CopyFromOptions<TSource, TForm>): void;

package/dist/core/behavior/behaviors/copy-from.js

@@ -0,0 +1,64 @@
+/**
+ * Копирование значений между полями
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/copyFrom
+ */
+import { watchField } from './watch-field';
+/**
+ * Копирует значения из одного поля/группы в другое при выполнении условия
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param source - Откуда копировать
+ * @param target - Куда копировать
+ * @param options - Опции копирования
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Копировать адрес регистрации в адрес проживания
+ *   copyFrom(path.registrationAddress, path.residenceAddress, {
+ *     when: (form) => form.sameAsRegistration === true,
+ *     fields: 'all'
+ *   });
+ * };
+ * ```
+ */
+export function copyFrom(source, target, options) {
+    const { when, fields = 'all', transform, debounce } = options || {};
+    watchField(source, (sourceValue, ctx) => {
+        // Проверка условия
+        if (when) {
+            const formValue = ctx.form.getValue();
+            if (!when(formValue))
+                return;
+        }
+        // Трансформация значения
+        const value = transform ? transform(sourceValue) : sourceValue;
+        // Получаем target node
+        const targetNode = ctx.form.getFieldByPath(target.__path);
+        if (!targetNode)
+            return;
+        // Копирование
+        if (fields === 'all' || !fields) {
+            targetNode.setValue(value, { emitEvent: false });
+        }
+        else {
+            // Частичное копирование для групп
+            const patch = {};
+            fields.forEach((key) => {
+                if (sourceValue && typeof sourceValue === 'object') {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    patch[key] = sourceValue[key];
+                }
+            });
+            if ('patchValue' in targetNode) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                targetNode.patchValue(patch);
+            }
+        }
+    }, { debounce });
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Условное включение/отключение полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/enableWhen
+ */
+import type { FieldPathNode } from '../../types';
+import type { EnableWhenOptions } from '../types';
+/**
+ * Условное включение поля на основе значений других полей
+ *
+ * @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 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 - Опции
+ *
+ * @example
+ * ```typescript
+ * const schema: BehaviorSchemaFn<MyForm> = (path) => {
+ *   // Выключить поле для потребительского кредита
+ *   disableWhen(path.propertyValue, (form) => form.loanType === 'consumer');
+ * };
+ * ```
+ */
+export declare function disableWhen<TForm>(field: FieldPathNode<TForm, any>, condition: (form: TForm) => boolean, options?: EnableWhenOptions): void;

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

@@ -0,0 +1,81 @@
+/**
+ * Условное включение/отключение полей
+ *
+ * @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.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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/index.js

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

@@ -0,0 +1,51 @@
+/**
+ * Условный сброс полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ * @module behaviors/resetWhen
+ */
+import type { 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 - Опции
+ *
+ * @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 declare function resetWhen<TForm extends FormFields>(field: FieldPathNode<TForm, FormValue>, condition: (form: TForm) => boolean, options?: ResetWhenOptions & {
+    debounce?: number;
+}): void;