@reformer/core 1.0.0-beta.3

package/dist/core/utils/type-guards.js

@@ -0,0 +1,169 @@
+/**
+ * Type Guards - централизованные функции проверки типов узлов
+ *
+ * Устраняет дублирование между form-node.ts, validation-applicator.ts и validation-context.ts
+ *
+ * @group Utilities
+ * @category Type Guards
+ *
+ * @example
+ * ```typescript
+ * import { isFieldNode, isGroupNode } from '@/core/utils/type-guards';
+ *
+ * if (isFieldNode(node)) {
+ *   // TypeScript знает, что node это FieldNode
+ *   node.validators;
+ * }
+ * ```
+ */
+/**
+ * Проверить, является ли значение любым FormNode
+ *
+ * Проверяет базовые свойства, общие для всех типов узлов
+ *
+ * @group Utilities
+ * @category Type Guards
+ *
+ * @param value - Значение для проверки
+ * @returns true если value является FormNode
+ *
+ * @example
+ * ```typescript
+ * if (isFormNode(value)) {
+ *   value.setValue(newValue);
+ *   value.validate();
+ * }
+ * ```
+ */
+export function isFormNode(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return (typeof value === 'object' &&
+        'value' in value &&
+        'setValue' in value &&
+        'getValue' in value &&
+        'validate' in value);
+}
+/**
+ * Проверить, является ли значение FieldNode (примитивное поле)
+ *
+ * FieldNode представляет примитивное поле формы (string, number, boolean и т.д.)
+ * и имеет валидаторы, но не имеет вложенных полей или элементов массива
+ *
+ * @group Utilities
+ * @category Type Guards
+ *
+ * @param value - Значение для проверки
+ * @returns true если value является FieldNode
+ *
+ * @example
+ * ```typescript
+ * if (isFieldNode(node)) {
+ *   node.validators; //  OK
+ *   node.asyncValidators; //  OK
+ *   node.markAsTouched(); //  OK
+ * }
+ * ```
+ */
+export function isFieldNode(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return (isFormNode(value) &&
+        'validators' in value &&
+        'asyncValidators' in value &&
+        // FieldNode имеет markAsTouched метод
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        typeof value.markAsTouched === 'function' &&
+        // У FieldNode нет fields или items
+        !('fields' in value) &&
+        !('items' in value));
+}
+/**
+ * Проверить, является ли значение GroupNode (объект с вложенными полями)
+ *
+ * GroupNode представляет объект с вложенными полями формы
+ * и имеет методы для применения validation/behavior схем
+ *
+ * @param value - Значение для проверки
+ * @returns true если value является GroupNode
+ *
+ * @example
+ * ```typescript
+ * if (isGroupNode(node)) {
+ *   node.applyValidationSchema(schema); //  OK
+ *   node.getFieldByPath('user.email'); //  OK
+ * }
+ * ```
+ */
+export function isGroupNode(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return (isFormNode(value) &&
+        'applyValidationSchema' in value &&
+        'applyBehaviorSchema' in value &&
+        'getFieldByPath' in value &&
+        // GroupNode НЕ имеет items/push/removeAt (это ArrayNode)
+        !('items' in value) &&
+        !('push' in value) &&
+        !('removeAt' in value));
+}
+/**
+ * Проверить, является ли значение ArrayNode (массив форм)
+ *
+ * ArrayNode представляет массив вложенных форм (обычно GroupNode)
+ * и имеет array-like методы (push, removeAt, at)
+ *
+ * @param value - Значение для проверки
+ * @returns true если value является ArrayNode
+ *
+ * @example
+ * ```typescript
+ * if (isArrayNode(node)) {
+ *   node.push(); //  OK - добавить элемент
+ *   node.removeAt(0); //  OK - удалить элемент
+ *   const item = node.at(0); //  OK - получить элемент
+ * }
+ * ```
+ */
+export function isArrayNode(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    return (isFormNode(value) &&
+        'items' in value &&
+        'length' in value &&
+        'push' in value &&
+        'removeAt' in value &&
+        'at' in value &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        typeof value.push === 'function' &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        typeof value.removeAt === 'function');
+}
+/**
+ * Получить тип узла как строку (для отладки)
+ *
+ * Полезно для логирования и отладки
+ *
+ * @param node - Узел для проверки
+ * @returns Строковое название типа узла
+ *
+ * @example
+ * ```typescript
+ * console.log('Node type:', getNodeType(node)); // "FieldNode" | "GroupNode" | "ArrayNode" | "FormNode" | "Unknown"
+ * ```
+ */
+export function getNodeType(node) {
+    if (isFieldNode(node))
+        return 'FieldNode';
+    if (isGroupNode(node))
+        return 'GroupNode';
+    if (isArrayNode(node))
+        return 'ArrayNode';
+    if (isFormNode(node))
+        return 'FormNode';
+    return 'Unknown';
+}

