@reformer/core 11.0.0-beta.1 → 11.0.0-beta.10

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+export * from './model/index'
+export {}

package/dist/model.js

@@ -0,0 +1,27 @@
+import { c as s, e as r, a as l } from "./create-model-DPSG3I0O.js";
+import { a as d, g as o, f as t, d as c, i as f, b as n, c as m, m as u, r as p, s as b, e as g, u as h } from "./safe-effect-BazLOv1g.js";
+import { c as k, a as v, r as D, b as F, s as x, t as y, w as C } from "./behaviors-value-D05z3my6.js";
+export {
+  d as arrayOf,
+  k as computeFrom,
+  v as copyFrom,
+  s as createModel,
+  o as deepEqual,
+  t as deferredWritesSettled,
+  r as eachLeafSignal,
+  l as eachValueSignal,
+  c as isDerived,
+  f as isModelContainerSignal,
+  n as isValueSignal,
+  m as markDerived,
+  u as modelOf,
+  D as resetWhen,
+  F as revalidateWhen,
+  p as runOutsideEffect,
+  b as safeCallback,
+  g as safeDebouncedCallback,
+  x as syncFields,
+  y as transformValue,
+  h as unmarkDerived,
+  C as watchField
+};

package/dist/node-kind-C-r6ZMdo.js

@@ -0,0 +1,15 @@
+const n = Symbol.for("@reformer/core/form-node-kind"), e = Symbol.for("@reformer/core/form-node-raw");
+function t(r) {
+  if (typeof r != "object" || r === null) return;
+  const o = r[n];
+  return o === "control" || o === "group" || o === "array" ? o : void 0;
+}
+function f(r) {
+  return r[e] ?? r;
+}
+export {
+  n as N,
+  e as R,
+  t as k,
+  f as r
+};

