valgen 5.19.1 → 5.19.3

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '5.19.1';
+export const version = '5.19.3';
 export const postValidation = Symbol('postValidation');
 export const preValidation = Symbol('preValidation');
 export const VALIDATE_METADATA = Symbol('VALIDATE_METADATA');

package/index.d.ts

@@ -3,6 +3,7 @@ import { DatePrecision } from './rules/index.js';
 import * as vg from './rules/index.js';
 export * from './constants.js';
 export * from './core/index.js';
+export type { DatePrecision } from './rules/type-rules/is-date.js';
 export type { IsObject } from './rules/type-rules/is-object.js';
 declare const isAlpha: import("./core/validator.js").Validator<string, string, ExecutionOptions>;
 declare const isAlphanumeric: import("./core/validator.js").Validator<string, string, ExecutionOptions>;

package/index.js

@@ -58,10 +58,14 @@ const toBoolean = vg.isBoolean({ coerce: true });
 const toDate = vg.isDate({ coerce: true });
 const toDateStringValidators = new Map();
 const toDateString = (input, options, ctx) => {
-    const trim = options?.trim ?? 'seconds';
+    const trim = options?.trim ?? 'ms';
     let validator = toDateStringValidators.get(trim);
     if (!validator) {
-        validator = vg.isDateString({ coerce: true, trim });
+        validator = vg.isDateString({
+            coerce: true,
+            precisionMax: trim,
+            trim: true,
+        });
         toDateStringValidators.set(trim, validator);
     }
     return validator(input, options, ctx);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "5.19.1",
+  "version": "5.19.3",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

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

@@ -12,7 +12,7 @@ export declare function isDate(options?: IsDateOptions): import("../../core/vali
 export interface IsDateStringOptions extends ValidationOptions {
     precisionMin?: DatePrecision;
     precisionMax?: DatePrecision;
-    trim?: DatePrecision;
+    trim?: boolean;
     timeZone?: boolean | number;
 }
 /**

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

@@ -37,33 +37,32 @@ export function isDate(options) {
  * @validator isDateString
  */
 export function isDateString(options) {
-    const trimIdx = PRECISION_INDEX[options?.trim || 'tz'] || 9;
-    const precisionMin = options?.precisionMin || options?.trim || 'minutes';
+    const trim = options?.trim;
     const precisionMax = options?.precisionMax || 'tz';
-    const precisionMaxIdx = PRECISION_INDEX[precisionMax] || 9;
-    const precisionMinIdx = Math.min(trimIdx, precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
+    const precisionMaxIdx = PRECISION_INDEX[precisionMax] || 8;
+    let precisionMin = options?.precisionMin || 'minutes';
+    const precisionMinIdx = Math.min(precisionMaxIdx, PRECISION_INDEX[precisionMin] || 6);
+    precisionMin = (PRECISION_INDEX_KEYS[PRECISION_INDEX_VALUES.indexOf(precisionMinIdx)] || precisionMin);
     return validator('isDateString', (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
-        const parsed = coerceDateString(input, options?.trim);
+        const parsed = coerceDateString(input, trim ? precisionMax : undefined);
         if (parsed) {
-            if (parsed.precision >= precisionMinIdx &&
-                parsed.precision <= precisionMaxIdx) {
-                return coerce ? parsed.value : input;
+            if (parsed.precision < precisionMinIdx) {
+                context.fail(_this, `Minimum date precision should be ${precisionMin}`, input, options);
+            }
+            if (parsed.precision > precisionMaxIdx) {
+                context.fail(_this, `Maximum date precision should be ${precisionMax}`, input, options);
             }
+            return coerce ? parsed.value : input;
         }
-        context.fail(_this, `Value is not valid date string` +
-            (options?.precisionMin || options?.precisionMax
-                ? ` with required precision`
-                : ''), input, {
-            ...options,
-        });
+        context.fail(_this, `Value "${input}" is not a valid date string`, 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,6}))?)?((?:[+-](0[0-9]|1[0-2])(?::(\d{2}))?)|Z)?)?$/;
 const DATE_PATTERN2 = /^(\d{4,14})(?:\.(\d{1,6}))?(?:(?:([+-])(0[0-9]|1[0-2])(\d{2})?)|Z)?$/;
-function coerceDateString(input, precision) {
-    const precisionIndex = (precision ? PRECISION_INDEX[precision] : 9) || 9;
+function coerceDateString(input, trimPrecision) {
+    const precisionIndex = (trimPrecision ? PRECISION_INDEX[trimPrecision] : 9) || 9;
     let dateParts;
     let detectedPrecision = 0;
     if (input instanceof Date || typeof input === 'number') {
@@ -114,8 +113,8 @@ function coerceDateString(input, precision) {
     }
     if (!dateParts)
         return;
-    detectedPrecision = dateParts.findIndex(v => !v);
-    if (detectedPrecision === -1)
+    detectedPrecision = dateParts[7] ? 8 : dateParts.findIndex(v => !v);
+    if (detectedPrecision < 0)
         detectedPrecision = Math.min(dateParts.length, 8);
     let value = dateParts[0] || '0000';
     if (precisionIndex > 1)
@@ -134,7 +133,7 @@ function coerceDateString(input, precision) {
         value += dateParts[7] || '';
     return {
         value,
-        precision: detectedPrecision || 8,
+        precision: Math.min(precisionIndex, detectedPrecision),
     };
 }
 const PRECISION_INDEX = {
@@ -154,6 +153,8 @@ const PRECISION_INDEX = {
     ms: 7,
     tz: 8,
 };
+const PRECISION_INDEX_KEYS = Object.keys(PRECISION_INDEX);
+const PRECISION_INDEX_VALUES = Object.values(PRECISION_INDEX);
 function setPrecision(d, precision) {
     switch (precision) {
         case 'year': {