quantique-field-validator 1.0.2-Beta → 1.0.2

package/Messages/defaultErrorMessages.js

@@ -12,6 +12,8 @@ const defaultErrorMessages = (rules, type) => {
     noValidation: `No validation exist for ${type}`,
     custom: "Validation failed",
     Alphanumeric: "value must be alphanumecric",
+    chassisNumber: "valid chassis number",
+    engineNumber: "valid engine number",
     customValidation:
       rules.errorMessages?.customValidation || "Custom validation failed",
   };

package/Validators/ValidateChassisNumber.js

@@ -0,0 +1,36 @@
+// ChassisNumber  validation
+const validateChassisNumber = (value, rules, defaultErrorMessages, type) => {
+  if (rules?.minLength && value?.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value?.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  const defaultRegex = /^[A-HJ-NPR-Z0-9]{17}$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        defaultErrorMessages(rules, type).chassisNumber ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateChassisNumber;

package/Validators/validateAadhaar.js

@@ -1,24 +1,13 @@
-const validateAadhaar = (
-  value,
-  rules,
-  defaultErrorMessages,
-  type
-
-) => {
+const validateAadhaar = (value, rules, defaultErrorMessages, type) => {
   const defaultRules = {
-    regex: /^[2-9]{1}[0-9]{11}$/, 
+    regex: /^[2-9]{1}[0-9]{11}$/,
   };
   const effectiveRules = {
     ...defaultRules,
     ...rules,
   };
 
-  
-
-  if (
-    effectiveRules?.regex &&
-    !new RegExp(effectiveRules?.regex).test(value)
-  ) {
+  if (effectiveRules?.regex && !new RegExp(effectiveRules?.regex).test(value)) {
     return {
       isValid: false,
       error:

package/Validators/validateDate.js

@@ -1,4 +1,18 @@
 // Date validation
+
+// {
+//   minAge: 18,
+//   maxAge: 65,
+//   minPlus: 2,
+//   maxPlus: 30,
+//   minMinus: 5,
+//   maxMinus: 365,
+//   unit: "month", // or "day" or "year"
+//   errorMessages: {
+//     minPlus: "Date must be at least 2 months ahead!",
+//   }
+// }
+
 const validateDate = (
   value,
   rules = { format: "DD/MM/YYYY" },
@@ -26,6 +40,27 @@ const validateDate = (
     return new Date(year, month, day);
   };
 
+  const applyOffset = (baseDate, value, unit, operation = "add") => {
+    const date = new Date(baseDate);
+    const multiplier = operation === "subtract" ? -1 : 1;
+
+    switch (unit) {
+      case "month":
+      case "months":
+        date.setMonth(date.getMonth() + value * multiplier);
+        break;
+      case "year":
+      case "years":
+        date.setFullYear(date.getFullYear() + value * multiplier);
+        break;
+      default:
+        date.setDate(date.getDate() + value * multiplier);
+        break;
+    }
+
+    return date;
+  };
+
   const parsedDate = parseDateByFormat(value, rules?.format);
   const today = new Date();
   today.setHours(0, 0, 0, 0); // Normalize for accurate comparisons
@@ -40,11 +75,11 @@ const validateDate = (
     };
   }
 
-  // Age check (e.g., user must be 18+)
+  // Age check (minAge)
   if (rules?.minAge) {
-    const ageDate = new Date();
-    ageDate.setFullYear(ageDate.getFullYear() - rules.minAge);
-    if (parsedDate > ageDate) {
+    const minAgeDate = new Date();
+    minAgeDate.setFullYear(minAgeDate.getFullYear() - rules.minAge);
+    if (parsedDate > minAgeDate) {
       return {
         isValid: false,
         error:
@@ -55,59 +90,72 @@ const validateDate = (
     }
   }
 
-  // Relative date checks
+  // Age check (maxAge)
+  if (rules?.maxAge) {
+    const maxAgeDate = new Date();
+    maxAgeDate.setFullYear(maxAgeDate.getFullYear() - rules.maxAge);
+    if (parsedDate < maxAgeDate) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.maxAge ||
+          defaultErrorMessages(rules, type)?.maxAge ||
+          `You must be at most ${rules.maxAge} years old`,
+      };
+    }
+  }
+
+  // Handle relative rules with units (default to "day")
+  const unit = rules?.unit || "day";
+
   if (rules?.minMinus) {
-    const minPast = new Date(today);
-    minPast.setDate(minPast.getDate() - rules.minMinus);
+    const minPast = applyOffset(today, rules.minMinus, unit, "subtract");
     if (parsedDate < minPast) {
       return {
         isValid: false,
         error:
           rules?.errorMessages?.minMinus ||
           defaultErrorMessages(rules, type)?.minMinus ||
-          `Date should not be earlier than ${rules.minMinus} days ago`,
+          `Date should not be earlier than ${rules.minMinus} ${unit}(s) ago`,
       };
     }
   }
 
   if (rules?.maxPlus) {
-    const maxFuture = new Date(today);
-    maxFuture.setDate(maxFuture.getDate() + rules.maxPlus);
+    const maxFuture = applyOffset(today, rules.maxPlus, unit, "add");
     if (parsedDate > maxFuture) {
       return {
         isValid: false,
         error:
           rules?.errorMessages?.maxPlus ||
           defaultErrorMessages(rules, type)?.maxPlus ||
-          `Date should not be more than ${rules.maxPlus} days in the future`,
+          `Date should not be more than ${rules.maxPlus} ${unit}(s) in the future`,
       };
     }
   }
 
   if (rules?.minPlus) {
-    const minFuture = new Date(today);
-    minFuture.setDate(minFuture.getDate() + rules.minPlus);
+    const minFuture = applyOffset(today, rules.minPlus, unit, "add");
     if (parsedDate < minFuture) {
       return {
         isValid: false,
         error:
           rules?.errorMessages?.minPlus ||
           defaultErrorMessages(rules, type)?.minPlus ||
-          `Date should be at least ${rules.minPlus} days in the future`,
+          `Date should be at least ${rules.minPlus} ${unit}(s) in the future`,
       };
     }
   }
 
   if (rules?.maxMinus) {
-    const maxPast = new Date(today);
-    maxPast.setDate(maxPast.getDate() - rules.maxMinus);
+    const maxPast = applyOffset(today, rules.maxMinus, unit, "subtract");
     if (parsedDate > maxPast) {
       return {
         isValid: false,
         error:
           rules?.errorMessages?.maxMinus ||
           defaultErrorMessages(rules, type)?.maxMinus ||
-          `Date should not be later than ${rules.maxMinus} days ago`,
+          `Date should not be later than ${rules.maxMinus} ${unit}(s) ago`,
       };
     }
   }

package/Validators/validateEmail.js

@@ -20,7 +20,8 @@ const validateEmail = (value, rules, defaultErrorMessages, type) => {
   }
 
   // Check against custom regex if provided
-  const defaultRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  const defaultRegex =
+    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}))$/;
   const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
 
   if (!regexToUse.test(value)) {

package/Validators/validateEngineNumber .js

@@ -0,0 +1,36 @@
+// ChassisNumber  validation
+const validateEngineNumber = (value, rules, defaultErrorMessages, type) => {
+  if (rules?.minLength && value?.length < rules?.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value?.length > rules?.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  const defaultRegex = /^[A-Za-z0-9.]{5,25}$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        defaultErrorMessages(rules, type).engineNumber ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateEngineNumber;

package/Validators/validateFloatNumber.js

@@ -0,0 +1,108 @@
+// Float Number Validation with Precision Check
+
+// const rules = {
+//     decimalPrecision: 2,      // allow only 2 digits after decimal
+//     maxWholeDigits: 6,        // allow up to 6 digits before decimal
+//     minValue: 0.01,
+//     maxValue: 999999.99,
+//   };
+
+const validateFloatNumber = (value, rules, defaultErrorMessages, type) => {
+  // Reject if value contains spaces
+  if (/\s/.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).noSpace ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  // Default float regex (supports optional decimal)
+  const defaultFloatRegex = /^\d+(\.\d+)?$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultFloatRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid ||
+        "Please enter a valid amount (e.g., 123.45)",
+    };
+  }
+
+  const numberValue = Number(value);
+
+  // Decimal precision validation
+  if (rules?.decimalPrecision !== undefined) {
+    const decimalPart = value.split(".")[1];
+    const actualPrecision = decimalPart ? decimalPart.length : 0;
+    if (actualPrecision > rules.decimalPrecision) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.decimalPrecision ||
+          `Only up to ${rules.decimalPrecision} digits allowed after decimal.`,
+      };
+    }
+  }
+
+  // Whole number digit validation
+  if (rules?.maxWholeDigits !== undefined) {
+    const wholePart = value.split(".")[0];
+    if (wholePart.length > rules.maxWholeDigits) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.maxWholeDigits ||
+          `Only up to ${rules.maxWholeDigits} digits allowed before decimal.`,
+      };
+    }
+  }
+
+  // Length checks (on the full string)
+  if (rules?.minLength && value.length < rules.minLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minLength ||
+        defaultErrorMessages(rules, type).minLength,
+    };
+  }
+
+  if (rules?.maxLength && value.length > rules.maxLength) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxLength ||
+        defaultErrorMessages(rules, type).maxLength,
+    };
+  }
+
+  // Value range checks
+  if (rules?.minValue !== undefined && numberValue < rules.minValue) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.minValue ||
+        defaultErrorMessages(rules, type).minValue ||
+        `Amount must be at least ${rules.minValue}`,
+    };
+  }
+
+  if (rules?.maxValue !== undefined && numberValue > rules.maxValue) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxValue ||
+        defaultErrorMessages(rules, type).maxValue ||
+        `Amount must not exceed ${rules.maxValue}`,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateFloatNumber;

