@reformer/core 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/behaviors/compute-from.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/compute-from'
+export {}

package/dist/behaviors/compute-from.js

@@ -0,0 +1,31 @@
+import { effect as _ } from "@preact/signals-core";
+import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as V } from "../safe-effect-Dh8uw81c.js";
+function N(n, i, s, f) {
+  const { debounce: p, condition: u } = f || {}, h = (r, E, m) => {
+    const a = r.getFieldByPath(i.__path);
+    if (!a) return null;
+    const o = n.map((e) => r.getFieldByPath(e.__path)).filter((e) => e !== void 0);
+    return o.length === 0 ? null : _(() => {
+      o.forEach((e) => e.value.value), m(() => {
+        if (u) {
+          const t = r.getValue();
+          if (!u(t)) return;
+        }
+        const e = o.map((t) => t.value.value), l = {};
+        n.forEach((t, d) => {
+          const g = t.__path.split(".").pop() || t.__path;
+          l[g] = e[d];
+        });
+        const c = s(l);
+        a.value.peek() !== c && V(() => {
+          a.setValue(c, { emitEvent: !1 });
+        });
+      });
+    });
+  };
+  v().register(h, { debounce: p });
+}
+export {
+  N as computeFrom
+};

package/dist/behaviors/copy-from.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/copy-from'
+export {}

package/dist/behaviors/copy-from.js

@@ -0,0 +1,29 @@
+import { r as s } from "../safe-effect-Dh8uw81c.js";
+import { watchField as d } from "./watch-field.js";
+function E(l, c, m) {
+  const { when: a, fields: o = "all", transform: i, debounce: p } = m || {};
+  d(
+    l,
+    (t, n) => {
+      if (a) {
+        const f = n.form.getValue();
+        if (!a(f)) return;
+      }
+      const h = i ? i(t) : t, e = n.form.getFieldByPath(c.__path);
+      e && s(() => {
+        if (o === "all" || !o)
+          e.setValue(h, { emitEvent: !1 });
+        else {
+          const f = {};
+          o.forEach((r) => {
+            t && typeof t == "object" && (f[r] = t[r]);
+          }), "patchValue" in e && e.patchValue(f);
+        }
+      });
+    },
+    { debounce: p }
+  );
+}
+export {
+  E as copyFrom
+};

package/dist/behaviors/enable-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/enable-when'
+export {}

package/dist/behaviors/enable-when.js

@@ -0,0 +1,25 @@
+import { effect as c } from "@preact/signals-core";
+import { b } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as d } from "../safe-effect-Dh8uw81c.js";
+function h(t, n, r) {
+  const { debounce: o, resetOnDisable: a = !1 } = r || {}, i = (s, m, l) => {
+    const e = s.getFieldByPath(t.__path);
+    return e ? c(() => {
+      const f = s.value.value;
+      l(() => {
+        const u = n(f);
+        d(() => {
+          u ? e.enable() : (e.disable(), a && e.reset());
+        });
+      });
+    }) : null;
+  };
+  b().register(i, { debounce: o });
+}
+function _(t, n, r) {
+  h(t, (o) => !n(o), r);
+}
+export {
+  _ as disableWhen,
+  h as enableWhen
+};

package/dist/behaviors/reset-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/reset-when'
+export {}

package/dist/behaviors/reset-when.js

@@ -0,0 +1,24 @@
+import { effect as c } from "@preact/signals-core";
+import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as h } from "../safe-effect-Dh8uw81c.js";
+function R(r, n, o) {
+  const { debounce: s, resetValue: u = null, onlyIfDirty: a = !1 } = o || {}, i = (t, m, l) => {
+    const e = t.getFieldByPath(r.__path);
+    return e ? c(() => {
+      const f = t.value.value;
+      l(() => {
+        if (n(f)) {
+          if (a && !e.dirty.value)
+            return;
+          h(() => {
+            e.setValue(u), e.markAsPristine(), e.markAsUntouched();
+          });
+        }
+      });
+    }) : null;
+  };
+  d().register(i, { debounce: s });
+}
+export {
+  R as resetWhen
+};

package/dist/behaviors/revalidate-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/revalidate-when'
+export {}

package/dist/behaviors/revalidate-when.js

