@reformer/core 2.0.1 → 3.0.0

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

@@ -4,7 +4,7 @@
  * Реализует FormContext для behavior схем
  */
 import type { GroupNode } from '../nodes/group-node';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormProxy } from '../types/form-proxy';
 import type { FormContext } from '../types/form-context';
 import type { FieldPathNode } from '../types/field-path';
 /**
@@ -18,7 +18,7 @@ export declare class BehaviorContextImpl<TForm> implements FormContext<TForm> {
     /**
      * Форма с типизированным Proxy-доступом к полям
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     private _form;
     constructor(form: GroupNode<TForm>);
     /**

package/dist/core/context/form-context-impl.d.ts

@@ -5,7 +5,7 @@
  */
 import type { GroupNode } from '../nodes/group-node';
 import type { FormContext } from '../types/form-context';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormProxy } from '../types/form-proxy';
 /**
  * Базовая реализация FormContext
  *
@@ -17,7 +17,7 @@ export declare class FormContextImpl<TForm> implements FormContext<TForm> {
     /**
      * Форма с типизированным Proxy-доступом к полям
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     protected readonly _groupNode: GroupNode<TForm>;
     constructor(groupNode: GroupNode<TForm>);
     /**

package/dist/core/nodes/array-node.d.ts

@@ -12,7 +12,7 @@ import type { ReadonlySignal } from '@preact/signals-core';
 import { FormNode, type SetValueOptions } from './form-node';
 import type { FieldStatus, ValidationError, FormFields } from '../types';
 import type { FormSchema } from '../types/deep-schema';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormProxy } from '../types/form-proxy';
 /**
  * ArrayNode - массив форм с реактивным состоянием
  *
@@ -76,7 +76,7 @@ export declare class ArrayNode<T extends FormFields> extends FormNode<T[]> {
      * @param index - Индекс элемента
      * @returns Типизированный GroupNode или undefined если индекс вне границ
      */
-    at(index: number): GroupNodeWithControls<T> | undefined;
+    at(index: number): FormProxy<T> | undefined;
     getValue(): T[];
     setValue(values: T[], options?: SetValueOptions): void;
     patchValue(values: (T | undefined)[]): void;
@@ -158,13 +158,13 @@ export declare class ArrayNode<T extends FormFields> extends FormNode<T[]> {
      * Итерировать по элементам массива
      * @param callback - Функция, вызываемая для каждого элемента с типизированным GroupNode
      */
-    forEach(callback: (item: GroupNodeWithControls<T>, index: number) => void): void;
+    forEach(callback: (item: FormProxy<T>, index: number) => void): void;
     /**
      * Маппинг элементов массива
      * @param callback - Функция преобразования с типизированным GroupNode
      * @returns Новый массив результатов
      */
-    map<R>(callback: (item: GroupNodeWithControls<T>, index: number) => R): R[];
+    map<R>(callback: (item: FormProxy<T>, index: number) => R): R[];
     /**
      * Создать новый элемент массива на основе схемы
      * @param initialValue - Начальные значения

package/dist/core/nodes/group-node.d.ts

@@ -13,7 +13,7 @@
 import type { ReadonlySignal } from '@preact/signals-core';
 import { FormNode, type SetValueOptions } from './form-node';
 import type { ValidationError, FieldStatus, ValidationSchemaFn, ValidatorRegistration, FormSchema, GroupNodeConfig, FormValue } from '../types';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormProxy } from '../types/form-proxy';
 import type { BehaviorSchemaFn } from '../behavior/types';
 /**
  * GroupNode - узел для группы полей
@@ -184,7 +184,7 @@ export declare class GroupNode<T> extends FormNode<T> {
      * console.log(proxy.email.value); // Прямой доступ к полю
      * ```
      */
-    getProxy(): GroupNodeWithControls<T>;
+    getProxy(): FormProxy<T>;
     /**
      * Получить все поля формы как итератор
      */

package/dist/core/types/form-context.d.ts

@@ -22,7 +22,7 @@
  * });
  * ```
  */
-import type { GroupNodeWithControls } from './group-node-proxy';
+import type { FormProxy } from './form-proxy';
 import type { FieldPathNode } from './field-path';
 /**
  * Единый контекст для работы с формой
@@ -62,7 +62,7 @@ export interface FormContext<TForm> {
      * ctx.form.items.clear()
      * ```
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     /**
      * Безопасно установить значение поля по строковому пути или FieldPath
      *

package/dist/core/types/{group-node-proxy.d.ts → form-proxy.d.ts}

@@ -1,5 +1,5 @@
 /**
- * Типы для Proxy-доступа к полям GroupNode
+ * Типы для Proxy-доступа к полям формы
  *
  * Решает проблему типизации, когда GroupNode<T> использует Proxy для прямого доступа к полям.
  * TypeScript не может автоматически определить правильные типы для вложенных форм и массивов.
@@ -16,7 +16,7 @@
  *   items: Array<{ title: string }>;
  * }
  *
- * const form: GroupNodeWithControls<MyForm> = new GroupNode(schema);
+ * const form: FormProxy<MyForm> = new GroupNode(schema);
  *
  * //  TypeScript знает, что это FieldNode<string>
  * form.name.setValue('John');
@@ -36,9 +36,9 @@ type ArrayNode<_T> = any;
  * Мапит тип модели данных T на правильные типы узлов формы
  *
  * Рекурсивно определяет типы узлов на основе структуры данных:
- * - `T[K] extends Array<infer U>` где U - объект → `ArrayNodeWithControls<U>`
+ * - `T[K] extends Array<infer U>` где U - объект → `FormArrayProxy<U>`
  * - `T[K] extends Array<infer U>` где U - примитив → `FieldNode<T[K]>` (массив как обычное поле)
- * - `T[K] extends object` → `GroupNodeWithControls<T[K]>` (вложенная форма с типизацией)
+ * - `T[K] extends object` → `FormProxy<T[K]>` (вложенная форма с типизацией)
  * - `T[K]` примитив → `FieldNode<T[K]>` (простое поле)
  *
  * Использует NonNullable для правильной обработки опциональных полей
@@ -48,8 +48,8 @@ type ArrayNode<_T> = any;
  *
  * @template T - Тип модели данных формы
  */
