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

package/dist/behaviors.js

@@ -1,7 +1,7 @@
-import { effect as O } from "@preact/signals-core";
-import { d as $, a as S, w as F, t as A, r as C, s as D, b as M } from "./behaviors-value-C7dSEhCc.js";
-import { m as k, u as x } from "./derived-registry-CluZCQ7U.js";
-import { e as G } from "./behaviors-node-DGEFMTQu.js";
+import { effect as j } from "@preact/signals-core";
+import { m as $, u as k, i as C } from "./form-model-DhW2HZOB.js";
+import { d as x, a as M, w as F, t as O, r as A, s as D, b as G } from "./behaviors-value-C7dSEhCc.js";
+import { e as T } from "./behaviors-node-DGEFMTQu.js";
 let p = null;
 function P(e) {
   if (!p)
@@ -17,13 +17,13 @@ function y() {
   const e = P("getScope");
   return { model: e.model, form: e.form };
 }
-function T(e) {
+function I(e) {
   return {
-    __run(n, t) {
-      const o = { cleanups: [], model: n, form: t }, r = p;
+    __run(t, n) {
+      const o = { cleanups: [], model: t, form: n }, r = p;
       p = o;
       try {
-        e({ model: n, form: t });
+        e({ model: t, form: n });
       } finally {
         p = r;
       }
@@ -34,111 +34,111 @@ function T(e) {
   };
 }
 function h(e) {
-  s(O(e));
+  s(j(e));
 }
-function _(e) {
-  $(e);
+function g(e) {
+  x(e);
 }
-const m = (e) => typeof e == "object" && e !== null && typeof e.peek == "function", B = (e) => Array.isArray(e) ? e : [e];
+const m = (e) => typeof e == "object" && e !== null && typeof e.peek == "function" && !C(e), B = (e) => Array.isArray(e) ? e : [e];
 function E(e) {
-  const n = {};
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    n[t] = m(o) ? o.value : E(o);
+  const t = {};
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    t[n] = m(o) ? o.value : E(o);
   }
-  return n;
+  return t;
 }
-function W(e, n) {
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    m(o) ? o.value = n?.[t] : W(o, n?.[t] ?? {});
+function W(e, t) {
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    m(o) ? o.value = t?.[n] : W(o, t?.[n] ?? {});
   }
 }
-function I(e) {
+function R(e) {
   if (!e) return;
-  const { form: n } = y();
-  return n.getFieldByPath(e);
+  const { form: t } = y();
+  return t.getFieldByPath(e);
 }
-function V(e) {
+function S(e) {
   return new Proxy(
     {},
     {
-      get: (n, t) => {
-        if (t === "$") return e;
-        if (typeof t != "string") return;
-        const o = e[t];
+      get: (t, n) => {
+        if (n === "$") return e;
+        if (typeof n != "string") return;
+        const o = e[n];
         if (o != null)
-          return m(o) ? o.value : V(o);
+          return m(o) ? o.value : S(o);
       }
     }
   );
 }
-function j(e) {
-  return (n) => {
+function V(e) {
+  return (t) => {
     try {
-      n();
-    } catch (t) {
-      if (t instanceof Error && /cycle detected/i.test(t.message)) {
+      t();
+    } catch (n) {
+      if (n instanceof Error && /cycle detected/i.test(n.message)) {
         const o = e.__path ?? "?";
         throw new Error(
           `[@reformer/core/behaviors] compute("${o}"): расходящийся цикл пересчёта — взаимные compute/computeFrom без стабилизации. Проверьте зависимости или добавьте стабилизирующее условие (when) / разорвите цикл через peek.`
         );
       }
-      throw t;
+      throw n;
     }
   };
 }
-function U(e, n, t) {
-  k(e), s(() => x(e));
-  const o = j(e);
+function X(e, t, n) {
+  $(e), s(() => k(e));
+  const o = V(e);
   h(() => {
-    if (t?.when && !t.when()) return;
-    const r = n();
+    if (n?.when && !n.when()) return;
+    const r = t();
     e.peek() !== r && o(() => {
       e.value = r;
     });
   });
 }
-function X(e, n, t, o) {
-  k(n), s(() => x(n));
-  const r = j(n);
+function Y(e, t, n, o) {
+  $(t), s(() => k(t));
+  const r = V(t);
   h(() => {
     const c = e.map((f) => f.value);
     if (o?.when && !o.when(...c)) return;
-    const i = t(...c);
-    n.peek() !== i && r(() => {
-      n.value = i;
+    const i = n(...c);
+    t.peek() !== i && r(() => {
+      t.value = i;
     });
   });
 }
-function Y(e, n, t) {
-  if (m(e) && m(n)) {
-    s(S(e, n, t));
+function Z(e, t, n) {
+  if (m(e) && m(t)) {
+    s(M(e, t, n));
     return;
   }
-  const o = e, r = n;
+  const o = e, r = t;
   h(() => {
     const c = E(o);
-    t?.when && !t.when() || _(() => W(r, c));
+    n?.when && !n.when() || g(() => W(r, c));
   });
 }
-function R(e, n, t) {
+function q(e, t, n) {
   let o;
   const r = (c) => {
     o?.abort(), o = new AbortController();
     const { signal: i } = o;
-    $(() => n(c, { signal: i }));
+    x(() => t(c, { signal: i }));
   };
-  if (!t?.debounce)
-    s(F(e, r, { immediate: t?.immediate }));
+  if (!n?.debounce)
+    s(F(e, r, { immediate: n?.immediate }));
   else {
     let c;
     const i = F(
       e,
       (f) => {
-        c && clearTimeout(c), c = setTimeout(() => r(f), t.debounce);
+        c && clearTimeout(c), c = setTimeout(() => r(f), n.debounce);
       },
-      { immediate: t?.immediate }
+      { immediate: n?.immediate }
     );
     s(() => {
       c && clearTimeout(c), i();
@@ -146,99 +146,99 @@ function R(e, n, t) {
   }
   s(() => o?.abort());
 }
-function q(e, n, t) {
+function z(e, t, n) {
   for (const o of B(e))
-    m(o) ? s(G(o, n, t)) : z(o, n, t);
+    m(o) ? s(T(o, t, n)) : L(o, t, n);
 }
-function Z(e, n, t) {
-  q(e, () => !n(), t);
+function ee(e, t, n) {
+  z(e, () => !t(), n);
 }
-function z(e, n, t) {
-  const o = I(e.__path);
+function L(e, t, n) {
+  const o = R(e.__path);
   o && h(() => {
-    const r = n();
-    _(() => {
-      r ? o.enable() : (o.disable(), t?.resetOnDisable && o.reset());
+    const r = t();
+    g(() => {
+      r ? o.enable() : (o.disable(), n?.resetOnDisable && o.reset());
     });
   });
 }
-function ee(e, n) {
-  s(A(e, n));
+function ne(e, t) {
+  s(O(e, t));
 }
-function te(e, n, t) {
-  s(C(e, n, t));
+function te(e, t, n) {
+  s(A(e, t, n));
 }
-function ne(e, n, t) {
-  s(D(e, n, t));
+function oe(e, t, n) {
+  s(D(e, t, n));
 }
-function oe(e, n) {
-  s(M(e, n));
+function re(e, t) {
+  s(G(e, t));
 }
-function g(e, n) {
-  return n.split(".").reduce((t, o) => t?.[o], e);
+function _(e, t) {
+  return t.split(".").reduce((n, o) => n?.[o], e);
 }
 function N(e) {
   return new Proxy(
     {},
     {
-      get(n, t) {
-        if (!(typeof t == "symbol" || t === "then"))
+      get(t, n) {
+        if (!(typeof n == "symbol" || n === "then"))
           throw new Error(
             `[@reformer/core/behaviors] applyEach: форма строки массива "${e}" недоступна (form.${String(
-              t
+              n
             )}) — массив не материализован в схеме формы. Per-row node-операции (enableWhen/updateComponentProps/reset) требуют узла { array, item } в схеме; value-операции (row.$.*: compute/copyFrom/transformValue) работают и без материализации.`
           );
       }
     }
   );
 }
-function H(e, n) {
-  const { model: t, form: o } = y(), r = e.__path;
+function H(e, t) {
+  const { model: n, form: o } = y(), r = e.__path;
   if (!r) return;
-  const c = g(t, r);
+  const c = _(n, r);
   if (!c) return;
   const i = o.getFieldByPath(
     r
-  ), f = i?.length, u = /* @__PURE__ */ new Map();
+  ), f = i?.length, a = /* @__PURE__ */ new Map();
   h(() => {
     const d = f ? f.value : c.length, w = /* @__PURE__ */ new Set();
-    for (let a = 0; a < d; a++) {
-      const l = c.at(a);
-      if (l != null && (w.add(l), !u.has(l))) {
-        const b = i?.at?.(a) ?? N(r);
-        u.set(l, n.__run(l, b));
+    for (let u = 0; u < d; u++) {
+      const l = c.at(u);
+      if (l != null && (w.add(l), !a.has(l))) {
+        const b = i?.at?.(u) ?? N(r);
+        a.set(l, t.__run(l, b));
       }
     }
-    for (const [a, l] of u)
-      w.has(a) || (l(), u.delete(a));
+    for (const [u, l] of a)
+      w.has(u) || (l(), a.delete(u));
   }), s(() => {
-    for (const d of u.values()) d();
-    u.clear();
+    for (const d of a.values()) d();
+    a.clear();
   });
 }
 function v(e) {
   if (e == null || typeof e != "object") return;
-  const n = e;
-  if (typeof n.at == "function" && typeof n.length == "number") {
-    const t = n.length;
-    for (let o = 0; o < t; o++) v(n.at(o));
+  const t = e;
+  if (typeof t.at == "function" && typeof t.length == "number") {
+    const n = t.length;
+    for (let o = 0; o < n; o++) v(t.at(o));
     return;
   }
-  for (const t of Object.keys(e)) v(e[t]);
+  for (const n of Object.keys(e)) v(e[n]);
 }
-function re(e, n) {
-  const { model: t } = y(), o = e.__path;
+function ce(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = g(t, o);
+  const r = _(n, o);
   r && H(
     e,
-    T(({ model: c }) => {
-      R(n(c), (i) => {
+    I(({ model: c }) => {
+      q(t(c), (i) => {
         if (i)
           for (let f = 0; f < r.length; f++) {
-            const u = r.at(f);
-            if (u && u !== c) {
-              const d = n(u);
+            const a = r.at(f);
+            if (a && a !== c) {
+              const d = t(a);
               d.peek() && (d.value = !1);
             }
           }
@@ -246,57 +246,57 @@ function re(e, n) {
     })
   );
 }
-function ce(e, n) {
-  const { model: t } = y(), o = e.__path;
+function ie(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = g(t, o);
+  const r = _(n, o);
   if (!r) return;
   let c = !1, i = 0;
   h(() => {
-    v(r), !c && (c = !0, _(() => {
+    v(r), !c && (c = !0, g(() => {
       c = !1;
-      const f = n(r.toArray());
-      let u = !1;
+      const f = t(r.toArray());
+      let a = !1;
       for (const { index: d, patch: w } of f) {
-        const a = r.at(d);
-        if (a)
+        const u = r.at(d);
+        if (u)
           for (const [l, b] of Object.entries(w))
-            a[l] !== b && (a[l] = b, u = !0);
+            u[l] !== b && (u[l] = b, a = !0);
       }
-      if (i = u ? i + 1 : 0, i > 50)
+      if (i = a ? i + 1 : 0, i > 50)
         throw i = 0, new Error(
           `[@reformer/core/behaviors] aggregateInto("${o}"): запись не сходится (>50 проходов) — derive должна быть идемпотентной на фикспоинте.`
         );
     }));
   });
 }
-function ie(e, n) {
-  const { form: t } = y();
+function fe(e, t) {
+  const { form: n } = y();
   for (const o of B(e)) {
     const r = o, c = r.__path;
     if (!c) continue;
-    const i = t ? t.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
-    s(n.__run(V(r), f));
+    const i = n ? n.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
+    s(t.__run(S(r), f));
   }
 }
 export {
-  ce as aggregateInto,
-  ie as apply,
+  ie as aggregateInto,
+  fe as apply,
   H as applyEach,
-  U as compute,
-  X as computeFrom,
-  Y as copyFrom,
-  _ as defer,
-  T as defineFormBehavior,
-  Z as disableWhen,
+  X as compute,
+  Y as computeFrom,
+  Z as copyFrom,
+  g as defer,
+  I as defineFormBehavior,
+  ee as disableWhen,
   h as effect,
-  q as enableWhen,
-  re as exclusiveFlag,
+  z as enableWhen,
+  ce as exclusiveFlag,
   y as getScope,
-  R as onChange,
+  q as onChange,
   s as onDispose,
   te as resetWhen,
-  oe as revalidateWhen,
-  ne as syncFields,
-  ee as transformValue
+  re as revalidateWhen,
+  oe as syncFields,
+  ne as transformValue
 };

package/dist/form/create-core-form.d.ts

@@ -0,0 +1,70 @@
+import { FormModel } from '../state/types';
+import { FormSchemaNode } from './types/schema-node';
+import { FormBehavior } from './behaviors';
+import { FormProxy } from './types/index';
+import { FormValidation, FormValidationBundle } from './validation-config';
+import { ValidationSchema } from './validation-schema';
+/**
+ * Общая часть конфига всех фабрик формы.
+ *
+ * @typeParam T - Форма данных модели.
+ * @typeParam B - Бандл конкретной фабрики (его получает {@link CreateFormConfigBase.setup}).
+ */
+export interface CreateFormConfigBase<T, B> {
+    /** Начальные значения — из них создаётся модель. Взаимоисключимо с `model`. */
+    initial?: T;
+    /** Готовая модель (если создана отдельной фабрикой). Приоритетнее `initial`. */
+    model?: FormModel<T>;
+    /** Декларативное поведение модели (compute/copyFrom/enableWhen/onChange). */
+    behavior?: FormBehavior<T>;
+    /** Правила валидации: готовая схема либо {@link FormValidation} со стратегией и шагами. */
+    validation?: FormValidation<T> | ValidationSchema<T>;
+    /**
+     * Правка модели ДО сборки формы. Нужна там, где значение обязано существовать к моменту
+     * построения нод — например, массив, наполняемый из вычислений (реактивные `onChange` на
+     * инициализации не срабатывают).
+     */
+    seed?: (model: FormModel<T>) => void;
+    /**
+     * Донастройка ПОСЛЕ сборки. Единственное место для правок, которые обязаны идти следом за
+     * `createForm`: поле, чьё значение уже массив, ноды не получает (см. `buildModelConfig`),
+     * поэтому такой префилл выполняется здесь.
+     */
+    setup?: (bundle: B) => void;
+}
+/** Результат {@link createCoreForm}: модель, форма и (если заданы правила) собранная валидация. */
+export interface CoreForm<T> {
+    model: FormModel<T>;
+    form: FormProxy<T>;
+    validation?: FormValidationBundle<T>;
+}
+/** Конфиг {@link createCoreForm}. */
+export interface CreateCoreFormConfig<T> extends CreateFormConfigBase<T, CoreForm<T>> {
+    /**
+     * Билдер схемы формы. Именно функция, а не готовое дерево: листья схемы держат сами сигналы
+     * модели (`value: model.$.email`), поэтому построить дерево до модели нечем.
+     */
+    schema?: (model: FormModel<T>) => FormSchemaNode;
+}
+/**
+ * Собрать модель, форму и валидацию за один проход.
+ *
+ * @typeParam T - Форма данных модели.
+ * @param config - {@link CreateCoreFormConfig}: (`initial` | `model`) + опц. `schema`, `behavior`,
+ *   `validation`, `seed`, `setup`.
+ * @returns {@link CoreForm}` <T>` — `{ model, form, validation? }`.
+ *
+ * @example
+ * ```tsx
+ * const credit = useFormBundle(() =>
+ *   createCoreForm<CreditForm>({
+ *     model: createCreditModel(),
+ *     schema: buildCreditSchema,
+ *     behavior: creditBehavior,
+ *     validation: { steps: { loan: loanRules, confirm: null }, extras: crossRules },
+ *   })
+ * );
+ * return <FormWizard form={credit.form} config={credit.validation} steps={STEPS} />;
+ * ```
+ */
+export declare function createCoreForm<T extends object>(config: CreateCoreFormConfig<T>): CoreForm<T>;

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

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

package/dist/form/index.d.ts

@@ -19,6 +19,12 @@ export { ModelArrayNode } from './nodes/model-array-node';
 export type { ModelArrayControl } from './nodes/model-array-node';
 export { createForm, createFormFromModel } from './create-form';
 export type { CreateFormFromModelArgs } from './create-form';
+export { createCoreForm } from './create-core-form';
+export type { CoreForm, CreateCoreFormConfig, CreateFormConfigBase } from './create-core-form';
+export { buildValidation } from './validation-config';
+export type { FormValidation, FormValidationBundle } from './validation-config';
+export { useFormBundle } from './hooks/use-form-bundle';
+export type { FormBundleLike } from './hooks/use-form-bundle';
 export { enableWhen, disableWhen } from './behaviors-node';
 export { FormErrorHandler, ErrorStrategy } from './error-handler';
 export { registerSignalNode, getNodeForSignal } from './signal-node-registry';

package/dist/form/validation-config.d.ts

@@ -0,0 +1,73 @@
+import { ReadonlySignal } from '@preact/signals-core';
+import { FormModel } from '../state/types';
+import { ValidationSchema } from './validation-schema';
+import { FormValidationController, ValidationStrategyKind } from './validation-strategy';
+/**
+ * Правила валидации формы — ДАННЫЕ (без привязки к рендеру).
+ *
+ * ⚠️ `schema` и значения `steps` обязаны быть **стабильными ссылками**: отмена устаревших прогонов
+ * ключуется по паре `(model, schema)` через `WeakMap`, поэтому инлайн-стрелка ломает дедупликацию —
+ * валидация начнёт возвращать `false` от уже отменённых прогонов. Держите их
+ * module-level-константами (`defineValidationSchema`).
+ */
+export interface FormValidation<T> {
+    /** Полный набор правил — для submit и `validateAll`. Без него собирается из `steps` + `extras`. */
+    schema?: ValidationSchema<T>;
+    /**
+     * Пошаговая валидация визарда: ключ = `selector` шага. `null` означает «шаг без правил» ЯВНО —
+     * чтобы опечатка в ключе не выглядела как пустой шаг.
+     */
+    steps?: Record<string, ValidationSchema<T> | null>;
+    /** Cross-field правила, которые проверяются только целиком (в `validateAll`), но не по шагам. */
+    extras?: ValidationSchema<T>;
+    /** Когда запускать живую валидацию. По умолчанию `'submit'` (реактивно молчит). */
+    strategy?: ValidationStrategyKind;
+    debounce?: number;
+    /** Режим live-фазы для `afterFirstSubmit`. По умолчанию `'change'`. */
+    liveAfterSubmit?: 'change' | 'blur';
+}
+/**
+ * Собранная валидация формы. Структурно совместима с `FormWizardConfig` и `StepValidationConfig`
+ * из `@reformer/cdk`, поэтому уходит в визард как есть: `config={bundle.validation}` либо
+ * `patchProps({ form, ...bundle.validation })`.
+ */
+export interface FormValidationBundle<T> {
+    /** Полная схема (стабильная ссылка) — та, по которой идёт `validateAll`. */
+    readonly schema: ValidationSchema<T>;
+    /** Селекторы шагов в порядке объявления. Пусто, если `steps` не заданы. */
+    readonly stepSelectors: readonly string[];
+    /** Полный прогон с раскрытием ошибок. Синоним {@link FormValidationBundle.validateAll}. */
+    validate(): Promise<boolean>;
+    validateAll(): Promise<boolean>;
+    /** Прогон правил одного шага: по номеру (1-based, как у визарда) или по селектору. */
+    validateStep(step: number | string): Promise<boolean>;
+    /** Контроллер живой валидации ШАГА; `null` — у шага нет правил либо стратегия `submit`. */
+    createStepController(step: number | string): FormValidationController | null;
+    /** Контроллер живой валидации ФОРМЫ. Армится хуком (`useFormBundle`), не фабрикой. */
+    readonly controller: FormValidationController;
+    /** Идёт ли прогон — реактивный сигнал (для тонкой подписки в UI). */
+    readonly validating: ReadonlySignal<boolean>;
+}
+/**
+ * Собрать {@link FormValidationBundle} из правил. Принимает либо готовую схему (сахар для простых
+ * форм), либо {@link FormValidation} с шагами и стратегией.
+ *
+ * Схема для `validateAll` собирается ОДИН раз на бандл — иначе ломается дедупликация прогонов.
+ *
+ * @typeParam T - Форма данных модели.
+ * @param model - Модель, по которой идут прогоны.
+ * @param validation - Правила; `undefined` — валидации у формы нет.
+ * @returns Бандл валидации либо `undefined`, если правила не заданы.
+ *
+ * @example
+ * ```ts
+ * const v = buildValidation(model, {
+ *   steps: { loan: loanRules, applicant: applicantRules, confirm: null },
+ *   extras: crossFieldRules,
+ *   strategy: 'blur',
+ * });
+ * await v!.validateStep(1);   // правила шага `loan`
+ * await v!.validateAll();     // все шаги + extras
+ * ```
+ */
+export declare function buildValidation<T>(model: FormModel<T>, validation?: FormValidation<T> | ValidationSchema<T>): FormValidationBundle<T> | undefined;

package/dist/form/validation-strategy.d.ts

@@ -23,9 +23,15 @@ export interface FormValidationController {
      * `afterFirstSubmit` в live-фазу. Возвращает `false`, если есть блокирующие ошибки.
      */
     validate(): Promise<boolean>;
-    /** Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR. */
+    /**
+     * Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR.
+     *
+     * После {@link FormValidationController.dispose} контроллер армируется ЗАНОВО: React монтирует
+     * компоненты повторно (StrictMode в разработке, remount по роуту), и «одноразовый» контроллер
+     * после такого цикла молча оставался бы без живой валидации.
+     */
     start(): () => void;
-    /** Снять подписки/таймеры. Идемпотентно. */
+    /** Снять подписки/таймеры. Идемпотентно; после него `start()` снова армирует стратегию. */
     dispose(): void;
     /** Идёт ли прогон (submit или live) — снапшот. */
     readonly isValidating: boolean;