valgen 5.20.0 → 6.0.0

package/rules/type-rules/is-tuple.d.ts

@@ -1,31 +1,31 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 /**
- * Validates if value is "tuple" and applies validation for each item.
- * Converts input value to tuple if coerce option is set to 'true'.
+ * Validates if the value is "tuple" and applies validation for each item.
+ * Converts input value to tuple if the coerce option is set to 'true'.
  * @validator isTuple
  */
-export declare function isTuple<T1, I1>(items: [Validator<T1, I1>], options?: ValidationOptions): Validator<[T1], [I1]>;
-export declare function isTuple<T1, I1, T2, I2>(items: [Validator<T1, I1>, Validator<T2, I2>], options?: ValidationOptions): Validator<[T1, T2], [I1, I2]>;
-export declare function isTuple<T1, I1, T2, I2, T3, I3>(items: [Validator<T1, I1>, Validator<T2, I2>, Validator<T3, I3>], options?: ValidationOptions): Validator<[T1, T2, T3], [I1, I2, I3]>;
+export declare function isTuple<T1, I1>(items: [Validator<T1, I1>], options?: isTuple.Options): Validator<[T1], [I1]>;
+export declare function isTuple<T1, I1, T2, I2>(items: [Validator<T1, I1>, Validator<T2, I2>], options?: isTuple.Options): Validator<[T1, T2], [I1, I2]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3>(items: [Validator<T1, I1>, Validator<T2, I2>, Validator<T3, I3>], options?: isTuple.Options): Validator<[T1, T2, T3], [I1, I2, I3]>;
 export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4>(items: [
     Validator<T1, I1>,
     Validator<T2, I2>,
     Validator<T3, I3>,
     Validator<T4, I4>
-], options?: ValidationOptions): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
+], options?: isTuple.Options): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
 export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4>(items: [
     Validator<T1, I1>,
     Validator<T2, I2>,
     Validator<T3, I3>,
     Validator<T4, I4>
-], options?: ValidationOptions): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
+], options?: isTuple.Options): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
 export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5>(items: [
     Validator<T1, I1>,
     Validator<T2, I2>,
     Validator<T3, I3>,
     Validator<T4, I4>,
     Validator<T5, I5>
-], options?: ValidationOptions): Validator<[T1, T2, T3, T4, T5], [I1, I2, I3, I4, I5]>;
+], options?: isTuple.Options): Validator<[T1, T2, T3, T4, T5], [I1, I2, I3, I4, I5]>;
 export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6>(items: [
     Validator<T1, I1>,
     Validator<T2, I2>,
@@ -34,7 +34,7 @@ export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6>(
     Validator<T5, I5>,
     Validator<T6, I6>,
     ...Validator[]
-], options?: ValidationOptions): Validator<[
+], options?: isTuple.Options): Validator<[
     T1,
     T2,
     T3,
@@ -51,3 +51,7 @@ export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6>(
     I5,
     ...any[]
 ]>;
+export declare namespace isTuple {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/type-rules/is-undefined.d.ts

@@ -1,6 +1,10 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is "undefined"
+ * Validates if the value is undefined
  * @validator isUndefined
  */
-export declare function isUndefined(options?: ValidationOptions): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare function isUndefined(options?: isUndefined.Options): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isUndefined {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/type-rules/is-undefined.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is "undefined"
+ * Validates if the value is undefined
  * @validator isUndefined
  */
 export function isUndefined(options) {

package/rules/utility-rules/all-of.d.ts

@@ -1,6 +1,10 @@
-import { type Validator } from '../../core/index.js';
+import { ValidationOptions, type Validator } from '../../core/index.js';
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export declare function allOf<T = any>(rules: Validator[]): Validator<T>;
+export declare function allOf<T = any>(rules: Validator[], options?: allOf.Options): Validator<T>;
+export declare namespace allOf {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/utility-rules/all-of.js

@@ -1,16 +1,16 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export function allOf(rules) {
+export function allOf(rules, options) {
     return validator('allOf', (input, context) => {
         let i;
         let c;
         const l = rules.length;
         for (i = 0; i < l; i++) {
             c = rules[i];
-            c(input, context);
+            c(input, context || options);
         }
         return input;
     });

package/rules/utility-rules/exists.d.ts

@@ -3,4 +3,8 @@ import { type ValidationOptions } from '../../core/index.js';
  * Validates if property exists
  * @validator exists
  */
-export declare function exists(options?: ValidationOptions): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare function exists(options?: exists.Options): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare namespace exists {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/utility-rules/one-of.d.ts

@@ -1,7 +1,11 @@
-import { type Validator } from '../../core/index.js';
+import { ValidationOptions, type Validator } from '../../core/index.js';
 type DiscriminatorRecord = Record<string, Validator>;
 /**
  *
  */
-export declare function oneOf(rules: (Validator | [Validator, DiscriminatorRecord])[]): Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare function oneOf(rules: (Validator | [Validator, DiscriminatorRecord])[], options?: oneOf.Options): Validator<any, any, import("../../core/types.js").ExecutionOptions>;
+export declare namespace oneOf {
+    interface Options extends ValidationOptions {
+    }
+}
 export {};

package/rules/utility-rules/one-of.js

@@ -1,8 +1,8 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  *
  */
-export function oneOf(rules) {
+export function oneOf(rules, options) {
     const l = rules.length;
     return validator('union', (input, context, _this) => {
         let i;
@@ -24,7 +24,7 @@ export function oneOf(rules) {
                 }
                 try {
                     for (const k of Object.keys(discriminator)) {
-                        discriminator[k](input[k], context);
+                        discriminator[k](input[k], context || options);
                         if (!passed)
                             break;
                     }
@@ -39,7 +39,7 @@ export function oneOf(rules) {
                 c = rules[i];
             if (passed)
                 try {
-                    v = c(input, context);
+                    v = c(input, context || options);
                     if (passed)
                         break;
                 }

package/rules/utility-rules/optional.d.ts

@@ -1,7 +1,11 @@
 import type { Nullish } from 'ts-gems';
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 /**
- * Makes sub-rule optional
+ * Makes the sub-rule optional
  * @validator optional
  */
-export declare function optional<T, I>(nested: Validator<T, I>, options?: ValidationOptions): Validator<Nullish<T>, Nullish<I>, import("../../core/types.js").ExecutionOptions>;
+export declare function optional<T, I>(nested: Validator<T, I>, options?: optional.Options): Validator<Nullish<T>, Nullish<I>, import("../../core/types.js").ExecutionOptions>;
+export declare namespace optional {
+    interface Options extends ValidationOptions {
+    }
+}

package/rules/utility-rules/optional.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Makes sub-rule optional
+ * Makes the sub-rule optional
  * @validator optional
  */
 export function optional(nested, options) {

package/rules/utility-rules/pipe.d.ts

@@ -1,9 +1,11 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
-export interface PipeOptions extends ValidationOptions {
-    returnIndex?: number;
-}
 /**
  *
  * @validator pipe
  */
-export declare function pipe<T>(rules: Validator[], options?: PipeOptions): Validator<T>;
+export declare function pipe<T>(rules: Validator[], options?: pipe.Options): Validator<T>;
+export declare namespace pipe {
+    interface Options extends ValidationOptions {
+        returnIndex?: number;
+    }
+}

package/rules/utility-rules/string-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Applies "String.replace" method
+ * @validator stringReplace
+ */
+export declare function stringReplace(searchValue: string | RegExp, replaceValue: string): any;
+export declare function stringReplace(searchValue: string | RegExp, replacer: (subsring: string, ...args: any[]) => string): any;
+export declare function stringReplace(searchValue: {
+    [Symbol.replace](string: string, replaceValue: string): string;
+}, replaceValue: string): any;
+export declare function stringReplace(searchValue: {
+    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+}, replacer: (substring: string, ...args: any[]) => string): any;
+/**
+ * Applies "String.split" method
+ * @validator split
+ */
+export declare function stringSplit(separator: string | RegExp, limit?: number): any;
+export declare function stringSplit(splitter: {
+    [Symbol.split](string: string, limit?: number): string[];
+}, limit?: number): any;
+/**
+ * Removes whitespace from both ends of a string
+ * @validator trim
+ */
+export declare function trim(): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Removes whitespace from the end of a string
+ * @validator trimEnd
+ */
+export declare const trimEnd: () => import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
+/**
+ * Removes whitespace from the beginning of a string
+ * @validator trimStart
+ */
+export declare const trimStart: () => import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/rules/utility-rules/string-utils.js

@@ -0,0 +1,48 @@
+import { validator } from '../../core/index.js';
+export function stringReplace(searchValue, replacer) {
+    return validator('stringReplace', (input) => {
+        if (input == null)
+            return input;
+        return String(input).replace(searchValue, replacer);
+    });
+}
+export function stringSplit(splitter, limit) {
+    return validator('stringSplit', (input) => {
+        if (input == null)
+            return input;
+        return String(input).split(splitter, limit);
+    });
+}
+/**
+ * Removes whitespace from both ends of a string
+ * @validator trim
+ */
+export function trim() {
+    return validator('trim', (input) => {
+        if (input == null)
+            return input;
+        return String(input).trim();
+    });
+}
+// *************************************************************
+/**
+ * Removes whitespace from the end of a string
+ * @validator trimEnd
+ */
+export const trimEnd = () => trimEndRule;
+const trimEndRule = validator('trimEnd', (input) => {
+    if (input == null)
+        return input;
+    return String(input).trimEnd();
+});
+// *************************************************************
+/**
+ * Removes whitespace from the beginning of a string
+ * @validator trimStart
+ */
+export const trimStart = () => trimStartRule;
+const trimStartRule = validator('trimStart', (input) => {
+    if (input == null)
+        return input;
+    return String(input).trimStart();
+});