package/Validators/validateNumber.js

@@ -11,8 +11,8 @@ const validateNumber = (value, rules, defaultErrorMessages, type) => {
     };
   }
 
-  // Default numeric regex (supports optional decimal and negative)
-  const defaultNumberRegex = /^-?\d+(\.\d+)?$/;
+  // Whole number only regex
+  const defaultNumberRegex = /^\d+$/;
   const regexToUse = rules?.regex
     ? new RegExp(rules.regex)
     : defaultNumberRegex;
@@ -23,7 +23,7 @@ const validateNumber = (value, rules, defaultErrorMessages, type) => {
       error:
         rules?.errorMessages?.invalid ||
         defaultErrorMessages(rules, type).invalid ||
-        "Please enter a valid number",
+        "Please enter a valid whole number",
     };
   }
 

package/index.js

@@ -11,6 +11,7 @@ const defaultErrorMessages = require("./Messages/defaultErrorMessages");
 const validateString = require("./Validators/validateString");
 const validateAlphanumeric = require("./Validators/validateAlphanumeric");
 const validateNumber = require("./Validators/validateNumber");
+const validateFloatNumber = require("./Validators/validateFloatNumber");
 const validateDate = require("./Validators/validateDate");
 const validateName = require("./Validators/validateName");
 const validateEmail = require("./Validators/validateEmail");
