@reformer/core 9.0.0 → 9.1.0

package/dist/{core → form}/types/validation-schema.d.ts

@@ -1,5 +1,5 @@
 import { FormValue, ValidationError } from './index';
-import { FormModel } from '../model/types';
+import { FormModel } from '../../state/types';
 /**
  * Чистый синхронный валидатор поля.
  *
@@ -35,27 +35,37 @@ import { FormModel } from '../model/types';
 export type Validator<TForm, TField> = (value: TField, scope: unknown, root: FormModel<TForm>) => ValidationError | null;
 /**
  * Чистый асинхронный валидатор поля. Та же тройка аргументов `(value, scope, root)`, что у
- * {@link Validator}, но возвращает `Promise`. Регистрируется через
- * `validateAsync(path, validator, { debounce })`.
+ * {@link Validator}, но возвращает `Promise`.
+ *
+ * @deprecated Осиротевший остаток удалённого оператора `validateAsync` (Ф7). Рантаймом не
+ * потребляется — живой async-путь узла поля использует `AsyncValidatorFn` `(value, { signal })`.
+ * Экспортируется только ради обратной совместимости.
  */
 export type AsyncValidator<TForm, TField> = (value: TField, scope: unknown, root: FormModel<TForm>) => Promise<ValidationError | null>;
 /**
- * Функция условия для applyWhen.
+ * Функция-предикат `(value) => boolean`.
+ *
+ * @deprecated Осиротевший остаток удалённого оператора `applyWhen` (Ф7). Рантаймом не
+ * потребляется; экспортируется только ради обратной совместимости.
  */
 export type ConditionFn<T> = (value: T) => boolean;
 /**
- * Опции для функции validate.
+ * Опции валидатора-фабрики (`required()`/`pattern()`/…). Передаются вторым (или последним)
+ * аргументом в фабрику и попадают в возвращаемую {@link ValidationError}.
  */
 export interface ValidateOptions {
-    /** Сообщение об ошибке */
+    /** Готовое сообщение об ошибке. Если не задано, валидаторы кладут `''`, и отображаемый текст
+     * резолвится из `code` (см. резолвер сообщений в `@reformer/cdk`). */
     message?: string;
-    /** Параметры ошибки */
+    /** Параметры ошибки (подстановка в шаблон сообщения / i18n). */
     params?: Record<string, FormValue>;
 }
 /**
- * Опции для функции validateAsync.
+ * @deprecated Осиротевший остаток удалённого оператора `validateAsync` (Ф7): опция `debounce`
+ * подключалась тем оператором, которого больше нет. Рантаймом не потребляется; экспортируется
+ * только ради обратной совместимости.
  */
 export interface ValidateAsyncOptions extends ValidateOptions {
-    /** Задержка перед выполнением валидации (в мс) */
+    /** Задержка перед выполнением валидации (в мс). */
     debounce?: number;
 }

package/dist/{core/model/validate-model.d.ts → form/validate-model-core.d.ts}

@@ -1,6 +1,6 @@
-import { ValidationError } from '../types';
-import { FormSchemaNode } from '../types/schema-node';
-import { FormModel } from './types';
+import { ValidationError } from './types/contracts';
+import { FormSchemaNode } from './types/schema-node';
+import { FormModel, PathAwareSignal } from '../state/types';
 /**
  * Валидатор слоя **данных**. `value` — значение поля; `model` — ближайший scope (под-модель элемента
  * массива или корень); `root` — корневая модель.
@@ -21,6 +21,26 @@ export interface ModelValidationResult {
     /** Ключ — путь поля (`'coBorrowers.0.relationship'`). Только поля с ошибками. */
     errors: Record<string, ValidationError[]>;
 }