@@ -0,0 +1,18 @@
+import { effect as d } from "@preact/signals-core";
+import { b as h } from "../registry-helpers-Bv_BJ1s-.js";
+function p(o, a, i) {
+  const { debounce: l } = i || {}, u = (t, s, c) => {
+    const r = t.getFieldByPath(o.__path);
+    if (!r) return null;
+    const n = a.map((e) => t.getFieldByPath(e.__path)).filter((e) => e !== void 0);
+    return n.length === 0 ? null : d(() => {
+      n.forEach((e) => e.value.value), c(() => {
+        r.validate();
+      });
+    });
+  };
+  h().register(u, { debounce: l });
+}
+export {
+  p as revalidateWhen
+};

package/dist/behaviors/sync-fields.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/sync-fields'
+export {}

package/dist/behaviors/sync-fields.js

@@ -0,0 +1,41 @@
+import { effect as o } from "@preact/signals-core";
+import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as i } from "../safe-effect-Dh8uw81c.js";
+function E(u, f, c) {
+  const { debounce: d, transform: a } = c || {}, p = (n, h, l) => {
+    const r = n.getFieldByPath(u.__path), s = n.getFieldByPath(f.__path);
+    if (!r || !s) return null;
+    let e = !1;
+    const g = o(() => {
+      const t = r.value.value;
+      e || l(() => {
+        e = !0, i(() => {
+          try {
+            const y = a ? a(t) : t;
+            s.setValue(y, { emitEvent: !1 });
+          } finally {
+            e = !1;
+          }
+        });
+      });
+    }), m = o(() => {
+      const t = s.value.value;
+      e || l(() => {
+        e = !0, i(() => {
+          try {
+            r.setValue(t, { emitEvent: !1 });
+          } finally {
+            e = !1;
+          }
+        });
+      });
+    });
+    return () => {
+      g(), m();
+    };
+  };
+  v().register(p, { debounce: d });
+}
+export {
+  E as syncFields
+};

package/dist/behaviors/transform-value.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/transform-value'
+export {}

package/dist/behaviors/transform-value.js

@@ -0,0 +1,45 @@
+import { watchField as p } from "./watch-field.js";
+function u(e, t, o) {
+  const { onUserChangeOnly: n = !1, emitEvent: m = !0, debounce: c } = o || {};
+  p(
+    e,
+    (s, i) => {
+      const a = i.form.getFieldByPath(e.__path);
+      if (!a || n && !a.touched.value)
+        return;
+      const f = t(s);
+      f !== s && a.setValue(f, { emitEvent: m });
+    },
+    { debounce: c }
+  );
+}
+function r(e, t) {
+  return (o, n) => {
+    u(o, e, { ...t, ...n });
+  };
+}
+const h = {
+  /** Перевести в верхний регистр */
+  toUpperCase: r((e) => e?.toUpperCase()),
+  /** Перевести в нижний регистр */
+  toLowerCase: r((e) => e?.toLowerCase()),
+  /** Удалить пробелы с краев */
+  trim: r((e) => e?.trim()),
+  /** Удалить все пробелы */
+  removeSpaces: r((e) => e?.replace(/\s/g, "")),
+  /** Оставить только цифры */
+  digitsOnly: r((e) => e?.replace(/\D/g, "")),
+  /** Округлить число */
+  round: r(
+    (e) => typeof e == "number" ? Math.round(e) : e
+  ),
+  /** Округлить до 2 знаков после запятой */
+  roundTo2: r(
+    (e) => typeof e == "number" ? Math.round(e * 100) / 100 : e
+  )
+};
+export {
+  r as createTransformer,
+  u as transformValue,
+  h as transformers
+};

package/dist/behaviors/watch-field.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/watch-field'
+export {}

package/dist/behaviors/watch-field.js

@@ -0,0 +1,21 @@
+import { effect as c } from "@preact/signals-core";
+import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as i } from "../safe-effect-Dh8uw81c.js";
+function g(n, r, u) {
+  const { debounce: a, immediate: f = !1 } = u || {}, s = (l, o, m) => {
+    const e = l.getFieldByPath(n.__path);
+    return e ? (f && i(() => {
+      const t = e.value.value;
+      r(t, o);
+    }), c(() => {
+      const t = e.value.value;
+      m(() => {
+        i(() => r(t, o));
+      });
+    })) : null;
+  };
+  d().register(s, { debounce: a });
+}
+export {
+  g as watchField
+};

package/dist/behaviors.js