@@ -20,15 +21,16 @@ const validatePassword = require("./Validators/validatePassword");
 const validateCustom = require("./Validators/validateCustom");
 const validateAadhaar = require("./Validators/validateAadhaar");
 const validatePanCard = require("./Validators/validatePanCard");
+const validateChassisNumber = require("./Validators/ValidateChassisNumber");
 
 const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
   // Trim the value if it's a string
-  // const trimmedValue = typeof value === "string" ? value.trim() : value;
+  // const selectedValue = typeof value === "string" ? value.trim() : value;
 
-  const trimmedValue = value;
+  const selectedValue = value;
 
   // Check if field is required and empty
-  if (rules.required && (!trimmedValue || trimmedValue === "")) {
+  if (rules.required && (!selectedValue || selectedValue === "")) {
     return {
       isValid: false,
       error:
@@ -38,13 +40,13 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
   }
 
   // Skip further validation if the field is empty and not required
-  if (!rules.required && (!trimmedValue || trimmedValue === "")) {
+  if (!rules.required && (!selectedValue || selectedValue === "")) {
     return { isValid: true, error: "" };
   }
 
   // First run custom validator if provided (highest priority)
   if (customValidator && typeof customValidator === "function") {
-    const customValidation = customValidator(trimmedValue);
+    const customValidation = customValidator(selectedValue);
 
     if (
       typeof customValidation === "object" &&
@@ -67,7 +69,7 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
 
   // Then run any custom validator in rules
   if (rules.customValidator && typeof rules.customValidator === "function") {
-    const rulesCustomValidation = rules.customValidator(trimmedValue);
+    const rulesCustomValidation = rules.customValidator(selectedValue);
 
     if (
       typeof rulesCustomValidation === "object" &&
@@ -90,35 +92,49 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
   // Then validate based on type
   switch (type) {
     case "string":
-      return validateString(trimmedValue, rules, defaultErrorMessages, type);
+      return validateString(selectedValue, rules, defaultErrorMessages, type);
     case "alphanumeric":
       return validateAlphanumeric(
-        trimmedValue,
+        selectedValue,
         rules,
         defaultErrorMessages,
         type
       );
     case "number":
-      return validateNumber(trimmedValue, rules, defaultErrorMessages, type);
+      return validateNumber(selectedValue, rules, defaultErrorMessages, type);
+    case "float":
+      return validateFloatNumber(
+        selectedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
     case "date":
-      return validateDate(trimmedValue, rules, defaultErrorMessages, type);
+      return validateDate(selectedValue, rules, defaultErrorMessages, type);
     case "name":
       return validateName(trimmedValue, rules, defaultErrorMessages, type);
-    case "aadhaar":
-      return validateAadhaar(trimmedValue, rules, defaultErrorMessages, type);
-    case "pan":
-      return validatePanCard(trimmedValue, rules, defaultErrorMessages, type);
-
     case "email":
-      return validateEmail(trimmedValue, rules, defaultErrorMessages, type);
+      return validateEmail(selectedValue, rules, defaultErrorMessages, type);
     case "mobile":
-      return validateMobile(trimmedValue, rules, defaultErrorMessages, type);
+      return validateMobile(selectedValue, rules, defaultErrorMessages, type);
     case "address":
-      return validateAddress(trimmedValue, rules, defaultErrorMessages, type);
+      return validateAddress(selectedValue, rules, defaultErrorMessages, type);
     case "password":
       return validatePassword(trimmedValue, rules, defaultErrorMessages, type);
+    case "chassis":
+      return validateChassisNumber(
+        trimmedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
+      return validatePassword(selectedValue, rules, defaultErrorMessages, type);
+    case "aadhaar":
+      return validateAadhaar(selectedValue, rules, defaultErrorMessages, type);
+    case "pan":
+      return validatePanCard(selectedValue, rules, defaultErrorMessages, type);
     case "custom":
-      return validateCustom(trimmedValue, rules, defaultErrorMessages, type);
+      return validateCustom(selectedValue, rules, defaultErrorMessages, type);
     default:
       return {
         isValid: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quantique-field-validator",
-  "version": "1.0.2Beta",
+  "version": "1.0.2",
   "description": "Validator to verify all form fields.",
   "main": "index.js",
   "scripts": {