@reformer/core 1.1.0-beta.3 → 1.1.0-beta.4

package/dist/validators.js

@@ -1,44 +1,45 @@
-import { h as g, t as o, j as f, a as x, G as y, A } from "./node-factory-D7DOnSSN.js";
-import { T as G, V as U, k as B } from "./node-factory-D7DOnSSN.js";
-import { g as u, V as w } from "./create-field-path-CdPF3lIK.js";
-function m(r, e, a) {
+import { h as c, t as l, j as i } from "./node-factory-DYXIgJmW.js";
+import { T as H, V as P, k as W, v as j } from "./node-factory-DYXIgJmW.js";
+import { g as u } from "./create-field-path-DcXDTWil.js";
+import { V as M } from "./create-field-path-DcXDTWil.js";
+function n(r, e, a) {
   if (!r) return;
-  const t = g(r);
-  u().registerSync(t, e, a);
+  const m = c(r);
+  u().registerSync(m, e, a);
 }
-function D(r, e, a) {
-  const t = g(r);
-  u().registerAsync(t, e, a);
+function A(r, e, a) {
+  const m = c(r);
+  u().registerAsync(m, e, a);
 }
-function b(r, e) {
+function _(r, e) {
   u().registerTree(r, e);
 }
-function R(r, e) {
+function $(r, e) {
   if (!Array.isArray(r) && !Array.isArray(e) && r && !("__key" in r) && !("__path" in r)) {
     e(r);
     return;
   }
   const a = (Array.isArray(r) ? r : [r]).filter(
     Boolean
-  ), t = Array.isArray(e) ? e : [e];
-  for (const n of a) {
-    const s = o(n);
-    for (const c of t)
-      c(s);
+  ), m = Array.isArray(e) ? e : [e];
+  for (const s of a) {
+    const t = l(s);
+    for (const g of m)
+      g(t);
   }
 }
-function p(r, e, a) {
-  const t = g(r);
-  u().enterCondition(t, e);
+function o(r, e, a) {
+  const m = c(r);
+  u().enterCondition(m, e);
   try {
-    const n = f();
-    a(n);
+    const s = i();
+    a(s);
   } finally {
     u().exitCondition();
   }
 }
-function N(r, e) {
-  r && m(r, (a) => a == null || a === "" ? {
+function w(r, e) {
+  r && n(r, (a) => a == null || a === "" ? {
     code: "required",
     message: e?.message || "Поле обязательно для заполнения",
     params: e?.params
@@ -48,55 +49,55 @@ function N(r, e) {
     params: e?.params
   } : null);
 }
-function L(r, e, a) {
-  r && m(r, (t) => t == null ? null : t < e ? {
+function D(r, e, a) {
+  r && n(r, (m) => m == null ? null : m < e ? {
     code: "min",
     message: a?.message || `Минимальное значение: ${e}`,
-    params: { min: e, actual: t, ...a?.params }
+    params: { min: e, actual: m, ...a?.params }
   } : null);
 }
-function C(r, e, a) {
-  r && m(r, (t) => t == null ? null : t > e ? {
+function h(r, e, a) {
+  r && n(r, (m) => m == null ? null : m > e ? {
     code: "max",
     message: a?.message || `Максимальное значение: ${e}`,
-    params: { max: e, actual: t, ...a?.params }
+    params: { max: e, actual: m, ...a?.params }
   } : null);
 }
-function _(r, e, a) {
-  r && m(r, (t) => t && t.length < e ? {
+function d(r, e, a) {
+  r && n(r, (m) => m && m.length < e ? {
     code: "minLength",
     message: a?.message || `Минимальная длина: ${e} символов`,
-    params: { minLength: e, actualLength: t.length, ...a?.params }
+    params: { minLength: e, actualLength: m.length, ...a?.params }
   } : null);
 }
-function T(r, e, a) {
-  r && m(r, (t) => t && t.length > e ? {
+function b(r, e, a) {
+  r && n(r, (m) => m && m.length > e ? {
     code: "maxLength",
     message: a?.message || `Максимальная длина: ${e} символов`,
-    params: { maxLength: e, actualLength: t.length, ...a?.params }
+    params: { maxLength: e, actualLength: m.length, ...a?.params }
   } : null);
 }
-function V(r, e) {
+function L(r, e) {
   if (!r) return;
   const a = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  m(r, (t) => t ? a.test(t) ? null : {
+  n(r, (m) => m ? a.test(m) ? null : {
     code: "email",
     message: e?.message || "Неверный формат email",
     params: e?.params
   } : null);
 }
-function q(r, e, a) {
-  r && m(r, (t) => t ? e.test(t) ? null : {
+function R(r, e, a) {
+  r && n(r, (m) => m ? e.test(m) ? null : {
     code: "pattern",
     message: a?.message || "Значение не соответствует требуемому формату",
     params: { pattern: e.source, ...a?.params }
   } : null);
 }
-function z(r, e) {
+function T(r, e) {
   if (!r) return;
-  const a = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i, t = /^https?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i;
-  m(r, (n) => n ? (e?.requireProtocol ? t : a).test(n) ? e?.allowedProtocols && e.allowedProtocols.length > 0 && !e.allowedProtocols.some(
-    (l) => n.toLowerCase().startsWith(`${l}://`)
+  const a = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i, m = /^https?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i;
+  n(r, (s) => s ? (e?.requireProtocol ? m : a).test(s) ? e?.allowedProtocols && e.allowedProtocols.length > 0 && !e.allowedProtocols.some(
+    (f) => s.toLowerCase().startsWith(`${f}://`)
   ) ? {
     code: "url_protocol",
     message: e?.message || `URL должен использовать один из протоколов: ${e.allowedProtocols.join(", ")}`,
@@ -107,9 +108,9 @@ function z(r, e) {
     params: e?.params
   } : null);
 }
-function I(r, e) {
+function C(r, e) {
   if (!r) return;
-  const a = e?.format || "any", t = {
+  const a = e?.format || "any", m = {
     // Международный формат: +1234567890 или +1 234 567 8900
     international: /^\+?[1-9]\d{1,14}$/,
     // Российский формат: +7 (XXX) XXX-XX-XX, 8 (XXX) XXX-XX-XX, и вариации
@@ -119,11 +120,11 @@ function I(r, e) {
     // Любой формат: минимум 10 цифр с возможными разделителями
     any: /^[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,9}$/
   };
-  m(r, (n) => {
-    if (!n)
+  n(r, (s) => {
+    if (!s)
       return null;
-    if (!t[a].test(n)) {
-      const c = {
+    if (!m[a].test(s)) {
+      const g = {
         international: "Введите телефон в международном формате (например, +1234567890)",
         ru: "Введите российский номер телефона (например, +7 900 123-45-67)",
         us: "Введите американский номер телефона (например, (123) 456-7890)",
@@ -131,15 +132,15 @@ function I(r, e) {
       };
       return {
         code: "phone",
-        message: e?.message || c[a],
+        message: e?.message || g[a],
         params: { format: a, ...e?.params }
       };
     }
     return null;
   });
 }
-function P(r, e) {
-  r && m(r, (a) => a == null ? null : typeof a != "number" || isNaN(a) ? {
+function N(r, e) {
+  r && n(r, (a) => a == null ? null : typeof a != "number" || isNaN(a) ? {
     code: "number",
     message: e?.message || "Значение должно быть числом",
     params: e?.params
@@ -169,130 +170,114 @@ function P(r, e) {
     params: e?.params
   } : null);
 }
-function H(r, e) {
-  r && m(r, (a) => {
+function q(r, e) {
+  r && n(r, (a) => {
     if (!a)
       return null;
-    let t;
+    let m;
     if (a instanceof Date)
-      t = a;
+      m = a;
     else if (typeof a == "string")
-      t = new Date(a);
+      m = new Date(a);
     else
       return {
         code: "date_invalid",
         message: e?.message || "Неверный формат даты",
         params: e?.params
       };
-    if (isNaN(t.getTime()))
+    if (isNaN(m.getTime()))
       return {
         code: "date_invalid",
         message: e?.message || "Неверный формат даты",
         params: e?.params
       };
-    const n = /* @__PURE__ */ new Date();
-    if (n.setHours(0, 0, 0, 0), e?.minDate) {
-      const s = new Date(e.minDate);
-      if (s.setHours(0, 0, 0, 0), t < s)
+    const s = /* @__PURE__ */ new Date();
+    if (s.setHours(0, 0, 0, 0), e?.minDate) {
+      const t = new Date(e.minDate);
+      if (t.setHours(0, 0, 0, 0), m < t)
         return {
           code: "date_min",
-          message: e?.message || `Дата должна быть не ранее ${s.toLocaleDateString()}`,
+          message: e?.message || `Дата должна быть не ранее ${t.toLocaleDateString()}`,
           params: { minDate: e.minDate, ...e?.params }
         };
     }
     if (e?.maxDate) {
-      const s = new Date(e.maxDate);
-      if (s.setHours(0, 0, 0, 0), t > s)
+      const t = new Date(e.maxDate);
+      if (t.setHours(0, 0, 0, 0), m > t)
         return {
           code: "date_max",
-          message: e?.message || `Дата должна быть не позднее ${s.toLocaleDateString()}`,
+          message: e?.message || `Дата должна быть не позднее ${t.toLocaleDateString()}`,
           params: { maxDate: e.maxDate, ...e?.params }
         };
     }
-    if (e?.noFuture && t > n)
+    if (e?.noFuture && m > s)
       return {
         code: "date_future",
         message: e?.message || "Дата не может быть в будущем",
         params: e?.params
       };
-    if (e?.noPast && t < n)
+    if (e?.noPast && m < s)
       return {
         code: "date_past",
         message: e?.message || "Дата не может быть в прошлом",
         params: e?.params
       };
     if (e?.minAge !== void 0 || e?.maxAge !== void 0) {
-      const s = Math.floor(
-        (n.getTime() - t.getTime()) / 315576e5
+      const t = Math.floor(
+        (s.getTime() - m.getTime()) / 315576e5
       );
-      if (e?.minAge !== void 0 && s < e.minAge)
+      if (e?.minAge !== void 0 && t < e.minAge)
         return {
           code: "date_min_age",
           message: e?.message || `Минимальный возраст: ${e.minAge} лет`,
-          params: { minAge: e.minAge, currentAge: s, ...e?.params }
+          params: { minAge: e.minAge, currentAge: t, ...e?.params }
         };
-      if (e?.maxAge !== void 0 && s > e.maxAge)
+      if (e?.maxAge !== void 0 && t > e.maxAge)
         return {
           code: "date_max_age",
           message: e?.message || `Максимальный возраст: ${e.maxAge} лет`,
-          params: { maxAge: e.maxAge, currentAge: s, ...e?.params }
+          params: { maxAge: e.maxAge, currentAge: t, ...e?.params }
         };
     }
     return null;
   });
 }
-function M(r, e) {
-  r && _(r, 1, {
+function z(r, e) {
+  r && d(r, 1, {
     message: e?.message || "Массив не должен быть пустым",
     params: { minLength: 1, ...e?.params }
   });
 }
-function W(r, e) {
+function I(r, e) {
   if (!r) return;
-  const a = g(r);
+  const a = c(r);
   u().registerArrayItemValidation(a, e);
 }
-function i(r) {
-  return r instanceof x ? [r] : r instanceof y ? Array.from(r.getAllFields()).flatMap(i) : r instanceof A ? r.map((e) => i(e)).flat() : [];
-}
-async function j(r, e) {
-  const a = new w();
-  a.beginRegistration();
-  let t = [], n = !1;
-  try {
-    const s = f();
-    e(s), t = a.getCurrentContext()?.getValidators() || [], a.cancelRegistration(), n = !0, r.clearErrors();
-    const l = i(r);
-    return await Promise.all(l.map((d) => d.validate())), t.length > 0 && await r.applyContextualValidators(t), r.valid.value;
-  } catch (s) {
-    throw n || a.cancelRegistration(), s;
-  }
-}
 export {
-  G as TreeValidationContextImpl,
-  U as ValidationContextImpl,
-  w as ValidationRegistry,
-  R as apply,
-  p as applyWhen,
-  f as createFieldPath,
-  H as date,
-  V as email,
-  B as extractKey,
-  g as extractPath,
-  C as max,
-  T as maxLength,
-  L as min,
-  _ as minLength,
-  M as notEmpty,
-  P as number,
-  q as pattern,
-  I as phone,
-  N as required,
-  o as toFieldPath,
-  z as url,
-  m as validate,
-  D as validateAsync,
+  H as TreeValidationContextImpl,
+  P as ValidationContextImpl,
+  M as ValidationRegistry,
+  $ as apply,
+  o as applyWhen,
+  i as createFieldPath,
+  q as date,
+  L as email,
+  W as extractKey,
+  c as extractPath,
+  h as max,
+  b as maxLength,
+  D as min,
+  d as minLength,
+  z as notEmpty,
+  N as number,
+  R as pattern,
+  C as phone,
+  w as required,
+  l as toFieldPath,
+  T as url,
+  n as validate,
+  A as validateAsync,
   j as validateForm,
-  W as validateItems,
-  b as validateTree
+  I as validateItems,
+  _ as validateTree
 };

package/llms.txt

@@ -6,7 +6,7 @@
 
 | What                                                                                        | Where                       |
 | ------------------------------------------------------------------------------------------- | --------------------------- |
-| `createForm`, `useFormControl`, `useFormControlValue`                                       | `@reformer/core`            |
+| `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`                       | `@reformer/core`            |
 | `ValidationSchemaFn`, `BehaviorSchemaFn`, `FieldPath`, `GroupNodeWithControls`, `FieldNode` | `@reformer/core`            |
 | `FormSchema`, `FieldConfig`, `ArrayNode`                                                    | `@reformer/core`            |
 | `required`, `min`, `max`, `minLength`, `maxLength`, `email`                                 | `@reformer/core/validators` |
@@ -23,6 +23,26 @@
 - Optional strings: `string` (empty string by default)
 - Do NOT add `[key: string]: unknown` to form interfaces
 
+### React Hooks Comparison (CRITICALLY IMPORTANT)
+
+| Hook | Return Type | Subscribes To | Use Case |
+|------|-------------|---------------|----------|
+| `useFormControl(field)` | `{ value, errors, disabled, touched, ... }` | All signals | Full field state, form inputs |
+| `useFormControlValue(field)` | `T` (value directly) | Only value signal | Conditional rendering |
+
+⚠️ **CRITICAL**: Do NOT destructure `useFormControlValue`! It returns `T` directly, NOT `{ value: T }`.
+
+```typescript
+// ❌ WRONG - will always be undefined!
+const { value: loanType } = useFormControlValue(control.loanType);
+
+// ✅ CORRECT
+const loanType = useFormControlValue(control.loanType);
+
+// ✅ CORRECT - useFormControl returns object, destructuring OK
+const { value, errors, disabled } = useFormControl(control.loanType);
+```
+
 ## 2. API SIGNATURES
 
 ### Validators
@@ -89,7 +109,7 @@ transformers.trim, transformers.toUpperCase, transformers.toLowerCase, transform
 interface BehaviorContext<TForm> {
   form: GroupNodeWithControls<TForm>;            // Form proxy with typed field access
   setFieldValue: (path: string, value: any) => void;
-  getFieldValue: (path: string) => unknown;
+  // ⚠️ To READ field values, use: ctx.form.fieldName.value.value
 }
 ```
 
@@ -121,6 +141,35 @@ const { value } = useFormControl(form.field as FieldNode<ExpectedType>);
 
 ## 4. ⚠️ COMMON MISTAKES
 
+### useFormControlValue (CRITICAL)
+
+```typescript
+// ❌ WRONG - useFormControlValue returns T directly, NOT { value: T }
+const { value: loanType } = useFormControlValue(control.loanType);
+// Result: loanType is ALWAYS undefined! Conditional rendering will fail.
+
+// ✅ CORRECT
+const loanType = useFormControlValue(control.loanType);
+
+// ✅ ALSO CORRECT - useFormControl returns object
+const { value, errors } = useFormControl(control.loanType);
+```
+
+### Reading Field Values in BehaviorContext (CRITICAL)
+
+```typescript
+// ❌ WRONG - getFieldValue does NOT exist!
+watchField(path.amount, (amount, ctx) => {
+  const rate = ctx.getFieldValue('rate'); // ERROR: Property 'getFieldValue' does not exist
+});
+
+// ✅ CORRECT - use ctx.form.fieldName.value.value
+watchField(path.amount, (amount, ctx) => {
+  const rate = ctx.form.rate.value.value;  // Read via signal
+  ctx.setFieldValue('total', amount * rate);
+});
+```
+
 ### Validators
 
 ```typescript
@@ -642,3 +691,193 @@ const schema: FormSchema<MyForm> = {
   },
 };
 ```
+
+## 16. READING FIELD VALUES (CRITICALLY IMPORTANT)
+
+### Why .value.value?
+
+ReFormer uses `@preact/signals-core` for reactivity:
+- `field.value` → `Signal<T>` (reactive container)
+- `field.value.value` → `T` (actual value)
+- `field.getValue()` → `T` (shorthand method, non-reactive)
+
+```typescript
+// Reading values in different contexts:
+
+// In React components - use hooks
+const { value } = useFormControl(control.email);     // Object with value
+const email = useFormControlValue(control.email);    // Value directly
+
+// In BehaviorContext (watchField, etc.)
+watchField(path.firstName, (firstName, ctx) => {
+  // ⚠️ ctx.form is typed as the PARENT GROUP of the watched field!
+  // For path.nested.field: ctx.form = NestedType, NOT RootForm!
+
+  const lastName = ctx.form.lastName.value.value;  // Read sibling field
+
+  // Use setFieldValue with full path for root-level fields
+  ctx.setFieldValue('fullName', `${firstName} ${lastName}`);
+});
+
+// Direct access on form controls
+form.email.value.value;           // Read current value
+form.address.city.value.value;    // Read nested value
+```
+
+### Reading Nested Values in watchField
+
+```typescript
+// ⚠️ IMPORTANT: ctx.form type depends on the watched path!
+
+// Watching root-level field
+watchField(path.loanAmount, (amount, ctx) => {
+  // ctx.form is MyForm - can access all fields
+  const rate = ctx.form.interestRate.value.value;
+  ctx.setFieldValue('monthlyPayment', amount * rate / 12);
+});
+
+// Watching nested field
+watchField(path.personalData.lastName, (lastName, ctx) => {
+  // ctx.form is PersonalData, NOT MyForm!
+  const firstName = ctx.form.firstName.value.value;   // ✅ Works
+  const middleName = ctx.form.middleName.value.value; // ✅ Works
+
+  // For root-level field, use setFieldValue with full path
+  ctx.setFieldValue('fullName', `${lastName} ${firstName}`);
+});
+```
+
+## 17. COMPUTE FROM vs WATCH FIELD
+
+### computeFrom - Same Nesting Level Only
+
+```typescript
+// ✅ Works: all source fields and target at same level
+computeFrom(
+  [path.price, path.quantity],
+  path.total,
+  ({ price, quantity }) => (price || 0) * (quantity || 0)
+);
+
+// ✅ Works: all nested at same level
+computeFrom(
+  [path.address.houseNumber, path.address.streetName],
+  path.address.fullAddress,
+  ({ houseNumber, streetName }) => `${houseNumber} ${streetName}`
+);
+
+// ❌ FAILS: different nesting levels
+computeFrom(
+  [path.nested.price, path.nested.quantity],
+  path.rootTotal,  // Different level - won't work!
+  ...
+);
+```
+
+### watchField - Any Level
+
+```typescript
+// ✅ Works for cross-level computation
+watchField(path.nested.price, (price, ctx) => {
+  const quantity = ctx.form.quantity.value.value;  // Sibling in nested
+  ctx.setFieldValue('rootTotal', price * quantity); // Full path to root
+});
+
+// ✅ Works for multiple dependencies
+watchField(path.loanAmount, (amount, ctx) => {
+  const term = ctx.form.loanTerm.value.value;
+  const rate = ctx.form.interestRate.value.value;
+
+  if (amount && term && rate) {
+    const monthly = calculateMonthlyPayment(amount, term, rate);
+    ctx.setFieldValue('monthlyPayment', monthly);
+  }
+});
+```
+
+### Rule of Thumb
+
+| Scenario | Use |
+|----------|-----|
+| All fields share same parent | `computeFrom` (simpler, auto-cleanup) |
+| Fields at different levels | `watchField` (more flexible) |
+| Multiple dependencies | `watchField` |
+| Async computation | `watchField` with async callback |
+
+## 18. ARRAY OPERATIONS
+
+### Array Methods
+
+```typescript
+// Add items
+form.items.push({ name: '', price: 0 });           // Add to end
+form.items.insert(0, { name: '', price: 0 });      // Insert at index
+
+// Remove items
+form.items.removeAt(index);                         // Remove by index
+form.items.clear();                                 // Remove all items
+
+// Reorder
+form.items.move(fromIndex, toIndex);                // Move item
+
+// Access
+form.items.length.value;                            // Current length (Signal)
+form.items.map((item, index) => ...);               // Iterate items
+form.items.at(index);                               // Get item at index
+```
+
+### Rendering Arrays
+
+```tsx
+function ItemsList({ form }: { form: GroupNodeWithControls<MyForm> }) {
+  const { length } = useFormControl(form.items);
+
+  return (
+    <div>
+      {form.items.map((item, index) => (
+        // item is GroupNode (sub-form) - each field is a control
+        <div key={item.id || index}>
+          <FormField control={item.name} />
+          <FormField control={item.price} />
+          <button onClick={() => form.items.removeAt(index)}>Remove</button>
+        </div>
+      ))}
+
+      {length === 0 && <p>No items yet</p>}
+
+      <button onClick={() => form.items.push({ name: '', price: 0 })}>
+        Add Item
+      </button>
+    </div>
+  );
+}
+```
+
+### Array Cross-Validation
+
+```typescript
+// Validate uniqueness across array items
+validateTree((ctx: { form: MyForm }) => {
+  const items = ctx.form.items;
+  const names = items.map(item => item.name.value.value);
+  const uniqueNames = new Set(names);
+
+  if (names.length !== uniqueNames.size) {
+    return { code: 'duplicate', message: 'Item names must be unique' };
+  }
+  return null;
+}, { targetField: 'items' });
+
+// Validate sum of percentages
+validateTree((ctx: { form: MyForm }) => {
+  const items = ctx.form.items;
+  const totalPercent = items.reduce(
+    (sum, item) => sum + (item.percentage.value.value || 0),
+    0
+  );
+
+  if (Math.abs(totalPercent - 100) > 0.01) {
+    return { code: 'invalid_total', message: 'Percentages must sum to 100%' };
+  }
+  return null;
+}, { targetField: 'items' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reformer/core",
-  "version": "1.1.0-beta.3",
+  "version": "1.1.0-beta.4",
   "description": "Reactive form state management library for React with signals-based architecture",
   "type": "module",
   "main": "./dist/index.js",