@reformer/core 5.0.2 → 7.0.0-beta.1

package/dist/core/validation/validators/max.d.ts

@@ -1,38 +1,16 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор максимального числового значения
+ * Фабрика валидатора максимального числового значения.
  *
- * Проверяет, что числовое значение не превышает указанный максимум.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param maxValue - Максимально допустимое значение
- * @param options - Опции валидации (message, params)
- *
  * @example
  * ```typescript
- * // Базовое использование
- * validationSchema: (path) => [
- *   max(path.quantity, 100),
- *   max(path.discount, 50),
- * ]
- *
- * // С кастомным сообщением
- * max(path.quantity, 100, { message: 'Максимум 100 единиц' })
- * ```
+ * import { validate } from '@reformer/core';
+ * import { max } from '@reformer/core/validators';
  *
- * @example
- * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'max',
- *   message: 'Максимальное значение: 100',
- *   params: { max: 100, actual: 150 }
- * }
+ * validate(path.quantity, max(100));
+ * validate(path.discount, max(50, { message: 'Не более 50%' }));
  * ```
  */
-export declare function max<TForm, TField extends number | null | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxValue: number, options?: ValidateOptions): void;
+export declare function max<TForm = unknown, TField extends number | undefined = number>(maxValue: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/min-age.d.ts

@@ -1,36 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Проверяет, что возраст (вычисленный из даты рождения) не меньше указанного
+ * Фабрика валидатора минимального возраста (по дате рождения).
  *
- * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
- *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации (дата рождения)
- * @param minAgeValue - Минимально допустимый возраст в годах
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Базовое использование - минимум 18 лет
- * validationSchema: (path) => [
- *   minAge(path.birthDate, 18),
- * ]
- *
- * // С кастомным сообщением
- * minAge(path.birthDate, 21, { message: 'Вам должно быть не менее 21 года' })
- * ```
+ * Пустые и невалидные даты пропускаются.
  *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'date_min_age',
- *   message: 'Минимальный возраст: 18 лет',
- *   params: { minAge: 18, currentAge: 16 }
- * }
+ * validate(path.birthDate, minAge(18));
+ * validate(path.birthDate, minAge(21, { message: 'Вам должно быть не менее 21 года' }));
  * ```
  */
-export declare function minAge<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minAgeValue: number, options?: ValidateOptions): void;
+export declare function minAge<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(minAgeValue: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/min-date.d.ts

@@ -1,36 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Проверяет, что дата не раньше указанной минимальной
+ * Фабрика валидатора минимальной даты (включительно).
  *
- * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
- *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param minDateValue - Минимально допустимая дата (включительно)
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Базовое использование
- * validationSchema: (path) => [
- *   minDate(path.eventDate, new Date('2024-01-01')),
- * ]
- *
- * // С кастомным сообщением
- * minDate(path.startDate, new Date(), { message: 'Дата должна быть не раньше сегодня' })
- * ```
+ * Пустые и невалидные даты пропускаются (используйте `required` и `isDate`).
  *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'date_min',
- *   message: 'Дата должна быть не ранее 01.01.2024',
- *   params: { minDate: Date }
- * }
+ * validate(path.eventDate, minDate(new Date('2024-01-01')));
+ * validate(path.startDate, minDate(new Date(), { message: 'Дата должна быть не раньше сегодня' }));
  * ```
  */
-export declare function minDate<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minDateValue: Date, options?: ValidateOptions): void;
+export declare function minDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(minDateValue: Date, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/min-length.d.ts

@@ -1,38 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор минимальной длины строки
+ * Фабрика валидатора минимальной длины строки или массива.
  *
- * Проверяет, что длина строки не меньше указанного минимума.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param minLen - Минимальная допустимая длина строки
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Базовое использование
- * validationSchema: (path) => [
- *   minLength(path.name, 2),
- *   minLength(path.password, 8),
- * ]
- *
- * // С кастомным сообщением
- * minLength(path.password, 8, { message: 'Пароль должен быть не менее 8 символов' })
- * ```
- *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'minLength',
- *   message: 'Минимальная длина: 8 символов',
- *   params: { minLength: 8, actualLength: 3 }
- * }
+ * validate(path.name, minLength(2));
+ * validate(path.password, minLength(8, { message: 'Min 8 символов' }));
  * ```
  */
-export declare function minLength<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, minLen: number, options?: ValidateOptions): void;
+export declare function minLength<TForm = unknown, TField = unknown>(minLen: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/min.d.ts

@@ -1,38 +1,16 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор минимального числового значения
+ * Фабрика валидатора минимального числового значения.
  *
- * Проверяет, что числовое значение не меньше указанного минимума.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param minValue - Минимально допустимое значение
- * @param options - Опции валидации (message, params)
- *
  * @example
  * ```typescript
