@astral/validations 4.20.3 → 4.20.4

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

@@ -0,0 +1,71 @@
+import { type ValidationResult } from '../../types';
+import { type ValidationContext } from '../../context';
+export type GuardDefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
+    /**
+     * Переопределяет дефолтное сообщения ошибки для required
+     * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
+     */
+    requiredErrorMessage?: string;
+    /**
+     * Переопределяет сообщение об ошибке типа
+     * @example string.define({ typeErrorMessage: 'ИНН не может быть числом' })(inn())
+     */
+    typeErrorMessage?: string;
+    /**
+     * Позволяет выключать проверку на required
+     * @default false
+     */
+    isOptional?: boolean;
+};
+export type GuardValue = unknown;
+/**
+ * Интерфейс функции guard, которая в прототипе содержит метод define
+ */
+export interface Guard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): ValidationResult;
+    /**
+     * Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
+     * @param options - параметры, позволяющие переопределить дефолтные настройки guard
+     * @example string(inn()).define({ requiredMessage: 'ИНН не может быть пустым' })
+     */
+    define<TDefineLastSchemaValues extends Record<string, unknown> = {}>(options: GuardDefOptions<AddDefOptions>): Guard<TDefineLastSchemaValues, AddDefOptions>;
+}
+/**
+ * Интерфейс асинхронной функции guard, которая в прототипе содержит метод define
+ */
+export interface AsyncGuard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): Promise<ValidationResult>;
+    /**
+     * Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
+     * @param options - параметры, позволяющие переопределить дефолтные настройки guard
+     * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
+     */
+    define(options: GuardDefOptions<AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
+}
+/**
+ * Функция, которая позволяет определять частную логику для guard
+ */
+type GuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => ValidationResult;
+/**
+ * Функция, которая позволяет определять частную логику для guard
+ */
+type AsyncGuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => Promise<ValidationResult>;
+/**
+ * Создает guard. Guard - функция, проверяющая тип значения
+ * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
+ * После первого вызова guard в прототипу функции становится доступен метод define, который позволяет переопределить дефолтное поведение guard (например, изменить текст для required правила)
+ * @example
+ * ```ts
+ * 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: 'Не строка' });
+ *     }
+ *
+ *     return compose<string, TValues>(...rules)(value, ctx);
+ *   });
+ * ```
+ */
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: GuardExecutor<TLastSchemaValues, AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: AsyncGuardExecutor<TLastSchemaValues, AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
+export {};

package/node/core/guard/createGuard/createGuard.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGuard = void 0;
+const rule_1 = require("../../rule");
+const context_1 = require("../../context");
+function createGuard(executor) {
+    // выделено в отдельную именованную функцию для того, чтобы ее можно было рекурсивно вызывать в define
+    const createInnerGuard = (defOptions = {}) => {
+        const guard = (value, prevCtx) => {
+            const actualDefOptions = Object.assign(Object.assign({}, defOptions), { isOptional: (prevCtx === null || prevCtx === void 0 ? void 0 : prevCtx.isOptional) || defOptions.isOptional });
+            const ctx = (0, context_1.createContext)(prevCtx, value, {
+                // данная конструкция останавливает погружение isOptional в последующие guard
+                isOptional: false,
+            });
+            const requiredResult = (0, rule_1.required)({
+                message: actualDefOptions === null || actualDefOptions === void 0 ? void 0 : actualDefOptions.requiredErrorMessage,
+            })(value, ctx);
+            if ((actualDefOptions === null || actualDefOptions === void 0 ? void 0 : actualDefOptions.isOptional) && requiredResult) {
+                return undefined;
+            }
+            return requiredResult || executor(value, ctx, actualDefOptions);
+        };
+        guard.define = (overridesDefOptions) => createInnerGuard(overridesDefOptions);
+        return guard;
+    };
+    return createInnerGuard();
+}
+exports.createGuard = createGuard;

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

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

package/node/core/guard/createGuard/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("./createGuard"), exports);

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

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

package/node/core/guard/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("./createGuard"), exports);

package/node/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './errors';
+export * from './context';
+export * from './errors';
+export * from './guard';
+export * from './rule';
+export * from './compose';
+export * from './composeAsync';
+export * from './utils';

package/node/core/index.js

@@ -0,0 +1,25 @@
+"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("./types"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./guard"), exports);
+__exportStar(require("./rule"), exports);
+__exportStar(require("./compose"), exports);
+__exportStar(require("./composeAsync"), exports);
+__exportStar(require("./utils"), exports);

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

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

package/node/core/logger/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("./logger"), exports);

package/node/core/logger/logger.d.ts

@@ -0,0 +1,6 @@
+declare class Logger {
+    private packageName;
+    error: (message: string, err: Error) => void;
+}
+export declare const logger: Logger;
+export {};

package/node/core/logger/logger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+class Logger {
+    constructor() {
+        this.packageName = '@astral/validations';
+        this.error = (message, err) => {
+            console.error(`${this.packageName}: ${message}`, err);
+        };
+    }
+}
+exports.logger = new Logger();