+export interface FieldTask {
+    signal: PathAwareSignal<unknown>;
+    validators: ModelValidator[];
+    scope: unknown;
+}
+/** Результат обхода схемы: что валидировать и что очистить. */
+export interface CollectResult {
+    /** Активные поля с валидаторами (прогоняются). */
+    tasks: FieldTask[];
+    /** Сигналы полей в ВЫКЛЮЧЕННЫХ ветках — их ошибки нужно очистить (`setErrors([])`). */
+    clearSignals: PathAwareSignal<unknown>[];
+}
+/** Один обход схемы → задачи (активные) + сигналы на очистку (выключенные ветки). */
+export declare function collect(model: unknown, schema: unknown): CollectResult;
+/**
+ * Есть ли среди собранных ошибок блокирующие. Ошибка с `severity: 'warning'` показывается,
+ * но НЕ блокирует submit (см. {@link ValidationError.severity} — 'warning' allows submission),
+ * поэтому `valid` выводится из наличия блокирующих ошибок, а не из общего количества ошибок.
+ */
+export declare const hasBlockingErrors: (errors: Record<string, ValidationError[]>) => boolean;
 /**
  * Синхронная headless-валидация данных. Асинхронные валидаторы пропускаются.
  *
@@ -48,25 +68,5 @@ export declare function validateModelSync<T>(model: FormModel<T>, schema: FormSc
  * ```
  */
 export declare function validateModel<T>(model: FormModel<T>, schema: FormSchemaNode): Promise<ModelValidationResult>;
-/**
- * In-form валидация: прогоняет {@link validateModel} и роутит ошибки в ноды формы
- * (через реестр сигнал→нода): `node.setErrors(errors[path] ?? [])` — заодно очищает прошедшие поля
- * И поля выключенных веток (`{ when, children }` с ложным условием). Дерево обходится ОДИН раз.
- *
- * @group Model
- * @param model - Модель данных ({@link FormModel}) — источник значений полей.
- * @param schema - Единая схема формы (та же, что передавалась в `createForm`).
- * @returns {@link ModelValidationResult} — `valid` + ошибки по пути поля; побочный эффект — ошибки
- *   разведены по нодам формы.
- * @remarks Поля, не материализованные в форме (элементы массива — строятся per-item), не роутятся
- * в родительскую форму; их ошибки доступны в возвращаемом результате по пути.
- *
- * @example Валидация перед submit (ошибки показываются в UI автоматически)
- * ```typescript
- * const form = createForm({ model, schema });
- * form.touchAll();
- * const res = await validateFormModel(model, schema);
- * if (res.valid) await api.save(model.get());
- * ```
- */
-export declare function validateFormModel<T>(model: FormModel<T>, schema: FormSchemaNode): Promise<ModelValidationResult>;
+/** Прогон задач (sync + async): возвращает ошибки по пути. */
+export declare function runTasks(tasks: FieldTask[], model: unknown): Promise<Record<string, ValidationError[]>>;

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

@@ -0,0 +1,27 @@
+import { FormSchemaNode } from './types/schema-node';
+import { FormModel } from '../state/types';
+import { ModelValidationResult } from './validate-model-core';
+export { validateModel, validateModelSync } from './validate-model-core';
+export type { ModelValidator, ModelValidationResult } from './validate-model-core';
+/**
+ * In-form валидация: прогоняет {@link validateModel} и роутит ошибки в ноды формы
+ * (через реестр сигнал→нода): `node.setErrors(errors[path] ?? [])` — заодно очищает прошедшие поля
+ * И поля выключенных веток (`{ when, children }` с ложным условием). Дерево обходится ОДИН раз.
+ *
+ * @group Model
+ * @param model - Модель данных ({@link FormModel}) — источник значений полей.
+ * @param schema - Единая схема формы (та же, что передавалась в `createForm`).
+ * @returns {@link ModelValidationResult} — `valid` + ошибки по пути поля; побочный эффект — ошибки
+ *   разведены по нодам формы.
+ * @remarks Поля, не материализованные в форме (элементы массива — строятся per-item), не роутятся
+ * в родительскую форму; их ошибки доступны в возвращаемом результате по пути.
+ *
+ * @example Валидация перед submit (ошибки показываются в UI автоматически)
+ * ```typescript
+ * const form = createForm({ model, schema });
+ * form.touchAll();
+ * const res = await validateFormModel(model, schema);
+ * if (res.valid) await api.save(model.get());
+ * ```
+ */
+export declare function validateFormModel<T>(model: FormModel<T>, schema: FormSchemaNode): Promise<ModelValidationResult>;

package/dist/{core → form}/validation/validators/required.d.ts

@@ -4,7 +4,8 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  *
  * Возвращает чистую функцию-валидатор `(value, control, root)`. Передаётся в `validate()`.
  *