-export type FormNodeControls<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends Array<infer U> ? U extends FormFields ? ArrayNodeWithControls<U> : FieldNode<T[K]> : NonNullable<T[K]> extends FormFields ? NonNullable<T[K]> extends Date | File | Blob ? FieldNode<T[K]> : GroupNodeWithControls<NonNullable<T[K]>> : FieldNode<T[K]>;
+export type FormControlsProxy<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends Array<infer U> ? U extends FormFields ? FormArrayProxy<U> : FieldNode<T[K]> : NonNullable<T[K]> extends FormFields ? NonNullable<T[K]> extends Date | File | Blob ? FieldNode<T[K]> : FormProxy<NonNullable<T[K]>> : FieldNode<T[K]>;
 };
 /**
  * Комбинированный тип для GroupNode с Proxy доступом к полям
@@ -72,7 +72,7 @@ export type FormNodeControls<T> = {
  *   };
  * }
  *
- * const form: GroupNodeWithControls<UserForm> = new GroupNode(schema);
+ * const form: FormProxy<UserForm> = new GroupNode(schema);
  *
  * // Доступ к методам GroupNode
  * await form.validate();
@@ -84,7 +84,7 @@ export type FormNodeControls<T> = {
  * form.profile.name.setValue('John');
  * ```
  */
-export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
+export type FormProxy<T> = GroupNode<T> & FormControlsProxy<T>;
 /**
  * Комбинированный тип для ArrayNode с Proxy доступом к элементам
  *
@@ -102,7 +102,7 @@ export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
  *   completed: boolean;
  * }
  *
- * const todos: ArrayNodeWithControls<TodoItem> = new ArrayNode(schema);
+ * const todos: FormArrayProxy<TodoItem> = new ArrayNode(schema);
  *
  * // Доступ к методам ArrayNode
  * todos.push({ title: 'New todo', completed: false });
@@ -117,19 +117,19 @@ export type GroupNodeWithControls<T> = GroupNode<T> & FormNodeControls<T>;
  * });
  * ```
  */
