@astral/validations 3.3.0 → 4.1.0

package/README.md

@@ -34,6 +34,9 @@
     - [kpp](#kpp)
     - [ogrnIP](#ogrnIP)
     - [ogrnUL](#ogrnUL)
+    - [personName](#personName)
+    - [personSurname](#personSurname)
+    - [personPatronymic](#personPatronymic)
   - [date](#date)
     - [min](#min-date)
     - [max](#max-date)
@@ -50,6 +53,7 @@
 - [Custom rules](#custom-rules)
   - [Базовый пример](#базовый-пример)
   - [Связанные поля](#связанные-поля)
+  - [Доступ к ctx.global.values](#доступ-к-высокоуровневым-values-ctxglobalvalues)
   - [Переиспользуемое правило](#переиспользуемое-правило)
 - [Common](#common)
   - [optional](#optional)
@@ -63,6 +67,7 @@
   - [Переиспользование объектов схемы, с условной валидацией и зависимыми полями](#переиспользование-объектов-схемы-с-условной-валидацией-и-зависимыми-полями)
   - [Error message customization](#error-message-customization)
   - [Exclusion managing](#exclusion-managing)
+- [Migration Guide](#migration-guide)
   
 ---
 
@@ -571,6 +576,72 @@ validate('1-22-33-5555555-6')
 
 ---
 
+### personName
+
+Проверяет валидно ли имя
+
+#### [Требования на реализацию](https://track.astral.ru/soft/wiki/pages/viewpage.action?pageId=3813152849#id-Требованиянареализацию-Требование5.Поле"Имя")
+
+```ts
+import { string, personName } from '@astral/validations';
+
+const validate = string(personName());
+
+// undefined
+validate('Иван');
+validate('иван');
+
+// { message: 'Проверьте имя' }
+validate('');
+validate('Иван--Иван');
+```
+
+---
+
+### personSurname
+
+Проверяет валидно ли фамилия
+
+#### [Требования на реализацию](https://track.astral.ru/soft/wiki/pages/viewpage.action?pageId=3813152849#id-Требованиянареализацию-Требование4.Поле"Фамилия")
+
+```ts
+import { string, personSurname } from '@astral/validations';
+
+const validate = string(personSurname());
+
+// undefined
+validate('Иванов');
+validate('иванов');
+
+// { message: 'Проверьте фамилию' }
+validate('');
+validate('Иванов--иванов');
+```
+
+---
+
+### personPatronymic
+
+Проверяет валидно ли отчество
+
+#### [Требования на реализацию](https://track.astral.ru/soft/wiki/pages/viewpage.action?pageId=3813152849#id-Требованиянареализацию-Требование6.Поле"Отчество")
+
+```ts
+import { string, personPatronymic } from '@astral/validations';
+
+const validate = string(personPatronymic());
+
+// undefined
+validate('Иванович');
+validate('иванович');
+
+
+// { message: 'Проверьте отчество' }
+validate('');
+validate('Иванович--Иванович');
+```
+
+
 ## date
 
 - Возвращает ошибку если:
@@ -952,9 +1023,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 +1047,7 @@ toPrettyError(
 
 Каждый guard позволяет переопределить дефолтные параметры:
 - Сообщение об ошибке типа
-- Сообщение о ошибке required
+- Сообщение об ошибке required
 - Уникальные для каждого guard параметры
 
 ```ts
@@ -1010,7 +1081,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 +1103,7 @@ toPrettyError(
 
 ## Связанные поля
 
-В ```ctx.global.values``` находится value, принятое самым верхнеуровневым guard'ом.
+В ```ctx.values``` находится value, принятое последним object.
 
 ```ts
 import { object, string, toPrettyError } from '@astral/validations';
@@ -1042,10 +1113,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 +1133,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 +1235,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 +1262,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 +1484,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 +1497,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 +1556,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/core/utils/index.d.ts

@@ -1,3 +1,7 @@
 export * from './isStringOfZeros';
 export * from './isNoDoubleZeroStart';
 export * from './resetTime';
+export * from './isStartsWithAndEndsWithLetter';
+export * from './isHasConsecutiveChars';
+export * from './isFullNameValidCharacters';
+export * from './isValidFullNameLength';

package/core/utils/index.js

@@ -1,3 +1,7 @@
 export * from './isStringOfZeros';
 export * from './isNoDoubleZeroStart';
 export * from './resetTime';
+export * from './isStartsWithAndEndsWithLetter';
+export * from './isHasConsecutiveChars';
+export * from './isFullNameValidCharacters';
+export * from './isValidFullNameLength';

package/core/utils/isFullNameValidCharacters/index.d.ts

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

package/core/utils/isFullNameValidCharacters/index.js

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

package/core/utils/isFullNameValidCharacters/isFullNameValidCharacters.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @description Проверяет, что разрешенные символы в тексте: прописные (большие) и строчные буквы (включая ё) русского алфавита,
+      прописные (большие) буквы I и V латинского алфавита, -, пробел, точка, апостроф, запятая, открывающая и закрывающая скобка
+ */
+export declare const isFullNameValidCharacters: (value: string) => boolean;

package/core/utils/isFullNameValidCharacters/isFullNameValidCharacters.js

@@ -0,0 +1,5 @@
+/**
+ * @description Проверяет, что разрешенные символы в тексте: прописные (большие) и строчные буквы (включая ё) русского алфавита,
+      прописные (большие) буквы I и V латинского алфавита, -, пробел, точка, апостроф, запятая, открывающая и закрывающая скобка
+ */
+export const isFullNameValidCharacters = (value) => !/^([а-яёА-ЯЁIV ё.,'’‎()\-\s]+)$/.test(value);

package/core/utils/isHasConsecutiveChars/index.d.ts

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

package/core/utils/isHasConsecutiveChars/index.js

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

package/core/utils/isHasConsecutiveChars/isHasConsecutiveChars.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что текст не может содержать последовательно два спецсимвола/пробела
+ */
+export declare const isHasConsecutiveChars: (value: string) => boolean;

package/core/utils/isHasConsecutiveChars/isHasConsecutiveChars.js

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что текст не может содержать последовательно два спецсимвола/пробела
+ */
+export const isHasConsecutiveChars = (value) => /([`~!@#$%^&*()\-_=+[{\]}\|;:'",<.>/?])\1|\s{2}/.test(value);

package/core/utils/isStartsWithAndEndsWithLetter/index.d.ts

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

package/core/utils/isStartsWithAndEndsWithLetter/index.js

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

package/core/utils/isStartsWithAndEndsWithLetter/isStartsWithAndEndsWithLetter.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что текст начинается с буквы и заканчивается буквой, кроме скобок ()
+ */
+export declare const isStartsWithAndEndsWithLetter: (value: string) => boolean;

package/core/utils/isStartsWithAndEndsWithLetter/isStartsWithAndEndsWithLetter.js

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что текст начинается с буквы и заканчивается буквой, кроме скобок ()
+ */
+export const isStartsWithAndEndsWithLetter = (value) => !/^[IV а-яёА-ЯЁ()](?:.*[IV а-яёА-ЯЁ()])?$/.test(value);

package/core/utils/isValidFullNameLength/index.d.ts

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

package/core/utils/isValidFullNameLength/index.js

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

package/core/utils/isValidFullNameLength/isValidFullNameLength.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что длина значения находится в допустимом диапазоне от 1 до 200 символов
+ */
+export declare const isValidFullNameLength: (value: string) => boolean;

package/core/utils/isValidFullNameLength/isValidFullNameLength.js

@@ -0,0 +1,4 @@
+/**
+ * @description Проверяет, что длина значения находится в допустимом диапазоне от 1 до 200 символов
+ */
+export const isValidFullNameLength = (value) => value.length < 1 || value.length > 200;

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/index.d.ts

@@ -24,6 +24,9 @@ export { snils, SNILS_ERROR_INFO } from './snils';
 export { createRule, REQUIRED_ERROR_INFO, type ValidationRule } from './core';
 export { ogrnUL, OGRN_UL_ERROR_INFO } from './ogrnUL';
 export { ogrnIP, OGRN_IP_ERROR_INFO } from './ogrnIP';
+export { personName, PERSON_NAME_ERROR_INFO } from './personName';
+export { personSurname, PERSON_SURNAME_ERROR_INFO } from './personSurname';
+export { personPatronymic, PERSON_PATRONYMIC_ERROR_INFO, } from './personPatronymic';
 export { any } from './any';
 export { when } from './when';
 export { toPrettyError } from './toPrettyError';

package/index.js

@@ -24,6 +24,9 @@ export { snils, SNILS_ERROR_INFO } from './snils';
 export { createRule, REQUIRED_ERROR_INFO } from './core';
 export { ogrnUL, OGRN_UL_ERROR_INFO } from './ogrnUL';
 export { ogrnIP, OGRN_IP_ERROR_INFO } from './ogrnIP';
+export { personName, PERSON_NAME_ERROR_INFO } from './personName';
+export { personSurname, PERSON_SURNAME_ERROR_INFO } from './personSurname';
+export { personPatronymic, PERSON_PATRONYMIC_ERROR_INFO, } from './personPatronymic';
 export { any } from './any';
 export { when } from './when';
 export { toPrettyError } from './toPrettyError';

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 {};