@reformer/core 11.0.0-beta.8 → 11.0.0-beta.9

package/dist/form/nodes/model-array-node.d.ts

@@ -1,126 +0,0 @@
-import { Signal, ReadonlySignal } from '@preact/signals-core';
-import { FormNode } from './form-node';
-import { FieldStatus, ValidationError } from '../types/index';
-import { FormModel } from '../../model/types';
-import { FormProxy } from '../types/form-proxy';
-/** Минимальный контракт реактивного массива модели, используемый узлом. */
-export interface ModelArrayControl<TItem extends object> {
-    readonly length: number;
-    at(index: number): FormModel<TItem> | undefined;
-    push(item?: TItem): void;
-    insertAt(index: number, item?: TItem): void;
-    removeAt(index: number): void;
-    move(from: number, to: number): void;
-    swap(a: number, b: number): void;
-    clear(): void;
-    toArray(): TItem[];
-}
-/**
- * Узел массива, делегирующий данные массиву {@link FormModel} (архитектура M1).
- *
- * В отличие от {@link ArrayNode} (владеет элементами сам), `ModelArrayNode` НЕ владеет данными:
- * массив принадлежит модели, а узел держит per-item формы элементов (привязанные к сигналам
- * под-моделей) и синхронизирует их с длиной массива модели. Мутации (`push`/`removeAt`/`move`/…)
- * делегируются массиву модели; per-item формы кэшируются по идентичности под-модели, поэтому при
- * reorder/повторном рендере не пересоздаются (состояние и валидация сохраняются). Реализует тот же
- * контракт, что ждут секции массива и `useFormControl` (`length`/`value`/`valid`/`errors`/`at`/`push`/…).
- *
- * Обычно создаётся не напрямую, а `createFormFromModel({ model, schema })`: когда в схеме встречается узел
- * массива `{ array: model.<field>, item: (item) => itemSchema }`, форма материализует его как
- * `ModelArrayNode` и кладёт под `form.<field>` (совместим с `FormArraySection`).
- *
- * @group Nodes
- *
- * @example Массив как часть формы (через createForm)
- * ```typescript
- * const model = createModel<{ rows: { name: string; qty: number }[] }>({ rows: [] });
- *
- * const rowItem = (item: FormModel<{ name: string; qty: number }>) => ({
- *   name: { value: item.$.name, component: Input },
- *   qty: { value: item.$.qty, component: Input },
- * });
- *
- * const form = createFormFromModel({
- *   model,
- *   schema: {
- *     children: [{ array: model.rows, item: rowItem }],
- *   },
- * });
- *
- * const rows = form.rows as unknown as ModelArrayNode<{ name: string; qty: number }>;
- * rows.push({ name: 'A', qty: 1 });   // мутация уезжает в model.rows
- * rows.at(0)?.name.setValue('B');     // правка поля элемента доезжает в под-модель
- * rows.length.value;                  // 1 (реактивная длина)
- * ```
- */
-export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
-    private readonly control;
-    private readonly buildItem;
-    private readonly itemNodes;
-    private readonly cache;
-    private mountedModels;
-    private readonly initial;
-    private readonly _arrayErrors;
-    private readonly disposeSync;
-    /**
-     * Сигнал per-item форм. Публичен в т.ч. чтобы `isArrayNode` распознавал узел как массив
-     * (duck-typing проверяет наличие `items`).
-     */
-    get items(): Signal<FormProxy<T>[]>;
-    readonly value: ReadonlySignal<T[]>;
-    readonly valid: ReadonlySignal<boolean>;
-    readonly invalid: ReadonlySignal<boolean>;
-    readonly pending: ReadonlySignal<boolean>;
-    readonly touched: ReadonlySignal<boolean>;
-    readonly dirty: ReadonlySignal<boolean>;
-    readonly errors: ReadonlySignal<ValidationError[]>;
-    readonly status: ReadonlySignal<FieldStatus>;
-    readonly length: ReadonlySignal<number>;
-    /**
-     * @param control Реактивный массив модели (`model.<path>`).
-     * @param buildItem Строитель формы элемента по его под-модели (инъекция, чтобы избежать цикла
-     *   импорта с `create-form`). Обычно `(item) => createFormFromModel({ model: item, schema: itemSchema(item) })`.
-     */
-    constructor(control: ModelArrayControl<T>, buildItem: (item: FormModel<T>) => FormProxy<T>);
-    at(index: number): FormProxy<T> | undefined;
-    map<R>(fn: (item: FormProxy<T>, index: number) => R): R[];
-    forEach(fn: (item: FormProxy<T>, index: number) => void): void;
-    /**
-     * Добавить элемент. Без значения — элемент по шаблону массива модели (`arrayOf(blank)` либо
-     * `initialValue` узла-массива схемы); шаблона нет — ошибка модели.
-     */
-    push(item?: Partial<T>): void;
-    /** Вставить элемент по индексу; без значения — по шаблону, как у {@link push}. */
-    insert(index: number, item?: Partial<T>): void;
-    removeAt(index: number): void;
-    /**
-     * Переместить элемент модель-массива. Делегирует мутацию массиву модели; внутренний `effect`
-     * пересоберёт `itemNodes` в новом порядке (per-item формы сохраняются по кешу идентичности).
-     */
-    move(from: number, to: number): void;
-    /** Поменять местами два элемента модель-массива (см. {@link move}). */
-    swap(a: number, b: number): void;
-    clear(): void;
-    getValue(): T[];
-    setValue(values: T[]): void;
-    patchValue(values: Partial<T[]>): void;
-    reset(values?: T[]): void;
-    resetToInitial(): void;
-    validate(): Promise<boolean>;
-    setErrors(errors: ValidationError[]): void;
-    clearErrors(): void;
-    protected onMarkAsTouched(): void;
-    protected onMarkAsUntouched(): void;
-    protected onMarkAsDirty(): void;
-    protected onMarkAsPristine(): void;
-    protected onDisable(): void;
-    protected onEnable(): void;
-    /** Диспозит форму элемента (эффекты/поведения/вложенные подписки); терпима к не-GroupNode. */
-    private disposeItemNode;
-    /**
-     * Очистка подписки синхронизации И детерминированный teardown всех форм элементов.
-     * Без пробрасывания dispose в itemNodes эффекты/поведения каждой формы элемента (в т.ч. disposeSync
-     * вложенных ModelArrayNode) остались бы жить после teardown формы — утечка подписок.
-     */
-    dispose(): void;
-}

