@astral/validations 4.20.2 → 4.20.4

package/node/toPrettyError/toPrettyError.d.ts

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

package/node/toPrettyError/toPrettyError.js

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

package/node/transform/index.d.ts

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

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

package/node/transform/transform.d.ts

@@ -0,0 +1,18 @@
+import { type ValidationRule } from '../core';
+type Transformer<TValue, TResult> = (value: TValue) => TResult;
+/**
+ * Трансформирует value в новый тип для валидации
+ * @param transformer - функция трансформации value в новый тип
+ * @param rules - правила, которые будут вызваны после трансформации value
+ * @example
+ * ```ts
+ *  string(
+ *    transform(
+ *      (value) => new Date(value),
+ *      date(min(new Date()))
+ *     )
+ *  );
+ * ```
+ */
+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/node/transform/transform.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const core_1 = require("../core");
+/**
+ * Трансформирует value в новый тип для валидации
+ * @param transformer - функция трансформации value в новый тип
+ * @param rules - правила, которые будут вызваны после трансформации value
+ * @example
+ * ```ts
+ *  string(
+ *    transform(
+ *      (value) => new Date(value),
+ *      date(min(new Date()))
+ *     )
+ *  );
+ * ```
+ */
+const transform = (transformer, ...rules) => (0, core_1.createRule)((value, ctx) => (0, core_1.compose)(...rules)(transformer(value), ctx));
+exports.transform = transform;

package/node/uploadedFile/constants.d.ts

@@ -0,0 +1,5 @@
+import { type ErrorInfo } from '../core';
+export declare const FILE_RESTRICTION_ERROR_INFO: ErrorInfo;
+export declare const FILE_LOADING_ERROR_INFO: ErrorInfo;
+export declare const FILE_UPLOAD_ERROR_INFO: ErrorInfo;
+export declare const FILE_REQUIRED_ERROR_INFO: ErrorInfo;

package/node/uploadedFile/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILE_REQUIRED_ERROR_INFO = exports.FILE_UPLOAD_ERROR_INFO = exports.FILE_LOADING_ERROR_INFO = exports.FILE_RESTRICTION_ERROR_INFO = void 0;
+const core_1 = require("../core");
+exports.FILE_RESTRICTION_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('file-restriction'),
+    message: 'Файл не соответствует ограничениям',
+};
+exports.FILE_LOADING_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('file-loading'),
+    message: 'Файл загружается',
+};
+exports.FILE_UPLOAD_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('file-upload'),
+    message: 'Ошибка загрузки файла',
+};
+exports.FILE_REQUIRED_ERROR_INFO = {
+    code: (0, core_1.createErrorCode)('file-required'),
+    message: 'Загрузите файл',
+};

package/node/uploadedFile/index.d.ts

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

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

package/node/uploadedFile/types.d.ts

@@ -0,0 +1,46 @@
+type FileStatus = {
+    /**
+     * Флаг загрузки файла
+     */
+    isLoading?: boolean;
+    /**
+     * Флаг состояния ошибки при загрузке файла
+     */
+    isUploadError?: boolean;
+    /**
+     * Флаг состояния ошибки при проверке файла на условия
+     */
+    isRestrictionError?: boolean;
+    /**
+     * Текст ошибки
+     */
+    errorMsg?: string;
+    /**
+     * Значение прогресса загрузки файла.
+     */
+    progress?: number;
+};
+export type UploadFile = {
+    /**
+     * Идентификатор
+     */
+    id: string;
+    /**
+     * Название файла
+     */
+    name: string;
+    /**
+     * Размер файла в байтах
+     */
+    size?: number;
+    file?: File;
+    /**
+     * Ссылка на файле
+     */
+    url?: string;
+    /**
+     * Состояния файла
+     */
+    status?: FileStatus;
+};
+export {};

package/node/uploadedFile/types.js

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

package/node/uploadedFile/uploadedFile.d.ts

@@ -0,0 +1,30 @@
+import { type ValidationRule } from '../core';
+import type { UploadFile } from './types';
+/**
+ * Guard для файла. Проверяет объект на соответствие формату UploadFile и его статусы загрузки.
+ * Валидирует наличие обязательных полей (id, name) и проверяет статусы файла (isLoading, isUploadError, isRestrictionError).
+ * @param rules - дополнительные правила валидации для файла
+ * @example
+ * ```ts
+ * const validate = uploadedFile();
+ *
+ * // Валидный файл
+ * validate({
+ *   id: 1,
+ *   name: "document.pdf",
+ *   status: {
+ *     isLoading: false
+ *   }
+ * });
+ *
+ * // Файл с ошибкой загрузки
+ * validate({
+ *   id: 1,
+ *   name: "document.pdf",
+ *   status: {
+ *     isUploadError: true
+ *   }
+ * });
+ * ```
+ */
+export declare const uploadedFile: <TLastSchemeValues extends Record<string, unknown>>(...rules: ValidationRule<UploadFile, TLastSchemeValues>[]) => import("../core").Guard<TLastSchemeValues, {}>;