- * Пустыми считаются: `null`, `undefined`, `''` (пустая строка).
+ * Пустыми считаются: `null`, `undefined`, `''` (пустая строка), `[]` (пустой массив —
+ * обязательный multi-select / FormArray без выбранных элементов).
  * Для boolean полей требуется значение `true`.
  *
  * @param options - Опции валидатора ({@link ValidateOptions}): `message`, `params`

package/dist/form/validators.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export validators from the main index to ensure single module instance.
+ * This prevents static registry isolation issues when consuming the library.
+ */
+export { validators as default } from '../index';
+export * from './validation/index';

package/dist/form-model-C8Fi83k4.js

@@ -0,0 +1,439 @@
+import { signal as v } from "@preact/signals-core";
+import { i as w } from "./behaviors-value-lCpqicfa.js";
+class P {
+  /**
+   * Хранилище подписок
+   * Ключ: уникальный идентификатор подписки
+   * Значение: функция отписки (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(t, e) {
+    return this.subscriptions.has(t) && (process.env.NODE_ENV !== "production" && console.warn(`[SubscriptionManager] Subscription "${t}" already exists, replacing`), this.subscriptions.get(t)?.()), this.subscriptions.set(t, e), () => this.remove(t);
+  }
+  /**
+   * Удаляет подписку по ключу
+   *
+   * Вызывает функцию отписки и удаляет подписку из хранилища.
+   * Если подписка с таким ключом не найдена, ничего не делает.
+   *
+   * @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(t) {
+    const e = this.subscriptions.get(t);
+    return e ? (e(), this.subscriptions.delete(t), !0) : !1;
+  }
+  /**
+   * Очищает все подписки
+   *
+   * Вызывает функции отписки для всех активных подписок
+   * и очищает хранилище. Обычно используется при dispose узла формы.
+   *
+   * @example
+   * ```typescript
+   * class FieldNode {
+   *   private subscriptions = new SubscriptionManager();
+   *
+   *   dispose() {
+   *     // Отписываемся от всех effect
+   *     this.subscriptions.clear();
+   *   }
+   * }
+   * ```
+   */
+  clear() {
+    this.subscriptions.forEach((t) => {
+      t();
+    }), 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(t) {
+    return this.subscriptions.has(t);
+  }
+  /**
+   * Возвращает список всех ключей активных подписок
+   *
+   * Полезно для отладки: можно увидеть, какие подписки активны.
+   *
+   * @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();
+  }
+}
+const u = (i) => !(i === null || typeof i != "object" || Array.isArray(i) || i instanceof Date || typeof Blob < "u" && i instanceof Blob || typeof File < "u" && i instanceof File), a = (i, t) => i === "" ? String(t) : `${i}.${t}`, p = (i) => /^\d+$/.test(i), o = (i) => {
+  if (Array.isArray(i)) return i.map(o);
+  if (u(i)) {
+    const t = {};
+    for (const e of Object.keys(i)) t[e] = o(i[e]);
+    return t;
+  }
+  return i;
+}, f = (i, t) => {
+  if (i === t) return !0;
+  if (Array.isArray(i) && Array.isArray(t))
+    return i.length !== t.length ? !1 : i.every((e, s) => f(e, t[s]));
+  if (u(i) && u(t)) {
+    const e = Object.keys(i), s = Object.keys(t);
+    return e.length !== s.length ? !1 : e.every((r) => f(i[r], t[r]));
+  }
+  return !1;
+};
+class _ {
+  constructor(t, e) {
+    this.path = e;
+    const s = v(t);
+    s.__path = e, this.signal = s, this.initial = o(t);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(t) {
+    this.path = t, this.signal.__path = t;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(t) {
+    this.signal.value = t;
+  }
+  resetToInitial() {
+    this.signal.value = o(this.initial);
+  }
+  captureInitial() {
+    this.initial = o(this.signal.peek());
+  }
+  dirty() {
+    return !f(this.signal.peek(), this.initial);
+  }
+}
+class b {
+  constructor(t, e) {
+    this.path = e;
+    for (const s of Object.keys(t))
+      this.children.set(s, c(t[s], a(e, s)));
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(t) {
+    this.path = t;
+    for (const [e, s] of this.children) s.rebase(a(t, e));
+  }
+  peek() {
+    const t = {};
+    for (const [e, s] of this.children) t[e] = s.peek();
+    return t;
+  }
+  set(t) {
+    if (t == null || typeof t != "object") return;
+    const e = t;
+    for (const [s, r] of this.children)
+      s in e && (r.kind === "leaf" && w(r.signal) || r.set(e[s]));
+  }
+  resetToInitial() {
+    for (const t of this.children.values()) t.resetToInitial();
+  }
+  captureInitial() {
+    for (const t of this.children.values()) t.captureInitial();
+  }
+  dirty() {
+    for (const t of this.children.values()) if (t.dirty()) return !0;
+    return !1;
+  }
+}
+class k {
+  constructor(t, e) {
+    this.path = e, this.items = v(t.map((s, r) => c(s, a(e, r)))), this.initial = o(t);
+  }
+  kind = "array";
+  items;
+  initial;
+  rebase(t) {
+    this.path = t, this.items.peek().forEach((e, s) => e.rebase(a(t, s)));
+  }
+  reindex() {
+    this.items.peek().forEach((t, e) => t.rebase(a(this.path, e)));
+  }
+  push(t) {
+    const e = this.items.peek();
+    this.items.value = [...e, c(t, a(this.path, e.length))];
+  }
+  insertAt(t, e) {
+    const s = [...this.items.peek()];
+    s.splice(t, 0, c(e, a(this.path, t))), this.items.value = s, this.reindex();
+  }
+  removeAt(t) {
+    const e = [...this.items.peek()];
+    e.splice(t, 1), this.items.value = e, this.reindex();
+  }
+  move(t, e) {
+    const s = [...this.items.peek()], [r] = s.splice(t, 1);
+    r && s.splice(e, 0, r), this.items.value = s, this.reindex();
+  }
+  swap(t, e) {
+    const s = [...this.items.peek()];
+    t < 0 || e < 0 || t >= s.length || e >= s.length || t === e || ([s[t], s[e]] = [s[e], s[t]], this.items.value = s, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  peek() {
+    return this.items.peek().map((t) => t.peek());
+  }
+  set(t) {
+    const e = Array.isArray(t) ? t : [];
+    this.items.value = e.map((s, r) => c(s, a(this.path, r)));
+  }
+  resetToInitial() {
+    this.set(o(this.initial));
+  }
+  captureInitial() {
+    this.initial = o(this.peek());
+  }
+  dirty() {
+    return !f(this.peek(), this.initial);
+  }
+}
+function c(i, t) {
+  return Array.isArray(i) ? new k(i, t) : u(i) ? new b(i, t) : new _(i, t);
+}
+function l(i) {
+  if (i)
+    return i.kind === "group" ? A(i) : i.kind === "array" ? x(i) : i.read();
+}
+function x(i) {
+  const t = {
+    get length() {
+      return i.items.value.length;
+    },
+    push: (e) => i.push(e),
+    insertAt: (e, s) => i.insertAt(e, s),
+    removeAt: (e) => i.removeAt(e),
+    move: (e, s) => i.move(e, s),
+    swap: (e, s) => i.swap(e, s),
+    clear: () => i.clear(),
+    at: (e) => l(i.items.value[e]),
+    map: (e) => i.items.value.map((s, r) => e(l(s), r)),
+    forEach: (e) => i.items.value.forEach((s, r) => e(l(s), r)),
+    toArray: () => i.peek(),
+    [Symbol.iterator]: function* () {
+      const e = i.items.value;
+      for (let s = 0; s < e.length; s++) yield l(e[s]);
+    }
+  };
+  return new Proxy(t, {
+    get: (e, s, r) => s === "__path" ? i.path : typeof s == "string" && p(s) ? l(i.items.value[Number(s)]) : Reflect.get(e, s, r),
+    has: (e, s) => typeof s == "string" && p(s) ? Number(s) < i.items.value.length : Reflect.has(e, s)
+  });
+}
+function d(i) {
+  if (i.kind === "leaf") return i.signal;
+  if (i.kind === "group")
+    return new Proxy(
+      {},
+      {
+        get: (e, s) => {
+          if (s === "__path") return i.path;
+          if (typeof s != "string") return;
+          const r = i.children.get(s);
+          return r ? d(r) : void 0;
+        },
+        has: (e, s) => typeof s == "string" && i.children.has(s),
+        ownKeys: () => [...i.children.keys()],
+        getOwnPropertyDescriptor: (e, s) => typeof s == "string" && i.children.has(s) ? { enumerable: !0, configurable: !0 } : void 0
+      }
+    );
+  const t = i;
+  return new Proxy(
+    {
+      get length() {
+        return t.items.value.length;
+      }
+    },
+    {
+      get: (e, s, r) => {
+        if (s === "__path") return t.path;
+        if (typeof s == "string" && p(s)) {
+          const n = t.items.value[Number(s)];
+          return n ? d(n) : void 0;
+        }
+        return Reflect.get(e, s, r);
+      }
+    }
+  );
+}
+function I(i, t) {
+  if (!t) return;
+  let e = i;
+  for (const s of t.split(".")) {
+    if (!e) return;
+    if (e.kind === "group") e = e.children.get(s);
+    else if (e.kind === "array") e = e.items.peek()[Number(s)];
+    else return;
+  }
+  return e && e.kind === "leaf" ? e.signal : void 0;
+}
+const g = /* @__PURE__ */ new Set([
+  "$",
+  "get",
+  "set",
+  "patch",
+  "isDirty",
+  "reset",
+  "captureInitial",
+  "signalAt"
+]), y = /* @__PURE__ */ new WeakMap();
+function A(i) {
+  const t = y.get(i);
+  if (t) return t;
+  const e = {
+    $: d(i),
+    get: () => i.peek(),
+    set: (r) => i.set(r),
+    patch: (r) => i.set(r),
+    isDirty: () => i.dirty(),
+    reset: () => i.resetToInitial(),
+    captureInitial: () => i.captureInitial(),
+    signalAt: (r) => I(i, r)
+  }, s = new Proxy(
+    {},
+    {
+      get: (r, n) => {
+        if (n === "__path") return i.path;
+        if (typeof n != "string") return;
+        const h = i.children.get(n);
+        if (h) return l(h);
+        if (g.has(n)) return e[n];
+      },
+      set: (r, n, h) => {
+        if (typeof n != "string") return !1;
+        const m = i.children.get(n);
+        return m ? (m.set(h), !0) : !1;
+      },
+      has: (r, n) => typeof n == "string" && (i.children.has(n) || g.has(n)),
+      ownKeys: () => [...i.children.keys()],
+      getOwnPropertyDescriptor: (r, n) => typeof n == "string" && i.children.has(n) ? { enumerable: !0, configurable: !0 } : void 0
+    }
+  );
+  return y.set(i, s), s;
+}
+function S(i) {
+  const t = new b(i, "");
+  return A(t);
+}
+export {
+  P as S,
+  S as c
+};

package/dist/index.d.ts

@@ -1,16 +1,11 @@
-export * from './core/types';
-export * from './core/factories';
-export * from './core/utils';
-export * from './core/model';
-export { FormNode } from './core/nodes/form-node';
-export { FieldNode } from './core/nodes/field-node';
-export { GroupNode } from './core/nodes/group-node';
-export { ArrayNode } from './core/nodes/array-node';
-export { ModelArrayNode } from './core/nodes/model-array-node';
-export type { ModelArrayControl } from './core/nodes/model-array-node';
-export type { SetValueOptions } from './core/nodes/form-node';
-export { useFormControl } from './hooks/useFormControl';
-export { useFormControlValue } from './hooks/useFormControlValue';
-export { useArrayLength } from './hooks/useArrayLength';
-export type { FieldControlState, ArrayControlState } from './hooks/types';
-export * as validators from './core/validation';
+/**
+ * Публичный barrel `@reformer/core` — зонтик над модулями `model` (state) и `form`.
+ *
+ * Состав экспортов НЕ изменился при модуляризации (реорг в src/model + src/form): реализация
+ * разложена по модулям, а этот barrel по-прежнему отдаёт единую поверхность.
+ */
+export * from './form/types/index';
+export * from './form/factories/index';
+export * from './state/index';
+export * from './form/index';
+export * as validators from './form/validation/index';