valgen 5.2.2 → 5.3.1

package/esm/rules/format-rules/is-lowercase.js

@@ -0,0 +1,24 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value a Lowercase string
+ * @validator isLowercase
+ */
+export function isLowercase(options) {
+    return validator('isLowercase', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isLowercase(input))
+            return input;
+        context.fail(_this, `"{{value}}" is not a lowercase string`, input);
+    }, options);
+}
+/**
+ * Validates if value a Uppercase string
+ * @validator isUppercase
+ */
+export function isUppercase(options) {
+    return validator('isUppercase', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isUppercase(input))
+            return input;
+        context.fail(_this, `"{{value}}" is not an uppercase string`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-mac-address.js

@@ -0,0 +1,18 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an MACAddress
+ * @validator isMACAddress
+ */
+export function isMACAddress(options) {
+    const opts = {
+        // eslint-disable-next-line camelcase
+        no_separators: options?.noSeparators,
+        eui: options?.eui,
+    };
+    return validator('isMACAddress', function (input, context, _this) {
+        if (input != null && typeof input === 'string' && validatorJS.isMACAddress(input, opts))
+            return input;
+        context.fail(_this, `{{label}} is not a valid MAC address`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-mobile-phone.js

@@ -0,0 +1,16 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a valid Email
+ * @validator isMobilePhone
+ */
+export function isMobilePhone(options) {
+    const opts = {
+        strictMode: options?.strictMode,
+    };
+    return validator('isMobilePhone', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isMobilePhone(input, options?.locale, opts))
+            return input;
+        context.fail(_this, `"{{value}}" is not a valid a Mobile Phone Number`, input);
+    }, options);
+}

package/esm/rules/{is-object-id.js → format-rules/is-object-id.js}

@@ -1,5 +1,5 @@
 import validatorJS from 'validator';
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is an "ObjectId".
  * @validator isObjectId
@@ -12,10 +12,10 @@ export function isObjectId(options) {
                     typeof input.toHexString === 'function' &&
                     _isObjectIdValue(input.toHexString()))))
             return input;
-        context.fail(_this, `{{label}} must be an ObjectId`, input);
+        context.fail(_this, `"{{value}}" is not a valid ObjectId`, input);
     }, options);
 }
 function _isObjectIdValue(input) {
-    return (input instanceof Uint8Array && input.length === 12) ||
-        (typeof input === 'string' && input.length === 24 && validatorJS.isHexadecimal(input));
+    return ((input instanceof Uint8Array && input.length === 12) ||
+        (typeof input === 'string' && input.length === 24 && validatorJS.isHexadecimal(input)));
 }

