@reformer/core 10.2.0 → 11.0.0-beta.10

package/dist/schema-controller-CpiO2JoK.js

@@ -0,0 +1,143 @@
+import { signal as v } from "@preact/signals-core";
+const h = /* @__PURE__ */ new WeakMap();
+function y(t) {
+  let s = h.get(t);
+  return s || (s = { hide: /* @__PURE__ */ new Map(), events: /* @__PURE__ */ new Map(), hooks: /* @__PURE__ */ new Map() }, h.set(t, s)), s;
+}
+function a(t, s) {
+  const e = t.lastIndexOf(s);
+  return e !== -1 && t.splice(e, 1), t.length === 0;
+}
+function R() {
+  const t = /* @__PURE__ */ new Map();
+  return {
+    hiddenOverrides: /* @__PURE__ */ new Map(),
+    propsOverrides: /* @__PURE__ */ new Map(),
+    refRegistry: /* @__PURE__ */ new Map(),
+    conditionRegistry: /* @__PURE__ */ new Map(),
+    effectRegistry: [],
+    callbackRegistry: /* @__PURE__ */ new Map(),
+    lifecycleRegistry: /* @__PURE__ */ new Map(),
+    version: v(0),
+    versionFor(s) {
+      let e = t.get(s);
+      return e || (e = v(0), t.set(s, e)), e;
+    }
+  };
+}
+function w(t = R()) {
+  const s = (e) => {
+    t.version.value++, t.versionFor(e).value++;
+  };
+  return {
+    __overrideMaps: t,
+    addRenderEffect(e) {
+      return t.effectRegistry.push(e), () => {
+        const n = t.effectRegistry.indexOf(e);
+        n !== -1 && t.effectRegistry.splice(n, 1);
+      };
+    },
+    node: (e) => ({
+      setHidden(n) {
+        return t.hiddenOverrides.get(e) === n ? this : (t.hiddenOverrides.set(e, n), s(e), this);
+      },
+      resetHidden() {
+        return t.hiddenOverrides.delete(e) && s(e), this;
+      },
+      patchProps(n) {
+        const d = t.propsOverrides.get(e);
+        return d != null && Object.keys(n).every(
+          (i) => i in d && Object.is(d[i], n[i])
+        ) ? this : (t.propsOverrides.set(e, { ...d ?? {}, ...n }), s(e), this);
+      },
+      resetProps() {
+        return t.propsOverrides.delete(e) && s(e), this;
+      },
+      getRef() {
+        let n = t.refRegistry.get(e);
+        return n || (n = { current: null }, t.refRegistry.set(e, n)), n;
+      },
+      addHideCondition(n) {
+        const { hide: d } = y(t);
+        let r = d.get(e);
+        if (!r) {
+          const c = v([]);
+          r = c, d.set(e, c), t.conditionRegistry.set(e, () => c.value.some((f) => f()));
+        }
+        r.value = [...r.value, n];
+        const i = r;
+        return () => {
+          const c = [...i.value];
+          if (!a(c, n)) {
+            i.value = c;
+            return;
+          }
+          i.value = c, d.get(e) === i && (d.delete(e), t.conditionRegistry.delete(e));
+        };
+      },
+      addEventHandler(n, d) {
+        const { events: r } = y(t);
+        let i = r.get(e);
+        i || r.set(e, i = /* @__PURE__ */ new Map());
+        let c = i.get(n);
+        c || i.set(n, c = []), c.push(d);
+        let f = t.callbackRegistry.get(e);
+        f || t.callbackRegistry.set(e, f = /* @__PURE__ */ new Map()), f.set(n, d);
+        const o = c, u = i;
+        return () => {
+          const g = a(o, d), l = t.callbackRegistry.get(e);
+          if (!g) {
+            l?.set(n, o[o.length - 1]);
+            return;
+          }
+          u.delete(n), l?.delete(n), l?.size === 0 && t.callbackRegistry.delete(e), u.size === 0 && r.delete(e);
+        };
+      },
+      addLifecycleHook(n, d) {
+        const { hooks: r } = y(t);
+        let i = r.get(e);
+        i || r.set(e, i = /* @__PURE__ */ new Map());
+        let c = i.get(n);
+        c || i.set(n, c = []), c.push(d), t.lifecycleRegistry.set(e, {
+          ...t.lifecycleRegistry.get(e) ?? {},
+          [n]: d
+        });
+        const f = c, o = i;
+        return () => {
+          const u = a(f, d), g = { ...t.lifecycleRegistry.get(e) ?? {} };
+          u ? (o.delete(n), delete g[n]) : g[n] = f[f.length - 1], Object.keys(g).length === 0 ? t.lifecycleRegistry.delete(e) : t.lifecycleRegistry.set(e, g), o.size === 0 && r.delete(e);
+        };
+      },
+      __selector: e,
+      __overrideMaps: t
+    })
+  };
+}
+function O() {
+  const t = /* @__PURE__ */ new WeakMap();
+  return {
+    scopeOf(s) {
+      let e = t.get(s);
+      return e || (e = w(), t.set(s, e)), e;
+    }
+  };
+}
+function M(t, s) {
+  const e = [s];
+  for (let r = 0; r < e.length; r++)
+    for (const i of e[r].nodes.values())
+      s.model !== void 0 && i.kind === "part" && i.content.model === s.model && e.push(i.content);
+  const n = (r) => e.some((i) => i.nodes.get(r)?.selector === r);
+  return [.../* @__PURE__ */ new Set([
+    ...t.hiddenOverrides.keys(),
+    ...t.propsOverrides.keys(),
+    ...t.conditionRegistry.keys(),
+    ...t.callbackRegistry.keys(),
+    ...t.lifecycleRegistry.keys()
+  ])].filter((r) => !n(r));
+}
+export {
+  w as a,
+  O as c,
+  M as u
+};