package/dist/platforms/react/field-binding/field-adapter.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Адаптер поля — как свести value-based seam формы (`value` + `onChange(value)` + `onBlur`) к
+ * контракту конкретного контрола. Чистые данные и чистые функции (без React): один механизм на
+ * всех, кто связывает поле с контролом, — `FormField.Control` из `@reformer/cdk` и рендерер
+ * `@reformer/renderer-react`.
+ *
+ * Контрол объявляет свой диалект статикой `reformerAdapter` (см. {@link getFieldAdapter}), поэтому
+ * отдельные «field-версии» компонентов не нужны: в `component` поля кладётся сам компонент.
+ *
+ * @module platforms/react/field-binding
+ */
+/**
+ * Адаптер поля: описывает диалект контрола (`checked`/`onCheckedChange`, `value`/`onValueChange`,
+ * DOM-событие в `onChange`, …). Все ключи необязательны — по умолчанию seam проходит как есть.
+ *
+ * @example Radix Checkbox
+ * ```ts
+ * const checkedAdapter: FieldAdapter = {
+ *   valueProp: 'checked',
+ *   changeProp: 'onCheckedChange',
+ *   fromEmit: (c) => c === true,
+ *   toValue: (v) => v ?? false,
+ * };
+ * ```
+ */
+export interface FieldAdapter {
+    /** Проп, из которого контрол читает значение (по умолчанию `'value'`). */
+    valueProp?: string;
+    /** Колбэк, через который контрол эмитит изменение (по умолчанию `'onChange'`). */
+    changeProp?: string;
+    /**
+     * Эмит контрола → значение поля (по умолчанию — как есть). `rest` — прочие props контрола
+     * (например, чтобы достать `options` при резолве значения).
+     */
+    fromEmit?: (arg: unknown, rest: Record<string, unknown>) => unknown;
+    /** Значение поля → `valueProp` контрола (коэрсия `null`/`undefined`; по умолчанию — как есть). */
+    toValue?: (value: unknown) => unknown;
+    /** Проброс blur нестандартным каналом (по умолчанию — `onBlur`). */
+    bindBlur?: (onBlur: () => void) => Record<string, unknown>;
+    /** Ключи, которые убрать из `componentProps` перед спредом в контрол. */
+    strip?: string[];
+    /**
+     * Передавать ли контролу ноду формы пропом `control` (только рендерер). По умолчанию `false`:
+     * issues/touched обслуживает обёртка поля. Ставь `true`, если контрол сам вызывает
+     * `useFormControl(control)`.
+     */
+    passControl?: boolean;
+}
+/** Компонент, объявивший свой диалект статикой. */
+export interface FieldAdapterCarrier {
+    reformerAdapter?: FieldAdapter;
+}
+/**
+ * Props, которые адресованы обёртке поля, а не контролу: `labelTooltip` рисует `FormField` у
+ * подписи. Они приходят в общем мешке `componentProps`, и без среза утекли бы в DOM контрола.
+ */
+export declare const FIELD_WRAPPER_ONLY_PROPS: readonly string[];
+/**
+ * Адаптер, объявленный компонентом статикой `reformerAdapter`, либо `undefined`.
+ *
+ * @example
+ * ```ts
+ * Checkbox.reformerAdapter = checkedAdapter;
+ * getFieldAdapter(Checkbox); // → checkedAdapter
+ * ```
+ */
+export declare function getFieldAdapter(component: unknown): FieldAdapter | undefined;
+/** Seam поля: текущее значение и value-based колбэки. */
+export interface FieldSeam {
+    value: unknown;
+    onChange: (value: unknown) => void;
+    onBlur: () => void;
+}
+/**
+ * Props контрола под адаптер: срезает служебные ключи обёртки и `strip` адаптера, кладёт значение
+ * в `valueProp` (через `toValue`), вешает `changeProp`, который прогоняет эмит контрола через
+ * `fromEmit` в value-based `onChange` поля, и пробрасывает blur (`bindBlur` либо `onBlur`).
+ * Без адаптера seam проходит как есть (`value` / `onChange` / `onBlur`).
+ *
+ * `componentProps` спредятся ПЕРВЫМИ — seam их перекрывает при совпадении ключей.
+ *
+ * @param adapter - Адаптер контрола или `undefined` (value-based контрол).
+ * @param seam - Значение поля и его колбэки.
+ * @param componentProps - Прочие props контрола.
+ * @returns Плоский объект props для спреда в контрол.
+ */
+export declare function bindFieldProps(adapter: FieldAdapter | undefined, seam: FieldSeam, componentProps?: Record<string, unknown>): Record<string, unknown>;

package/dist/platforms/react/field-binding/field-handle.d.ts

@@ -0,0 +1,53 @@
+import { Ref, RefObject } from 'react';
+/**
+ * Базовый императивный контракт поля формы.
+ *
+ * Обёртка поля (`FormField.Control` из `@reformer/cdk`, рендерер `@reformer/renderer-react`)
+ * строит его из DOM-узла контрола. Композиты со своим handle (`open`/`close`/`reload`/…) отдают
+ * его как есть — он расширяет этот контракт.
+ *
+ * Достаётся из render-схемы по селектору:
+ * `schema.node(sel).getRef<FieldHandle>().current?.focus()`.
+ *
+ * Покрывает ТОЛЬКО императивные действия. Реактивное состояние (value / disabled / options /
+ * validation) живёт в behaviors и через handle не дублируется.
+ */
+export interface FieldHandle {
+    /** Сфокусировать поле (делегирует на DOM-элемент контрола). */
+    focus(): void;
+    /** Снять фокус. */
+    blur(): void;
+    /** Проскроллить поле в область видимости. */
+    scrollIntoView(opts?: ScrollIntoViewOptions): void;
+    /** Живой DOM-элемент поля (или `null` до монтирования / для размонтированной ноды). */
+    getElement(): HTMLElement | null;
+}
+/**
+ * Собирает базовый {@link FieldHandle}, делегирующий на DOM-элемент по ссылке `el`.
+ * Все вызовы null-safe: до монтирования (`el.current === null`) — no-op, без исключений.
+ */
+export declare function makeElementFieldHandle(el: RefObject<HTMLElement | null>): FieldHandle;
+/**
+ * Ref для контрола поля + императивный handle для потребителя.
+ *
+ * Возвращённый ref вешается на контрол. На `outerRef` публикуется:
+ * - handle самого контрола, если тот его реализует (`useImperativeHandle` композита);
+ * - иначе — базовый {@link FieldHandle}, построенный из DOM-узла контрола.
+ *
+ * Хук вызывается безусловно; вешать ref на контрол стоит только при заданном `outerRef` —
+ * так function-компонент без ref-поддержки не получает лишний ref.
+ *
+ * @param outerRef - ref потребителя (из `forwardRef` или `schema.node(sel).getRef()`).
+ * @returns ref, который нужно передать контролу.
+ */
+export declare function useFieldHandleRef<H = FieldHandle>(outerRef: Ref<H> | undefined): RefObject<unknown>;
+/**
+ * Что публиковать потребителю по ref контрола: handle композита как есть, иначе (DOM-узел или
+ * ещё пусто) — базовый {@link FieldHandle}, читающий узел лениво из `inner`. С `cache` базовый
+ * handle создаётся один раз и дальше переиспользуется.
+ *
+ * @internal Экспортируется для юнит-тестов.
+ */
+export declare function resolveFieldHandle(inner: RefObject<unknown>, cache?: {
+    current: FieldHandle | null;
+}): unknown;