- * // Базовое использование
- * validationSchema: (path) => [
- *   min(path.age, 18),
- *   min(path.quantity, 1),
- * ]
- *
- * // С кастомным сообщением
- * min(path.age, 18, { message: 'Вам должно быть не менее 18 лет' })
- * ```
+ * import { validate } from '@reformer/core';
+ * import { min } from '@reformer/core/validators';
  *
- * @example
- * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'min',
- *   message: 'Минимальное значение: 18',
- *   params: { min: 18, actual: 16 }
- * }
+ * validate(path.age, min(18));
+ * validate(path.quantity, min(1, { message: 'Минимум 1' }));
  * ```
  */
-export declare function min<TForm, TField extends number | null | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, minValue: number, options?: ValidateOptions): void;
+export declare function min<TForm = unknown, TField extends number | undefined = number>(minValue: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/multiple-of.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число кратно заданному.
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.price, multipleOf(0.01));
+ * validate(path.rating, multipleOf(0.5, { message: 'Только шаг 0.5' }));
+ * ```
+ */
+export declare function multipleOf<TForm = unknown, TField extends number | undefined = number>(divisor: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/non-negative.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число неотрицательное (`≥ 0`).
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.quantity, nonNegative());
+ * validate(path.balance, nonNegative({ message: 'Баланс не может быть отрицательным' }));
+ * ```
+ */
+export declare function nonNegative<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/non-zero.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число не равно нулю.
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.quantity, nonZero());
+ * validate(path.divisor, nonZero({ message: 'Не может быть нулём' }));
+ * ```
+ */
+export declare function nonZero<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/past-date.d.ts

@@ -1,35 +1,12 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Проверяет, что дата находится в прошлом (не в будущем)
+ * Фабрика валидатора, проверяющего что дата не в будущем.
  *
- * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
- *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Базовое использование - дата рождения не может быть в будущем
- * validationSchema: (path) => [
- *   pastDate(path.birthDate),
- * ]
- *
- * // С кастомным сообщением
- * pastDate(path.birthDate, { message: 'Дата рождения не может быть в будущем' })
- * ```
+ * Пустые и невалидные даты пропускаются.
  *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'date_future',
- *   message: 'Дата не может быть в будущем',
- *   params: {}
- * }
+ * validate(path.birthDate, pastDate({ message: 'Дата рождения не может быть в будущем' }));
  * ```
  */
-export declare function pastDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;
+export declare function pastDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/pattern.d.ts

@@ -1,40 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор паттерна (регулярного выражения)
+ * Фабрика валидатора регулярного выражения.
  *
- * Проверяет, что значение соответствует указанному регулярному выражению.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param regex - Регулярное выражение для проверки
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Только буквы
- * pattern(path.name, /^[а-яА-Яa-zA-Z]+$/)
- *
- * // Только цифры
- * pattern(path.code, /^\d+$/)
- *
- * // С кастомным сообщением
- * pattern(path.username, /^[a-z0-9_]+$/i, {
- *   message: 'Только латинские буквы, цифры и подчёркивание'
- * })
- * ```
- *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'pattern',
- *   message: 'Значение не соответствует требуемому формату',
- *   params: { pattern: '^[a-z]+$' }
- * }
+ * validate(path.name, pattern(/^[а-яА-Яa-zA-Z]+$/));
+ * validate(path.code, pattern(/^\d+$/, { message: 'Только цифры' }));
  * ```
  */
-export declare function pattern<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, regex: RegExp, options?: ValidateOptions): void;
+export declare function pattern<TForm = unknown, TField extends string | undefined = string>(regex: RegExp, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/phone.d.ts

@@ -1,27 +1,17 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
-/**
- * Формат телефона для валидации
- *
- * @group Validation
- * @category Validators
- */
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
+export interface PhoneValidatorOptions extends ValidateOptions {
+    format?: PhoneFormat;
+}
 /**
- * Адаптер для phone валидатора
- * Поддерживает опциональные поля (string | undefined)
+ * Фабрика валидатора номера телефона.
  *
- * @group Validation
- * @category Validators
+ * Пустые значения пропускаются (используйте `required` для обязательности).
  *
  * @example
  * ```typescript
