@reformer/core 1.0.0-beta.3

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

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

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

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

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

@@ -0,0 +1,34 @@
+/**
+ * Валидатор номера телефона
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/phone
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Формат телефона для валидации
+ *
+ * @group Validation
+ * @category Validators
+ */
+export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
+/**
+ * Адаптер для phone валидатора
+ * Поддерживает опциональные поля (string | undefined)
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * phone(path.phoneNumber);
+ * phone(path.phoneNumber, { format: 'ru' });
+ * phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+ * ```
+ */
+export declare function phone<TForm, TField extends string | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Формат телефона */
+    format?: PhoneFormat;
+}): void;

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

@@ -0,0 +1,58 @@
+/**
+ * Валидатор номера телефона
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/phone
+ */
+import { validate } from '../core/validate';
+/**
+ * Адаптер для phone валидатора
+ * Поддерживает опциональные поля (string | undefined)
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * phone(path.phoneNumber);
+ * phone(path.phoneNumber, { format: 'ru' });
+ * phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+ * ```
+ */
+export function phone(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    const format = options?.format || 'any';
+    // Регулярные выражения для разных форматов
+    const patterns = {
+        // Международный формат: +1234567890 или +1 234 567 8900
+        international: /^\+?[1-9]\d{1,14}$/,
+        // Российский формат: +7 (XXX) XXX-XX-XX, 8 (XXX) XXX-XX-XX, и вариации
+        ru: /^(\+7|7|8)?[\s\-]?\(?[489][0-9]{2}\)?[\s\-]?[0-9]{3}[\s\-]?[0-9]{2}[\s\-]?[0-9]{2}$/,
+        // US формат: (123) 456-7890, 123-456-7890, 1234567890
+        us: /^(\+?1)?[\s\-]?\(?[2-9]\d{2}\)?[\s\-]?\d{3}[\s\-]?\d{4}$/,
+        // Любой формат: минимум 10 цифр с возможными разделителями
+        any: /^[\+]?[(]?[0-9]{1,4}[)]?[-\s\.]?[(]?[0-9]{1,4}[)]?[-\s\.]?[0-9]{1,9}$/,
+    };
+    validate(fieldPath, (value) => {
+        if (!value) {
+            return null;
+        }
+        const regex = patterns[format];
+        if (!regex.test(value)) {
+            const formatMessages = {
+                international: 'Введите телефон в международном формате (например, +1234567890)',
+                ru: 'Введите российский номер телефона (например, +7 900 123-45-67)',
+                us: 'Введите американский номер телефона (например, (123) 456-7890)',
+                any: 'Неверный формат телефона',
+            };
+            return {
+                code: 'phone',
+                message: options?.message || formatMessages[format],
+                params: { format, ...options?.params },
+            };
+        }
+        return null;
+    });
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Валидатор обязательного поля
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/required
+ */
+import type { ValidateOptions } from '../../types/validation-schema';
+import type { FieldPathNode } from '../../types';
+/**
+ * Валидатор обязательного поля
+ *
+ * Проверяет, что поле имеет непустое значение.
+ * Пустыми считаются: `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: 'Укажите номер телефона' })
+ *
+ * // Для checkbox (требует true)
+ * required(path.agreeToTerms, { message: 'Необходимо принять условия' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'required',
+ *   message: 'Поле обязательно для заполнения',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function required<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

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

@@ -0,0 +1,69 @@
+/**
+ * Валидатор обязательного поля
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/required
+ */
+import { validate } from '../core/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: 'Укажите номер телефона' })
+ *
+ * // Для checkbox (требует true)
+ * required(path.agreeToTerms, { message: 'Необходимо принять условия' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'required',
+ *   message: 'Поле обязательно для заполнения',
+ *   params: {}
+ * }
+ * ```
+ */
+export function required(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    validate(fieldPath, (value) => {
+        // Проверка на пустое значение
+        if (value === null || value === undefined || value === '') {
+            return {
+                code: 'required',
+                message: options?.message || 'Поле обязательно для заполнения',
+                params: options?.params,
+            };
+        }
+        // Для булевых значений требуем true
+        if (typeof value === 'boolean' && value !== true) {
+            return {
+                code: 'required',
+                message: options?.message || 'Поле обязательно для заполнения',
+                params: options?.params,
+            };
+        }
+        return null;
+    });
+}

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * Валидатор URL
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/url
+ */
+import { validate } from '../core/validate';
+/**
+ * Адаптер для URL валидатора
+ * Поддерживает опциональные поля (string | undefined)
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * url(path.website);
+ * url(path.website, { message: 'Введите корректный URL' });
+ * url(path.website, { requireProtocol: true });
+ * ```
+ */
+export function url(fieldPath, options) {
+    if (!fieldPath)
+        return; // Защита от undefined fieldPath
+    // URL regex с опциональным протоколом
+    const urlRegexWithProtocol = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i;
+    const urlRegexRequireProtocol = /^https?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/i;
+    validate(fieldPath, (value) => {
+        if (!value) {
+            return null;
+        }
+        const regex = options?.requireProtocol ? urlRegexRequireProtocol : urlRegexWithProtocol;
+        if (!regex.test(value)) {
+            return {
+                code: 'url',
+                message: options?.message || 'Неверный формат URL',
+                params: options?.params,
+            };
+        }
+        // Проверка разрешенных протоколов
+        if (options?.allowedProtocols && options.allowedProtocols.length > 0) {
+            const hasAllowedProtocol = options.allowedProtocols.some((protocol) => value.toLowerCase().startsWith(`${protocol}://`));
+            if (!hasAllowedProtocol) {
+                return {
+                    code: 'url_protocol',
+                    message: options?.message ||
+                        `URL должен использовать один из протоколов: ${options.allowedProtocols.join(', ')}`,
+                    params: { allowedProtocols: options.allowedProtocols, ...options?.params },
+                };
+            }
+        }
+        return null;
+    });
+}