package/dist/platforms/react/form-bundle-context.d.ts

@@ -0,0 +1,27 @@
+import { FormBundle } from '../../form/form-bundle';
+/**
+ * Контекст сборки. Значение — бандл `createForm`; вне рендерера — `null`.
+ *
+ * @example
+ * ```tsx
+ * <FormBundleContext.Provider value={bundle}>
+ *   <MyWizard />
+ * </FormBundleContext.Provider>
+ * ```
+ */
+export declare const FormBundleContext: import('react').Context<FormBundle<any> | null>;
+/**
+ * Бандл сборки, внутри которой отрисован компонент; `null` — компонент стоит вне рендерера
+ * (например, визард в разметке React-руками получает форму и поток шагов пропсами).
+ *
+ * @typeParam T - Форма данных модели.
+ *
+ * @example
+ * ```tsx
+ * function StepFooter() {
+ *   const bundle = useFormBundleContext<CreditForm>();
+ *   return <button onClick={() => void bundle?.validate()}>Проверить</button>;
+ * }
+ * ```
+ */
+export declare function useFormBundleContext<T = unknown>(): FormBundle<T> | null;

package/dist/{form → platforms/react}/hooks/types.d.ts

@@ -1,6 +1,6 @@
-import { ValidationError } from '../types/index';
+import { ValidationIssue } from '../../../form/types/index';
 /**
- * Состояние поля формы, возвращаемое хуком {@link useFormControl} для {@link FieldNode}.
+ * Состояние поля формы, возвращаемое хуком {@link useFormControl} для {@link FormControl}.
  *
  * Содержит реактивные данные поля: значение, состояние валидации, флаги взаимодействия
  * и пользовательские props для компонентов.
@@ -10,11 +10,12 @@ import { ValidationError } from '../types/index';
  * @example Базовое использование
  * ```tsx
  * interface Props {
- *   control: FieldNode<string>;
+ *   control: FormControl<string>;
  * }
  *
  * function TextField({ control }: Props) {
  *   const state = useFormControl(control);
+ *   const message = useIssueMessage(); // из '@reformer/core/react'
  *
  *   return (
  *     <div>
@@ -23,8 +24,8 @@ import { ValidationError } from '../types/index';
  *         disabled={state.disabled}
  *         onChange={e => control.setValue(e.target.value)}
  *       />
- *       {state.shouldShowError && state.errors[0] && (
- *         <span className="error">{state.errors[0].message}</span>
+ *       {state.shouldShowIssues && state.issues[0] && (
+ *         <span className="error">{message(state.issues[0])}</span>
  *       )}
  *     </div>
  *   );
@@ -88,21 +89,22 @@ export interface FieldControlState<T> {
      *
      * @example
      * ```tsx
-     * const { errors } = useFormControl(field);
+     * const { issues } = useFormControl(field);
+     * const message = useIssueMessage(); // из '@reformer/core/react'
      *
      * return (
      *   <ul className="error-list">
-     *     {errors.map((error, i) => (
-     *       <li key={i}>{error.message}</li>
+     *     {issues.map((error, i) => (
+     *       <li key={i}>{message(error)}</li>
      *     ))}
      *   </ul>
      * );
      * ```
      */
