@astral/validations 4.20.3 → 4.21.0

package/node/any/any.d.ts

@@ -0,0 +1,23 @@
+import { type ValidationRule } from '../core';
+/**
+ * Выключает любые проверки и валидирует value
+ * @param rules - правила, валидирующие любые значения
+ * @example
+ * ```ts
+ *   type Values = { name: string; surname?: string };
+ *
+ *   const validate = object<Values>({ name: any(), surname: any() });
+ *
+ *   // undefined
+ *   validate({});
+ * ```
+ *   const validate = any(transform((value) => new Date(value), date()));
+ *
+ *    // undefined
+ *    validate('12.22.2022');
+ *
+ *    // invalid date error
+ *    validate('13.22.2022');
+ * ```
+ */
+export declare const any: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<unknown, TLastSchemaValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;

package/node/any/any.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = void 0;
+const core_1 = require("../core");
+/**
+ * Выключает любые проверки и валидирует value
+ * @param rules - правила, валидирующие любые значения
+ * @example
+ * ```ts
+ *   type Values = { name: string; surname?: string };
+ *
+ *   const validate = object<Values>({ name: any(), surname: any() });
+ *
+ *   // undefined
+ *   validate({});
+ * ```
+ *   const validate = any(transform((value) => new Date(value), date()));
+ *
+ *    // undefined
+ *    validate('12.22.2022');
+ *
+ *    // invalid date error
+ *    validate('13.22.2022');
+ * ```
+ */
+const any = (...rules) => (0, core_1.createRule)((value, ctx) => {
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.any = any;

package/node/any/index.d.ts

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

package/node/any/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./any"), exports);

package/node/array/array.d.ts

@@ -0,0 +1,15 @@
+import { type ValidationRule } from '../core';
+/**
+ * Guard для массива. Проверяет value на соответствие типу array
+ * @param rules - правила валидаций, применяющиеся ко всему массиву
+ * @example
+ * ```ts
+ * const value = ['Vasya', 'Ivan'];
+ *
+ * const validateArray = array(min(1), arrayItem(string()));
+ *
+ * // undefined
+ * validateArray(value);
+ * ```
+ */
+export declare const array: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<Array<TItem>, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/node/array/array.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Guard для массива. Проверяет value на соответствие типу array
+ * @param rules - правила валидаций, применяющиеся ко всему массиву
+ * @example
+ * ```ts
+ * const value = ['Vasya', 'Ivan'];
+ *
+ * const validateArray = array(min(1), arrayItem(string()));
+ *
+ * // undefined
+ * validateArray(value);
+ * ```
+ */
+const array = (...rules) => (0, core_1.createGuard)((value, ctx, { typeErrorMessage }) => {
+    if (!Array.isArray(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, constants_1.ARRAY_TYPE_ERROR_INFO), { message: typeErrorMessage || constants_1.ARRAY_TYPE_ERROR_INFO.message }));
+    }
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.array = array;

package/node/array/constants.d.ts

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

package/node/array/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARRAY_TYPE_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.ARRAY_TYPE_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('array'),
+    message: 'Не является массивом',
+};

package/node/array/index.d.ts

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

package/node/array/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);
+__exportStar(require("./constants"), exports);

package/node/arrayItem/arrayItem.d.ts

@@ -0,0 +1,27 @@
+import { type ValidationRule } from '../core';
+/**
+ * Применяет правила к каждому элементу массива
+ * @param rules - правила валидации, которое применится к каждому элементу массива
+ * @example
+ * ```ts
+ * type Item = {
+ *   name: string;
+ *   age?: number;
+ * };
+ *
+ * const values: Values = [{ name: 'Vasya' }, { name: 'Vasya', age: 22 }];
+ *
+ * const validateArray = array(
+ *   arrayItem(
+ *     object<Item>({
+ *       name: string(min(2)),
+ *       age: optional(number()),
+ *     }),
+ *   ),
+ * );
+ *
+ * // undefined
+ * validateArray(values);
+ * ```
+ */
+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/node/arrayItem/arrayItem.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayItem = void 0;
+const core_1 = require("../core");
+/**
+ * Применяет правила к каждому элементу массива
+ * @param rules - правила валидации, которое применится к каждому элементу массива
+ * @example
+ * ```ts
+ * type Item = {
+ *   name: string;
+ *   age?: number;
+ * };
+ *
+ * const values: Values = [{ name: 'Vasya' }, { name: 'Vasya', age: 22 }];
+ *
+ * const validateArray = array(
+ *   arrayItem(
+ *     object<Item>({
+ *       name: string(min(2)),
+ *       age: optional(number()),
+ *     }),
+ *   ),
+ * );
+ *
+ * // undefined
+ * validateArray(values);
+ * ```
+ */
+const arrayItem = (...rules) => (0, core_1.createRule)((array, ctx) => {
+    const validationItemsResult = array.map((item) => (0, core_1.compose)(...rules)(item, ctx));
+    if (validationItemsResult.some((result) => result !== undefined)) {
+        return (0, core_1.createArrayError)(validationItemsResult);
+    }
+    return undefined;
+});
+exports.arrayItem = arrayItem;

