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

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

@@ -2,13 +2,13 @@
  * Модуль `platforms/react` — биндинги ядра к React.
  *
  * Единственное место в пакете, где есть runtime-зависимость от `react` и
- * `use-sync-external-store`: слои `model` и `form` от React свободны (в `form/types/` остаются
- * только type-only `ComponentType`/`ElementType` — они стираются при компиляции). Хуки читают
+ * `use-sync-external-store`: слои `model` и `form` от React свободны и в рантайме, и в типах
+ * (компонент узла схемы для них — непрозрачная ссылка `ComponentRef`). Хуки читают
  * сигналы нод формы через `useSyncExternalStore` и отдают плоские снапшоты
  * ({@link FieldControlState}/{@link ArrayControlState}) в рендер.
  *
- * Barrel заведён как точка для будущего сабпата `@reformer/core/react`; сейчас его состав
- * реэкспортируется зонтиком `@reformer/core` — ровно теми же именами, что и до выноса.
+ * Состав barrel'а отдаёт вход `@reformer/core/react` (`src/react.ts`); корень `@reformer/core` его
+ * не реэкспортирует.
  *
  * @group Platforms
  * @module platforms/react
@@ -20,6 +20,9 @@ export { useFormValidation } from './hooks/use-form-validation';
 export type { UseFormValidationArgs, UseFormValidationResult } from './hooks/use-form-validation';
 export { useFormBundle } from './hooks/use-form-bundle';
 export type { FormBundleLike } from './hooks/use-form-bundle';
+export { useFormFlow } from './hooks/use-form-flow';
+export type { FormFlowSnapshot } from './hooks/use-form-flow';
+export { FormBundleContext, useFormBundleContext } from './form-bundle-context';
 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';

package/dist/react.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Подпуть `@reformer/core/react` — привязка ядра к React: хуки нод формы, связка поля с контролом,
+ * контекст сборки и React-часть локализации.
+ *
+ * Единственный вход пакета с зависимостью от `react`. Корень `@reformer/core` и остальные сабпаты
+ * от React свободны, поэтому `react` и `react-dom` — необязательные peer-зависимости: они нужны
+ * только тому, кто импортирует этот вход.
+ *
+ * Контекст локализации обязан существовать в одном экземпляре на все пакеты `@reformer/*`:
+ * пакеты получают его отсюда как внешнюю зависимость и не включают в свою сборку
+ * (страж — `scripts/check-i18n-singleton.mjs`).
+ *
+ * @group Platforms
+ * @module react
+ * @mergeModuleWith <project>
+ */
+export * from './platforms/react/index';
+export { I18nProvider } from './platforms/react/i18n/provider';
+export type { I18nProviderProps, I18nStaticProviderProps, I18nLoadingProviderProps, } from './platforms/react/i18n/provider';
+export { useI18n, useMessages, useIssueMessage } from './platforms/react/i18n/hooks';
+export { I18N_CONTEXT_MARKER } from './platforms/react/i18n/context';
+export type { I18nContextValue } from './platforms/react/i18n/context';

package/dist/react.js

