@astral/validations 3.0.0-beta.1 → 3.0.0-beta.4

package/README.md

@@ -19,6 +19,7 @@
   - [number](#number)
     - [min](#min-number)
     - [max](#max-number)
+    - [integer](#integer)
   - [string](#string)
     - [min](#min-string)
     - [max](#max-string)
@@ -85,7 +86,8 @@ import {
   string,
   optional,
   min,
-  number
+  number,
+  toPrettyError,
 } from '@astral/validations';
 
 type Permission = {
@@ -124,13 +126,15 @@ validate({
   },
 });
 
-// Error in info.permissions.0.description: Обязательно
-validate({
-  name: 'Vasya',
-  info: {
-    permissions: [{ id: 1 }],
-  },
-});
+// { info: { permissions: [{ description: 'Обязательно' }] } }
+toPrettyError(
+  validate({
+    name: 'Vasya',
+    info: {
+        permissions: [{ id: 1 }],
+    },
+  })
+);
 ```
 
 Валидация отдельных value
@@ -233,6 +237,27 @@ validate(10)
 
 ---
 
+### integer
+
+Проверяет является ли значение целым числом.
+
+```ts
+import { number, integer } from '@astral/validations';
+
+const validate = number(integer(5));
+
+// undefined
+validate(5)
+
+// undefined
+validate(7)
+
+// { message: 'Только целые числа' }
+validate(3.14)
+```
+
+---
+
 ## string
 
 - Возвращает ошибку если:
@@ -636,7 +661,8 @@ import {
   string,
   optional,
   min,
-  number
+  number,
+  toPrettyError
 } from '@astral/validations';
 
 type User = {
@@ -670,13 +696,15 @@ validate({
   },
 });
 
-// Error in info.permissions.0.description: Обязательно
-validate({
-  name: 'Vasya',
-  info: {
-    permissions: [{ id: 1 }],
-  },
-});
+// { info: { permissions: [{ description: 'Обязательно' }] } }
+toPrettyError(
+  validate({
+    name: 'Vasya',
+    info: {
+      permissions: [{ id: 1 }],
+    },
+  })
+);
 ```
 
 ### partial
@@ -684,7 +712,7 @@ validate({
 Позволяет сделать все поля объекта optional.
 
 ```ts
-import { partial, object, string } from '@astral/validations';
+import { partial, object, string, toPrettyError } from '@astral/validations';
 
 type Values = {
   name: string;
@@ -696,8 +724,10 @@ const validateRequired = object<Values>({
   surname: string()
 })
 
-// { message: 'Ошибка в свойстве name: Обязательно' }
-validateRequired({});
+// { name: 'Обязательно' }
+toPrettyError(
+  validateRequired({})
+);
 
 const validatePartial = partial(
   object<Values>({
@@ -778,7 +808,8 @@ validate({
 import {
   array,
   arrayItem,
-  min
+  min,
+  toPrettyError
 } from '@astral/validations';
 
 type User = {
@@ -802,8 +833,10 @@ validate([{ name: 'Vasya' }]);
 // { message: 'Не меньше: 1' }
 validate([]);
 
-// { cause: { errorArray: [{ name: { message: 'Не является строкой' } }] } }
-validate([{ name: 22 }]);
+// [{ name: 'Не является строкой' }]
+toPrettyError(
+  validate([{ name: 22 }])
+);
 ```
 
 ### arrayItem
@@ -811,7 +844,7 @@ validate([{ name: 22 }]);
 Применяет переданные правила валидации к каждому элементу массива.
 
 ```ts
-import { array, arrayItem, object, string, optional } from '@astral/validations';
+import { array, arrayItem, object, string, optional, toPrettyError } from '@astral/validations';
 
 type User = {
   name: string;
@@ -831,16 +864,20 @@ const validate = array(
 validate([{ name: 'Vasya' }]);
 
 // { cause: { errorArray: [{ name: { message: 'Не является строкой' } }] } }
-validate([{ name: 22 }]);
+toPrettyError(
+  validate([{ name: 22 }])
+);
 ```
 
 ```ts
-import { array, arrayItem, string, min } from '@astral/validations';
+import { array, arrayItem, string, min, toPrettyError } from '@astral/validations';
 
 const validate = array(arrayItem(string(min(3))));
 
-// { cause: { arrayError: [undefined, { message: 'Мин. символов: 3' }] } }
-validate(['vasya', 'ma']);
+// [undefined, 'Мин. символов: 3']
+toPrettyError(
+  validate(['vasya', 'ma'])
+);
 ```
 
 ---
@@ -890,7 +927,7 @@ type Values = { name: string; isAgree: boolean };
 
 const validate = object<Values, Values>({
   name: when({
-    is: (_, ctx) => ctx.global.values.isAgree,
+    is: (_, ctx) => Boolean(ctx.global.values.isAgree),
     then: string(),
     otherwise: any(),
   }),
@@ -898,10 +935,12 @@ const validate = object<Values, Values>({
 });
 
 // undefined
-const result1 = validate({ isAgree: false, name: '' });
+validate({ isAgree: false, name: '' });
 
-// Required error для name
-const result2 = validate({ isAgree: true, name: '' });
+// { name: 'Обязательно' }
+toPrettyError(
+  validate({ isAgree: true, name: '' })
+);
 ```
 
 ---
@@ -937,14 +976,14 @@ validateCustomString(20);
 ## Базовый пример
 
 ```ts
-import { string, object } from '@astral/validations';
+import { string, object, toPrettyError } from '@astral/validations';
 
 type Values = {
   name: string;
   nickname: string;
 };
 
-const validate = object<Values>({
+const validate = object<Values, Values>({
   name: string(),
   nickname: string((value, ctx) => {
     if (value.includes('_')) {
@@ -958,8 +997,10 @@ const validate = object<Values>({
   }),
 });
 
-// { cause: { errorMap: { nickname: { message: 'Символ "_" запрещен', code: 'nickname-symbol' } } } }
-validate({ name: 'Vasya', nickname: 'va_sya' });
+// { nickname: 'Символ "_" запрещен' }
+toPrettyError(
+  validate({ name: 'Vasya', nickname: 'va_sya' })
+);
 ```
 
 ## Связанные поля
@@ -967,7 +1008,7 @@ validate({ name: 'Vasya', nickname: 'va_sya' });
 В ```ctx.global.values``` находится value, принятое самым верхнеуровневым guard'ом.
 
 ```ts
-import { object, string } from '@astral/validations';
+import { object, string, toPrettyError } from '@astral/validations';
 
 type Values = {
   password: string;
@@ -976,7 +1017,7 @@ type Values = {
 
 const validate = object<Values, Values>({
   password: string(min(9)),
-  repeatPassword: string<Values>(min(9), (value, ctx) => {
+  repeatPassword: string(min(9), (value, ctx) => {
     if (value !== ctx.global.values.password) {
       return ctx.createError({
         message: 'Пароли не совпадают',
@@ -988,8 +1029,10 @@ const validate = object<Values, Values>({
   }),
 });
 
-// Error.message "Пароли не совпадают" для repeatPassword 
-validate({ password: 'qywerty123', repeatPassword: 'qywerty1234' });
+// { repeatPassword: 'Пароли не совпадают' } 
+toPrettyError(
+  validate({ password: 'qywerty123', repeatPassword: 'qywerty1234' })
+);
 ```
 
 ## Переиспользуемое правило
@@ -1069,7 +1112,7 @@ type Values = { name: string; isAgree: boolean };
 
 const validate = object<Values, Values>({
   name: when({
-    is: (_, ctx) => ctx.global.values.isAgree,
+    is: (_, ctx) => Boolean(ctx.global.values.isAgree),
     then: string(),
     otherwise: any(),
   }),
@@ -1077,10 +1120,12 @@ const validate = object<Values, Values>({
 });
 
 // undefined
-const result1 = validate({ isAgree: false, name: '' });
+validate({ isAgree: false, name: '' });
 
-// Required error для name
-const result2 = validate({ isAgree: true, name: '' });
+// { name: 'Обязательно' }
+toPrettyError(
+  validate({ isAgree: true, name: '' })
+);
 ```
 
 When для ветки объекта:
@@ -1094,19 +1139,20 @@ type Values = {
 
 const validate = object<Values, Values>({
   name: string(),
-  info: when<Values>({
+  info: when({
     is: (_, ctx) => ctx.global.values.name === 'Vasya',
     then: object<ValuesInfo>({ surname: string() }),
     otherwise: any(),
   }),
 });
 
-// Error.message "Обязательно" для info
-validate({ name: 'Vasya' });
+// { info: 'Обязательно' }
+toPrettyError(
+  validate({ name: 'Vasya' })
+);
 
 // undefined
 validate({ name: 'Kolya' });
-
 ```
 
 ---

package/any/any.d.ts

@@ -10,12 +10,4 @@
  *   validate({});
  * ```
  */
-export declare const any: <TValues>() => (value: unknown, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const any: <TValues>() => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;

package/array/array.d.ts

@@ -12,4 +12,11 @@ import { ValidationRule } from '../core';
  * validateArray(value);
  * ```
  */
-export declare const array: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem[], TValues>[]) => import("../core").Guard<unknown[], TValues, {}>;
+export declare const array: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem[], TValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<{}> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};

package/arrayItem/arrayItem.d.ts

@@ -24,12 +24,4 @@ import { ValidationRule } from '../core';
  * validateArray(values);
  * ```
  */
-export declare const arrayItem: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem, TValues>[]) => (value: TItem[], prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const arrayItem: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem, TValues>[]) => (value: TItem[], prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;

package/boolean/boolean.d.ts

@@ -10,4 +10,11 @@ import { ValidationRule } from '../core';
  *  validate(true);
  * ```
  */
-export declare const boolean: <TValues>(...rules: ValidationRule<boolean, TValues>[]) => import("../core").Guard<boolean, TValues, {}>;
+export declare const boolean: <TValues>(...rules: ValidationRule<boolean, TValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<{}> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};

package/core/context/types.d.ts

@@ -1,26 +1,27 @@
+import { DeepPartial, DeepReadonly } from 'utility-types';
 import { createSimpleError } from '../errors';
 /**
  * @description Контекст, который доступен в каждом правиле
  */
-export type ValidationContext<TValues> = Readonly<{
+export type ValidationContext<TValues> = DeepReadonly<{
     /**
      * @description Глобальные значения, идущие от самого верхнего правила к самому нижнему
      */
-    global: Readonly<{
+    global: {
         /**
          * @description Значения, которые валидируется guard самого высоко порядка
          */
-        values: TValues;
+        values: DeepPartial<TValues>;
         /**
          * @description Глобальные переопределения (сквозные для всех правил)
          */
-        overrides: Readonly<{
+        overrides: {
             /**
              * @description Делает для всех объектов в схеме все свойства необязательными
              */
             objectIsPartial: boolean;
-        }>;
-    }>;
+        };
+    };
     /**
      * @description Фабрика ошибок. Возвращает новую ошибку валидации
      */

package/core/guard/createGuard/createGuard.d.ts

@@ -1,4 +1,4 @@
-import { ValidationResult, ValidationTypes } from '../../types';
+import { ValidationResult } from '../../types';
 import { ValidationContext } from '../../context';
 type DefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
     /**
@@ -17,18 +17,18 @@ type DefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefO
      */
     isOptional?: boolean;
 };
-type GuardValue<ValidationType> = ValidationType | undefined | null | unknown;
+type GuardValue = unknown;
 /**
  * @description Интерфейс функции guard, которая в прототипе содержит метод define
  */
-export interface Guard<ValidationType extends ValidationTypes, TValues, AddDefOptions extends Record<string, unknown> = {}> {
-    (value: GuardValue<ValidationType>, ctx?: ValidationContext<TValues>): ValidationResult;
+export interface Guard<TValues = unknown, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue, ctx?: ValidationContext<TValues>): ValidationResult;
     /**
      * @description Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
      * @param options - параметры, позволяющие переопределить дефолтные настройки guard
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
      */
-    define(options: DefOptions<AddDefOptions>): Guard<ValidationType, TValues, AddDefOptions>;
+    define(options: DefOptions<AddDefOptions>): Guard<TValues, AddDefOptions>;
 }
 /**
  * @description Функция, которая позволяет определять частную логику для guard
@@ -50,5 +50,8 @@ type GuardExecutor<TValues, AddDefOptions extends Record<string, unknown>> = (va
  *   });
  * ```
  */
-export declare const createGuard: <ValidationType extends unknown, TValues, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<TValues, AddDefOptions>) => Guard<ValidationType, TValues, AddDefOptions>;
+export declare const createGuard: <TValues, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<TValues, AddDefOptions>) => {
+    (value: unknown, prevCtx?: ValidationContext<TValues> | undefined): ValidationResult;
+    define(overridesDefOptions: DefOptions<AddDefOptions>): any;
+};
 export {};

package/core/rule/createRule/createRule.d.ts

@@ -30,13 +30,5 @@ type RuleExecutor<ValidationType extends ValidationTypes, TValues> = (value: Val
  *   }, params);
  * ```
  */
-export declare const createRule: <ValidationType extends unknown, TValues = unknown>(executor: RuleExecutor<ValidationType, TValues>, commonParams?: CommonRuleParams<ValidationType> | undefined) => (value: ValidationType, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../..").ErrorInfo) => import("../..").ValidationSimpleError<{}>;
-}> | undefined) => ValidationResult;
+export declare const createRule: <ValidationType extends unknown, TValues = unknown>(executor: RuleExecutor<ValidationType, TValues>, commonParams?: CommonRuleParams<ValidationType> | undefined) => (value: ValidationType, prevCtx?: ValidationContext<TValues> | undefined) => ValidationResult;
 export {};

package/core/rule/required/required.d.ts

@@ -8,12 +8,4 @@ export declare const required: ({ message, }?: {
      * @default Обязательно
      */
     message?: string | undefined;
-}) => (value: unknown, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: unknown;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../..").ErrorInfo) => import("../..").ValidationSimpleError<{}>;
-}> | undefined) => import("../..").ValidationResult;
+}) => (value: unknown, prevCtx?: import("../..").ValidationContext<unknown> | undefined) => import("../..").ValidationResult;

package/date/date.d.ts

@@ -15,5 +15,12 @@ type AdditionalDefOptions = {
  *  validate(new Date('22.22.2022'));
  * ```
  */
-export declare const date: <TValues>(...rules: ValidationRule<Date, TValues>[]) => import("../core").Guard<Date, TValues, AdditionalDefOptions>;
+export declare const date: <TValues>(...rules: ValidationRule<Date, TValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};
 export {};

package/deepPartial/deepPartial.d.ts

@@ -18,12 +18,4 @@ import { Guard } from '../core';
  *     const result = validate({ info: { info: {} } });
  * ```
  */
-export declare const deepPartial: <TValues>(guard: Guard<unknown, TValues, {}>) => (value: unknown, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const deepPartial: <TValues>(guard: Guard<TValues, {}>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;

package/email/email.d.ts

@@ -16,13 +16,5 @@ type EmailParams = {
  *  validate('example@mail.ru');
  * ```
  */
-export declare const email: <TValues>(params?: EmailParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const email: <TValues>(params?: EmailParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/index.d.ts

@@ -8,6 +8,8 @@ export { array, ARRAY_TYPE_ERROR_INFO } from './array';
 export { arrayItem } from './arrayItem';
 export { deepPartial } from './deepPartial';
 export { min, STRING_MIN_ERROR_CODE, ARRAY_MIN_ERROR_CODE, DATE_MIN_ERROR_CODE, NUMBER_MIN_ERROR_CODE, } from './min';
+export { max, STRING_MAX_ERROR_CODE, ARRAY_MAX_ERROR_CODE, DATE_MAX_ERROR_CODE, NUMBER_MAX_ERROR_CODE, } from './max';
+export { integer, INTEGER_ERROR_INFO } from './integer';
 export { or } from './or';
 export { pattern, PATTERN_ERROR_CODE } from './pattern';
 export { onlyNumber, ONLY_NUMBER_ERROR_CODE } from './onlyNumber';
@@ -23,3 +25,4 @@ export { ogrnUL, OGRN_UL_ERROR_INFO } from './ogrnUL';
 export { ogrnIP, OGRN_IP_ERROR_INFO } from './ogrnIP';
 export { any } from './any';
 export { when } from './when';
+export { toPrettyError } from './toPrettyError';

package/index.js

@@ -8,6 +8,8 @@ export { array, ARRAY_TYPE_ERROR_INFO } from './array';
 export { arrayItem } from './arrayItem';
 export { deepPartial } from './deepPartial';
 export { min, STRING_MIN_ERROR_CODE, ARRAY_MIN_ERROR_CODE, DATE_MIN_ERROR_CODE, NUMBER_MIN_ERROR_CODE, } from './min';
+export { max, STRING_MAX_ERROR_CODE, ARRAY_MAX_ERROR_CODE, DATE_MAX_ERROR_CODE, NUMBER_MAX_ERROR_CODE, } from './max';
+export { integer, INTEGER_ERROR_INFO } from './integer';
 export { or } from './or';
 export { pattern, PATTERN_ERROR_CODE } from './pattern';
 export { onlyNumber, ONLY_NUMBER_ERROR_CODE } from './onlyNumber';
@@ -23,3 +25,4 @@ export { ogrnUL, OGRN_UL_ERROR_INFO } from './ogrnUL';
 export { ogrnIP, OGRN_IP_ERROR_INFO } from './ogrnIP';
 export { any } from './any';
 export { when } from './when';
+export { toPrettyError } from './toPrettyError';

package/innIP/innIP.d.ts

@@ -13,13 +13,5 @@ type InnIPParams = CommonRuleParams<string> & {
  * validate('384212952720');
  * ```
  */
-export declare const innIP: <TValues>(params?: InnIPParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const innIP: <TValues>(params?: InnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/innUL/innUL.d.ts

@@ -13,13 +13,5 @@ type InnULParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const innUL: <TValues>(params?: InnULParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const innUL: <TValues>(params?: InnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/integer/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorInfo } from '../core';
+export declare const INTEGER_ERROR_INFO: ErrorInfo;

package/integer/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const INTEGER_ERROR_INFO = {
+    code: createErrorCode('integer'),
+    message: 'Только целые числа',
+};

package/integer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './integer';

package/integer/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './integer';

package/integer/integer.d.ts

@@ -0,0 +1,25 @@
+type IntegerParams = {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description
+ * Проверяет является ли значение целым числом.
+ * @example
+ * ```ts
+ * const validate = number(integer(5));
+ *
+ * // undefined
+ * validate(5)
+ *
+ * // undefined
+ * validate(7)
+ *
+ * // { message: 'Только целые числа' }
+ * validate(3.14)
+ * ```
+ */
+export declare const integer: <TValues>(params?: IntegerParams) => (value: number, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export {};

package/integer/integer.js

@@ -0,0 +1,28 @@
+import { createRule } from '../core';
+import { INTEGER_ERROR_INFO } from './constants';
+/**
+ * @description
+ * Проверяет является ли значение целым числом.
+ * @example
+ * ```ts
+ * const validate = number(integer(5));
+ *
+ * // undefined
+ * validate(5)
+ *
+ * // undefined
+ * validate(7)
+ *
+ * // { message: 'Только целые числа' }
+ * validate(3.14)
+ * ```
+ */
+export const integer = (params) => createRule((value, ctx) => {
+    if (!Number.isInteger(value)) {
+        return ctx.createError({
+            message: (params === null || params === void 0 ? void 0 : params.message) || INTEGER_ERROR_INFO.message,
+            code: INTEGER_ERROR_INFO.code,
+        });
+    }
+    return undefined;
+});

package/kpp/kpp.d.ts

@@ -13,13 +13,5 @@ type KPPParams = CommonRuleParams<string> & {
  * validate('770201001');
  * ```
  */
-export declare const kpp: <TValues>(params?: KPPParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const kpp: <TValues>(params?: KPPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/mobilePhone/mobilePhone.d.ts

@@ -15,13 +15,5 @@ type MobilePhoneParams = CommonRuleParams<string> & {
  * validate('79999999999');
  * ```
  */
-export declare const mobilePhone: <TValues>(params?: MobilePhoneParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const mobilePhone: <TValues>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/number/number.d.ts

@@ -15,5 +15,12 @@ type AdditionalDefOptions = {
  *  validate(24);
  * ```
  */
-export declare const number: <TValues>(...rules: ValidationRule<number, TValues>[]) => import("../core").Guard<number, TValues, AdditionalDefOptions>;
+export declare const number: <TValues>(...rules: ValidationRule<number, TValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};
 export {};

package/object/object.d.ts

@@ -4,8 +4,8 @@ import { Guard, ValidationContext, ValidationRule } from '../core';
  * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
  */
 interface ObjectPropGuard<TValues> {
-    (value: Parameters<Guard<unknown, TValues>>[0], ctx: ValidationContext<TValues>): ReturnType<Guard<unknown, TValues>>;
-    define: Guard<unknown, TValues>['define'];
+    (value: Parameters<Guard<TValues>>[0], ctx: ValidationContext<TValues>): ReturnType<Guard<TValues>>;
+    define: Guard<TValues>['define'];
 }
 type AdditionalDefOptions = {
     /**
@@ -13,10 +13,6 @@ type AdditionalDefOptions = {
      */
     isPartial?: boolean;
 };
-/**
- * @description Тип, который необходим для того, чтобы object невозможно было использовать без использования generic
- */
-type NeverSchema = Record<'__never', never>;
 /**
  * @description Возможные значения, принимаемые схемой
  */
@@ -48,5 +44,12 @@ export type Schema<TValue extends Record<string, unknown>, TValues = unknown> =
  * });
  * ```
  */
-export declare const object: <Value extends Record<string, unknown> = NeverSchema, TValues = unknown>(schema: Schema<Value, TValues>) => Guard<Value, TValues, AdditionalDefOptions>;
+export declare const object: <Value extends Record<string, unknown>, TValues = unknown>(schema: Schema<Value, TValues>) => {
+    (value: unknown, prevCtx?: ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};
 export {};

package/object/object.js

@@ -35,9 +35,7 @@ export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, i
         const isOptional = ctx.global.overrides.objectIsPartial || isPartial;
         return schemaEntries.reduce((errorMap, [key, rule]) => {
             const isGuard = 'define' in rule;
-            const callRule = isGuard && isOptional
-                ? optional(rule)
-                : rule;
+            const callRule = isGuard && isOptional ? optional(rule) : rule;
             errorMap[key] = callRule(value[key], ctx);
             return errorMap;
         }, {});

package/ogrnIP/ogrnIP.d.ts

@@ -13,13 +13,5 @@ type OgrnIPParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnIP: <TValues>(params?: OgrnIPParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const ogrnIP: <TValues>(params?: OgrnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/ogrnUL/ogrnUL.d.ts

@@ -13,13 +13,5 @@ type OgrnULParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnUL: <TValues>(params?: OgrnULParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const ogrnUL: <TValues>(params?: OgrnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/onlyNumber/onlyNumber.d.ts

@@ -12,13 +12,5 @@ type OnlyNumberParams = {
  *  validate('123');
  * ```
  */
-export declare const onlyNumber: <TValues>(params?: OnlyNumberParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const onlyNumber: <TValues>(params?: OnlyNumberParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/optional/optional.d.ts

@@ -4,4 +4,4 @@ import { Guard } from '../core';
  * @param guard - правило, проверяющее тип значения
  * @example object({ name: optional(string(min(22))) })
  */
-export declare const optional: <ValidationType extends unknown, TValues>(guard: Guard<ValidationType, TValues, {}>) => Guard<ValidationType, TValues, {}>;
+export declare const optional: <TValues>(guard: Guard<TValues, {}>) => Guard<TValues, {}>;

package/optional/optional.js

@@ -1,15 +1,6 @@
-import { string } from '../string';
 /**
  * @description Выключает проверку на required в guard
  * @param guard - правило, проверяющее тип значения
  * @example object({ name: optional(string(min(22))) })
  */
 export const optional = (guard) => guard.define({ isOptional: true });
-const validateCustomString = string().define({
-    typeErrorMessage: 'Только строка',
-    requiredErrorMessage: 'Не может быть пустым',
-});
-// { message: 'Не может быть пустым' }
-validateCustomString(undefined);
-// { message: 'Только строка' }
-validateCustomString(20);

package/or/or.d.ts

@@ -11,12 +11,4 @@ import { ValidationResult, ValidationRule } from '../core';
  *  const result = validate('string');
  * ```
  */
-export declare const or: <TValues>(...rules: ValidationRule<unknown, TValues>[]) => (value: unknown, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => ValidationResult;
+export declare const or: <TValues>(...rules: ValidationRule<unknown, TValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => ValidationResult;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@astral/validations",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.4",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {
-    "is-plain-obj": "^4.1.0"
+    "is-plain-obj": "^4.1.0",
+    "utility-types": "^3.10.0"
   },
   "author": "Astral.Soft",
   "license": "MIT",

package/partial/partial.d.ts

@@ -1,10 +1,16 @@
+import { object } from '../object';
 /**
  * @description Выключает проверку на required для всех полей объекта
  * @param objectGuard
  * @example partial(object({ name: string() }))
  */
-export declare const partial: (objectGuard: import("../core").Guard<Record<string, unknown>, unknown, {
-    isPartial?: boolean | undefined;
-}>) => import("../core").Guard<Record<string, unknown>, unknown, {
-    isPartial?: boolean | undefined;
-}>;
+export declare const partial: (objectGuard: ReturnType<typeof object>) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<unknown> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<{
+        isPartial?: boolean | undefined;
+    }> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};

package/pattern/pattern.d.ts

@@ -14,13 +14,5 @@ type PatternParams = {
  * string(pattern(/[0-9]/))
  * ```
  */
-export declare const pattern: <TValues>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const pattern: <TValues>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/snils/snils.d.ts

@@ -13,13 +13,5 @@ type SnilsParams = CommonRuleParams<string> & {
  * validate('15657325992');
  * ```
  */
-export declare const snils: <TValues>(params?: SnilsParams) => (value: string, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const snils: <TValues>(params?: SnilsParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/string/string.d.ts

@@ -1,2 +1,9 @@
 import { ValidationRule } from '../core';
-export declare const string: <TValues>(...rules: ValidationRule<string, TValues>[]) => import("../core").Guard<string, TValues, {}>;
+export declare const string: <TValues>(...rules: ValidationRule<string, TValues>[]) => {
+    (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+    define(overridesDefOptions: Partial<{}> & {
+        requiredErrorMessage?: string | undefined;
+        typeErrorMessage?: string | undefined;
+        isOptional?: boolean | undefined;
+    }): any;
+};

package/toPrettyError/index.d.ts

@@ -0,0 +1 @@
+export * from './toPrettyError';

package/toPrettyError/index.js

@@ -0,0 +1 @@
+export * from './toPrettyError';

package/toPrettyError/toPrettyError.d.ts

@@ -0,0 +1,39 @@
+import { ValidationResult } from '../core';
+import { PlainValidationResult } from '../toPlainError';
+/**
+ * @description Преобразует ошибку валидации в формат для вывода (например, в консоль)
+ * @param validationResult
+ * @example
+ * ```ts
+ *
+ * type ListItem = { description: string };
+ *
+ * type Values = {
+ *   info: { name: string };
+ *   list: ListItem[];
+ * };
+ *
+ * const validate = object<Values>({
+ *   info: object<Values['info']>({ name: string() }),
+ *   list: array(
+ *     arrayItem(
+ *       object<ListItem>({
+ *         description: string(),
+ *       }),
+ *     ),
+ *   ),
+ * });
+ *
+ * const error = validate({
+ *   info: { name: 22 },
+ *   list: [{}],
+ * });
+ *
+ * // {
+ * //   info: { name: 'Не является строкой' },
+ * //   list: [{ description: 'Обязательно' }],
+ * // }
+ * toPrettyError(error);
+ * ```
+ */
+export declare const toPrettyError: (validationResult: ValidationResult) => PlainValidationResult<string>;

package/toPrettyError/toPrettyError.js

@@ -0,0 +1,38 @@
+import { toPlainError } from '../toPlainError';
+/**
+ * @description Преобразует ошибку валидации в формат для вывода (например, в консоль)
+ * @param validationResult
+ * @example
+ * ```ts
+ *
+ * type ListItem = { description: string };
+ *
+ * type Values = {
+ *   info: { name: string };
+ *   list: ListItem[];
+ * };
+ *
+ * const validate = object<Values>({
+ *   info: object<Values['info']>({ name: string() }),
+ *   list: array(
+ *     arrayItem(
+ *       object<ListItem>({
+ *         description: string(),
+ *       }),
+ *     ),
+ *   ),
+ * });
+ *
+ * const error = validate({
+ *   info: { name: 22 },
+ *   list: [{}],
+ * });
+ *
+ * // {
+ * //   info: { name: 'Не является строкой' },
+ * //   list: [{ description: 'Обязательно' }],
+ * // }
+ * toPrettyError(error);
+ * ```
+ */
+export const toPrettyError = (validationResult) => toPlainError(validationResult, (err) => err.message);

package/transform/transform.d.ts

@@ -14,13 +14,5 @@ type Transformer<TValue, TResult> = (value: TValue) => TResult;
  *  );
  * ```
  */
-export declare const transform: <TValue extends unknown, TResult extends unknown, TValues>(transformer: Transformer<TValue, TResult>, ...rules: ValidationRule<TResult, TValues>[]) => (value: TValue, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const transform: <TValue extends unknown, TResult extends unknown, TValues>(transformer: Transformer<TValue, TResult>, ...rules: ValidationRule<TResult, TValues>[]) => (value: TValue, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};

package/when/when.d.ts

@@ -35,13 +35,5 @@ type Params<TValues> = {
  * const result2 = validate({ isAgree: true, name: '' });
  * ```
  */
-export declare const when: <TValues>({ is, then, otherwise }: Params<TValues>) => (value: unknown, prevCtx?: Readonly<{
-    global: Readonly<{
-        values: TValues;
-        overrides: Readonly<{
-            objectIsPartial: boolean;
-        }>;
-    }>;
-    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
-}> | undefined) => import("../core").ValidationResult;
+export declare const when: <TValues>({ is, then, otherwise }: Params<TValues>) => (value: unknown, prevCtx?: ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
 export {};