package/dist/core/validation/core/apply-when.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Условная валидация
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import type { FieldPath } from '../../types/field-path';
+import type { ConditionFn } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Применить валидацию только при выполнении условия
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * applyWhen(
+ *   path.loanType,
+ *   (type) => type === 'mortgage',
+ *   (path) => {
+ *     required(path.propertyValue, { message: 'Укажите стоимость' });
+ *     min(path.propertyValue, 1000000);
+ *   }
+ * );
+ * ```
+ */
+export declare function applyWhen<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, condition: ConditionFn<TField>, validationFn: (path: FieldPath<TForm>) => void): void;

package/dist/core/validation/core/apply-when.js

@@ -0,0 +1,41 @@
+/**
+ * Условная валидация
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { extractPath, createFieldPath } from '../field-path';
+import { getCurrentValidationRegistry } from '../../utils/registry-helpers';
+/**
+ * Применить валидацию только при выполнении условия
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * applyWhen(
+ *   path.loanType,
+ *   (type) => type === 'mortgage',
+ *   (path) => {
+ *     required(path.propertyValue, { message: 'Укажите стоимость' });
+ *     min(path.propertyValue, 1000000);
+ *   }
+ * );
+ * ```
+ */
+export function applyWhen(fieldPath, condition, validationFn) {
+    const path = extractPath(fieldPath);
+    // Входим в условный блок
+    getCurrentValidationRegistry().enterCondition(path, condition);
+    try {
+        // Выполняем вложенную валидацию
+        // Создаем новый FieldPath proxy для вложенной функции
+        const nestedPath = createFieldPath();
+        validationFn(nestedPath);
+    }
+    finally {
+        // Выходим из условного блока
+        getCurrentValidationRegistry().exitCondition();
+    }
+}

package/dist/core/validation/core/apply.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Композиция validation схем
+ *
+ * Предоставляет функции для переиспользования validation схем:
+ * - apply: применение схемы к полям (новый API)
+ *
+ * Дополняет существующий toFieldPath и applyWhen.
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import type { FieldPathNode, FieldPath } from '../../types';
+import type { ValidationSchemaFn } from '../../types/validation-schema';
+/**
+ * Применить validation схему к корневому path формы
+ *
+ * Используется для композиции схем на уровне всей формы.
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @param path - Корневой FieldPath формы (весь объект путей)
+ * @param validationSchema - Схема валидации
+ *
+ * @example
+ * ```typescript
+ * const creditApplicationValidation: ValidationSchemaFn<CreditApplicationForm> = (path) => {
+ *   apply(path, basicInfoValidation);
+ *   apply(path, contactInfoValidation);
+ * };
+ * ```
+ */
+export declare function apply<TForm>(path: FieldPath<TForm>, validationSchema: ValidationSchemaFn<TForm>): void;
+/**
+ * Применить validation схему к вложенному полю или полям
+ *
+ * Поддерживает:
+ * - Одно поле или массив полей
+ * - Одну схему или массив схем
+ * - Все комбинации (поле + схема, поле + схемы, поля + схема, поля + схемы)
+ *
+ * @param fields - Одно поле или массив полей
+ * @param validationSchemas - Одна схема или массив схем
+ *
+ * @example
+ * ```typescript
+ * // Одна схема к одному полю
+ * apply(path.registrationAddress, addressValidation);
+ *
+ * // Одна схема к нескольким полям
+ * apply([path.homeAddress, path.workAddress], addressValidation);
+ *
+ * // Несколько схем к одному полю
+ * apply(path.email, [emailValidation, uniqueEmailValidation]);
+ *
+ * // Несколько схем к нескольким полям
+ * apply(
+ *   [path.email, path.confirmEmail],
+ *   [emailValidation, matchValidation]
+ * );
+ * ```
+ */
+export declare function apply<TForm, TField>(fields: FieldPathNode<TForm, TField> | Array<FieldPathNode<TForm, TField> | undefined> | undefined, validationSchemas: ValidationSchemaFn<TField> | Array<ValidationSchemaFn<TField>>): void;

package/dist/core/validation/core/apply.js