@@ -1,22 +1,29 @@
-import { a as s, b as r, g as t, c as o, m as l, i as h, f as n, e as i, k as m, j as p, s as c, t as d, l as f, n as F, h as y } from "./behaviors-2HSqHPb4.js";
-import { d as v, B, c as b } from "./registry-helpers-BRxAr6nG.js";
+import { a as o, b as a, i as t, t as m } from "./index-D25LsbRm.js";
+import { a as s, B as f } from "./registry-helpers-Bv_BJ1s-.js";
+import { copyFrom as n } from "./behaviors/copy-from.js";
+import { disableWhen as h, enableWhen as i } from "./behaviors/enable-when.js";
+import { computeFrom as c } from "./behaviors/compute-from.js";
+import { watchField as F } from "./behaviors/watch-field.js";
+import { revalidateWhen as v } from "./behaviors/revalidate-when.js";
+import { syncFields as b } from "./behaviors/sync-fields.js";
+import { resetWhen as g } from "./behaviors/reset-when.js";
+import { createTransformer as C, transformValue as I, transformers as P } from "./behaviors/transform-value.js";
 export {
-  v as BehaviorContextImpl,
-  B as BehaviorRegistry,
-  s as apply,
-  r as applyWhen,
-  t as computeFrom,
-  o as copyFrom,
-  b as createFieldPath,
-  l as createTransformer,
-  h as default,
-  n as disableWhen,
+  s as BehaviorContextImpl,
+  f as BehaviorRegistry,
+  o as apply,
+  a as applyWhen,
+  c as computeFrom,
+  n as copyFrom,
+  C as createTransformer,
+  t as default,
+  h as disableWhen,
   i as enableWhen,
-  m as resetWhen,
-  p as revalidateWhen,
-  c as syncFields,
-  d as toBehaviorFieldPath,
-  f as transformValue,
-  F as transformers,
-  y as watchField
+  g as resetWhen,
+  v as revalidateWhen,
+  b as syncFields,
+  m as toBehaviorFieldPath,
+  I as transformValue,
+  P as transformers,
+  F as watchField
 };

package/dist/core/behavior/behavior-context.d.ts

@@ -1,18 +1,21 @@
+import { GroupNode } from '../nodes/group-node';
+import { FormProxy } from '../types/form-proxy';
+import { FormContext } from '../types/form-context';
+import { FieldPathNode } from '../types/field-path';
 /**
- * BehaviorContext - контекст для behavior callback функций
+ * Реализация {@link FormContext} для behaviors. Создаётся фреймворком и передаётся
+ * в callback'и behaviors (`watchField`, `computeFrom`, …) — напрямую инстанцировать
+ * не нужно.
  *
- * Реализует FormContext для behavior схем
- */
-import type { GroupNode } from '../nodes/group-node';
-import type { FormProxy } from '../types/form-proxy';
-import type { FormContext } from '../types/form-context';
-import type { FieldPathNode } from '../types/field-path';
-/**
- * Реализация BehaviorContext (FormContext)
+ * @example
+ * ```typescript
+ * import { watchField } from '@reformer/core/behaviors/watch-field';
  *
- * Предоставляет:
- * - `form` - прямой типизированный доступ к форме
- * - `setFieldValue` - безопасная установка значения (emitEvent: false)
+ * watchField(path.country, (value, ctx) => {
+ *   // ctx — экземпляр BehaviorContextImpl
+ *   ctx.setFieldValue(path.city, '');
+ * });
+ * ```
  */
 export declare class BehaviorContextImpl<TForm> implements FormContext<TForm> {
     /**
@@ -30,4 +33,15 @@ export declare class BehaviorContextImpl<TForm> implements FormContext<TForm> {
      * @param value - Новое значение
      */
     setFieldValue(path: string | FieldPathNode<TForm, unknown>, value: unknown): void;
+    /**
+     * Получить поле формы по строковому пути
+     *
+     * Используется для динамического доступа к вложенным полям, например:
+     * - `ctx.getFieldByPath('address.city')` -> FieldNode
+     * - `ctx.getFieldByPath(path.city.__path)` -> FieldNode (для nested behaviors)
+     *
+     * @param path - Строковый путь к полю (например "address.city")
+     * @returns FieldNode или undefined если поле не найдено
+     */
+    getFieldByPath(path: string): import('../..').FormNode<import('../types').FormValue> | undefined;
 }

