@reformer/core 10.2.0 → 11.0.0-beta.2

package/dist/form/types/contracts.d.ts

@@ -19,12 +19,6 @@
 export type FormValue = string | number | boolean | null | undefined | Date | File | FormValue[] | {
     [key: string]: FormValue;
 };
-/**
- * Type-safe alternative to 'any' for unknown form values
- * Requires explicit type checking before use
- * @internal
- */
-export type UnknownFormValue = unknown;
 /**
  * Синхронная функция валидации
  * @group Types

package/dist/form/types/deep-schema.d.ts

@@ -58,15 +58,6 @@ type RequireAtLeastOne<T> = {
  * @internal
  */
 type NonEmptyFieldConfig<T> = RequireAtLeastOne<FieldConfig<T>>;
-/**
- * Конфигурация массива
- * @group Types
- * @category Configuration Types
- */
-export interface ArrayConfig<T extends object> {
-    itemSchema: FormSchema<T>;
-    initial?: Partial<T>[];
-}
 /**
  * **Data-shaped** конфиг формы: ключи повторяют структуру данных `T`, значения — {@link FieldConfig}
  * (или вложенный `FormSchema`). Форма конфига, из которой строится {@link GroupNode}.

package/dist/form/types/index.d.ts

@@ -1,10 +1,10 @@
 import { FormSchema } from './deep-schema';
 import { FormNode } from '../nodes/form-node';
-export type { FormValue, UnknownFormValue, ValidatorFn, AsyncValidatorOptions, AsyncValidatorFn, ValidationError, ErrorFilterOptions, FieldStatus, } from './contracts';
+export type { FormValue, ValidatorFn, AsyncValidatorOptions, AsyncValidatorFn, ValidationError, ErrorFilterOptions, FieldStatus, } from './contracts';
 export type { FieldConfig } from './deep-schema';
-export type { Validator, AsyncValidator, ConditionFn, ValidateOptions, ValidateAsyncOptions, } from './validation-schema';
-export type { FormSchema, ArrayConfig } from './deep-schema';
-export type { FormSchemaNode, SchemaArrayControl, SchemaValidator } from './schema-node';
+export type { Validator, ValidateOptions } from './validation-schema';
+export type { FormSchema } from './deep-schema';
+export type { FormSchemaNode, SchemaArrayControl } from './schema-node';
 export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy';
 /**
  * Конфигурация GroupNode.
@@ -25,20 +25,6 @@ export interface GroupNodeConfig<T> {
  * @internal
  */
 export type UnknownRecord = Record<string, unknown>;
-/**
- * Интерфейс для узлов с методом applyValidationSchema
- * @internal
- */
-export interface WithValidationSchema {
-    applyValidationSchema(schemaFn: unknown): void;
-}
-/**
- * Интерфейс для узлов с методом applyBehaviorSchema
- * @internal
- */
-export interface WithBehaviorSchema {
-    applyBehaviorSchema(schemaFn: unknown): void;
-}
 /**
  * Интерфейс для узлов, похожих на ArrayNode (с методом at)
  * Используется для duck typing при обходе путей
@@ -63,29 +49,9 @@ export interface ConfigWithSchema {
 export interface ConfigWithValue {
     value: unknown;
 }
-/**
- * Тип для путей к полям (field paths)
- * Используется в навигации по полям вместо any
- * @internal
- */
-export type FieldPathSegment = {
-    key: string;
-    index?: number;
-};
-/**
- * Тип для коллбэков и обработчиков событий
- * Используется вместо (...args: any[]) => any
- * @internal
- */
-export type UnknownCallback = (...args: unknown[]) => unknown;
 /**
  * Тип для проверки на функцию в conditional types
  * Используется вместо Function для type narrowing
  * @internal
  */
 export type AnyFunction = (...args: never[]) => unknown;
-/**
- * Тип для результатов загрузки ресурсов
- * @internal
- */
-export type ResourceLoadResult = unknown;

package/dist/form/types/schema-node.d.ts

@@ -1,14 +1,5 @@
 import { ElementType } from 'react';
-import { ValidationError } from './contracts';
-/**
- * Валидатор поля схемы (legacy). Дерево-движок, вызывавший `validators` узла как
- * `(value, scope, root)`, удалён — живые правила это `Rule<T>` в `validate(sig, [...])`
- * (`@reformer/core/validation`). Тип остаётся широким по параметрам для совместимости
- * узлов, всё ещё несущих `validators` (гетерогенные контракты `ValidatorFn`/`Validator`).
- *
- * @group Types
- */
-export type SchemaValidator = (value: any, ...rest: any[]) => ValidationError | null | Promise<ValidationError | null>;
+import { Signal } from '../../signals';
 /**
  * Минимальный контракт реактивного массива модели ({@link FormSchemaNode.array}).
  * Совпадает по форме с рантайм-фасадом `model.<array>` (см. `ModelArray`); рендерерский
@@ -55,19 +46,25 @@ export interface FormSchemaNode {
     component?: ElementType;
     /** Props компонента. Также «клапан» для вложенности под-узлов (напр. steps визарда). */
     componentProps?: Record<string, unknown>;
-    validators?: SchemaValidator[];
-    asyncValidators?: SchemaValidator[];
     updateOn?: 'change' | 'blur' | 'submit';
     disabled?: boolean;
     /** Задержка (мс) перед запуском асинхронной валидации. */
     debounce?: number;
     /** Идентификатор узла (для wizard/tabs/renderBehavior). */
     selector?: string;
