@umituz/react-native-validation 1.4.7 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-validation",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "Comprehensive validation and sanitization utilities for React Native forms",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -23,20 +23,15 @@ export {
   validatePattern,
   validateDateOfBirth,
   validateAge,
-  batchValidate,
 } from "./infrastructure/utils/validators";
 
-// Dream-specific validators
+// Infrastructure Layer - Advanced Validators
 export {
-  validateDreamTitle,
-  validateDreamDescription,
-  validateDreamMood,
-  validateDreamCategory,
-  validateDreamDate,
-  validateDreamTags,
-  validateDreamPrivacy,
-  validateDreamForm,
-} from "./infrastructure/utils/validators";
+  validateEnum,
+  validateTags,
+  validateDateRange,
+  batchValidate,
+} from "./infrastructure/utils/advanced-validators";
 
 // Infrastructure Layer - Sanitization
 export {

package/src/infrastructure/utils/advanced-validators.ts

@@ -0,0 +1,114 @@
+/**
+ * Advanced Validation Utilities
+ * Complex validation functions for React Native forms
+ */
+
+import type { ValidationResult } from "../../domain/entities/ValidationResult";
+
+/**
+ * Custom enum validation
+ * Generic validator for enum-like values with custom options
+ */
+export const validateEnum = (
+  value: string,
+  validOptions: readonly string[],
+  fieldName: string = "Field",
+): ValidationResult => {
+  if (!value || value.trim() === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  if (!validOptions.includes(value.toLowerCase())) {
+    return {
+      isValid: false,
+      error: `Please select a valid ${fieldName.toLowerCase()}`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Tags validation
+ * Generic validator for array of strings with constraints
+ */
+export const validateTags = (
+  tags: string[],
+  maxTags: number = 10,
+  maxTagLength: number = 20,
+): ValidationResult => {
+  if (!Array.isArray(tags)) {
+    return { isValid: false, error: "Tags must be an array" };
+  }
+
+  if (tags.length > maxTags) {
+    return { isValid: false, error: `Maximum ${maxTags} tags allowed` };
+  }
+
+  for (const tag of tags) {
+    if (typeof tag !== "string" || tag.trim().length === 0) {
+      return { isValid: false, error: "All tags must be non-empty strings" };
+    }
+
+    if (tag.trim().length > maxTagLength) {
+      return {
+        isValid: false,
+        error: `Each tag must be at most ${maxTagLength} characters`,
+      };
+    }
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Date range validation
+ * Validates date is within a specific range
+ */
+export const validateDateRange = (
+  date: Date,
+  minDate?: Date,
+  maxDate?: Date,
+  fieldName: string = "Date",
+): ValidationResult => {
+  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
+    return { isValid: false, error: `Please enter a valid ${fieldName.toLowerCase()}` };
+  }
+
+  if (minDate && date < minDate) {
+    return {
+      isValid: false,
+      error: `${fieldName} cannot be before ${minDate.toLocaleDateString()}`,
+    };
+  }
+
+  if (maxDate && date > maxDate) {
+    return {
+      isValid: false,
+      error: `${fieldName} cannot be after ${maxDate.toLocaleDateString()}`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Batch validation
+ * Validates multiple fields and returns all errors
+ */
+export const batchValidate = (
+  validations: Array<{ field: string; validator: () => ValidationResult }>,
+): { isValid: boolean; errors: Record<string, string> } => {
+  const errors: Record<string, string> = {};
+  let isValid = true;
+
+  validations.forEach(({ field, validator }) => {
+    const result = validator();
+    if (!result.isValid && result.error) {
+      errors[field] = result.error;
+      isValid = false;
+    }
+  });
+
+  return { isValid, errors };
+};

package/src/infrastructure/utils/date-validators.ts

@@ -0,0 +1,28 @@
+/**
+ * Date Validation Utilities
+ * Validation functions for date fields
+ */
+
+import type { ValidationResult } from "../../../domain/entities/ValidationResult";
+
+/**
+ * Validate date of birth
+ */
+export const validateDateOfBirth = (date: Date): ValidationResult => {
+  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
+    return { isValid: false, error: "Please enter a valid date" };
+  }
+
+  const today = new Date();
+  const age = today.getFullYear() - date.getFullYear();
+
+  if (age < 13) {
+    return { isValid: false, error: "You must be at least 13 years old" };
+  }
+
+  if (age > 120) {
+    return { isValid: false, error: "Please enter a valid date of birth" };
+  }
+
+  return { isValid: true };
+};

package/src/infrastructure/utils/numeric-validators.ts

@@ -0,0 +1,54 @@
+/**
+ * Numeric Validation Utilities
+ * Validation functions for numeric values
+ */
+
+import type { ValidationResult } from "../../../domain/entities/ValidationResult";
+
+/**
+ * Validate number range
+ */
+export const validateNumberRange = (
+  value: number,
+  min: number,
+  max: number,
+  fieldName: string = "Value",
+): ValidationResult => {
+  if (isNaN(value)) {
+    return { isValid: false, error: `${fieldName} must be a number` };
+  }
+
+  if (value < min || value > max) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be between ${min} and ${max}`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate positive number
+ */
+export const validatePositiveNumber = (
+  value: number,
+  fieldName: string = "Value",
+): ValidationResult => {
+  if (isNaN(value)) {
+    return { isValid: false, error: `${fieldName} must be a number` };
+  }
+
+  if (value <= 0) {
+    return { isValid: false, error: `${fieldName} must be greater than 0` };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate age
+ */
+export const validateAge = (age: number): ValidationResult => {
+  return validateNumberRange(age, 13, 120, "Age");
+};

package/src/infrastructure/utils/text-validators.ts

@@ -0,0 +1,133 @@
+/**
+ * Text Validation Utilities
+ * Validation functions for text-based fields
+ */
+
+import type { ValidationResult } from "../../../domain/entities/ValidationResult";
+
+/**
+ * Validate email format
+ */
+export const validateEmail = (email: string): ValidationResult => {
+  if (!email || email.trim() === "") {
+    return { isValid: false, error: "Email is required" };
+  }
+
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Please enter a valid email address" };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate required field
+ */
+export const validateRequired = (
+  value: string,
+  fieldName: string = "This field",
+): ValidationResult => {
+  if (!value || value.trim() === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate name
+ */
+export const validateName = (
+  name: string,
+  fieldName: string = "Name",
+  minLength: number = 2,
+): ValidationResult => {
+  if (!name || name.trim() === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  if (name.trim().length < minLength) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be at least ${minLength} characters`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate phone number (E.164 format)
+ */
+export const validatePhone = (phone: string): ValidationResult => {
+  if (!phone || phone.trim() === "") {
+    return { isValid: false, error: "Phone number is required" };
+  }
+
+  const phoneRegex = /^\+[1-9]\d{1,14}$/;
+  if (!phoneRegex.test(phone)) {
+    return { isValid: false, error: "Please enter a valid phone number" };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate min length
+ */
+export const validateMinLength = (
+  value: string,
+  minLength: number,
+  fieldName: string = "Field",
+): ValidationResult => {
+  if (!value || value.trim().length < minLength) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be at least ${minLength} characters`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate max length
+ */
+export const validateMaxLength = (
+  value: string,
+  maxLength: number,
+  fieldName: string = "Field",
+): ValidationResult => {
+  if (value && value.trim().length > maxLength) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be at most ${maxLength} characters`,
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate pattern (regex)
+ */
+export const validatePattern = (
+  value: string,
+  pattern: RegExp,
+  fieldName: string = "Field",
+  errorMessage?: string,
+): ValidationResult => {
+  if (!value) {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  if (!pattern.test(value)) {
+    return {
+      isValid: false,
+      error: errorMessage || `${fieldName} format is invalid`,
+    };
+  }
+
+  return { isValid: true };
+};

package/src/infrastructure/utils/validators.ts

@@ -3,464 +3,25 @@
  * Comprehensive validation functions for React Native forms
  */
 
-import type { ValidationResult } from "../../domain/entities/ValidationResult";
-
-/**
- * Validate email format
- */
-export const validateEmail = (email: string): ValidationResult => {
-  if (!email || email.trim() === "") {
-    return { isValid: false, error: "Email is required" };
-  }
-
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(email)) {
-    return { isValid: false, error: "Please enter a valid email address" };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate required field
- */
-export const validateRequired = (
-  value: string,
-  fieldName: string = "This field",
-): ValidationResult => {
-  if (!value || value.trim() === "") {
-    return { isValid: false, error: `${fieldName} is required` };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate name
- */
-export const validateName = (
-  name: string,
-  fieldName: string = "Name",
-  minLength: number = 2,
-): ValidationResult => {
-  if (!name || name.trim() === "") {
-    return { isValid: false, error: `${fieldName} is required` };
-  }
-
-  if (name.trim().length < minLength) {
-    return {
-      isValid: false,
-      error: `${fieldName} must be at least ${minLength} characters`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate phone number (E.164 format)
- */
-export const validatePhone = (phone: string): ValidationResult => {
-  if (!phone || phone.trim() === "") {
-    return { isValid: false, error: "Phone number is required" };
-  }
-
-  const phoneRegex = /^\+[1-9]\d{1,14}$/;
-  if (!phoneRegex.test(phone)) {
-    return { isValid: false, error: "Please enter a valid phone number" };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate number range
- */
-export const validateNumberRange = (
-  value: number,
-  min: number,
-  max: number,
-  fieldName: string = "Value",
-): ValidationResult => {
-  if (isNaN(value)) {
-    return { isValid: false, error: `${fieldName} must be a number` };
-  }
-
-  if (value < min || value > max) {
-    return {
-      isValid: false,
-      error: `${fieldName} must be between ${min} and ${max}`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate positive number
- */
-export const validatePositiveNumber = (
-  value: number,
-  fieldName: string = "Value",
-): ValidationResult => {
-  if (isNaN(value)) {
-    return { isValid: false, error: `${fieldName} must be a number` };
-  }
-
-  if (value <= 0) {
-    return { isValid: false, error: `${fieldName} must be greater than 0` };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate min length
- */
-export const validateMinLength = (
-  value: string,
-  minLength: number,
-  fieldName: string = "Field",
-): ValidationResult => {
-  if (!value || value.trim().length < minLength) {
-    return {
-      isValid: false,
-      error: `${fieldName} must be at least ${minLength} characters`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate max length
- */
-export const validateMaxLength = (
-  value: string,
-  maxLength: number,
-  fieldName: string = "Field",
-): ValidationResult => {
-  if (value && value.trim().length > maxLength) {
-    return {
-      isValid: false,
-      error: `${fieldName} must be at most ${maxLength} characters`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate pattern (regex)
- */
-export const validatePattern = (
-  value: string,
-  pattern: RegExp,
-  fieldName: string = "Field",
-  errorMessage?: string,
-): ValidationResult => {
-  if (!value) {
-    return { isValid: false, error: `${fieldName} is required` };
-  }
-
-  if (!pattern.test(value)) {
-    return {
-      isValid: false,
-      error: errorMessage || `${fieldName} format is invalid`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate date of birth
- */
-export const validateDateOfBirth = (date: Date): ValidationResult => {
-  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
-    return { isValid: false, error: "Please enter a valid date" };
-  }
-
-  const today = new Date();
-  const age = today.getFullYear() - date.getFullYear();
-
-  if (age < 13) {
-    return { isValid: false, error: "You must be at least 13 years old" };
-  }
-
-  if (age > 120) {
-    return { isValid: false, error: "Please enter a valid date of birth" };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate age
- */
-export const validateAge = (age: number): ValidationResult => {
-  return validateNumberRange(age, 13, 120, "Age");
-};
-
-/**
- * Batch validation
- * Validates multiple fields and returns all errors
- */
-export const batchValidate = (
-  validations: Array<{ field: string; validator: () => ValidationResult }>,
-): { isValid: boolean; errors: Record<string, string> } => {
-  const errors: Record<string, string> = {};
-  let isValid = true;
-
-  validations.forEach(({ field, validator }) => {
-    const result = validator();
-    if (!result.isValid && result.error) {
-      errors[field] = result.error;
-      isValid = false;
-    }
-  });
-
-  return { isValid, errors };
-};
-
-/**
- * Dream-specific validation functions
- */
-
-/**
- * Validate dream title
- */
-export const validateDreamTitle = (
-  title: string,
-  minLength: number = 3,
-  maxLength: number = 100,
-): ValidationResult => {
-  if (!title || title.trim() === "") {
-    return { isValid: false, error: "Dream title is required" };
-  }
-
-  if (title.trim().length < minLength) {
-    return {
-      isValid: false,
-      error: `Dream title must be at least ${minLength} characters`,
-    };
-  }
-
-  if (title.trim().length > maxLength) {
-    return {
-      isValid: false,
-      error: `Dream title must be at most ${maxLength} characters`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream description
- */
-export const validateDreamDescription = (
-  description: string,
-  minLength: number = 10,
-  maxLength: number = 2000,
-): ValidationResult => {
-  if (!description || description.trim() === "") {
-    return { isValid: false, error: "Dream description is required" };
-  }
-
-  if (description.trim().length < minLength) {
-    return {
-      isValid: false,
-      error: `Dream description must be at least ${minLength} characters`,
-    };
-  }
-
-  if (description.trim().length > maxLength) {
-    return {
-      isValid: false,
-      error: `Dream description must be at most ${maxLength} characters`,
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream mood
- */
-export const validateDreamMood = (mood: string): ValidationResult => {
-  if (!mood || mood.trim() === "") {
-    return { isValid: false, error: "Dream mood is required" };
-  }
-
-  const validMoods = [
-    "happy",
-    "sad",
-    "scared",
-    "excited",
-    "peaceful",
-    "anxious",
-    "confused",
-    "angry",
-    "surprised",
-    "neutral",
-  ];
-  if (!validMoods.includes(mood.toLowerCase())) {
-    return {
-      isValid: false,
-      error: "Please select a valid mood",
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream category
- */
-export const validateDreamCategory = (category: string): ValidationResult => {
-  if (!category || category.trim() === "") {
-    return { isValid: false, error: "Dream category is required" };
-  }
-
-  const validCategories = [
-    "lucid",
-    "nightmare",
-    "recurring",
-    "prophetic",
-    "healing",
-    "creative",
-    "adventure",
-    "relationship",
-    "work",
-    "childhood",
-    "flying",
-    "falling",
-    "chase",
-    "exam",
-    "tooth",
-    "other",
-  ];
-  if (!validCategories.includes(category.toLowerCase())) {
-    return {
-      isValid: false,
-      error: "Please select a valid category",
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream date
- */
-export const validateDreamDate = (date: Date): ValidationResult => {
-  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
-    return { isValid: false, error: "Please enter a valid dream date" };
-  }
-
-  const today = new Date();
-  if (date > today) {
-    return { isValid: false, error: "Dream date cannot be in the future" };
-  }
-
-  // Don't allow dreams older than 1 year
-  const oneYearAgo = new Date();
-  oneYearAgo.setFullYear(oneYearAgo.getFullYear() - 1);
-  if (date < oneYearAgo) {
-    return {
-      isValid: false,
-      error: "Dream date cannot be more than 1 year old",
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream tags
- */
-export const validateDreamTags = (tags: string[]): ValidationResult => {
-  if (!Array.isArray(tags)) {
-    return { isValid: false, error: "Dream tags must be an array" };
-  }
-
-  if (tags.length > 10) {
-    return { isValid: false, error: "Maximum 10 tags allowed" };
-  }
-
-  for (const tag of tags) {
-    if (typeof tag !== "string" || tag.trim().length === 0) {
-      return { isValid: false, error: "All tags must be non-empty strings" };
-    }
-
-    if (tag.trim().length > 20) {
-      return {
-        isValid: false,
-        error: "Each tag must be at most 20 characters",
-      };
-    }
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Validate dream privacy setting
- */
-export const validateDreamPrivacy = (privacy: string): ValidationResult => {
-  if (!privacy || privacy.trim() === "") {
-    return { isValid: false, error: "Privacy setting is required" };
-  }
-
-  const validPrivacyOptions = ["private", "friends", "public"];
-  if (!validPrivacyOptions.includes(privacy.toLowerCase())) {
-    return {
-      isValid: false,
-      error: "Please select a valid privacy setting",
-    };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Complete dream form validation
- * Validates all dream fields at once
- */
-export const validateDreamForm = (formData: {
-  title?: string;
-  description?: string;
-  mood?: string;
-  category?: string;
-  date?: Date;
-  tags?: string[];
-  privacy?: string;
-}): { isValid: boolean; errors: Record<string, string> } => {
-  const validations = [
-    {
-      field: "title",
-      validator: () => validateDreamTitle(formData.title || ""),
-    },
-    {
-      field: "description",
-      validator: () => validateDreamDescription(formData.description || ""),
-    },
-    { field: "mood", validator: () => validateDreamMood(formData.mood || "") },
-    {
-      field: "category",
-      validator: () => validateDreamCategory(formData.category || ""),
-    },
-    {
-      field: "date",
-      validator: () => validateDreamDate(formData.date || new Date()),
-    },
-    { field: "tags", validator: () => validateDreamTags(formData.tags || []) },
-    {
-      field: "privacy",
-      validator: () => validateDreamPrivacy(formData.privacy || ""),
-    },
-  ];
-
-  return batchValidate(validations);
-};
+// Text validators
+export {
+  validateEmail,
+  validateRequired,
+  validateName,
+  validatePhone,
+  validateMinLength,
+  validateMaxLength,
+  validatePattern,
+} from "./text-validators";
+
+// Numeric validators
+export {
+  validateNumberRange,
+  validatePositiveNumber,
+  validateAge,
+} from "./numeric-validators";
+
+// Date validators
+export {
+  validateDateOfBirth,
+} from "./date-validators";