quantique-field-validator 1.0.0 → 1.0.2-Beta

package/Messages/defaultErrorMessages.js

@@ -0,0 +1,20 @@
+// Default error messages
+const defaultErrorMessages = (rules, type) => {
+  return {
+    noSpace: "Value should not contain spaces",
+    minAge: `User must be  ${rules.minAge} years or older`,
+    minMinus: "Date is too far in the past",
+    maxPlus: "Date is too far in the future",
+    required: "This field is required",
+    minLength: `Minimum length should be ${rules.minLength}`,
+    maxLength: `Maximum length should be ${rules.maxLength}`,
+    invalid: `Invalid ${type}`,
+    noValidation: `No validation exist for ${type}`,
+    custom: "Validation failed",
+    Alphanumeric: "value must be alphanumecric",
+    customValidation:
+      rules.errorMessages?.customValidation || "Custom validation failed",
+  };
+};
+
+module.exports = defaultErrorMessages;

package/Validators/validateAadhaar.js

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

package/Validators/validateAddress.js

@@ -0,0 +1,38 @@
+// Address validation
+const validateAddress = (value, rules, defaultErrorMessages, type) => {
+  // Check length constraints
+  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,
+    };
+  }
+
+  // Check against custom regex if provided
+  const defaultRegex = /^[a-zA-Z0-9\s,./\-#&:]+$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateAddress;

package/Validators/validateAlphanumeric.js

@@ -0,0 +1,47 @@
+// Alphanumeric validation
+const validateAlphanumeric = (value, rules, defaultErrorMessages, type) => {
+  // Check length constraints if value is a string
+  if (typeof value !== "string") {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).Alphanumeric,
+    };
+  }
+  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,
+    };
+  }
+
+  // Check against custom regex if provided
+  const defaultRegex = /^[a-z0-9]+$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).Alphanumeric ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateAlphanumeric;

package/Validators/validateCustom.js

@@ -0,0 +1,18 @@
+// Custom validation
+const validateCustom = (value, rules, defaultErrorMessages, type) => {
+  // Check against custom regex if provided
+  const regexToUse = new RegExp(rules.regex);
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateCustom;

package/Validators/validateDate.js

@@ -0,0 +1,118 @@
+// Date validation
+const validateDate = (
+  value,
+  rules = { format: "DD/MM/YYYY" },
+  defaultErrorMessages,
+  type
+) => {
+  const parseDateByFormat = (value, format) => {
+    if (!format) return new Date(value); // fallback to default
+
+    const separator = format.includes("/") ? "/" : "-";
+    const parts = value.split(separator);
+    const formatParts = format.split(separator);
+
+    if (parts.length !== 3 || formatParts.length !== 3) return new Date(NaN);
+
+    const dateParts = {};
+    formatParts.forEach((part, index) => {
+      dateParts[part] = parseInt(parts[index], 10);
+    });
+
+    const day = dateParts["DD"];
+    const month = (dateParts["MM"] || 1) - 1; // Month is 0-indexed
+    const year = dateParts["YYYY"];
+
+    return new Date(year, month, day);
+  };
+
+  const parsedDate = parseDateByFormat(value, rules?.format);
+  const today = new Date();
+  today.setHours(0, 0, 0, 0); // Normalize for accurate comparisons
+
+  if (isNaN(parsedDate.getTime())) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type)?.invalid ||
+        "Invalid date format",
+    };
+  }
+
+  // Age check (e.g., user must be 18+)
+  if (rules?.minAge) {
+    const ageDate = new Date();
+    ageDate.setFullYear(ageDate.getFullYear() - rules.minAge);
+    if (parsedDate > ageDate) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.minAge ||
+          defaultErrorMessages(rules, type)?.minAge ||
+          `You must be at least ${rules.minAge} years old`,
+      };
+    }
+  }
+
+  // Relative date checks
+  if (rules?.minMinus) {
+    const minPast = new Date(today);
+    minPast.setDate(minPast.getDate() - rules.minMinus);
+    if (parsedDate < minPast) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.minMinus ||
+          defaultErrorMessages(rules, type)?.minMinus ||
+          `Date should not be earlier than ${rules.minMinus} days ago`,
+      };
+    }
+  }
+
+  if (rules?.maxPlus) {
+    const maxFuture = new Date(today);
+    maxFuture.setDate(maxFuture.getDate() + rules.maxPlus);
+    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`,
+      };
+    }
+  }
+
+  if (rules?.minPlus) {
+    const minFuture = new Date(today);
+    minFuture.setDate(minFuture.getDate() + rules.minPlus);
+    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`,
+      };
+    }
+  }
+
+  if (rules?.maxMinus) {
+    const maxPast = new Date(today);
+    maxPast.setDate(maxPast.getDate() - rules.maxMinus);
+    if (parsedDate > maxPast) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.maxMinus ||
+          defaultErrorMessages(rules, type)?.maxMinus ||
+          `Date should not be later than ${rules.maxMinus} days ago`,
+      };
+    }
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateDate;