@@ -0,0 +1,505 @@
+import U, { useRef as v, useCallback as y, useMemo as m, useEffect as F, useState as j, createContext as G, useContext as L, useImperativeHandle as $, createElement as k, Fragment as K } from "react";
+import { D as N } from "./locale-CG54AU2Q.js";
+import { a as x, c as W, t as Y, r as X } from "./validation-message-Ced9MGxs.js";
+import { c as z } from "./type-guards-D-N_5Ddh.js";
+import { effect as R } from "@preact/signals-core";
+import { h as J } from "./strategy-CoFSemuP.js";
+var w = { exports: {} }, I = {};
+var q;
+function Q() {
+  if (q) return I;
+  q = 1;
+  var e = U;
+  function t(i, c) {
+    return i === c && (i !== 0 || 1 / i === 1 / c) || i !== i && c !== c;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, u = e.useState, n = e.useEffect, s = e.useLayoutEffect, d = e.useDebugValue;
+  function h(i, c) {
+    var o = c(), l = u({ inst: { value: o, getSnapshot: c } }), f = l[0].inst, S = l[1];
+    return s(
+      function() {
+        f.value = o, f.getSnapshot = c, p(f) && S({ inst: f });
+      },
+      [i, o, c]
+    ), n(
+      function() {
+        return p(f) && S({ inst: f }), i(function() {
+          p(f) && S({ inst: f });
+        });
+      },
+      [i]
+    ), d(o), o;
+  }
+  function p(i) {
+    var c = i.getSnapshot;
+    i = i.value;
+    try {
+      var o = c();
+      return !r(i, o);
+    } catch {
+      return !0;
+    }
+  }
+  function E(i, c) {
+    return c();
+  }
+  var a = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? E : h;
+  return I.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : a, I;
+}
+var C = {};
+var B;
+function Z() {
+  return B || (B = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(o, l) {
+      return o === l && (o !== 0 || 1 / o === 1 / l) || o !== o && l !== l;
+    }
+    function t(o, l) {
+      a || n.startTransition === void 0 || (a = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var f = l();
+      if (!i) {
+        var S = l();
+        s(f, S) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), i = !0);
+      }
+      S = d({
+        inst: { value: f, getSnapshot: l }
+      });
+      var g = S[0].inst, _ = S[1];
+      return p(
+        function() {
+          g.value = f, g.getSnapshot = l, r(g) && _({ inst: g });
+        },
+        [o, f, l]
+      ), h(
+        function() {
+          return r(g) && _({ inst: g }), o(function() {
+            r(g) && _({ inst: g });
+          });
+        },
+        [o]
+      ), E(f), f;
+    }
+    function r(o) {
+      var l = o.getSnapshot;
+      o = o.value;
+      try {
+        var f = l();
+        return !s(o, f);
+      } catch {
+        return !0;
+      }
+    }
+    function u(o, l) {
+      return l();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var n = U, s = typeof Object.is == "function" ? Object.is : e, d = n.useState, h = n.useEffect, p = n.useLayoutEffect, E = n.useDebugValue, a = !1, i = !1, c = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? u : t;
+    C.useSyncExternalStore = n.useSyncExternalStore !== void 0 ? n.useSyncExternalStore : c, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), C;
+}
+var P;
+function ee() {
+  return P || (P = 1, process.env.NODE_ENV === "production" ? w.exports = Q() : w.exports = Z()), w.exports;
+}
+var b = ee();
+function te(e, t) {
+  if (e === t) return !0;
+  if (e.length !== t.length) return !1;
+  for (let r = 0; r < e.length; r++)
+    if (e[r] !== t[r]) return !1;
+  return !0;
+}
+function ne(e, t) {
+  if (Object.is(e, t)) return !0;
+  if (e === null || t === null || typeof e != "object" || typeof t != "object") return !1;
+  const r = e, u = t, n = Object.keys(r);
+  return n.length !== Object.keys(u).length ? !1 : n.every(
+    (s) => Object.prototype.hasOwnProperty.call(u, s) && Object.is(r[s], u[s])
+  );
+}
+function V(e, t, r, u) {
+  const n = v(null), s = v(e);
+  s.current = e;
+  const d = v(t);
+  d.current = t;
+  const h = v(r);
+  if (h.current = r, n.current === null) {
+    const a = {};
+    for (const i in e)
+      a[i] = e[i].value;
+    n.current = { ...a, __snapshot: null };
+  }
+  const p = y(
+    (a) => {
+      let i = !0;
+      return R(() => {
+        const o = s.current;
+        for (const { key: l } of d.current)
+          o[l]?.value;
+        if (i) {
+          i = !1;
+          return;
+        }
+        a();
+      });
+    },
+    // subscriptionKey намеренно не читается в теле — он здесь КЛЮЧ ИДЕНТИЧНОСТИ подписки (см. JSDoc
+    // параметра). Убрать его (как предлагает автофикс) значит получить subscribe, созданный один раз
+    // навсегда: подмена контрола на другой узел перестанет пересоздавать effect. Тот же приём ниже
+    // у getSnapshot.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [u]
+  ), E = y(() => {
+    const a = n.current, i = s.current, c = {};
+    for (const l in i)
+      c[l] = i[l].value;
+    let o = !1;
+    for (const l of d.current) {
+      const { key: f, useShallowArrayEqual: S, useShallowObjectEqual: g } = l, _ = c[f], A = a[f];
+      if (g) {
+        if (!ne(A, _)) {
+          o = !0;
+          break;
+        }
+      } else if (S) {
+        if (!te(A, _)) {
+          o = !0;
+          break;
+        }
+      } else if (A !== _) {
+        o = !0;
+        break;
+      }
+    }
+    if (!o && a.__snapshot && a.__key === u)
+      return a.__snapshot;
+    for (const l in i)
+      a[l] = c[l];
+    return a.__key = u, a.__snapshot = h.current(c), a.__snapshot;
+  }, [u]);
+  return b.useSyncExternalStore(p, E, E);
+}
+function re(e) {
+  const t = {
+    value: e.value,
+    disabled: e.disabled,
+    issues: e.issues,
+    pending: e.pending,
+    valid: e.valid,
+    invalid: e.invalid,
+    touched: e.touched,
+    dirty: e.dirty,
+    shouldShowError: e.shouldShowError,
+    shouldShowIssues: e.shouldShowIssues,
+    componentProps: e.componentProps
+  };
+  return V(t, [
+    { key: "value" },
+    { key: "disabled" },
+    { key: "issues", useShallowArrayEqual: !0 },
+    { key: "pending" },
+    { key: "valid" },
+    { key: "invalid" },
+    { key: "touched" },
+    { key: "dirty" },
+    { key: "shouldShowError" },
+    { key: "shouldShowIssues" },
+    // `updateComponentProps` всегда отдаёт новый объект: те же значения поле не перерисовывают.
+    { key: "componentProps", useShallowObjectEqual: !0 }
+  ], (n) => ({
+    value: n.value,
+    pending: n.pending,
+    disabled: n.disabled,
+    issues: n.issues,
+    valid: n.valid,
+    invalid: n.invalid,
+    touched: n.touched,
+    dirty: n.dirty,
+    shouldShowError: n.shouldShowError,
+    shouldShowIssues: n.shouldShowIssues,
+    componentProps: n.componentProps
+  }), e);
+}
+function ue(e) {
+  const t = {
+    value: e.value,
+    issues: e.issues,
+    ownIssues: e.ownIssues,
+    pending: e.pending,
+    valid: e.valid,
+    invalid: e.invalid,
+    touched: e.touched,
+    dirty: e.dirty,
+    disabled: e.disabled
+  };
+  return V(t, [
+    { key: "value" },
+    { key: "issues", useShallowArrayEqual: !0 },
+    { key: "ownIssues", useShallowArrayEqual: !0 },
+    { key: "pending" },
+    { key: "valid" },
+    { key: "invalid" },
+    { key: "touched" },
+    { key: "dirty" },
+    { key: "disabled" }
+  ], (n) => ({
+    value: n.value,
+    length: n.value.length,
+    pending: n.pending,
+    issues: n.issues,
+    ownIssues: n.ownIssues,
+    valid: n.valid,
+    invalid: n.invalid,
+    touched: n.touched,
+    dirty: n.dirty,
+    disabled: n.disabled
+  }), e);
+}
+function se() {
+  return V({}, [], () => ({
+    value: [],
+    length: 0,
+    pending: !1,
+    issues: [],
+    ownIssues: [],
+    valid: !0,
+    invalid: !1,
+    touched: !1,
+    dirty: !1,
+    disabled: !1
+  }));
+}
+function be(e) {
+  return e ? z(e) ? ue(e) : re(e) : se();
+}
+function Oe(e) {
+  const t = v({ value: e.value.value }), r = y(
+    (n) => {
+      let s = !0;
+      return R(() => {
+        if (e.value.value, s) {
+          s = !1;
+          return;
+        }
+        n();
+      });
+    },
+    [e]
+  ), u = y(() => {
+    const n = e.value.value;
+    return t.current.value === n ? t.current.value : (t.current.value = n, n);
+  }, [e]);
+  return b.useSyncExternalStore(r, u, u);
+}
+function ke(e) {
+  const t = v({ length: e.length }), r = y(
+    (n) => {
+      let s = !0;
+      return R(() => {
+        if (e.length, s) {
+          s = !1;
+          return;
+        }
+        n();
+      });
+    },
+    [e]
+  ), u = y(() => {
+    const n = e.length;
+    return t.current.length === n ? t.current.length : (t.current.length = n, n);
+  }, [e]);
+  return b.useSyncExternalStore(r, u, u);
+}
+function we(e) {
+  const { model: t, schema: r, strategy: u, debounce: n, liveAfterSubmit: s } = e, d = m(
+    () => J(t, r, { strategy: u, debounce: n, liveAfterSubmit: s }),
+    [t, r, u, n, s]
+  );
+  F(() => d.start(), [d]);
+  const h = b.useSyncExternalStore(
+    y((a) => d.validating.subscribe(a), [d]),
+    () => d.validating.peek(),
+    () => !1
+    // SSR: прогон не идёт
+  ), p = y(
+    async () => (await d.run({ touch: "all", submit: !0 })).status === "valid",
+    [d]
+  ), E = y(() => d.validate(), [d]);
+  return { submit: p, validate: E, isValidating: h };
+}
+function Le(e) {
+  const [t, r] = j(e), [u] = j(() => e), n = v(null);
+  return F(() => {
+    const s = n.current;
+    if (s?.bundle === t && s.done) {
+      let h = !0;
+      return queueMicrotask(() => {
+        h && r(u());
+      }), () => {
+        h = !1;
+      };
+    }
+    n.current = null, s?.bundle === t && (s.cancelled = !0);
+    const d = t.validation?.controller.start();
+    return () => {
+      d?.();
+      const h = { bundle: t, cancelled: !1, done: !1 };
+      n.current = h, queueMicrotask(() => {
+        h.cancelled || (t.dispose?.(), h.done = !0);
+      });
+    };
+  }, [t, u]), t;
+}
+const D = (e) => ({
+  current: e.current.value,
+  index: e.index.value,
+  completed: e.completed.value,
+  isFirst: e.isFirst.value,
+  isLast: e.isLast.value,
+  validating: e.validating.value
+}), oe = (e, t) => e.current === t.current && e.index === t.index && e.completed === t.completed && e.validating === t.validating;
+function xe(e) {
+  const t = v(null), r = y(() => {
+    const n = D(e), s = t.current;
+    return s && s.flow === e && oe(s.snapshot, n) ? s.snapshot : (t.current = { flow: e, snapshot: n }, n);
+  }, [e]), u = y(
+    (n) => {
+      let s = !0;
+      return R(() => {
+        if (D(e), s) {
+          s = !1;
+          return;
+        }
+        n();
+      });
+    },
+    [e]
+  );
+  return b.useSyncExternalStore(u, r, r);
+}
+const ie = G(null);
+function Re() {
+  return L(ie);
+}
+const le = ["labelTooltip"];
+function Ae(e) {
+  if (!(e == null || typeof e != "function" && typeof e != "object"))
+    return e.reformerAdapter;
+}
+const H = (e) => e;
+function Ie(e, t, r = {}) {
+  const u = { ...r };
+  for (const s of le) delete u[s];
+  for (const s of e?.strip ?? []) delete u[s];
+  if (!e)
+    return { ...u, value: t.value, onChange: t.onChange, onBlur: t.onBlur };
+  const n = e.fromEmit ?? H;
+  return {
+    ...u,
+    [e.valueProp ?? "value"]: (e.toValue ?? H)(t.value),
+    [e.changeProp ?? "onChange"]: (s) => t.onChange(n(s, u)),
+    ...e.bindBlur ? e.bindBlur(t.onBlur) : { onBlur: t.onBlur }
+  };
+}
+function M(e) {
+  return {
+    focus: () => e.current?.focus(),
+    blur: () => e.current?.blur(),
+    scrollIntoView: (t) => e.current?.scrollIntoView(t),
+    getElement: () => e.current
+  };
+}
+function ae(e) {
+  return typeof e == "object" && e !== null && e.nodeType === 1;
+}
+function Ce(e) {
+  const t = v(null), r = v(null);
+  return $(e, () => ce(t, r)), t;
+}
+function ce(e, t) {
+  const r = e.current;
+  if (r != null && !ae(r)) return r;
+  const u = e;
+  return t ? (t.current ??= M(u), t.current) : M(u);
+}
+const de = "ReformerI18nContext", fe = () => {
+};
+function T(e, t, r, u = fe) {
+  return { ...e, pending: t, error: r, retry: u };
+}
+const he = T(x(N), !1, void 0), O = G(he);
+O.displayName = de;
+function pe({ locale: e, children: t }) {
+  const r = m(() => T(x(e), !1, void 0), [e]);
+  return k(O.Provider, { value: r }, t);
+}
+function Se({
+  lang: e,
+  load: t,
+  fallback: r,
+  onError: u,
+  children: n
+}) {
+  const s = v(u);
+  s.current = u;
+  const d = v(null), h = v(!1), p = m(
+    () => W(t, e, {
+      onError: (f, S) => s.current?.(f, S),
+      previous: d.current ?? void 0
+    }),
+    [t]
+  );
+  F(() => {
+    p.setLang(e);
+  }, [p, e]);
+  const E = b.useSyncExternalStore(p.subscribe, p.getState, p.getState), { locale: a, pending: i, error: c } = E;
+  a !== null && (d.current = a);
+  const o = a === null && (c !== void 0 || h.current), l = m(
+    () => a === null && !o ? null : T(x(a ?? N), i, c, p.retry),
+    [a, o, i, c, p]
+  );
+  return l === null ? r === void 0 ? null : k(K, null, r) : (h.current = !0, k(O.Provider, { value: l }, n));
+}
+function Fe(e) {
+  return "locale" in e ? k(pe, e) : k(Se, e);
+}
+function Ve() {
+  return L(O);
+}
+function Te(e) {
+  const { locale: t } = L(O);
+  return m(
+    () => (r, u) => Y(t, e, r, u),
+    [t, e]
+  );
+}
+function je(e) {
+  const { locale: t } = L(O);
+  return m(() => {
+    const r = x(t);
+    return (u) => X(u, r, e);
+  }, [t, e]);
+}
+export {
+  le as FIELD_WRAPPER_ONLY_PROPS,
+  ie as FormBundleContext,
+  de as I18N_CONTEXT_MARKER,
+  Fe as I18nProvider,
+  Ie as bindFieldProps,
+  Ae as getFieldAdapter,
+  M as makeElementFieldHandle,
+  ke as useArrayLength,
+  Ce as useFieldHandleRef,
+  Le as useFormBundle,
+  Re as useFormBundleContext,
+  be as useFormControl,
+  Oe as useFormControlValue,
+  xe as useFormFlow,
+  we as useFormValidation,
+  Ve as useI18n,
+  je as useIssueMessage,
+  Te as useMessages
+};

package/dist/runtime-token.d.ts

@@ -7,8 +7,7 @@
  *
  * Почему именно объект, а не строка с версией: две копии ОДНОЙ версии ломают всё ровно так же,
  * как две копии разных версий, — раздваиваются модульные `WeakMap` (`derived-registry`,
- * `signal-node-registry`) и перестают работать проверки `instanceof Signal`. Сравнение версий
- * такой случай пропустило бы.
+ * `signal-node-registry`). Сравнение версий такой случай пропустило бы.
  *
  * @see `@reformer/form-registry/guard`
  *