@reformer/core 1.1.0 → 2.0.0-beta.2

package/dist/core/utils/field-path-navigator.js

@@ -1,374 +0,0 @@
-/**
- * Навигация по путям к полям формы
- *
- * Централизует логику парсинга и навигации по путям к полям формы.
- * Используется в ValidationContext, BehaviorContext, GroupNode для единообразной
- * обработки путей вида "address.city" или "items[0].name".
- *
- * Устраняет дублирование логики парсинга путей в 4 местах кодовой базы.
- *
- * @internal
- *
- * @example
- * ```typescript
- * const navigator = new FieldPathNavigator();
- *
- * // Парсинг пути
- * const segments = navigator.parsePath('items[0].title');
- * // [{ key: 'items', index: 0 }, { key: 'title' }]
- *
- * // Получение значения из объекта
- * const obj = { items: [{ title: 'Item 1' }] };
- * const value = navigator.getValueByPath(obj, 'items[0].title');
- * // 'Item 1'
- *
- * // Получение узла формы
- * const titleNode = navigator.getNodeByPath(form, 'items[0].title');
- * titleNode?.setValue('New Title');
- * ```
- */
-export class FieldPathNavigator {
-    /**
-     * Парсит путь в массив сегментов
-     *
-     * Поддерживаемые форматы:
-     * - Простые пути: "name", "email"
-     * - Вложенные пути: "address.city", "user.profile.avatar"
-     * - Массивы: "items[0]", "items[0].name", "tags[1][0]"
-     * - Комбинации: "orders[0].items[1].price"
-     *
-     * @param path Путь к полю (строка с точками и квадратными скобками)
-     * @returns Массив сегментов пути
-     *
-     * @example
-     * ```typescript
-     * navigator.parsePath('email');
-     * // [{ key: 'email' }]
-     *
-     * navigator.parsePath('address.city');
-     * // [{ key: 'address' }, { key: 'city' }]
-     *
-     * navigator.parsePath('items[0].name');
-     * // [{ key: 'items', index: 0 }, { key: 'name' }]
-     * ```
-     */
-    parsePath(path) {
-        const segments = [];
-        let currentPart = '';
-        let inBrackets = false;
-        for (let i = 0; i < path.length; i++) {
-            const char = path[i];
-            if (char === '[') {
-                inBrackets = true;
-                currentPart += char;
-            }
-            else if (char === ']') {
-                inBrackets = false;
-                currentPart += char;
-            }
-            else if (char === '.' && !inBrackets) {
-                // Разделитель найден, обрабатываем накопленную часть
-                if (currentPart) {
-                    this.addSegment(segments, currentPart);
-                    currentPart = '';
-                }
-            }
-            else {
-                currentPart += char;
-            }
-        }
-        // Добавляем последнюю часть
-        if (currentPart) {
-            this.addSegment(segments, currentPart);
-        }
-        return segments;
-    }
-    /**
-     * Добавляет сегмент в массив, обрабатывая массивы
-     * @private
-     */
-    addSegment(segments, part) {
-        // Проверка на массив: items[0]
-        const arrayMatch = part.match(/^(.+)\[(\d+)\]$/);
-        if (arrayMatch) {
-            segments.push({
-                key: arrayMatch[1],
-                index: parseInt(arrayMatch[2], 10),
-            });
-        }
-        else {
-            segments.push({ key: part });
-        }
-    }
-    /**
-     * Получает значение по пути из объекта
-     *
-     * Проходит по всем сегментам пути и возвращает конечное значение.
-     * Если путь не найден, возвращает undefined.
-     *
-     * @param obj Объект для навигации
-     * @param path Путь к значению
-     * @returns Значение или undefined, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const obj = {
-     *   email: 'test@mail.com',
-     *   address: { city: 'Moscow' },
-     *   items: [{ title: 'Item 1' }]
-     * };
-     *
-     * navigator.getValueByPath(obj, 'email');
-     * // 'test@mail.com'
-     *
-     * navigator.getValueByPath(obj, 'address.city');
-     * // 'Moscow'
-     *
-     * navigator.getValueByPath(obj, 'items[0].title');
-     * // 'Item 1'
-     *
-     * navigator.getValueByPath(obj, 'invalid.path');
-     * // undefined
-     * ```
-     */
-    getValueByPath(obj, path) {
-        const segments = this.parsePath(path);
-        let current = obj;
-        for (const segment of segments) {
-            if (current == null)
-                return undefined;
-            current = current[segment.key];
-            if (segment.index !== undefined) {
-                if (!Array.isArray(current))
-                    return undefined;
-                current = current[segment.index];
-            }
-        }
-        return current;
-    }
-    /**
-     * Устанавливает значение по пути в объекте (мутирует объект)
-     *
-     * Создает промежуточные объекты, если они не существуют.
-     * Выбрасывает ошибку, если ожидается массив, но его нет.
-     *
-     * @param obj Объект для модификации
-     * @param path Путь к значению
-     * @param value Новое значение
-     *
-     * @throws {Error} Если ожидается массив по пути, но его нет
-     *
-     * @example
-     * ```typescript
-     * const obj = { address: { city: '' } };
-     * navigator.setValueByPath(obj, 'address.city', 'Moscow');
-     * // obj.address.city === 'Moscow'
-     *
-     * const obj2: UnknownRecord = {};
-     * navigator.setValueByPath(obj2, 'address.city', 'Moscow');
-     * // Создаст { address: { city: 'Moscow' } }
-     *
-     * const obj3 = { items: [{ title: 'Old' }] };
-     * navigator.setValueByPath(obj3, 'items[0].title', 'New');
-     * // obj3.items[0].title === 'New'
-     * ```
-     */
-    setValueByPath(obj, path, value) {
-        const segments = this.parsePath(path);
-        if (segments.length === 0) {
-            throw new Error('Cannot set value: empty path');
-        }
-        let current = obj;
-        // Проходим до предпоследнего сегмента
-        for (let i = 0; i < segments.length - 1; i++) {
-            const segment = segments[i];
-            let next = current[segment.key];
-            if (segment.index !== undefined) {
-                // Доступ к массиву: items[0]
-                if (!Array.isArray(next)) {
-                    throw new Error(`Expected array at path segment: ${segment.key}, but got ${typeof next}`);
-                }
-                current = next[segment.index];
-            }
-            else {
-                // Доступ к объекту: address
-                if (next == null) {
-                    // Создаем объект, если его нет
-                    current[segment.key] = {};
-                    next = current[segment.key];
-                }
-                current = next;
-            }
-        }
-        // Устанавливаем значение в последнем сегменте
-        const lastSegment = segments[segments.length - 1];
-        if (lastSegment.index !== undefined) {
-            const arr = current[lastSegment.key];
-            if (!Array.isArray(arr)) {
-                throw new Error(`Expected array at path segment: ${lastSegment.key}, but got ${typeof arr}`);
-            }
-            arr[lastSegment.index] = value;
-        }
-        else {
-            current[lastSegment.key] = value;
-        }
-    }
-    /**
-     * Получить значение из FormNode по пути
-     *
-     * Автоматически извлекает значение из FormNode (через .value.value).
-     * Используется в ValidationContext и BehaviorContext для единообразного
-     * доступа к значениям полей формы.
-     *
-     * @param form Корневой узел формы (обычно GroupNode)
-     * @param path Путь к полю
-     * @returns Значение поля или undefined, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: 'test@mail.com', component: Input },
-     *   address: {
-     *     city: { value: 'Moscow', component: Input }
-     *   },
-     *   items: [{ title: { value: 'Item 1', component: Input } }]
-     * });
-     *
-     * navigator.getFormNodeValue(form, 'email');
-     * // 'test@mail.com'
-     *
-     * navigator.getFormNodeValue(form, 'address.city');
-     * // 'Moscow'
-     *
-     * navigator.getFormNodeValue(form, 'items[0].title');
-     * // 'Item 1'
-     *
-     * navigator.getFormNodeValue(form, 'invalid.path');
-     * // undefined
-     * ```
-     */
-    getFormNodeValue(form, path) {
-        const node = this.getNodeByPath(form, path);
-        if (node == null) {
-            return undefined;
-        }
-        // FormNode возвращает .value.value
-        if (this.isFormNode(node)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return node.value.value;
-        }
-        // Для обычных объектов возвращаем как есть
-        return node;
-    }
-    /**
-     * Type guard для проверки, является ли объект FormNode
-     *
-     * Проверяет наличие характерных свойств FormNode:
-     * - value (Signal)
-     * - value.value (значение Signal)
-     *
-     * @param obj Объект для проверки
-     * @returns true, если объект является FormNode
-     * @private
-     */
-    isFormNode(obj) {
-        return (obj != null &&
-            typeof obj === 'object' &&
-            'value' in obj &&
-            typeof obj.value === 'object' &&
-            obj.value != null &&
-            'value' in obj.value);
-    }
-    /**
-     * Получает узел формы по пути
-     *
-     * Навигирует по структуре FormNode (GroupNode/FieldNode/ArrayNode)
-     * и возвращает узел по указанному пути.
-     *
-     * Поддерживает:
-     * - Доступ к полям GroupNode через fields Map
-     * - Доступ к элементам ArrayNode через индекс
-     * - Proxy-доступ к полям (для обратной совместимости)
-     *
-     * @param form Корневой узел формы (обычно GroupNode)
-     * @param path Путь к узлу
-     * @returns Узел формы или null, если путь не найден
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: '', component: Input },
-     *   address: {
-     *     city: { value: '', component: Input }
-     *   },
-     *   items: [{ title: { value: '', component: Input } }]
-     * });
-     *
-     * const emailNode = navigator.getNodeByPath(form, 'email');
-     * // FieldNode
-     *
-     * const cityNode = navigator.getNodeByPath(form, 'address.city');
-     * // FieldNode
-     *
-     * const itemNode = navigator.getNodeByPath(form, 'items[0]');
-     * // GroupNode
-     *
-     * const titleNode = navigator.getNodeByPath(form, 'items[0].title');
-     * // FieldNode
-     *
-     * const invalidNode = navigator.getNodeByPath(form, 'invalid.path');
-     * // null
-     * ```
-     */
-    getNodeByPath(form, path) {
-        const segments = this.parsePath(path);
-        let current = form;
-        for (const segment of segments) {
-            if (current == null)
-                return null;
-            const currentRecord = current;
-            // Для GroupNode: доступ через fields Map
-            if (currentRecord.fields && currentRecord.fields instanceof Map) {
-                current = currentRecord.fields.get(segment.key);
-                // Если это не ArrayNode или нет индекса, продолжаем
-                if (segment.index === undefined) {
-                    if (current == null)
-                        return null;
-                    continue;
-                }
-            }
-            // Для ArrayNode: доступ через items и индекс
-            else if (segment.index !== undefined && currentRecord.items) {
-                const items = currentRecord.items.value || currentRecord.items;
-                if (!Array.isArray(items))
-                    return null;
-                current = items[segment.index];
-                if (current == null)
-                    return null;
-                continue;
-            }
-            // Proxy-доступ (для обратной совместимости)
-            else if (segment.index === undefined) {
-                current = currentRecord[segment.key];
-                if (current == null)
-                    return null;
-                continue;
-            }
-            // Если нашли ArrayNode и есть индекс, получаем элемент массива
-            if (current && segment.index !== undefined && current.items) {
-                const items = current.items.value ||
-                    current.items;
-                if (!Array.isArray(items))
-                    return null;
-                current = items[segment.index];
-            }
-            // Если запрашивается индекс, но узел не является ArrayNode, возвращаем null
-            else if (current && segment.index !== undefined && !current.items) {
-                return null;
-            }
-            if (current == null)
-                return null;
-        }
-        return current;
-    }
-}