package/dist/signals.d.ts

@@ -1,13 +1,19 @@
+import { ReadonlySignal } from '@preact/signals-core';
+export { signal, computed, effect, batch, untracked, Signal } from '@preact/signals-core';
+export type { ReadonlySignal } from '@preact/signals-core';
 /**
- * Единая точка владения реактивным рантаймом @preact/signals-core.
+ * Значение — сигнал: результат `signal()` или `computed()`, в том числе созданный другой копией
+ * рантайма.
  *
- * Другие @reformer/* пакеты (например renderer-react) импортируют Signal и примитивы
- * ОТСЮДА (`@reformer/core/signals`), а НЕ напрямую из `@preact/signals-core`. Так
- * гарантируется одна копия рантайма и единая идентичность класса `Signal` через границы
- * пакетов — это критично для проверок вида `value instanceof Signal` над сигналами,
- * созданными внутри @reformer/core.
+ * Контейнерные узлы дерева `model.$` (группа, массив) тоже проходят проверку: это сигналы
+ * агрегированного значения. Лист от контейнера отличает `isModelContainerSignal`, а ручку, к
+ * которой можно привязать поле, — `isValueSignal` (оба — из `@reformer/core`).
  *
- * @module reformer/signals
+ * @example
+ * ```typescript
+ * isSignal(signal(1)); // true
+ * isSignal(computed(() => 1)); // true
+ * isSignal({ value: 1 }); // false
+ * ```
  */
-export { signal, computed, effect, batch, untracked, Signal } from '@preact/signals-core';
-export type { ReadonlySignal } from '@preact/signals-core';
+export declare function isSignal(value: unknown): value is ReadonlySignal<unknown>;

package/dist/signals.js

@@ -1,9 +1,14 @@
-import { Signal as a, batch as c, computed as f, effect as n, signal as o, untracked as r } from "@preact/signals-core";
+import { Signal as e, batch as a, computed as f, effect as i, signal as l, untracked as p } from "@preact/signals-core";
+const n = Symbol.for("preact-signals");
+function o(t) {
+  return typeof t == "object" && t !== null && t.brand === n;
+}
 export {
-  a as Signal,
-  c as batch,
+  e as Signal,
+  a as batch,
   f as computed,
-  n as effect,
-  o as signal,
-  r as untracked
+  i as effect,
+  o as isSignal,
+  l as signal,
+  p as untracked
 };

package/dist/strategy-DzvnsWLh.js

