valgen 6.0.3 → 6.2.0

package/rules/index.d.ts

@@ -44,6 +44,7 @@ export * from './type-rules/is-bigint.js';
 export * from './type-rules/is-boolean.js';
 export * from './type-rules/is-date.js';
 export * from './type-rules/is-enum.js';
+export * from './type-rules/is-instanceof.js';
 export * from './type-rules/is-integer.js';
 export * from './type-rules/is-null.js';
 export * from './type-rules/is-number.js';
@@ -54,7 +55,9 @@ export * from './type-rules/is-tuple.js';
 export * from './type-rules/is-undefined.js';
 export * from './utility-rules/all-of.js';
 export * from './utility-rules/exists.js';
+export * from './utility-rules/fixed.js';
 export * from './utility-rules/get-length.js';
+export * from './utility-rules/nullable.js';
 export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';

package/rules/index.js

@@ -44,6 +44,7 @@ export * from './type-rules/is-bigint.js';
 export * from './type-rules/is-boolean.js';
 export * from './type-rules/is-date.js';
 export * from './type-rules/is-enum.js';
+export * from './type-rules/is-instanceof.js';
 export * from './type-rules/is-integer.js';
 export * from './type-rules/is-null.js';
 export * from './type-rules/is-number.js';
@@ -54,7 +55,9 @@ export * from './type-rules/is-tuple.js';
 export * from './type-rules/is-undefined.js';
 export * from './utility-rules/all-of.js';
 export * from './utility-rules/exists.js';
+export * from './utility-rules/fixed.js';
 export * from './utility-rules/get-length.js';
+export * from './utility-rules/nullable.js';
 export * from './utility-rules/one-of.js';
 export * from './utility-rules/optional.js';
 export * from './utility-rules/pipe.js';

