@umituz/react-native-validation 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Ümit UZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,181 @@
+# @umituz/react-native-validation
+
+Comprehensive validation utilities for React Native forms. Provides reusable validation functions for common input types.
+
+## Installation
+
+```bash
+npm install @umituz/react-native-validation
+```
+
+## Peer Dependencies
+
+- `react` >= 18.2.0
+- `react-native` >= 0.74.0
+
+## Features
+
+- ✅ Email validation
+- ✅ Password validation (with strength requirements)
+- ✅ Phone number validation (E.164 format)
+- ✅ Required field validation
+- ✅ Name validation
+- ✅ Number range validation
+- ✅ Min/Max length validation
+- ✅ Pattern (regex) validation
+- ✅ Date of birth validation
+- ✅ Health & fitness validators (weight, height, age, calories, macros, etc.)
+- ✅ Batch validation
+- ✅ TypeScript type safety
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { validateEmail, validatePassword, validateRequired } from '@umituz/react-native-validation';
+
+// Validate email
+const emailResult = validateEmail('user@example.com');
+if (!emailResult.isValid) {
+  console.error(emailResult.error);
+}
+
+// Validate password
+const passwordResult = validatePassword('MySecure123', {
+  minLength: 8,
+  requireUppercase: true,
+  requireLowercase: true,
+  requireNumber: true,
+});
+
+// Validate required field
+const requiredResult = validateRequired('value', 'Field Name');
+```
+
+### Form Validation Example
+
+```typescript
+import {
+  validateEmail,
+  validatePassword,
+  validatePasswordConfirmation,
+  validateRequired,
+  batchValidate,
+} from '@umituz/react-native-validation';
+
+const validateForm = (email: string, password: string, confirmPassword: string) => {
+  return batchValidate([
+    { field: 'email', validator: () => validateEmail(email) },
+    { field: 'password', validator: () => validatePassword(password) },
+    {
+      field: 'confirmPassword',
+      validator: () => validatePasswordConfirmation(password, confirmPassword),
+    },
+  ]);
+};
+
+const result = validateForm('user@example.com', 'MySecure123', 'MySecure123');
+if (!result.isValid) {
+  console.log('Validation errors:', result.errors);
+}
+```
+
+### Health & Fitness Validators
+
+```typescript
+import {
+  validateWeight,
+  validateHeight,
+  validateAge,
+  validateCalories,
+  validateWorkoutDuration,
+} from '@umituz/react-native-validation';
+
+const weightResult = validateWeight(75); // kg
+const heightResult = validateHeight(175); // cm
+const ageResult = validateAge(25);
+const caloriesResult = validateCalories(2000);
+const durationResult = validateWorkoutDuration(45); // minutes
+```
+
+### Custom Validation
+
+```typescript
+import { validatePattern, validateNumberRange } from '@umituz/react-native-validation';
+
+// Validate with custom pattern
+const patternResult = validatePattern(
+  'ABC123',
+  /^[A-Z]{3}\d{3}$/,
+  'Code',
+  'Code must be 3 uppercase letters followed by 3 numbers'
+);
+
+// Validate number range
+const rangeResult = validateNumberRange(50, 0, 100, 'Percentage');
+```
+
+## API Reference
+
+### Core Validators
+
+- `validateEmail(email: string): ValidationResult`
+- `validatePassword(password: string, options?: PasswordOptions): ValidationResult`
+- `validatePasswordConfirmation(password: string, confirmPassword: string): ValidationResult`
+- `validateRequired(value: string, fieldName?: string): ValidationResult`
+- `validateName(name: string, fieldName?: string, minLength?: number): ValidationResult`
+- `validatePhone(phone: string): ValidationResult`
+
+### Number Validators
+
+- `validateNumberRange(value: number, min: number, max: number, fieldName?: string): ValidationResult`
+- `validatePositiveNumber(value: number, fieldName?: string): ValidationResult`
+
+### String Validators
+
+- `validateMinLength(value: string, minLength: number, fieldName?: string): ValidationResult`
+- `validateMaxLength(value: string, maxLength: number, fieldName?: string): ValidationResult`
+- `validatePattern(value: string, pattern: RegExp, fieldName?: string, errorMessage?: string): ValidationResult`
+
+### Date Validators
+
+- `validateDateOfBirth(date: Date): ValidationResult`
+- `validateAge(age: number): ValidationResult`
+
+### Health & Fitness Validators
+
+- `validateWeight(weight: number): ValidationResult` (20-300 kg)
+- `validateHeight(height: number): ValidationResult` (50-250 cm)
+- `validateCalories(calories: number): ValidationResult` (0-10000)
+- `validateMacros(grams: number, macroType: string): ValidationResult` (0-1000 g)
+- `validateWaterIntake(glasses: number): ValidationResult` (0-50)
+- `validateWorkoutDuration(minutes: number): ValidationResult` (1-600 min)
+- `validateReps(reps: number): ValidationResult` (1-1000)
+- `validateSets(sets: number): ValidationResult` (1-100)
+- `validateExerciseWeight(weight: number): ValidationResult` (0-1000 kg)
+
+### Batch Validation
+
+- `batchValidate(validations: Array<{ field: string; validator: () => ValidationResult }>): { isValid: boolean; errors: Record<string, string> }`
+
+## Types
+
+```typescript
+interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+interface PasswordOptions {
+  minLength?: number;
+  requireUppercase?: boolean;
+  requireLowercase?: boolean;
+  requireNumber?: boolean;
+}
+```
+
+## License
+
+MIT
+

package/lib/domain/entities/ValidationResult.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validation Result Entity
+ * Standard return type for all validation functions
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}

package/lib/domain/entities/ValidationResult.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Validation Result Entity
+ * Standard return type for all validation functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @umituz/react-native-validation
+ *
+ * Comprehensive validation utilities for React Native forms.
+ * Provides reusable validation functions for common input types.
+ *
+ * @package react-native-validation
+ */
+export type { ValidationResult } from './domain/entities/ValidationResult';
+export { validateEmail, validatePassword, validatePasswordConfirmation, validateRequired, validateName, validatePhone, validateNumberRange, validatePositiveNumber, validateMinLength, validateMaxLength, validatePattern, validateDateOfBirth, validateAge, validateWeight, validateHeight, validateCalories, validateMacros, validateWaterIntake, validateWorkoutDuration, validateReps, validateSets, validateExerciseWeight, batchValidate, } from './infrastructure/utils/validators';

package/lib/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @umituz/react-native-validation
+ *
+ * Comprehensive validation utilities for React Native forms.
+ * Provides reusable validation functions for common input types.
+ *
+ * @package react-native-validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchValidate = exports.validateExerciseWeight = exports.validateSets = exports.validateReps = exports.validateWorkoutDuration = exports.validateWaterIntake = exports.validateMacros = exports.validateCalories = exports.validateHeight = exports.validateWeight = exports.validateAge = exports.validateDateOfBirth = exports.validatePattern = exports.validateMaxLength = exports.validateMinLength = exports.validatePositiveNumber = exports.validateNumberRange = exports.validatePhone = exports.validateName = exports.validateRequired = exports.validatePasswordConfirmation = exports.validatePassword = exports.validateEmail = void 0;
+// Infrastructure Layer - Validators
+var validators_1 = require("./infrastructure/utils/validators");
+Object.defineProperty(exports, "validateEmail", { enumerable: true, get: function () { return validators_1.validateEmail; } });
+Object.defineProperty(exports, "validatePassword", { enumerable: true, get: function () { return validators_1.validatePassword; } });
+Object.defineProperty(exports, "validatePasswordConfirmation", { enumerable: true, get: function () { return validators_1.validatePasswordConfirmation; } });
+Object.defineProperty(exports, "validateRequired", { enumerable: true, get: function () { return validators_1.validateRequired; } });
+Object.defineProperty(exports, "validateName", { enumerable: true, get: function () { return validators_1.validateName; } });
+Object.defineProperty(exports, "validatePhone", { enumerable: true, get: function () { return validators_1.validatePhone; } });
+Object.defineProperty(exports, "validateNumberRange", { enumerable: true, get: function () { return validators_1.validateNumberRange; } });
+Object.defineProperty(exports, "validatePositiveNumber", { enumerable: true, get: function () { return validators_1.validatePositiveNumber; } });
+Object.defineProperty(exports, "validateMinLength", { enumerable: true, get: function () { return validators_1.validateMinLength; } });
+Object.defineProperty(exports, "validateMaxLength", { enumerable: true, get: function () { return validators_1.validateMaxLength; } });
+Object.defineProperty(exports, "validatePattern", { enumerable: true, get: function () { return validators_1.validatePattern; } });
+Object.defineProperty(exports, "validateDateOfBirth", { enumerable: true, get: function () { return validators_1.validateDateOfBirth; } });
+Object.defineProperty(exports, "validateAge", { enumerable: true, get: function () { return validators_1.validateAge; } });
+Object.defineProperty(exports, "validateWeight", { enumerable: true, get: function () { return validators_1.validateWeight; } });
+Object.defineProperty(exports, "validateHeight", { enumerable: true, get: function () { return validators_1.validateHeight; } });
+Object.defineProperty(exports, "validateCalories", { enumerable: true, get: function () { return validators_1.validateCalories; } });
+Object.defineProperty(exports, "validateMacros", { enumerable: true, get: function () { return validators_1.validateMacros; } });
+Object.defineProperty(exports, "validateWaterIntake", { enumerable: true, get: function () { return validators_1.validateWaterIntake; } });
+Object.defineProperty(exports, "validateWorkoutDuration", { enumerable: true, get: function () { return validators_1.validateWorkoutDuration; } });
+Object.defineProperty(exports, "validateReps", { enumerable: true, get: function () { return validators_1.validateReps; } });
+Object.defineProperty(exports, "validateSets", { enumerable: true, get: function () { return validators_1.validateSets; } });
+Object.defineProperty(exports, "validateExerciseWeight", { enumerable: true, get: function () { return validators_1.validateExerciseWeight; } });
+Object.defineProperty(exports, "batchValidate", { enumerable: true, get: function () { return validators_1.batchValidate; } });

package/lib/infrastructure/utils/validators.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Validation Utilities
+ * Comprehensive validation functions for React Native forms
+ */
+import type { ValidationResult } from '../../domain/entities/ValidationResult';
+/**
+ * Validate email format
+ */
+export declare const validateEmail: (email: string) => ValidationResult;
+/**
+ * Validate password strength
+ * @param password - Password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @param requireUppercase - Require uppercase letter (default: true)
+ * @param requireLowercase - Require lowercase letter (default: true)
+ * @param requireNumber - Require number (default: true)
+ */
+export declare const validatePassword: (password: string, options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+}) => ValidationResult;
+/**
+ * Validate password confirmation
+ */
+export declare const validatePasswordConfirmation: (password: string, confirmPassword: string) => ValidationResult;
+/**
+ * Validate required field
+ */
+export declare const validateRequired: (value: string, fieldName?: string) => ValidationResult;
+/**
+ * Validate name
+ */
+export declare const validateName: (name: string, fieldName?: string, minLength?: number) => ValidationResult;
+/**
+ * Validate phone number (E.164 format)
+ */
+export declare const validatePhone: (phone: string) => ValidationResult;
+/**
+ * Validate number range
+ */
+export declare const validateNumberRange: (value: number, min: number, max: number, fieldName?: string) => ValidationResult;
+/**
+ * Validate positive number
+ */
+export declare const validatePositiveNumber: (value: number, fieldName?: string) => ValidationResult;
+/**
+ * Validate min length
+ */
+export declare const validateMinLength: (value: string, minLength: number, fieldName?: string) => ValidationResult;
+/**
+ * Validate max length
+ */
+export declare const validateMaxLength: (value: string, maxLength: number, fieldName?: string) => ValidationResult;
+/**
+ * Validate pattern (regex)
+ */
+export declare const validatePattern: (value: string, pattern: RegExp, fieldName?: string, errorMessage?: string) => ValidationResult;
+/**
+ * Validate date of birth
+ */
+export declare const validateDateOfBirth: (date: Date) => ValidationResult;
+/**
+ * Validate age
+ */
+export declare const validateAge: (age: number) => ValidationResult;
+/**
+ * Validate weight (kg)
+ */
+export declare const validateWeight: (weight: number) => ValidationResult;
+/**
+ * Validate height (cm)
+ */
+export declare const validateHeight: (height: number) => ValidationResult;
+/**
+ * Validate calories
+ */
+export declare const validateCalories: (calories: number) => ValidationResult;
+/**
+ * Validate macros (protein, carbs, fat in grams)
+ */
+export declare const validateMacros: (grams: number, macroType: string) => ValidationResult;
+/**
+ * Validate water intake (glasses)
+ */
+export declare const validateWaterIntake: (glasses: number) => ValidationResult;
+/**
+ * Validate workout duration (minutes)
+ */
+export declare const validateWorkoutDuration: (minutes: number) => ValidationResult;
+/**
+ * Validate reps
+ */
+export declare const validateReps: (reps: number) => ValidationResult;
+/**
+ * Validate sets
+ */
+export declare const validateSets: (sets: number) => ValidationResult;
+/**
+ * Validate exercise weight (kg)
+ */
+export declare const validateExerciseWeight: (weight: number) => ValidationResult;
+/**
+ * Batch validation
+ * Validates multiple fields and returns all errors
+ */
+export declare const batchValidate: (validations: Array<{
+    field: string;
+    validator: () => ValidationResult;
+}>) => {
+    isValid: boolean;
+    errors: Record<string, string>;
+};

package/lib/infrastructure/utils/validators.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Validation Utilities
+ * Comprehensive validation functions for React Native forms
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchValidate = exports.validateExerciseWeight = exports.validateSets = exports.validateReps = exports.validateWorkoutDuration = exports.validateWaterIntake = exports.validateMacros = exports.validateCalories = exports.validateHeight = exports.validateWeight = exports.validateAge = exports.validateDateOfBirth = exports.validatePattern = exports.validateMaxLength = exports.validateMinLength = exports.validatePositiveNumber = exports.validateNumberRange = exports.validatePhone = exports.validateName = exports.validateRequired = exports.validatePasswordConfirmation = exports.validatePassword = exports.validateEmail = void 0;
+/**
+ * Validate email format
+ */
+const validateEmail = (email) => {
+    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 };
+};
+exports.validateEmail = validateEmail;
+/**
+ * Validate password strength
+ * @param password - Password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @param requireUppercase - Require uppercase letter (default: true)
+ * @param requireLowercase - Require lowercase letter (default: true)
+ * @param requireNumber - Require number (default: true)
+ */
+const validatePassword = (password, options) => {
+    const { minLength = 8, requireUppercase = true, requireLowercase = true, requireNumber = true, } = options || {};
+    if (!password || password.trim() === '') {
+        return { isValid: false, error: 'Password is required' };
+    }
+    if (password.length < minLength) {
+        return {
+            isValid: false,
+            error: `Password must be at least ${minLength} characters`,
+        };
+    }
+    if (requireUppercase && !/[A-Z]/.test(password)) {
+        return {
+            isValid: false,
+            error: 'Password must contain at least one uppercase letter',
+        };
+    }
+    if (requireLowercase && !/[a-z]/.test(password)) {
+        return {
+            isValid: false,
+            error: 'Password must contain at least one lowercase letter',
+        };
+    }
+    if (requireNumber && !/[0-9]/.test(password)) {
+        return {
+            isValid: false,
+            error: 'Password must contain at least one number',
+        };
+    }
+    return { isValid: true };
+};
+exports.validatePassword = validatePassword;
+/**
+ * Validate password confirmation
+ */
+const validatePasswordConfirmation = (password, confirmPassword) => {
+    if (!confirmPassword) {
+        return { isValid: false, error: 'Please confirm your password' };
+    }
+    if (password !== confirmPassword) {
+        return { isValid: false, error: 'Passwords do not match' };
+    }
+    return { isValid: true };
+};
+exports.validatePasswordConfirmation = validatePasswordConfirmation;
+/**
+ * Validate required field
+ */
+const validateRequired = (value, fieldName = 'This field') => {
+    if (!value || value.trim() === '') {
+        return { isValid: false, error: `${fieldName} is required` };
+    }
+    return { isValid: true };
+};
+exports.validateRequired = validateRequired;
+/**
+ * Validate name
+ */
+const validateName = (name, fieldName = 'Name', minLength = 2) => {
+    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 };
+};
+exports.validateName = validateName;
+/**
+ * Validate phone number (E.164 format)
+ */
+const validatePhone = (phone) => {
+    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 };
+};
+exports.validatePhone = validatePhone;
+/**
+ * Validate number range
+ */
+const validateNumberRange = (value, min, max, fieldName = 'Value') => {
+    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 };
+};
+exports.validateNumberRange = validateNumberRange;
+/**
+ * Validate positive number
+ */
+const validatePositiveNumber = (value, fieldName = 'Value') => {
+    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 };
+};
+exports.validatePositiveNumber = validatePositiveNumber;
+/**
+ * Validate min length
+ */
+const validateMinLength = (value, minLength, fieldName = 'Field') => {
+    if (!value || value.trim().length < minLength) {
+        return {
+            isValid: false,
+            error: `${fieldName} must be at least ${minLength} characters`,
+        };
+    }
+    return { isValid: true };
+};
+exports.validateMinLength = validateMinLength;
+/**
+ * Validate max length
+ */
+const validateMaxLength = (value, maxLength, fieldName = 'Field') => {
+    if (value && value.trim().length > maxLength) {
+        return {
+            isValid: false,
+            error: `${fieldName} must be at most ${maxLength} characters`,
+        };
+    }
+    return { isValid: true };
+};
+exports.validateMaxLength = validateMaxLength;
+/**
+ * Validate pattern (regex)
+ */
+const validatePattern = (value, pattern, fieldName = 'Field', errorMessage) => {
+    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 };
+};
+exports.validatePattern = validatePattern;
+/**
+ * Validate date of birth
+ */
+const validateDateOfBirth = (date) => {
+    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 };
+};
+exports.validateDateOfBirth = validateDateOfBirth;
+/**
+ * Validate age
+ */
+const validateAge = (age) => {
+    return (0, exports.validateNumberRange)(age, 13, 120, 'Age');
+};
+exports.validateAge = validateAge;
+/**
+ * Validate weight (kg)
+ */
+const validateWeight = (weight) => {
+    return (0, exports.validateNumberRange)(weight, 20, 300, 'Weight');
+};
+exports.validateWeight = validateWeight;
+/**
+ * Validate height (cm)
+ */
+const validateHeight = (height) => {
+    return (0, exports.validateNumberRange)(height, 50, 250, 'Height');
+};
+exports.validateHeight = validateHeight;
+/**
+ * Validate calories
+ */
+const validateCalories = (calories) => {
+    return (0, exports.validateNumberRange)(calories, 0, 10000, 'Calories');
+};
+exports.validateCalories = validateCalories;
+/**
+ * Validate macros (protein, carbs, fat in grams)
+ */
+const validateMacros = (grams, macroType) => {
+    return (0, exports.validateNumberRange)(grams, 0, 1000, macroType);
+};
+exports.validateMacros = validateMacros;
+/**
+ * Validate water intake (glasses)
+ */
+const validateWaterIntake = (glasses) => {
+    return (0, exports.validateNumberRange)(glasses, 0, 50, 'Water intake');
+};
+exports.validateWaterIntake = validateWaterIntake;
+/**
+ * Validate workout duration (minutes)
+ */
+const validateWorkoutDuration = (minutes) => {
+    return (0, exports.validateNumberRange)(minutes, 1, 600, 'Workout duration');
+};
+exports.validateWorkoutDuration = validateWorkoutDuration;
+/**
+ * Validate reps
+ */
+const validateReps = (reps) => {
+    return (0, exports.validateNumberRange)(reps, 1, 1000, 'Reps');
+};
+exports.validateReps = validateReps;
+/**
+ * Validate sets
+ */
+const validateSets = (sets) => {
+    return (0, exports.validateNumberRange)(sets, 1, 100, 'Sets');
+};
+exports.validateSets = validateSets;
+/**
+ * Validate exercise weight (kg)
+ */
+const validateExerciseWeight = (weight) => {
+    return (0, exports.validateNumberRange)(weight, 0, 1000, 'Weight');
+};
+exports.validateExerciseWeight = validateExerciseWeight;
+/**
+ * Batch validation
+ * Validates multiple fields and returns all errors
+ */
+const batchValidate = (validations) => {
+    const errors = {};
+    let isValid = true;
+    validations.forEach(({ field, validator }) => {
+        const result = validator();
+        if (!result.isValid && result.error) {
+            errors[field] = result.error;
+            isValid = false;
+        }
+    });
+    return { isValid, errors };
+};
+exports.batchValidate = batchValidate;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@umituz/react-native-validation",
+  "version": "1.0.0",
+  "description": "Comprehensive validation utilities for React Native forms",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf lib",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build",
+    "version:patch": "npm version patch -m 'chore: release v%s'",
+    "version:minor": "npm version minor -m 'chore: release v%s'",
+    "version:major": "npm version major -m 'chore: release v%s'"
+  },
+  "keywords": [
+    "react-native",
+    "validation",
+    "forms",
+    "validators",
+    "form-validation"
+  ],
+  "author": "Ümit UZ <umit@umituz.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umituz/react-native-validation"
+  },
+  "peerDependencies": {
+    "react": ">=18.2.0",
+    "react-native": ">=0.74.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.45",
+    "@types/react-native": "^0.73.0",
+    "react": "^18.2.0",
+    "react-native": "^0.74.0",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}
+

package/src/domain/entities/ValidationResult.ts

@@ -0,0 +1,10 @@
+/**
+ * Validation Result Entity
+ * Standard return type for all validation functions
+ */
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+

package/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @umituz/react-native-validation
+ *
+ * Comprehensive validation utilities for React Native forms.
+ * Provides reusable validation functions for common input types.
+ *
+ * @package react-native-validation
+ */
+
+// Domain Layer - Entities
+export type { ValidationResult } from './domain/entities/ValidationResult';
+
+// Infrastructure Layer - Validators
+export {
+  validateEmail,
+  validatePassword,
+  validatePasswordConfirmation,
+  validateRequired,
+  validateName,
+  validatePhone,
+  validateNumberRange,
+  validatePositiveNumber,
+  validateMinLength,
+  validateMaxLength,
+  validatePattern,
+  validateDateOfBirth,
+  validateAge,
+  validateWeight,
+  validateHeight,
+  validateCalories,
+  validateMacros,
+  validateWaterIntake,
+  validateWorkoutDuration,
+  validateReps,
+  validateSets,
+  validateExerciseWeight,
+  batchValidate,
+} from './infrastructure/utils/validators';
+

package/src/infrastructure/utils/validators.ts

@@ -0,0 +1,368 @@
+/**
+ * Validation Utilities
+ * 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 password strength
+ * @param password - Password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @param requireUppercase - Require uppercase letter (default: true)
+ * @param requireLowercase - Require lowercase letter (default: true)
+ * @param requireNumber - Require number (default: true)
+ */
+export const validatePassword = (
+  password: string,
+  options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+  }
+): ValidationResult => {
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumber = true,
+  } = options || {};
+
+  if (!password || password.trim() === '') {
+    return { isValid: false, error: 'Password is required' };
+  }
+
+  if (password.length < minLength) {
+    return {
+      isValid: false,
+      error: `Password must be at least ${minLength} characters`,
+    };
+  }
+
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    return {
+      isValid: false,
+      error: 'Password must contain at least one uppercase letter',
+    };
+  }
+
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    return {
+      isValid: false,
+      error: 'Password must contain at least one lowercase letter',
+    };
+  }
+
+  if (requireNumber && !/[0-9]/.test(password)) {
+    return {
+      isValid: false,
+      error: 'Password must contain at least one number',
+    };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Validate password confirmation
+ */
+export const validatePasswordConfirmation = (
+  password: string,
+  confirmPassword: string
+): ValidationResult => {
+  if (!confirmPassword) {
+    return { isValid: false, error: 'Please confirm your password' };
+  }
+
+  if (password !== confirmPassword) {
+    return { isValid: false, error: 'Passwords do not match' };
+  }
+
+  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');
+};
+
+/**
+ * Validate weight (kg)
+ */
+export const validateWeight = (weight: number): ValidationResult => {
+  return validateNumberRange(weight, 20, 300, 'Weight');
+};
+
+/**
+ * Validate height (cm)
+ */
+export const validateHeight = (height: number): ValidationResult => {
+  return validateNumberRange(height, 50, 250, 'Height');
+};
+
+/**
+ * Validate calories
+ */
+export const validateCalories = (calories: number): ValidationResult => {
+  return validateNumberRange(calories, 0, 10000, 'Calories');
+};
+
+/**
+ * Validate macros (protein, carbs, fat in grams)
+ */
+export const validateMacros = (
+  grams: number,
+  macroType: string
+): ValidationResult => {
+  return validateNumberRange(grams, 0, 1000, macroType);
+};
+
+/**
+ * Validate water intake (glasses)
+ */
+export const validateWaterIntake = (glasses: number): ValidationResult => {
+  return validateNumberRange(glasses, 0, 50, 'Water intake');
+};
+
+/**
+ * Validate workout duration (minutes)
+ */
+export const validateWorkoutDuration = (minutes: number): ValidationResult => {
+  return validateNumberRange(minutes, 1, 600, 'Workout duration');
+};
+
+/**
+ * Validate reps
+ */
+export const validateReps = (reps: number): ValidationResult => {
+  return validateNumberRange(reps, 1, 1000, 'Reps');
+};
+
+/**
+ * Validate sets
+ */
+export const validateSets = (sets: number): ValidationResult => {
+  return validateNumberRange(sets, 1, 100, 'Sets');
+};
+
+/**
+ * Validate exercise weight (kg)
+ */
+export const validateExerciseWeight = (weight: number): ValidationResult => {
+  return validateNumberRange(weight, 0, 1000, 'Weight');
+};
+
+/**
+ * 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 };
+};
+