-    errors: ValidationError[];
+    issues: ValidationIssue[];
     /**
      * Флаг валидности поля.
-     * `true` когда поле прошло все валидации (errors.length === 0).
+     * `true` когда поле прошло все валидации (issues.length === 0).
      *
      * @example
      * ```tsx
@@ -116,7 +118,7 @@ export interface FieldControlState<T> {
     valid: boolean;
     /**
      * Флаг невалидности поля.
-     * `true` когда есть ошибки валидации (errors.length > 0).
+     * `true` когда есть ошибки валидации (issues.length > 0).
      * Противоположность {@link valid}.
      *
      * @example
@@ -146,27 +148,44 @@ export interface FieldControlState<T> {
      */
     touched: boolean;
     /**
-     * Флаг для отображения ошибки.
-     * Комбинация touched && invalid - удобный shortcut для UI.
+     * Показывать ли состояние ошибки — `aria-invalid`, рамку: поле невалидно и его трогали или
+     * меняли. Предупреждение (`severity: 'warning'`) поле невалидным не делает, поэтому для текстов
+     * замечаний есть {@link FieldControlState.shouldShowIssues}.
      *
      * @example
      * ```tsx
-     * const { shouldShowError, errors } = useFormControl(field);
+     * const { shouldShowError } = useFormControl(field);
+     *
+     * return <input {...props} aria-invalid={shouldShowError} />;
+     * ```
+     */
+    shouldShowError: boolean;
+    /**
+     * Показывать ли тексты замечаний: у поля есть замечания — ошибки или предупреждения, — и его
+     * трогали или меняли.
+     *
+     * @example
+     * ```tsx
+     * const { shouldShowError, shouldShowIssues, issues } = useFormControl(field);
+     * const message = useIssueMessage(); // из '@reformer/core/react'
      *
      * return (
      *   <div>
-     *     <input {...props} />
-     *     {shouldShowError && (
-     *       <span className="error">{errors[0]?.message}</span>
-     *     )}
+     *     <input {...props} aria-invalid={shouldShowError} />
+     *     {shouldShowIssues &&
+     *       issues.map((issue) => (
+     *         <span key={issue.code} className={issue.severity === 'warning' ? 'warning' : 'error'}>
+     *           {message(issue)}
+     *         </span>
+     *       ))}
      *   </div>
      * );
      * ```
      */