package/dist/form/nodes/subscription-manager.d.ts

@@ -1,180 +0,0 @@
-/**
- * Менеджер подписок для FormNode
- *
- * Централизует управление effect-подписками в узлах формы,
- * предотвращает утечки памяти и упрощает отладку.
- *
- * Каждая подписка имеет уникальный ключ, что позволяет:
- * - Отписываться от конкретной подписки по ключу
- * - Автоматически заменять существующие подписки
- * - Отслеживать количество активных подписок (для отладки)
- *
- * @internal
- *
- * @example
- * ```typescript
- * class FieldNode {
- *   private subscriptions = new SubscriptionManager();
- *
- *   watch(callback: Function) {
- *     const dispose = effect(() => callback(this.value.value));
- *     return this.subscriptions.add('watch', dispose);
- *   }
- *
- *   dispose() {
- *     this.subscriptions.clear();
- *   }
- * }
- * ```
- */
-export declare class SubscriptionManager {
-    /**
-     * Хранилище подписок
-     * Ключ: уникальный идентификатор подписки
-     * Значение: функция отписки (dispose)
-     */
-    private subscriptions;
-    /**
-     * Добавляет подписку
-     *
-     * Если подписка с таким ключом уже существует, отписывается от неё
-     * и заменяет новой. Это предотвращает утечки памяти при повторной
-     * регистрации подписки с тем же ключом.
-     *
-     * @param key Уникальный ключ подписки
-     * @param dispose Функция отписки (обычно возвращаемая из effect())
-     * @returns Функция для отписки от этой конкретной подписки
-     *
-     * @example
-     * ```typescript
-     * const manager = new SubscriptionManager();
-     *
-     * // Добавление подписки
-     * const unsubscribe = manager.add('mySubscription', () => {
-     *   console.log('Disposing subscription');
-     * });
-     *
-     * // Отписка через возвращаемую функцию
-     * unsubscribe();
-     *
-     * // Или через manager.remove()
-     * manager.add('anotherSub', disposeFn);
-     * manager.remove('anotherSub');
-     * ```
-     */
-    add(key: string, dispose: () => void): () => void;
-    /**
-     * Удаляет подписку по ключу
-     *
-     * Вызывает функцию отписки и удаляет подписку из хранилища.
-     * Если подписка с таким ключом не найдена, ничего не делает.
-     *
-     * @param key Ключ подписки
-     * @returns true, если подписка была удалена, false если не найдена
-     *
-     * @example
-     * ```typescript
-     * const manager = new SubscriptionManager();
-     * manager.add('mySub', disposeFn);
-     *
-     * // Удаление подписки
-     * const removed = manager.remove('mySub'); // true
-     *
-     * // Попытка удалить несуществующую подписку
-     * const removed2 = manager.remove('nonExistent'); // false
-     * ```
-     */
-    remove(key: string): boolean;
-    /**
-     * Очищает все подписки
-     *
-     * Вызывает функции отписки для всех активных подписок
-     * и очищает хранилище. Обычно используется при dispose узла формы.
-     *
-     * @example
-     * ```typescript
-     * class FieldNode {
-     *   private subscriptions = new SubscriptionManager();
-     *
-     *   dispose() {
-     *     // Отписываемся от всех effect
-     *     this.subscriptions.clear();
-     *   }
-     * }
-     * ```
-     */
-    clear(): void;
-    /**
-     * Возвращает количество активных подписок
-     *
-     * Полезно для отладки утечек памяти. Если количество подписок
-     * растет без ограничений, это может указывать на то, что
-     * компоненты не отписываются должным образом.
-     *
-     * @returns Количество активных подписок
-     *
-     * @example
-     * ```typescript
-     * const manager = new SubscriptionManager();
-     * console.log(manager.size()); // 0
-     *
-     * manager.add('sub1', disposeFn1);
-     * manager.add('sub2', disposeFn2);
-     * console.log(manager.size()); // 2
-     *
-     * manager.clear();
-     * console.log(manager.size()); // 0
-     * ```
-     */
-    size(): number;
-    /**
-     * Проверяет, есть ли подписка с данным ключом
-     *
-     * @param key Ключ подписки
-     * @returns true, если подписка существует
-     *
-     * @example
-     * ```typescript
-     * const manager = new SubscriptionManager();
-     * manager.add('mySub', disposeFn);
-     *
-     * console.log(manager.has('mySub')); // true
-     * console.log(manager.has('nonExistent')); // false
-     * ```
-     */
-    has(key: string): boolean;
-    /**
-     * Возвращает список всех ключей активных подписок
-     *
-     * Полезно для отладки: можно увидеть, какие подписки активны.
-     *
-     * @returns Массив ключей всех активных подписок
-     *
-     * @example
-     * ```typescript
-     * const manager = new SubscriptionManager();
-     * manager.add('watch-value', disposeFn1);
-     * manager.add('watch-errors', disposeFn2);
-     *
-     * console.log(manager.getKeys()); // ['watch-value', 'watch-errors']
-     * ```
-     */
-    getKeys(): string[];
-    /**
-     * Отписывается от всех подписок (алиас для clear())
-     *
-     * Используется при dispose() узла формы для совместимости с ожидаемым API.
-     *
-     * @example
-     * ```typescript
-     * class FieldNode {
-     *   private subscriptions = new SubscriptionManager();
-     *
-     *   dispose() {
-     *     this.subscriptions.dispose();
-     *   }
-     * }
-     * ```
-     */
-    dispose(): void;
-}

