@astral/validations 4.13.3 → 4.14.1

package/README.md

@@ -71,6 +71,7 @@
 - [Common](#common)
   - [optional](#optional)
   - [when. Условная валидация](#when-условная-валидация)
+  - [enabled. Условная валидация](#enabled-условная-валидация)
   - [transform](#transform)
   - [or](#or)
 - [Async](#async)
@@ -1607,6 +1608,57 @@ toPrettyError(
   validate({ name: 'Vasya' })
 );
 
+// undefined
+validate({ name: 'Kolya' });
+```
+---
+
+## enabled. Условная валидация
+
+Позволяет определять условные валидации без выбора альтернативной схемы. Является упрощением when с otherwise = any().
+
+```ts
+type Values = { name: string; isAgree: boolean };
+
+const validate = object<Values>({
+  name: enabled({
+    is: (_, ctx) => Boolean(ctx.values?.isAgree),
+    then: string(),
+  }),
+  isAgree: optional(boolean()),
+});
+
+// undefined
+validate({ isAgree: false, name: '' });
+
+// { name: 'Обязательно' }
+toPrettyError(
+  validate({ isAgree: true, name: '' })
+);
+```
+
+Enabled для ветки объекта:
+```ts
+type ValuesInfo = { surname: string };
+
+type Values = {
+  name: string;
+  info?: ValuesInfo;
+};
+
+const validate = object<Values>({
+  name: string(),
+  info: enabled({
+    is: (_, ctx) => ctx.values?.name === 'Vasya',
+    then: object<ValuesInfo>({ surname: string() }),
+  }),
+});
+
+// { info: 'Обязательно' }
+toPrettyError(
+  validate({ name: 'Vasya' })
+);
+
 // undefined
 validate({ name: 'Kolya' });
 ```

package/array/array.d.ts

@@ -12,4 +12,4 @@ import { type ValidationRule } from '../core';
  * validateArray(value);
  * ```
  */
-export declare const array: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<TItem[], TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;
+export declare const array: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<Array<TItem>, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/core/compose/compose.d.ts

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

package/core/composeAsync/composeAsync.d.ts

@@ -3,4 +3,4 @@ import { type AsyncIndependentValidationRule, type AsyncValidationRule, type Ind
  * Объединяет переданные асинхронные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
  * @example composeAsync(stringAsync(), max());
  */
-export declare const composeAsync: <ValidationType, TLastSchemaValues extends Record<string, unknown>>(...rules: (IndependentValidationRule<ValidationType, TLastSchemaValues> | AsyncIndependentValidationRule<ValidationType, TLastSchemaValues> | ValidationRule<ValidationType, TLastSchemaValues> | AsyncValidationRule<ValidationType, TLastSchemaValues>)[]) => AsyncIndependentValidationRule<ValidationType, Record<string, unknown>>;
+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/core/rule/createRule/createRule.d.ts

@@ -30,5 +30,5 @@ type RuleExecutor<ValidationType extends ValidationTypes, TLastSchemaValues exte
  *   }, params);
  * ```
  */
-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 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/core/rule/required/required.d.ts

@@ -7,5 +7,5 @@ export declare const required: ({ message, }?: {
      * @description Кастомное сообщение ошибки
      * @default Обязательно
      */
-    message?: string | undefined;
+    message?: string;
 }) => (value: unknown, prevCtx?: import("../..").ValidationContext<{}> | undefined) => import("../..").ValidationResult;

package/deepPartial/deepPartial.d.ts

@@ -18,4 +18,4 @@ import { type Guard } from '../core';
  *     const result = validate({ info: { info: {} } });
  * ```
  */
-export declare const deepPartial: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues, {}>) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | 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/enabled/enabled.d.ts

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

package/enabled/enabled.js

@@ -0,0 +1,31 @@
+import { any } from '../any';
+import { callRule, createRule, } from '../core';
+/**
+ * @description Позволяет указывать условные валидации
+ * @example
+ * ```ts
+ * type Values = { name: string; isAgree: boolean };
+ *
+ * const validate = object<Values>({
+ *   name: enabled({
+ *     is: (_, ctx) => ctx.global.values.isAgree,
+ *     then: string(),
+ *   }),
+ *   isAgree: optional(boolean()),
+ * });
+ *
+ * // undefined
+ * const result1 = validate({ isAgree: false, name: '' });
+ *
+ * // Required error для name
+ * const result2 = validate({ isAgree: true, name: '' });
+ * ```
+ */
+export const enabled = ({ is, then, }) => {
+    return createRule((value, ctx) => {
+        if (is(value, ctx)) {
+            return callRule(then, value, ctx);
+        }
+        return callRule(any(), value, ctx);
+    });
+};

package/enabled/index.d.ts

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

package/enabled/index.js

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

package/index.d.ts

@@ -44,3 +44,4 @@ export { any } from './any';
 export { when } from './when';
 export { toPrettyError } from './toPrettyError';
 export { transform } from './transform';
+export { enabled } from './enabled';

package/index.js

@@ -44,3 +44,4 @@ export { any } from './any';
 export { when } from './when';
 export { toPrettyError } from './toPrettyError';
 export { transform } from './transform';
+export { enabled } from './enabled';

package/object/objectAsync/objectAsync.js

@@ -44,7 +44,7 @@ import { OBJECT_TYPE_ERROR_INFO } from '../constants';
  * });
  * ```
  */
-export const objectAsync = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => __awaiter(void 0, void 0, void 0, function* () {
+export const objectAsync = (schema) => createGuard((value_1, ctx_1, _a) => __awaiter(void 0, [value_1, ctx_1, _a], void 0, function* (value, ctx, { typeErrorMessage, isPartial }) {
     const context = createContext(ctx, value, {
         lastSchemaValue: value,
     });

package/package.json

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

package/string/stringAsync/stringAsync.d.ts

@@ -3,4 +3,4 @@ import { type AsyncValidationRule, type ValidationRule } from '../../core';
  * Позволяет использовать для валидации асинхронные правила
  * @example stringAsync(async () => undefined)
  */
-export declare const stringAsync: <TLastSchemaValues extends Record<string, unknown>>(...rules: (ValidationRule<string, TLastSchemaValues> | AsyncValidationRule<string, TLastSchemaValues>)[]) => import("../../core").AsyncGuard<TLastSchemaValues, {}>;
+export declare const stringAsync: <TLastSchemaValues extends Record<string, unknown>>(...rules: Array<ValidationRule<string, TLastSchemaValues> | AsyncValidationRule<string, TLastSchemaValues>>) => import("../../core").AsyncGuard<TLastSchemaValues, {}>;

package/string/stringAsync/stringAsync.js

@@ -15,7 +15,7 @@ import { STRING_TYPE_ERROR_INFO } from '../constants';
  * Позволяет использовать для валидации асинхронные правила
  * @example stringAsync(async () => undefined)
  */
-export const stringAsync = (...rules) => createGuard((value, ctx, { typeErrorMessage }) => __awaiter(void 0, void 0, void 0, function* () {
+export const stringAsync = (...rules) => createGuard((value_1, ctx_1, _a) => __awaiter(void 0, [value_1, ctx_1, _a], void 0, function* (value, ctx, { typeErrorMessage }) {
     if (!isString(value)) {
         return ctx.createError(Object.assign(Object.assign({}, STRING_TYPE_ERROR_INFO), { message: typeErrorMessage || STRING_TYPE_ERROR_INFO.message }));
     }