package/node/arrayItem/index.d.ts

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

package/node/arrayItem/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arrayItem"), exports);

package/node/boolean/boolean.d.ts

@@ -0,0 +1,13 @@
+import { type ValidationRule } from '../core';
+/**
+ * Guard для boolean. Проверяет значение на тип boolean
+ * @param rules - правила, валидирующие boolean или unknown value
+ * @example
+ * ```ts
+ *  const validate = boolean();
+ *
+ *  // undefined
+ *  validate(true);
+ * ```
+ */
+export declare const boolean: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<boolean, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/node/boolean/boolean.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Guard для boolean. Проверяет значение на тип boolean
+ * @param rules - правила, валидирующие boolean или unknown value
+ * @example
+ * ```ts
+ *  const validate = boolean();
+ *
+ *  // undefined
+ *  validate(true);
+ * ```
+ */
+const boolean = (...rules) => (0, core_1.createGuard)((value, ctx, { typeErrorMessage }) => {
+    if (typeof value !== 'boolean') {
+        return ctx.createError(Object.assign(Object.assign({}, constants_1.BOOLEAN_TYPE_ERROR_INFO), { message: typeErrorMessage || constants_1.BOOLEAN_TYPE_ERROR_INFO.message }));
+    }
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.boolean = boolean;

package/node/boolean/constants.d.ts

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

package/node/boolean/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOOLEAN_TYPE_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.BOOLEAN_TYPE_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('boolean-type'),
+    message: 'Не boolean',
+};

package/node/boolean/index.d.ts

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

package/node/boolean/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./constants"), exports);

package/node/containsDifferentCases/constants.d.ts

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

package/node/containsDifferentCases/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTAINS_DIFFERENT_CASES_ERROR_CODE = void 0;
+const core_1 = require("../core");
+exports.CONTAINS_DIFFERENT_CASES_ERROR_CODE = (0, core_1.createErrorCode)('containsDifferentCases');

package/node/containsDifferentCases/containsDifferentCases.d.ts

@@ -0,0 +1,16 @@
+type ContainsDifferentCasesParams = {
+    /**
+     * Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * Проверяет на наличие в строке символов разных регистров
+ * @example
+ * ```ts
+ *  const validate = string(containsDifferentCases());
+ *  validate('testTEST');
+ * ```
+ */
+export declare const containsDifferentCases: <TLastSchemaValues extends Record<string, unknown>>(params?: ContainsDifferentCasesParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/containsDifferentCases/containsDifferentCases.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsDifferentCases = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Проверяет на наличие в строке символов разных регистров
+ * @example
+ * ```ts
+ *  const validate = string(containsDifferentCases());
+ *  validate('testTEST');
+ * ```
+ */
+const containsDifferentCases = (params) => (0, core_1.createRule)((value, ctx) => {
+    const containsLowerCaseRegex = /(?=.*[A-ZА-ЯЁ])/;
+    const containsUpperCaseRegex = /(?=.*[a-zа-яё])/;
+    if (!containsLowerCaseRegex.test(value) ||
+        !containsUpperCaseRegex.test(value)) {
+        return ctx.createError({
+            code: constants_1.CONTAINS_DIFFERENT_CASES_ERROR_CODE,
+            message: (params === null || params === void 0 ? void 0 : params.message) || 'Строка должна содержать символы разного регистра',
+        });
+    }
+    return undefined;
+});
+exports.containsDifferentCases = containsDifferentCases;

package/node/containsDifferentCases/index.d.ts

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

package/node/containsDifferentCases/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./containsDifferentCases"), exports);

package/node/containsNumbers/constants.d.ts

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

package/node/containsNumbers/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTAINS_NUMBERS_ERROR_CODE = void 0;
+const core_1 = require("../core");
+exports.CONTAINS_NUMBERS_ERROR_CODE = (0, core_1.createErrorCode)('containsNumbers');

package/node/containsNumbers/containsNumbers.d.ts

@@ -0,0 +1,16 @@
+type ContainsNumbersParams = {
+    /**
+     * Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * Проверяет на наличие чисел в строке
+ * @example
+ * ```ts
+ *  const validate = string(containsNumbers());
+ *  validate('test123');
+ * ```
+ */
+export declare const containsNumbers: <TLastSchemaValues extends Record<string, unknown>>(params?: ContainsNumbersParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/containsNumbers/containsNumbers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsNumbers = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Проверяет на наличие чисел в строке
+ * @example
+ * ```ts
+ *  const validate = string(containsNumbers());
+ *  validate('test123');
+ * ```
+ */
+const containsNumbers = (params) => (0, core_1.createRule)((value, ctx) => {
+    const containsNumbersRegex = /\d/;
+    if (!containsNumbersRegex.test(value)) {
+        return ctx.createError({
+            code: constants_1.CONTAINS_NUMBERS_ERROR_CODE,
+            message: (params === null || params === void 0 ? void 0 : params.message) || 'Строка должна содержать числа',
+        });
+    }
+    return undefined;
+});
+exports.containsNumbers = containsNumbers;

package/node/containsNumbers/index.d.ts

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

package/node/containsNumbers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./containsNumbers"), exports);

package/node/containsPunctuationMarks/constants.d.ts

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

package/node/containsPunctuationMarks/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTAINS_PUNCTUATION_MARKS_ERROR_CODE = void 0;
+const core_1 = require("../core");
+exports.CONTAINS_PUNCTUATION_MARKS_ERROR_CODE = (0, core_1.createErrorCode)('containsPunctuationMarks');

package/node/containsPunctuationMarks/containsPunctuationMarks.d.ts

@@ -0,0 +1,16 @@
+type ContainsPunctuationMarksParams = {
+    /**
+     * Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * Проверяет на наличие в строке знаков пунктуации !$%&’()+,-./:;<=>?@[]^_{|}”
+ * @example
+ * ```ts
+ *  const validate = string(containsPunctuationMarks());
+ *  validate('test?');
+ * ```
+ */
+export declare const containsPunctuationMarks: <TLastSchemaValues extends Record<string, unknown>>(params?: ContainsPunctuationMarksParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/node/containsPunctuationMarks/containsPunctuationMarks.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsPunctuationMarks = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Проверяет на наличие в строке знаков пунктуации !$%&’()+,-./:;<=>?@[]^_{|}”
+ * @example
+ * ```ts
+ *  const validate = string(containsPunctuationMarks());
+ *  validate('test?');
+ * ```
+ */
+const containsPunctuationMarks = (params) => (0, core_1.createRule)((value, ctx) => {
+    const containsPunctuationMarksRegex = /(?=.*[!$%&’”'"()+,-.\/:;<=>?@\[\]^_{|}])/;
+    if (!containsPunctuationMarksRegex.test(value)) {
+        return ctx.createError({
+            code: constants_1.CONTAINS_PUNCTUATION_MARKS_ERROR_CODE,
+            message: (params === null || params === void 0 ? void 0 : params.message) || 'Строка должна содержать знаки пунктуации',
+        });
+    }
+    return undefined;
+});
+exports.containsPunctuationMarks = containsPunctuationMarks;

package/node/containsPunctuationMarks/index.d.ts

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

package/node/containsPunctuationMarks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./containsPunctuationMarks"), exports);

package/node/core/compose/compose.d.ts

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

package/node/core/compose/compose.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const rule_1 = require("../rule");
+/**
+ * Объединяет переданные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
+ * @example compose(min(), max());
+ */
+const compose = (...rules) => (value, ctx) => rules.reduce((result, rule) => result ||
+    (0, rule_1.callRule)(rule, value, ctx), undefined);
+exports.compose = compose;

package/node/core/compose/index.d.ts

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

package/node/core/compose/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compose"), exports);

package/node/core/composeAsync/composeAsync.d.ts

@@ -0,0 +1,6 @@
+import { type AsyncIndependentValidationRule, type AsyncValidationRule, type IndependentValidationRule, type ValidationRule } from '../rule';
+/**
+ * Объединяет переданные асинхронные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
+ * @example composeAsync(stringAsync(), max());
+ */
+export declare const composeAsync: <ValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: Array<IndependentValidationRule<ValidationType, TLastSchemaValues> | AsyncIndependentValidationRule<ValidationType, TLastSchemaValues> | ValidationRule<ValidationType, TLastSchemaValues> | AsyncValidationRule<ValidationType, TLastSchemaValues>>) => AsyncIndependentValidationRule<ValidationType, Record<string, unknown>>;

package/node/core/composeAsync/composeAsync.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeAsync = void 0;
+const rule_1 = require("../rule");
+/**
+ * Объединяет переданные асинхронные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
+ * @example composeAsync(stringAsync(), max());
+ */
+const composeAsync = (...rules) => (value, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    let result;
+    for (const rule of rules) {
+        result = yield (0, rule_1.callAsyncRule)(rule, value, ctx);
+        if (result) {
+            break;
+        }
+    }
+    return result;
+});
+exports.composeAsync = composeAsync;

package/node/core/composeAsync/index.d.ts

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