package/dist/form/status-machine.d.ts

@@ -1,115 +0,0 @@
-import { ReadonlySignal } from '@preact/signals-core';
-import { FieldStatus } from './types/index';
-/**
- * FormStatusMachine - управляет состоянием поля формы
- *
- * Предоставляет:
- * - Единый источник истины для статуса
- * - Computed signals для derived состояний (valid, invalid, pending, disabled)
- * - Валидацию переходов между состояниями
- *
- * @example
- * ```typescript
- * const statusMachine = new FormStatusMachine('valid');
- *
- * // Начало валидации
- * statusMachine.startValidation();
- * console.log(statusMachine.pending.value); // true
- *
- * // Завершение валидации с ошибками
- * statusMachine.completeValidation(true);
- * console.log(statusMachine.invalid.value); // true
- *
- * // Отключение поля
- * statusMachine.disable();
- * console.log(statusMachine.disabled.value); // true
- * ```
- */
-export declare class FormStatusMachine {
-    /** Внутренний сигнал статуса */
-    private readonly _status;
-    /** Публичный read-only сигнал статуса */
-    readonly status: ReadonlySignal<FieldStatus>;
-    /** Поле валидно */
-    readonly valid: ReadonlySignal<boolean>;
-    /** Поле невалидно */
-    readonly invalid: ReadonlySignal<boolean>;
-    /** Идет валидация */
-    readonly pending: ReadonlySignal<boolean>;
-    /** Поле отключено */
-    readonly disabled: ReadonlySignal<boolean>;
-    /**
-     * @param initial - Начальный статус (по умолчанию 'valid')
-     */
-    constructor(initial?: FieldStatus);
-    /**
-     * Начать валидацию
-     *
-     * Переводит статус в 'pending' если поле не отключено
-     *
-     * @example
-     * ```typescript
-     * statusMachine.startValidation();
-     * // status: 'pending'
-     * ```
-     */
-    startValidation(): void;
-    /**
-     * Завершить валидацию
-     *
-     * @param hasErrors - Есть ли ошибки валидации
-     *
-     * @example
-     * ```typescript
-     * // Валидация успешна
-     * statusMachine.completeValidation(false);
-     * // status: 'valid'
-     *
-     * // Есть ошибки
-     * statusMachine.completeValidation(true);
-     * // status: 'invalid'
-     * ```
-     */
-    completeValidation(hasErrors: boolean): void;
-    /**
-     * Установить ошибки напрямую (без перехода через pending)
-     *
-     * Используется для синхронной валидации или установки ошибок извне
-     *
-     * @param hasErrors - Есть ли ошибки
-     *
-     * @example
-     * ```typescript
-     * statusMachine.setErrors(true);
-     * // status: 'invalid'
-     * ```
-     */
-    setErrors(hasErrors: boolean): void;
-    /**
-     * Отключить поле
-     *
-     * Переводит статус в 'disabled'
-     *
-     * @example
-     * ```typescript
-     * statusMachine.disable();
-     * // status: 'disabled'
-     * ```
-     */
-    disable(): void;
-    /**
-     * Включить поле
-     *
-     * @param hasErrors - Есть ли ошибки (определяет valid/invalid)
-     *
-     * @example
-     * ```typescript
-     * statusMachine.enable(false);
-     * // status: 'valid'
-     *
-     * statusMachine.enable(true);
-     * // status: 'invalid'
-     * ```
-     */
-    enable(hasErrors?: boolean): void;
-}