package/node/uploadedFile/uploadedFile.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadedFile = void 0;
+const core_1 = require("../core");
+const constants_1 = require("./constants");
+/**
+ * Guard для файла. Проверяет объект на соответствие формату UploadFile и его статусы загрузки.
+ * Валидирует наличие обязательных полей (id, name) и проверяет статусы файла (isLoading, isUploadError, isRestrictionError).
+ * @param rules - дополнительные правила валидации для файла
+ * @example
+ * ```ts
+ * const validate = uploadedFile();
+ *
+ * // Валидный файл
+ * validate({
+ *   id: 1,
+ *   name: "document.pdf",
+ *   status: {
+ *     isLoading: false
+ *   }
+ * });
+ *
+ * // Файл с ошибкой загрузки
+ * validate({
+ *   id: 1,
+ *   name: "document.pdf",
+ *   status: {
+ *     isUploadError: true
+ *   }
+ * });
+ * ```
+ */
+const uploadedFile = (...rules) => (0, core_1.createGuard)((value, ctx) => {
+    if (!value ||
+        typeof value !== 'object' ||
+        !('id' in value) ||
+        !('name' in value)) {
+        return ctx.createError({
+            code: constants_1.FILE_REQUIRED_ERROR_INFO.code,
+            message: constants_1.FILE_REQUIRED_ERROR_INFO.message,
+        });
+    }
+    const { status } = value;
+    if (status === null || status === void 0 ? void 0 : status.isRestrictionError) {
+        return ctx.createError({
+            code: constants_1.FILE_RESTRICTION_ERROR_INFO.code,
+            message: status.errorMsg || constants_1.FILE_RESTRICTION_ERROR_INFO.message,
+        });
+    }
+    if (status === null || status === void 0 ? void 0 : status.isLoading) {
+        return ctx.createError({
+            code: constants_1.FILE_LOADING_ERROR_INFO.code,
+            message: status.errorMsg || constants_1.FILE_LOADING_ERROR_INFO.message,
+        });
+    }
+    if (status === null || status === void 0 ? void 0 : status.isUploadError) {
+        return ctx.createError({
+            code: constants_1.FILE_UPLOAD_ERROR_INFO.code,
+            message: status.errorMsg || constants_1.FILE_UPLOAD_ERROR_INFO.message,
+        });
+    }
+    return (0, core_1.compose)(...rules)(value, ctx);
+});
+exports.uploadedFile = uploadedFile;

package/node/uploadedFileList/constants.d.ts

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

package/node/uploadedFileList/constants.js

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

package/node/uploadedFileList/index.d.ts

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

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

package/node/uploadedFileList/uploadedFileList.d.ts

@@ -0,0 +1,24 @@
+import { type ValidationRule } from '../core';
+import { type UploadFile } from '../uploadedFile/types';
+/**
+ * Guard для списка файлов. Проверяет массив на валидность и каждый файл в массиве на соответствие формату UploadFile.
+ * Проверяет статусы файлов (isLoading, isUploadError, isRestrictionError).
+ * @param rules - дополнительные правила валидации для массива файлов
+ * @example
+ * ```ts
+ * const validate = uploadedFileList();
+ *
+ * // Валидный массив файлов
+ * validate([
+ *   { id: 1, name: "document1.pdf" },
+ *   { id: 2, name: "document2.pdf", status: { isLoading: false } }
+ * ]);
+ *
+ * // Массив с ошибкой загрузки
+ * validate([
+ *   { id: 1, name: "document1.pdf" },
+ *   { id: 2, name: "document2.pdf", status: { isUploadError: true } }
+ * ]);
+ * ```
+ */
+export declare const uploadedFileList: <TLastSchemeValues extends Record<string, unknown>>(...rules: ValidationRule<UploadFile[], TLastSchemeValues>[]) => import("../core").Guard<TLastSchemeValues, {}>;