+    /**
+     * ⚠️ Рантайм этого поля НЕ ЧИТАЕТ — `renderer-react` берёт testId из `componentProps.testId`
+     * (иначе выводит из пути сигнала). Поле оставлено только потому, что `RenderSchemaNode`
+     * рендерера объявляет свой одноимённый; пишите `componentProps: { testId: '…' }`.
+     */
     testId?: string;
-    /** Дочерние узлы (даёт контекстную типизацию вложенным литералам — value/validators/when). */
-    children?: readonly FormSchemaNode[];
-    /** Условие включения поддерева (branch-узел `{ when, children }`). */
-    when?: (scope: any, root: any) => boolean;
+    /**
+     * Содержимое узла: под-узлы (даёт контекстную типизацию вложенным литералам — value/validators/when)
+     * и текстовые части. Текст (литерал, число, сигнал модели) — такой же ребёнок, как узел: core его
+     * не интерпретирует (обход пропускает примитивы и не спускается внутрь сигнала), а рендерер
+     * выводит на своём месте в порядке следования.
+     */
+    children?: readonly (FormSchemaNode | string | number | Signal<any>)[];
     /** Реактивный массив модели (`model.<path>`) — маркер узла-массива (вместе с `item`). */
     array?: SchemaArrayControl;
     /** Схема элемента массива: под-модель элемента → узел поддерева. */

package/dist/form/types/validation-schema.d.ts

@@ -11,22 +11,6 @@ import { FormModel } from '../../state/types';
  * обратной совместимости (`SchemaValidator`-union).
  */
 export type Validator<TForm, TField> = (value: TField, scope: unknown, root: FormModel<TForm>) => ValidationError | null;
-/**
- * Чистый асинхронный валидатор поля. Та же тройка аргументов `(value, scope, root)`, что у
- * {@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>;
-/**
- * Функция-предикат `(value) => boolean`.
- *
- * @deprecated Осиротевший остаток удалённого оператора `applyWhen` (Ф7). Рантаймом не
- * потребляется; экспортируется только ради обратной совместимости.
- */
-export type ConditionFn<T> = (value: T) => boolean;
 /**
  * Опции валидатора-фабрики (`required()`/`pattern()`/…). Передаются вторым (или последним)
  * аргументом в фабрику и попадают в возвращаемую {@link ValidationError}.
@@ -38,12 +22,3 @@ export interface ValidateOptions {
     /** Параметры ошибки (подстановка в шаблон сообщения / i18n). */
     params?: Record<string, FormValue>;
 }
-/**
- * @deprecated Осиротевший остаток удалённого оператора `validateAsync` (Ф7): опция `debounce`
- * подключалась тем оператором, которого больше нет. Рантаймом не потребляется; экспортируется
- * только ради обратной совместимости.
- */
-export interface ValidateAsyncOptions extends ValidateOptions {
-    /** Задержка перед выполнением валидации (в мс). */
-    debounce?: number;
-}

package/dist/form/unique-id.d.ts

@@ -25,10 +25,6 @@ export declare const SubscriptionKey: {
     readonly LinkFields: "linkFields";
     /** GroupNode.watchField() */
     readonly WatchField: "watchField";
-    /** ArrayNode.watchItems() */
-    readonly WatchItems: "watchItems";
-    /** ArrayNode.watchLength() */
-    readonly WatchLength: "watchLength";
 };
 export type SubscriptionKeyType = (typeof SubscriptionKey)[keyof typeof SubscriptionKey];
 /**
@@ -37,17 +33,13 @@ export type SubscriptionKeyType = (typeof SubscriptionKey)[keyof typeof Subscrip
  * @param prefix - Префикс для идентификатора (используйте {@link SubscriptionKey}).
  * @returns Уникальный идентификатор в формате `${prefix}-${counter}`.
  *
+ * ⚠️ `SubscriptionKey`/`SubscriptionKeyType` — внутренние: барель `@reformer/core` их не отдаёт,
+ * поэтому вызвать `uniqueId` извне пакета типобезопасно нельзя. Пример ниже — внутрипакетный.
+ *
  * @example
  * ```typescript
- * import { uniqueId, SubscriptionKey } from '@reformer/core';
- *
  * uniqueId(SubscriptionKey.WatchField); // → 'watchField-1'
  * uniqueId(SubscriptionKey.WatchField); // → 'watchField-2'
  * ```
  */
 export declare function uniqueId(prefix: SubscriptionKeyType): string;
-/**
- * Сбросить счётчик (только для тестов)
- * @internal
- */
-export declare function resetUniqueIdCounter(): void;

package/dist/form/validators.d.ts

@@ -1,6 +1,11 @@
 /**
- * Re-export validators from the main index to ensure single module instance.
- * This prevents static registry isolation issues when consuming the library.
+ * Точка входа сабпата `@reformer/core/validators` — все фабрики правил одним импортом.
+ *
+ * Гранулярные сабпаты (`@reformer/core/validators/required` и ещё 21) собираются отдельными
+ * entry для tree-shaking; этот модуль отдаёт полный набор для случаев, когда правил много.
+ *
+ * Ранее здесь был ещё и default-экспорт (`validators` из корневого `index`), заведённый как
+ * часть бандл-фикса «shared static registry». Реестров, ради которых он существовал, в коде
+ * больше нет, чанк-шаринг он не обеспечивал, потребителей не имел — удалён в 7.0.
  */
-export { validators as default } from '../index';
 export * from './validation/index';

package/dist/form-model-DhW2HZOB.js

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

package/dist/index.d.ts

@@ -8,4 +8,4 @@ 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';
+export { CORE_RUNTIME_TOKEN } from './runtime-token';