package/dist/form/types/deep-schema.d.ts

@@ -1,107 +0,0 @@
-import { ComponentType } from 'react';
-import { Signal } from '@preact/signals-core';
-import { ValidatorFn, AsyncValidatorFn, AnyFunction } from './index';
-/**
- * Конфигурация поля
- * @group Types
- * @category Configuration Types
- * @remarks
- * В схеме `createFormFromModel({ model, schema })` лист связывают через **`value: model.$.field`**: harvest
- * ловит узел по идентичности `Signal` (`node.value instanceof Signal` — см. `create-form.ts`) и
- * нормализует его в `valueSignal`. Писать `valueSignal:` **в самой схеме `createForm` нельзя** —
- * harvest его не подхватит (проверка идёт по `node.value`), и `component`/`componentProps` этого
- * узла молча отбросятся. `value`/`valueSignal` на прямом FieldNode-конфиге — это
- * post-normalization / legacy-слой, а не форма записи в схеме `createForm`.
- */
-export interface FieldConfig<T> {
-    /**
-     * Начальное значение-литерал (legacy-путь). Под архитектурой M1 значение приходит из
-     * {@link FieldConfig.valueSignal} (сигнал {@link FormModel}); тогда `value` не требуется.
-     */
-    value?: T | null;
-    /**
-     * Сигнал значения из {@link FormModel} (M1). Если задан — служит источником истины значения
-     * поля (нода не владеет значением, а ссылается на этот сигнал). Имеет приоритет над `value`.
-     */
-    valueSignal?: Signal<T>;
-    /**
-     * UI-компонент поля. Опционален: core-часть можно использовать без ссылки на компонент
-     * (значение/валидация работают без UI; компонент нужен только для рендеринга).
-     */
-    component?: ComponentType<any>;
-    componentProps?: any;
-    validators?: ValidatorFn<T>[];
-    asyncValidators?: AsyncValidatorFn<T>[];
-    disabled?: boolean;
-    updateOn?: 'change' | 'blur' | 'submit';
-    /** Задержка (в мс) перед запуском асинхронной валидации */
-    debounce?: number;
-}
-/**
- * «Хотя бы одно поле обязано присутствовать»: превращает объект со всеми опциональными
- * свойствами в объединение вариантов, где ровно один ключ обязателен, а остальные опциональны.
- * Пустой объект `{}` не assignable ни к одному варианту и потому отклоняется.
- *
- * @internal
- */
-type RequireAtLeastOne<T> = {
-    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
-}[keyof T];
-/**
- * {@link FieldConfig}, из которого нельзя сделать пустой `{}`.
- *
- * Все свойства {@link FieldConfig} опциональны, поэтому в {@link FormSchema} опечатка вида
- * `{ email: {} }` молча проходит проверку типов и в рантайме становится пустой подгруппой
- * вместо поля. `NonEmptyFieldConfig` требует наличия хотя бы одного свойства (value/valueSignal/
- * component/validators/…), оставляя каждое из них опциональным по отдельности.
- *
- * @internal
- */
-type NonEmptyFieldConfig<T> = RequireAtLeastOne<FieldConfig<T>>;
-/**
- * **Data-shaped** конфиг формы: ключи повторяют структуру данных `T`, значения — {@link FieldConfig}
- * (или вложенный `FormSchema`). Форма конфига, из которой строится {@link GroupNode}.
- * - `T[] -> [FormSchema<T>]` (массив с одним элементом)
- * - `object -> FormSchema<T>` (группа)
- * - `primitive -> FieldConfig<T>` (поле)
- *
- * Использует NonNullable для корректной обработки опциональных полей.
- *
- * ⚠️ Не путать с {@link FormSchemaNode} — тот описывает **узел дерева** M1-схемы (лист/массив/
- * контейнер), передаваемой в `createFormFromModel({ model, schema })`. `FormSchema` — это data-shaped конфиг
- * (ключи = поля данных), а не узел дерева.
- *
- * @group Types
- * @category Configuration Types
- *
- * @example
- * ```typescript
- * interface Form {
- *   name: string;                    // → FieldConfig<string>
- *   address: {                       // → FormSchema<Address>
- *     city: string;
- *     street: string;
- *   };
- *   items?: Array<{                  // → [FormSchema<Item>] (опциональный)
- *     title: string;
- *     price: number;
- *   }>;
- * }
- *
- * const schema: FormSchema<Form> = {
- *   name: { value: '', component: Input },
- *   address: {
- *     city: { value: '', component: Input },
- *     street: { value: '', component: Input },
- *   },
- *   items: [{
- *     title: { value: '', component: Input },
- *     price: { value: 0, component: Input },
- *   }],
- * };
- * ```
- */
-export type FormSchema<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends string | number | boolean ? NonEmptyFieldConfig<T[K]> : NonNullable<T[K]> extends Array<infer U> ? U extends string | number | boolean ? NonEmptyFieldConfig<T[K]> : U extends Date | File | Blob | AnyFunction ? NonEmptyFieldConfig<T[K]> : [FormSchema<U>] : NonNullable<T[K]> extends Date | File | Blob | AnyFunction ? NonEmptyFieldConfig<T[K]> : FormSchema<NonNullable<T[K]>>;
-};
-export {};