package/dist/core/behavior/behavior-registry.d.ts

@@ -1,21 +1,25 @@
+import { GroupNode } from '../nodes/group-node';
+import { BehaviorHandlerFn, BehaviorOptions } from './types';
+import { AbstractRegistry } from '../utils/abstract-registry';
+import { FormFields } from '../types';
 /**
- * BehaviorRegistry - регистрация и управление behavior схемами
- *
- * Аналогично ValidationRegistry, но для реактивного поведения форм
+ * Зарегистрированный behavior с опциями
  */
-import type { GroupNode } from '../nodes/group-node';
-import type { BehaviorHandlerFn, BehaviorOptions } from './types';
-import { FormFields } from '../types';
+export interface RegisteredBehavior {
+    /** Handler функция behavior */
+    handler: BehaviorHandlerFn<FormFields>;
+    /** Debounce в миллисекундах */
+    debounce?: number;
+}
 /**
  * Реестр behaviors для формы
  *
  * Каждый экземпляр GroupNode создает собственный реестр (композиция).
  * Устраняет race conditions и изолирует формы друг от друга.
  *
- * Context stack используется для tracking текущего активного реестра:
- * - beginRegistration() помещает this в stack
- * - endRegistration() извлекает из stack
- * - getCurrent() возвращает текущий активный реестр
+ * Наследует AbstractRegistry для унификации:
+ * - Управления global stack
+ * - Template methods begin/end registration
  *
  * @example
  * ```typescript
@@ -30,14 +34,7 @@ import { FormFields } from '../types';
  * }
  * ```
  */
