@reformer/core 1.1.0 → 2.0.0-beta.2

package/dist/core/types/deep-schema.js

@@ -1,11 +0,0 @@
-/**
- * Типы для схемы формы (Deep Schema)
- *
- * Автоматическое определение типов схемы на основе структуры данных:
- * - `[{...}]` → массив форм
- * - `{...}` → вложенная группа
- * - `{value, component}` → конфигурация поля
- *
- * @group Types
- */
-export {};

package/dist/core/types/field-path.js

@@ -1,4 +0,0 @@
-// ============================================================================
-// FieldPath - proxy для доступа к путям полей
-// ============================================================================
-export {};

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

@@ -1,25 +0,0 @@
-/**
- * Единый контекст для работы с формой
- *
- * Используется в:
- * - Behavior схемах (watchField, copyFrom, transformValue, etc.)
- * - Validation схемах (validate, validateAsync, validateTree)
- *
- * @example
- * ```typescript
- * // Behavior
- * watchField(path.country, (country, ctx) => {
- *   ctx.form.city.updateComponentProps({ options: cities });
- *   ctx.setFieldValue('city', null);
- * });
- *
- * // Validation
- * validate(path.email, (value, ctx) => {
- *   if (!value) return { code: 'required', message: 'Required' };
- *   const confirm = ctx.form.confirmEmail.value.value;
- *   if (value !== confirm) return { code: 'mismatch', message: 'Emails must match' };
- *   return null;
- * });
- * ```
- */
-export {};

package/dist/core/types/group-node-proxy.js

@@ -1,31 +0,0 @@
-/**
- * Типы для Proxy-доступа к полям GroupNode
- *
- * Решает проблему типизации, когда GroupNode<T> использует Proxy для прямого доступа к полям.
- * TypeScript не может автоматически определить правильные типы для вложенных форм и массивов.
- *
- * @group Types
- *
- * @example
- * ```typescript
- * interface MyForm {
- *   name: string;
- *   address: {
- *     city: string;
- *   };
- *   items: Array<{ title: string }>;
- * }
- *
- * const form: GroupNodeWithControls<MyForm> = new GroupNode(schema);
- *
- * //  TypeScript знает, что это FieldNode<string>
- * form.name.setValue('John');
- *
- * //  TypeScript знает, что это GroupNode<{city: string}>
- * form.address.city.setValue('Moscow');
- *
- * //  TypeScript знает, что это ArrayNode<{title: string}>
- * form.items.push({ title: 'New Item' });
- * ```
- */
-export {};

package/dist/core/types/index.js

@@ -1,4 +0,0 @@
-// ============================================================================
-// Form Value Types
-// ============================================================================
-export {};

package/dist/core/types/validation-schema.js

@@ -1,10 +0,0 @@
-/**
- * Типы для validation schema паттерна
- *
- * Основано на Angular Signal Forms подходе:
- * - Валидация определяется отдельно от схемы полей
- * - Поддержка условной валидации (applyWhen)
- * - Cross-field валидация (validateTree)
- * - Асинхронная валидация с контекстом
- */
-export {};

package/dist/core/utils/create-form.js

@@ -1,24 +0,0 @@
-/**
- * Фабричная функция для создания формы с правильной типизацией
- *
- * Решает проблему с типизацией конструктора GroupNode, который возвращает
- * Proxy (GroupNodeWithControls), но TypeScript не может это вывести автоматически.
- *
- * @group Utilities
- *
- * @example
- * ```typescript
- * // Вместо:
- * const form: GroupNodeWithControls<MyForm> = new GroupNode<MyForm>(config);
- *
- * // Используйте:
- * const form = createForm<MyForm>(config);
- * ```
- */
-import { GroupNode } from '../nodes/group-node';
-/**
- * Реализация фабричной функции
- */
-export function createForm(schemaOrConfig) {
-    return new GroupNode(schemaOrConfig);
-}

package/dist/core/utils/debounce.js

