@reformer/core 1.1.0-beta.7 → 1.1.0-beta.8

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.js

@@ -1,69 +0,0 @@
-/**
- * Создание типизированного FieldPath для Behavior Schema
- * Аналогично createFieldPath из validators
- */
-/**
- * Создать типизированный путь к полям формы
- * Используется для декларативного описания behavior схем
- *
- * @example
- * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // path.email, path.address.city и т.д. - типизированы
- *   copyFrom(path.residenceAddress, path.registrationAddress, {
- *     when: (form) => form.sameAsRegistration
- *   });
- * };
- * ```
- */
-export function createFieldPath() {
-    return createFieldPathProxy('');
-}
-/**
- * Создать Proxy для вложенного доступа к полям
- * @private
- */
-function createFieldPathProxy(currentPath) {
-    return new Proxy(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    {}, {
-        get(__target, prop) {
-            // Поддержка обоих вариантов для обратной совместимости
-            if (prop === '__path' || prop === '__fieldPath') {
-                return currentPath || prop;
-            }
-            if (prop === '__key') {
-                const parts = currentPath.split('.');
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return (parts[parts.length - 1] || prop);
-            }
-            const newPath = currentPath ? `${currentPath}.${prop}` : prop;
-            // Создаем объект FieldPathNode с вложенным Proxy
-            const node = {
-                __path: newPath,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                __key: prop,
-                __formType: undefined,
-                __fieldType: undefined,
-            };
-            // Возвращаем Proxy, который поддерживает дальнейшую вложенность
-            return new Proxy(node, {
-                get(_target, nestedProp) {
-                    // Поддержка обоих вариантов для обратной совместимости
-                    if (nestedProp === '__path' || nestedProp === '__fieldPath') {
-                        return newPath;
-                    }
-                    if (nestedProp === '__key') {
-                        return prop;
-                    }
-                    if (nestedProp === '__formType' || nestedProp === '__fieldType') {
-                        return undefined;
-                    }
-                    // Для вложенных свойств создаем новый Proxy
-                    const nestedPath = `${newPath}.${nestedProp}`;
-                    return createFieldPathProxy(nestedPath);
-                },
-            });
-        },
-    });
-}

package/dist/core/behavior/index.js

@@ -1,17 +0,0 @@
-/**
- * Behavior Schema API - Декларативное описание реактивного поведения форм
- *
- * @group Behaviors
- * @module behaviors
- */
-// Функции для декларативного описания поведения
-// Behaviors
-export * from './behaviors';
-// Композиция behavior схем (аналог toFieldPath из validation API)
-export { apply, applyWhen, toBehaviorFieldPath } from './compose-behavior';
-// Вспомогательные классы и функции
-// Примечание: BehaviorRegistry (глобальный singleton) был удален в пользу
-// локальных экземпляров BehaviorRegistry в каждом GroupNode
-export { BehaviorRegistry } from './behavior-registry';
-export { BehaviorContextImpl } from './behavior-context';
-export { createFieldPath } from './create-field-path';

package/dist/core/behavior/types.js

@@ -1,7 +0,0 @@
-/**
- * Типы и интерфейсы для Behavior Schema API
- *
- * @group Behaviors
- * @category Behavior Types
- */
-export {};

package/dist/core/context/form-context-impl.js

@@ -1,37 +0,0 @@
-/**
- * Реализация единого FormContext
- *
- * Используется как базовая реализация для behavior и validation контекстов
- */
-/**
- * Базовая реализация FormContext
- *
- * Предоставляет:
- * - `form` - типизированный Proxy-доступ к форме
- * - `setFieldValue` - безопасная установка значения (emitEvent: false)
- */
-export class FormContextImpl {
-    /**
-     * Форма с типизированным Proxy-доступом к полям
-     */
-    form;
-    _groupNode;
-    constructor(groupNode) {
-        this._groupNode = groupNode;
-        // Используем _proxyInstance если доступен, иначе fallback
-        this.form = (groupNode
-            ._proxyInstance || groupNode.getProxy());
-    }
-    /**
-     * Безопасно установить значение поля по строковому пути
-     *
-     * Автоматически использует emitEvent: false для предотвращения циклов
-     */
-    setFieldValue(path, value) {
-        const node = this._groupNode.getFieldByPath(path);
-        if (node) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            node.setValue(value, { emitEvent: false });
-        }
-    }
-}

package/dist/core/factories/index.js

@@ -1,6 +0,0 @@
-/**
- * Фабрики для создания узлов формы
- *
- * Централизованное место для всех фабрик и builder-паттернов.
- */
-export { NodeFactory } from './node-factory';

package/dist/core/factories/node-factory.js

