@reformer/core 1.1.0 → 2.0.0-beta.3

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

@@ -1,60 +0,0 @@
-/**
- * Валидатор максимального значения
- *
- * @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.js

@@ -1,60 +0,0 @@
-/**
- * Валидатор минимальной длины строки
- *
- * @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.js

@@ -1,60 +0,0 @@
-/**
- * Валидатор минимального значения
- *
- * @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.js

@@ -1,90 +0,0 @@
-/**
- * Валидатор числовых значений
- *
- * @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;
-    });
-}

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

@@ -1,62 +0,0 @@
-/**
- * Валидатор паттерна (регулярного выражения)
- *
- * @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.js

@@ -1,58 +0,0 @@
-/**
- * Валидатор номера телефона
- *
- * @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.js

@@ -1,69 +0,0 @@
-/**
- * Валидатор обязательного поля
- *
- * @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.js

@@ -1,55 +0,0 @@
-/**
- * Валидатор 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;
-    });
-}