valgen 4.0.1 → 4.2.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# v4.2.0
+[2023-11-15]
+
+### Changes
+
+* Removed "format" option and added "precision" option to isDate validator ([`2e332a6`](https://github.com/panates/valgen/commit/2e332a6fb9907e0b50f98a6dbcbbdfb3764af867))
+* Added test for "label" option ([`162f41a`](https://github.com/panates/valgen/commit/162f41ac36762a146718c3efc4784bb33f48c955))
+
+# v4.1.0
+[2023-10-31]
+
+### Changes
+
+* Updated validation messages. ([`066fc4e`](https://github.com/panates/valgen/commit/066fc4e0f9fc7a0c0543572cf543c66084611135))
+
 # v4.0.1
 [2023-10-24]
 

package/cjs/core/context.js

@@ -15,6 +15,8 @@ class Context {
             this.onFail = options.onFail;
         if (options?.coerce != null)
             this.coerce = options?.coerce;
+        if (options?.label != null)
+            this.label = options?.label;
     }
     fail(rule, message, value, details) {
         const issue = (0, omit_undefined_js_1.omitUndefined)({

package/cjs/rules/is-array.js

@@ -12,7 +12,7 @@ function isArray(itemValidator, options) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} is not an array`, input);
+            context.fail(_this, `{{label}} must be an array`, input);
             return;
         }
         if (!itemValidator)

package/cjs/rules/is-bigint.js

@@ -9,13 +9,12 @@ const index_js_1 = require("../core/index.js");
  */
 function isBigint(options) {
     return (0, index_js_1.validator)('isBigint', function (input, context, _this) {
-        if (input != null && typeof input !== 'bigint' && context.coerce) {
-            if (typeof input === 'string' || typeof input === 'number')
-                input = BigInt(input);
-        }
         if (typeof input === 'bigint')
             return input;
-        context.fail(_this, `{{label}} is not a valid BigInt`, input);
+        if ((typeof input === 'number' && !isNaN(input)) ||
+            (typeof input === 'string' && context.coerce))
+            return BigInt(input);
+        context.fail(_this, `{{label}} must be an integer number`, input);
     }, options);
 }
 exports.isBigint = isBigint;

package/cjs/rules/is-boolean.js

@@ -24,7 +24,7 @@ function isBoolean(options) {
         }
         if (typeof input === 'boolean')
             return input;
-        context.fail(_this, `{{label}} is not a valid boolean`, input);
+        context.fail(_this, `{{label}} must be a boolean`, input);
     }, options);
 }
 exports.isBoolean = isBoolean;

package/cjs/rules/is-date.js

@@ -7,31 +7,41 @@ exports.isDateString = exports.isDate = void 0;
 const dayjs_1 = __importDefault(require("dayjs"));
 const customParseFormat_1 = __importDefault(require("dayjs/plugin/customParseFormat"));
 const index_js_1 = require("../core/index.js");
-const object_utils_js_1 = require("../helpers/object.utils.js");
 dayjs_1.default.extend(customParseFormat_1.default);
+/* 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)?)?$/;
 /**
  * Validates if value is instance of "Date".
  * Converts input value to Date if coerce option is set to 'true'.
  * @validator isDate
  */
 function isDate(options) {
+    const precision = options?.precision;
     return (0, index_js_1.validator)('isDate', function (input, context, _this) {
         if (input != null && !(input instanceof Date) && context.coerce) {
-            if (typeof input === 'string') {
-                const d = (0, dayjs_1.default)(input, options?.format);
+            if (typeof input === 'string' && context.coerce) {
+                const d = (0, dayjs_1.default)(input);
                 if (d.isValid())
                     input = d.toDate();
             }
             else if (typeof input === 'number')
                 input = new Date(input);
         }
-        if (input && input instanceof Date && !isNaN(input.getTime()))
+        if (input && input instanceof Date && !isNaN(input.getTime())) {
+            if (precision === 'year') {
+                input.setHours(0, 0, 0, 0);
+                input.setMonth(0, 1);
+            }
+            if (precision === 'month') {
+                input.setHours(0, 0, 0, 0);
+                input.setDate(1);
+            }
+            if (precision === 'date')
+                input.setHours(0, 0, 0, 0);
             return input;
-        context.fail(_this, `{{label}} is not a valid Date instance` +
-            (context.coerce
-                ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
-                : ''), input, { format: options?.format });
-    }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
+        }
+        context.fail(_this, `{{label}} must be a Date instance or a date string`, input);
+    }, options);
 }
 exports.isDate = isDate;
 /**
@@ -40,23 +50,55 @@ exports.isDate = isDate;
  * @validator isDateString
  */
 function isDateString(options) {
-    const inputFormat = options?.format;
-    const coerceFormat = Array.isArray(options?.format) ? options?.format[0] : options?.format;
+    const precision = options?.precision;
+    const trim = options?.trim;
     return (0, index_js_1.validator)('isDateString', function (input, context, _this) {
-        if (input instanceof Date) {
+        if (typeof input === 'string') {
             const d = (0, dayjs_1.default)(input);
-            if (d.isValid())
-                return coerceFormat ? d.format(coerceFormat) : d.toISOString();
+            if (d.isValid()) {
+                const m = DATE_PATTERN.exec(input);
+                if (m) {
+                    if (!precision ||
+                        precision === 'year' ||
+                        (precision === 'month' && m[2]) ||
+                        (precision === 'date' && m[2] && m[3]) ||
+                        (precision === 'time' && m[2] && m[3] && m[4])) {
+                        if (!context.coerce)
+                            return input;
+                        let s = m[1];
+                        if (m[2])
+                            s += '-' + m[2];
+                        else
+                            return s;
+                        if (m[3])
+                            s += '-' + m[3];
+                        else
+                            return s;
+                        if (trim === 'time' || !m[4])
+                            return s;
+                        s += 'T' + m[4];
+                        if (trim === 'timezone')
+                            return s;
+                        if (m[9])
+                            s += '-' + m[9];
+                        return s;
+                    }
+                }
+            }
         }
-        else if (typeof input === 'string') {
-            const d = (0, dayjs_1.default)(input, inputFormat);
+        else if (input != null) {
+            const d = (0, dayjs_1.default)(input);
             if (d.isValid()) {
-                if (context.coerce && options?.format)
-                    return coerceFormat ? d.format(coerceFormat) : d.toISOString();
-                return input;
+                if (!context.coerce)
+                    return input;
+                if (trim === 'timezone')
+                    return d.millisecond() ? d.format('YYYY-MM-DDTHH:mm:ss.SSS') : d.format('YYYY-MM-DDTHH:mm:ss');
+                if (trim === 'time')
+                    return d.format('YYYY-MM-DD');
+                return d.toISOString();
             }
         }
-        context.fail(_this, `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`, input, { format: options?.format });
-    }, (0, object_utils_js_1.omitKeys)(options || {}, ['format']));
+        context.fail(_this, `{{label}} is not a valid date string`, input, { ...options });
+    }, options);
 }
 exports.isDateString = isDateString;

package/cjs/rules/is-empty.js

@@ -8,29 +8,29 @@ const index_js_1 = require("../core/index.js");
  */
 function isEmpty(options) {
     return (0, index_js_1.validator)('isEmpty', function (input, context, _this) {
-        if (input != null) {
-            if (typeof input === 'string') {
-                if (!input)
-                    return input;
-            }
-            else if (Array.isArray(input)) {
-                if (!input.length)
-                    return input;
-            }
-            else if (input instanceof Set) {
-                if (!input.size)
-                    return input;
-            }
-            else if (input instanceof Map) {
-                if (!input.size)
-                    return input;
-            }
-            else if (typeof input === 'object') {
-                if (!Object.keys(input).length)
-                    return input;
-            }
+        if (input == null)
+            return input;
+        if (typeof input === 'string') {
+            if (!input)
+                return input;
+        }
+        else if (Array.isArray(input)) {
+            if (!input.length)
+                return input;
+        }
+        else if (input instanceof Set) {
+            if (!input.size)
+                return input;
+        }
+        else if (input instanceof Map) {
+            if (!input.size)
+                return input;
+        }
+        else if (typeof input === 'object') {
+            if (!Object.keys(input).length)
+                return input;
         }
-        context.fail(_this, `{{label}} is not empty`, input);
+        context.fail(_this, `{{label}} must be empty`, input);
     }, options);
 }
 exports.isEmpty = isEmpty;
@@ -62,7 +62,7 @@ function isNotEmpty(options) {
                     return input;
             }
         }
-        context.fail(_this, `{{label}} is empty`, input);
+        context.fail(_this, `{{label}} mustn't be empty`, input);
     }, options);
 }
 exports.isNotEmpty = isNotEmpty;

package/cjs/rules/is-integer.js

@@ -20,7 +20,7 @@ function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.fail(_this, `{{label}} is not a valid integer number`, input);
+        context.fail(_this, `{{label}} must be an integer number`, input);
     }, options);
 }
 exports.isInteger = isInteger;

package/cjs/rules/is-null.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUndefined = exports.isDefined = exports.isNull = void 0;
+exports.isUndefined = exports.isDefined = exports.isNullish = exports.isNull = void 0;
 const index_js_1 = require("../core/index.js");
 /**
  * Validates if value is "null".
@@ -8,14 +8,28 @@ const index_js_1 = require("../core/index.js");
  */
 function isNull(options) {
     return (0, index_js_1.validator)('isNull', function (input, context, _this) {
-        if (context.coerce)
-            return null;
         if (input === null)
             return input;
-        context.fail(_this, `{{label}} is not null`, input);
+        if (context.coerce)
+            return null;
+        context.fail(_this, `{{label}} must be null`, input);
     }, options);
 }
 exports.isNull = isNull;
+/**
+ * Validates if value is "null" or "undefined".
+ * @validator isNull
+ */
+function isNullish(options) {
+    return (0, index_js_1.validator)('isNullish', function (input, context, _this) {
+        if (input == null)
+            return input;
+        if (context.coerce)
+            return null;
+        context.fail(_this, `{{label}} must be null or undefined`, input);
+    }, options);
+}
+exports.isNullish = isNullish;
 /**
  * Validates if value is not "undefined" nor "null"
  * @validator isDefined
@@ -24,7 +38,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}} is not defined`, input);
+        context.fail(_this, `{{label}} must be defined`, input);
     }, options);
 }
 exports.isDefined = isDefined;
@@ -38,7 +52,7 @@ function isUndefined(options) {
             return undefined;
         if (input === undefined)
             return;
-        context.fail(_this, `{{label}} defined`, input);
+        context.fail(_this, `{{label}} mustn\'t be defined`, input);
     }, options);
 }
 exports.isUndefined = isUndefined;

package/cjs/rules/is-number.js

@@ -20,7 +20,7 @@ function isNumber(options) {
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.fail(_this, `{{label}} is not a valid number`, input);
+        context.fail(_this, `{{label}} must be a number`, 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}} is not a valid ObjectId`, input);
+        context.fail(_this, `{{label}} must be an ObjectId`, input);
     }, options);
 }
 exports.isObjectId = isObjectId;

package/cjs/rules/is-object.js

@@ -33,7 +33,7 @@ function isObject(schema, options) {
     });
     const _rule = (0, index_js_1.validator)('isObject', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.fail(_this, `{{label}} is not an object`, input);
+            context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
         const keys = [...Object.keys(input), ...Object.keys(schema)];

package/cjs/rules/is-record.js

@@ -10,7 +10,7 @@ const index_js_1 = require("../core/index.js");
 function isRecord(keyRule, valueRule, options) {
     return (0, index_js_1.validator)('isRecord', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.fail(_this, `{{label}} is not an object`, input);
+            context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
         const keyContext = context.extend();

package/cjs/rules/is-string.js

@@ -21,7 +21,7 @@ function isString(options) {
         }
         if (typeof input === 'string')
             return input;
-        context.fail(_this, `{{label}} is not a string`, input);
+        context.fail(_this, `{{label}} must be a string`, input);
     }, options);
 }
 exports.isString = isString;

package/cjs/rules/is-tuple.js

@@ -7,7 +7,7 @@ function isTuple(items, options) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} is not a tuple`, input);
+            context.fail(_this, `{{label}} must be a tuple`, input);
             return;
         }
         const location = context.location || '';

package/esm/core/context.js

@@ -12,6 +12,8 @@ export class Context {
             this.onFail = options.onFail;
         if (options?.coerce != null)
             this.coerce = options?.coerce;
+        if (options?.label != null)
+            this.label = options?.label;
     }
     fail(rule, message, value, details) {
         const issue = omitUndefined({

package/esm/rules/is-array.js

@@ -9,7 +9,7 @@ export function isArray(itemValidator, options) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} is not an array`, input);
+            context.fail(_this, `{{label}} must be an array`, input);
             return;
         }
         if (!itemValidator)

package/esm/rules/is-bigint.js

@@ -6,12 +6,11 @@ import { validator } from '../core/index.js';
  */
 export function isBigint(options) {
     return validator('isBigint', function (input, context, _this) {
-        if (input != null && typeof input !== 'bigint' && context.coerce) {
-            if (typeof input === 'string' || typeof input === 'number')
-                input = BigInt(input);
-        }
         if (typeof input === 'bigint')
             return input;
-        context.fail(_this, `{{label}} is not a valid BigInt`, input);
+        if ((typeof input === 'number' && !isNaN(input)) ||
+            (typeof input === 'string' && context.coerce))
+            return BigInt(input);
+        context.fail(_this, `{{label}} must be an integer number`, input);
     }, options);
 }

package/esm/rules/is-boolean.js

@@ -21,6 +21,6 @@ export function isBoolean(options) {
         }
         if (typeof input === 'boolean')
             return input;
-        context.fail(_this, `{{label}} is not a valid boolean`, input);
+        context.fail(_this, `{{label}} must be a boolean`, input);
     }, options);
 }