package/dist/form/types/form-proxy.d.ts

@@ -1,141 +0,0 @@
-import { FieldNode } from '../nodes/field-node';
-import { GroupNode } from '../nodes/group-node';
-import { ArrayNode } from '../nodes/array-node';
-/**
- * Признак «объект-группа» — обычный объект, который нужно обернуть в под-форму.
- *
- * Исключает массивы, спец-объекты (`Date`/`File`/`Blob`) и примитивы.
- * Используется как дискриминатор вместо `extends FormFields` (`Record<string, FormValue>`):
- * пользовательские модели почти всегда объявлены через `interface`, который НЕ assignable
- * к Record-типу (у интерфейса нет неявной index signature), и потому ошибочно проваливался
- * бы в ветку `FieldNode`. Проверка `extends object` корректно ловит и `interface`, и `type`.
- *
- * @internal
- */
-type IsGroupObject<V> = V extends ReadonlyArray<unknown> ? false : V extends Date | File | Blob ? false : V extends (...args: never[]) => unknown ? false : V extends object ? true : false;
-/**
- * Мапит тип модели данных T на правильные типы узлов формы
- *
- * Рекурсивно определяет типы узлов на основе структуры данных:
- * - `T[K] extends Array<infer U>` где U - объект → `FormArrayProxy<U>`
- * - `T[K] extends Array<infer U>` где U - примитив → `FieldNode<T[K]>` (массив как обычное поле)
- * - `T[K] extends object` → `FormProxy<T[K]>` (вложенная форма с типизацией)
- * - `T[K]` примитив → `FieldNode<T[K]>` (простое поле)
- *
- * Использует NonNullable для правильной обработки опциональных полей
- *
- * @group Types
- * @category Proxy Types
- *
- * @template T - Тип модели данных формы
- */
-export type FormControlsProxy<T> = {
-    [K in keyof T]-?: NonNullable<T[K]> extends ReadonlyArray<infer U> ? IsGroupObject<U> extends true ? FormArrayProxy<U & object> : FieldNode<T[K]> : IsGroupObject<NonNullable<T[K]>> extends true ? FormProxy<NonNullable<T[K]>> : FieldNode<T[K]>;
-};
-/**
- * Комбинированный тип для GroupNode с Proxy доступом к полям
- *
- * Объединяет методы и свойства GroupNode с типизированными полями формы.
- * Это позволяет использовать как API GroupNode, так и прямой доступ к полям.
- *
- * @group Types
- * @category Proxy Types
- *
- * @template T - Тип модели данных формы
- *
- * @example
- * ```typescript
- * interface UserForm {
- *   email: string;
- *   profile: {
- *     name: string;
- *     age: number;
- *   };
- * }
- *
- * const form = createLegacyForm<UserForm>(schema);
- *
- * // Доступ к методам GroupNode
- * await form.validate();
- * const values = form.getValue();
- * console.log(form.valid.value);
- *
- * // Прямой доступ к полям (через Proxy)
- * form.email.setValue('test@mail.com');
- * form.profile.name.setValue('John');
- * ```
- *
- * @remarks
- * **Зарезервированные имена.** Прямой доступ `form.<name>` отдаёт приоритет собственным
- * членам {@link GroupNode} (`value`, `status`, `id`, `errors`, `disabled`, `reset`, `submit`, …).
- * Поэтому поле модели, названное любым из этих имён, недостижимо как `form.<name>` — там будет
- * агрегированный сигнал/метод узла, а не {@link FieldNode}. Такие имена исключены из полевого
- * пространства имён на уровне типов (через `Omit<…, keyof GroupNode>`), чтобы затенение не
- * компилировалось молча. Для доступа к любому полю по имени — включая затенённые — используйте
- * escape-hatch пространство {@link FormProxy.$}: `form.$.status`, `form.$.id`, `form.$.value`.
- */
-export type FormProxy<T> = GroupNode<T> & Omit<FormControlsProxy<T>, keyof GroupNode<T>> & {
-    /**
-     * Escape-hatch пространство имён «controls»: типобезопасный доступ ко ВСЕМ полям формы
-     * по имени, включая поля, чьи имена совпадают с членами {@link GroupNode}
-     * (`value`/`status`/`id`/`errors`/…), недостижимые через `form.<name>`.
-     *
-     * @example
-     * ```typescript
-     * // модель: { status: string; email: string }
-     * form.status;      // ReadonlySignal<FieldStatus> — агрегат GroupNode (не поле!)
-     * form.$.status;    // FieldNode<string> — поле пользователя
-     * form.$.status.setValue('active');
-     * form.$.email;     // FieldNode<string> — так же доступны и незатенённые поля
-     * ```
-     */
-    readonly $: FormControlsProxy<T>;
-};
-/**
- * Комбинированный тип для ArrayNode с Proxy доступом к элементам
- *
- * Объединяет методы и свойства ArrayNode с типизированным доступом к элементам массива.
- *
- * @group Types
- * @category Proxy Types
- *
- * @template T - Тип модели данных элемента массива
- *
- * @example
- * ```typescript
- * interface TodoItem {
- *   title: string;
- *   completed: boolean;
- * }
- *
- * const todos: FormArrayProxy<TodoItem> = new ArrayNode(schema);
- *
- * // Доступ к методам ArrayNode
- * todos.push({ title: 'New todo', completed: false });
- * todos.removeAt(0);
- *
- * // Доступ к элементам (через Proxy)
- * todos.at(0)?.title.setValue('Updated title');
- *
- * // Итерация
- * todos.forEach((item, i) => {
- *   console.log(item.title.value.value);
- * });
- * ```
- */
-export type FormArrayProxy<T extends object> = ArrayNode<T> & {
-    /**
-     * Безопасный доступ к элементу массива по индексу
-     * Возвращает GroupNode с типизированными полями или undefined
-     */
-    at(index: number): FormProxy<T> | undefined;
-    /**
-     * Итерация по элементам массива с типизированными элементами
-     */
-    forEach(callback: (item: FormProxy<T>, index: number) => void): void;
-    /**
-     * Маппинг элементов массива с типизированными элементами
-     */
-    map<R>(callback: (item: FormProxy<T>, index: number) => R): R[];
-};
-export {};