package/dist/core/utils/index.js

@@ -1,14 +0,0 @@
-/**
- * Утилиты для работы с формами
- *
- * Централизованные вспомогательные классы и функции.
- */
-export { FieldPathNavigator } from './field-path-navigator';
-export { SubscriptionManager } from './subscription-manager';
-export { getCurrentValidationRegistry, getCurrentBehaviorRegistry } from './registry-helpers';
-export { RegistryStack } from './registry-stack';
-export { isFormNode, isFieldNode, isGroupNode, isArrayNode, getNodeType } from './type-guards';
-export { Debouncer } from './debounce';
-export { FormErrorHandler, ErrorStrategy } from './error-handler';
-export { createForm } from './create-form';
-export * from './resources';

package/dist/core/utils/registry-helpers.js

@@ -1,79 +0,0 @@
-/**
- * Вспомогательные функции для работы с реестрами
- *
- * Централизует логику получения текущего активного реестра валидации/поведения
- * из context stack, избегая дублирования кода в schema-validators.ts,
- * array-validators.ts и schema-behaviors.ts
- */
-import { ValidationRegistry } from '../validation/validation-registry';
-import { BehaviorRegistry } from '../behavior/behavior-registry';
-/**
- * Получить текущий активный ValidationRegistry из context stack
- *
- * Используется внутри validation schema функций (validate, validateAsync, required и т.д.)
- * для регистрации валидаторов в активном контексте GroupNode
- *
- * @returns Текущий ValidationRegistry или заглушка в production
- * @throws Error если нет активного контекста (только в DEV режиме)
- *
- * @internal
- *
- * @example
- * ```typescript
- * function required(fieldPath, options) {
- *   const registry = getCurrentValidationRegistry();
- *   registry.registerSync(path, validator, options);
- * }
- * ```
- */
-export function getCurrentValidationRegistry() {
-    const registry = ValidationRegistry.getCurrent();
-    if (!registry) {
-        if (import.meta.env.DEV) {
-            throw new Error('No active ValidationRegistry context. Make sure to call applyValidationSchema() within a GroupNode context.');
-        }
-        // В production возвращаем заглушку чтобы не ломать приложение
-        return {
-            registerSync: () => { },
-            registerAsync: () => { },
-            registerTree: () => { },
-            enterCondition: () => { },
-            exitCondition: () => { },
-            registerArrayItemValidation: () => { },
-        };
-    }
-    return registry;
-}
-/**
- * Получить текущий активный BehaviorRegistry из context stack
- *
- * Используется внутри behavior schema функций (copyFrom, enableWhen, computeFrom и т.д.)
- * для регистрации поведений в активном контексте GroupNode
- *
- * @returns Текущий BehaviorRegistry или заглушка в production
- * @throws Error если нет активного контекста (только в DEV режиме)
- *
- * @internal
- *
- * @example
- * ```typescript
- * function copyFrom(target, source, options) {
- *   const registry = getCurrentBehaviorRegistry();
- *   const handler = createCopyBehavior(target, source, options);
- *   registry.register(handler, { debounce: options?.debounce });
- * }
- * ```
- */
-export function getCurrentBehaviorRegistry() {
-    const registry = BehaviorRegistry.getCurrent();
-    if (!registry) {
-        if (import.meta.env.DEV) {
-            throw new Error('No active BehaviorRegistry context. Make sure to call applyBehaviorSchema() within a GroupNode context.');
-        }
-        // В production возвращаем заглушку чтобы не ломать приложение
-        return {
-            register: () => { },
-        };
-    }
-    return registry;
-}