package/Validators/validateEmail.js

@@ -0,0 +1,38 @@
+// Email validation
+const validateEmail = (value, rules, defaultErrorMessages, type) => {
+  // Check length constraints
+  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,
+    };
+  }
+
+  // Check against custom regex if provided
+  const defaultRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateEmail;

package/Validators/validateMobile.js

@@ -0,0 +1,116 @@
+// Mobile validation
+const validateMobile = (value, rules, defaultErrorMessages, type) => {
+  // Default regex for Indian mobile number: starts with 6-9 and followed by 9 digits (total 10)
+  const defaultRegex = /^[6-9]\d{9}$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+// const validateMobile = (value, rules, defaultErrorMessages, type) => {
+//   // Check length constraints
+//   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,
+//     };
+//   }
+
+//   // Check against custom regex if provided
+//   if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+//     return {
+//       isValid: false,
+//       error: rules?.errorMessages?.invalid || defaultErrorMessages(rules, type).invalid,
+//     };
+//   }
+
+//   // Default mobile regex (accepts numbers, +, -, and spaces)
+//   const mobileRegex = /^[\d\s+\-()]*$/;
+//   if (!mobileRegex.test(value)) {
+//     return {
+//       isValid: false,
+//       error:
+//         rules?.errorMessages?.invalid || "Please enter a valid mobile number",
+//     };
+//   }
+
+//   return { isValid: true, error: "" };
+// };
+
+// const validateMobile = (value, rules = {}, defaultErrorMessages, type) => {
+//   // Check length constraints
+//   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,
+//     };
+//   }
+
+//   // Custom regex check
+//   if (rules.regex && !new RegExp(rules.regex).test(value)) {
+//     return {
+//       isValid: false,
+//       error:
+//         rules.errorMessages?.invalid ||
+//         defaultErrorMessages(rules, type).invalid,
+//     };
+//   }
+
+//   // Validate using libphonenumber-js
+//   const phoneNumber = parsePhoneNumberFromString(
+//     value,
+//     rules?.countryCode || "IN"
+//   );
+
+//   //   console.log('phoneNumber', phoneNumber)
+//   console.log(
+//     "phoneNumber.isValid()",
+//     phoneNumber.isValid(),
+//     phoneNumber.getType()
+//   );
+
+//   if (
+//     !phoneNumber?.isValid() &&
+//     (phoneNumber?.getType() !== "MOBILE" ||
+//       phoneNumber?.getType() !== "FIXED_LINE_OR_MOBILE")
+//   ) {
+//     return {
+//       isValid: false,
+//       error:
+//         rules.errorMessages?.invalid ||
+//         defaultErrorMessages(rules, type).invalid ||
+//         "Please enter a valid mobile number",
+//     };
+//   }
+
+//   return { isValid: true, error: "" };
+// };
+
+module.exports = validateMobile;

package/Validators/validateName.js

@@ -0,0 +1,59 @@
+// Name validation
+const validateName = (
+  value,
+  rules = { type: "user" },
+  defaultErrorMessages,
+  type
+) => {
+  // Check length constraints
+  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,
+    };
+  }
+
+  // Default name validation (only letters, spaces, and basic punctuation)
+  // Check against custom regex if provided
+  if (rules?.type === "user") {
+    const defaultRegex = /^[a-zA-ZÀ-ÿ\s'-.]*$/;
+    const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+    if (!regexToUse.test(value)) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.invalid || "Name contains invalid characters",
+      };
+    }
+  }
+
+  if (rules?.type === "corporate") {
+    const defaultRegex = /^[A-Za-z0-9&.,'()\- ]*$/;
+    const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+    if (!regexToUse.test(value)) {
+      return {
+        isValid: false,
+        error:
+          rules?.errorMessages?.invalid ||
+          "Corporate Name contains invalid characters",
+      };
+    }
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateName;

package/Validators/validateNumber.js

@@ -0,0 +1,75 @@
+// Number validation
+const validateNumber = (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 numeric regex (supports optional decimal and negative)
+  const defaultNumberRegex = /^-?\d+(\.\d+)?$/;
+  const regexToUse = rules?.regex
+    ? new RegExp(rules.regex)
+    : defaultNumberRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid ||
+        "Please enter a valid number",
+    };
+  }
+
+  const numberValue = Number(value);
+
+  // Length checks (on the 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 ||
+        `Value must be at least ${rules.minValue}`,
+    };
+  }
+
+  if (rules?.maxValue !== undefined && numberValue > rules.maxValue) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.maxValue ||
+        defaultErrorMessages(rules, type).maxValue ||
+        `Value must not exceed ${rules.maxValue}`,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateNumber;