package/rules/logical-rules/is-defined.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isDefined
  */
 export function isDefined(options) {
-    return validator('is-defined', (input, context, _this) => {
+    return validator(isDefined.name, (input, context, _this) => {
         if (input !== undefined)
             return input;
         context.fail(_this, `Value must be defined`, input);

package/rules/logical-rules/is-empty.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isEmpty
  */
 export function isEmpty(options) {
-    return validator('isEmpty', (input, context, _this) => {
+    return validator(isEmpty.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (typeof input === 'string') {

package/rules/logical-rules/is-equal.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isEqual
  */
 export function isEqual(compare, options) {
-    return validator('isEqual', (input, context, _this) => {
+    return validator(isEqual.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (input !== compare)
@@ -17,7 +17,7 @@ export function isEqual(compare, options) {
  * @validator isNotEqual
  */
 export function isNotEqual(compare, options) {
-    return validator('isNotEqual', (input, context, _this) => {
+    return validator(isNotEqual.name, (input, context, _this) => {
         if (input == null)
             return input;
         if (input === compare) {

package/rules/logical-rules/is-gt.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator iGt
  */
 export function isGt(minValue, options) {
-    return validator('isGt', (input, context, _this) => {
+    return validator(isGt.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input > minValue) {

package/rules/logical-rules/is-gte.d.ts

@@ -4,7 +4,7 @@ import type { range } from './range.js';
  * Checks if value is grater than or equal to minValue
  * @validator isGte
  */
-export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T, T>;
+export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T>;
 export declare namespace isGte {
     interface Options extends ValidationOptions {
         caseInsensitive?: boolean;

package/rules/logical-rules/is-gte.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isGte
  */
 export function isGte(minValue, options) {
-    return validator('isGte', (input, context, _this) => {
+    return validator(isGte.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input >= minValue) {

package/rules/logical-rules/is-lt.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isLt
  */
 export function isLt(maxValue, options) {
-    return validator('isLt', (input, context, _this) => {
+    return validator(isLt.name, (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input < maxValue) {

package/rules/logical-rules/is-lte.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isLte
  */
 export function isLte(maxValue, options) {
-    return validator('isLte', (input, context, _this) => {
+    return validator(isLte.name, (input, context, _this) => {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue) {

package/rules/logical-rules/range.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator range
  */
 export function range(minValue, maxValue, options) {
-    return validator('range', (input, context, _this) => {
+    return validator(range.name, (input, context, _this) => {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&

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

@@ -3,4 +3,4 @@ import { validator } from '../../core/index.js';
  * Does nothing, just returns the original input value.
  * @validator isAny
  */
-export const isAny = () => validator('is-any', (input) => input);
+export const isAny = () => validator(isAny.name, (input) => input);

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

@@ -1,4 +1,4 @@
-import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { ValidationOptions, Validator } from '../../core/index.js';
 /**
  * Validates if the value is "array" and applies validation for each item.
  * Converts input value to array if the coerce option is set to 'true'.

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

@@ -1,11 +1,11 @@
-import { validator, } from '../../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if the value is "array" and applies validation for each item.
  * Converts input value to array if the coerce option is set to 'true'.
  * @validator isArray
  */
 export function isArray(itemValidator, options) {
-    return validator('isArray', (input, context, _this) => {
+    return validator(isArray.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

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

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNumber
  */
 export function isBigint(options) {
-    return validator('isBigint', (input, context, _this) => {
+    return validator(isBigint.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         if (typeof input === 'bigint')
             return input;

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

@@ -7,7 +7,7 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * @validator isBoolean
  */
 export function isBoolean(options) {
-    return validator('isBoolean', (input, context, _this) => {
+    return validator(isBoolean.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'boolean' && coerce) {

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

@@ -1,4 +1,5 @@
 import * as datefns from 'date-fns';
+import {} from 'ts-gems';
 import { validator, } from '../../core/index.js';
 /**
  * Validates if value is a "Date" instance or ISO 8601 formatted date string.
@@ -7,7 +8,7 @@ import { validator, } from '../../core/index.js';
  */
 export function isDate(options) {
     const trim = options?.trim;
-    return validator('isDate', (input, context, _this) => {
+    return validator(isDate.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let d;
         if (input instanceof Date)
@@ -43,7 +44,7 @@ export function isDateString(options) {
     let precisionMin = options?.precisionMin || 'minutes';
     const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
     precisionMin = (PRECISION_INDEX_KEYS[PRECISION_INDEX_VALUES.indexOf(precisionMinIdx)] || precisionMin);
-    return validator('isDateString', (input, context, _this) => {
+    return validator(isDateString.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         const parsed = coerceDateString(input, trim ? precisionMax : undefined);
         if (parsed) {

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

@@ -22,7 +22,7 @@ export function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return validator('isEnum', (input, context, _this) => {
+    return validator(isEnum.name, (input, context, _this) => {
         if (input != null &&
             valObj[typeof input === 'string' && caseInSensitive
                 ? input.toUpperCase()

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

@@ -0,0 +1,11 @@
+import type { Type } from 'ts-gems';
+import { type ValidationOptions } from '../../core/index.js';
+/**
+ * Validates if the value instance of given class or classes
+ * @validator isUndefined
+ */
+export declare function isInstanceOf<T extends object>(clazz: Type<T>, options?: isInstanceOf.Options): import("../../core/validator.js").Validator<T, unknown, import("../../core/types.js").ExecutionOptions>;
+export declare namespace isInstanceOf {
+    interface Options extends ValidationOptions {
+    }
+}

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

@@ -0,0 +1,17 @@
+import { isPlainObject } from '@jsopen/objects';
+import { validator, } from '../../core/index.js';
+/**
+ * Validates if the value instance of given class or classes
+ * @validator isUndefined
+ */
+export function isInstanceOf(clazz, options) {
+    return validator(isInstanceOf.name, (input, context, _this) => {
+        if ((options?.coerce ?? context.coerce) && isPlainObject(input)) {
+            Object.setPrototypeOf(input, clazz.prototype);
+        }
+        if (!(input instanceof clazz)) {
+            context.fail(_this, `Value must be an instance of "${clazz.name}"`, input);
+        }
+        return input;
+    }, options);
+}

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

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isInteger
  */
 export function isInteger(options) {
-    return validator('isInteger', (input, context, _this) => {
+    return validator(isInteger.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

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

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNull
  */
 export function isNull(options) {
-    return validator('isNull', (input, context, _this) => {
+    return validator(isNull.name, (input, context, _this) => {
         if (input === null)
             return input;
         context.fail(_this, `Value must be null`, input);
@@ -15,7 +15,7 @@ export function isNull(options) {
  * @validator isNotNull
  */
 export function isNotNull(options) {
-    return validator('isNotNull', (input, context, _this) => {
+    return validator(isNotNull.name, (input, context, _this) => {
         if (input !== null)
             return input;
         context.fail(_this, `{{label}} is null`, input);
@@ -26,7 +26,7 @@ export function isNotNull(options) {
  * @validator isNullish
  */
 export function isNullish(options) {
-    return validator('isNullish', (input, context, _this) => {
+    return validator(isNullish.name, (input, context, _this) => {
         if (input == null)
             return input;
         context.fail(_this, `{{label}} is not nullish`, input);
@@ -37,7 +37,7 @@ export function isNullish(options) {
  * @validator isNotNullish
  */
 export function isNotNullish(options) {
-    return validator('isNotNullish', (input, context, _this) => {
+    return validator(isNotNullish.name, (input, context, _this) => {
         if (input != null)
             return input;
         if (input === null)

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

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isNumber
  */
 export function isNumber(options) {
-    return validator('isNumber', (input, context, _this) => {
+    return validator(isNumber.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'number' && coerce) {

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

@@ -33,7 +33,7 @@ export function isObject(schema, options) {
             throw new TypeError(`Invalid definition in validation schema (${k})`);
         }
     }
-    const _rule = validator('isObject', (input, context, _this) => {
+    const _rule = validator(isObject.name, (input, context, _this) => {
         let output = input;
         if (ctor && ctor[preValidation]) {
             output = ctor[preValidation](output, context, _this);

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

@@ -1,4 +1,4 @@
-import { type ValidationOptions, type Validator } from '../../core/index.js';
+import type { ValidationOptions, Validator } from '../../core/index.js';
 /**
  * Validates the record object according to given "key" and "value" rules
  * Converts properties according to rules if the coerce option is set to 'true'.

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

@@ -1,11 +1,11 @@
-import { validator, } from '../../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates the record object according to given "key" and "value" rules
  * Converts properties according to rules if the coerce option is set to 'true'.
  * @validator isRecord
  */
 export function isRecord(keyRule, valueRule, options) {
-    return validator('isRecord', (input, context, _this) => {
+    return validator(isRecord.name, (input, context, _this) => {
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `Value must be an object`, input);
             return;

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

@@ -5,7 +5,7 @@ import { validator, } from '../../core/index.js';
  * @validator isString
  */
 export function isString(options) {
-    return validator('isString', (input, context, _this) => {
+    return validator(isString.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && typeof output !== 'string' && coerce) {

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

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 export function isTuple(items, options) {
-    return validator('isTuple', (input, context, _this) => {
+    return validator(isTuple.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))

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

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator isUndefined
  */
 export function isUndefined(options) {
-    return validator('isUndefined', (input, context, _this) => {
+    return validator(isUndefined.name, (input, context, _this) => {
         if (options?.coerce ?? context.coerce)
             return undefined;
         if (input === undefined)

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

@@ -1,4 +1,4 @@
-import { ValidationOptions, type Validator } from '../../core/index.js';
+import type { ValidationOptions, Validator } from '../../core/index.js';
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf

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

@@ -1,10 +1,10 @@
-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, options) {
-    return validator('allOf', (input, context) => {
+    return validator(allOf.name, (input, context) => {
         let i;
         let c;
         const l = rules.length;

package/rules/utility-rules/exists.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator exists
  */
 export function exists(options) {
-    return validator('exists', (input, context, _this) => {
+    return validator(exists.name, (input, context, _this) => {
         if (input !== undefined ||
             (context.scope &&
                 Object.getOwnPropertyDescriptor(context.scope, input))) {

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

@@ -0,0 +1,5 @@
+/**
+ * Check if value is not nullish before calling nested rule
+ * @validator required
+ */
+export declare function fixed<T, I>(value: T): import("../../core/validator.js").Validator<T, I, import("../../core/types.js").ExecutionOptions>;

package/rules/utility-rules/fixed.js

@@ -0,0 +1,10 @@
+import { validator } from '../../core/index.js';
+/**
+ * Check if value is not nullish before calling nested rule
+ * @validator required
+ */
+export function fixed(value) {
+    return validator(fixed.name, () => {
+        return value;
+    });
+}

package/rules/utility-rules/get-length.js

@@ -4,7 +4,7 @@ import { validator } from '../../core/index.js';
  * @validator getLength
  */
 export function getLength() {
-    return validator('getLength', (input, context, _this) => {
+    return validator(getLength.name, (input, context, _this) => {
         if (typeof input === 'string')
             return input.length;
         if (Array.isArray(input))

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

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

package/rules/utility-rules/nullable.js

@@ -0,0 +1,12 @@
+import { validator, } from '../../core/index.js';
+/**
+ * Makes the sub-rule nullable (undefined of null)
+ * @validator optional
+ */
+export function nullable(nested, options) {
+    return validator(nullable.name, (input, context) => {
+        if (input == null)
+            return input;
+        return nested(input, context);
+    }, options);
+}

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

@@ -1,4 +1,4 @@
-import { ValidationOptions, type Validator } from '../../core/index.js';
+import type { ValidationOptions, Validator } from '../../core/index.js';
 type DiscriminatorRecord = Record<string, Validator>;
 /**
  *

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

@@ -1,10 +1,10 @@
-import { validator, } from '../../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  *
  */
 export function oneOf(rules, options) {
     const l = rules.length;
-    return validator('union', (input, context, _this) => {
+    return validator(oneOf.name, (input, context, _this) => {
         let i;
         let c;
         let discriminator;

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

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

package/rules/utility-rules/optional.js

@@ -4,8 +4,8 @@ import { validator, } from '../../core/index.js';
  * @validator optional
  */
 export function optional(nested, options) {
-    return validator('optional', (input, context) => {
-        if (input == null)
+    return validator(optional.name, (input, context) => {
+        if (input === undefined)
             return input;
         return nested(input, context);
     }, options);

package/rules/utility-rules/pipe.js

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
 export function pipe(rules, options) {
     const l = rules.length;
     const returnIndex = options?.returnIndex;
-    return validator('pipe', (input, context) => {
+    return validator(pipe.name, (input, context) => {
         let i;
         let c;
         let v = input;

package/rules/utility-rules/required.js

@@ -4,7 +4,7 @@ import { validator, } from '../../core/index.js';
  * @validator required
  */
 export function required(nested, options) {
-    return validator('required', (input, context, _this) => {
+    return validator(required.name, (input, context, _this) => {
         if (input == null)
             input = options?.default;
         if (input == null) {

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

@@ -27,9 +27,9 @@ export declare function trim(): import("../../core/validator.js").Validator<stri
  * 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>;
+export declare function 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>;
+export declare function trimStart(): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

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

@@ -1,13 +1,13 @@
 import { validator } from '../../core/index.js';
 export function stringReplace(searchValue, replacer) {
-    return validator('stringReplace', (input) => {
+    return validator(stringReplace.name, (input) => {
         if (input == null)
             return input;
         return String(input).replace(searchValue, replacer);
     });
 }
 export function stringSplit(splitter, limit) {
-    return validator('stringSplit', (input) => {
+    return validator(stringSplit.name, (input) => {
         if (input == null)
             return input;
         return String(input).split(splitter, limit);
@@ -18,7 +18,7 @@ export function stringSplit(splitter, limit) {
  * @validator trim
  */
 export function trim() {
-    return validator('trim', (input) => {
+    return validator(trim.name, (input) => {
         if (input == null)
             return input;
         return String(input).trim();
@@ -29,20 +29,22 @@ export function 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();
-});
+export function trimEnd() {
+    return validator(trimEnd.name, (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();
-});
+export function trimStart() {
+    return validator(trimStart.name, (input) => {
+        if (input == null)
+            return input;
+        return String(input).trimStart();
+    });
+}