-    shouldShowError: boolean;
+    shouldShowIssues: boolean;
     /**
      * Пользовательские props для передачи в UI-компоненты.
-     * Устанавливаются через {@link FieldNode.updateComponentProps}.
+     * Устанавливаются через {@link FormControl.updateComponentProps}.
      *
      * @example
      * ```tsx
@@ -207,7 +226,7 @@ export interface FieldControlState<T> {
     dirty: boolean;
 }
 /**
- * Состояние массива формы, возвращаемое хуком {@link useFormControl} для {@link ArrayNode}.
+ * Состояние массива формы, возвращаемое хуком {@link useFormControl} для {@link FormArray}.
  *
  * Содержит реактивные данные массива: значения элементов, длину, состояние валидации
  * и флаги взаимодействия.
@@ -222,7 +241,7 @@ export interface FieldControlState<T> {
  * }
  *
  * interface Props {
- *   control: ArrayNode<Phone>;
+ *   control: FormArray<Phone>;
  * }
  *
  * function PhoneList({ control }: Props) {
@@ -232,7 +251,7 @@ export interface FieldControlState<T> {
  *     <div>
  *       {control.map((item, index) => (
  *         <PhoneItem
- *           key={item.id}
+ *           key={control.keyAt(index)}
  *           control={item}
  *           onRemove={() => control.removeAt(index)}
  *         />
@@ -244,7 +263,7 @@ export interface FieldControlState<T> {
  *         Add Phone
  *       </button>
  *
- *       {!valid && <p className="error">Please fix phone errors</p>}
+ *       {!valid && <p className="error">Please fix phone issues</p>}
  *     </div>
  *   );
  * }
@@ -290,23 +309,24 @@ export interface ArrayControlState<T> {
      */
     pending: boolean;
     /**
-     * Массив ошибок валидации уровня массива.
-     * Не включает ошибки отдельных элементов.
+     * Замечания массива: собственные (правила на ручке массива) и замечания всех его строк.
      *
      * @example
      * ```tsx
-     * // Валидатор массива
-     * validators.apply(phonesArray, {
-     *   validator: (phones) => phones.length >= 1,
-     *   message: 'At least one phone required'
-     * });
+     * // Правило массива — в схеме валидации
+     * validate(model.$.phones, [minLength(1, { code: 'phones.minLength' })]);
      *
      * // В компоненте
-     * const { errors } = useFormControl(phonesArray);
-     * // errors содержит ошибку "At least one phone required" если массив пуст
+     * const { issues } = useFormControl(phonesArray);
+     * // для пустого массива issues содержит замечание с кодом 'phones.minLength'
      * ```
      */
-    errors: ValidationError[];
+    issues: ValidationIssue[];
+    /**
+     * Собственные замечания массива — только правила на его ручке (`minLength` и т.п.), без
+     * замечаний строк. Их показывает ошибка уровня массива (`FieldArray.Error`).
+     */
+    ownIssues: ValidationIssue[];
     /**
      * Флаг валидности массива и всех его элементов.
      * `true` только когда массив и все вложенные элементы валидны.
@@ -324,7 +344,9 @@ export interface ArrayControlState<T> {
     touched: boolean;
     /**
      * Флаг изменения.
-     * `true` когда значение массива отличается от начального.
+     * `true` после правки любого элемента или изменения состава через форму (`push`, `removeAt`,
+     * `move`, `setValue`…). Как у поля, запись в модель (загрузка данных) и операция, которая состав
+     * не поменяла, изменением не считаются; снимает `reset`.
      *
      * @example
      * ```tsx
@@ -341,7 +363,7 @@ export interface ArrayControlState<T> {
     dirty: boolean;
     /**
      * Флаг отключения массива.
-     * `true` когда массив отключён (`ArrayNode.disable()`), в том числе через
+     * `true` когда массив отключён (`FormArray.disable()`), в том числе через
      * распространение disable от родительской группы.
      *
      * Используйте для отключения UI-действий добавления/удаления, когда массив

package/dist/platforms/react/hooks/use-form-bundle.d.ts

@@ -0,0 +1,41 @@
+import { FormValidationController } from '../../../form/validation/strategy';
+/** Минимум, который хук ожидает от бандла: контроллер живой валидации и снятие — оба опционально. */
+export interface FormBundleLike {
+    validation?: {
+        controller: FormValidationController;
+    };
+    /** Снять сборку: поведение, подписки нод, живую проверку. Есть у всех фабрик семейства. */
+    dispose?(): void;
+}
+/**
+ * Собрать форму один раз и держать её стабильной; живую стратегию валидации армировать в эффекте
+ * (не при SSR — там эффекты не выполняются); при размонтировании снять сборку.
+ *
+ * @typeParam B - Тип бандла конкретной фабрики.
+ * @param factory - Фабрика бандла, обычно `() => createForm({…})`. Сборкой владеет хук: при
+ *   размонтировании он вызывает её `dispose()`, поэтому фабрика должна собирать НОВУЮ форму, а не
+ *   возвращать чужую, живущую дольше компонента.
+ * @returns Стабильный бандл.
+ *
+ * @example
+ * ```tsx
+ * const credit = useFormBundle(() => createForm<CreditForm>({ model: createCreditModel() }));
+ * ```
+ *
+ * @remarks
+ * Передавайте именно фабрику: `useState` трактует функцию как ленивый инициализатор, а некоторые
+ * части бандла сами являются функциями (`RenderSchemaProxy`), поэтому `useFormBundle(bundle.render)`
+ * вызвал бы её вместо сохранения.
+ *
+ * Сборка снимается микрозадачей после размонтирования, а не в самой очистке эффекта (см. шапку
+ * модуля): код, который сразу после размонтирования пишет в модель, ещё видит живое поведение.
+ *
+ * **Ограничение StrictMode (только разработка).** StrictMode вызывает ленивый инициализатор
+ * `useState` дважды, и фабрика на монтирование срабатывает два раза. Второй бандл React
+ * выбрасывает до коммита: хук его не видит, поэтому не армирует и не снимает. Живая проверка у
+ * него не запущена, но поведение (`compute`, `onChange`, …) работает, пока бандл не соберёт
+ * сборщик мусора. В production инициализатор вызывается один раз и утечки нет. Побочные эффекты
+ * на создание (запрос данных в фабрике или в `setup`) в разработке поэтому тоже срабатывают
+ * дважды — запускайте их из поведения формы или из эффекта компонента.
+ */
+export declare function useFormBundle<B extends FormBundleLike>(factory: () => B): B;