package/Validators/validatePanCard.js

@@ -0,0 +1,34 @@
+const validatePanCard = (
+  value,
+  rules,
+  defaultErrorMessages,
+  type
+) => {
+  const defaultRules = {
+    regex: /^[A-Z]{5}[0-9]{4}[A-Z]{1}$/, 
+  };
+
+  
+  const effectiveRules = {
+    ...defaultRules,
+    ...rules,
+  };
+
+  
+
+  if (
+    effectiveRules?.regex &&
+    !new RegExp(effectiveRules?.regex).test(value)
+  ) {
+    return {
+      isValid: false,
+      error:
+        effectiveRules?.errorMessages?.invalid ||
+        defaultErrorMessages(effectiveRules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validatePanCard;

package/Validators/validatePassword.js

@@ -0,0 +1,38 @@
+// Add password validation
+const validatePassword = (value, rules, defaultErrorMessages, type) => {
+  // Check length constraints
+  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,
+    };
+  }
+
+  // Check against custom regex if provided
+  const defaultRegex = /^(?=.*[A-Za-z])(?=.*\d).+$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        "Password must contain at least one letter and one number",
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validatePassword;

package/Validators/validateString.js

@@ -0,0 +1,41 @@
+// String validation
+const validateString = (value, rules, defaultErrorMessages, type) => {
+  if (typeof value !== "string") {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+  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,
+    };
+  }
+
+  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
+    return {
+      isValid: false,
+      error:
+        rules?.errorMessages?.invalid ||
+        defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: "" };
+};
+
+module.exports = validateString;

package/index.js

@@ -6,26 +6,34 @@
  * @param {function} [customValidator] - Optional custom validation function
  * @returns {object} - Returns { isValid: boolean, error: string }
  */
-const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
-  // Default error messages
-  const defaultErrorMessages = {
-    required: "This field is required",
-    minLength: `Minimum length should be ${rules.minLength}`,
-    maxLength: `Maximum length should be ${rules.maxLength}`,
-    invalid: `Invalid ${type}`,
-    custom: "Validation failed",
-    customValidation:
-      rules.errorMessages?.customValidation || "Custom validation failed",
-  };
 
+const defaultErrorMessages = require("./Messages/defaultErrorMessages");
+const validateString = require("./Validators/validateString");
+const validateAlphanumeric = require("./Validators/validateAlphanumeric");
+const validateNumber = require("./Validators/validateNumber");
+const validateDate = require("./Validators/validateDate");
+const validateName = require("./Validators/validateName");
+const validateEmail = require("./Validators/validateEmail");
+const validateMobile = require("./Validators/validateMobile");
+const validateAddress = require("./Validators/validateAddress");
+const validatePassword = require("./Validators/validatePassword");
+const validateCustom = require("./Validators/validateCustom");
+const validateAadhaar = require("./Validators/validateAadhaar");
+const validatePanCard = require("./Validators/validatePanCard");
+
+const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
   // Trim the value if it's a string
-  const trimmedValue = typeof value === "string" ? value.trim() : value;
+  // const trimmedValue = typeof value === "string" ? value.trim() : value;
+
+  const trimmedValue = value;
 
   // Check if field is required and empty
   if (rules.required && (!trimmedValue || trimmedValue === "")) {
     return {
       isValid: false,
-      error: rules.errorMessages?.required || defaultErrorMessages.required,
+      error:
+        rules.errorMessages?.required ||
+        defaultErrorMessages(rules, type).required,
     };
   }
 
@@ -44,12 +52,14 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
     ) {
       return {
         isValid: false,
-        error: customValidation.error || defaultErrorMessages.customValidation,
+        error:
+          customValidation.error ||
+          defaultErrorMessages(rules, type).customValidation,
       };
     } else if (customValidation === false) {
       return {
         isValid: false,
-        error: defaultErrorMessages.customValidation,
+        error: defaultErrorMessages(rules, type).customValidation,
       };
     }
     // If custom validator returns true or { isValid: true }, continue with other validations
@@ -65,235 +75,55 @@ const dynamicValidator = (value, type, rules = {}, customValidator = null) => {
     ) {
       return {
         isValid: false,
-        error: rulesCustomValidation.error || defaultErrorMessages.custom,
+        error:
+          rulesCustomValidation.error ||
+          defaultErrorMessages(rules, type).custom,
       };
     } else if (rulesCustomValidation === false) {
       return {
         isValid: false,
-        error: defaultErrorMessages.custom,
+        error: defaultErrorMessages(rules, type).custom,
       };
     }
   }
 
   // Then validate based on type
   switch (type) {
+    case "string":
+      return validateString(trimmedValue, rules, defaultErrorMessages, type);
+    case "alphanumeric":
+      return validateAlphanumeric(
+        trimmedValue,
+        rules,
+        defaultErrorMessages,
+        type
+      );
+    case "number":
+      return validateNumber(trimmedValue, rules, defaultErrorMessages, type);
+    case "date":
+      return validateDate(trimmedValue, rules, defaultErrorMessages, type);
     case "name":
-      return validateName(trimmedValue, rules, defaultErrorMessages);
+      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);
+      return validateEmail(trimmedValue, rules, defaultErrorMessages, type);
     case "mobile":
