valgen 5.2.1 → 5.3.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# v5.3.0
+[2024-05-06]
+
+### Changes
+
+* Added validation generation option to enable coercing by default. ([`5b012ee`](https://github.com/panates/valgen/commit/5b012ee21b89e601ebb7d9f624d93042862da8ca))
+
+# v5.2.2
+[2024-03-29]
+
+### Changes
+
+* Updated dependencies ([`9d9af6f`](https://github.com/panates/valgen/commit/9d9af6fadeece926a8ec1bc93d14ffc7ace625d0))
+* Updated dependencies ([`636ce75`](https://github.com/panates/valgen/commit/636ce759e83e765661e7c5c8730c6b824076d344))
+
 # v5.2.1
 [2024-03-27]
 

package/cjs/core/context.js

@@ -44,7 +44,11 @@ class Context {
                 return x;
             const k = m[1];
             let v = issue[k];
-            if (!v && m[1] === 'label' && (this.location || this.property))
+            if (k === 'value') {
+                const s = String(issue.value);
+                return s.length < 30 ? s : s.substring(0, 30) + '..';
+            }
+            if (!v && k === 'label' && (this.location || this.property))
                 v = '`' + (this.location || this.property) + '`';
             if (v != null)
                 return v;

package/cjs/index.js

@@ -26,7 +26,8 @@ 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 });
-exports.isHexadecimal = exports.isDecimal = exports.isAscii = exports.isAlphanumeric = exports.isAlpha = exports.isUppercase = exports.isLowercase = exports.isJWT = exports.isHexColor = exports.isETHAddress = exports.isBtcAddress = exports.isISSN = exports.isFQDN = exports.isEAN = exports.isIBAN = exports.isCreditCard = exports.isBIC = exports.isBase64 = exports.isURL = exports.isPort = exports.isMACAddress = exports.isIPRange = exports.isIP = exports.isMobilePhone = exports.isEmail = exports.isUUID5 = exports.isUUID4 = exports.isUUID3 = exports.isUUID2 = exports.isUUID1 = exports.isUUID = exports.isString = exports.isObjectId = exports.isObject = exports.isNumber = exports.isUndefined = exports.isDefined = exports.isNullish = exports.isNull = exports.isInteger = exports.isNotEmpty = exports.isEmpty = exports.isDateString = exports.isDate = exports.isBoolean = exports.isBigint = exports.isArray = exports.isAny = exports.vg = void 0;
+exports.toArray = exports.isHexadecimal = exports.isDecimal = exports.isAscii = exports.isAlphanumeric = exports.isAlpha = exports.isUppercase = exports.isLowercase = exports.isJWT = exports.isHexColor = exports.isETHAddress = exports.isBtcAddress = exports.isISSN = exports.isFQDN = exports.isEAN = exports.isIBAN = exports.isCreditCard = exports.isBIC = exports.isBase64 = exports.isURL = exports.isPort = exports.isMACAddress = exports.isIPRange = exports.isIP = exports.isMobilePhone = exports.isEmail = exports.isUUID5 = exports.isUUID4 = exports.isUUID3 = exports.isUUID2 = exports.isUUID1 = exports.isUUID = exports.isString = exports.isObjectId = exports.isObject = exports.isNumber = exports.isUndefined = exports.isDefined = exports.isNullish = exports.isNull = exports.isInteger = exports.isNotEmpty = exports.isEmpty = exports.isDateString = exports.isDate = exports.isBoolean = exports.isBigint = exports.isArray = exports.isAny = exports.vg = void 0;
+exports.toString = exports.toNumber = exports.toInteger = exports.toDateString = exports.toDate = exports.toBoolean = void 0;
 const vg = __importStar(require("./rules/index.js"));
 exports.vg = vg;
 __exportStar(require("./constants.js"), exports);
@@ -127,3 +128,17 @@ const isDecimal = vg.isDecimal();
 exports.isDecimal = isDecimal;
 const isHexadecimal = vg.isHexadecimal();
 exports.isHexadecimal = isHexadecimal;
+const toArray = vg.isArray(isAny, { coerce: true });
+exports.toArray = toArray;
+const toBoolean = vg.isBoolean({ coerce: true });
+exports.toBoolean = toBoolean;
+const toDate = vg.isDate({ coerce: true });
+exports.toDate = toDate;
+const toDateString = vg.isDateString({ coerce: true });
+exports.toDateString = toDateString;
+const toInteger = vg.isInteger({ coerce: true });
+exports.toInteger = toInteger;
+const toNumber = vg.isNumber({ coerce: true });
+exports.toNumber = toNumber;
+const toString = vg.isString({ coerce: true });
+exports.toString = toString;

package/cjs/rules/is-array.js

@@ -9,10 +9,11 @@ const index_js_1 = require("../core/index.js");
  */
 function isArray(itemValidator, options) {
     return (0, index_js_1.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)

package/cjs/rules/is-bigint.js

@@ -9,12 +9,14 @@ const index_js_1 = require("../core/index.js");
  */
 function isBigint(options) {
     return (0, index_js_1.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))
+            (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);
 }
 exports.isBigint = isBigint;

package/cjs/rules/is-boolean.js

@@ -11,7 +11,8 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  */
 function isBoolean(options) {
     return (0, index_js_1.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;
@@ -24,7 +25,8 @@ 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);
 }
 exports.isBoolean = isBoolean;

package/cjs/rules/is-date.js

@@ -13,11 +13,12 @@ const DATE_PATTERN = /^(\d{4})(?:-(0[0-9]|1[0-2]))?(?:-([0-2][0-9]|3[0-1]))?(?:[
 function isDate(options) {
     const precision = options?.precision;
     return (0, index_js_1.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 = (0, date_fns_1.parseISO)(input);
             }
             else if (typeof input === 'number')
@@ -36,7 +37,7 @@ 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);
 }
 exports.isDate = isDate;
@@ -49,6 +50,7 @@ function isDateString(options) {
     const precision = options?.precision;
     const trim = options?.trim;
     return (0, index_js_1.validator)('isDateString', function (input, context, _this) {
+        const coerce = options?.coerce || context.coerce;
         if (typeof input === 'string') {
             const m = DATE_PATTERN.exec(input);
             if (m) {
@@ -59,7 +61,7 @@ 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])
@@ -87,7 +89,7 @@ function isDateString(options) {
                 ? (0, date_fns_1.formatISO)(input, { representation: 'date' })
                 : (0, date_fns_1.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);
 }
 exports.isDateString = isDateString;

package/cjs/rules/is-empty.js

@@ -13,24 +13,29 @@ 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);
 }
 exports.isEmpty = isEmpty;
@@ -44,25 +49,30 @@ 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);
 }
 exports.isNotEmpty = isNotEmpty;

package/cjs/rules/is-integer.js

@@ -9,7 +9,8 @@ const index_js_1 = require("../core/index.js");
  */
 function isInteger(options) {
     return (0, index_js_1.validator)('isInteger', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
@@ -20,7 +21,9 @@ function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.fail(_this, `{{label}} must be an integer number`, input);
+        const t = typeof input === 'bigint' ? 'BigInt ' :
+            (typeof input === 'string' ? 'String ' : '');
+        context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);
 }
 exports.isInteger = isInteger;

package/cjs/rules/is-null.js

@@ -10,9 +10,10 @@ function isNull(options) {
     return (0, index_js_1.validator)('isNull', function (input, context, _this) {
         if (input === null)
             return input;
-        if (context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
             return null;
-        context.fail(_this, `{{label}} must be null`, input);
+        context.fail(_this, `"{{value}}" is not null`, input);
     }, options);
 }
 exports.isNull = isNull;
@@ -24,9 +25,10 @@ function isNullish(options) {
     return (0, index_js_1.validator)('isNullish', function (input, context, _this) {
         if (input == null)
             return input;
-        if (context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
             return null;
-        context.fail(_this, `{{label}} must be null or undefined`, input);
+        context.fail(_this, `"{{value}}" is not nullish`, input);
     }, options);
 }
 exports.isNullish = isNullish;
@@ -38,7 +40,7 @@ function isDefined(options) {
     return (0, index_js_1.validator)('is-defined', function (input, context, _this) {
         if (input !== undefined)
             return input;
-        context.fail(_this, `{{label}} must be defined`, input);
+        context.fail(_this, `Is not defined`, input);
     }, options);
 }
 exports.isDefined = isDefined;
@@ -48,7 +50,7 @@ exports.isDefined = isDefined;
  */
 function isUndefined(options) {
     return (0, index_js_1.validator)('isUndefined', function (input, context, _this) {
-        if (context.coerce)
+        if (options?.coerce || context.coerce)
             return undefined;
         if (input === undefined)
             return;

package/cjs/rules/is-number.js

@@ -9,18 +9,21 @@ const index_js_1 = require("../core/index.js");
  */
 function isNumber(options) {
     return (0, index_js_1.validator)('isNumber', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
                 const v = Number(input);
                 if (input === BigInt(v))
-                    input = v;
+                    return v;
             }
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.fail(_this, `{{label}} must be a number`, input);
+        const t = typeof input === 'bigint' ? 'BigInt ' :
+            (typeof input === 'string' ? 'String ' : '');
+        context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);
 }
 exports.isNumber = isNumber;

package/cjs/rules/is-object-id.js

@@ -18,7 +18,7 @@ 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);
 }
 exports.isObjectId = isObjectId;

package/cjs/rules/is-object.js

@@ -37,7 +37,8 @@ function isObject(schema, options) {
     const _rule = (0, index_js_1.validator)('isObject', function (input, context, _this) {
         if (ctor && ctor[constants_js_1.preValidation])
             input = ctor[constants_js_1.preValidation](input, context, _this);
-        if (typeof input === 'string' && context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (typeof input === 'string' && coerce)
             input = JSON.parse(input);
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);

package/cjs/rules/is-string.js

@@ -9,7 +9,8 @@ const index_js_1 = require("../core/index.js");
  */
 function isString(options) {
     return (0, index_js_1.validator)('isString', function (input, context, _this) {
-        if (input != null && typeof input !== 'string' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'string' && coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
                     input = input.toJSON();

package/cjs/rules/is-tuple.js

@@ -4,10 +4,11 @@ exports.isTuple = void 0;
 const index_js_1 = require("../core/index.js");
 function isTuple(items, options) {
     return (0, index_js_1.validator)('isTuple', 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 a tuple`, input);
+            context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
         }
         const location = context.location || '';

package/cjs/rules/range.js

@@ -83,7 +83,7 @@ function range(minValue, maxValue, options) {
         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);
+        context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
     }, options);
 }
 exports.range = range;

package/cjs/rules/union.js

@@ -30,7 +30,7 @@ function union(codecs) {
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `{{location}} didn't match any of required format`, input);
+        context.fail(_this, `Value didn't match any on union rules`, input);
     });
 }
 exports.union = union;

package/esm/core/context.js

@@ -41,7 +41,11 @@ export class Context {
                 return x;
             const k = m[1];
             let v = issue[k];
-            if (!v && m[1] === 'label' && (this.location || this.property))
+            if (k === 'value') {
+                const s = String(issue.value);
+                return s.length < 30 ? s : s.substring(0, 30) + '..';
+            }
+            if (!v && k === 'label' && (this.location || this.property))
                 v = '`' + (this.location || this.property) + '`';
             if (v != null)
                 return v;

package/esm/index.js

@@ -49,4 +49,11 @@ const isAlphanumeric = vg.isAlphanumeric();
 const isAscii = vg.isAscii();
 const isDecimal = vg.isDecimal();
 const isHexadecimal = vg.isHexadecimal();
-export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal };
+const toArray = vg.isArray(isAny, { coerce: true });
+const toBoolean = vg.isBoolean({ coerce: true });
+const toDate = vg.isDate({ coerce: true });
+const toDateString = vg.isDateString({ coerce: true });
+const toInteger = vg.isInteger({ coerce: true });
+const toNumber = vg.isNumber({ coerce: true });
+const toString = vg.isString({ coerce: true });
+export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal, toArray, toBoolean, toDate, toDateString, toInteger, toNumber, toString };

package/esm/rules/is-array.js

@@ -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)

package/esm/rules/is-bigint.js

@@ -6,11 +6,13 @@ 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))
+            (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

@@ -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

@@ -10,11 +10,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 +34,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 +46,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 +57,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])
@@ -83,6 +85,6 @@ export function isDateString(options) {
                 ? 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);
 }

package/esm/rules/is-empty.js

@@ -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/is-integer.js

@@ -6,7 +6,8 @@ import { validator } from '../core/index.js';
  */
 export function isInteger(options) {
     return validator('isInteger', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
@@ -17,6 +18,8 @@ export function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.fail(_this, `{{label}} must be an integer number`, input);
+        const t = typeof input === 'bigint' ? 'BigInt ' :
+            (typeof input === 'string' ? 'String ' : '');
+        context.fail(_this, `${t}"{{value}}" is not a valid integer value`, input);
     }, options);
 }

package/esm/rules/is-null.js

@@ -7,9 +7,10 @@ export function isNull(options) {
     return validator('isNull', function (input, context, _this) {
         if (input === null)
             return input;
-        if (context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
             return null;
-        context.fail(_this, `{{label}} must be null`, input);
+        context.fail(_this, `"{{value}}" is not null`, input);
     }, options);
 }
 /**
@@ -20,9 +21,10 @@ export function isNullish(options) {
     return validator('isNullish', function (input, context, _this) {
         if (input == null)
             return input;
-        if (context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (coerce)
             return null;
-        context.fail(_this, `{{label}} must be null or undefined`, input);
+        context.fail(_this, `"{{value}}" is not nullish`, input);
     }, options);
 }
 /**
@@ -33,7 +35,7 @@ export function isDefined(options) {
     return validator('is-defined', function (input, context, _this) {
         if (input !== undefined)
             return input;
-        context.fail(_this, `{{label}} must be defined`, input);
+        context.fail(_this, `Is not defined`, input);
     }, options);
 }
 /**
@@ -42,7 +44,7 @@ export function isDefined(options) {
  */
 export function isUndefined(options) {
     return validator('isUndefined', function (input, context, _this) {
-        if (context.coerce)
+        if (options?.coerce || context.coerce)
             return undefined;
         if (input === undefined)
             return;

package/esm/rules/is-number.js

@@ -6,17 +6,20 @@ import { validator } from '../core/index.js';
  */
 export function isNumber(options) {
     return validator('isNumber', function (input, context, _this) {
-        if (input != null && typeof input !== 'number' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'number' && coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
             if (typeof input === 'bigint') {
                 const v = Number(input);
                 if (input === BigInt(v))
-                    input = v;
+                    return v;
             }
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.fail(_this, `{{label}} must be a number`, input);
+        const t = typeof input === 'bigint' ? 'BigInt ' :
+            (typeof input === 'string' ? 'String ' : '');
+        context.fail(_this, `${t}"{{value}}" is not a valid number value`, input);
     }, options);
 }

package/esm/rules/is-object-id.js

@@ -12,7 +12,7 @@ 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) {

package/esm/rules/is-object.js

@@ -34,7 +34,8 @@ export function isObject(schema, options) {
     const _rule = validator('isObject', function (input, context, _this) {
         if (ctor && ctor[preValidation])
             input = ctor[preValidation](input, context, _this);
-        if (typeof input === 'string' && context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (typeof input === 'string' && coerce)
             input = JSON.parse(input);
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);

package/esm/rules/is-string.js

@@ -6,7 +6,8 @@ import { validator } from '../core/index.js';
  */
 export function isString(options) {
     return validator('isString', function (input, context, _this) {
-        if (input != null && typeof input !== 'string' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'string' && coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
                     input = input.toJSON();

package/esm/rules/is-tuple.js

@@ -1,10 +1,11 @@
 import { validator } from '../core/index.js';
 export function isTuple(items, options) {
     return validator('isTuple', 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 a tuple`, input);
+            context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
         }
         const location = context.location || '';

package/esm/rules/range.js

@@ -76,6 +76,6 @@ export function range(minValue, maxValue, options) {
         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);
+        context.fail(_this, `Value must be between ${minValue} and ${maxValue}`, input);
     }, options);
 }

package/esm/rules/union.js

@@ -27,6 +27,6 @@ export function union(codecs) {
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `{{location}} didn't match any of required format`, input);
+        context.fail(_this, `Value didn't match any on union rules`, input);
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.2.1",
+  "version": "5.3.0",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -14,7 +14,7 @@
   "dependencies": {
     "@types/validator": "^13.11.9",
     "date-fns": "^3.6.0",
-    "ts-gems": "^3.2.1",
+    "ts-gems": "^3.4.0",
     "validator": "^13.11.0"
   },
   "type": "module",

package/typings/core/types.d.ts

@@ -14,6 +14,7 @@ export interface ErrorIssue {
 export type OnFailFunction = (issue: ErrorIssue, context: Context, _super?: OnFailFunction) => string | Omit<ErrorIssue, 'id' | 'input'>;
 export interface ValidationOptions {
     onFail?: OnFailFunction;
+    coerce?: boolean;
 }
 export interface ExecutionOptions extends ValidationOptions {
     coerce?: boolean;

package/typings/index.d.ts

@@ -50,4 +50,11 @@ declare const isAlphanumeric: import("./core/validator.js").Validator<string, st
 declare const isAscii: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isDecimal: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
 declare const isHexadecimal: import("./core/validator.js").Validator<string, string, import("./core/types.js").ExecutionOptions>;
-export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal };
+declare const toArray: import("./core/validator.js").Validator<any[], any, import("./core/types.js").ExecutionOptions>;
+declare const toBoolean: import("./core/validator.js").Validator<boolean | undefined, unknown, import("./core/types.js").ExecutionOptions>;
+declare const toDate: import("./core/validator.js").Validator<Date, string | number | Date, import("./core/types.js").ExecutionOptions>;
+declare const toDateString: import("./core/validator.js").Validator<string, string | number | Date, import("./core/types.js").ExecutionOptions>;
+declare const toInteger: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
+declare const toNumber: import("./core/validator.js").Validator<number, unknown, import("./core/types.js").ExecutionOptions>;
+declare const toString: import("./core/validator.js").Validator<string, unknown, import("./core/types.js").ExecutionOptions>;
+export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal, toArray, toBoolean, toDate, toDateString, toInteger, toNumber, toString };

package/typings/rules/pipe.d.ts

@@ -3,9 +3,9 @@ import { Validator } from '../core/index.js';
  *
  * @validator pipe
  */
-export declare function pipe<T>(...rules: [...Validator[], Validator<T, any>]): Validator<T, any, import("../core/types.js").ExecutionOptions>;
+export declare function pipe<T>(...rules: Validator[]): Validator<T>;
 /**
  * Test given value against to all codecs and returns original input
  * @validator allOf
  */
-export declare function allOf(...rules: Validator[]): Validator<any, any, import("../core/types.js").ExecutionOptions>;
+export declare function allOf<T = any>(...rules: Validator[]): Validator<T>;