@reformer/core 10.1.0 → 10.2.0

package/dist/form/validation-strategy.d.ts

@@ -0,0 +1,55 @@
+import { ReadonlySignal } from '@preact/signals-core';
+import { FormModel } from '../index';
+import { ValidationSchema } from './validation-schema';
+/**
+ * Когда запускается schema-валидация:
+ * - `submit` (по умолчанию) — только явным вызовом `validate()` (на отправке);
+ * - `blur` — при потере фокуса поля (смена `touched` любого листа);
+ * - `change` — на каждый ввод (с опц. `debounce`);
+ * - `afterFirstSubmit` — тихо до первого `validate()`, затем live (см. `liveAfterSubmit`).
+ */
+export type ValidationStrategyKind = 'submit' | 'blur' | 'change' | 'afterFirstSubmit';
+export interface ValidationStrategyOptions {
+    /** Стратегия запуска. Default `'submit'`. */
+    strategy?: ValidationStrategyKind;
+    /** Debounce (мс) для live-фаз (`change` и live-часть `afterFirstSubmit`). Default `0`. */
+    debounce?: number;
+    /** Режим live-фазы для `afterFirstSubmit`. Default `'change'`. */
+    liveAfterSubmit?: 'change' | 'blur';
+}
+export interface FormValidationController {
+    /**
+     * Полный прогон схемы с раскрытием ошибок (`touch: true`) — для submit. Также переводит
+     * `afterFirstSubmit` в live-фазу. Возвращает `false`, если есть блокирующие ошибки.
+     */
+    validate(): Promise<boolean>;
+    /** Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR. */
+    start(): () => void;
+    /** Снять подписки/таймеры. Идемпотентно. */
+    dispose(): void;
+    /** Идёт ли прогон (submit или live) — снапшот. */
+    readonly isValidating: boolean;
+    /** Реактивный сигнал состояния прогона (для тонкой подписки в UI). */
+    readonly validating: ReadonlySignal<boolean>;
+}
+/**
+ * Собрать контроллер валидации формы с выбранной стратегией запуска. Переиспользует
+ * {@link validateModel} как единственный движок прогона.
+ *
+ * Фабрика ЧИСТАЯ до `start()` (никаких подписок) — безопасна для SSR/headless. Реактивные триггеры
+ * арминуются только в `start()` (в React — из `useEffect`).
+ *
+ * @typeParam T - Форма данных модели.
+ * @param model - Модель данных.
+ * @param schema - Схема валидации. **Стабильная ссылка** (иначе `validateModel` не отменит устаревший прогон).
+ * @param options - {@link ValidationStrategyOptions}.
+ *
+ * @example
+ * ```ts
+ * const ctrl = createFormValidation(model, schema, { strategy: 'afterFirstSubmit', debounce: 300 });
+ * const dispose = ctrl.start();               // на клиенте
+ * const ok = await ctrl.validate();           // submit → раскрыть все ошибки
+ * dispose();
+ * ```
+ */
+export declare function createFormValidation<T>(model: FormModel<T>, schema: ValidationSchema<T>, options?: ValidationStrategyOptions): FormValidationController;

package/dist/form-model-DYCzGGKF.js

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