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

package/dist/model/model-signals-proxy.d.ts

@@ -0,0 +1,32 @@
+import { PathAwareSignal } from './types';
+import { ModelNode, GroupNode } from './model-nodes';
+/**
+ * Узел дерева `$`: лист → сам {@link PathAwareSignal}, группа/массив → контейнерный узел —
+ * {@link ReadonlySignal} агрегированного значения ПЛЮС доступ к детям по имени/индексу.
+ *
+ * Порядок разрешения ключа: служебные `__path`/`__kind` → ребёнок → свойство сигнала. Дети идут
+ * раньше свойств сигнала — тот же приоритет, что у {@link makeFormModel} (поле формы затеняет метод
+ * API). Поэтому имена `value`/`peek`/`subscribe`/`valueOf`/`toString`/`toJSON`/`brand` де-факто
+ * зарезервированы: одноимённое поле формы затенит свойство сигнала (`subscribe` при этом продолжает
+ * работать — он замкнут на агрегат, а не читает `.value` через прокси).
+ *
+ * `has`/`ownKeys` намеренно НЕ показывают свойства сигнала — ровно как `__path`, доступный через
+ * `get`, но невидимый для `in`/`Object.keys`. Так `Object.keys(model.$.<group>)` остаётся списком
+ * полей, а потребители, перечисляющие модель, не видят служебных ключей.
+ */
+export declare function signalsProxy(node: ModelNode): any;
+/**
+ * Узел дерева `model.$` — контейнер (группа/массив), а не лист?
+ *
+ * Контейнерный узел структурно совместим с `ReadonlySignal` (`peek`/`value`/`subscribe`), поэтому
+ * duck-typing «есть `peek` ⇒ это лист» на нём даёт ложное срабатывание. Этот guard — надёжный
+ * способ различить: обходчикам дерева нужно спускаться в контейнер, а не читать его целиком.
+ *
+ * @group Model
+ * @example
+ * ```typescript
+ * const isLeaf = (v: unknown) => isSignalLike(v) && !isModelContainerSignal(v);
+ * ```
+ */
+export declare function isModelContainerSignal(value: unknown): boolean;
+export declare function resolveSignalAt(root: GroupNode, path: string): PathAwareSignal<unknown> | undefined;

package/dist/model/model-value-proxy.d.ts

@@ -0,0 +1,3 @@
+import { GroupNode } from './model-nodes';
+export declare const rootByFacade: WeakMap<object, GroupNode>;
+export declare function makeFormModel(group: GroupNode): any;

package/dist/{state → model}/safe-effect.d.ts

@@ -19,7 +19,7 @@
  * не здесь. См. также `aggregateInto`, где коалесинг реализован на уровне самого оператора.
  *
  * @group Utils