-export type ArrayNodeWithControls<T extends FormFields> = ArrayNode<T> & {
+export type FormArrayProxy<T extends FormFields> = ArrayNode<T> & {
     /**
      * Безопасный доступ к элементу массива по индексу
      * Возвращает GroupNode с типизированными полями или undefined
      */
-    at(index: number): GroupNodeWithControls<T> | undefined;
+    at(index: number): FormProxy<T> | undefined;
     /**
      * Итерация по элементам массива с типизированными элементами
      */
-    forEach(callback: (item: GroupNodeWithControls<T>, index: number) => void): void;
+    forEach(callback: (item: FormProxy<T>, index: number) => void): void;
     /**
      * Маппинг элементов массива с типизированными элементами
      */
-    map<R>(callback: (item: GroupNodeWithControls<T>, index: number) => R): R[];
+    map<R>(callback: (item: FormProxy<T>, index: number) => R): R[];
 };
 export {};

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

@@ -64,7 +64,7 @@ export type { FieldPath, FieldPathNode } from '../types/field-path';
 export type { ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions, ValidationSchemaFn, ValidatorRegistration, } from './validation-schema';
 export type { FormSchema, ArrayConfig } from './deep-schema';
 export type { FormContext } from './form-context';
-export type { FormNodeControls, GroupNodeWithControls, ArrayNodeWithControls, } from './group-node-proxy';
+export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy';
 import type { BehaviorSchemaFn } from '../behavior/types';
 import type { FormSchema } from './deep-schema';
 import type { ValidationSchemaFn } from './validation-schema';

package/dist/core/utils/create-form.d.ts

@@ -2,20 +2,20 @@
  * Фабричная функция для создания формы с правильной типизацией
  *
  * Решает проблему с типизацией конструктора GroupNode, который возвращает
- * Proxy (GroupNodeWithControls), но TypeScript не может это вывести автоматически.
+ * Proxy (FormProxy), но TypeScript не может это вывести автоматически.
  *
  * @group Utilities
  *
  * @example
  * ```typescript
  * // Вместо:
- * const form: GroupNodeWithControls<MyForm> = new GroupNode<MyForm>(config);
+ * const form: FormProxy<MyForm> = new GroupNode<MyForm>(config);
  *
  * // Используйте:
  * const form = createForm<MyForm>(config);
  * ```
  */
-import type { GroupNodeWithControls, GroupNodeConfig, FormSchema } from '../types';
+import type { FormProxy, GroupNodeConfig, FormSchema } from '../types';
 /**
  * Создать форму с полной конфигурацией (form, behavior, validation)
  *
@@ -43,7 +43,7 @@ import type { GroupNodeWithControls, GroupNodeConfig, FormSchema } from '../type
  * form.email.setValue('test@mail.com');
  * ```
  */
-export declare function createForm<T>(config: GroupNodeConfig<T>): GroupNodeWithControls<T>;
+export declare function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
 /**
  * Создать форму только со схемой полей (обратная совместимость)
  *
@@ -58,4 +58,4 @@ export declare function createForm<T>(config: GroupNodeConfig<T>): GroupNodeWith
  * });
  * ```
  */
-export declare function createForm<T>(schema: FormSchema<T>): GroupNodeWithControls<T>;
+export declare function createForm<T>(schema: FormSchema<T>): FormProxy<T>;

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

@@ -3,7 +3,7 @@
  */
 import type { GroupNode } from '../nodes/group-node';
 import type { FieldNode } from '../nodes/field-node';
-import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormProxy } from '../types/form-proxy';
 import type { FormContext } from '../types/form-context';
 /**
  * Реализация контекста валидации для отдельного поля
@@ -15,7 +15,7 @@ export declare class ValidationContextImpl<TForm, TField> implements FormContext
     /**
      * Форма с типизированным Proxy-доступом к полям
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     constructor(form: GroupNode<TForm>, _fieldKey: keyof TForm, control: FieldNode<TField>);
     /**
      * Получить текущее значение поля (внутренний метод для validation-applicator)
@@ -37,7 +37,7 @@ export declare class TreeValidationContextImpl<TForm> implements FormContext<TFo
     /**
      * Форма с типизированным Proxy-доступом к полям
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     constructor(form: GroupNode<TForm>);
     /**
      * Безопасно установить значение поля по строковому пути
@@ -55,7 +55,7 @@ export declare class ArrayValidationContextImpl<TForm, TItem> implements FormCon
     /**
      * Форма с типизированным Proxy-доступом к полям
      */