-export declare class BehaviorRegistry {
-    /**
-     * Stack активных контекстов регистрации
-     * Используется для изоляции форм друг от друга
-     */
-    private static contextStack;
-    private registrations;
-    private isRegistering;
+export declare class BehaviorRegistry extends AbstractRegistry<RegisteredBehavior> {
     /**
      * Получить текущий активный реестр из context stack
      *
@@ -55,13 +52,6 @@ export declare class BehaviorRegistry {
      * ```
      */
     static getCurrent(): BehaviorRegistry | null;
-    /**
-     * Начать регистрацию behaviors
-     * Вызывается перед применением схемы
-     *
-     * Помещает this в context stack для изоляции форм
-     */
-    beginRegistration(): void;
     /**
      * Зарегистрировать behavior handler
      * Вызывается функциями из schema-behaviors.ts
@@ -80,8 +70,6 @@ export declare class BehaviorRegistry {
      * Завершить регистрацию и применить behaviors к форме
      * Создает effect подписки для всех зарегистрированных behaviors
      *
-     * Извлекает this из context stack
-     *
      * @param form - GroupNode формы
      * @returns Количество зарегистрированных behaviors и функция cleanup
      */

package/dist/core/behavior/behaviors/compute-from.d.ts

@@ -1,12 +1,5 @@
-/**
- * Вычисляемые поля
- *
- * @group Behaviors
- * @category Behavior Rules
- * @module behaviors/computeFrom
- */
-import type { FieldPathNode } from '../../types';
-import type { ComputeFromOptions } from '../types';
+import { FieldPathNode } from '../../types';
+import { ComputeFromOptions } from '../types';
 /**
  * Автоматически вычисляет значение поля на основе других полей
  *
@@ -16,26 +9,62 @@ import type { ComputeFromOptions } from '../types';
  * @param sources - Массив полей-зависимостей
  * @param target - Поле для записи результата
  * @param computeFn - Функция вычисления (принимает объект с именами полей)
- * @param options - Опции
+ * @param options - Опции (`debounce`, `condition`, `trigger`)
  *
- * @example
+ * @example Многополевой расчёт — total = price × quantity
  * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // Автоматический расчет минимального взноса
- *   computeFrom(
- *     [path.propertyValue],
- *     path.initialPayment,
- *     (values) => values.propertyValue ? values.propertyValue * 0.2 : null,
- *     { debounce: 300 }
- *   );
+ * import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
  *
- *   // Общая стоимость = цена * количество
+ * interface OrderForm {
+ *   price: number;
+ *   quantity: number;
+ *   total: number;
+ * }
+ *
+ * export const orderBehavior: BehaviorSchemaFn<OrderForm> = (path) => {
  *   computeFrom(
  *     [path.price, path.quantity],
  *     path.total,
- *     (values) => values.price * values.quantity
+ *     (values) =>
+ *       (typeof values.price === 'number' ? values.price : 0) *
+ *       (typeof values.quantity === 'number' ? values.quantity : 0),
+ *   );
+ * };
+ * ```
+ *
+ * @example Edge case — async-like дорогие вычисления с `debounce` и условием
+ * ```typescript
+ * import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface MortgageForm {
+ *   loanType: 'mortgage' | 'consumer';
+ *   loanAmount: number;
+ *   loanTerm: number;
+ *   interestRate: number;
+ *   monthlyPayment: number;
+ * }
+ *
+ * function annuity(values: MortgageForm): number {
+ *   const { loanAmount, loanTerm, interestRate } = values;
+ *   if (!loanAmount || !loanTerm || !interestRate) return 0;
+ *   const r = interestRate / 100 / 12;
+ *   const n = loanTerm;
+ *   return Math.round((loanAmount * r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1));
+ * }
+ *
+ * export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
+ *   computeFrom(
+ *     [path.loanAmount, path.loanTerm, path.interestRate],
+ *     path.monthlyPayment,
+ *     annuity,
+ *     {
+ *       debounce: 300,                                  // не пересчитываем на каждый keystroke
+ *       condition: (form) => form.loanType === 'mortgage', // считаем только для ипотеки
+ *     },
  *   );
  * };
  * ```
+ *
+ * @see [docs/llms/20-compute-vs-watch.md](../../../../docs/llms/20-compute-vs-watch.md)
  */
 export declare function computeFrom<TForm, TTarget>(sources: FieldPathNode<TForm, any>[], target: FieldPathNode<TForm, TTarget>, computeFn: (values: TForm) => TTarget, options?: ComputeFromOptions<TForm>): void;

package/dist/core/behavior/behaviors/copy-from.d.ts

@@ -1,12 +1,5 @@
-/**
- * Копирование значений между полями
- *
- * @group Behaviors
- * @category Behavior Rules
- * @module behaviors/copyFrom
- */
-import type { FieldPathNode } from '../../types';
-import type { CopyFromOptions } from '../types';
+import { FieldPathNode } from '../../types';
+import { CopyFromOptions } from '../types';
 /**
  * Копирует значения из одного поля/группы в другое при выполнении условия
  *
@@ -15,17 +8,49 @@ import type { CopyFromOptions } from '../types';
  *
  * @param source - Откуда копировать
  * @param target - Куда копировать
- * @param options - Опции копирования
+ * @param options - Опции копирования (`when`, `fields`, `transform`, `debounce`)
  *
- * @example
+ * @example Скаляр → скаляр с условием
  * ```typescript
- * const schema: BehaviorSchemaFn<MyForm> = (path) => {
- *   // Копировать адрес регистрации в адрес проживания
+ * import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface ContactForm {
+ *   sameEmail: boolean;
+ *   email: string;
+ *   emailAdditional: string;
+ * }
+ *
+ * export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
+ *   copyFrom(path.email, path.emailAdditional, {
+ *     when: (form) => form.sameEmail === true,
+ *   });
+ * };
+ * ```
+ *
+ * @example Копирование группы с подмножеством полей и `transform`
+ * ```typescript
+ * import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface Address { country: string; region: string; city: string; street: string }
+ * interface ProfileForm {
+ *   sameAsRegistration: boolean;
+ *   registrationAddress: Address;
+ *   residenceAddress: Address;
+ * }
+ *
+ * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
  *   copyFrom(path.registrationAddress, path.residenceAddress, {
  *     when: (form) => form.sameAsRegistration === true,
- *     fields: 'all'
+ *     fields: ['country', 'region', 'city'], // street НЕ копируем
+ *     transform: (addr) => ({
+ *       ...addr,
+ *       country: addr.country.toUpperCase(), // нормализация при копировании
+ *     }),
+ *     debounce: 200,
  *   });
  * };
  * ```
+ *
+ * @see [docs/llms/23-copy-from.md](../../../../docs/llms/23-copy-from.md)
  */
 export declare function copyFrom<TForm, TSource, TTarget>(source: FieldPathNode<TForm, TSource>, target: FieldPathNode<TForm, TTarget>, options?: CopyFromOptions<TSource, TForm>): void;