@reformer/core 1.0.0-beta.3

package/dist/core/validation/validators/email.js

@@ -0,0 +1,60 @@
+/**
+ * Валидатор формата email
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/email
+ */
+import { validate } from '../core/validate';
+/**
+ * Валидатор формата email
+ *
+ * Проверяет, что значение соответствует формату email адреса.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   required(path.email),
+ *   email(path.email),
+ * ]
+ *
+ * // С кастомным сообщением
+ * email(path.email, { message: 'Введите корректный email адрес' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'email',
+ *   message: 'Неверный формат email',
+ *   params: {}
+ * }
+ * ```
+ */
+export function email(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    validate(fieldPath, (value) => {
+        if (!value) {
+            return null;
+        }
+        if (!emailRegex.test(value)) {
+            return {
+                code: 'email',
+                message: options?.message || 'Неверный формат email',
+                params: options?.params,
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Reusable validators
+ */
+export { required } from './required';
+export { min } from './min';
+export { max } from './max';
+export { minLength } from './min-length';
+export { maxLength } from './max-length';
+export { email } from './email';
+export { pattern } from './pattern';
+export { url } from './url';
+export { phone, type PhoneFormat } from './phone';
+export { number } from './number';
+export { date } from './date';

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

@@ -0,0 +1,14 @@
+/**
+ * Reusable validators
+ */
+export { required } from './required';
+export { min } from './min';
+export { max } from './max';
+export { minLength } from './min-length';
+export { maxLength } from './max-length';
+export { email } from './email';
+export { pattern } from './pattern';
+export { url } from './url';
+export { phone } from './phone';
+export { number } from './number';
+export { date } from './date';

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

@@ -0,0 +1,45 @@
+/**
+ * Валидатор максимальной длины строки
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/maxLength
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Валидатор максимальной длины строки
+ *
+ * Проверяет, что длина строки не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxLen - Максимальная допустимая длина строки
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   maxLength(path.name, 50),
+ *   maxLength(path.bio, 500),
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxLength(path.bio, 500, { message: 'Максимум 500 символов' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'maxLength',
+ *   message: 'Максимальная длина: 500 символов',
+ *   params: { maxLength: 500, actualLength: 512 }
+ * }
+ * ```
+ */
+export declare function maxLength<TForm, TField extends string | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxLen: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-length.js

@@ -0,0 +1,60 @@
+/**
+ * Валидатор максимальной длины строки
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/maxLength
+ */
+import { validate } from '../core/validate';
+/**
+ * Валидатор максимальной длины строки
+ *
+ * Проверяет, что длина строки не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxLen - Максимальная допустимая длина строки
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   maxLength(path.name, 50),
+ *   maxLength(path.bio, 500),
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxLength(path.bio, 500, { message: 'Максимум 500 символов' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'maxLength',
+ *   message: 'Максимальная длина: 500 символов',
+ *   params: { maxLength: 500, actualLength: 512 }
+ * }
+ * ```
+ */
+export function maxLength(fieldPath, maxLen, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        if (!value) {
+            return null;
+        }
+        if (value.length > maxLen) {
+            return {
+                code: 'maxLength',
+                message: options?.message || `Максимальная длина: ${maxLen} символов`,
+                params: { maxLength: maxLen, actualLength: value.length, ...options?.params },
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Валидатор максимального значения
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/max
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Валидатор максимального числового значения
+ *
+ * Проверяет, что числовое значение не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `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 единиц' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'max',
+ *   message: 'Максимальное значение: 100',
+ *   params: { max: 100, actual: 150 }
+ * }
+ * ```
+ */
+export declare function max<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max.js

@@ -0,0 +1,60 @@
+/**
+ * Валидатор максимального значения
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/max
+ */
+import { validate } from '../core/validate';
+/**
+ * Валидатор максимального числового значения
+ *
+ * Проверяет, что числовое значение не превышает указанный максимум.
+ * Пустые значения пропускаются (используйте `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 единиц' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'max',
+ *   message: 'Максимальное значение: 100',
+ *   params: { max: 100, actual: 150 }
+ * }
+ * ```
+ */
+export function max(fieldPath, maxValue, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        if (value > maxValue) {
+            return {
+                code: 'max',
+                message: options?.message || `Максимальное значение: ${maxValue}`,
+                params: { max: maxValue, actual: value, ...options?.params },
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Валидатор минимальной длины строки
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/minLength
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Валидатор минимальной длины строки
+ *
+ * Проверяет, что длина строки не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `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 }
+ * }
+ * ```
+ */
+export declare function minLength<TForm, TField extends string | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, minLen: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-length.js

@@ -0,0 +1,60 @@
+/**
+ * Валидатор минимальной длины строки
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/minLength
+ */
+import { validate } from '../core/validate';
+/**
+ * Валидатор минимальной длины строки
+ *
+ * Проверяет, что длина строки не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `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 }
+ * }
+ * ```
+ */
+export function minLength(fieldPath, minLen, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        if (!value) {
+            return null;
+        }
+        if (value.length < minLen) {
+            return {
+                code: 'minLength',
+                message: options?.message || `Минимальная длина: ${minLen} символов`,
+                params: { minLength: minLen, actualLength: value.length, ...options?.params },
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Валидатор минимального значения
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/min
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Валидатор минимального числового значения
+ *
+ * Проверяет, что числовое значение не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `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 лет' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'min',
+ *   message: 'Минимальное значение: 18',
+ *   params: { min: 18, actual: 16 }
+ * }
+ * ```
+ */
+export declare function min<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, minValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min.js

@@ -0,0 +1,60 @@
+/**
+ * Валидатор минимального значения
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/min
+ */
+import { validate } from '../core/validate';
+/**
+ * Валидатор минимального числового значения
+ *
+ * Проверяет, что числовое значение не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `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 лет' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'min',
+ *   message: 'Минимальное значение: 18',
+ *   params: { min: 18, actual: 16 }
+ * }
+ * ```
+ */
+export function min(fieldPath, minValue, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        if (value === null || value === undefined) {
+            return null; // Пропускаем, если пусто (используйте required для обязательности)
+        }
+        if (value < minValue) {
+            return {
+                code: 'min',
+                message: options?.message || `Минимальное значение: ${minValue}`,
+                params: { min: minValue, actual: value, ...options?.params },
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Валидатор числовых значений
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/number
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Адаптер для number валидатора
+ * Проверяет, что значение является числом и соответствует заданным ограничениям
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * number(path.age);
+ * number(path.price, { min: 0, max: 1000000 });
+ * number(path.percentage, { min: 0, max: 100, integer: true });
+ * number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
+ * ```
+ */
+export declare function number<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Минимальное значение (включительно) */
+    min?: number;
+    /** Максимальное значение (включительно) */
+    max?: number;
+    /** Требовать целое число */
+    integer?: boolean;
+    /** Значение должно быть кратно этому числу */
+    multipleOf?: number;
+    /** Разрешить отрицательные числа (по умолчанию true) */
+    allowNegative?: boolean;
+    /** Разрешить ноль (по умолчанию true) */
+    allowZero?: boolean;
+}): void;

package/dist/core/validation/validators/number.js

@@ -0,0 +1,90 @@
+/**
+ * Валидатор числовых значений
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/number
+ */
+import { validate } from '../core/validate';
+/**
+ * Адаптер для number валидатора
+ * Проверяет, что значение является числом и соответствует заданным ограничениям
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * number(path.age);
+ * number(path.price, { min: 0, max: 1000000 });
+ * number(path.percentage, { min: 0, max: 100, integer: true });
+ * number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
+ * ```
+ */
+export function number(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        // Пропускаем null/undefined
+        if (value === null || value === undefined) {
+            return null;
+        }
+        // Проверка, что значение является числом
+        if (typeof value !== 'number' || isNaN(value)) {
+            return {
+                code: 'number',
+                message: options?.message || 'Значение должно быть числом',
+                params: options?.params,
+            };
+        }
+        // Проверка на целое число
+        if (options?.integer && !Number.isInteger(value)) {
+            return {
+                code: 'number_integer',
+                message: options?.message || 'Значение должно быть целым числом',
+                params: options?.params,
+            };
+        }
+        // Проверка минимального значения
+        if (options?.min !== undefined && value < options.min) {
+            return {
+                code: 'number_min',
+                message: options?.message || `Значение должно быть не менее ${options.min}`,
+                params: { min: options.min, ...options?.params },
+            };
+        }
+        // Проверка максимального значения
+        if (options?.max !== undefined && value > options.max) {
+            return {
+                code: 'number_max',
+                message: options?.message || `Значение должно быть не более ${options.max}`,
+                params: { max: options.max, ...options?.params },
+            };
+        }
+        // Проверка кратности
+        if (options?.multipleOf !== undefined && value % options.multipleOf !== 0) {
+            return {
+                code: 'number_multiple',
+                message: options?.message || `Значение должно быть кратно ${options.multipleOf}`,
+                params: { multipleOf: options.multipleOf, ...options?.params },
+            };
+        }
+        // Проверка отрицательных чисел
+        if (options?.allowNegative === false && value < 0) {
+            return {
+                code: 'number_negative',
+                message: options?.message || 'Отрицательные числа не допускаются',
+                params: options?.params,
+            };
+        }
+        // Проверка нуля
+        if (options?.allowZero === false && value === 0) {
+            return {
+                code: 'number_zero',
+                message: options?.message || 'Ноль не допускается',
+                params: options?.params,
+            };
+        }
+        return null;
+    });
+}