package/dist/platforms/react/hooks/use-form-flow.d.ts

@@ -0,0 +1,40 @@
+import { FormFlow } from '../../../form/flow/flow';
+/**
+ * Состояние потока на момент рендера.
+ *
+ * @group React
+ */
+export interface FormFlowSnapshot {
+    /** Текущий шаг. */
+    readonly current: string;
+    /** Номер текущего шага с нуля. */
+    readonly index: number;
+    /** Пройденные шаги. */
+    readonly completed: ReadonlySet<string>;
+    readonly isFirst: boolean;
+    readonly isLast: boolean;
+    /** Идёт ли проверка шага. */
+    readonly validating: boolean;
+}
+/**
+ * Подписаться на поток шагов: компонент перерисовывается при смене шага, пройденных шагов и
+ * состояния проверки. Переходы — методами самого потока (`flow.next()`, `flow.goTo(id)`).
+ *
+ * @param flow - Поток шагов (`bundle.flow`).
+ * @returns {@link FormFlowSnapshot}.
+ *
+ * @example
+ * ```tsx
+ * function Steps({ flow }: { flow: FormFlow }) {
+ *   const { current, isLast, validating } = useFormFlow(flow);
+ *   return (
+ *     <button disabled={isLast || validating} onClick={() => void flow.next()}>
+ *       Далее ({current})
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @group React
+ */
+export declare function useFormFlow(flow: FormFlow): FormFlowSnapshot;

package/dist/{form → platforms/react}/hooks/use-form-validation.d.ts