-      return validateMobile(trimmedValue, rules, defaultErrorMessages);
+      return validateMobile(trimmedValue, rules, defaultErrorMessages, type);
     case "address":
-      return validateAddress(trimmedValue, rules, defaultErrorMessages);
+      return validateAddress(trimmedValue, rules, defaultErrorMessages, type);
     case "password":
-      return validatePassword(trimmedValue, rules, defaultErrorMessages);
+      return validatePassword(trimmedValue, rules, defaultErrorMessages, type);
+    case "custom":
+      return validateCustom(trimmedValue, rules, defaultErrorMessages, type);
     default:
-      return validateCustom(trimmedValue, rules, defaultErrorMessages);
-  }
-};
-
-// ... (keep all the existing validateName, validateEmail, etc. functions from previous solution)
-
-// Name validation
-const validateName = (value, rules, defaultErrorMessages) => {
-  // Check length constraints
-  if (rules?.minLength && value?.length < rules?.minLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-    };
-  }
-
-  if (rules?.maxLength && value?.length > rules?.maxLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
-    };
-  }
-
-  // Check against custom regex if provided
-  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  // Default name validation (only letters, spaces, and basic punctuation)
-  const nameRegex = /^[a-zA-ZÀ-ÿ\s'-.]*$/;
-  if (!nameRegex.test(value)) {
-    return {
-      isValid: false,
-      error:
-        rules?.errorMessages?.invalid || "Name contains invalid characters",
-    };
-  }
-
-  return { isValid: true, error: "" };
-};
-
-// Email validation
-const validateEmail = (value, rules, defaultErrorMessages) => {
-  // Check length constraints
-  if (rules?.minLength && value.length < rules?.minLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-    };
-  }
-
-  if (rules?.maxLength && value.length > rules?.maxLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
-    };
-  }
-
-  // Check against custom regex if provided
-  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  // Default email regex
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(value)) {
-    return {
-      isValid: false,
-      error:
-        rules?.errorMessages?.invalid || "Please enter a valid email address",
-    };
-  }
-
-  return { isValid: true, error: "" };
-};
-
-// Mobile validation
-const validateMobile = (value, rules, defaultErrorMessages) => {
-  // Check length constraints
-  if (rules?.minLength && value.length < rules?.minLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-    };
-  }
-
-  if (rules?.maxLength && value.length > rules?.maxLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
-    };
-  }
-
-  // Check against custom regex if provided
-  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  // Default mobile regex (accepts numbers, +, -, and spaces)
-  const mobileRegex = /^[\d\s+\-()]*$/;
-  if (!mobileRegex.test(value)) {
-    return {
-      isValid: false,
-      error:
-        rules?.errorMessages?.invalid || "Please enter a valid mobile number",
-    };
-  }
-
-  return { isValid: true, error: "" };
-};
-
-// Address validation
-const validateAddress = (value, rules, defaultErrorMessages) => {
-  // Check length constraints
-  if (rules?.minLength && value.length < rules?.minLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-    };
-  }
-
-  if (rules?.maxLength && value.length > rules?.maxLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
-    };
-  }
-
-  // Check against custom regex if provided
-  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  return { isValid: true, error: "" };
-};
-
-// Add password validation
-const validatePassword = (value, rules, defaultErrorMessages) => {
-  // Check length constraints
-  if (rules?.minLength && value.length < rules?.minLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-    };
-  }
-
-  if (rules?.maxLength && value.length > rules?.maxLength) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
-    };
-  }
-
-  // Check against custom regex if provided
-  if (rules?.regex && !new RegExp(rules?.regex).test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid || defaultErrorMessages.invalid,
-    };
-  }
-
-  // Default password validation (at least one letter, one number)
-  const passwordRegex = /^(?=.*[A-Za-z])(?=.*\d).+$/;
-  if (!passwordRegex.test(value)) {
-    return {
-      isValid: false,
-      error:
-        rules?.errorMessages?.invalid ||
-        "Password must contain at least one letter and one number",
-    };
-  }
-
-  return { isValid: true, error: "" };
-};
-
-// Custom validation
-const validateCustom = (value, rules, defaultErrorMessages) => {
-  // Check length constraints if value is a string
-  if (typeof value === "string") {
-    if (rules?.minLength && value.length < rules?.minLength) {
       return {
         isValid: false,
-        error:
-          rules?.errorMessages?.minLength || defaultErrorMessages.minLength,
-      };
-    }
-
-    if (rules?.maxLength && value.length > rules?.maxLength) {
-      return {
-        isValid: false,
-        error:
-          rules?.errorMessages?.maxLength || defaultErrorMessages.maxLength,
+        error: defaultErrorMessages(rules, type)?.noValidation,
       };
-    }
   }
 };
 

package/package.json

@@ -1,22 +1,22 @@
-{
-  "name": "quantique-field-validator",
-  "version": "1.0.0",
-  "description": "Validator to verify all form fields.",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/saketsinhaquantique/quantique-field-validator.git"
-  },
-  "keywords": [
-    "QFV"
-  ],
-  "author": "Saket Brij Sinha <saket.sinha@quantique.ai>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/saketsinhaquantique/quantique-field-validator/issues"
-  },
-  "homepage": "https://github.com/saketsinhaquantique/quantique-field-validator#readme"
-}
+{
+  "name": "quantique-field-validator",
+  "version": "1.0.2Beta",
+  "description": "Validator to verify all form fields.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saketsinhaquantique/quantique-field-validator.git"
+  },
+  "keywords": [
+    "QFV"
+  ],
+  "author": "Saket Brij Sinha <saket.sinha@quantique.ai>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/saketsinhaquantique/quantique-field-validator/issues"
+  },
+  "homepage": "https://github.com/saketsinhaquantique/quantique-field-validator#readme"
+}