@reformer/core 11.0.0-beta.5 → 11.0.0-beta.7

package/dist/model-signals-proxy-2vqS243J.js

@@ -0,0 +1,250 @@
+import { batch as y, signal as v, Signal as A, computed as w } from "@preact/signals-core";
+const u = /* @__PURE__ */ new WeakMap();
+function R(t) {
+  u.set(t, (u.get(t) ?? 0) + 1);
+}
+function D(t) {
+  const e = u.get(t);
+  e !== void 0 && (e <= 1 ? u.delete(t) : u.set(t, e - 1));
+}
+function _(t) {
+  return u.has(t);
+}
+const h = (t) => !(t === null || typeof t != "object" || Array.isArray(t) || t instanceof Date || typeof Blob < "u" && t instanceof Blob || typeof File < "u" && t instanceof File), o = (t, e) => t === "" ? String(e) : `${t}.${e}`, S = (t) => /^\d+$/.test(t), l = (t) => {
+  if (Array.isArray(t)) return t.map(l);
+  if (h(t)) {
+    const e = {};
+    for (const r of Object.keys(t)) e[r] = l(t[r]);
+    return e;
+  }
+  return t;
+}, d = (t, e) => {
+  if (t === e) return !0;
+  if (Array.isArray(t) && Array.isArray(e))
+    return t.length !== e.length ? !1 : t.every((r, i) => d(r, e[i]));
+  if (h(t) && h(e)) {
+    const r = Object.keys(t), i = Object.keys(e);
+    return r.length !== i.length ? !1 : r.every((s) => d(t[s], e[s]));
+  }
+  return !1;
+};
+class j {
+  constructor(e, r) {
+    this.path = r;
+    const i = v(e);
+    i.__path = r, this.signal = i, this.initial = l(e);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(e) {
+    this.path = e, this.signal.__path = e;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(e) {
+    this.signal.value = e;
+  }
+  resetToInitial() {
+    this.signal.value = l(this.initial);
+  }
+  captureInitial() {
+    this.initial = l(this.signal.peek());
+  }
+  dirty() {
+    return !d(this.signal.peek(), this.initial);
+  }
+}
+class $ {
+  constructor(e, r) {
+    this.path = r;
+    for (const i of Object.keys(e))
+      this.children.set(i, c(e[i], o(r, i)));
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(e) {
+    this.path = e;
+    for (const [r, i] of this.children) i.rebase(o(e, r));
+  }
+  /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+  read() {
+    const e = {};
+    for (const [r, i] of this.children) e[r] = i.read();
+    return e;
+  }
+  peek() {
+    const e = {};
+    for (const [r, i] of this.children) e[r] = i.peek();
+    return e;
+  }
+  set(e) {
+    if (e == null || typeof e != "object") return;
+    const r = e;
+    y(() => {
+      for (const [i, s] of this.children)
+        i in r && (s.kind === "leaf" && _(s.signal) || s.set(r[i]));
+    });
+  }
+  resetToInitial() {
+    y(() => {
+      for (const e of this.children.values()) e.resetToInitial();
+    });
+  }
+  captureInitial() {
+    for (const e of this.children.values()) e.captureInitial();
+  }
+  dirty() {
+    for (const e of this.children.values()) if (e.dirty()) return !0;
+    return !1;
+  }
+}
+class x {
+  constructor(e, r) {
+    this.path = r, this.items = v(e.map((i, s) => c(i, o(r, s)))), this.initial = l(e);
+  }
+  kind = "array";
+  items;
+  initial;
+  rebase(e) {
+    this.path = e, this.items.peek().forEach((r, i) => r.rebase(o(e, i)));
+  }
+  reindex() {
+    this.items.peek().forEach((e, r) => e.rebase(o(this.path, r)));
+  }
+  push(e) {
+    const r = this.items.peek();
+    this.items.value = [...r, c(e, o(this.path, r.length))];
+  }
+  insertAt(e, r) {
+    const i = [...this.items.peek()];
+    i.splice(e, 0, c(r, o(this.path, e))), this.items.value = i, this.reindex();
+  }
+  removeAt(e) {
+    const r = [...this.items.peek()];
+    r.splice(e, 1), this.items.value = r, this.reindex();
+  }
+  move(e, r) {
+    const i = [...this.items.peek()], [s] = i.splice(e, 1);
+    s && i.splice(r, 0, s), this.items.value = i, this.reindex();
+  }
+  swap(e, r) {
+    const i = [...this.items.peek()];
+    e < 0 || r < 0 || e >= i.length || r >= i.length || e === r || ([i[e], i[r]] = [i[r], i[e]], this.items.value = i, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  /**
+   * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+   * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+   */
+  read() {
+    return this.items.value.map((e) => e.read());
+  }
+  peek() {
+    return this.items.peek().map((e) => e.peek());
+  }
+  set(e) {
+    const r = Array.isArray(e) ? e : [];
+    this.items.value = r.map((i, s) => c(i, o(this.path, s)));
+  }
+  resetToInitial() {
+    this.set(l(this.initial));
+  }
+  captureInitial() {
+    this.initial = l(this.peek());
+  }
+  dirty() {
+    return !d(this.peek(), this.initial);
+  }
+}
+function c(t, e) {
+  return Array.isArray(t) ? new x(t, e) : h(t) ? new $(t, e) : new j(t, e);
+}
+const k = /* @__PURE__ */ new WeakMap();
+function I(t) {
+  const e = w(() => t.read());
+  return {
+    get value() {
+      return e.value;
+    },
+    peek: () => e.peek(),
+    subscribe: (r) => e.subscribe(r),
+    valueOf: () => e.value,
+    toString: () => String(e.value),
+    toJSON: () => e.value,
+    brand: e.brand
+  };
+}
+function b(t) {
+  if (t.kind === "leaf") return t.signal;
+  const e = k.get(t);
+  if (e) return e;
+  const r = I(t), i = t.kind === "group", s = (a) => i ? t.children.get(a) : S(a) ? t.items.value[Number(a)] : void 0, g = i ? {} : {
+    get length() {
+      return t.items.value.length;
+    }
+  }, m = new Proxy(g, {
+    get: (a, n, p) => {
+      if (n === "__path") return t.path;
+      if (n === "__kind") return t.kind;
+      if (typeof n != "string") return Reflect.get(r, n, r);
+      const f = s(n);
+      return f ? b(f) : !i && Reflect.has(a, n) ? Reflect.get(a, n, p) : Reflect.get(r, n, r);
+    },
+    set: (a, n, p) => {
+      if (!i && n === "value")
+        return t.set(p), !0;
+      const f = t.path === "" ? "model.$" : `model.$.${t.path}`;
+      throw new TypeError(
+        `[@reformer/core] ${f}: запись в «${String(n)}» ` + (i ? "узла-группы невозможна — группа читается целиком, а пишется по полям (model.$.<поле>.value) либо через model.patch(...)" : "узла-массива невозможна — массив заменяется целиком через .value, а элемент правится своим сигналом (model.$.<массив>[i].value)")
+      );
+    },
+    has: (a, n) => typeof n == "string" && (s(n) !== void 0 || !i && Reflect.has(a, n)),
+    ownKeys: () => i ? [...t.children.keys()] : Reflect.ownKeys(g),
+    getOwnPropertyDescriptor: (a, n) => typeof n == "string" && s(n) ? { enumerable: !0, configurable: !0 } : i ? void 0 : Reflect.getOwnPropertyDescriptor(a, n)
+  });
+  return k.set(t, m), m;
+}
+function P(t) {
+  if (t == null || typeof t != "object") return !1;
+  const e = t.__kind;
+  return e === "group" || e === "array";
+}
+function O(t) {
+  return t == null || typeof t != "object" ? !1 : t.__kind === "array";
+}
+function M(t) {
+  return t instanceof A || O(t);
+}
+function T(t, e) {
+  if (!e) return;
+  let r = t;
+  for (const i of e.split(".")) {
+    if (!r) return;
+    if (r.kind === "group") r = r.children.get(i);
+    else if (r.kind === "array") r = r.items.peek()[Number(i)];
+    else return;
+  }
+  if (r)
+    return r.kind === "leaf" ? r.signal : r.kind === "array" ? b(r) : void 0;
+}
+export {
+  $ as G,
+  M as a,
+  _ as b,
+  S as c,
+  O as d,
+  P as i,
+  R as m,
+  T as r,
+  b as s,
+  D as u
+};

package/dist/model.js

@@ -1,21 +1,23 @@
-import { c as s, e as r } from "./create-model-Dxh9cfLp.js";
-import { a as i, i as t, m as c, u as l } from "./model-signals-proxy-mV3WGdlO.js";
-import { c as n, a as f, r as m, b as u, d as p, e as b, f as h, s as k, t as v, w as D } from "./behaviors-value-C7dSEhCc.js";
+import { c as s, e as r, a as i } from "./create-model-B8U-COv-.js";
+import { b as o, i as c, a as n, m as t, u as d } from "./model-signals-proxy-2vqS243J.js";
+import { c as m, a as u, r as b, b as h, d as p, e as g, f as k, s as v, t as D, w as F } from "./behaviors-value-C7dSEhCc.js";
 export {
-  n as computeFrom,
-  f as copyFrom,
+  m as computeFrom,
+  u as copyFrom,
   s as createModel,
   r as eachLeafSignal,
-  i as isDerived,
-  t as isModelContainerSignal,
-  c as markDerived,
-  m as resetWhen,
-  u as revalidateWhen,
+  i as eachValueSignal,
+  o as isDerived,
+  c as isModelContainerSignal,
+  n as isValueSignal,
+  t as markDerived,
+  b as resetWhen,
+  h as revalidateWhen,
   p as runOutsideEffect,
-  b as safeCallback,
-  h as safeDebouncedCallback,
-  k as syncFields,
-  v as transformValue,
-  l as unmarkDerived,
-  D as watchField
+  g as safeCallback,
+  k as safeDebouncedCallback,
+  v as syncFields,
+  D as transformValue,
+  d as unmarkDerived,
+  F as watchField
 };

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`:
+     * errors/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,50 @@
+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`.
+ *
+ * @internal Экспортируется для юнит-тестов.
+ */
+export declare function resolveFieldHandle(inner: RefObject<unknown>): unknown;

package/dist/platforms/react/hooks/types.d.ts

@@ -15,6 +15,7 @@ import { ValidationError } from '../../../form/types/index';
  *
  * function TextField({ control }: Props) {
  *   const state = useFormControl(control);
+ *   const message = useValidationMessage(); // из '@reformer/core/i18n'
  *
  *   return (
  *     <div>
@@ -24,7 +25,7 @@ import { ValidationError } from '../../../form/types/index';
  *         onChange={e => control.setValue(e.target.value)}
  *       />
  *       {state.shouldShowError && state.errors[0] && (
- *         <span className="error">{state.errors[0].message}</span>
+ *         <span className="error">{message(state.errors[0])}</span>
  *       )}
  *     </div>
  *   );
@@ -89,11 +90,12 @@ export interface FieldControlState<T> {
      * @example
      * ```tsx
      * const { errors } = useFormControl(field);
+     * const message = useValidationMessage(); // из '@reformer/core/i18n'
      *
      * return (
      *   <ul className="error-list">
      *     {errors.map((error, i) => (
-     *       <li key={i}>{error.message}</li>
+     *       <li key={i}>{message(error)}</li>
      *     ))}
      *   </ul>
      * );
@@ -152,12 +154,13 @@ export interface FieldControlState<T> {
      * @example
      * ```tsx
      * const { shouldShowError, errors } = useFormControl(field);
+     * const message = useValidationMessage(); // из '@reformer/core/i18n'
      *
      * return (
      *   <div>
      *     <input {...props} />
      *     {shouldShowError && (
-     *       <span className="error">{errors[0]?.message}</span>
+     *       <span className="error">{message(errors[0])}</span>
      *     )}
      *   </div>
      * );

package/dist/platforms/react/hooks/useFormControlValue.d.ts

@@ -134,6 +134,7 @@ import { FormValue } from '../../../form/types/index';
  * // Основной редактор использует useFormControl для полного состояния
  * function MarkdownEditor({ control }: MarkdownEditorProps) {
  *   const { value, shouldShowError, errors } = useFormControl(control);
+ *   const message = useValidationMessage(); // из '@reformer/core/i18n'
  *
  *   return (
  *     <div className="editor-container">
@@ -141,7 +142,7 @@ import { FormValue } from '../../../form/types/index';
  *         value={value}
  *         onChange={e => control.setValue(e.target.value)}
  *       />
- *       {shouldShowError && <span className="error">{errors[0]?.message}</span>}
+ *       {shouldShowError && <span className="error">{message(errors[0])}</span>}
  *
  *       {/* Preview обновляется только при изменении value *}
  *       <MarkdownPreview control={control} />

package/dist/platforms/react/i18n/context.d.ts

@@ -0,0 +1,13 @@
+import { I18nHandle } from '../../../i18n/translator';
+/** Имя контекста и одновременно маркер, по которому страж ищет его копии в сборках. */
+export declare const I18N_CONTEXT_MARKER = "ReformerI18nContext";
+/** Что видит компонент: ручка активной локали и состояние её загрузки. */
+export interface I18nContextValue extends I18nHandle {
+    /** Идёт загрузка другого языка; на экране пока прежний. Без загрузчика всегда `false`. */
+    readonly pending: boolean;
+    /** Ошибка последней загрузки языка. */
+    readonly error: unknown;
+}
+/** Значение контекста для локали: ручка плюс состояние загрузки. */
+export declare function contextValue(handle: I18nHandle, pending: boolean, error: unknown): I18nContextValue;
+export declare const I18nContext: import('react').Context<I18nContextValue>;

package/dist/platforms/react/i18n/hooks.d.ts

@@ -0,0 +1,59 @@
+import { ValidationError } from '../../../form/types/contracts';
+import { Messages } from '../../../i18n/locale';
+import { MessageValues } from '../../../i18n/message-format';
+import { I18nContextValue } from './context';
+/**
+ * Активная локаль: перевод ключей приложения, форматирование чисел, дат и размеров, состояние
+ * загрузки языка. Без провайдера — английский с пустым словарём.
+ *
+ * @example
+ * ```tsx
+ * function LangBadge() {
+ *   const { code, pending, t } = useI18n();
+ *   return <span aria-busy={pending}>{t('app.language')}: {code}</span>;
+ * }
+ * ```
+ */
+export declare function useI18n(): I18nContextValue;
+/**
+ * Переводчик пакета: ищет ключ в локали провайдера, а при промахе берёт встроенную английскую
+ * таблицу этого пакета. Так пакет говорит по-английски без провайдера и не зависит от того, знает
+ * ли локаль его ключи. Тип ключа выводится из таблицы — опечатка в ключе не скомпилируется.
+ *
+ * `defaults` должен быть стабильной ссылкой (импорт JSON-модуля), иначе переводчик будет
+ * пересоздаваться на каждый рендер.
+ *
+ * @param defaults - Встроенная английская таблица пакета.
+ * @returns Функция `(ключ, значения?) => строка`; её идентичность меняется вместе с локалью.
+ *
+ * @example
+ * ```tsx
+ * import en from './locale/en.json';
+ *
+ * const useKitMessages = () => useMessages(en);
+ *
+ * function ClearButton() {
+ *   const t = useKitMessages();
+ *   return <button aria-label={t('kit.select.clear')} />;
+ * }
+ * ```
+ */
+export declare function useMessages<D extends Messages>(defaults: D): (key: keyof D & string, values?: MessageValues) => string;
+/**
+ * Резолвер текста ошибки валидации по активной локали: `messageKey` автора → явное `message` →
+ * словарь локали по коду → встроенный английский → код. Идентичность функции меняется вместе с
+ * локалью, поэтому показанные ошибки переводятся при смене языка без повторной валидации.
+ *
+ * `FormField` из `@reformer/cdk` использует его сам; вызывайте напрямую, если рисуете ошибки
+ * своим компонентом.
+ *
+ * @example
+ * ```tsx
+ * function FieldErrors({ control }: { control: FieldNode<string> }) {
+ *   const message = useValidationMessage();
+ *   const { errors } = useFormControl(control);
+ *   return <>{errors.map((error) => <span key={error.code}>{message(error)}</span>)}</>;
+ * }
+ * ```
+ */
+export declare function useValidationMessage(): (error: ValidationError) => string;

package/dist/platforms/react/i18n/provider.d.ts

@@ -0,0 +1,52 @@
+import { ReactElement, ReactNode } from 'react';
+import { FormLocale } from '../../../i18n/locale';
+import { LocaleLoad } from '../../../i18n/locale-store';
+/** Режим «готовая локаль». */
+export interface I18nStaticProviderProps {
+    /** Локаль. Смена объекта переключает язык сразу. */
+    locale: FormLocale;
+    children?: ReactNode;
+}
+/** Режим «провайдер грузит сам». */
+export interface I18nLoadingProviderProps {
+    /** Код языка. Смена кода запускает загрузку; до её конца на экране прежний язык. */
+    lang: string;
+    /** Загрузчик локалей — обычно результат `createLocaleLoader`. */
+    load: LocaleLoad;
+    /**
+     * Что показать, пока не загружена самая первая локаль. По умолчанию — ничего: иначе на кадр
+     * мелькнул бы встроенный английский. Если локаль уже в кэше загрузчика (`load.preload(lang)`
+     * до монтирования), первый рендер синхронный и `fallback` не показывается.
+     */
+    fallback?: ReactNode;
+    /** Отказ загрузки. Язык на экране при этом не меняется. */
+    onError?: (error: unknown, lang: string) => void;
+    children?: ReactNode;
+}
+export type I18nProviderProps = I18nStaticProviderProps | I18nLoadingProviderProps;
+/**
+ * Провайдер локализации для подписей компонентов, ошибок валидации и авторских подписей формы.
+ * Без провайдера компоненты говорят встроенным английским.
+ *
+ * При смене `lang` на экране остаётся прежний язык, пока новый не загрузится (`useI18n().pending`
+ * — для индикатора). При быстром переключении применяется только последний запрос. Вложенный
+ * провайдер заменяет локаль для своего поддерева целиком.
+ *
+ * @example Провайдер грузит локаль сам
+ * ```tsx
+ * const [lang, setLang] = useState('ru');
+ *
+ * <I18nProvider lang={lang} load={loadLocale}>
+ *   <LangSwitch value={lang} onChange={setLang} />
+ *   <CreditForm />
+ * </I18nProvider>
+ * ```
+ *
+ * @example Готовая локаль — SSR и тесты
+ * ```tsx
+ * import { ru } from '@reformer/ui-kit/locale/ru';
+ *
+ * <I18nProvider locale={ru}><CreditForm /></I18nProvider>
+ * ```
+ */
+export declare function I18nProvider(props: I18nProviderProps): ReactElement | null;

package/dist/platforms/react/index.d.ts

@@ -21,3 +21,7 @@ export type { UseFormValidationArgs, UseFormValidationResult } from './hooks/use
 export { useFormBundle } from './hooks/use-form-bundle';
 export type { FormBundleLike } from './hooks/use-form-bundle';
 export type { FieldControlState, ArrayControlState } from './hooks/types';
+export { getFieldAdapter, bindFieldProps, FIELD_WRAPPER_ONLY_PROPS, } from './field-binding/field-adapter';
+export type { FieldAdapter, FieldAdapterCarrier, FieldSeam } from './field-binding/field-adapter';
+export { makeElementFieldHandle, useFieldHandleRef } from './field-binding/field-handle';
+export type { FieldHandle } from './field-binding/field-handle';