@@ -0,0 +1,38 @@
+/**
+ * Композиция validation схем
+ *
+ * Предоставляет функции для переиспользования validation схем:
+ * - apply: применение схемы к полям (новый API)
+ *
+ * Дополняет существующий toFieldPath и applyWhen.
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { toFieldPath } from '../field-path';
+// Реализация
+export function apply(pathOrFields, validationSchemas) {
+    // Случай 1: FieldPath<TForm> + одна схема (композиция на уровне формы)
+    // Проверяем, является ли это FieldPath (не имеет __key и __path)
+    if (!Array.isArray(pathOrFields) &&
+        !Array.isArray(validationSchemas) &&
+        pathOrFields &&
+        !('__key' in pathOrFields) &&
+        !('__path' in pathOrFields)) {
+        const path = pathOrFields;
+        const schema = validationSchemas;
+        schema(path);
+        return;
+    }
+    // Случай 2: FieldPathNode или массив полей
+    const fieldArray = (Array.isArray(pathOrFields) ? pathOrFields : [pathOrFields]).filter(Boolean);
+    const schemaArray = Array.isArray(validationSchemas) ? validationSchemas : [validationSchemas];
+    // Применяем все схемы ко всем полям
+    for (const field of fieldArray) {
+        const nestedPath = toFieldPath(field);
+        for (const schema of schemaArray) {
+            // Type assertion: в случае 2 мы работаем только с ValidationSchemaFn<TField>
+            schema(nestedPath);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Core validation functions
+ */
+export { validate } from './validate';
+export { validateAsync } from './validate-async';
+export { validateTree } from './validate-tree';
+export { applyWhen } from './apply-when';
+export { apply } from './apply';

package/dist/core/validation/core/index.js

@@ -0,0 +1,8 @@
+/**
+ * Core validation functions
+ */
+export { validate } from './validate';
+export { validateAsync } from './validate-async';
+export { validateTree } from './validate-tree';
+export { applyWhen } from './apply-when';
+export { apply } from './apply';

package/dist/core/validation/core/validate-async.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Асинхронная валидация поля
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import type { ContextualAsyncValidatorFn, ValidateAsyncOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Зарегистрировать асинхронный валидатор для поля
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validateAsync(
+ *   path.inn,
+ *   async (ctx: ValidationContext<TForm, TField>) => {
+ *     const inn = ctx.value();
+ *     if (!inn) return null;
+ *
+ *     const response = await fetch('/api/validate-inn', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ inn }),
+ *     });
+ *
+ *     const data = await response.json();
+ *     if (!data.valid) {
+ *       return {
+ *         code: 'invalidInn',
+ *         message: 'ИНН не найден в базе данных ФНС',
+ *       };
+ *     }
+ *
+ *     return null;
+ *   },
+ *   { debounce: 1000 }
+ * );
+ * ```
+ */
+export declare function validateAsync<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, validatorFn: ContextualAsyncValidatorFn<TForm, TField>, options?: ValidateAsyncOptions): void;

package/dist/core/validation/core/validate-async.js

@@ -0,0 +1,45 @@
+/**
+ * Асинхронная валидация поля
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { extractPath } from '../field-path';
+import { getCurrentValidationRegistry } from '../../utils/registry-helpers';
+/**
+ * Зарегистрировать асинхронный валидатор для поля
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validateAsync(
+ *   path.inn,
+ *   async (ctx: ValidationContext<TForm, TField>) => {
+ *     const inn = ctx.value();
+ *     if (!inn) return null;
+ *
+ *     const response = await fetch('/api/validate-inn', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ inn }),
+ *     });
+ *
+ *     const data = await response.json();
+ *     if (!data.valid) {
+ *       return {
+ *         code: 'invalidInn',
+ *         message: 'ИНН не найден в базе данных ФНС',
+ *       };
+ *     }
+ *
+ *     return null;
+ *   },
+ *   { debounce: 1000 }
+ * );
+ * ```
+ */
+export function validateAsync(fieldPath, validatorFn, options) {
+    const path = extractPath(fieldPath);
+    getCurrentValidationRegistry().registerAsync(path, validatorFn, options);
+}

package/dist/core/validation/core/validate-tree.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Cross-field валидация
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { TreeValidatorFn, ValidateTreeOptions } from '../../types';
+/**
+ * Зарегистрировать cross-field валидатор
+ *
+ * Используется для валидации, которая зависит от нескольких полей
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validateTree(
+ *   (ctx: ValidationContext<TForm, TField>) => {
+ *     const form = ctx.formValue();
+ *     if (form.initialPayment && form.propertyValue) {
+ *       if (form.initialPayment > form.propertyValue) {
+ *         return {
+ *           code: 'initialPaymentTooHigh',
+ *           message: 'Первоначальный взнос не может превышать стоимость',
+ *         };
+ *       }
+ *     }
+ *     return null;
+ *   },
+ *   { targetField: 'initialPayment' }
+ * );
+ * ```
+ */
+export declare function validateTree<TForm>(validatorFn: TreeValidatorFn<TForm>, options?: ValidateTreeOptions): void;