- * phone(path.phoneNumber);
- * phone(path.phoneNumber, { format: 'ru' });
- * phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+ * validate(path.phone, phone());
+ * validate(path.phone, phone({ format: 'ru' }));
  * ```
  */
-export declare function phone<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
-    /** Формат телефона */
-    format?: PhoneFormat;
-}): void;
+export declare function phone<TForm = unknown, TField extends string | undefined = string>(options?: PhoneValidatorOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/required.d.ts

@@ -1,41 +1,20 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор обязательного поля
+ * Фабрика валидатора обязательного поля.
+ *
+ * Возвращает чистую функцию-валидатор `(value, control, root)`. Передаётся в `validate()`.
  *
- * Проверяет, что поле имеет непустое значение.
  * Пустыми считаются: `null`, `undefined`, `''` (пустая строка).
  * Для boolean полей требуется значение `true`.
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param options - Опции валидации (message, params)
- *
  * @example
  * ```typescript
- * // Базовое использование
- * validationSchema: (path, { validate }) => [
- *   required(path.name),
- *   required(path.email),
- * ]
- *
- * // С кастомным сообщением
- * required(path.phone, { message: 'Укажите номер телефона' })
+ * import { validate } from '@reformer/core';
+ * import { required } from '@reformer/core/validators';
  *
- * // Для checkbox (требует true)
- * required(path.agreeToTerms, { message: 'Необходимо принять условия' })
- * ```
- *
- * @example
- * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'required',
- *   message: 'Поле обязательно для заполнения',
- *   params: {}
- * }
+ * validate(path.email, required());
+ * validate(path.phone, required({ message: 'Укажите номер телефона' }));
+ * validate(path.agreeToTerms, required({ message: 'Необходимо принять условия' }));
  * ```
  */
-export declare function required<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;
+export declare function required<TForm = unknown, TField = unknown>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/url.d.ts

@@ -1,22 +1,20 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+export interface UrlValidatorOptions extends ValidateOptions {
+    /** Требовать наличие протокола (http:// или https://) */
+    requireProtocol?: boolean;
+    /** Разрешенные протоколы */
+    allowedProtocols?: string[];
+}
 /**
- * Адаптер для URL валидатора
- * Поддерживает опциональные поля (string | undefined)
+ * Фабрика валидатора URL.
  *
- * @group Validation
- * @category Validators
+ * Пустые значения пропускаются (используйте `required` для обязательности).
  *
  * @example
  * ```typescript
- * url(path.website);
- * url(path.website, { message: 'Введите корректный URL' });
- * url(path.website, { requireProtocol: true });
+ * validate(path.website, url());
+ * validate(path.website, url({ requireProtocol: true }));
+ * validate(path.website, url({ allowedProtocols: ['https'] }));
  * ```
  */
-export declare function url<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
-    /** Требовать наличие протокола (http:// или https://) */
-    requireProtocol?: boolean;
-    /** Разрешенные протоколы */
-    allowedProtocols?: string[];
-}): void;
+export declare function url<TForm = unknown, TField extends string | undefined = string>(options?: UrlValidatorOptions): Validator<TForm, TField>;

package/dist/index.d.ts

@@ -1,17 +1,16 @@
 export * from './core/types';
 export * from './core/factories';
 export * from './core/utils';
+export * from './core/model';
 export { FormNode } from './core/nodes/form-node';
 export { FieldNode } from './core/nodes/field-node';
 export { GroupNode } from './core/nodes/group-node';
 export { ArrayNode } from './core/nodes/array-node';
+export { ModelArrayNode } from './core/nodes/model-array-node';
+export type { ModelArrayControl } from './core/nodes/model-array-node';
 export type { SetValueOptions } from './core/nodes/form-node';
 export { useFormControl } from './hooks/useFormControl';
 export { useFormControlValue } from './hooks/useFormControlValue';
 export { useArrayLength } from './hooks/useArrayLength';
-export { useHiddenCondition } from './hooks/useHiddenCondition';
 export type { FieldControlState, ArrayControlState } from './hooks/types';
-export type { BehaviorSchemaFn } from './core/behavior/types';
-export { validateForm } from './core/validation/validate-form';
-export * as behaviors from './core/behavior';
 export * as validators from './core/validation';