@@ -0,0 +1,375 @@
+import { batch as F, signal as X, effect as Y, untracked as Z } from "@preact/signals-core";
+import { a as ee } from "./create-model-DPSG3I0O.js";
+import { g as p } from "./signal-node-registry-tiwel-TV.js";
+import { n as te, m as L, o as ne, f as oe } from "./safe-effect-BazLOv1g.js";
+let k = null;
+function B(e, n) {
+  const t = k;
+  k = e;
+  try {
+    return n();
+  } finally {
+    k = t;
+  }
+}
+function h(e) {
+  if (!k)
+    throw new Error(
+      `[@reformer/core/validation] "${e}" вызван вне схемы валидации — операторы валидации можно вызывать только внутри прогона validateModel(...) (напрямую или через apply/each).`
+    );
+  return k;
+}
+function W(e, n) {
+  let t = e.origins.get(n);
+  t || e.origins.set(n, t = /* @__PURE__ */ new Map());
+  let o = t.get(e.origin);
+  return o || t.set(e.origin, o = []), o;
+}
+function j(e, n, t) {
+  const o = e.origin;
+  e.origin = n, e.executed.add(n);
+  try {
+    t();
+  } finally {
+    e.origin = o;
+  }
+}
+const se = (e) => e.whenStack.every((n) => n());
+function I(e, n) {
+  return se(e) ? (e.checked.add(n), !0) : !1;
+}
+function be(e, n) {
+  const t = h("validate"), o = W(t, e);
+  if (!I(t, e)) return;
+  const i = e.peek();
+  for (const s of n) {
+    const r = s(i);
+    r && o.push(r);
+  }
+}
+const _ = "ruleFailed";
+function me(e, n) {
+  const t = h("validateAsync"), o = e, i = W(t, o);
+  if (!I(t, o)) return;
+  const s = e.peek(), r = t.signal;
+  t.asyncFields.add(o);
+  for (const a of n)
+    t.pending.push(
+      // Вызов внутри исполнителя промиса: синхронное исключение правила — такой же сбой.
+      new Promise((c) => c(a(s, { signal: r }))).then(
+        (c) => {
+          c && !r.aborted && i.push(c);
+        },
+        (c) => {
+          r.aborted || (t.failures.push({ handle: o, error: c }), i.some((u) => u.code === _) || i.push({ code: _ }));
+        }
+      )
+    );
+}
+function Oe(e, n) {
+  const t = h("validateWhen");
+  t.whenStack.push(e);
+  try {
+    n();
+  } finally {
+    t.whenStack.pop();
+  }
+}
+function ie(e, n, t) {
+  const o = h("cross"), i = W(o, n);
+  if (!I(o, n)) return;
+  const s = t(e.get());
+  s && i.push(s);
+}
+function V(e) {
+  return {
+    model: e,
+    cross: (n, t) => ie(e, n, t)
+  };
+}
+function C(e, n, t) {
+  const o = n, i = { ...e, model: o };
+  B(
+    i,
+    () => j(i, t, () => t(V(o)))
+  );
+}
+function re(e, n) {
+  const t = ne(n);
+  if (!t)
+    throw new TypeError(
+      `[@reformer/core/validation] ${e}: ожидался массив под-форм модели — \`model.$.<массив>\`. Массив примитивов — одно значение поля, его проверяют целиком: \`validate(model.$.<массив>, [...])\`.`
+    );
+  return L(t);
+}
+function Se(e, n) {
+  const t = h("applyEach"), o = re("applyEach", e), i = o.length;
+  for (let s = 0; s < i; s++) C(t, o.at(s), n);
+}
+function Ee(...e) {
+  const n = h("apply");
+  if (typeof e[0] == "function") {
+    for (const i of e)
+      j(n, i, () => i(V(n.model)));
+    return;
+  }
+  const [t, o] = e;
+  for (const i of Array.isArray(t) ? t : [t]) {
+    const s = te(i);
+    if (!s)
+      throw new TypeError(
+        "[@reformer/core/validation] apply: ожидалась группа модели — `model.$.<группа>`. Массив под-форм подключают через `applyEach`."
+      );
+    C(n, L(s), o);
+  }
+}
+function Me(e) {
+  return e;
+}
+const S = /* @__PURE__ */ new WeakMap(), G = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ new WeakMap(), H = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap(), b = {}, $ = {}, U = /* @__PURE__ */ new WeakMap();
+function ae(e) {
+  const n = /* @__PURE__ */ new Set(), t = [];
+  for (const o of e)
+    for (const i of o) {
+      const s = JSON.stringify([i.code, i.severity ?? null, i.params ?? null]);
+      n.has(s) || (n.add(s), t.push(i));
+    }
+  return t;
+}
+function M(e, n, t, o, i, s = !1) {
+  const r = E.get(e), a = n.ownIssues?.peek() ?? [], c = r !== void 0 && a === r.written, u = c ? r.byOrigin : /* @__PURE__ */ new Map();
+  if (!c && s && a.length > 0 && u.set($, a), u.delete(b), t === void 0) {
+    for (const l of [...u.keys()]) l !== $ && u.delete(l);
+    i !== void 0 && i.length > 0 && u.set(b, i);
+  } else {
+    for (const l of t.executed) u.delete(l);
+    o?.forEach((l, v) => {
+      l.length > 0 && u.set(v, l);
+    });
+  }
+  const f = u.size === 0 ? [] : ae(u.values());
+  n.setIssues(f), E.set(e, { byOrigin: u, written: n.ownIssues?.peek() ?? f });
+}
+function N(e, n, t, o) {
+  const i = p(e), s = t === void 0 ? void 0 : n?.origins.get(e);
+  if (i === void 0) {
+    if (s?.forEach((r, a) => {
+      const c = o.get(a) ?? [];
+      c.push(...r), o.set(a, c);
+    }), n === void 0 && t !== void 0) {
+      const r = o.get(b) ?? [];
+      r.push(...t), o.set(b, r);
+    }
+    return;
+  }
+  M(e, i, n, s, t);
+}
+function ce(e, n, t) {
+  if (e === void 0) return;
+  const o = p(e.$);
+  if (o !== void 0 && !(t.size === 0 && !E.has(o))) {
+    if (n === void 0) {
+      M(o, o, void 0, void 0, t.get(b) ?? [], !0);
+      return;
+    }
+    M(o, o, n, t, void 0, !0);
+  }
+}
+function ue(e, n) {
+  let t = S.get(e);
+  t || S.set(e, t = /* @__PURE__ */ new WeakMap());
+  let o = t.get(n);
+  return o || t.set(n, o = { fields: /* @__PURE__ */ new Set(), ac: null }), o;
+}
+const fe = (e) => {
+  for (const n of e.values()) for (const t of n) if (t.severity !== "warning") return !0;
+  return !1;
+};
+function le(e) {
+  return e.aborted ? Promise.resolve() : new Promise((n) => {
+    e.addEventListener("abort", () => n(), { once: !0 });
+  });
+}
+const P = (e) => e !== null && typeof e == "object" && p(e)?.disabled?.peek() === !0;
+function D(e, n) {
+  if (n.__path === "") return P(n);
+  let t = e.$;
+  for (const o of n.__path.split("."))
+    if (t === null || typeof t != "object" || (t = t[o], P(t))) return !0;
+  return t !== n;
+}
+function de(e, n, t, o, i) {
+  for (const s of n.keys())
+    D(e, s) && (n.set(s, []), i.get(s)?.forEach((r, a, c) => c.set(a, [])), o.delete(s));
+  for (let s = t.length - 1; s >= 0; s--)
+    D(e, t[s].handle) && t.splice(s, 1);
+}
+function pe(e, n) {
+  S.get(e)?.get(n)?.ac?.abort();
+}
+let A = 0;
+function q(e) {
+  A++;
+  try {
+    F(e);
+  } finally {
+    A--;
+  }
+}
+const ge = () => A > 0;
+async function J(e, n, t, o = !1) {
+  const i = ue(e, n);
+  i.ac?.abort();
+  const s = new AbortController();
+  i.ac = s;
+  const r = [], a = {
+    model: e,
+    issues: /* @__PURE__ */ new Map(),
+    checked: /* @__PURE__ */ new Set(),
+    pending: [],
+    asyncFields: /* @__PURE__ */ new Set(),
+    failures: r,
+    whenStack: [],
+    signal: s.signal,
+    origin: n,
+    origins: /* @__PURE__ */ new Map(),
+    executed: /* @__PURE__ */ new Set([n])
+  };
+  B(a, () => n(V(e)));
+  const c = [];
+  if (t) {
+    for (const f of a.asyncFields) {
+      const l = p(f);
+      l && c.push(l);
+    }
+    for (const f of c) f.setPending(!0);
+  }
+  a.pending.length ? await Promise.race([Promise.all(a.pending), le(s.signal)]) : o && await oe();
+  for (const [f, l] of a.origins) a.issues.set(f, [...l.values()].flat());
+  o && de(e, a.issues, r, a.checked, a.origins);
+  const u = {
+    status: s.signal.aborted ? "cancelled" : r.length > 0 ? "error" : fe(a.issues) ? "invalid" : "valid",
+    issues: a.issues,
+    failures: r
+  };
+  return G.set(u, i), z.set(u, a.checked), H.set(u, { origins: a.origins, executed: a.executed }), U.set(u, e), {
+    result: u,
+    release: () => {
+      for (const f of c) f.setPending(!1);
+    }
+  };
+}
+async function Ae(e, n) {
+  return (await J(e, n, !1)).result;
+}
+function he(e, n) {
+  if (e.status === "cancelled") return;
+  const t = G.get(e), o = new Set(e.issues.keys()), i = z.get(e) ?? o, s = H.get(e), r = () => {
+    const a = /* @__PURE__ */ new Map();
+    if (t)
+      for (const c of t.fields)
+        o.has(c) || N(c, s, void 0, a);
+    for (const [c, u] of e.issues) N(c, s, u, a);
+    if (ce(U.get(e), s, a), n?.touch) for (const c of i) p(c)?.markAsTouched();
+  };
+  n?.touch ? q(r) : F(r), t && (t.fields = o);
+}
+async function K(e, n, t) {
+  const { result: o, release: i } = await J(e, n, !0, t?.skipDisabled), s = t?.touch ?? !1, r = () => {
+    he(o, { touch: s !== !1 }), s === "all" && (o.status === "invalid" || o.status === "error") && p(e.$)?.markAsTouched(), i();
+  };
+  return s !== !1 ? q(r) : F(r), o;
+}
+async function Fe(e, n, t) {
+  return (await K(e, n, t)).status === "valid";
+}
+function We(e, n, t = {}) {
+  const { strategy: o = "submit", debounce: i = 0, liveAfterSubmit: s = "change" } = t, r = X(!1);
+  let a = 0, c = !1, u, f;
+  const l = async (d) => {
+    a++, r.value = !0;
+    try {
+      return await K(e, n, { touch: d, skipDisabled: !0 });
+    } finally {
+      --a === 0 && (r.value = !1);
+    }
+  }, v = () => {
+    l(!1).catch((d) => {
+      process.env.NODE_ENV !== "production" && console.error(
+        "[@reformer/core/validation] живой прогон схемы завершился исключением",
+        d
+      );
+    });
+  }, Q = () => {
+    if (!i) {
+      v();
+      return;
+    }
+    f && clearTimeout(f), f = setTimeout(v, i);
+  }, x = (d, g, y) => {
+    let O = !0;
+    return Y(() => {
+      if (y?.(), ee(e, d), O) {
+        O = !1;
+        return;
+      }
+      o === "afterFirstSubmit" && !c || Z(g);
+    });
+  }, m = {
+    async validate() {
+      return (await m.run()).status === "valid";
+    },
+    run(d) {
+      return d?.submit && (c = !0), l(d?.touch ?? !0);
+    },
+    start() {
+      if (u) return () => m.dispose();
+      const d = o === "afterFirstSubmit" ? s : o;
+      if (d === "change")
+        u = x((g) => void g.value, Q);
+      else if (d === "blur") {
+        const g = /* @__PURE__ */ new WeakMap();
+        let y = !1;
+        u = x(
+          (O) => {
+            const w = p(O);
+            if (w === void 0) return;
+            const R = w.touches?.value ?? (w.touched.value ? 1 : 0), T = g.get(w);
+            T !== void 0 && R > T && (y = !0), g.set(w, R);
+          },
+          () => {
+            y && !ge() && v();
+          },
+          () => {
+            y = !1;
+          }
+        );
+      }
+      return () => m.dispose();
+    },
+    dispose() {
+      f && (clearTimeout(f), f = void 0), u?.(), u = void 0, pe(e, n);
+    },
+    get isValidating() {
+      return r.value;
+    },
+    get validating() {
+      return r;
+    }
+  };
+  return m;
+}
+export {
+  me as a,
+  Oe as b,
+  Ee as c,
+  Se as d,
+  Me as e,
+  he as f,
+  Fe as g,
+  We as h,
+  pe as i,
+  K as j,
+  Ae as r,
+  be as v
+};

package/dist/type-guards-D-N_5Ddh.js

@@ -0,0 +1,19 @@
+import { k as o } from "./node-kind-C-r6ZMdo.js";
+function i(r) {
+  return o(r) !== void 0;
+}
+function t(r) {
+  return o(r) === "control";
+}
+function u(r) {
+  return o(r) === "group";
+}
+function a(r) {
+  return o(r) === "array";
+}
+export {
+  t as a,
+  u as b,
+  a as c,
+  i
+};

package/dist/validation-issue-B9mjI8jz.js

@@ -0,0 +1,7 @@
+function c(a, e, d) {
+  const r = d === void 0 ? e?.params : { ...d, ...e?.params };
+  return r === void 0 ? { code: e?.code ?? a } : { code: e?.code ?? a, params: r };
+}
+export {
+  c as v
+};