@reformer/core 1.1.0 → 2.0.0-beta.10

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.d.ts

@@ -1,160 +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 declare class Debouncer {
-    private readonly delay;
-    /**
-     * Таймер для отложенного выполнения
-     * @private
-     */
-    private timer?;
-    /**
-     * Создать Debouncer с заданной задержкой
-     *
-     * @param delay Задержка в миллисекундах (0 = без задержки)
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300); // 300мс задержка
-     * const immediate = new Debouncer(0);  // Без задержки
-     * ```
-     */
-    constructor(delay: number);
-    /**
-     * Отложить выполнение функции
-     *
-     * Если вызывается повторно до истечения 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"
-     * ```
-     */
-    debounce<T>(fn: () => T | Promise<T>): Promise<T>;
-    /**
-     * Отменить отложенное выполнение
-     *
-     * Если есть запланированный вызов, он будет отменен и не выполнится.
-     * Promise из debounce() никогда не разрешится.
-     *
-     * @example
-     * ```typescript
-     * const debouncer = new Debouncer(300);
-     *
-     * debouncer.debounce(async () => {
-     *   console.log('This will not execute');
-     * });
-     *
-     * debouncer.cancel(); // Отменяем вызов
-     * ```
-     */
-    cancel(): void;
-    /**
-     * Выполнить функцию немедленно, отменив любой отложенный вызов
-     *
-     * Полезно когда нужно принудительно выполнить действие сейчас,
-     * игнорируя 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" не выполнится (отменен)
-     * ```
-     */
-    flush<T>(fn: () => T | Promise<T>): Promise<T>;
-    /**
-     * Проверить, есть ли активный (запланированный) вызов
-     *
-     * @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(): boolean;
-}

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;
-    }
-}