package/dist/core/utils/registry-stack.js

@@ -1,86 +0,0 @@
-/**
- * Generic Registry Stack - утилита для управления стеком регистрации
- *
- * Используется ValidationRegistry и BehaviorRegistry для tracking активного контекста.
- * Устраняет дублирование кода между параллельными системами.
- *
- * @template T - Тип элементов в стеке (ValidationRegistry или BehaviorRegistry)
- *
- * @internal
- *
- * @example
- * ```typescript
- * class ValidationRegistry {
- *   private static registryStack = new RegistryStack<ValidationRegistry>();
- *
- *   static getCurrent() {
- *     return ValidationRegistry.registryStack.getCurrent();
- *   }
- *
- *   beginRegistration() {
- *     ValidationRegistry.registryStack.push(this);
- *   }
- *
- *   endRegistration() {
- *     ValidationRegistry.registryStack.verify(this, 'ValidationRegistry');
- *   }
- * }
- * ```
- */
-export class RegistryStack {
-    stack = [];
-    /**
-     * Добавить элемент в стек
-     * @param item - Элемент для добавления
-     */
-    push(item) {
-        this.stack.push(item);
-    }
-    /**
-     * Извлечь элемент из стека
-     * @returns Извлеченный элемент или undefined если стек пуст
-     */
-    pop() {
-        return this.stack.pop();
-    }
-    /**
-     * Получить текущий элемент (вершину стека) без извлечения
-     * @returns Текущий элемент или null если стек пуст
-     */
-    getCurrent() {
-        return this.stack.length > 0 ? this.stack[this.stack.length - 1] : null;
-    }
-    /**
-     * Извлечь элемент из стека с проверкой
-     * Выводит предупреждение в DEV режиме если извлеченный элемент не совпадает с ожидаемым
-     *
-     * @param expected - Ожидаемый элемент
-     * @param name - Имя реестра для отладки (например, 'ValidationRegistry')
-     */
-    verify(expected, name) {
-        const popped = this.pop();
-        if (popped !== expected && import.meta.env.DEV) {
-            console.warn(`${name}: Stack mismatch. Expected ${expected}, got ${popped}`);
-        }
-    }
-    /**
-     * Получить длину стека
-     * @returns Количество элементов в стеке
-     */
-    get length() {
-        return this.stack.length;
-    }
-    /**
-     * Проверить, пуст ли стек
-     * @returns true если стек пуст
-     */
-    isEmpty() {
-        return this.stack.length === 0;
-    }
-    /**
-     * Очистить стек
-     */
-    clear() {
-        this.stack = [];
-    }
-}

