@astral/validations 3.3.0 → 4.0.0

package/README.md

@@ -50,6 +50,7 @@
 - [Custom rules](#custom-rules)
   - [Базовый пример](#базовый-пример)
   - [Связанные поля](#связанные-поля)
+  - [Доступ к ctx.global.values](#доступ-к-высокоуровневым-values-ctxglobalvalues)
   - [Переиспользуемое правило](#переиспользуемое-правило)
 - [Common](#common)
   - [optional](#optional)
@@ -63,6 +64,7 @@
   - [Переиспользование объектов схемы, с условной валидацией и зависимыми полями](#переиспользование-объектов-схемы-с-условной-валидацией-и-зависимыми-полями)
   - [Error message customization](#error-message-customization)
   - [Exclusion managing](#exclusion-managing)
+- [Migration Guide](#migration-guide)
   
 ---
 
@@ -952,9 +954,9 @@ validate([1, 2]);
 ```ts
 type Values = { name: string; isAgree: boolean };
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   name: when({
-    is: (_, ctx) => Boolean(ctx.global.values.isAgree),
+    is: (_, ctx) => Boolean(ctx.values?.isAgree),
     then: string(),
     otherwise: any(),
   }),
@@ -976,7 +978,7 @@ toPrettyError(
 
 Каждый guard позволяет переопределить дефолтные параметры:
 - Сообщение об ошибке типа
-- Сообщение о ошибке required
+- Сообщение об ошибке required
 - Уникальные для каждого guard параметры
 
 ```ts
@@ -1010,7 +1012,7 @@ type Values = {
   nickname: string;
 };
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   name: string(),
   nickname: string((value, ctx) => {
     if (value.includes('_')) {
@@ -1032,7 +1034,7 @@ toPrettyError(
 
 ## Связанные поля
 
-В ```ctx.global.values``` находится value, принятое самым верхнеуровневым guard'ом.
+В ```ctx.values``` находится value, принятое последним object.
 
 ```ts
 import { object, string, toPrettyError } from '@astral/validations';
@@ -1042,10 +1044,10 @@ type Values = {
   repeatPassword: string;
 };
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   password: string(min(9)),
   repeatPassword: string(min(9), (value, ctx) => {
-    if (value !== ctx.global.values.password) {
+    if (value !== ctx.values?.password) {
       return ctx.createError({
         message: 'Пароли не совпадают',
         code: 'repeat-password',
@@ -1062,6 +1064,33 @@ toPrettyError(
 );
 ```
 
+
+## Доступ к высокоуровневым values (```ctx.global.values```)
+
+В ```ctx.global.values``` находится values, полученное самым первым guard.
+
+```ts
+import { object, string, boolean, optional } from '@astral/validations';
+
+type Values = {
+  isAgree: boolean;
+  info: {
+    name: string
+  }
+};
+
+const validate = object<Values>({
+  isAgree: optional(boolean()),
+  info: object<Values['info']>({
+    name: when({
+      is: (_, ctx) => Boolean(ctx.global.values?.isAgree),
+      then: string(),
+      otherwise: any(),
+    }),
+  })
+});
+```
+
 ## Переиспользуемое правило
 
 ```ts
@@ -1137,9 +1166,9 @@ validate({
 ```ts
 type Values = { name: string; isAgree: boolean };
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   name: when({
-    is: (_, ctx) => Boolean(ctx.global.values.isAgree),
+    is: (_, ctx) => Boolean(ctx.values?.isAgree),
     then: string(),
     otherwise: any(),
   }),
@@ -1164,10 +1193,10 @@ type Values = {
   info?: ValuesInfo;
 };
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   name: string(),
   info: when({
-    is: (_, ctx) => ctx.global.values.name === 'Vasya',
+    is: (_, ctx) => ctx.values?.name === 'Vasya',
     then: object<ValuesInfo>({ surname: string() }),
     otherwise: any(),
   }),
@@ -1386,12 +1415,10 @@ type Values = {
   org: { data: RusOrganization | EngOrganization };
 };
 
-// второй параметр generic - это глобально валидируемое значение. Для формы это весь values
-const rusOrganization = object<RusOrganization, Values>({
+const rusOrganization = object<RusOrganization>({
   inn: string(
-    // автоматический вывод типа для ctx.global.values
     when({
-      is: (_, ctx) => Boolean(ctx.global.values.isRus),
+      is: (_, ctx) => Boolean((ctx.global.values as Values)?.isRus),
       then: rusOrganization,
       otherwise: engOrganization,
     }),
@@ -1401,14 +1428,13 @@ const rusOrganization = object<RusOrganization, Values>({
 
 const engOrganization = object<EngOrganization, Values>({ name: string() });
 
-// необходимо явно указать Values для типизации ctx.global.values
 const organization = when<Values>({
-  is: (_, ctx) => Boolean(ctx.global.values.isRus),
+  is: (_, ctx) => Boolean((ctx.global.values as Values)?.isRus),
   then: rusOrganization,
   otherwise: engOrganization,
 });
 
-const validate = object<Values, Values>({
+const validate = object<Values>({
   isRus: optional(boolean()),
   org: organization,
 });
@@ -1461,3 +1487,19 @@ const validate = string(kpp({ exclude: isExclude }));
 // undefined (значение не будет провалидировано)
 validate(excludeValue);
 ```
+
+# Migration guide
+
+## v3 -> v4
+
+### object
+
+Generic object guard стал принимать один параметр - валидируемое значение.
+
+### Типизация guard и rules
+
+Generics правил и guards стали принимать тип для ```ctx.values``` вместо ```ctx.global.values```.
+
+### ctx.global.values
+
+```ctx.global.values``` стал ```unknown```. Для использования необходимо вручную уточнять тип. [Пример](#доступ-к-высокоуровневым-values-ctxglobalvalues).

package/any/any.d.ts

@@ -10,4 +10,4 @@
  *   validate({});
  * ```
  */
-export declare const any: <TValues>() => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const any: <TLastSchemaValues extends Record<string, unknown>>() => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;

package/array/array.d.ts

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

package/arrayItem/arrayItem.d.ts

@@ -24,4 +24,4 @@ import { ValidationRule } from '../core';
  * validateArray(values);
  * ```
  */
-export declare const arrayItem: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem, TValues>[]) => (value: TItem[], prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const arrayItem: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<TItem, TLastSchemaValues>[]) => (value: TItem[], prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;

package/boolean/boolean.d.ts

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

package/core/compose/compose.d.ts

@@ -3,4 +3,4 @@ import { IndependentValidationRule, ValidationRule } from '../rule';
  * @description Объединяет переданные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
  * @example compose(min(), max());
  */
-export declare const compose: <ValidationType, TValues>(...rules: (IndependentValidationRule<ValidationType, TValues> | ValidationRule<ValidationType, TValues>)[]) => IndependentValidationRule<ValidationType, TValues>;
+export declare const compose: <ValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: (IndependentValidationRule<ValidationType, TLastSchemaValues> | ValidationRule<ValidationType, TLastSchemaValues>)[]) => IndependentValidationRule<ValidationType, Record<string, unknown>>;

package/core/context/createContext/createContext.d.ts

@@ -4,5 +4,5 @@ import { ValidationTypes } from '../../types';
  * @description Создает context валидации. Используется внутри фабрик guard и rule
  * @default по-дефолту сбрасывает все флаги в false
  */
-export declare function createContext<Value extends ValidationTypes>(prevCtx: ValidationContext<Value> | undefined, value: Value): ValidationContext<Value>;
-export declare function createContext<Value extends ValidationTypes, Values>(prevCtx: ValidationContext<Values> | undefined, value: Value): ValidationContext<Values>;
+export declare function createContext<TValue extends ValidationTypes>(prevCtx: ValidationContext<{}, TValue> | undefined, value: TValue): ValidationContext<{}, TValue>;
+export declare function createContext<TValue extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>>(prevCtx: ValidationContext<{}> | undefined, value: TValue, lastSchemaValue: TLastSchemaValues): ValidationContext<TLastSchemaValues, TValue>;

package/core/context/createContext/createContext.js

@@ -1,9 +1,14 @@
 import { createSimpleError } from '../../errors';
-export function createContext(prevCtx, value) {
-    if (prevCtx) {
+export function createContext(prevCtx, value, lastSchemaValue) {
+    if (prevCtx && !lastSchemaValue) {
         return prevCtx;
     }
+    const currentLastSchemaValue = lastSchemaValue ? lastSchemaValue : undefined;
+    if (prevCtx) {
+        return Object.assign(Object.assign({}, prevCtx), { values: currentLastSchemaValue });
+    }
     return {
+        values: currentLastSchemaValue,
         global: {
             values: value,
             overrides: {

package/core/context/types.d.ts

@@ -3,7 +3,11 @@ import { createSimpleError } from '../errors';
 /**
  * @description Контекст, который доступен в каждом правиле
  */
-export type ValidationContext<TValues> = DeepReadonly<{
+export type ValidationContext<TLastSchemaValues extends Record<string, unknown> = {}, TGlobalSchemaValues = unknown> = DeepReadonly<{
+    /**
+     * @description Values последнего валидируемого object
+     */
+    values?: DeepPartial<TLastSchemaValues>;
     /**
      * @description Глобальные значения, идущие от самого верхнего правила к самому нижнему
      */
@@ -11,7 +15,7 @@ export type ValidationContext<TValues> = DeepReadonly<{
         /**
          * @description Значения, которые валидируется guard самого высоко порядка
          */
-        values: DeepPartial<TValues>;
+        values: TGlobalSchemaValues;
         /**
          * @description Глобальные переопределения (сквозные для всех правил)
          */

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

@@ -21,26 +21,26 @@ type GuardValue = unknown;
 /**
  * @description Интерфейс функции guard, которая в прототипе содержит метод define
  */
-export interface Guard<TValues = unknown, AddDefOptions extends Record<string, unknown> = {}> {
-    (value: GuardValue, ctx?: ValidationContext<TValues>): ValidationResult;
+export interface Guard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): ValidationResult;
     /**
      * @description Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
      * @param options - параметры, позволяющие переопределить дефолтные настройки guard
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
      */
-    define(options: DefOptions<AddDefOptions>): Guard<TValues, AddDefOptions>;
+    define(options: DefOptions<AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
 }
 /**
  * @description Функция, которая позволяет определять частную логику для guard
  */
-type GuardExecutor<TValues, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TValues>, defOptions: DefOptions<AddDefOptions>) => ValidationResult;
+type GuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: DefOptions<AddDefOptions>) => ValidationResult;
 /**
  * @description Создает guard. Guard - функция, проверяющая тип значения
  * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
  * После первого вызова guard в прототипу функции становится доступен метод define, который позволяет переопределить дефолтное поведение guard (например, изменить текст для required правила)
  * @example
  * ```ts
- * const string = <TValues>(...rules: ValidationRule<string, TValues>[]) =>
+ * const string = <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<string, TValues>[]) =>
  *   createGuard<string, TValues>((value, ctx) => {
  *     if (typeof value !== 'string') {
  *       return ctx.createError({ code: 'custom error', message: 'Не строка' });
@@ -50,8 +50,8 @@ type GuardExecutor<TValues, AddDefOptions extends Record<string, unknown>> = (va
  *   });
  * ```
  */
-export declare const createGuard: <TValues, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<TValues, AddDefOptions>) => {
-    (value: unknown, prevCtx?: ValidationContext<TValues> | undefined): ValidationResult;
+export declare const createGuard: <TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<AddDefOptions>) => {
+    (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined): ValidationResult;
     define(overridesDefOptions: DefOptions<AddDefOptions>): any;
 };
 export {};

package/core/guard/createGuard/createGuard.js

@@ -7,7 +7,7 @@ import { compose } from '../../compose';
  * После первого вызова guard в прототипу функции становится доступен метод define, который позволяет переопределить дефолтное поведение guard (например, изменить текст для required правила)
  * @example
  * ```ts
- * const string = <TValues>(...rules: ValidationRule<string, TValues>[]) =>
+ * const string = <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<string, TValues>[]) =>
  *   createGuard<string, TValues>((value, ctx) => {
  *     if (typeof value !== 'string') {
  *       return ctx.createError({ code: 'custom error', message: 'Не строка' });

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

@@ -8,12 +8,12 @@ export type CommonRuleParams<ValidationType extends ValidationTypes> = {
     /**
      * @description Функция, позволяющая для каждого правила указать исключение
      */
-    exclude?: (value: ValidationType, ctx: ValidationContext<unknown>) => boolean;
+    exclude?: (value: ValidationType, ctx: ValidationContext) => boolean;
 };
 /**
  * @description Функция, которая позволяет определять частную логику для guard
  */
-type RuleExecutor<ValidationType extends ValidationTypes, TValues> = (value: ValidationType, ctx: ValidationContext<TValues>) => ValidationResult;
+type RuleExecutor<ValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>> = (value: ValidationType, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;
 /**
  * @description Создает правила валидации, которые можно использовать внутри guard или по отдельности
  * @param executor - функция, которая позволяет определять частную логику для guard
@@ -30,5 +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?: ValidationContext<TValues> | undefined) => ValidationResult;
+export declare const createRule: <ValidationType extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(executor: RuleExecutor<ValidationType, TLastSchemaValues>, commonParams?: CommonRuleParams<ValidationType> | undefined) => (value: ValidationType, prevCtx?: ValidationContext<TLastSchemaValues> | undefined) => ValidationResult;
 export {};

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

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

package/core/rule/types.d.ts

@@ -3,13 +3,13 @@ import { ValidationResult } from '../types';
 /**
  * @description Самостоятельное правило для валидации. Может использоваться вне guard'ов
  */
-export type IndependentValidationRule<TValue, TValues> = (value: TValue, ctx?: ValidationContext<TValues>) => ValidationResult;
+export type IndependentValidationRule<TValue, TLastSchemaValues extends Record<string, unknown>> = (value: TValue, ctx?: ValidationContext<TLastSchemaValues>) => ValidationResult;
 /**
  * @description Правило для валидации, работающее исключительно с guard'ами
  */
-export type ValidationRule<TValue, TValues> = (value: TValue, ctx: ValidationContext<TValues>) => ValidationResult;
+export type ValidationRule<TValue, TLastSchemaValues extends Record<string, unknown> = {}> = (value: TValue, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;
 /**
  * @description Композиционное правило валидации, умеющее работать с любыми значениями.
  * В основном используется для композиционных правил, которые принимают rule, умеющие валидировать разные значения (optional, transform...)
  */
-export type UniversalCompositionalValidationRule<TValues = unknown> = ValidationRule<any, TValues>;
+export type UniversalCompositionalValidationRule<TLastSchemaValues extends Record<string, unknown>> = ValidationRule<any, TLastSchemaValues>;

package/date/date.d.ts

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

package/deepPartial/deepPartial.d.ts

@@ -18,4 +18,4 @@ import { Guard } from '../core';
  *     const result = validate({ info: { info: {} } });
  * ```
  */
-export declare const deepPartial: <TValues>(guard: Guard<TValues, {}>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const deepPartial: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues, {}>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;

package/email/email.d.ts

@@ -16,5 +16,5 @@ type EmailParams = {
  *  validate('example@mail.ru');
  * ```
  */
-export declare const email: <TValues>(params?: EmailParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const email: <TLastSchemaValues extends Record<string, unknown>>(params?: EmailParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/innIP/innIP.d.ts

@@ -13,5 +13,5 @@ type InnIPParams = CommonRuleParams<string> & {
  * validate('384212952720');
  * ```
  */
-export declare const innIP: <TValues>(params?: InnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const innIP: <TLastSchemaValues extends Record<string, unknown>>(params?: InnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/innUL/innUL.d.ts

@@ -13,5 +13,5 @@ type InnULParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const innUL: <TValues>(params?: InnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const innUL: <TLastSchemaValues extends Record<string, unknown>>(params?: InnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/integer/integer.d.ts

@@ -21,5 +21,5 @@ type IntegerParams = {
  * validate(3.14)
  * ```
  */
-export declare const integer: <TValues>(params?: IntegerParams) => (value: number, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const integer: <TLastSchemaValues extends Record<string, unknown>>(params?: IntegerParams) => (value: number, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/kpp/kpp.d.ts

@@ -13,5 +13,5 @@ type KPPParams = CommonRuleParams<string> & {
  * validate('770201001');
  * ```
  */
-export declare const kpp: <TValues>(params?: KPPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const kpp: <TLastSchemaValues extends Record<string, unknown>>(params?: KPPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/max/max.d.ts

@@ -5,7 +5,7 @@ type MaxParams<ValidationType> = {
     /**
      * @description Сообщение ошибки
      */
-    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext) => string;
 };
 /**
  * @description Проверяет значение на соответствие максимуму. Работает с: string, array, Date, number
@@ -21,6 +21,6 @@ type MaxParams<ValidationType> = {
  *  date(max(new Date())));
  * ```
  */
-export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
-export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes, unknown>>;
+export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date>>;
+export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes>>;
 export {};

package/min/min.d.ts

@@ -5,7 +5,7 @@ type MinParams<ValidationType> = {
     /**
      * @description Сообщение ошибки
      */
-    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext<unknown>) => string;
+    getMessage?: (threshold: CommonThreshold, value: ValidationType, ctx: ValidationContext) => string;
 };
 /**
  * @description Проверяет значение на соответствие минимуму. Работает с: string, array, Date, number
@@ -21,6 +21,6 @@ type MinParams<ValidationType> = {
  *  date(min(new Date())));
  * ```
  */
-export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date, unknown>>;
-export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes, unknown>>;
+export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date>>;
+export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes>>;
 export {};

package/mobilePhone/mobilePhone.d.ts

@@ -15,5 +15,5 @@ type MobilePhoneParams = CommonRuleParams<string> & {
  * validate('79999999999');
  * ```
  */
-export declare const mobilePhone: <TValues>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const mobilePhone: <TLastSchemaValues extends Record<string, unknown>>(params?: MobilePhoneParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/number/number.d.ts

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

package/object/object.d.ts

@@ -3,9 +3,9 @@ import { Guard, ValidationContext, ValidationRule } from '../core';
  * @description Специальный итерфейс Guard для object. В данном интерфейсе ctx required
  * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
  */
-interface ObjectPropGuard<TValues> {
-    (value: Parameters<Guard<TValues>>[0], ctx: ValidationContext<TValues>): ReturnType<Guard<TValues>>;
-    define: Guard<TValues>['define'];
+interface ObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<Guard<TLastSchemaValues>>;
+    define: Guard<TLastSchemaValues>['define'];
 }
 type AdditionalDefOptions = {
     /**
@@ -16,11 +16,11 @@ type AdditionalDefOptions = {
 /**
  * @description Возможные значения, принимаемые схемой
  */
-export type SchemaValue<TValues> = ObjectPropGuard<TValues> | ValidationRule<unknown, TValues>;
+export type SchemaValue<TValue extends Record<string, unknown>> = ObjectPropGuard<TValue> | ValidationRule<unknown, TValue>;
 /**
  * @description Схема правил валдиации для объекта
  */
-export type Schema<TValue extends Record<string, unknown>, TValues = unknown> = Record<keyof TValue, SchemaValue<TValues>>;
+export type Schema<TValue extends Record<string, unknown>> = Record<keyof TValue, SchemaValue<TValue>>;
 /**
  * @description Guard для объекта
  * @param schema - схема валидации объекта
@@ -44,13 +44,13 @@ export type Schema<TValue extends Record<string, unknown>, TValues = unknown> =
  * });
  * ```
  */
-export declare const object: <TValue extends Record<string, unknown>, TValues = unknown>(schema: Schema<TValue, TValues>) => {
-    (value: unknown, prevCtx?: ValidationContext<TValues> | undefined): import("../core").ValidationResult;
+export declare const object: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: Schema<TValue>) => {
+    (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<AdditionalDefOptions> & {
         requiredErrorMessage?: string | undefined;
         typeErrorMessage?: string | undefined;
         isOptional?: boolean | undefined;
     }): any;
 };
-export type ObjectGuard<TValue extends Record<string, unknown>, TValues = unknown> = ReturnType<typeof object<TValue, TValues>>;
+export type ObjectGuard<TValue extends Record<string, unknown>> = ReturnType<typeof object<TValue>>;
 export {};

package/object/object.js

@@ -1,5 +1,5 @@
 import isPlainObject from 'is-plain-obj';
-import { createErrorMap, createGuard, } from '../core';
+import { createContext, createErrorMap, createGuard, } from '../core';
 import { optional } from '../optional';
 import { isEmptyErrors } from './isEmptyErrors';
 import { OBJECT_TYPE_ERROR_INFO } from './constants';
@@ -27,16 +27,17 @@ import { OBJECT_TYPE_ERROR_INFO } from './constants';
  * ```
  */
 export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => {
+    const context = createContext(ctx, value, value);
     if (!isPlainObject(value)) {
-        return ctx.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
+        return context.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
     }
     const generateErrorMap = () => {
         const schemaEntries = Object.entries(schema);
-        const isOptional = ctx.global.overrides.objectIsPartial || isPartial;
+        const isOptional = context.global.overrides.objectIsPartial || isPartial;
         return schemaEntries.reduce((errorMap, [key, rule]) => {
             const isGuard = 'define' in rule;
             const callRule = isGuard && isOptional ? optional(rule) : rule;
-            errorMap[key] = callRule(value[key], ctx);
+            errorMap[key] = callRule(value[key], context);
             return errorMap;
         }, {});
     };

package/ogrnIP/ogrnIP.d.ts

@@ -13,5 +13,5 @@ type OgrnIPParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnIP: <TValues>(params?: OgrnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const ogrnIP: <TLastSchemaValues extends Record<string, unknown>>(params?: OgrnIPParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/ogrnUL/ogrnUL.d.ts

@@ -13,5 +13,5 @@ type OgrnULParams = CommonRuleParams<string> & {
  * validate('7728168971');
  * ```
  */
-export declare const ogrnUL: <TValues>(params?: OgrnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const ogrnUL: <TLastSchemaValues extends Record<string, unknown>>(params?: OgrnULParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/onlyNumber/onlyNumber.d.ts

@@ -12,5 +12,5 @@ type OnlyNumberParams = {
  *  validate('123');
  * ```
  */
-export declare const onlyNumber: <TValues>(params?: OnlyNumberParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const onlyNumber: <TLastSchemaValues extends Record<string, unknown>>(params?: OnlyNumberParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | 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: <TValues>(guard: Guard<TValues, {}>) => Guard<TValues, {}>;
+export declare const optional: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues, {}>) => Guard<TLastSchemaValues, {}>;

package/or/or.d.ts

@@ -11,4 +11,4 @@ import { ValidationResult, ValidationRule } from '../core';
  *  const result = validate('string');
  * ```
  */
-export declare const or: <TValues>(...rules: ValidationRule<unknown, TValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => ValidationResult;
+export declare const or: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<unknown, TLastSchemaValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => ValidationResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astral/validations",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {

package/partial/partial.d.ts

@@ -5,7 +5,7 @@ import { object } from '../object';
  * @example partial(object({ name: string() }))
  */
 export declare const partial: (objectGuard: ReturnType<typeof object>) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<unknown> | undefined): import("../core").ValidationResult;
+    (value: unknown, prevCtx?: import("../core").ValidationContext<Record<string, unknown>> | undefined): import("../core").ValidationResult;
     define(overridesDefOptions: Partial<{
         isPartial?: boolean | undefined;
     }> & {

package/pattern/pattern.d.ts

@@ -14,5 +14,5 @@ type PatternParams = {
  * string(pattern(/[0-9]/))
  * ```
  */
-export declare const pattern: <TValues>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const pattern: <TLastSchemaValues extends Record<string, unknown>>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/positiveNumber/positiveNumber.d.ts

@@ -21,5 +21,5 @@ type PositiveNumberParams = {
  * validate(-1)
  * ```
  */
-export declare const positiveNumber: <TValues>(params?: PositiveNumberParams) => (value: number, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const positiveNumber: <TLastSchemaValues extends Record<string, unknown>>(params?: PositiveNumberParams) => (value: number, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/snils/snils.d.ts

@@ -13,5 +13,5 @@ type SnilsParams = CommonRuleParams<string> & {
  * validate('15657325992');
  * ```
  */
-export declare const snils: <TValues>(params?: SnilsParams) => (value: string, prevCtx?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const snils: <TLastSchemaValues extends Record<string, unknown>>(params?: SnilsParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/string/string.d.ts

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

package/transform/transform.d.ts

@@ -14,5 +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?: import("../core").ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const transform: <TValue extends unknown, TResult extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(transformer: Transformer<TValue, TResult>, ...rules: ValidationRule<TResult, TLastSchemaValues>[]) => (value: TValue, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/when/when.d.ts

@@ -1,17 +1,17 @@
 import { ValidationContext, ValidationRule } from '../core';
-type Params<TValues> = {
+type Params<TLastSchemaValues extends Record<string, unknown>> = {
     /**
      * @description Условие для выбора ветки
      */
-    is: (value: unknown, ctx: ValidationContext<TValues>) => boolean;
+    is: (value: unknown, ctx: ValidationContext<TLastSchemaValues>) => boolean;
     /**
      * Правила валидации, применяемые если is === true
      */
-    then: ValidationRule<unknown, TValues>;
+    then: ValidationRule<unknown, TLastSchemaValues>;
     /**
      * Правила валидации, применяемые если is === false
      */
-    otherwise: ValidationRule<unknown, TValues>;
+    otherwise: ValidationRule<unknown, TLastSchemaValues>;
 };
 /**
  * @description Позволяет указывать условные валидации
@@ -19,7 +19,7 @@ type Params<TValues> = {
  * ```ts
  * type Values = { name: string; isAgree: boolean };
  *
- * const validate = object<Values, Values>({
+ * const validate = object<Values>({
  *   name: when({
  *     is: (_, ctx) => ctx.global.values.isAgree,
  *     then: string(),
@@ -35,5 +35,5 @@ type Params<TValues> = {
  * const result2 = validate({ isAgree: true, name: '' });
  * ```
  */
-export declare const when: <TValues>({ is, then, otherwise }: Params<TValues>) => (value: unknown, prevCtx?: ValidationContext<TValues> | undefined) => import("../core").ValidationResult;
+export declare const when: <TLastSchemaValues extends Record<string, unknown>>({ is, then, otherwise, }: Params<TLastSchemaValues>) => (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
 export {};

package/when/when.js

@@ -5,7 +5,7 @@ import { createRule } from '../core';
  * ```ts
  * type Values = { name: string; isAgree: boolean };
  *
- * const validate = object<Values, Values>({
+ * const validate = object<Values>({
  *   name: when({
  *     is: (_, ctx) => ctx.global.values.isAgree,
  *     then: string(),
@@ -21,7 +21,7 @@ import { createRule } from '../core';
  * const result2 = validate({ isAgree: true, name: '' });
  * ```
  */
-export const when = ({ is, then, otherwise }) => createRule((value, ctx) => {
+export const when = ({ is, then, otherwise, }) => createRule((value, ctx) => {
     if (is(value, ctx)) {
         return then(value, ctx);
     }