@@ -1,197 +0,0 @@
-/**
- * Debouncer - утилита для отложенного выполнения функций
- *
- * Устраняет дублирование debounce логики между field-node.ts и behavior-registry.ts
- *
- * @internal
- *
- * @example
- * ```typescript
- * const debouncer = new Debouncer(300);
- *
- * // Отложить выполнение на 300мс
- * await debouncer.debounce(async () => {
- *   await validateField();
- * });
- *
- * // Отменить отложенное выполнение
- * debouncer.cancel();
- *
- * // Выполнить немедленно, отменив отложенное
- * await debouncer.flush(async () => {
- *   await validateField();
- * });
- * ```
- */
-/**
- * Класс для debouncing (отложенного выполнения) функций
- *
- * @internal
- *
- * Откладывает выполнение функции на заданное время. Если функция вызывается
- * повторно до истечения времени, предыдущий вызов отменяется.
- *
- * Полезно для:
- * - Отложенной валидации при вводе (debounced validation)
- * - Отложенного сохранения данных
- * - Отложенной обработки событий behaviors
- *
- * @example
- * ```typescript
- * // В FieldNode
- * class FieldNode {
- *   private validationDebouncer: Debouncer;
- *
- *   constructor(config) {
- *     this.validationDebouncer = new Debouncer(config.debounce || 0);
- *   }
- *
- *   async validate(): Promise<boolean> {
- *     return this.validationDebouncer.debounce(async () => {
- *       // Валидация выполнится через debounce мс
- *       return await this.runValidation();
- *     });
- *   }
- * }
- * ```
- */
-export class Debouncer {
-    delay;
-    /**
-     * Таймер для отложенного выполнения
-     * @private
-     */
-    timer;
-    /**
-     * Создать Debouncer с заданной задержкой
-     *
-     * @param delay Задержка в миллисекундах (0 = без задержки)
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300); // 300мс задержка
-     * const immediate = new Debouncer(0);  // Без задержки
-     * ```
-     */
-    constructor(delay) {
-        this.delay = delay;
-    }
-    /**
-     * Отложить выполнение функции
-     *
-     * Если вызывается повторно до истечения delay, предыдущий вызов отменяется
-     * и таймер перезапускается.
-     *
-     * @param fn Функция для выполнения (может быть async)
-     * @returns Promise, который разрешается результатом функции
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300);
-     *
-     * // Первый вызов - запланирован через 300мс
-     * debouncer.debounce(async () => console.log('First'));
-     *
-     * // Второй вызов через 100мс - отменяет первый, запланирован через 300мс
-     * debouncer.debounce(async () => console.log('Second'));
-     *
-     * // Через 300мс выведет только: "Second"
-     * ```
-     */
-    async debounce(fn) {
-        return new Promise((resolve, reject) => {
-            // Отменяем предыдущий таймер, если есть
-            if (this.timer) {
-                clearTimeout(this.timer);
-            }
-            // Если delay = 0, выполняем немедленно
-            if (this.delay === 0) {
-                Promise.resolve()
-                    .then(() => fn())
-                    .then(resolve)
-                    .catch(reject);
-                return;
-            }
-            // Запускаем новый таймер
-            this.timer = setTimeout(async () => {
-                try {
-                    const result = await fn();
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            }, this.delay);
-        });
-    }
-    /**
-     * Отменить отложенное выполнение
-     *
-     * Если есть запланированный вызов, он будет отменен и не выполнится.
-     * Promise из debounce() никогда не разрешится.
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300);
-     *
-     * debouncer.debounce(async () => {
-     *   console.log('This will not execute');
-     * });
-     *
-     * debouncer.cancel(); // Отменяем вызов
-     * ```
-     */
-    cancel() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = undefined;
-        }
-    }
-    /**
-     * Выполнить функцию немедленно, отменив любой отложенный вызов
-     *
-     * Полезно когда нужно принудительно выполнить действие сейчас,
-     * игнорируя debounce.
-     *
-     * @param fn Функция для немедленного выполнения
-     * @returns Promise с результатом функции
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300);
-     *
-     * // Запланировано через 300мс
-     * debouncer.debounce(async () => console.log('Delayed'));
-     *
-     * // Отменяем отложенный и выполняем немедленно
-     * await debouncer.flush(async () => console.log('Immediate'));
-     * // Выведет: "Immediate" (сразу)
-     * // "Delayed" не выполнится (отменен)
-     * ```
-     */
-    async flush(fn) {
-        this.cancel();
-        return await fn();
-    }
-    /**
-     * Проверить, есть ли активный (запланированный) вызов
-     *
-     * @returns true если есть запланированный вызов
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300);
-     *
-     * console.log(debouncer.isPending()); // false
-     *
-     * debouncer.debounce(() => console.log('Test'));
-     * console.log(debouncer.isPending()); // true
-     *
-     * // Через 300мс
-     * console.log(debouncer.isPending()); // false
-     * ```
-     */
-    isPending() {
-        return this.timer !== undefined;
-    }
-}