@@ -1,11 +1,11 @@
-import { FormModel } from '../../index';
-import { ValidationSchema } from '../validation-schema';
-import { ValidationStrategyKind } from '../validation-strategy';
+import { FormModel } from '../../../model/types';
+import { ValidationDefinition } from '../../../form/validation';
+import { ValidationStrategyKind } from '../../../form/validation/strategy';
 export interface UseFormValidationArgs<T> {
     /** Модель данных формы. */
     model: FormModel<T>;
     /** Схема валидации. **Стабильная ссылка** (module-level `const` / `useMemo`) — иначе ломается дедуп раннера. */
-    schema: ValidationSchema<T>;
+    schema: ValidationDefinition<T>;
     /** Стратегия запуска. Default `'submit'`. */
     strategy?: ValidationStrategyKind;
     /** Debounce (мс) для live-фаз (`change` / live-часть `afterFirstSubmit`). */
@@ -14,9 +14,15 @@ export interface UseFormValidationArgs<T> {
     liveAfterSubmit?: 'change' | 'blur';
 }
 export interface UseFormValidationResult {
-    /** Полный прогон + раскрытие ошибок (`touch:true`); для `onSubmit`. Стабильная ссылка. */
+    /**
+     * Попытка отправки: полный прогон; при замечаниях раскрыта вся форма, `afterFirstSubmit`
+     * переходит в живую фазу. `true` — только статус `valid`. Для `onSubmit`. Стабильная ссылка.
+     */
     submit: () => Promise<boolean>;
-    /** Алиас `submit` для не-submit сценариев. */
+    /**
+     * Проверка без отправки: полный прогон, раскрыты замечания проверенных полей, фаза
+     * `afterFirstSubmit` не меняется. Для кнопки «Проверить». Стабильная ссылка.
+     */
     validate: () => Promise<boolean>;
     /** Идёт ли прогон (submit или live) — для блокировки кнопки. */
     isValidating: boolean;
@@ -31,7 +37,7 @@ export interface UseFormValidationResult {
  *
  * @example
  * ```tsx
- * const validation = defineValidationSchema<Form>(({ model }) => { ... }); // module-level
+ * const validation = defineValidation<Form>(({ model }) => { ... }); // module-level
  *
  * function MyForm() {
  *   const { submit, isValidating } = useFormValidation({

package/dist/{form → platforms/react}/hooks/useArrayLength.d.ts

@@ -1,13 +1,13 @@
-import { ArrayNode } from '../nodes/array-node';
+import { FormArray } from '../../../form/types/index';
 /**
  * React-хук для подписки только на длину массива.
  *
- * Оптимизированная версия {@link useFormControl} для ArrayNode, которая
- * подписывается только на сигнал `length`. Компонент не будет ре-рендериться
+ * Оптимизированная версия {@link useFormControl} для FormArray, которая
+ * подписывается только на длину массива. Компонент не будет ре-рендериться
  * при изменении значений вложенных полей.
  *
  * @typeParam T - Тип элемента массива
- * @param control - ArrayNode для подписки
+ * @param control - FormArray для подписки
  * @returns Текущая длина массива
  *
  * @example
@@ -18,7 +18,7 @@ import { ArrayNode } from '../nodes/array-node';
  *   return (
  *     <div>
  *       {arrayNode.map((item, index) => (
- *         <ItemRenderer key={item.id} item={item} />
+ *         <ItemRenderer key={arrayNode.keyAt(index)} item={item} />
  *       ))}
  *     </div>
  *   );
@@ -27,4 +27,4 @@ import { ArrayNode } from '../nodes/array-node';
  *
  * @group React Hooks
  */
-export declare function useArrayLength<T extends object>(control: ArrayNode<T>): number;
+export declare function useArrayLength<T extends object>(control: FormArray<T>): number;

package/dist/{form → platforms/react}/hooks/useFormControl.d.ts

@@ -1,24 +1,22 @@
-import { FieldNode } from '../nodes/field-node';
-import { ArrayNode } from '../nodes/array-node';
-import { FormValue } from '../types/index';
+import { FormArray, FormControl } from '../../../form/types/index';
 import { FieldControlState, ArrayControlState } from './types';
 /**
- * React-хук для подписки на состояние {@link ArrayNode}.
+ * React-хук для подписки на состояние {@link FormArray}.
  *
  * @typeParam T - Тип элемента массива
- * @param control - ArrayNode или undefined
+ * @param control - FormArray или undefined
  * @returns Состояние массива {@link ArrayControlState}
  *
  * @group React Hooks
  */
-export declare function useFormControl<T extends object>(control: ArrayNode<T> | undefined): ArrayControlState<T>;
+export declare function useFormControl<T extends object>(control: FormArray<T> | undefined): ArrayControlState<T>;
 /**
- * React-хук для подписки на состояние {@link FieldNode}.
+ * React-хук для подписки на состояние {@link FormControl}.
  *
  * @typeParam T - Тип значения поля
- * @param control - FieldNode для подписки
+ * @param control - FormControl для подписки
  * @returns Состояние поля {@link FieldControlState}
  *
  * @group React Hooks
  */
-export declare function useFormControl<T extends FormValue>(control: FieldNode<T>): FieldControlState<T>;
+export declare function useFormControl<T>(control: FormControl<T>): FieldControlState<T>;