package/esm/rules/format-rules/is-passport-number.js

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a passport number
+ * @validator isPassportNumber
+ */
+export function isPassportNumber(countryCode, options) {
+    return validator('isPassportNumber', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isPassportNumber(input, countryCode))
+            return input;
+        context.fail(_this, `"{{value}}" is not a valid ${countryCode} PassportNumber)`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-port.js

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a port number
+ * @validator isPort
+ */
+export function isPort(options) {
+    return validator('isPort', function (input, context, _this) {
+        if (input != null && typeof input === 'string' && validatorJS.isPort(input))
+            return input;
+        context.fail(_this, `{{label}} is not a valid port number`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-url.js

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an URL
+ * @validator isURL
+ */
+export function isURL(options) {
+    return validator('isURL', function (input, context, _this) {
+        if (input != null && typeof input === 'string' && validatorJS.isURL(input, options))
+            return input;
+        context.fail(_this, `{{value}} is not a valid URL`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-uuid.js

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an "UUID".
+ * @validator isUUID
+ */
+export function isUUID(version, options) {
+    return validator('isUUID', function (input, context, _this) {
+        if (input != null && typeof input === 'string' && validatorJS.isUUID(input, version))
+            return input;
+        context.fail(_this, `{{label}} is not a valid UUID${version ? ' v' + version : ''}`, input);
+    }, options);
+}

package/esm/rules/format-rules/is-vat-number.js

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an VAT number
+ * @validator isVAT
+ */
+export function isVATNumber(countryCode, options) {
+    return validator('isVATNumber', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isVAT(input, countryCode))
+            return input;
+        context.fail(_this, `"{{value}}" is not a valid VAT number`, input);
+    }, options);
+}

package/esm/rules/{is-regexp.js → format-rules/matches.js}

@@ -1,9 +1,9 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Coerces given value to "UUID" format or returns undefined if nullish
  * @validator uuid
  */
-export function isRegExp(format, options) {
+export function matches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
     const formatName = options?.formatName;
     return validator('matches', function (input, context, _this) {
@@ -11,6 +11,9 @@ export function isRegExp(format, options) {
             return;
         if (typeof input === 'string' && regExp.test(input))
             return input;
-        context.fail(_this, `{{label}} does not match ${formatName || 'requested'} format`, input, { format, formatName });
+        context.fail(_this, `"{{value}}" does not match ${formatName || 'requested'} format`, input, {
+            format,
+            formatName,
+        });
     }, options);
 }

package/esm/rules/index.js

@@ -1,22 +1,49 @@
-export * from './is-any.js';
-export * from './is-array.js';
-export * from './is-bigint.js';
-export * from './is-boolean.js';
-export * from './is-date.js';
-export * from './is-empty.js';
-export * from './is-enum.js';
-export * from './is-integer.js';
-export * from './is-null.js';
-export * from './is-regexp.js';
-export * from './is-number.js';
-export * from './is-object.js';
-export * from './is-object-id.js';
-export * from './is-record.js';
-export * from './is-string.js';
-export * from './is-tuple.js';
-export * from './length.js';
-export * from './optional.js';
-export * from './pipe.js';
-export * from './range.js';
-export * from './string-formats.js';
-export * from './union.js';
+export * from './type-rules/is-any.js';
+export * from './type-rules/is-array.js';
+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-integer.js';
+export * from './type-rules/is-null.js';
+export * from './type-rules/is-number.js';
+export * from './type-rules/is-object.js';
+export * from './type-rules/is-record.js';
+export * from './type-rules/is-string.js';
+export * from './type-rules/is-tuple.js';
+export * from './format-rules/is-alpha.js';
+export * from './format-rules/is-ascii.js';
+export * from './format-rules/is-base64.js';
+export * from './format-rules/is-btc-address.js';
+export * from './format-rules/is-credit-card.js';
+export * from './format-rules/is-decimal.js';
+export * from './format-rules/is-ean.js';
+export * from './format-rules/is-email.js';
+export * from './format-rules/is-eth-address.js';
+export * from './format-rules/is-fqdn.js';
+export * from './format-rules/is-hash.js';
+export * from './format-rules/is-hex.js';
+export * from './format-rules/is-hex-color.js';
+export * from './format-rules/is-iban.js';
+export * from './format-rules/is-ip.js';
+export * from './format-rules/is-issn.js';
+export * from './format-rules/is-jwt.js';
+export * from './format-rules/is-lowercase.js';
+export * from './format-rules/is-mac-address.js';
+export * from './format-rules/is-mobile-phone.js';
+export * from './format-rules/is-object-id.js';
+export * from './format-rules/is-passport-number.js';
+export * from './format-rules/is-port.js';
+export * from './format-rules/is-url.js';
+export * from './format-rules/is-uuid.js';
+export * from './format-rules/is-vat-number.js';
+export * from './format-rules/matches.js';
+export * from './logical-rules/is-defined.js';
+export * from './logical-rules/is-empty.js';
+export * from './logical-rules/range.js';
+export * from './utility-rules/exists.js';
+export * from './utility-rules/get-length.js';
+export * from './utility-rules/optional.js';
+export * from './utility-rules/pipe.js';
+export * from './utility-rules/required.js';
+export * from './utility-rules/union.js';

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

@@ -0,0 +1,25 @@
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is not "undefined" nor "null"
+ * @validator isDefined
+ */
+export function isDefined(options) {
+    return validator('is-defined', function (input, context, _this) {
+        if (input !== undefined)
+            return input;
+        context.fail(_this, `Is not defined`, input);
+    }, options);
+}
+/**
+ * Validates if value is "undefined"
+ * @validator isUndefined
+ */
+export function isUndefined(options) {
+    return validator('isUndefined', function (input, context, _this) {
+        if (options?.coerce || context.coerce)
+            return undefined;
+        if (input === undefined)
+            return;
+        context.fail(_this, `{{label}} mustn\'t be defined`, input);
+    }, options);
+}

package/esm/rules/{is-empty.js → logical-rules/is-empty.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Checks if value is an empty. Value should be string, array, set, map or object
  * @validator isEmpty
@@ -10,24 +10,29 @@ export function isEmpty(options) {
         if (typeof input === 'string') {
             if (!input)
                 return input;
+            context.fail(_this, `Is not an empty string`, input);
         }
         else if (Array.isArray(input)) {
             if (!input.length)
                 return input;
+            context.fail(_this, `Is not an empty array`, input);
         }
         else if (input instanceof Set) {
             if (!input.size)
                 return input;
+            context.fail(_this, `Is not an empty Set`, input);
         }
         else if (input instanceof Map) {
             if (!input.size)
                 return input;
+            context.fail(_this, `Is not an empty Map`, input);
         }
         else if (typeof input === 'object') {
             if (!Object.keys(input).length)
                 return input;
+            context.fail(_this, `Is not an empty Object`, input);
         }
-        context.fail(_this, `{{label}} must be empty`, input);
+        context.fail(_this, `Is not empty`, input);
     }, options);
 }
 /**
@@ -40,24 +45,29 @@ export function isNotEmpty(options) {
             if (typeof input === 'string') {
                 if (input)
                     return input;
+                context.fail(_this, `Value is an empty string`, input);
             }
             else if (Array.isArray(input)) {
                 if (input.length)
                     return input;
+                context.fail(_this, `Value is an empty array`, input);
             }
             else if (input instanceof Set) {
                 if (input.size)
                     return input;
+                context.fail(_this, `Value is an empty Set`, input);
             }
             else if (input instanceof Map) {
                 if (input.size)
                     return input;
+                context.fail(_this, `Value is an empty Map`, input);
             }
             else if (typeof input === 'object') {
                 if (Object.keys(input).length)
                     return input;
+                context.fail(_this, `Value is an empty Object`, input);
             }
         }
-        context.fail(_this, `{{label}} mustn't be empty`, input);
+        context.fail(_this, `Value is empty`, input);
     }, options);
 }

package/esm/rules/{range.js → logical-rules/range.js}

@@ -1,4 +1,33 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
+import { getLength } from '../utility-rules/get-length.js';
+import { allOf, pipe } from '../utility-rules/pipe.js';
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+export function range(minValue, maxValue, options) {
+    return validator('range', function (input, context, _this) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        if (minValue instanceof Date &&
+            maxValue instanceof Date &&
+            input instanceof Date &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        if (typeof minValue === 'string' &&
+            typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            input >= minValue &&
+            input <= maxValue)
+            return input;
+        context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
+    }, options);
+}
 export function isGt(minValue, options) {
     return validator('isGt', function (input, context, _this) {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
@@ -7,11 +36,11 @@ export function isGt(minValue, options) {
             return input;
         if (minValue instanceof Date && input instanceof Date && input > minValue)
             return input;
-        if (typeof minValue === 'string' && typeof input === 'string' &&
-            (input > minValue ||
-                (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
+        if (typeof minValue === 'string' &&
+            typeof input === 'string' &&
+            (input > minValue || (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
+        context.fail(_this, `{{label}} must be greater than ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isGte(minValue, options) {
@@ -22,11 +51,11 @@ export function isGte(minValue, options) {
             return input;
         if (minValue instanceof Date && input instanceof Date && input >= minValue)
             return input;
-        if (typeof minValue === 'string' && typeof input === 'string' &&
-            (input >= minValue ||
-                (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
+        if (typeof minValue === 'string' &&
+            typeof input === 'string' &&
+            (input >= minValue || (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
+        context.fail(_this, `{{label}} must be greater than or equal to ${typeof minValue === 'string' ? `"${minValue}"` : minValue}`, input);
     }, options);
 }
 export function isLt(maxValue, options) {
@@ -37,45 +66,39 @@ export function isLt(maxValue, options) {
             return input;
         if (maxValue instanceof Date && input instanceof Date && input < maxValue)
             return input;
-        if (typeof maxValue === 'string' && typeof input === 'string' &&
-            (input < maxValue ||
-                (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
+        if (typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            (input < maxValue || (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
+        context.fail(_this, `{{label}} must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
 export function isLte(maxValue, options) {
-    return validator('isLt', function (input, context, _this) {
+    return validator('isLte', function (input, context, _this) {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue)
             return input;
         if (maxValue instanceof Date && input instanceof Date && input <= maxValue)
             return input;
-        if (typeof maxValue === 'string' && typeof input === 'string' &&
-            (input <= maxValue ||
-                (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
+        if (typeof maxValue === 'string' &&
+            typeof input === 'string' &&
+            (input <= maxValue || (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
             return input;
-        context.fail(_this, `{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
+        context.fail(_this, `{{label}} must be lover than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }
 /**
- * Checks if value is between minValue and maxValue
- * @validator range
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
  */
-export function range(minValue, maxValue, options) {
-    return validator('range', function (input, context, _this) {
-        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
-            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
-            (typeof input === 'number' || typeof input === 'bigint') &&
-            input >= minValue && input <= maxValue)
-            return input;
-        if (minValue instanceof Date && maxValue instanceof Date &&
-            input instanceof Date && input >= minValue && input <= maxValue)
-            return input;
-        if (typeof minValue === 'string' && typeof maxValue === 'string' &&
-            typeof input === 'string' && input >= minValue && input <= maxValue)
-            return input;
-        context.fail(_this, `{{label}} must be between ${minValue} and ${maxValue}`, input);
-    }, options);
-}
+export const lengthMin = (minValue) => allOf(pipe(getLength(), isGte(minValue, {
+    onFail: () => `The length of {{label}} must be at least ${minValue}`,
+})));
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator lengthMax
+ */
+export const lengthMax = (maxValue) => allOf(pipe(getLength(), isLte(maxValue, {
+    onFail: () => `The length of {{label}} must be at most ${maxValue}`,
+})));

package/esm/rules/{is-any.js → type-rules/is-any.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Does nothing, just returns original input value.
  * @validator isAny

package/esm/rules/{is-array.js → type-rules/is-array.js}

@@ -1,4 +1,4 @@
-import { validator, } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "array" and applies validation for each item.
  * Converts input value to array if coerce option is set to 'true'.
@@ -6,10 +6,11 @@ import { validator, } from '../core/index.js';
  */
 export function isArray(itemValidator, options) {
     return validator('isArray', function (input, context, _this) {
-        if (input != null && context.coerce && !Array.isArray(input))
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} must be an array`, input);
+            context.fail(_this, `"{{value}}" is not an array value`, input);
             return;
         }
         if (!itemValidator)
@@ -24,9 +25,7 @@ export function isArray(itemValidator, options) {
             v = input[i];
             itemContext.scope = input;
             // itemContext.location = location + '[' + i + ']';
-            itemContext.location = context.location
-                ? context.location + `[${i}]`
-                : `<Array>[${i}]`;
+            itemContext.location = context.location ? context.location + `[${i}]` : `<Array>[${i}]`;
             itemContext.index = i;
             v = itemValidator(v, itemContext);
             out.push(v);

package/esm/rules/{is-bigint.js → type-rules/is-bigint.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /**
  * Validates if value is "BigInt".
  * Converts input value to number if coerce option is set to 'true'.
@@ -6,11 +6,12 @@ import { validator } from '../core/index.js';
  */
 export function isBigint(options) {
     return validator('isBigint', function (input, context, _this) {
+        const coerce = options?.coerce || context.coerce;
         if (typeof input === 'bigint')
             return input;
-        if ((typeof input === 'number' && !isNaN(input)) ||
-            (typeof input === 'string' && context.coerce))
+        if ((typeof input === 'number' && !isNaN(input)) || (typeof input === 'string' && coerce))
             return BigInt(input);
-        context.fail(_this, `{{label}} must be an integer number`, input);
+        const t = typeof input === 'string' ? 'String ' : '';
+        context.fail(_this, `${t}"{{value}}" is not a valid BigInt value`, input);
     }, options);
 }

package/esm/rules/{is-boolean.js → type-rules/is-boolean.js}

@@ -1,4 +1,4 @@
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 const TRUE_PATTERN = /^true|t|1|yes|y$/i;
 const FALSE_PATTERN = /^false|f|0|no|n$/i;
 /**
@@ -8,7 +8,8 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  */
 export function isBoolean(options) {
     return validator('isBoolean', function (input, context, _this) {
-        if (input != null && typeof input !== 'boolean' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'boolean' && coerce) {
             if (typeof input === 'string') {
                 if (TRUE_PATTERN.test(input))
                     return true;
@@ -21,6 +22,7 @@ export function isBoolean(options) {
         }
         if (typeof input === 'boolean')
             return input;
-        context.fail(_this, `{{label}} must be a boolean`, input);
+        const t = typeof input === 'string' ? 'String ' : '';
+        context.fail(_this, `${t}"{{value}}" is not a valid boolean value`, input);
     }, options);
 }

package/esm/rules/{is-date.js → type-rules/is-date.js}

@@ -1,7 +1,9 @@
 import { formatISO, parseISO } from 'date-fns';
-import { validator } from '../core/index.js';
+import { validator } from '../../core/index.js';
 /* eslint-disable-next-line max-len */ // noinspection RegExpUnnecessaryNonCapturingGroup
-const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,3}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
+const DATE_PATTERN = 
+// eslint-disable-next-line max-len
+/^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[T ](([0-1][0-9]|2[0-4]):([0-5][0-9])(?::([0-5][0-9]))?(?:\.(\d{0,3}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
 /**
  * Validates if value is instance of "Date".
  * Converts input value to Date if coerce option is set to 'true'.
@@ -10,11 +12,12 @@ const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[
 export function isDate(options) {
     const precision = options?.precision;
     return validator('isDate', function (input, context, _this) {
+        const coerce = options?.coerce || context.coerce;
         let d;
         if (input instanceof Date)
             d = input;
-        else if (input != null && context.coerce) {
-            if (typeof input === 'string' && context.coerce) {
+        else if (input != null && coerce) {
+            if (typeof input === 'string' && coerce) {
                 d = parseISO(input);
             }
             else if (typeof input === 'number')
@@ -33,7 +36,7 @@ export function isDate(options) {
                 d.setHours(0, 0, 0, 0);
             return d;
         }
-        context.fail(_this, `{{label}} must be a Date instance or a date string`, input);
+        context.fail(_this, `"{{value}}" is not a valid date value`, input, { ...options });
     }, options);
 }
 /**
@@ -45,6 +48,7 @@ export function isDateString(options) {
     const precision = options?.precision;
     const trim = options?.trim;
     return validator('isDateString', function (input, context, _this) {
+        const coerce = options?.coerce || context.coerce;
         if (typeof input === 'string') {
             const m = DATE_PATTERN.exec(input);
             if (m) {
@@ -55,7 +59,7 @@ export function isDateString(options) {
                         (precision === 'month' && m[2]) ||
                         (precision === 'date' && m[2] && m[3]) ||
                         (precision === 'time' && m[2] && m[3] && m[4])) {
-                        if (!context.coerce)
+                        if (!coerce)
                             return input;
                         let s = m[1];
                         if (m[2])
@@ -79,10 +83,8 @@ export function isDateString(options) {
             }
         }
         else if (input instanceof Date) {
-            return trim === 'date'
-                ? formatISO(input, { representation: 'date' })
-                : formatISO(input).substring(0, 19);
+            return trim === 'date' ? formatISO(input, { representation: 'date' }) : formatISO(input).substring(0, 19);
         }
-        context.fail(_this, `{{label}} is not a valid date string`, input, { ...options });
+        context.fail(_this, `"{{value}}" is not a valid date string`, input, { ...options });
     }, options);
 }