package/dist/core/utils/error-handler.js

@@ -1,226 +0,0 @@
-/**
- * FormErrorHandler - централизованная обработка ошибок в формах
- *
- * Устраняет несогласованность обработки ошибок между:
- * - field-node.ts (логирует и конвертирует в ValidationError)
- * - behavior-applicator.ts (логирует и пробрасывает)
- * - validation-applicator.ts (логирует и проглатывает)
- *
- * @example
- * ```typescript
- * try {
- *   await validator(value);
- * } catch (error) {
- *   return FormErrorHandler.handle(error, 'AsyncValidator', ErrorStrategy.CONVERT);
- * }
- * ```
- */
-/**
- * Стратегия обработки ошибок
- *
- * Определяет, что делать с ошибкой после логирования
- */
-export var ErrorStrategy;
-(function (ErrorStrategy) {
-    /**
-     * Пробросить ошибку дальше (throw)
-     * Используется когда ошибка критична и должна остановить выполнение
-     */
-    ErrorStrategy["THROW"] = "throw";
-    /**
-     * Залогировать и проглотить ошибку (продолжить выполнение)
-     * Используется когда ошибка не критична
-     */
-    ErrorStrategy["LOG"] = "log";
-    /**
-     * Конвертировать ошибку в ValidationError
-     * Используется в async validators для отображения ошибки валидации пользователю
-     */
-    ErrorStrategy["CONVERT"] = "convert";
-})(ErrorStrategy || (ErrorStrategy = {}));
-/**
- * Централизованный обработчик ошибок для форм
- *
- * Обеспечивает:
- * - Единообразное логирование ошибок в DEV режиме
- * - Гибкие стратегии обработки (throw/log/convert)
- * - Типобезопасное извлечение сообщений из Error/string/unknown
- *
- * @example
- * ```typescript
- * // В async validator (конвертировать в ValidationError)
- * try {
- *   await validateEmail(value);
- * } catch (error) {
- *   return FormErrorHandler.handle(error, 'EmailValidator', ErrorStrategy.CONVERT);
- * }
- *
- * // В behavior applicator (пробросить критичную ошибку)
- * try {
- *   applyBehavior(schema);
- * } catch (error) {
- *   FormErrorHandler.handle(error, 'BehaviorApplicator', ErrorStrategy.THROW);
- * }
- *
- * // В validator (залогировать и продолжить)
- * try {
- *   validator(value);
- * } catch (error) {
- *   FormErrorHandler.handle(error, 'Validator', ErrorStrategy.LOG);
- * }
- * ```
- */
-export class FormErrorHandler {
-    /**
-     * Обработать ошибку согласно заданной стратегии
-     *
-     * @param error Ошибка для обработки (Error | string | unknown)
-     * @param context Контекст ошибки для логирования (например, 'AsyncValidator', 'BehaviorRegistry')
-     * @param strategy Стратегия обработки (THROW | LOG | CONVERT)
-     * @returns ValidationError если strategy = CONVERT, undefined если strategy = LOG, никогда не возвращается если strategy = THROW
-     *
-     * @example
-     * ```typescript
-     * // THROW - пробросить ошибку
-     * try {
-     *   riskyOperation();
-     * } catch (error) {
-     *   FormErrorHandler.handle(error, 'RiskyOperation', ErrorStrategy.THROW);
-     *   // Этот код никогда не выполнится
-     * }
-     *
-     * // LOG - залогировать и продолжить
-     * try {
-     *   nonCriticalOperation();
-     * } catch (error) {
-     *   FormErrorHandler.handle(error, 'NonCritical', ErrorStrategy.LOG);
-     *   // Продолжаем выполнение
-     * }
-     *
-     * // CONVERT - конвертировать в ValidationError
-     * try {
-     *   await validator(value);
-     * } catch (error) {
-     *   const validationError = FormErrorHandler.handle(
-     *     error,
-     *     'AsyncValidator',
-     *     ErrorStrategy.CONVERT
-     *   );
-     *   return validationError;
-     * }
-     * ```
-     */
-    static handle(error, context, strategy = ErrorStrategy.THROW) {
-        // Извлекаем сообщение из ошибки
-        const message = this.extractMessage(error);
-        // Логируем в DEV режиме
-        if (import.meta.env.DEV) {
-            console.error(`[${context}]`, error);
-        }
-        // Применяем стратегию
-        switch (strategy) {
-            case ErrorStrategy.THROW:
-                throw error;
-            case ErrorStrategy.LOG:
-                // Просто логируем, не возвращаем ничего
-                return;
-            case ErrorStrategy.CONVERT:
-                // Конвертируем в ValidationError
-                return {
-                    code: 'validator_error',
-                    message,
-                    params: { field: context },
-                };
-        }
-    }
-    /**
-     * Извлечь сообщение из ошибки
-     *
-     * Обрабатывает различные типы ошибок:
-     * - Error объекты → error.message
-     * - Строки → возвращает как есть
-     * - Объекты с message → извлекает message
-     * - Другое → String(error)
-     *
-     * @param error Ошибка для извлечения сообщения
-     * @returns Сообщение ошибки
-     * @private
-     *
-     * @example
-     * ```typescript
-     * FormErrorHandler.extractMessage(new Error('Test'));
-     * // 'Test'
-     *
-     * FormErrorHandler.extractMessage('String error');
-     * // 'String error'
-     *
-     * FormErrorHandler.extractMessage({ message: 'Object error' });
-     * // 'Object error'
-     *
-     * FormErrorHandler.extractMessage(null);
-     * // 'null'
-     * ```
-     */
-    static extractMessage(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === 'string') {
-            return error;
-        }
-        if (typeof error === 'object' && error !== null && 'message' in error) {
-            return String(error.message);
-        }
-        return String(error);
-    }
-    /**
-     * Создать ValidationError с заданными параметрами
-     *
-     * Утилитная функция для создания ValidationError объектов
-     *
-     * @param code Код ошибки
-     * @param message Сообщение ошибки
-     * @param field Поле (опционально)
-     * @returns ValidationError объект
-     *
-     * @example
-     * ```typescript
-     * const error = FormErrorHandler.createValidationError(
-     *   'required',
-     *   'This field is required',
-     *   'email'
-     * );
-     * // { code: 'required', message: 'This field is required', field: 'email' }
-     * ```
-     */
-    static createValidationError(code, message, field) {
-        return {
-            code,
-            message,
-            params: field ? { field } : undefined,
-        };
-    }
-    /**
-     * Проверить, является ли объект ValidationError
-     *
-     * Type guard для ValidationError
-     *
-     * @param value Значение для проверки
-     * @returns true если value является ValidationError
-     *
-     * @example
-     * ```typescript
-     * if (FormErrorHandler.isValidationError(result)) {
-     *   console.log(result.code); // OK, типобезопасно
-     * }
-     * ```
-     */
-    static isValidationError(value) {
-        return (typeof value === 'object' &&
-            value !== null &&
-            'code' in value &&
-            'message' in value &&
-            typeof value.code === 'string' &&
-            typeof value.message === 'string');
-    }
-}