package/node/core/rule/callAsyncRule/callAsyncRule.d.ts

@@ -0,0 +1,8 @@
+import { type AsyncValidationRule, type ValidationRule } from '../types';
+import { type ValidationResult } from '../../types';
+import { type ValidationContext } from '../../context';
+/**
+ * Позволяет рекурсивно вызывать асинхронные правила. Rule может возвращать другой rule
+ * Если один из rule выбросит exception, то функция его обработает и вернет дефолтную ошибку
+ */
+export declare const callAsyncRule: <TValue, TLastSchemaValues extends Record<string, unknown>>(rule: ValidationRule<TValue, TLastSchemaValues> | AsyncValidationRule<TValue, TLastSchemaValues>, value: TValue, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult | Promise<ValidationResult>;

package/node/core/rule/callAsyncRule/callAsyncRule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAsyncRule = void 0;
+const errors_1 = require("../../errors");
+const logger_1 = require("../../logger");
+/**
+ * Позволяет рекурсивно вызывать асинхронные правила. Rule может возвращать другой rule
+ * Если один из rule выбросит exception, то функция его обработает и вернет дефолтную ошибку
+ */
+const callAsyncRule = (rule, value, ctx) => {
+    const ruleResult = rule(value, ctx);
+    if (ruleResult && 'then' in ruleResult) {
+        return ruleResult
+            .then((result) => {
+            if (typeof result === 'function') {
+                return (0, exports.callAsyncRule)(result, value, ctx);
+            }
+            return result;
+        })
+            .catch((err) => {
+            logger_1.logger.error('Ошибка при выполнении асинхронного правила', err);
+            return ctx.createError(errors_1.REJECT_PROMISE_ERROR_INFO);
+        });
+    }
+    return typeof ruleResult === 'function'
+        ? (0, exports.callAsyncRule)(ruleResult, value, ctx)
+        : ruleResult;
+};
+exports.callAsyncRule = callAsyncRule;

package/node/core/rule/callAsyncRule/index.d.ts

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

package/node/core/rule/callAsyncRule/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("./callAsyncRule"), exports);

package/node/core/rule/callRule/callRule.d.ts

@@ -0,0 +1,7 @@
+import { type ValidationRule } from '../types';
+import { type ValidationResult } from '../../types';
+import { type ValidationContext } from '../../context';
+/**
+ * Позволяет рекурсивно вызывать правила. Rule может возвращать другой rule
+ */
+export declare const callRule: <TValue, TLastSchemaValues extends Record<string, unknown>>(rule: ValidationRule<TValue, TLastSchemaValues>, value: TValue, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;

package/node/core/rule/callRule/callRule.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callRule = void 0;
+/**
+ * Позволяет рекурсивно вызывать правила. Rule может возвращать другой rule
+ */
+const callRule = (rule, value, ctx) => {
+    const ruleResult = rule(value, ctx);
+    return typeof ruleResult === 'function'
+        ? (0, exports.callRule)(ruleResult, value, ctx)
+        : ruleResult;
+};
+exports.callRule = callRule;

package/node/core/rule/callRule/index.d.ts

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

package/node/core/rule/callRule/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("./callRule"), exports);

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

@@ -0,0 +1,34 @@
+import { type ValidationResult, type ValidationTypes } from '../../types';
+import { type ValidationContext } from '../../context';
+import { type IndependentValidationRule } from '../types';
+/**
+ * Единые параметры для всех правил
+ */
+export type CommonRuleParams<ValidationType extends ValidationTypes> = {
+    /**
+     * Функция, позволяющая для каждого правила указать исключение
+     */
+    exclude?: (value: ValidationType, ctx: ValidationContext) => boolean;
+};
+/**
+ * Функция, которая позволяет определять частную логику для guard
+ */
+type RuleExecutor<ValidationType extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>> = (value: ValidationType, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult;
+/**
+ * Создает правила валидации, которые можно использовать внутри guard или по отдельности
+ * @param executor - функция, которая позволяет определять частную логику для guard
+ * @param commonParams - единые параметры для всех rule
+ * @example
+ * ```ts
+ * const inn = (params: CommonRuleParams<string> & { message?: string }) =>
+ *   createRule<string>((value, ctx) => {
+ *     if (!isInn(value)) {
+ *       return ctx.createError({ code: 'custom error', message: params?.message || 'Неверный ИНН' });
+ *     }
+ *
+ *     return undefined;
+ *   }, params);
+ * ```
+ */
+export declare const createRule: <ValidationType extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(executor: RuleExecutor<ValidationType, TLastSchemaValues>, commonParams?: CommonRuleParams<ValidationType>) => (value: Parameters<IndependentValidationRule<ValidationType, TLastSchemaValues>>[0], prevCtx?: Parameters<IndependentValidationRule<ValidationType, TLastSchemaValues>>[1]) => ReturnType<IndependentValidationRule<ValidationType, TLastSchemaValues>>;
+export {};

package/node/core/rule/createRule/createRule.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+const context_1 = require("../../context");
+/**
+ * Создает правила валидации, которые можно использовать внутри guard или по отдельности
+ * @param executor - функция, которая позволяет определять частную логику для guard
+ * @param commonParams - единые параметры для всех rule
+ * @example
+ * ```ts
+ * const inn = (params: CommonRuleParams<string> & { message?: string }) =>
+ *   createRule<string>((value, ctx) => {
+ *     if (!isInn(value)) {
+ *       return ctx.createError({ code: 'custom error', message: params?.message || 'Неверный ИНН' });
+ *     }
+ *
+ *     return undefined;
+ *   }, params);
+ * ```
+ */
+const createRule = (executor, commonParams) => (value, prevCtx) => {
+    var _a;
+    // контекст создается, если он не был создан раннее
+    const ctx = (0, context_1.createContext)(prevCtx, value);
+    // если value попало под исключения из правил, то дальше валидацию не продолжаем
+    if ((_a = commonParams === null || commonParams === void 0 ? void 0 : commonParams.exclude) === null || _a === void 0 ? void 0 : _a.call(commonParams, value, ctx)) {
+        return undefined;
+    }
+    return executor(value, ctx);
+};
+exports.createRule = createRule;

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

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

package/node/core/rule/createRule/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("./createRule"), exports);

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