package/dist/core/validation/core/validate-tree.js

@@ -0,0 +1,37 @@
+/**
+ * Cross-field валидация
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { getCurrentValidationRegistry } from '../../utils/registry-helpers';
+/**
+ * Зарегистрировать cross-field валидатор
+ *
+ * Используется для валидации, которая зависит от нескольких полей
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validateTree(
+ *   (ctx: ValidationContext<TForm, TField>) => {
+ *     const form = ctx.formValue();
+ *     if (form.initialPayment && form.propertyValue) {
+ *       if (form.initialPayment > form.propertyValue) {
+ *         return {
+ *           code: 'initialPaymentTooHigh',
+ *           message: 'Первоначальный взнос не может превышать стоимость',
+ *         };
+ *       }
+ *     }
+ *     return null;
+ *   },
+ *   { targetField: 'initialPayment' }
+ * );
+ * ```
+ */
+export function validateTree(validatorFn, options) {
+    getCurrentValidationRegistry().registerTree(validatorFn, options);
+}

package/dist/core/validation/core/validate.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Кастомная синхронная валидация поля
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import type { ContextualValidatorFn, FieldPathNode, ValidateOptions } from '../../types';
+/**
+ * Зарегистрировать кастомный синхронный валидатор для поля
+ * Поддерживает опциональные поля
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
+ *   const birthDate = new Date(ctx.value());
+ *   const age = calculateAge(birthDate);
+ *
+ *   if (age < 18) {
+ *     return {
+ *       code: 'tooYoung',
+ *       message: 'Заемщику должно быть не менее 18 лет',
+ *     };
+ *   }
+ *
+ *   return null;
+ * });
+ * ```
+ */
+export declare function validate<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, validatorFn: ContextualValidatorFn<TForm, TField>, options?: ValidateOptions): void;

package/dist/core/validation/core/validate.js

@@ -0,0 +1,38 @@
+/**
+ * Кастомная синхронная валидация поля
+ *
+ * @group Validation
+ * @category Core Functions
+ */
+import { extractPath } from '../field-path';
+import { getCurrentValidationRegistry } from '../../utils/registry-helpers';
+/**
+ * Зарегистрировать кастомный синхронный валидатор для поля
+ * Поддерживает опциональные поля
+ *
+ * @group Validation
+ * @category Core Functions
+ *
+ * @example
+ * ```typescript
+ * validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
+ *   const birthDate = new Date(ctx.value());
+ *   const age = calculateAge(birthDate);
+ *
+ *   if (age < 18) {
+ *     return {
+ *       code: 'tooYoung',
+ *       message: 'Заемщику должно быть не менее 18 лет',
+ *     };
+ *   }
+ *
+ *   return null;
+ * });
+ * ```
+ */
+export function validate(fieldPath, validatorFn, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    const path = extractPath(fieldPath);
+    getCurrentValidationRegistry().registerSync(path, validatorFn, options);
+}

package/dist/core/validation/field-path.d.ts

@@ -0,0 +1,43 @@
+/**
+ * FieldPath proxy - типобезопасный доступ к путям полей формы
+ */
+import type { FieldPath, FieldPathNode } from '../types';
+/**
+ * Создать FieldPath proxy для формы
+ *
+ * @example
+ * ```typescript
+ * const path = createFieldPath<MyForm>();
+ * console.log(path.email.__path); // 'email'
+ * console.log(path.personalData.firstName.__path); // 'personalData.firstName'
+ * ```
+ */
+export declare function createFieldPath<T>(): FieldPath<T>;
+/**
+ * Извлечь путь из FieldPathNode
+ */
+export declare function extractPath(node: FieldPathNode<unknown, unknown> | unknown): string;
+/**
+ * Преобразовать FieldPathNode в FieldPath для переиспользования схем
+ *
+ * Позволяет композировать validation schemas:
+ *
+ * @example
+ * ```typescript
+ * const personalDataValidation = (path: FieldPath<PersonalData>) => {
+ *   required(path.firstName, { message: 'Имя обязательно' });
+ *   required(path.lastName, { message: 'Фамилия обязательна' });
+ * };
+ *
+ * const mainValidation = (path: FieldPath<MyForm>) => {
+ *   //  Переиспользуем схему
+ *   personalDataValidation(toFieldPath(path.personalData));
+ *   required(path.email);
+ * };
+ * ```
+ */
+export declare function toFieldPath<T>(node: FieldPathNode<unknown, T, never> | FieldPathNode<any, T, any>): FieldPath<T>;
+/**
+ * Извлечь ключ поля из FieldPathNode
+ */
+export declare function extractKey(node: FieldPathNode<unknown, unknown> | unknown): string;