@reformer/core 10.1.0 → 11.0.0-beta.1

package/dist/runtime-token.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Штамп копии рантайма ядра.
+ *
+ * Единственное назначение — быть объектом, уникальным в пределах ОДНОЙ копии модуля. Две
+ * независимо загруженные копии `@reformer/core` дадут два разных объекта, и по их несовпадению
+ * guard распознаёт дубль рантайма.
+ *
+ * Почему именно объект, а не строка с версией: две копии ОДНОЙ версии ломают всё ровно так же,
+ * как две копии разных версий, — раздваиваются модульные `WeakMap` (`derived-registry`,
+ * `signal-node-registry`) и перестают работать проверки `instanceof Signal`. Сравнение версий
+ * такой случай пропустило бы.
+ *
+ * @see `@reformer/form-registry/guard`
+ *
+ * @example
+ * ```ts
+ * import { CORE_RUNTIME_TOKEN } from '@reformer/core';
+ * import { stampRuntime } from '@reformer/form-registry/guard';
+ *
+ * stampRuntime('@reformer/core', CORE_RUNTIME_TOKEN);
+ * ```
+ */
+export declare const CORE_RUNTIME_TOKEN: object;

package/dist/state/form-model.d.ts

@@ -1,4 +1,15 @@
-import { FormModel } from './types';
+import { FormModel, PathAwareSignal } from './types';
+/**
+ * Обойти ВСЕ листовые сигналы модели (включая элементы массивов), вызвав `visit` на каждом.
+ *
+ * Внутри реактивного `effect` служит подпиской «любое поле изменилось»: `visit(sig => void sig.value)`
+ * подписывает на значения листьев, а обход массивов через `items.value` — на их состав. Так строятся
+ * триггеры `change`/`blur` стратегий валидации (см. `createFormValidation`), тем же паттерном, что
+ * `revalidateWhen`, но без ручного перечисления зависимостей.
+ *
+ * @group Model
+ */
+export declare function eachLeafSignal<T>(model: FormModel<T>, visit: (signal: PathAwareSignal<unknown>) => void): void;
 /**
  * Создать реактивную модель данных формы (слой M1).
  *

package/dist/state.js

@@ -1,19 +1,21 @@
-import { S as s, c as r } from "./form-model-C8Fi83k4.js";
-import { c as o, a as t, i, m as d, r as l, b as m, d as n, e as f, f as u, s as b, t as p, u as k, w as v } from "./behaviors-value-lCpqicfa.js";
+import { c as s } from "./form-model-DYCzGGKF.js";
+import { c as o, a as t, r as c, b as i, d as m, e as d, f, s as l, t as n, w as u } from "./behaviors-value-C7dSEhCc.js";
+import { i as b, m as k, u as v } from "./derived-registry-CluZCQ7U.js";
+import { S as D } from "./subscription-manager-705bls97.js";
 export {
-  s as SubscriptionManager,
+  D as SubscriptionManager,
   o as computeFrom,
   t as copyFrom,
-  r as createModel,
-  i as isDerived,
-  d as markDerived,
-  l as resetWhen,
-  m as revalidateWhen,
-  n as runOutsideEffect,
-  f as safeCallback,
-  u as safeDebouncedCallback,
-  b as syncFields,
-  p as transformValue,
-  k as unmarkDerived,
-  v as watchField
+  s as createModel,
+  b as isDerived,
+  k as markDerived,
+  c as resetWhen,
+  i as revalidateWhen,
+  m as runOutsideEffect,
+  d as safeCallback,
+  f as safeDebouncedCallback,
+  l as syncFields,
+  n as transformValue,
+  v as unmarkDerived,
+  u as watchField
 };

package/dist/subscription-manager-705bls97.js

@@ -0,0 +1,171 @@
+class t {
+  /**
+   * Хранилище подписок
+   * Ключ: уникальный идентификатор подписки
+   * Значение: функция отписки (dispose)
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Добавляет подписку
+   *
+   * Если подписка с таким ключом уже существует, отписывается от неё
+   * и заменяет новой. Это предотвращает утечки памяти при повторной
+   * регистрации подписки с тем же ключом.
+   *
+   * @param key Уникальный ключ подписки
+   * @param dispose Функция отписки (обычно возвращаемая из effect())
+   * @returns Функция для отписки от этой конкретной подписки
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   *
+   * // Добавление подписки
+   * const unsubscribe = manager.add('mySubscription', () => {
+   *   console.log('Disposing subscription');
+   * });
+   *
+   * // Отписка через возвращаемую функцию
+   * unsubscribe();
+   *
+   * // Или через manager.remove()
+   * manager.add('anotherSub', disposeFn);
+   * manager.remove('anotherSub');
+   * ```
+   */
+  add(s, i) {
+    return this.subscriptions.has(s) && (process.env.NODE_ENV !== "production" && console.warn(`[SubscriptionManager] Subscription "${s}" already exists, replacing`), this.subscriptions.get(s)?.()), this.subscriptions.set(s, i), () => this.remove(s);
+  }
+  /**
+   * Удаляет подписку по ключу
+   *
+   * Вызывает функцию отписки и удаляет подписку из хранилища.
+   * Если подписка с таким ключом не найдена, ничего не делает.
+   *
+   * @param key Ключ подписки
+   * @returns true, если подписка была удалена, false если не найдена
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('mySub', disposeFn);
+   *
+   * // Удаление подписки
+   * const removed = manager.remove('mySub'); // true
+   *
+   * // Попытка удалить несуществующую подписку
+   * const removed2 = manager.remove('nonExistent'); // false
+   * ```
+   */
+  remove(s) {
+    const i = this.subscriptions.get(s);
+    return i ? (i(), this.subscriptions.delete(s), !0) : !1;
+  }
+  /**
+   * Очищает все подписки
+   *
+   * Вызывает функции отписки для всех активных подписок
+   * и очищает хранилище. Обычно используется при dispose узла формы.
+   *
+   * @example
+   * ```typescript
+   * class FieldNode {
+   *   private subscriptions = new SubscriptionManager();
+   *
+   *   dispose() {
+   *     // Отписываемся от всех effect
+   *     this.subscriptions.clear();
+   *   }
+   * }
+   * ```
+   */
+  clear() {
+    this.subscriptions.forEach((s) => {
+      s();
+    }), this.subscriptions.clear();
+  }
+  /**
+   * Возвращает количество активных подписок
+   *
+   * Полезно для отладки утечек памяти. Если количество подписок
+   * растет без ограничений, это может указывать на то, что
+   * компоненты не отписываются должным образом.
+   *
+   * @returns Количество активных подписок
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * console.log(manager.size()); // 0
+   *
+   * manager.add('sub1', disposeFn1);
+   * manager.add('sub2', disposeFn2);
+   * console.log(manager.size()); // 2
+   *
+   * manager.clear();
+   * console.log(manager.size()); // 0
+   * ```
+   */
+  size() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Проверяет, есть ли подписка с данным ключом
+   *
+   * @param key Ключ подписки
+   * @returns true, если подписка существует
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('mySub', disposeFn);
+   *
+   * console.log(manager.has('mySub')); // true
+   * console.log(manager.has('nonExistent')); // false
+   * ```
+   */
+  has(s) {
+    return this.subscriptions.has(s);
+  }
+  /**
+   * Возвращает список всех ключей активных подписок
+   *
+   * Полезно для отладки: можно увидеть, какие подписки активны.
+   *
+   * @returns Массив ключей всех активных подписок
+   *
+   * @example
+   * ```typescript
+   * const manager = new SubscriptionManager();
+   * manager.add('watch-value', disposeFn1);
+   * manager.add('watch-errors', disposeFn2);
+   *
+   * console.log(manager.getKeys()); // ['watch-value', 'watch-errors']
+   * ```
+   */
+  getKeys() {
+    return Array.from(this.subscriptions.keys());
+  }
+  /**
+   * Отписывается от всех подписок (алиас для clear())
+   *
+   * Используется при dispose() узла формы для совместимости с ожидаемым API.
+   *
+   * @example
+   * ```typescript
+   * class FieldNode {
+   *   private subscriptions = new SubscriptionManager();
+   *
+   *   dispose() {
+   *     this.subscriptions.dispose();
+   *   }
+   * }
+   * ```
+   */
+  dispose() {
+    this.clear();
+  }
+}
+export {
+  t as S
+};

package/dist/validation.js

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

package/dist/validators.d.ts

@@ -1,6 +1,2 @@
 export * from './form/validators'
 export {}
-import _default from './form/validators'
-export default _default
-export * from './form/validators'
-export {}