- * @module utils/safe-effect
+ * @module model/safe-effect
  */
 /**
  * Создает callback, который выполняется вне контекста effect

package/dist/model-signals-proxy-mV3WGdlO.js

@@ -0,0 +1,233 @@
+import { batch as m, signal as y, computed as b } from "@preact/signals-core";
+const c = /* @__PURE__ */ new WeakMap();
+function R(t) {
+  c.set(t, (c.get(t) ?? 0) + 1);
+}
+function S(t) {
+  const e = c.get(t);
+  e !== void 0 && (e <= 1 ? c.delete(t) : c.set(t, e - 1));
+}
+function A(t) {
+  return c.has(t);
+}
+const f = (t) => !(t === null || typeof t != "object" || Array.isArray(t) || t instanceof Date || typeof Blob < "u" && t instanceof Blob || typeof File < "u" && t instanceof File), o = (t, e) => t === "" ? String(e) : `${t}.${e}`, w = (t) => /^\d+$/.test(t), l = (t) => {
+  if (Array.isArray(t)) return t.map(l);
+  if (f(t)) {
+    const e = {};
+    for (const i of Object.keys(t)) e[i] = l(t[i]);
+    return e;
+  }
+  return t;
+}, h = (t, e) => {
+  if (t === e) return !0;
+  if (Array.isArray(t) && Array.isArray(e))
+    return t.length !== e.length ? !1 : t.every((i, r) => h(i, e[r]));
+  if (f(t) && f(e)) {
+    const i = Object.keys(t), r = Object.keys(e);
+    return i.length !== r.length ? !1 : i.every((s) => h(t[s], e[s]));
+  }
+  return !1;
+};
+class _ {
+  constructor(e, i) {
+    this.path = i;
+    const r = y(e);
+    r.__path = i, this.signal = r, this.initial = l(e);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(e) {
+    this.path = e, this.signal.__path = e;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(e) {
+    this.signal.value = e;
+  }
+  resetToInitial() {
+    this.signal.value = l(this.initial);
+  }
+  captureInitial() {
+    this.initial = l(this.signal.peek());
+  }
+  dirty() {
+    return !h(this.signal.peek(), this.initial);
+  }
+}
+class j {
+  constructor(e, i) {
+    this.path = i;
+    for (const r of Object.keys(e))
+      this.children.set(r, u(e[r], o(i, r)));
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(e) {
+    this.path = e;
+    for (const [i, r] of this.children) r.rebase(o(e, i));
+  }
+  /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+  read() {
+    const e = {};
+    for (const [i, r] of this.children) e[i] = r.read();
+    return e;
+  }
+  peek() {
+    const e = {};
+    for (const [i, r] of this.children) e[i] = r.peek();
+    return e;
+  }
+  set(e) {
+    if (e == null || typeof e != "object") return;
+    const i = e;
+    m(() => {
+      for (const [r, s] of this.children)
+        r in i && (s.kind === "leaf" && A(s.signal) || s.set(i[r]));
+    });
+  }
+  resetToInitial() {
+    m(() => {
+      for (const e of this.children.values()) e.resetToInitial();
+    });
+  }
+  captureInitial() {
+    for (const e of this.children.values()) e.captureInitial();
+  }
+  dirty() {
+    for (const e of this.children.values()) if (e.dirty()) return !0;
+    return !1;
+  }
+}
+class x {
+  constructor(e, i) {
+    this.path = i, this.items = y(e.map((r, s) => u(r, o(i, s)))), this.initial = l(e);
+  }
+  kind = "array";
+  items;
+  initial;
+  rebase(e) {
+    this.path = e, this.items.peek().forEach((i, r) => i.rebase(o(e, r)));
+  }
+  reindex() {
+    this.items.peek().forEach((e, i) => e.rebase(o(this.path, i)));
+  }
+  push(e) {
+    const i = this.items.peek();
+    this.items.value = [...i, u(e, o(this.path, i.length))];
+  }
+  insertAt(e, i) {
+    const r = [...this.items.peek()];
+    r.splice(e, 0, u(i, o(this.path, e))), this.items.value = r, this.reindex();
+  }
+  removeAt(e) {
+    const i = [...this.items.peek()];
+    i.splice(e, 1), this.items.value = i, this.reindex();
+  }
+  move(e, i) {
+    const r = [...this.items.peek()], [s] = r.splice(e, 1);
+    s && r.splice(i, 0, s), this.items.value = r, this.reindex();
+  }
+  swap(e, i) {
+    const r = [...this.items.peek()];
+    e < 0 || i < 0 || e >= r.length || i >= r.length || e === i || ([r[e], r[i]] = [r[i], r[e]], this.items.value = r, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  /**
+   * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+   * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+   */
+  read() {
+    return this.items.value.map((e) => e.read());
+  }
+  peek() {
+    return this.items.peek().map((e) => e.peek());
+  }
+  set(e) {
+    const i = Array.isArray(e) ? e : [];
+    this.items.value = i.map((r, s) => u(r, o(this.path, s)));
+  }
+  resetToInitial() {
+    this.set(l(this.initial));
+  }
+  captureInitial() {
+    this.initial = l(this.peek());
+  }
+  dirty() {
+    return !h(this.peek(), this.initial);
+  }
+}
+function u(t, e) {
+  return Array.isArray(t) ? new x(t, e) : f(t) ? new j(t, e) : new _(t, e);
+}
+const k = /* @__PURE__ */ new WeakMap();
+function I(t) {
+  const e = b(() => t.read());
+  return {
+    get value() {
+      return e.value;
+    },
+    peek: () => e.peek(),
+    subscribe: (i) => e.subscribe(i),
+    valueOf: () => e.value,
+    toString: () => String(e.value),
+    toJSON: () => e.value,
+    brand: e.brand
+  };
+}
+function O(t) {
+  if (t.kind === "leaf") return t.signal;
+  const e = k.get(t);
+  if (e) return e;
+  const i = I(t), r = t.kind === "group", s = (a) => r ? t.children.get(a) : w(a) ? t.items.value[Number(a)] : void 0, d = r ? {} : {
+    get length() {
+      return t.items.value.length;
+    }
+  }, p = new Proxy(d, {
+    get: (a, n, v) => {
+      if (n === "__path") return t.path;
+      if (n === "__kind") return t.kind;
+      if (typeof n != "string") return Reflect.get(i, n, i);
+      const g = s(n);
+      return g ? O(g) : !r && Reflect.has(a, n) ? Reflect.get(a, n, v) : Reflect.get(i, n, i);
+    },
+    has: (a, n) => typeof n == "string" && (s(n) !== void 0 || !r && Reflect.has(a, n)),
+    ownKeys: () => r ? [...t.children.keys()] : Reflect.ownKeys(d),
+    getOwnPropertyDescriptor: (a, n) => typeof n == "string" && s(n) ? { enumerable: !0, configurable: !0 } : r ? void 0 : Reflect.getOwnPropertyDescriptor(a, n)
+  });
+  return k.set(t, p), p;
+}
+function D(t) {
+  if (t == null || typeof t != "object") return !1;
+  const e = t.__kind;
+  return e === "group" || e === "array";
+}
+function P(t, e) {
+  if (!e) return;
+  let i = t;
+  for (const r of e.split(".")) {
+    if (!i) return;
+    if (i.kind === "group") i = i.children.get(r);
+    else if (i.kind === "array") i = i.items.peek()[Number(r)];
+    else return;
+  }
+  return i && i.kind === "leaf" ? i.signal : void 0;
+}
+export {
+  j as G,
+  A as a,
+  w as b,
+  D as i,
+  R as m,
+  P as r,
+  O as s,
+  S as u
+};

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+export * from './model/index'
+export {}

package/dist/model.js

@@ -0,0 +1,21 @@
+import { c as s, e as r } from "./create-model-Dxh9cfLp.js";
+import { a as i, i as t, m as c, u as l } from "./model-signals-proxy-mV3WGdlO.js";
+import { c as n, a as f, r as m, b as u, d as p, e as b, f as h, s as k, t as v, w as D } from "./behaviors-value-C7dSEhCc.js";
+export {
+  n as computeFrom,
+  f as copyFrom,
+  s as createModel,
+  r as eachLeafSignal,
+  i as isDerived,
+  t as isModelContainerSignal,
+  c as markDerived,
+  m as resetWhen,
+  u as revalidateWhen,
+  p as runOutsideEffect,
+  b as safeCallback,
+  h as safeDebouncedCallback,
+  k as syncFields,
+  v as transformValue,
+  l as unmarkDerived,
+  D as watchField
+};

package/dist/{form → platforms/react}/hooks/types.d.ts

@@ -1,4 +1,4 @@
-import { ValidationError } from '../types/index';
+import { ValidationError } from '../../../form/types/index';
 /**
  * Состояние поля формы, возвращаемое хуком {@link useFormControl} для {@link FieldNode}.
  *

package/dist/{form → platforms/react}/hooks/use-form-bundle.d.ts

@@ -1,4 +1,4 @@
-import { FormValidationController } from '../validation-strategy';
+import { FormValidationController } from '../../../form/validation/strategy';
 /** Минимум, который хук ожидает от бандла: опциональный контроллер живой валидации. */
 export interface FormBundleLike {
     validation?: {

package/dist/{form → platforms/react}/hooks/use-form-validation.d.ts

@@ -1,6 +1,6 @@
-import { FormModel } from '../../index';
-import { ValidationSchema } from '../validation-schema';
-import { ValidationStrategyKind } from '../validation-strategy';
+import { FormModel } from '../../../index';
+import { ValidationSchema } from '../../../form/validation';
+import { ValidationStrategyKind } from '../../../form/validation/strategy';
 export interface UseFormValidationArgs<T> {
     /** Модель данных формы. */
     model: FormModel<T>;

package/dist/{form → platforms/react}/hooks/useArrayLength.d.ts

@@ -1,4 +1,4 @@
-import { ArrayNode } from '../nodes/array-node';
+import { ArrayNode } from '../../../form/nodes/array-node';
 /**
  * React-хук для подписки только на длину массива.
  *

package/dist/{form → platforms/react}/hooks/useFormControl.d.ts

@@ -1,6 +1,6 @@
-import { FieldNode } from '../nodes/field-node';
-import { ArrayNode } from '../nodes/array-node';
-import { FormValue } from '../types/index';
+import { FieldNode } from '../../../form/nodes/field-node';
+import { ArrayNode } from '../../../form/nodes/array-node';
+import { FormValue } from '../../../form/types/index';
 import { FieldControlState, ArrayControlState } from './types';
 /**
  * React-хук для подписки на состояние {@link ArrayNode}.

package/dist/{form → platforms/react}/hooks/useFormControlValue.d.ts

@@ -1,5 +1,5 @@
-import { FieldNode } from '../nodes/field-node';
-import { FormValue } from '../types/index';
+import { FieldNode } from '../../../form/nodes/field-node';
+import { FormValue } from '../../../form/types/index';
 /**
  * React-хук для подписки только на значение поля.
  *

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

@@ -0,0 +1,23 @@
+/**
+ * Модуль `platforms/react` — биндинги ядра к React.
+ *
+ * Единственное место в пакете, где есть runtime-зависимость от `react` и
+ * `use-sync-external-store`: слои `model` и `form` от React свободны (в `form/types/` остаются
+ * только type-only `ComponentType`/`ElementType` — они стираются при компиляции). Хуки читают
+ * сигналы нод формы через `useSyncExternalStore` и отдают плоские снапшоты
+ * ({@link FieldControlState}/{@link ArrayControlState}) в рендер.
+ *
+ * Barrel заведён как точка для будущего сабпата `@reformer/core/react`; сейчас его состав
+ * реэкспортируется зонтиком `@reformer/core` — ровно теми же именами, что и до выноса.
+ *
+ * @group Platforms
+ * @module platforms/react
+ */
+export { useFormControl } from './hooks/useFormControl';
+export { useFormControlValue } from './hooks/useFormControlValue';
+export { useArrayLength } from './hooks/useArrayLength';
+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 type { FieldControlState, ArrayControlState } from './hooks/types';

package/dist/signals.d.ts

@@ -7,7 +7,7 @@
  * пакетов — это критично для проверок вида `value instanceof Signal` над сигналами,
  * созданными внутри @reformer/core.
  *
- * @module reformer/signals
+ * @module signals
  */
 export { signal, computed, effect, batch, untracked, Signal } from '@preact/signals-core';
 export type { ReadonlySignal } from '@preact/signals-core';

package/dist/strategy-DA3JwxsR.js

@@ -0,0 +1,170 @@
+import { signal as A, effect as M } from "@preact/signals-core";
+import { e as W } from "./create-model-Dxh9cfLp.js";
+import { g as v } from "./signal-node-registry-tiwel-TV.js";
+let g = null;
+function E(e, n) {
+  const t = g;
+  g = e;
+  try {
+    return n();
+  } finally {
+    g = t;
+  }
+}
+function u(e) {
+  if (!g)
+    throw new Error(
+      `[@reformer/core/validation] "${e}" вызван вне схемы валидации — операторы валидации можно вызывать только внутри прогона validateModel(...) (напрямую или через apply/each).`
+    );
+  return g;
+}
+function m(e, n) {
+  let t = e.errors.get(n);
+  return t || e.errors.set(n, t = []), t;
+}
+const b = (e) => e.whenStack.every((n) => n());
+function D(e, n) {
+  const t = u("validate"), r = m(t, e);
+  if (!b(t)) return;
+  const o = e.peek();
+  for (const a of n) {
+    const i = a(o, t.model, t.model);
+    i && r.push(i);
+  }
+}
+function N(e, n) {
+  const t = u("validateAsync"), r = m(t, e);
+  if (!b(t)) return;
+  const o = e.peek(), a = t.signal;
+  for (const i of n)
+    t.pending.push(
+      i(o, { signal: a }).then(
+        (s) => {
+          s && !a.aborted && r.push(s);
+        },
+        () => {
+        }
+      )
+    );
+}
+function R(e, n) {
+  const t = u("validateWhen");
+  t.whenStack.push(e);
+  try {
+    n();
+  } finally {
+    t.whenStack.pop();
+  }
+}
+function _(e, n) {
+  const t = u("cross"), r = m(t, e);
+  if (!b(t)) return;
+  const o = n(t.model.get());
+  o && r.push(o);
+}
+function $(e, n) {
+  u("each");
+  const t = e.length;
+  for (let r = 0; r < t; r++) n(e.at(r));
+}
+function j(...e) {
+  const t = u("apply").model;
+  for (const r of e) r({ model: t });
+}
+function z(e) {
+  return e;
+}
+const x = /* @__PURE__ */ new WeakMap();
+function L(e, n) {
+  let t = x.get(e);
+  t || x.set(e, t = /* @__PURE__ */ new WeakMap());
+  let r = t.get(n);
+  return r || t.set(n, r = { fields: /* @__PURE__ */ new Set(), ac: null }), r;
+}
+const P = (e) => {
+  for (const n of e.values()) for (const t of n) if (t.severity !== "warning") return !0;
+  return !1;
+};
+function T(e) {
+  return e.aborted ? Promise.resolve() : new Promise((n) => {
+    e.addEventListener("abort", () => n(), { once: !0 });
+  });
+}
+async function C(e, n, t) {
+  const r = L(e, n);
+  r.ac?.abort();
+  const o = new AbortController();
+  r.ac = o;
+  const a = {
+    model: e,
+    errors: /* @__PURE__ */ new Map(),
+    pending: [],
+    whenStack: [],
+    signal: o.signal
+  };
+  if (E(a, () => n({ model: e })), a.pending.length && await Promise.race([Promise.all(a.pending), T(o.signal)]), o.signal.aborted) return !1;
+  const i = new Set(a.errors.keys());
+  for (const s of r.fields) i.has(s) || v(s)?.setErrors([]);
+  for (const s of i) v(s)?.setErrors(a.errors.get(s) ?? []);
+  if (t?.touch) for (const s of i) v(s)?.markAsTouched();
+  return r.fields = i, !P(a.errors);
+}
+function G(e, n, t = {}) {
+  const { strategy: r = "submit", debounce: o = 0, liveAfterSubmit: a = "change" } = t, i = A(!1);
+  let s = 0, y = !1, f, c;
+  const w = async (l) => {
+    s++, i.value = !0;
+    try {
+      return await C(e, n, { touch: l });
+    } finally {
+      --s === 0 && (i.value = !1);
+    }
+  }, p = () => {
+    w(!1);
+  }, F = () => {
+    if (!o) {
+      p();
+      return;
+    }
+    c && clearTimeout(c), c = setTimeout(p, o);
+  }, k = (l, d) => {
+    let S = !0;
+    return M(() => {
+      if (W(e, l), S) {
+        S = !1;
+        return;
+      }
+      r === "afterFirstSubmit" && !y || d();
+    });
+  }, h = {
+    async validate() {
+      return y = !0, w(!0);
+    },
+    start() {
+      if (f) return () => h.dispose();
+      const l = r === "afterFirstSubmit" ? a : r;
+      return l === "change" ? f = k((d) => void d.value, F) : l === "blur" && (f = k((d) => void v(d)?.touched.value, p)), () => h.dispose();
+    },
+    dispose() {
+      c && (clearTimeout(c), c = void 0), f?.(), f = void 0;
+    },
+    get isValidating() {
+      return i.value;
+    },
+    get validating() {
+      return i;
+    }
+  };
+  return h;
+}
+export {
+  N as a,
+  R as b,
+  _ as c,
+  j as d,
+  $ as e,
+  z as f,
+  C as g,
+  G as h,
+  D as v
+};

package/dist/validation.d.ts

@@ -1,2 +1,2 @@
-export * from './form/validation-schema'
+export * from './form/validation/index'
 export {}