@@ -0,0 +1,5 @@
+export * from './createRule';
+export * from './types';
+export * from './required';
+export * from './callRule';
+export * from './callAsyncRule';

package/node/core/rule/index.js

@@ -0,0 +1,21 @@
+"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("./createRule"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./required"), exports);
+__exportStar(require("./callRule"), exports);
+__exportStar(require("./callAsyncRule"), exports);

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

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

package/node/core/rule/required/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_ERROR_INFO = void 0;
+const errors_1 = require("../../errors");
+exports.REQUIRED_ERROR_INFO = {
+    code: (0, errors_1.createErrorCode)('required'),
+    message: 'Обязательно',
+};

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

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

package/node/core/rule/required/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("./required"), exports);
+__exportStar(require("./constants"), exports);

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

@@ -0,0 +1,11 @@
+/**
+ * Проверяет value на пустоту. Если значение пустое, то возвращает ошибку.
+ * Правило универсально для всех типов данных
+ */
+export declare const required: ({ message, }?: {
+    /**
+     * Кастомное сообщение ошибки
+     * @default Обязательно
+     */
+    message?: string;
+}) => (value: unknown, prevCtx?: import("../..").ValidationContext<{}> | undefined) => import("../..").ValidationResult;

package/node/core/rule/required/required.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.required = void 0;
+const createRule_1 = require("../createRule");
+const constants_1 = require("./constants");
+/**
+ * Проверяет value на пустоту. Если значение пустое, то возвращает ошибку.
+ * Правило универсально для всех типов данных
+ */
+const required = ({ message, } = {}) => (0, createRule_1.createRule)((value, ctx) => {
+    const createRequiredError = () => ctx.createError(Object.assign(Object.assign({}, constants_1.REQUIRED_ERROR_INFO), { message: message || constants_1.REQUIRED_ERROR_INFO.message }));
+    if (value === null) {
+        return createRequiredError();
+    }
+    if (typeof value === 'object') {
+        return undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'symbol') {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value.trim() ? undefined : createRequiredError();
+    }
+    if (typeof value === 'boolean') {
+        return value ? undefined : createRequiredError();
+    }
+    return createRequiredError();
+});
+exports.required = required;

package/node/core/rule/types.d.ts

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

package/node/core/rule/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/core/types.d.ts

@@ -0,0 +1,9 @@
+import { type ValidationError } from './errors';
+/**
+ * Результат работы валидации
+ */
+export type ValidationResult = ValidationError | undefined;
+/**
+ * Доступные для валидации типы value
+ */
+export type ValidationTypes = unknown | object | string | number | Date | Array<unknown>;

package/node/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+export * from './isDateEarlier';
+export * from './isFullNameValidCharacters';
+export * from './isHasConsecutiveChars';
+export * from './isNoDoubleZeroStart';
+export * from './isStartsWithAndEndsWithLetter';
+export * from './isStringOfZeros';
+export * from './isValidFullNameLength';
+export * from './resetTime';

package/node/core/utils/index.js

@@ -0,0 +1,24 @@
+"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("./isDateEarlier"), exports);
+__exportStar(require("./isFullNameValidCharacters"), exports);
+__exportStar(require("./isHasConsecutiveChars"), exports);
+__exportStar(require("./isNoDoubleZeroStart"), exports);
+__exportStar(require("./isStartsWithAndEndsWithLetter"), exports);
+__exportStar(require("./isStringOfZeros"), exports);
+__exportStar(require("./isValidFullNameLength"), exports);
+__exportStar(require("./resetTime"), exports);

package/node/core/utils/isDateEarlier/index.d.ts

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