@reformer/core 5.0.0 → 6.0.0

package/README.md

@@ -40,6 +40,8 @@ import {
   validate,
   watchField,
   FieldNode,
+  type ValidationSchemaFn,
+  type BehaviorSchemaFn,
 } from '@reformer/core';
 
 // 0. Simple FormField component
@@ -76,7 +78,7 @@ const formSchema = {
 };
 
 // 3. Validation schema
-validationSchema = (path) => {
+const validationSchema: ValidationSchemaFn<RegistrationForm> = (path) => {
   required(path.username);
 
   required(path.email);
@@ -85,9 +87,9 @@ validationSchema = (path) => {
   required(path.password);
   required(path.confirmPassword);
 
-  // Cross-field validation: passwords must match
-  validate(path.confirmPassword, (value, ctx) => {
-    const password = ctx.form.password.value.value;
+  // Cross-field validation: вешается на поле-носитель ошибки, соседнее поле читается через `root`
+  validate(path.confirmPassword, (value, _control, root) => {
+    const password = root.password.value.value;
     if (value && password && value !== password) {
       return { code: 'mismatch', message: 'Passwords do not match' };
     }
@@ -96,7 +98,7 @@ validationSchema = (path) => {
 };
 
 // 4. Behavior schema
-behavior = (path) => {
+const behaviorSchema: BehaviorSchemaFn<RegistrationForm> = (path) => {
   // Clear confirmPassword when password changes (if not empty)
   watchField(path.password, (_, ctx) => {
     const confirmValue = ctx.form.confirmPassword.value.value;

package/dist/behaviors-O9a1Djj9.js

@@ -0,0 +1,147 @@
+import { effect as u } from "@preact/signals-core";
+const o = /* @__PURE__ */ new WeakSet();
+function h(e) {
+  o.add(e);
+}
+function p(e) {
+  return o.has(e);
+}
+const d = /* @__PURE__ */ new WeakMap();
+function y(e, n) {
+  d.set(e, n);
+}
+function v(e) {
+  return d.get(e);
+}
+function b(e) {
+  return (...n) => {
+    queueMicrotask(() => e(...n));
+  };
+}
+function s(e) {
+  queueMicrotask(e);
+}
+function w(e, n) {
+  return () => {
+    n(() => {
+      queueMicrotask(e);
+    });
+  };
+}
+function W(e, n, r, a) {
+  return u(() => {
+    const t = e.map((f) => f.value);
+    if (a?.when && !a.when(...t)) return;
+    const l = r(...t);
+    n.peek() !== l && (n.value = l);
+  });
+}
+function x(e, n, r) {
+  return u(() => {
+    const a = e.value;
+    if (r?.when && !r.when()) return;
+    const t = r?.transform ? r.transform(a) : a;
+    n.peek() !== t && (n.value = t);
+  });
+}
+function F(e, n, r) {
+  let a = !0;
+  return u(() => {
+    const t = e.value;
+    a && (a = !1, !r?.immediate) || n(t);
+  });
+}
+function k(e, n, r) {
+  return u(() => {
+    const a = n(), t = v(e);
+    t && s(() => {
+      a ? t.enable() : (t.disable(), r?.resetOnDisable && t.reset());
+    });
+  });
+}
+function g(e, n, r) {
+  return k(e, () => !n(), r);
+}
+function D(e, n) {
+  let r = !1;
+  return u(() => {
+    const a = e.value;
+    r || s(() => {
+      const t = n(a);
+      if (e.peek() !== t) {
+        r = !0;
+        try {
+          e.value = t;
+        } finally {
+          r = !1;
+        }
+      }
+    });
+  });
+}
+function M(e, n, r) {
+  const a = r?.resetValue ?? null;
+  return u(() => {
+    const t = n();
+    s(() => {
+      t && e.peek() !== a && (e.value = a);
+    });
+  });
+}
+function q(e, n, r) {
+  const a = r?.transform;
+  let t = !1;
+  const l = u(() => {
+    const i = e.value;
+    t || s(() => {
+      t = !0;
+      try {
+        const c = a ? a(i) : i;
+        n.peek() !== c && (n.value = c);
+      } finally {
+        t = !1;
+      }
+    });
+  }), f = u(() => {
+    const i = n.value;
+    t || s(() => {
+      t = !0;
+      try {
+        e.peek() !== i && (e.value = i);
+      } finally {
+        t = !1;
+      }
+    });
+  });
+  return () => {
+    l(), f();
+  };
+}
+function S(e, n) {
+  let r = !0;
+  return u(() => {
+    if (e.forEach((a) => a.value), r) {
+      r = !1;
+      return;
+    }
+    s(() => n());
+  });
+}
+export {
+  M as a,
+  S as b,
+  x as c,
+  y as d,
+  k as e,
+  b as f,
+  v as g,
+  w as h,
+  p as i,
+  W as j,
+  g as k,
+  h as m,
+  s as r,
+  q as s,
+  D as t,
+  F as w
+};

package/dist/behaviors.d.ts

@@ -1,6 +1,133 @@
+import { Signal, ReadonlySignal } from '@preact/signals-core';
+import { BehaviorCleanup, FormModel, FormProxy } from './index';
+/** Контекст схемы поведения: модель (значения/сигналы) + форма (ноды). */
+export type BehaviorScope<T> = {
+    model: FormModel<T>;
+    form: FormProxy<T>;
+};
+/** Результат {@link defineFormBehavior}; передаётся в `createForm({ behavior })`. */
+export interface FormBehavior<T> {
+    /** @internal Запускается `createForm` после построения нод и заполнения реестра сигнал→нода. */
+    __run(model: FormModel<T>, form: FormProxy<T>): BehaviorCleanup;
+}
+export type { Signal, ReadonlySignal, BehaviorCleanup };
+/** Зарегистрировать произвольную отписку в активной схеме. */
+export declare function onDispose(cleanup: BehaviorCleanup): void;
+/** Текущий scope ({ model, form }) активной схемы (escape hatch для кросс-операторов). */
+export declare function getScope<T>(): BehaviorScope<T>;
 /**
- * Re-export behaviors from the main index to ensure single module instance.
- * This prevents static registry isolation issues when consuming the library.
+ * Описать поведение формы декларативно. Возвращает {@link FormBehavior} для `createForm({ behavior })`.
+ *
+ * @example
+ * ```ts
+ * export const myBehavior = defineFormBehavior<MyForm>(({ model, form }) => {
+ *   compute(model.$.total, () => model.price * model.qty);
+ *   enableWhen([model.$.city], () => Boolean(model.country));
+ *   onChange(model.$.country, async (c) => form.city.updateComponentProps({ options: await load(c) }));
+ * });
+ * ```
  */
-export { behaviors as default } from './index';
-export * from './core/behavior';
+export declare function defineFormBehavior<T>(setup: (scope: BehaviorScope<T>) => void): FormBehavior<T>;
+/** Реактивный эффект (авто-dispose). Колбэк может вернуть собственный cleanup. */
+export declare function effect(fn: () => void | (() => void)): void;
+/** Отложенная запись вне effect-контекста (микротаск) — защита от «Cycle detected». */
+export declare function defer(fn: () => void): void;
+/** Вычисляемое поле с auto-tracking: `target = read()` при изменении прочитанных сигналов. */
+export declare function compute<R>(target: Signal<R>, read: () => R, options?: {
+    when?: () => boolean;
+}): void;
+/** Вычисляемое поле с явным списком зависимостей (escape hatch). */
+export declare function computeFrom<R>(sources: ReadonlySignal<unknown>[], target: Signal<R>, fn: (...values: any[]) => R, options?: {
+    when?: (...values: any[]) => boolean;
+}): void;
+/** Копирование `source → target` — скаляр или группа (объект целиком). */
+export declare function copyFrom<T>(source: ReadonlySignal<T> | object, target: Signal<T> | object, options?: {
+    when?: () => boolean;
+    transform?: (value: T) => T;
+}): void;
+/** Контекст async-реакции: `signal` аннулируется, когда поле меняется снова до завершения колбэка. */
+export interface ChangeContext {
+    signal: AbortSignal;
+}
+/**
+ * Реакция на изменение поля; `{ debounce, immediate }`.
+ *
+ * Колбэк выполняется ВНЕ effect-контекста (микротаск/таймер) — можно безопасно писать сигналы и ноды
+ * (`updateComponentProps`/`reset`/`clear`) без ручного `defer` и без «Cycle detected».
+ *
+ * Для async-колбэков 2-м аргументом приходит `{ signal }` (AbortSignal): при следующей смене значения
+ * предыдущий `signal` аннулируется. Передавай его в `fetch` (сетевая отмена) или проверяй
+ * `signal.aborted` перед применением результата — это убирает гонки устаревших ответов (F2).
+ */
+export declare function onChange<T>(source: ReadonlySignal<T>, cb: (value: T, ctx: ChangeContext) => void, options?: {
+    immediate?: boolean;
+    debounce?: number;
+}): void;
+type EnableTarget = ReadonlySignal<unknown> | object;
+/** Условное включение поля(ей) — скаляр, массив целей или группа. `resetOnDisable=false` по умолчанию. */
+export declare function enableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Условное выключение поля(ей) (инверсия {@link enableWhen}). */
+export declare function disableWhen(target: EnableTarget | EnableTarget[], condition: () => boolean, options?: {
+    resetOnDisable?: boolean;
+}): void;
+/** Трансформация значения поля (идемпотентная). */
+export declare function transformValue<T>(target: Signal<T>, transformer: (value: T) => T): void;
+/** Сброс значения по условию. */
+export declare function resetWhen<T>(target: Signal<T>, condition: () => boolean, options?: {
+    resetValue?: T;
+}): void;
+/** Двусторонняя синхронизация двух полей. */
+export declare function syncFields<T>(a: Signal<T>, b: Signal<T>, options?: {
+    transform?: (value: T) => T;
+}): void;
+/** Ревалидация при изменении зависимостей. */
+export declare function revalidateWhen(deps: ReadonlySignal<unknown>[], revalidate: () => void): void;
+/**
+ * Применить под-схему к КАЖДОМУ элементу динамического массива (per-item поведение).
+ * Реагирует на добавление/удаление строк: новым строкам поведение применяется, удалённым — отписывается.
+ *
+ * Под-схема получает scope строки: `model` (под-модель строки — `row.$.field`) и `form` (нода строки).
+ * - Value-операции (`compute`/`copyFrom`/`transformValue` на `row.$.*`) работают всегда.
+ * - Node-операции (`enableWhen`/`updateComponentProps`/`reset` через `form.*`) требуют, чтобы массив был
+ *   МАТЕРИАЛИЗОВАН в форме (узел `{ array, item }` в схеме) — тогда `form` строки = та же нода, что
+ *   рендерится, а её сигналы зарегистрированы (`enableWhen` резолвит ноду). Без материализации доступ
+ *   к `form.*` бросит понятную ошибку (см. {@link unmaterializedRowForm}).
+ *
+ * @example
+ * applyEach(model.$.items, defineFormBehavior<Item>(({ model: row, form }) => {
+ *   compute(row.$.lineTotal, () => row.qty * row.price);    // value-op — всегда
+ *   enableWhen(row.$.discount, () => row.qty > 10);          // node-op — нужна материализация массива
+ * }));
+ */
+export declare function applyEach<TItem>(array: object, itemSchema: FormBehavior<TItem>): void;
+/**
+ * Взаимное исключение булева флага среди строк массива (single-selection — «единственный primary»).
+ * Когда флаг строки становится true, у остальных строк он сбрасывается в false. Не хрупок к push:
+ * новые строки с флагом false исключения не запускают.
+ *
+ * @example
+ * exclusiveFlag(model.$.contacts, (row) => row.$.primary);
+ */
+export declare function exclusiveFlag<TItem>(array: object, getFlag: (row: FormModel<TItem>) => Signal<boolean>): void;
+/**
+ * Агрегатная запись в строки массива. `derive(snapshot)` получает СНИМОК строк и возвращает список
+ * `{ index, patch }`, который применяется к строкам. Записи КОАЛЕСИРУЮТСЯ в один отложенный проход на
+ * финальном состоянии — поэтому массовые синхронные мутации (push в цикле) не вызывают каскад на
+ * промежуточных состояниях. `derive` должна сходиться (на фикспоинте возвращать те же значения).
+ *
+ * @example
+ * // последняя строка = 100 − Σ(остальные)
+ * aggregateInto(model.$.rows, (rows) => {
+ *   const n = rows.length; if (n === 0) return [];
+ *   const others = rows.slice(0, n - 1).reduce((s, r) => s + r.percent, 0);
+ *   return [{ index: n - 1, patch: { percent: 100 - others } }];
+ * });
+ */
+export declare function aggregateInto<TItem>(array: object, derive: (rows: TItem[]) => Array<{
+    index: number;
+    patch: Partial<TItem>;
+}>): void;
+/** Применить под-схему к одному или нескольким полям-группам (переиспользование). */
+export declare function apply<TField>(targets: object | object[], subSchema: FormBehavior<TField>): void;

package/dist/behaviors.js

@@ -1,29 +1,300 @@
-import { a as o, b as a, i as t, t as m } from "./index-D25LsbRm.js";
-import { a as s, B as f } from "./registry-helpers-Bv_BJ1s-.js";
-import { copyFrom as n } from "./behaviors/copy-from.js";
-import { disableWhen as h, enableWhen as i } from "./behaviors/enable-when.js";
-import { computeFrom as c } from "./behaviors/compute-from.js";
-import { watchField as F } from "./behaviors/watch-field.js";
-import { revalidateWhen as v } from "./behaviors/revalidate-when.js";
-import { syncFields as b } from "./behaviors/sync-fields.js";
-import { resetWhen as g } from "./behaviors/reset-when.js";
-import { createTransformer as C, transformValue as I, transformers as P } from "./behaviors/transform-value.js";
+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";
+let p = null;
+function k(e) {
+  if (!p)
+    throw new Error(
+      `[@reformer/core/behaviors] "${e}" вызван вне defineFormBehavior(...) — операторы поведения можно вызывать только внутри схемы.`
+    );
+  return p;
+}
+function a(e) {
+  k("onDispose").cleanups.push(e);
+}
+function y() {
+  const e = k("getScope");
+  return { model: e.model, form: e.form };
+}
+function G(e) {
+  return {
+    __run(n, t) {
+      const o = { cleanups: [], model: n, form: t }, r = p;
+      p = o;
+      try {
+        e({ model: n, form: t });
+      } finally {
+        p = r;
+      }
+      return () => {
+        for (const c of o.cleanups) c();
+      };
+    }
+  };
+}
+function m(e) {
+  a(j(e));
+}
+function g(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);
+  }
+  return n;
+}
+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 T(e) {
+  if (!e) return;
+  const { form: n } = y();
+  return n.getFieldByPath(e);
+}
+function W(e) {
+  return new Proxy(
+    {},
+    {
+      get: (n, t) => {
+        if (t === "$") return e;
+        if (typeof t != "string") return;
+        const o = e[t];
+        if (o != null)
+          return h(o) ? o.value : W(o);
+      }
+    }
+  );
+}
+function V(e) {
+  return (n) => {
+    try {
+      n();
+    } catch (t) {
+      if (t instanceof Error && /cycle detected/i.test(t.message)) {
+        const o = e.__path ?? "?";
+        throw new Error(
+          `[@reformer/core/behaviors] compute("${o}"): расходящийся цикл пересчёта — взаимные compute/computeFrom без стабилизации. Проверьте зависимости или добавьте стабилизирующее условие (when) / разорвите цикл через peek.`
+        );
+      }
+      throw t;
+    }
+  };
+}
+function K(e, n, t) {
+  x(e);
+  const o = V(e);
+  m(() => {
+    if (t?.when && !t.when()) return;
+    const r = n();
+    e.peek() !== r && o(() => {
+      e.value = r;
+    });
+  });
+}
+function L(e, n, t, o) {
+  x(n);
+  const r = V(n);
+  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;
+    });
+  });
+}
+function Q(e, n, t) {
+  if (h(e) && h(n)) {
+    a(O(e, n, t));
+    return;
+  }
+  const o = e, r = n;
+  m(() => {
+    const c = B(o);
+    t?.when && !t.when() || g(() => E(r, c));
+  });
+}
+function I(e, n, t) {
+  let o;
+  const r = (c) => {
+    o?.abort(), o = new AbortController();
+    const { signal: i } = o;
+    $(() => n(c, { signal: i }));
+  };
+  if (!t?.debounce)
+    a(F(e, r, { immediate: t?.immediate }));
+  else {
+    let c;
+    const i = F(
+      e,
+      (f) => {
+        c && clearTimeout(c), c = setTimeout(() => r(f), t.debounce);
+      },
+      { immediate: t?.immediate }
+    );
+    a(() => {
+      c && clearTimeout(c), i();
+    });
+  }
+  a(() => 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 U(e, n, t) {
+  R(e, () => !n(), t);
+}
+function q(e, n, t) {
+  const o = T(e.__path);
+  o && m(() => {
+    const r = n();
+    g(() => {
+      r ? o.enable() : (o.disable(), t?.resetOnDisable && o.reset());
+    });
+  });
+}
+function X(e, n) {
+  a(A(e, n));
+}
+function Y(e, n, t) {
+  a(C(e, n, t));
+}
+function Z(e, n, t) {
+  a(M(e, n, t));
+}
+function ee(e, n) {
+  a(D(e, n));
+}
+function _(e, n) {
+  return n.split(".").reduce((t, o) => t?.[o], e);
+}
+function z(e) {
+  return new Proxy(
+    {},
+    {
+      get(n, t) {
+        if (!(typeof t == "symbol" || t === "then"))
+          throw new Error(
+            `[@reformer/core/behaviors] applyEach: форма строки массива "${e}" недоступна (form.${String(
+              t
+            )}) — массив не материализован в схеме формы. 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;
+  if (!r) return;
+  const c = _(t, r);
+  if (!c) return;
+  const i = o.getFieldByPath(
+    r
+  ), f = i?.length, s = /* @__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 (const [u, l] of s)
+      w.has(u) || (l(), s.delete(u));
+  }), a(() => {
+    for (const d of s.values()) d();
+    s.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));
+    return;
+  }
+  for (const t of Object.keys(e)) v(e[t]);
+}
+function te(e, n) {
+  const { model: t } = y(), o = e.__path;
+  if (!o) return;
+  const r = _(t, o);
+  r && N(
+    e,
+    G(({ model: c }) => {
+      I(n(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);
+              d.peek() && (d.value = !1);
+            }
+          }
+      });
+    })
+  );
+}
+function ne(e, n) {
+  const { model: t } = y(), o = e.__path;
+  if (!o) return;
+  const r = _(t, o);
+  if (!r) return;
+  let c = !1, i = 0;
+  m(() => {
+    v(r), !c && (c = !0, g(() => {
+      c = !1;
+      const f = n(r.toArray());
+      let s = !1;
+      for (const { index: d, patch: w } of f) {
+        const u = r.at(d);
+        if (u)
+          for (const [l, b] of Object.entries(w))
+            u[l] !== b && (u[l] = b, s = !0);
+      }
+      if (i = s ? 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)) {
+    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));
+  }
+}
 export {
-  s as BehaviorContextImpl,
-  f as BehaviorRegistry,
-  o as apply,
-  a as applyWhen,
-  c as computeFrom,
-  n as copyFrom,
-  C as createTransformer,
-  t as default,
-  h as disableWhen,
-  i as enableWhen,
-  g as resetWhen,
-  v as revalidateWhen,
-  b as syncFields,
-  m as toBehaviorFieldPath,
-  I as transformValue,
-  P as transformers,
-  F as watchField
+  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,
+  m as effect,
+  R 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
 };