@@ -1,281 +0,0 @@
-/**
- * NodeFactory - фабрика для создания узлов формы
- *
- * Инкапсулирует логику определения типа конфига и создания соответствующего узла.
- * Используется в GroupNode и ArrayNode для создания дочерних узлов.
- *
- * Паттерн Factory Method упрощает создание узлов и делает код более читаемым:
- * - Вместо if-else в GroupNode/ArrayNode
- * - Единая точка для создания узлов
- * - Легко добавлять новые типы узлов
- *
- * @example
- * ```typescript
- * const factory = new NodeFactory();
- *
- * // Создание FieldNode
- * const field = factory.createNode({ value: '', component: Input });
- *
- * // Создание GroupNode
- * const group = factory.createNode({
- *   email: { value: '', component: Input },
- *   password: { value: '', component: Input }
- * });
- *
- * // Создание ArrayNode
- * const array = factory.createNode({
- *   schema: { title: { value: '', component: Input } },
- *   initialItems: []
- * });
- * ```
- */
-import { FieldNode } from '../nodes/field-node';
-import { GroupNode } from '../nodes/group-node';
-import { ArrayNode } from '../nodes/array-node';
-/**
- * Фабрика для создания узлов формы
- *
- * Определяет тип конфига и создает соответствующий узел (FieldNode, GroupNode, ArrayNode)
- */
-export class NodeFactory {
-    /**
-     * Создает узел формы на основе конфигурации
-     *
-     * ✅ ОБНОВЛЕНО: Теперь поддерживает массивы напрямую
-     *
-     * Автоматически определяет тип узла:
-     * - FieldNode: имеет value и component
-     * - ArrayNode: массив [schema, ...items] или { schema, initialItems }
-     * - GroupNode: объект без value, component, schema
-     *
-     * @param config Конфигурация узла
-     * @returns Экземпляр FieldNode, GroupNode или ArrayNode
-     * @throws Error если конфиг не соответствует ни одному типу
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * // FieldNode
-     * const field = factory.createNode({
-     *   value: 'test@mail.com',
-     *   component: Input,
-     *   validators: [required, email]
-     * });
-     *
-     * // GroupNode
-     * const group = factory.createNode({
-     *   email: { value: '', component: Input },
-     *   password: { value: '', component: Input }
-     * });
-     *
-     * // ArrayNode (объект)
-     * const array = factory.createNode({
-     *   schema: { title: { value: '', component: Input } },
-     *   initialItems: [{ title: 'Item 1' }]
-     * });
-     *
-     * // ArrayNode (массив) - новый формат
-     * const array2 = factory.createNode([
-     *   { title: { value: '', component: Input } }, // schema
-     *   { title: 'Item 1' }, // initial item 1
-     *   { title: 'Item 2' }  // initial item 2
-     * ]);
-     * ```
-     */
-    createNode(config) {
-        // 0. ✅ НОВОЕ: Проверка массива (приоритет: специфический формат)
-        if (Array.isArray(config) && config.length >= 1) {
-            return this.createArrayNodeFromArray(config);
-        }
-        // 1. Проверка FieldConfig (приоритет: самый специфичный тип)
-        if (this.isFieldConfig(config)) {
-            return new FieldNode(config);
-        }
-        // 2. Проверка ArrayConfig
-        if (this.isArrayConfig(config)) {
-            const arrayConfig = config;
-            return new ArrayNode(arrayConfig.schema, arrayConfig.initialItems);
-        }
-        // 3. Проверка GroupConfig (самый общий тип)
-        if (this.isGroupConfig(config)) {
-            return new GroupNode(config);
-        }
-        // Неизвестный конфиг
-        throw new Error(`NodeFactory: Unknown node config. Expected FieldConfig, GroupConfig, or ArrayConfig, but got: ${JSON.stringify(config)}`);
-    }
-    /**
-     * Создать ArrayNode из массива [schema, ...initialItems]
-     *
-     * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
-     *
-     * Формат: [itemSchema, ...initialItems]
-     * - Первый элемент - схема элемента массива
-     * - Остальные элементы - начальные значения
-     *
-     * @param config Массив с схемой и начальными элементами
-     * @returns ArrayNode
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * // Массив с начальными элементами
-     * const array = factory.createArrayNodeFromArray([
-     *   { title: { value: '', component: Input } }, // schema
-     *   { title: 'Item 1' }, // initial value
-     *   { title: 'Item 2' }  // initial value
-     * ]);
-     * ```
-     * @private
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    createArrayNodeFromArray(config) {
-        const [itemSchema, ...restItems] = config;
-        // Обработка начальных элементов:
-        // Если элемент - схема группы, извлечь значения
-        const initialItems = [];
-        //  ИСПРАВЛЕНИЕ: Первый элемент является и схемой, и первым элементом данных
-        // Если первый элемент имеет значения (GroupConfig с value), добавляем его как первый item
-        if (this.isGroupConfig(itemSchema)) {
-            initialItems.push(this.extractValues(itemSchema));
-        }
-        // Добавляем остальные элементы
-        for (const item of restItems) {
-            if (this.isGroupConfig(item)) {
-                initialItems.push(this.extractValues(item));
-            }
-            else {
-                initialItems.push(item);
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new ArrayNode(itemSchema, initialItems);
-    }
-    /**
-     * Извлечь значения из схемы (рекурсивно)
-     *
-     * ✅ НОВОЕ: Извлечено из GroupNode для централизации логики
-     *
-     * Преобразует схему формы в объект со значениями:
-     * - `{ name: { value: 'John', component: Input } } → { name: 'John' }`
-     * - Поддерживает вложенные группы
-     * - Поддерживает массивы
-     *
-     * @param schema Схема формы
-     * @returns Объект со значениями полей
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * const schema = {
-     *   name: { value: 'John', component: Input },
-     *   age: { value: 30, component: Input },
-     *   address: {
-     *     city: { value: 'Moscow', component: Input }
-     *   }
-     * };
-     *
-     * factory.extractValues(schema);
-     * // { name: 'John', age: 30, address: { city: 'Moscow' } }
-     * ```
-     */
-    extractValues(schema) {
-        // 1. FieldConfig - вернуть value
-        if (this.isFieldConfig(schema)) {
-            return schema.value;
-        }
-        // 2. Массив - рекурсивно обработать элементы
-        if (Array.isArray(schema)) {
-            return schema.map((item) => this.extractValues(item));
-        }
-        // 3. GroupConfig - рекурсивно извлечь значения всех полей
-        if (this.isGroupConfig(schema)) {
-            const result = {};
-            for (const [key, config] of Object.entries(schema)) {
-                result[key] = this.extractValues(config);
-            }
-            return result;
-        }
-        // 4. Примитивное значение - вернуть как есть
-        return schema;
-    }
-    /**
-     * Проверяет, является ли конфиг конфигурацией поля (FieldConfig)
-     *
-     * FieldConfig имеет обязательные свойства:
-     * - value: начальное значение поля
-     * - component: React-компонент для отображения
-     *
-     * @param config Проверяемая конфигурация
-     * @returns true если config является FieldConfig
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * factory.isFieldConfig({ value: '', component: Input }); // true
-     * factory.isFieldConfig({ email: { value: '' } }); // false
-     * factory.isFieldConfig(null); // false
-     * ```
-     */
-    isFieldConfig(config) {
-        return (config != null && typeof config === 'object' && 'value' in config && 'component' in config);
-    }
-    /**
-     * Проверяет, является ли конфиг конфигурацией массива (ArrayConfig)
-     *
-     * ArrayConfig имеет обязательное свойство:
-     * - schema: схема для элементов массива
-     *
-     * И НЕ имеет:
-     * - value (отличие от FieldConfig)
-     *
-     * @param config Проверяемая конфигурация
-     * @returns true если config является ArrayConfig
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * factory.isArrayConfig({ schema: {}, initialItems: [] }); // true
-     * factory.isArrayConfig({ value: '', component: Input }); // false
-     * factory.isArrayConfig({ email: { value: '' } }); // false
-     * ```
-     */
-    isArrayConfig(config) {
-        return (config != null && typeof config === 'object' && 'schema' in config && !('value' in config));
-    }
-    /**
-     * Проверяет, является ли конфиг конфигурацией группы (GroupConfig)
-     *
-     * GroupConfig - это объект, который:
-     * - НЕ является FieldConfig (нет value/component)
-     * - НЕ является ArrayConfig (нет schema)
-     * - Содержит вложенные конфиги полей/групп/массивов
-     *
-     * @param config Проверяемая конфигурация
-     * @returns true если config является GroupConfig
-     *
-     * @example
-     * ```typescript
-     * const factory = new NodeFactory();
-     *
-     * factory.isGroupConfig({
-     *   email: { value: '', component: Input },
-     *   password: { value: '', component: Input }
-     * }); // true
-     *
-     * factory.isGroupConfig({ value: '', component: Input }); // false
-     * factory.isGroupConfig({ schema: {} }); // false
-     * factory.isGroupConfig(null); // false
-     * ```
-     */
-    isGroupConfig(config) {
-        return (config != null &&
-            typeof config === 'object' &&
-            !this.isFieldConfig(config) &&
-            !this.isArrayConfig(config));
-    }
-}