valgen 5.15.4 → 5.17.0

package/CHANGELOG.md

@@ -1,6 +1,22 @@
 ## Changelog
 
-### [v5.15.4](https://github.com/panates/valgen/compare/v5.15.3...v5.15.4) - 
+### [v5.17.0](https://github.com/panates/valgen/compare/v5.16.0...v5.17.0) - 
+
+#### 🪲 Fixes
+
+- refactor: Refactored isDate and isDateString validation rules @Eray Hanoğlu 
+
+#### 🛠 Refactoring and Updates
+
+- refactor: Refactored isDate and isDateString validation rules @Eray Hanoğlu 
+
+### [v5.16.0](https://github.com/panates/valgen/compare/v5.15.4...v5.16.0) -  16 July 2025 
+
+#### 🛠 Refactoring and Updates
+
+- refactor: Refactored isDate and isDateString validation rules @Eray Hanoğlu 
+
+### [v5.15.4](https://github.com/panates/valgen/compare/v5.15.3...v5.15.4) -  11 July 2025 
 
 #### 🛠 Refactoring and Updates
 

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

@@ -9,7 +9,7 @@ const index_js_1 = require("../../core/index.js");
  */
 function isArray(itemValidator, options) {
     return (0, index_js_1.validator)('isArray', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
             output = [output];

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

@@ -9,7 +9,7 @@ const index_js_1 = require("../../core/index.js");
  */
 function isBigint(options) {
     return (0, index_js_1.validator)('isBigint', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         if (typeof input === 'bigint')
             return input;
         if ((typeof input === 'number' && !isNaN(input)) ||

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

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

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

@@ -2,97 +2,180 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDate = isDate;
 exports.isDateString = isDateString;
-const date_fns_1 = require("date-fns");
+const tslib_1 = require("tslib");
+const datefns = tslib_1.__importStar(require("date-fns"));
 const index_js_1 = require("../../core/index.js");
-// 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 an instance of "Date".
- * Converts input value to Date if a coerce option is set to 'true'.
+ * Validates if value is a "Date" instance or ISO 8601 formatted date string.
+ *  if a `coerce` option is `true`, converts input value to Date instance
  * @validator isDate
  */
 function isDate(options) {
-    const precision = options?.precision;
+    const trim = options?.trim;
     return (0, index_js_1.validator)('isDate', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         let d;
         if (input instanceof Date)
             d = input;
-        else if (input != null && coerce) {
-            if (typeof input === 'string' && coerce) {
-                d = (0, date_fns_1.parseISO)(input);
-            }
-            else if (typeof input === 'number')
+        else if (coerce) {
+            if (typeof input === 'number')
                 d = new Date(input);
-        }
-        if (d && !isNaN(d.getTime())) {
-            if (precision === 'year') {
-                d.setHours(0, 0, 0, 0);
-                d.setMonth(0, 1);
-            }
-            if (precision === 'month') {
-                d.setHours(0, 0, 0, 0);
-                d.setDate(1);
+            else if (typeof input === 'string') {
+                const parsed = coerceDateString(input);
+                if (parsed) {
+                    d = new Date(parsed.value);
+                }
             }
-            if (precision === 'date')
-                d.setHours(0, 0, 0, 0);
+        }
+        if (datefns.isValid(d)) {
+            setPrecision(d, trim);
             return d;
         }
-        context.fail(_this, `Value must be a valid date`, input, {
+        context.fail(_this, `Value is not valid date`, input, {
             ...options,
         });
     }, options);
 }
 /**
  * Validates if value is DFS (date formatted string).
- * Converts input value to DFS if coerce option is set to 'true'.
+ * Converts input value to DFS if the "coerce" option is set to 'true'.
  * @validator isDateString
  */
 function isDateString(options) {
-    const precision = options?.precision;
-    const trim = options?.trim;
+    const precisionMin = options?.precisionMin || 'minutes';
+    const precisionMax = options?.precisionMax || 'tz';
+    const precisionMaxIdx = PRECISION_INDEX[precisionMax] || 9;
+    const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
     return (0, index_js_1.validator)('isDateString', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
-        if (typeof input === 'string') {
-            const m = DATE_PATTERN.exec(input);
-            if (m) {
-                const d = (0, date_fns_1.parseISO)(input);
-                if (d && !isNaN(d.getTime())) {
-                    if (!precision ||
-                        precision === 'year' ||
-                        (precision === 'month' && m[2]) ||
-                        (precision === 'date' && m[2] && m[3]) ||
-                        (precision === 'time' && m[2] && m[3] && m[4])) {
-                        if (!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 === 'date' || !m[4])
-                            return s;
-                        s += 'T' + m[4].substring(0, 8);
-                        if (trim === 'time')
-                            return s;
-                        if (m[9])
-                            s += m[9];
-                        return s;
-                    }
-                }
+        const coerce = options?.coerce ?? context.coerce;
+        const parsed = coerceDateString(input, options?.trim);
+        if (parsed) {
+            if (parsed.precision >= precisionMinIdx &&
+                parsed.precision <= precisionMaxIdx) {
+                return coerce ? parsed.value : input;
             }
         }
-        else if (input instanceof Date) {
-            return trim === 'date'
-                ? (0, date_fns_1.formatISO)(input, { representation: 'date' })
-                : (0, date_fns_1.formatISO)(input).substring(0, 19);
-        }
-        context.fail(_this, `Value must be a valid date string`, input, {
+        context.fail(_this, `Value is not valid date string` +
+            (options?.precisionMin || options?.precisionMax
+                ? ` with required precision`
+                : ''), input, {
             ...options,
         });
     }, options);
 }
+// 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)?)?$/;
+function coerceDateString(input, precision) {
+    let dateParts;
+    let outPrecision = 0;
+    if (input instanceof Date || typeof input === 'number') {
+        const d = typeof input === 'number' ? new Date(input) : input;
+        dateParts = [
+            padString(d.getFullYear(), 4),
+            padString(d.getMonth() + 1, 2),
+            padString(d.getDate(), 2),
+            padString(d.getHours(), 2),
+            padString(d.getMinutes(), 2),
+            padString(d.getSeconds(), 2),
+            String(d.getMilliseconds()),
+        ];
+    }
+    else if (typeof input === 'string') {
+        const d = datefns.parseISO(input);
+        const m = DATE_PATTERN.exec(input);
+        if (m && datefns.isValid(d)) {
+            m.shift();
+            dateParts = m;
+        }
+    }
+    if (!dateParts)
+        return;
+    outPrecision = dateParts.findIndex(v => !v);
+    if (outPrecision === -1)
+        outPrecision = dateParts.length + 1;
+    const precisionIndex = (precision ? PRECISION_INDEX[precision] : 9) || 9;
+    let value = dateParts[0] || '0000';
+    if (precisionIndex > 1)
+        value += '-' + (dateParts[1] || '01');
+    if (precisionIndex > 2)
+        value += '-' + (dateParts[2] || '01');
+    if (precisionIndex > 3)
+        value += 'T' + (dateParts[3] || '00');
+    if (precisionIndex > 4)
+        value += ':' + (dateParts[4] || '00');
+    if (precisionIndex > 5)
+        value += ':' + (dateParts[5] || '00');
+    if (precisionIndex > 6)
+        value += dateParts[6] ? '.' + dateParts[6] : '';
+    if (precisionIndex > 7)
+        value += dateParts[7] || '';
+    return {
+        value,
+        precision: outPrecision || 8,
+    };
+}
+const PRECISION_INDEX = {
+    year: 1,
+    yr: 1,
+    month: 2,
+    mo: 2,
+    day: 3,
+    d: 4,
+    hours: 4,
+    hr: 4,
+    minutes: 5,
+    min: 5,
+    seconds: 6,
+    sec: 6,
+    milliseconds: 7,
+    ms: 7,
+    tz: 8,
+};
+/**
+ * Pads a string to the specified length
+ * @param value - The string to pad
+ * @param len - The desired total length of the resulting string
+ * @param padChar - The character to pad with (defaults to '0')
+ * @returns The padded string
+ */
+function padString(value, len, padChar = '0') {
+    // Convert value to string if it's a number
+    const str = String(value);
+    // Return original string if it's already longer or equal to target length
+    if (str.length >= len) {
+        return str;
+    }
+    // Create padding and concatenate with original string
+    const padding = padChar.repeat(len - str.length);
+    return padding + str;
+}
+function setPrecision(d, precision) {
+    switch (precision) {
+        case 'year': {
+            d.setMonth(0, 1);
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'month': {
+            d.setDate(1);
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'day': {
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'hours': {
+            d.setMinutes(0, 0, 0);
+            break;
+        }
+        case 'minutes': {
+            d.setSeconds(0, 0);
+            break;
+        }
+        case 'seconds': {
+            d.setMilliseconds(0);
+            break;
+        }
+    }
+}

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

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

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

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

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

@@ -41,7 +41,7 @@ function isObject(schema, options) {
         if (ctor && ctor[constants_js_1.preValidation]) {
             output = ctor[constants_js_1.preValidation](output, context, _this);
         }
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         if (typeof output === 'string' && coerce)
             output = JSON.parse(output);
         if (!(output && typeof output === 'object')) {

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

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

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

@@ -4,7 +4,7 @@ exports.isTuple = isTuple;
 const index_js_1 = require("../../core/index.js");
 function isTuple(items, options) {
     return (0, index_js_1.validator)('isTuple', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
             output = [output];

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

@@ -8,7 +8,7 @@ const index_js_1 = require("../../core/index.js");
  */
 function isUndefined(options) {
     return (0, index_js_1.validator)('isUndefined', (input, context, _this) => {
-        if (options?.coerce || context.coerce)
+        if (options?.coerce ?? context.coerce)
             return undefined;
         if (input === undefined)
             return;

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

@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
  */
 export function isArray(itemValidator, options) {
     return validator('isArray', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         let output = input;
         if (output != null && coerce && !Array.isArray(output))
             output = [output];

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

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

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

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

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

@@ -1,94 +1,176 @@
-import { formatISO, parseISO } from 'date-fns';
+import * as datefns from 'date-fns';
 import { validator, } from '../../core/index.js';
-// 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 an instance of "Date".
- * Converts input value to Date if a coerce option is set to 'true'.
+ * Validates if value is a "Date" instance or ISO 8601 formatted date string.
+ *  if a `coerce` option is `true`, converts input value to Date instance
  * @validator isDate
  */
 export function isDate(options) {
-    const precision = options?.precision;
+    const trim = options?.trim;
     return validator('isDate', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         let d;
         if (input instanceof Date)
             d = input;
-        else if (input != null && coerce) {
-            if (typeof input === 'string' && coerce) {
-                d = parseISO(input);
-            }
-            else if (typeof input === 'number')
+        else if (coerce) {
+            if (typeof input === 'number')
                 d = new Date(input);
-        }
-        if (d && !isNaN(d.getTime())) {
-            if (precision === 'year') {
-                d.setHours(0, 0, 0, 0);
-                d.setMonth(0, 1);
-            }
-            if (precision === 'month') {
-                d.setHours(0, 0, 0, 0);
-                d.setDate(1);
+            else if (typeof input === 'string') {
+                const parsed = coerceDateString(input);
+                if (parsed) {
+                    d = new Date(parsed.value);
+                }
             }
-            if (precision === 'date')
-                d.setHours(0, 0, 0, 0);
+        }
+        if (datefns.isValid(d)) {
+            setPrecision(d, trim);
             return d;
         }
-        context.fail(_this, `Value must be a valid date`, input, {
+        context.fail(_this, `Value is not valid date`, input, {
             ...options,
         });
     }, options);
 }
 /**
  * Validates if value is DFS (date formatted string).
- * Converts input value to DFS if coerce option is set to 'true'.
+ * Converts input value to DFS if the "coerce" option is set to 'true'.
  * @validator isDateString
  */
 export function isDateString(options) {
-    const precision = options?.precision;
-    const trim = options?.trim;
+    const precisionMin = options?.precisionMin || 'minutes';
+    const precisionMax = options?.precisionMax || 'tz';
+    const precisionMaxIdx = PRECISION_INDEX[precisionMax] || 9;
+    const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
     return validator('isDateString', (input, context, _this) => {
-        const coerce = options?.coerce || context.coerce;
-        if (typeof input === 'string') {
-            const m = DATE_PATTERN.exec(input);
-            if (m) {
-                const d = parseISO(input);
-                if (d && !isNaN(d.getTime())) {
-                    if (!precision ||
-                        precision === 'year' ||
-                        (precision === 'month' && m[2]) ||
-                        (precision === 'date' && m[2] && m[3]) ||
-                        (precision === 'time' && m[2] && m[3] && m[4])) {
-                        if (!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 === 'date' || !m[4])
-                            return s;
-                        s += 'T' + m[4].substring(0, 8);
-                        if (trim === 'time')
-                            return s;
-                        if (m[9])
-                            s += m[9];
-                        return s;
-                    }
-                }
+        const coerce = options?.coerce ?? context.coerce;
+        const parsed = coerceDateString(input, options?.trim);
+        if (parsed) {
+            if (parsed.precision >= precisionMinIdx &&
+                parsed.precision <= precisionMaxIdx) {
+                return coerce ? parsed.value : input;
             }
         }
-        else if (input instanceof Date) {
-            return trim === 'date'
-                ? formatISO(input, { representation: 'date' })
-                : formatISO(input).substring(0, 19);
-        }
-        context.fail(_this, `Value must be a valid date string`, input, {
+        context.fail(_this, `Value is not valid date string` +
+            (options?.precisionMin || options?.precisionMax
+                ? ` with required precision`
+                : ''), input, {
             ...options,
         });
     }, options);
 }
+// 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)?)?$/;
+function coerceDateString(input, precision) {
+    let dateParts;
+    let outPrecision = 0;
+    if (input instanceof Date || typeof input === 'number') {
+        const d = typeof input === 'number' ? new Date(input) : input;
+        dateParts = [
+            padString(d.getFullYear(), 4),
+            padString(d.getMonth() + 1, 2),
+            padString(d.getDate(), 2),
+            padString(d.getHours(), 2),
+            padString(d.getMinutes(), 2),
+            padString(d.getSeconds(), 2),
+            String(d.getMilliseconds()),
+        ];
+    }
+    else if (typeof input === 'string') {
+        const d = datefns.parseISO(input);
+        const m = DATE_PATTERN.exec(input);
+        if (m && datefns.isValid(d)) {
+            m.shift();
+            dateParts = m;
+        }
+    }
+    if (!dateParts)
+        return;
+    outPrecision = dateParts.findIndex(v => !v);
+    if (outPrecision === -1)
+        outPrecision = dateParts.length + 1;
+    const precisionIndex = (precision ? PRECISION_INDEX[precision] : 9) || 9;
+    let value = dateParts[0] || '0000';
+    if (precisionIndex > 1)
+        value += '-' + (dateParts[1] || '01');
+    if (precisionIndex > 2)
+        value += '-' + (dateParts[2] || '01');
+    if (precisionIndex > 3)
+        value += 'T' + (dateParts[3] || '00');
+    if (precisionIndex > 4)
+        value += ':' + (dateParts[4] || '00');
+    if (precisionIndex > 5)
+        value += ':' + (dateParts[5] || '00');
+    if (precisionIndex > 6)
+        value += dateParts[6] ? '.' + dateParts[6] : '';
+    if (precisionIndex > 7)
+        value += dateParts[7] || '';
+    return {
+        value,
+        precision: outPrecision || 8,
+    };
+}
+const PRECISION_INDEX = {
+    year: 1,
+    yr: 1,
+    month: 2,
+    mo: 2,
+    day: 3,
+    d: 4,
+    hours: 4,
+    hr: 4,
+    minutes: 5,
+    min: 5,
+    seconds: 6,
+    sec: 6,
+    milliseconds: 7,
+    ms: 7,
+    tz: 8,
+};
+/**
+ * Pads a string to the specified length
+ * @param value - The string to pad
+ * @param len - The desired total length of the resulting string
+ * @param padChar - The character to pad with (defaults to '0')
+ * @returns The padded string
+ */
+function padString(value, len, padChar = '0') {
+    // Convert value to string if it's a number
+    const str = String(value);
+    // Return original string if it's already longer or equal to target length
+    if (str.length >= len) {
+        return str;
+    }
+    // Create padding and concatenate with original string
+    const padding = padChar.repeat(len - str.length);
+    return padding + str;
+}
+function setPrecision(d, precision) {
+    switch (precision) {
+        case 'year': {
+            d.setMonth(0, 1);
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'month': {
+            d.setDate(1);
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'day': {
+            d.setHours(0, 0, 0, 0);
+            break;
+        }
+        case 'hours': {
+            d.setMinutes(0, 0, 0);
+            break;
+        }
+        case 'minutes': {
+            d.setSeconds(0, 0);
+            break;
+        }
+        case 'seconds': {
+            d.setMilliseconds(0);
+            break;
+        }
+    }
+}

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

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

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

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

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

@@ -38,7 +38,7 @@ export function isObject(schema, options) {
         if (ctor && ctor[preValidation]) {
             output = ctor[preValidation](output, context, _this);
         }
-        const coerce = options?.coerce || context.coerce;
+        const coerce = options?.coerce ?? context.coerce;
         if (typeof output === 'string' && coerce)
             output = JSON.parse(output);
         if (!(output && typeof output === 'object')) {

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

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

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

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

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

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

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.15.4",
+  "version": "5.17.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
     "@browsery/validator": "^13.12.0-r3",
+    "@js-temporal/polyfill": "^0.5.1",
     "date-fns": "^4.1.0",
     "reflect-metadata": "^0.2.2",
     "ts-gems": "^3.11.3",

package/types/rules/type-rules/is-date.d.ts

@@ -1,22 +1,23 @@
 import { type ValidationOptions } from '../../core/index.js';
+type Precision = 'year' | 'yr' | 'month' | 'mo' | 'day' | 'd' | 'hours' | 'hr' | 'minutes' | 'min' | 'seconds' | 'sec' | 'milliseconds' | 'ms' | 'tz';
+export interface IsDateOptions extends ValidationOptions {
+    trim?: Precision;
+}
 /**
- * Validates if value is an instance of "Date".
- * Converts input value to Date if a coerce option is set to 'true'.
+ * Validates if value is a "Date" instance or ISO 8601 formatted date string.
+ *  if a `coerce` option is `true`, converts input value to Date instance
  * @validator isDate
  */
-export declare function isDate(options?: isDate.Options): import("../../core/validator.js").Validator<Date, string | number | Date, import("../../core/types.js").ExecutionOptions>;
+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 {
-    precision?: 'year' | 'month' | 'date' | 'time';
-    trim?: 'date' | 'time';
+    precisionMin?: Precision;
+    precisionMax?: Precision;
+    trim?: Precision;
 }
 /**
  * Validates if value is DFS (date formatted string).
- * Converts input value to DFS if coerce option is set to 'true'.
+ * Converts input value to DFS if the "coerce" option is set to 'true'.
  * @validator isDateString
  */
 export declare function isDateString(options?: IsDateStringOptions): import("../../core/validator.js").Validator<string, string | number | Date, import("../../core/types.js").ExecutionOptions>;
-export declare namespace isDate {
-    interface Options extends ValidationOptions {
-        precision?: 'year' | 'month' | 'date' | 'time';
-    }
-}
+export {};