@reformer/core 9.0.0-beta.1 → 9.0.0-beta.2

package/dist/behaviors.js

@@ -1,27 +1,27 @@
-import { effect as j } from "@preact/signals-core";
-import { r as $, m as x, c as O, w as F, e as S, t as A, a as C, s as M, b as D } from "./behaviors-O9a1Djj9.js";
+import { effect as O } from "@preact/signals-core";
+import { r as $, m as k, u as x, c as S, w as F, e as A, t as C, a as D, s as M, b as G } from "./behaviors-Br4Im38V.js";
 let p = null;
-function k(e) {
+function P(e) {
   if (!p)
     throw new Error(
       `[@reformer/core/behaviors] "${e}" вызван вне defineFormBehavior(...) — операторы поведения можно вызывать только внутри схемы.`
     );
   return p;
 }
-function a(e) {
-  k("onDispose").cleanups.push(e);
+function s(e) {
+  P("onDispose").cleanups.push(e);
 }
 function y() {
-  const e = k("getScope");
+  const e = P("getScope");
   return { model: e.model, form: e.form };
 }
-function G(e) {
+function T(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;
       }
@@ -32,211 +32,211 @@ function G(e) {
   };
 }
 function m(e) {
-  a(j(e));
+  s(O(e));
 }
-function g(e) {
+function _(e) {
   $(e);
 }
-const h = (e) => typeof e == "object" && e !== null && typeof e.peek == "function", P = (e) => Array.isArray(e) ? e : [e];
-function B(e) {
-  const n = {};
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    n[t] = h(o) ? o.value : B(o);
+const h = (e) => typeof e == "object" && e !== null && typeof e.peek == "function", B = (e) => Array.isArray(e) ? e : [e];
+function E(e) {
+  const t = {};
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    t[n] = h(o) ? o.value : E(o);
   }
-  return n;
+  return t;
 }
-function E(e, n) {
-  for (const t of Object.keys(e)) {
-    const o = e[t];
-    h(o) ? o.value = n?.[t] : E(o, n?.[t] ?? {});
+function W(e, t) {
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    h(o) ? o.value = t?.[n] : W(o, t?.[n] ?? {});
   }
 }
-function T(e) {
+function I(e) {
   if (!e) return;
-  const { form: n } = y();
-  return n.getFieldByPath(e);
+  const { form: t } = y();
+  return t.getFieldByPath(e);
 }
-function W(e) {
+function V(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 h(o) ? o.value : W(o);
+          return h(o) ? o.value : V(o);
       }
     }
   );
 }
-function V(e) {
-  return (n) => {
+function j(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 K(e, n, t) {
-  x(e);
-  const o = V(e);
+function L(e, t, n) {
+  k(e), s(() => x(e));
+  const o = j(e);
   m(() => {
-    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 L(e, n, t, o) {
-  x(n);
-  const r = V(n);
+function Q(e, t, n, o) {
+  k(t), s(() => x(t));
+  const r = j(t);
   m(() => {
     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 Q(e, n, t) {
-  if (h(e) && h(n)) {
-    a(O(e, n, t));
+function U(e, t, n) {
+  if (h(e) && h(t)) {
+    s(S(e, t, n));
     return;
   }
-  const o = e, r = n;
+  const o = e, r = t;
   m(() => {
-    const c = B(o);
-    t?.when && !t.when() || g(() => E(r, c));
+    const c = E(o);
+    n?.when && !n.when() || _(() => W(r, c));
   });
 }
-function I(e, n, t) {
+function R(e, t, n) {
   let o;
   const r = (c) => {
     o?.abort(), o = new AbortController();
     const { signal: i } = o;
-    $(() => n(c, { signal: i }));
+    $(() => t(c, { signal: i }));
   };
-  if (!t?.debounce)
-    a(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 }
     );
-    a(() => {
+    s(() => {
       c && clearTimeout(c), i();
     });
   }
-  a(() => o?.abort());
+  s(() => o?.abort());
 }
-function R(e, n, t) {
-  for (const o of P(e))
-    h(o) ? a(S(o, n, t)) : q(o, n, t);
+function q(e, t, n) {
+  for (const o of B(e))
+    h(o) ? s(A(o, t, n)) : z(o, t, n);
 }
-function U(e, n, t) {
-  R(e, () => !n(), t);
+function X(e, t, n) {
+  q(e, () => !t(), n);
 }
-function q(e, n, t) {
-  const o = T(e.__path);
+function z(e, t, n) {
+  const o = I(e.__path);
   o && m(() => {
-    const r = n();
-    g(() => {
-      r ? o.enable() : (o.disable(), t?.resetOnDisable && o.reset());
+    const r = t();
+    _(() => {
+      r ? o.enable() : (o.disable(), n?.resetOnDisable && o.reset());
     });
   });
 }
-function X(e, n) {
-  a(A(e, n));
+function Y(e, t) {
+  s(C(e, t));
 }
-function Y(e, n, t) {
-  a(C(e, n, t));
+function Z(e, t, n) {
+  s(D(e, t, n));
 }
-function Z(e, n, t) {
-  a(M(e, n, t));
+function ee(e, t, n) {
+  s(M(e, t, n));
 }
-function ee(e, n) {
-  a(D(e, n));
+function ne(e, t) {
+  s(G(e, t));
 }
-function _(e, n) {
-  return n.split(".").reduce((t, o) => t?.[o], e);
+function g(e, t) {
+  return t.split(".").reduce((n, o) => n?.[o], e);
 }
-function z(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 N(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 = _(t, r);
+  const c = g(n, r);
   if (!c) return;
   const i = o.getFieldByPath(
     r
-  ), f = i?.length, s = /* @__PURE__ */ new Map();
+  ), f = i?.length, u = /* @__PURE__ */ new Map();
   m(() => {
     const d = f ? f.value : c.length, w = /* @__PURE__ */ new Set();
-    for (let u = 0; u < d; u++) {
-      const l = c.at(u);
-      if (l != null && (w.add(l), !s.has(l))) {
-        const b = i?.at?.(u) ?? z(r);
-        s.set(l, n.__run(l, b));
+    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, t.__run(l, b));
       }
     }
-    for (const [u, l] of s)
-      w.has(u) || (l(), s.delete(u));
-  }), a(() => {
-    for (const d of s.values()) d();
-    s.clear();
+    for (const [a, l] of u)
+      w.has(a) || (l(), u.delete(a));
+  }), s(() => {
+    for (const d of u.values()) d();
+    u.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 te(e, n) {
-  const { model: t } = y(), o = e.__path;
+function te(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = _(t, o);
-  r && N(
+  const r = g(n, o);
+  r && H(
     e,
-    G(({ model: c }) => {
-      I(n(c), (i) => {
+    T(({ model: c }) => {
+      R(t(c), (i) => {
         if (i)
           for (let f = 0; f < r.length; f++) {
-            const s = r.at(f);
-            if (s && s !== c) {
-              const d = n(s);
+            const u = r.at(f);
+            if (u && u !== c) {
+              const d = t(u);
               d.peek() && (d.value = !1);
             }
           }
@@ -244,57 +244,57 @@ function te(e, n) {
     })
   );
 }
-function ne(e, n) {
-  const { model: t } = y(), o = e.__path;
+function oe(e, t) {
+  const { model: n } = y(), o = e.__path;
   if (!o) return;
-  const r = _(t, o);
+  const r = g(n, o);
   if (!r) return;
   let c = !1, i = 0;
   m(() => {
-    v(r), !c && (c = !0, g(() => {
+    v(r), !c && (c = !0, _(() => {
       c = !1;
-      const f = n(r.toArray());
-      let s = !1;
+      const f = t(r.toArray());
+      let u = !1;
       for (const { index: d, patch: w } of f) {
-        const u = r.at(d);
-        if (u)
+        const a = r.at(d);
+        if (a)
           for (const [l, b] of Object.entries(w))
-            u[l] !== b && (u[l] = b, s = !0);
+            a[l] !== b && (a[l] = b, u = !0);
       }
-      if (i = s ? i + 1 : 0, i > 50)
+      if (i = u ? i + 1 : 0, i > 50)
         throw i = 0, new Error(
           `[@reformer/core/behaviors] aggregateInto("${o}"): запись не сходится (>50 проходов) — derive должна быть идемпотентной на фикспоинте.`
         );
     }));
   });
 }
-function oe(e, n) {
-  const { form: t } = y();
-  for (const o of P(e)) {
+function re(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;
-    a(n.__run(W(r), f));
+    const i = n ? n.getFieldByPath(c) : void 0, f = i ? i.getProxy?.() ?? i : void 0;
+    s(t.__run(V(r), f));
   }
 }
 export {
-  ne as aggregateInto,
-  oe as apply,
-  N as applyEach,
-  K as compute,
-  L as computeFrom,
-  Q as copyFrom,
-  g as defer,
-  G as defineFormBehavior,
-  U as disableWhen,
+  oe as aggregateInto,
+  re as apply,
+  H as applyEach,
+  L as compute,
+  Q as computeFrom,
+  U as copyFrom,
+  _ as defer,
+  T as defineFormBehavior,
+  X as disableWhen,
   m as effect,
-  R as enableWhen,
+  q as enableWhen,
   te as exclusiveFlag,
   y as getScope,
-  I as onChange,
-  a as onDispose,
-  Y as resetWhen,
-  ee as revalidateWhen,
-  Z as syncFields,
-  X as transformValue
+  R as onChange,
+  s as onDispose,
+  Z as resetWhen,
+  ne as revalidateWhen,
+  ee as syncFields,
+  Y as transformValue
 };

package/dist/core/model/behaviors.d.ts

@@ -57,10 +57,25 @@ export declare function watchField<T>(source: ReadonlySignal<T>, cb: (value: T)
  * ⚠️ Поле должно быть материализовано в форме (`createForm`) — иначе ноды в реестре нет (например,
  * элемент массива, который строится per-item).
  *
+ * ⚠️ Если то же поле одновременно является целью `compute`/`computeFrom`, обязательно ограничь
+ * compute тем же условием (`when`), что и это `enableWhen`. Механизмы не согласованы: `enableWhen`
+ * работает со статус-машиной ноды (enable/disable/reset), а `compute` пишет `target.value` напрямую
+ * в сигнал модели и проверяет только собственный `options.when` — состояние `disabled` он НЕ смотрит.
+ * Поэтому при выключенном поле любое изменение зависимости compute молча заново заполнит его (а с
+ * `resetOnDisable` — перезапишет только что сброшенное значение), и так как `getValue()`/`submit`
+ * включают disabled-поля, мусор утечёт в payload. Это аналог правила #13 гайда add-behavior,
+ * которое сегодня сформулировано только для `copyFrom`; для `compute` то же ограничение обязательно.
+ *
  * @group Model
  * @example
  * ```typescript
  * enableWhen(model.$.propertyValue, () => model.loanType === 'mortgage', { resetOnDisable: true });
+ *
+ * // Поле-цель compute, которое ТАКЖЕ в resetOnDisable enableWhen: compute обязан нести тот же when,
+ * // иначе initialPayment заново заполнится в выключенном состоянии и утечёт в submit.
+ * compute(model.$.initialPayment, () => model.propertyValue * 0.2, {
+ *   when: () => model.loanType === 'mortgage',
+ * });
  * ```
  */
 export declare function enableWhen(target: ReadonlySignal<unknown>, condition: () => boolean, options?: {

package/dist/core/nodes/group-node.d.ts

@@ -1,4 +1,4 @@
-import { ReadonlySignal } from '@preact/signals-core';
+import { Signal, ReadonlySignal } from '@preact/signals-core';
 import { FormNode, SetValueOptions } from './form-node';
 import { ValidationError, FieldStatus, FormSchema, GroupNodeConfig, FormValue } from '../types';
 import { FormProxy } from '../types/form-proxy';
@@ -54,6 +54,18 @@ export declare class GroupNode<T> extends FormNode<T> {
     private readonly _disabled;
     /** Form-level validation errors */
     private readonly _formErrors;
+    /**
+     * M1: валидация уровня модели/схемы (`validateFormModel(model, schema)`). Привязывается
+     * `createForm({ model, schema })`, т.к. под M1 валидаторы срезаны с FieldNode и живут на слое
+     * модели. Без неё `validate()`/`submit()` пропускали бы все schema-валидаторы. @internal
+     */
+    private _modelValidate?;
+    /**
+     * M1: связь листовой ноды-ребёнка → её сигнал модели (тот, что помечает `markDerived`).
+     * Нужна bulk-сеттерам (`setValue`/`patchValue`), чтобы корректно определять derived-поля:
+     * `field.value` — computed-обёртка, отличная от записываемого сигнала модели. @internal
+     */
+    private readonly _fieldSignals;
     readonly value: ReadonlySignal<T>;
     readonly valid: ReadonlySignal<boolean>;
     readonly invalid: ReadonlySignal<boolean>;
@@ -156,7 +168,12 @@ export declare class GroupNode<T> extends FormNode<T> {
      *
      * @param onSubmit - Callback для отправки данных
      * @param options - Опции submit (skipValidation, skipTouch)
-     * @returns Результат от onSubmit или null если валидация не пройдена
+     * @returns Результат от onSubmit или `null` если валидация не пройдена
+     *
+     * @remarks
+     * `null` перегружен: он означает и «валидация не пройдена», и легитимный `null`-результат
+     * `onSubmit` (или void-обработчик). Если вызывающей стороне нужно различать эти случаи —
+     * используйте {@link submitWithResult}, который возвращает явный флаг `success`.
      */
     submit<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<R | null>;
     /**
@@ -264,6 +281,19 @@ export declare class GroupNode<T> extends FormNode<T> {
      * @internal
      */
     attachBehaviorCleanup(cleanup: () => void): void;
+    /**
+     * Прикрепить валидацию уровня модели/схемы (M1). Вызывается `createForm({ model, schema })`,
+     * чтобы `validate()`/`submit()` прогоняли schema-валидаторы (`validateFormModel`), а не только
+     * пустые FieldNode. Возвращаемый флаг — валидна ли модель по схеме.
+     * @internal
+     */
+    attachModelValidator(validate: () => Promise<boolean>): void;
+    /**
+     * Связать листовую ноду-ребёнка с её сигналом модели (M1). Вызывается `createForm` для каждого
+     * листового поля на его владеющей группе — используется bulk-сеттерами для derived-guard (F9).
+     * @internal
+     */
+    registerFieldSignal(node: FormNode<any>, signal: Signal<unknown>): void;
     /**
      * Очистить все ресурсы узла
      */

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

@@ -58,6 +58,7 @@ export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
     private readonly buildItem;
     private readonly itemNodes;
     private readonly cache;
+    private mountedModels;
     private readonly initial;
     private readonly _arrayErrors;
     private readonly disposeSync;
@@ -109,6 +110,12 @@ export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
     protected onMarkAsPristine(): void;
     protected onDisable(): void;
     protected onEnable(): void;
-    /** Очистка подписки синхронизации. */
+    /** Диспозит форму элемента (эффекты/поведения/вложенные подписки); терпима к не-GroupNode. */
+    private disposeItemNode;
+    /**
+     * Очистка подписки синхронизации И детерминированный teardown всех форм элементов.
+     * Без пробрасывания dispose в itemNodes эффекты/поведения каждой формы элемента (в т.ч. disposeSync
+     * вложенных ModelArrayNode) остались бы жить после teardown формы — утечка подписок.
+     */
     dispose(): void;
 }

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

@@ -37,6 +37,27 @@ export interface FieldConfig<T> {
     /** Задержка (в мс) перед запуском асинхронной валидации */
     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>>;
 /**
  * Конфигурация массива
  * @group Types
@@ -90,5 +111,6 @@ export interface ArrayConfig<T extends object> {
  * ```
  */
 export type FormSchema<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends string | number | boolean ? FieldConfig<T[K]> : NonNullable<T[K]> extends Array<infer U> ? U extends string | number | boolean ? FieldConfig<T[K]> : U extends Date | File | Blob | AnyFunction ? FieldConfig<T[K]> : [FormSchema<U>] : NonNullable<T[K]> extends Date | File | Blob | AnyFunction ? FieldConfig<T[K]> : FormSchema<NonNullable<T[K]>>;
+    [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/core/types/form-proxy.d.ts

@@ -64,8 +64,33 @@ export type FormControlsProxy<T> = {
  * 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> & FormControlsProxy<T>;
+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 доступом к элементам
  *