package/node/uploadedFileList/uploadedFileList.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadedFileList = void 0;
+const core_1 = require("../core");
+const array_1 = require("../array");
+const uploadedFile_1 = require("../uploadedFile");
+const constants_1 = require("./constants");
+/**
+ * Guard для списка файлов. Проверяет массив на валидность и каждый файл в массиве на соответствие формату UploadFile.
+ * Проверяет статусы файлов (isLoading, isUploadError, isRestrictionError).
+ * @param rules - дополнительные правила валидации для массива файлов
+ * @example
+ * ```ts
+ * const validate = uploadedFileList();
+ *
+ * // Валидный массив файлов
+ * validate([
+ *   { id: 1, name: "document1.pdf" },
+ *   { id: 2, name: "document2.pdf", status: { isLoading: false } }
+ * ]);
+ *
+ * // Массив с ошибкой загрузки
+ * validate([
+ *   { id: 1, name: "document1.pdf" },
+ *   { id: 2, name: "document2.pdf", status: { isUploadError: true } }
+ * ]);
+ * ```
+ */
+const uploadedFileList = (...rules) => (0, core_1.createGuard)((value, ctx) => {
+    if ((0, array_1.array)()(value)) {
+        return ctx.createError({
+            code: constants_1.FILE_LIST_NOT_ARRAY_ERROR_INFO.code,
+            message: constants_1.FILE_LIST_NOT_ARRAY_ERROR_INFO.message,
+        });
+    }
+    const uploadFileList = value;
+    for (const item of uploadFileList) {
+        if ((0, uploadedFile_1.uploadedFile)()(item)) {
+            const error = (0, uploadedFile_1.uploadedFile)()(item, ctx);
+            if (error) {
+                return error;
+            }
+        }
+    }
+    return (0, core_1.compose)(...rules)(uploadFileList, ctx);
+});
+exports.uploadedFileList = uploadedFileList;

package/node/when/index.d.ts

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

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

package/node/when/when.d.ts

@@ -0,0 +1,39 @@
+import { type ValidationContext, type ValidationRule } from '../core';
+type Params<TLastSchemaValues extends Record<string, unknown>> = {
+    /**
+     * Условие для выбора ветки
+     */
+    is: (value: unknown, ctx: ValidationContext<TLastSchemaValues>) => boolean;
+    /**
+     * Правила валидации, применяемые если is === true
+     */
+    then: ValidationRule<unknown, TLastSchemaValues>;
+    /**
+     * Правила валидации, применяемые если is === false
+     */
+    otherwise: ValidationRule<unknown, TLastSchemaValues>;
+};
+/**
+ * Позволяет указывать условные валидации
+ * @example
+ * ```ts
+ * type Values = { name: string; isAgree: boolean };
+ *
+ * const validate = object<Values>({
+ *   name: when({
+ *     is: (_, ctx) => ctx.global.values.isAgree,
+ *     then: string(),
+ *     otherwise: any(),
+ *   }),
+ *   isAgree: optional(boolean()),
+ * });
+ *
+ * // undefined
+ * const result1 = validate({ isAgree: false, name: '' });
+ *
+ * // Required error для name
+ * const result2 = validate({ isAgree: true, name: '' });
+ * ```
+ */
+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/node/when/when.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.when = void 0;
+const core_1 = require("../core");
+/**
+ * Позволяет указывать условные валидации
+ * @example
+ * ```ts
+ * type Values = { name: string; isAgree: boolean };
+ *
+ * const validate = object<Values>({
+ *   name: when({
+ *     is: (_, ctx) => ctx.global.values.isAgree,
+ *     then: string(),
+ *     otherwise: any(),
+ *   }),
+ *   isAgree: optional(boolean()),
+ * });
+ *
+ * // undefined
+ * const result1 = validate({ isAgree: false, name: '' });
+ *
+ * // Required error для name
+ * const result2 = validate({ isAgree: true, name: '' });
+ * ```
+ */
+const when = ({ is, then, otherwise, }) => (0, core_1.createRule)((value, ctx) => {
+    if (is(value, ctx)) {
+        return (0, core_1.callRule)(then, value, ctx);
+    }
+    return (0, core_1.callRule)(otherwise, value, ctx);
+});
+exports.when = when;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@astral/validations",
-  "version": "4.20.2",
+  "version": "4.20.4",
   "browser": "./index.js",
-  "main": "./index.js",
+  "main": "./mode/index.js",
   "dependencies": {
     "is-plain-obj": "^4.1.0",
     "utility-types": "^3.10.0",
@@ -22,6 +22,10 @@
   "types": "./index.d.ts",
   "module": "./index.js",
   "exports": {
-    ".": "./index.js"
+    ".": {
+      "vitest": "./node/index.js",
+      "module": "./index.js",
+      "require": "./node/index.js"
+    }
   }
 }