-    readonly form: GroupNodeWithControls<TForm>;
+    readonly form: FormProxy<TForm>;
     constructor(form: GroupNode<TForm>, _fieldKey: keyof TForm, arrayValue: TItem[]);
     /**
      * Получить текущее значение массива (для валидатора)

package/llms.txt

@@ -7,7 +7,7 @@
 | What                                                                                        | Where                       |
 | ------------------------------------------------------------------------------------------- | --------------------------- |
 | `createForm`, `useFormControl`, `useFormControlValue`, `validateForm`                       | `@reformer/core`            |
-| `ValidationSchemaFn`, `BehaviorSchemaFn`, `FieldPath`, `GroupNodeWithControls`, `FieldNode` | `@reformer/core`            |
+| `ValidationSchemaFn`, `BehaviorSchemaFn`, `FieldPath`, `FormProxy`, `FieldNode` | `@reformer/core`            |
 | `FormSchema`, `FieldConfig`, `ArrayNode`                                                    | `@reformer/core`            |
 | `required`, `min`, `max`, `minLength`, `maxLength`, `email`                                 | `@reformer/core/validators` |
 | `pattern`, `url`, `phone`, `number`, `date`                                                 | `@reformer/core/validators` |
@@ -48,7 +48,7 @@ const { value, errors, disabled } = useFormControl(control.loanType);
 ```typescript
 import { createForm, useFormControl } from '@reformer/core';
 import { required, email } from '@reformer/core/validators';
-import type { GroupNodeWithControls } from '@reformer/core';
+import type { FormProxy } from '@reformer/core';
 
 // 1. Define form type
 interface ContactForm {
@@ -105,7 +105,7 @@ function ContactFormComponent() {
 
 // 4. Pass form to child components via props (NOT context!)
 interface FormStepProps {
-  form: GroupNodeWithControls<ContactForm>;
+  form: FormProxy<ContactForm>;
 }
 
 function FormStep({ form }: FormStepProps) {
@@ -218,7 +218,7 @@ transformers.trim, transformers.toUpperCase, transformers.toLowerCase, transform
 
 // BehaviorContext interface:
 interface BehaviorContext<TForm> {
-  form: GroupNodeWithControls<TForm>;            // Form proxy with typed field access
+  form: FormProxy<TForm>;            // Form proxy with typed field access
   setFieldValue: (path: string, value: any) => void;
   // To READ field values, use: ctx.form.fieldName.value.value
 }
@@ -374,7 +374,7 @@ import type {
   ValidationSchemaFn,
   BehaviorSchemaFn,
   FieldPath,
-  GroupNodeWithControls,
+  FormProxy,
   FieldNode,
 } from '@reformer/core';
 
@@ -536,13 +536,13 @@ form.items.push({ id: '1', name: 'Item' }); // Array operations
 ### createForm Returns a Proxy
 
 ```typescript
-// createForm() returns GroupNodeWithControls<T> (a Proxy wrapper around GroupNode)
+// createForm() returns FormProxy<T> (a Proxy wrapper around GroupNode)
 // This enables type-safe field access:
 const form = createForm<MyForm>({...});
 
 form.email           // FieldNode<string> - TypeScript knows the type!
 form.address.city    // FieldNode<string> - nested access works
-form.items.at(0)     // GroupNodeWithControls<ItemType> - array items
+form.items.at(0)     // FormProxy<ItemType> - array items
 
 // IMPORTANT: Proxy doesn't pass instanceof checks!
 // Use type guards instead:
@@ -1014,7 +1014,7 @@ function ShadcnFormField({ control, label }: FormFieldProps<string>) {
 | `FieldSchema` | `FieldConfig<T>` | Type for individual field config |
 | `when()` | `applyWhen()` | Conditional validation function |
 | `FormFields` | `FieldNode<T>` | Type for field nodes |
-| `FormInstance<T>` | `GroupNodeWithControls<T>` | Form type for component props |
+| `FormInstance<T>` | `FormProxy<T>` | Form type for component props |
 | `useArrayField()` | `form.items.push/map/removeAt` | Use ArrayNode methods directly |
 | `FormProvider` | `<Component form={form} />` | Pass form via props, no context |
 | `formState` | `form.valid`, `form.dirty`, etc. | Separate signals on form |
@@ -1183,8 +1183,8 @@ const first = form.items[0];        // undefined or error
 const second = form.items[1];       // undefined or error
 
 // CORRECT - use .at() method
-const first = form.items.at(0);     // GroupNodeWithControls<ItemType> | undefined
-const second = form.items.at(1);    // GroupNodeWithControls<ItemType> | undefined
+const first = form.items.at(0);     // FormProxy<ItemType> | undefined
+const second = form.items.at(1);    // FormProxy<ItemType> | undefined
 
 // CORRECT - iterate with map (most common pattern)
 form.items.map((item, index) => {
@@ -1217,7 +1217,7 @@ form.items.at(index);                               // Get item at index (NOT it
 ### Rendering Arrays
 
 ```tsx
-function ItemsList({ form }: { form: GroupNodeWithControls<MyForm> }) {
+function ItemsList({ form }: { form: FormProxy<MyForm> }) {
   const { length } = useFormControl(form.items);
 
   return (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reformer/core",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Reactive form state management library for React with signals-based architecture",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,6 +24,7 @@
   "scripts": {
     "generate:llms": "npx tsx scripts/generate-llms.ts",
     "build": "npm run generate:llms && vite build && tsc -p tsconfig.json",
+    "build:stackblitz": "vite build && tsc -p tsconfig.json",
     "dev": "vite",
     "test": "vitest",
     "test:watch": "vitest watch"