package/esm/rules/is-date.js

@@ -1,31 +1,41 @@
 import dayjs from 'dayjs';
 import customParseFormat from 'dayjs/plugin/customParseFormat';
 import { validator } from '../core/index.js';
-import { omitKeys } from '../helpers/object.utils.js';
 dayjs.extend(customParseFormat);
+/* 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)?)?$/;
 /**
  * Validates if value is instance of "Date".
  * Converts input value to Date if coerce option is set to 'true'.
  * @validator isDate
  */
 export function isDate(options) {
+    const precision = options?.precision;
     return validator('isDate', function (input, context, _this) {
         if (input != null && !(input instanceof Date) && context.coerce) {
-            if (typeof input === 'string') {
-                const d = dayjs(input, options?.format);
+            if (typeof input === 'string' && context.coerce) {
+                const d = dayjs(input);
                 if (d.isValid())
                     input = d.toDate();
             }
             else if (typeof input === 'number')
                 input = new Date(input);
         }
-        if (input && input instanceof Date && !isNaN(input.getTime()))
+        if (input && input instanceof Date && !isNaN(input.getTime())) {
+            if (precision === 'year') {
+                input.setHours(0, 0, 0, 0);
+                input.setMonth(0, 1);
+            }
+            if (precision === 'month') {
+                input.setHours(0, 0, 0, 0);
+                input.setDate(1);
+            }
+            if (precision === 'date')
+                input.setHours(0, 0, 0, 0);
             return input;
-        context.fail(_this, `{{label}} is not a valid Date instance` +
-            (context.coerce
-                ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
-                : ''), input, { format: options?.format });
-    }, omitKeys(options || {}, ['format']));
+        }
+        context.fail(_this, `{{label}} must be a Date instance or a date string`, input);
+    }, options);
 }
 /**
  * Validates if value is DFS (date formatted string).
@@ -33,22 +43,54 @@ export function isDate(options) {
  * @validator isDateString
  */
 export function isDateString(options) {
-    const inputFormat = options?.format;
-    const coerceFormat = Array.isArray(options?.format) ? options?.format[0] : options?.format;
+    const precision = options?.precision;
+    const trim = options?.trim;
     return validator('isDateString', function (input, context, _this) {
-        if (input instanceof Date) {
+        if (typeof input === 'string') {
             const d = dayjs(input);
-            if (d.isValid())
-                return coerceFormat ? d.format(coerceFormat) : d.toISOString();
+            if (d.isValid()) {
+                const m = DATE_PATTERN.exec(input);
+                if (m) {
+                    if (!precision ||
+                        precision === 'year' ||
+                        (precision === 'month' && m[2]) ||
+                        (precision === 'date' && m[2] && m[3]) ||
+                        (precision === 'time' && m[2] && m[3] && m[4])) {
+                        if (!context.coerce)
+                            return input;
+                        let s = m[1];
+                        if (m[2])
+                            s += '-' + m[2];
+                        else
+                            return s;
+                        if (m[3])
+                            s += '-' + m[3];
+                        else
+                            return s;
+                        if (trim === 'time' || !m[4])
+                            return s;
+                        s += 'T' + m[4];
+                        if (trim === 'timezone')
+                            return s;
+                        if (m[9])
+                            s += '-' + m[9];
+                        return s;
+                    }
+                }
+            }
         }
-        else if (typeof input === 'string') {
-            const d = dayjs(input, inputFormat);
+        else if (input != null) {
+            const d = dayjs(input);
             if (d.isValid()) {
-                if (context.coerce && options?.format)
-                    return coerceFormat ? d.format(coerceFormat) : d.toISOString();
-                return input;
+                if (!context.coerce)
+                    return input;
+                if (trim === 'timezone')
+                    return d.millisecond() ? d.format('YYYY-MM-DDTHH:mm:ss.SSS') : d.format('YYYY-MM-DDTHH:mm:ss');
+                if (trim === 'time')
+                    return d.format('YYYY-MM-DD');
+                return d.toISOString();
             }
         }
-        context.fail(_this, `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`, input, { format: options?.format });
-    }, omitKeys(options || {}, ['format']));
+        context.fail(_this, `{{label}} is not a valid date string`, input, { ...options });
+    }, options);
 }