package/dist/core/utils/resources.js

@@ -1,69 +0,0 @@
-// ============================================================================
-// Типы ресурсов
-// ============================================================================
-// ============================================================================
-// 1. Статическая стратегия
-// ============================================================================
-/**
- * Статический ресурс - данные загружаются один раз
- * @param items - массив элементов
- */
-export function staticResource(items) {
-    return {
-        type: 'static',
-        load: async () => ({
-            items,
-            totalCount: items.length,
-        }),
-    };
-}
-// ============================================================================
-// 2. Предзагрузка
-// ============================================================================
-/**
- * Предзагрузка - данные загружаются один раз при первом обращении через функцию
- * @param loader - функция загрузки, принимает параметры и возвращает массив
- */
-export function preloadResource(loader) {
-    let cache = null;
-    return {
-        type: 'preload',
-        load: async (params) => {
-            if (!cache) {
-                const items = await loader(params);
-                cache = {
-                    items,
-                    totalCount: items.length,
-                };
-            }
-            return cache;
-        },
-    };
-}
-// ============================================================================
-// 3. Парциональная загрузка
-// ============================================================================
-/**
- * Парциональная загрузка - данные загружаются порциями с учетом поиска/пагинации
- * @param loader - функция загрузки, принимает параметры и возвращает массив
- */
-export function partialResource(loader) {
-    return {
-        type: 'partial',
-        load: async (params) => {
-            const items = await loader(params);
-            return {
-                items,
-                totalCount: items.length, // Можно расширить для поддержки серверной пагинации
-            };
-        },
-    };
-}
-// ============================================================================
-// Экспорт всех стратегий
-// ============================================================================
-export const Resources = {
-    static: staticResource,
-    preload: preloadResource,
-    partial: partialResource,
-};