quantique-field-validator 1.0.6 → 1.0.9

package/Validators/validateName.js

@@ -1,67 +1,67 @@
-// Name validation
-const validateName = (
-  value,
-  rules = { type: 'user' },
-  defaultErrorMessages,
-  type
-) => {
-  // First check if value is empty or just whitespace
-  if (!value || !value.trim()) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.empty || 'Name cannot be empty',
-    };
-  }
-
-  // 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À-ÿ])[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])[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;
+// Name validation
+const validateName = (
+  value,
+  rules = { type: 'user' },
+  defaultErrorMessages,
+  type
+) => {
+  // First check if value is empty or just whitespace
+  if (!value || !value.trim()) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.empty || 'Name cannot be empty',
+    };
+  }
+
+  // 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À-ÿ])[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])[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

@@ -1,75 +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,
-    };
-  }
-
-  // Whole number only regex
-  const defaultNumberRegex = /^\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 whole 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;
+// 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,
+    };
+  }
+
+  // Whole number only regex
+  const defaultNumberRegex = /^\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 whole 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

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

package/Validators/validatePassword.js

@@ -1,38 +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;
+// 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/validateRTO.js

@@ -1,41 +1,41 @@
-// RTO validation
-const validateRTO = (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 =
-    rules?.version === 'new'
-      ? /^[A-Z]{2}-[0-9]{1,2}(-[A-Z]{1,2})?$/
-      : rules?.version === 'all'
-      ? /^[A-Z]{2}-?[0-9]{1,2}(-?[A-Z]{1,2})?$/
-      : /^[A-Z]{2}-[0-9]{1,2}$/;
-  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
-  if (!regexToUse.test(value)) {
-    return {
-      isValid: false,
-      error: rules?.errorMessages?.invalid
-        ? rules?.errorMessages?.invalid
-        : defaultErrorMessages(rules, type).rto ||
-          defaultErrorMessages(rules, type).invalid,
-    };
-  }
-
-  return { isValid: true, error: '' };
-};
-
-module.exports = validateRTO;
+// RTO validation
+const validateRTO = (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 =
+    rules?.version === 'new'
+      ? /^[A-Z]{2}-[0-9]{1,2}(-[A-Z]{1,2})?$/
+      : rules?.version === 'all'
+      ? /^[A-Z]{2}-?[0-9]{1,2}(-?[A-Z]{1,2})?$/
+      : /^[A-Z]{2}-[0-9]{1,2}$/;
+  const regexToUse = rules?.regex ? new RegExp(rules.regex) : defaultRegex;
+  if (!regexToUse.test(value)) {
+    return {
+      isValid: false,
+      error: rules?.errorMessages?.invalid
+        ? rules?.errorMessages?.invalid
+        : defaultErrorMessages(rules, type).rto ||
+          defaultErrorMessages(rules, type).invalid,
+    };
+  }
+
+  return { isValid: true, error: '' };
+};
+
+module.exports = validateRTO;

package/Validators/validateString.js

@@ -1,41 +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;
+// 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;