package/esm/rules/is-empty.js

@@ -5,29 +5,29 @@ import { validator } from '../core/index.js';
  */
 export function isEmpty(options) {
     return validator('isEmpty', function (input, context, _this) {
-        if (input != null) {
-            if (typeof input === 'string') {
-                if (!input)
-                    return input;
-            }
-            else if (Array.isArray(input)) {
-                if (!input.length)
-                    return input;
-            }
-            else if (input instanceof Set) {
-                if (!input.size)
-                    return input;
-            }
-            else if (input instanceof Map) {
-                if (!input.size)
-                    return input;
-            }
-            else if (typeof input === 'object') {
-                if (!Object.keys(input).length)
-                    return input;
-            }
+        if (input == null)
+            return input;
+        if (typeof input === 'string') {
+            if (!input)
+                return input;
+        }
+        else if (Array.isArray(input)) {
+            if (!input.length)
+                return input;
+        }
+        else if (input instanceof Set) {
+            if (!input.size)
+                return input;
+        }
+        else if (input instanceof Map) {
+            if (!input.size)
+                return input;
+        }
+        else if (typeof input === 'object') {
+            if (!Object.keys(input).length)
+                return input;
         }
-        context.fail(_this, `{{label}} is not empty`, input);
+        context.fail(_this, `{{label}} must be empty`, input);
     }, options);
 }
 /**
@@ -58,6 +58,6 @@ export function isNotEmpty(options) {
                     return input;
             }
         }
-        context.fail(_this, `{{label}} is empty`, input);
+        context.fail(_this, `{{label}} mustn't be empty`, input);
     }, options);
 }

package/esm/rules/is-integer.js

@@ -17,6 +17,6 @@ export function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.fail(_this, `{{label}} is not a valid integer number`, input);
+        context.fail(_this, `{{label}} must be an integer number`, input);
     }, options);
 }

package/esm/rules/is-null.js

@@ -5,11 +5,24 @@ import { validator } from '../core/index.js';
  */
 export function isNull(options) {
     return validator('isNull', function (input, context, _this) {
+        if (input === null)
+            return input;
         if (context.coerce)
             return null;
-        if (input === null)
+        context.fail(_this, `{{label}} must be null`, input);
+    }, options);
+}
+/**
+ * Validates if value is "null" or "undefined".
+ * @validator isNull
+ */
+export function isNullish(options) {
+    return validator('isNullish', function (input, context, _this) {
+        if (input == null)
             return input;
-        context.fail(_this, `{{label}} is not null`, input);
+        if (context.coerce)
+            return null;
+        context.fail(_this, `{{label}} must be null or undefined`, input);
     }, options);
 }
 /**
@@ -20,7 +33,7 @@ export function isDefined(options) {
     return validator('is-defined', function (input, context, _this) {
         if (input !== undefined)
             return input;
-        context.fail(_this, `{{label}} is not defined`, input);
+        context.fail(_this, `{{label}} must be defined`, input);
     }, options);
 }
 /**
@@ -33,6 +46,6 @@ export function isUndefined(options) {
             return undefined;
         if (input === undefined)
             return;
-        context.fail(_this, `{{label}} defined`, input);
+        context.fail(_this, `{{label}} mustn\'t be defined`, input);
     }, options);
 }

package/esm/rules/is-number.js

@@ -17,6 +17,6 @@ export function isNumber(options) {
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.fail(_this, `{{label}} is not a valid number`, input);
+        context.fail(_this, `{{label}} must be a number`, 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}} is not a valid ObjectId`, input);
+        context.fail(_this, `{{label}} must be an ObjectId`, input);
     }, options);
 }
 function _isObjectIdValue(input) {

package/esm/rules/is-object.js

@@ -30,7 +30,7 @@ export function isObject(schema, options) {
     });
     const _rule = validator('isObject', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.fail(_this, `{{label}} is not an object`, input);
+            context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
         const keys = [...Object.keys(input), ...Object.keys(schema)];

package/esm/rules/is-record.js

@@ -7,7 +7,7 @@ import { validator, } from '../core/index.js';
 export function isRecord(keyRule, valueRule, options) {
     return validator('isRecord', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.fail(_this, `{{label}} is not an object`, input);
+            context.fail(_this, `{{label}} must be an object`, input);
             return;
         }
         const keyContext = context.extend();

package/esm/rules/is-string.js

@@ -18,7 +18,7 @@ export function isString(options) {
         }
         if (typeof input === 'string')
             return input;
-        context.fail(_this, `{{label}} is not a string`, input);
+        context.fail(_this, `{{label}} must be a string`, input);
     }, options);
 }
 export function stringReplace(searchValue, replacer) {

package/esm/rules/is-tuple.js

@@ -4,7 +4,7 @@ export function isTuple(items, options) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} is not a tuple`, input);
+            context.fail(_this, `{{label}} must be a tuple`, input);
             return;
         }
         const location = context.location || '';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "4.0.1",
+  "version": "4.2.0",
   "author": "Panates",
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>"
@@ -12,7 +12,7 @@
     "url": "https://github.com/panates/valgen.git"
   },
   "dependencies": {
-    "@types/validator": "^13.11.5",
+    "@types/validator": "^13.11.6",
     "dayjs": "^2.0.0-alpha.4",
     "ts-gems": "^2.5.0",
     "validator": "^13.11.0"

package/typings/core/types.d.ts

@@ -18,4 +18,5 @@ export interface ValidationOptions {
 export interface ExecutionOptions extends ValidationOptions {
     coerce?: boolean;
     maxErrors?: number;
+    label?: string;
 }

package/typings/rules/is-date.d.ts

@@ -1,6 +1,6 @@
 import { ValidationOptions } from '../core/index.js';
 export interface IsDateOptions extends ValidationOptions {
-    format?: string | string[];
+    precision?: 'year' | 'month' | 'date' | 'time';
 }
 /**
  * Validates if value is instance of "Date".
@@ -9,7 +9,8 @@ export interface IsDateOptions extends ValidationOptions {
  */
 export declare function isDate(options?: IsDateOptions): import("../core/validator.js").Validator<Date, string | number | Date, import("../core/types.js").ExecutionOptions>;
 export interface IsDateStringOptions extends ValidationOptions {
-    format?: string | string[];
+    precision?: 'year' | 'month' | 'date' | 'time';
+    trim?: 'time' | 'timezone';
 }
 /**
  * Validates if value is DFS (date formatted string).

package/typings/rules/is-null.d.ts

@@ -4,6 +4,11 @@ import { ValidationOptions } from '../core/index.js';
  * @validator isNull
  */
 export declare function isNull(options?: ValidationOptions): import("../core/validator.js").Validator<null, unknown, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is "null" or "undefined".
+ * @validator isNull
+ */
+export declare function isNullish(options?: ValidationOptions): import("../core/validator.js").Validator<null, unknown, import("../core/types.js").ExecutionOptions>;
 /**
  * Validates if value is not "undefined" nor "null"
  * @validator isDefined