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

package/dist/{state/form-model.d.ts → model/create-model.d.ts}

@@ -1,18 +1,4 @@
 import { FormModel, PathAwareSignal } from './types';
-/**
- * Узел дерева `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;
 /**
  * Обойти ВСЕ листовые сигналы модели (включая элементы массивов), вызвав `visit` на каждом.
  *

package/dist/{state → model}/index.d.ts

@@ -1,32 +1,31 @@
 /**
- * `@reformer/core/state` — низкоуровневый реактивный **state-субстрат** (M1) и barrel модуля `state`.
+ * `@reformer/core/model` — низкоуровневый реактивный субстрат (M1) и barrel модуля `model`.
  *
  * Это «прокси-объект с сигналами» и инструментарий для построения доменных модулей поверх него
  * (form, table, …). Модуль СТРОГО реактивный: НИЧЕГО связанного с формами/валидацией/схемами здесь
- * нет — только модель, value-операции, producer-флаг и утилиты субстрата. Граница state⇏form
- * зафиксирована ESLint-правилом (`no-restricted-imports` на `src/state/**`).
+ * нет — только модель, value-операции, producer-флаг и утилиты субстрата. Граница model⇏form
+ * зафиксирована ESLint-правилом (`no-restricted-imports` на `src/model/**`).
  *
  * Реактивный рантайм (`signal/computed/effect/…`) живёт в отдельном subpath `@reformer/core/signals`
  * (единый владелец `@preact/signals-core`) — импортируй его оттуда; здесь он НЕ реэкспортируется,
  * чтобы зонтичный barrel `.` не разрастался рантаймом.
  *
- * Состав (реэкспорты — из тех же файлов, что использует зонтик `.`, поэтому `.` и `/state` — один
+ * Состав (реэкспорты — из тех же файлов, что использует зонтик `.`, поэтому `.` и `/model` — один
  * module-инстанс: общий `derived`-WeakMap, единая идентичность `Signal`):
  * - **модель** — `createModel` + типы `FormModel`/`ModelArray`/… + `PathAwareSignal`;
+ * - **обход листьев** — `eachLeafSignal` (подписка «любое поле изменилось»);
  * - **value-операции** (реактивные правила) — `computeFrom`/`copyFrom`/`watchField`/`transformValue`/
  *   `resetWhen`/`syncFields`/`revalidateWhen`;
  * - **producer-owned флаг** — `markDerived`/`isDerived`/`unmarkDerived`;
- * - **утилиты субстрата** — `runOutsideEffect`/`safeCallback`/`safeDebouncedCallback`,
- *   `SubscriptionManager`.
+ * - **утилиты субстрата** — `runOutsideEffect`/`safeCallback`/`safeDebouncedCallback`.
  *
- * @group State
- * @module state
+ * @group Model
+ * @module model
  */
-export { createModel } from './form-model';
+export { createModel, eachLeafSignal } from './create-model';
 export type { FormModel, ModelArray, ModelArraySignals, ModelGroupSignals, ModelObject, ModelValue, ModelSignals, ModelApi, PathAwareSignal, } from './types';
-export { isModelContainerSignal } from './form-model';
+export { isModelContainerSignal } from './model-signals-proxy';
 export { computeFrom, copyFrom, watchField, transformValue, resetWhen, syncFields, revalidateWhen, } from './behaviors-value';
 export type { BehaviorCleanup } from './behaviors-value';
 export { markDerived, isDerived, unmarkDerived } from './derived-registry';
 export { runOutsideEffect, safeCallback, safeDebouncedCallback } from './safe-effect';
-export { SubscriptionManager } from './subscription-manager';

package/dist/model/model-nodes.d.ts

@@ -0,0 +1,60 @@
+import { Signal } from '@preact/signals-core';
+import { PathAwareSignal } from './types';
+export declare const isIndexKey: (key: string) => boolean;
+export type ModelNode = LeafNode | GroupNode | ArrayNode;
+declare class LeafNode {
+    path: string;
+    readonly kind: "leaf";
+    readonly signal: PathAwareSignal<unknown>;
+    private initial;
+    constructor(initial: unknown, path: string);
+    rebase(path: string): void;
+    /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+    read(): unknown;
+    /** Нереактивный снимок. */
+    peek(): unknown;
+    set(value: unknown): void;
+    resetToInitial(): void;
+    captureInitial(): void;
+    dirty(): boolean;
+}
+export declare class GroupNode {
+    path: string;
+    readonly kind: "group";
+    readonly children: Map<string, ModelNode>;
+    constructor(initial: Record<string, unknown>, path: string);
+    rebase(path: string): void;
+    /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+    read(): Record<string, unknown>;
+    peek(): Record<string, unknown>;
+    set(value: unknown): void;
+    resetToInitial(): void;
+    captureInitial(): void;
+    dirty(): boolean;
+}
+export declare class ArrayNode {
+    path: string;
+    readonly kind: "array";
+    readonly items: Signal<ModelNode[]>;
+    private initial;
+    constructor(initial: unknown[], path: string);
+    rebase(path: string): void;
+    private reindex;
+    push(value: unknown): void;
+    insertAt(index: number, value: unknown): void;
+    removeAt(index: number): void;
+    move(from: number, to: number): void;
+    swap(a: number, b: number): void;
+    clear(): void;
+    /**
+     * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+     * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+     */
+    read(): unknown[];
+    peek(): unknown[];
+    set(value: unknown): void;
+    resetToInitial(): void;
+    captureInitial(): void;
+    dirty(): boolean;
+}
+export {};

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/platforms/react/hooks/use-form-bundle.d.ts

@@ -0,0 +1,26 @@
+import { FormValidationController } from '../../../form/validation/strategy';
+/** Минимум, который хук ожидает от бандла: опциональный контроллер живой валидации. */
+export interface FormBundleLike {
+    validation?: {
+        controller: FormValidationController;
+    };
+}
+/**
+ * Собрать форму один раз и держать её стабильной; живую стратегию валидации армировать в эффекте
+ * (не при SSR — там эффекты не выполняются).
+ *
+ * @typeParam B - Тип бандла конкретной фабрики.
+ * @param factory - Фабрика бандла, обычно `() => createCoreForm({…})`.
+ * @returns Стабильный бандл.
+ *
+ * @example
+ * ```tsx
+ * const credit = useFormBundle(() => createCoreForm<CreditForm>({ model: createCreditModel() }));
+ * ```
+ *
+ * @remarks
+ * Передавайте именно фабрику: `useState` трактует функцию как ленивый инициализатор, а некоторые
+ * части бандла сами являются функциями (`RenderSchemaProxy`), поэтому `useFormBundle(bundle.render)`
+ * вызвал бы её вместо сохранения.
+ */
+export declare function useFormBundle<B extends FormBundleLike>(factory: () => B): B;

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';