@umituz/react-native-validation 1.4.5 → 1.4.6

package/package.json

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

package/src/index.ts

@@ -8,7 +8,7 @@
  */
 
 // Domain Layer - Entities
-export type { ValidationResult } from './domain/entities/ValidationResult';
+export type { ValidationResult } from "./domain/entities/ValidationResult";
 
 // Infrastructure Layer - Validators
 export {
@@ -24,7 +24,19 @@ export {
   validateDateOfBirth,
   validateAge,
   batchValidate,
-} from './infrastructure/utils/validators';
+} from "./infrastructure/utils/validators";
+
+// Dream-specific validators
+export {
+  validateDreamTitle,
+  validateDreamDescription,
+  validateDreamMood,
+  validateDreamCategory,
+  validateDreamDate,
+  validateDreamTags,
+  validateDreamPrivacy,
+  validateDreamForm,
+} from "./infrastructure/utils/validators";
 
 // Infrastructure Layer - Sanitization
 export {
@@ -36,7 +48,7 @@ export {
   sanitizeText,
   containsDangerousChars,
   isWithinLengthLimit,
-} from './infrastructure/utils/sanitization';
+} from "./infrastructure/utils/sanitization";
 
 // Infrastructure Layer - MIME Type Validation
 export {
@@ -44,7 +56,7 @@ export {
   SUPPORTED_IMAGE_MIME_TYPES,
   EXTENSION_TO_MIME_TYPE,
   MIME_TYPE_TO_EXTENSION,
-} from './infrastructure/utils/mime-types.constants';
+} from "./infrastructure/utils/mime-types.constants";
 
 export {
   getFileExtension,
@@ -53,8 +65,10 @@ export {
   validateImageMimeType,
   validateImageExtension,
   validateImageDataUrl,
-} from './infrastructure/utils/mime-type-validator';
+} from "./infrastructure/utils/mime-type-validator";
 
 // Infrastructure Layer - Image Validation
-export { validateImageUri, getImageMimeType } from './infrastructure/utils/image-validator';
-
+export {
+  validateImageUri,
+  getImageMimeType,
+} from "./infrastructure/utils/image-validator";

package/src/infrastructure/utils/validators.ts

@@ -3,19 +3,19 @@
  * Comprehensive validation functions for React Native forms
  */
 
-import type { ValidationResult } from '../../domain/entities/ValidationResult';
+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' };
+  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: false, error: "Please enter a valid email address" };
   }
 
   return { isValid: true };
@@ -26,9 +26,9 @@ export const validateEmail = (email: string): ValidationResult => {
  */
 export const validateRequired = (
   value: string,
-  fieldName: string = 'This field'
+  fieldName: string = "This field",
 ): ValidationResult => {
-  if (!value || value.trim() === '') {
+  if (!value || value.trim() === "") {
     return { isValid: false, error: `${fieldName} is required` };
   }
 
@@ -40,10 +40,10 @@ export const validateRequired = (
  */
 export const validateName = (
   name: string,
-  fieldName: string = 'Name',
-  minLength: number = 2
+  fieldName: string = "Name",
+  minLength: number = 2,
 ): ValidationResult => {
-  if (!name || name.trim() === '') {
+  if (!name || name.trim() === "") {
     return { isValid: false, error: `${fieldName} is required` };
   }
 
@@ -61,13 +61,13 @@ export const validateName = (
  * Validate phone number (E.164 format)
  */
 export const validatePhone = (phone: string): ValidationResult => {
-  if (!phone || phone.trim() === '') {
-    return { isValid: false, error: 'Phone number is required' };
+  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: false, error: "Please enter a valid phone number" };
   }
 
   return { isValid: true };
@@ -80,7 +80,7 @@ export const validateNumberRange = (
   value: number,
   min: number,
   max: number,
-  fieldName: string = 'Value'
+  fieldName: string = "Value",
 ): ValidationResult => {
   if (isNaN(value)) {
     return { isValid: false, error: `${fieldName} must be a number` };
@@ -101,7 +101,7 @@ export const validateNumberRange = (
  */
 export const validatePositiveNumber = (
   value: number,
-  fieldName: string = 'Value'
+  fieldName: string = "Value",
 ): ValidationResult => {
   if (isNaN(value)) {
     return { isValid: false, error: `${fieldName} must be a number` };
@@ -120,7 +120,7 @@ export const validatePositiveNumber = (
 export const validateMinLength = (
   value: string,
   minLength: number,
-  fieldName: string = 'Field'
+  fieldName: string = "Field",
 ): ValidationResult => {
   if (!value || value.trim().length < minLength) {
     return {
@@ -138,7 +138,7 @@ export const validateMinLength = (
 export const validateMaxLength = (
   value: string,
   maxLength: number,
-  fieldName: string = 'Field'
+  fieldName: string = "Field",
 ): ValidationResult => {
   if (value && value.trim().length > maxLength) {
     return {
@@ -156,8 +156,8 @@ export const validateMaxLength = (
 export const validatePattern = (
   value: string,
   pattern: RegExp,
-  fieldName: string = 'Field',
-  errorMessage?: string
+  fieldName: string = "Field",
+  errorMessage?: string,
 ): ValidationResult => {
   if (!value) {
     return { isValid: false, error: `${fieldName} is required` };
@@ -178,18 +178,18 @@ export const validatePattern = (
  */
 export const validateDateOfBirth = (date: Date): ValidationResult => {
   if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
-    return { isValid: false, error: 'Please enter a valid date' };
+    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' };
+    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: false, error: "Please enter a valid date of birth" };
   }
 
   return { isValid: true };
@@ -199,7 +199,7 @@ export const validateDateOfBirth = (date: Date): ValidationResult => {
  * Validate age
  */
 export const validateAge = (age: number): ValidationResult => {
-  return validateNumberRange(age, 13, 120, 'Age');
+  return validateNumberRange(age, 13, 120, "Age");
 };
 
 /**
@@ -207,7 +207,7 @@ export const validateAge = (age: number): ValidationResult => {
  * Validates multiple fields and returns all errors
  */
 export const batchValidate = (
-  validations: Array<{ field: string; validator: () => ValidationResult }>
+  validations: Array<{ field: string; validator: () => ValidationResult }>,
 ): { isValid: boolean; errors: Record<string, string> } => {
   const errors: Record<string, string> = {};
   let isValid = true;
@@ -223,3 +223,244 @@ export const batchValidate = (
   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);
+};