@umituz/react-native-validation 1.2.0 → 1.3.1

package/README.md

@@ -39,6 +39,8 @@ npm install @umituz/react-native-validation
 
 ### General
 - ✅ TypeScript type safety
+- ✅ Image file validation (prevents zip, exe, etc.)
+- ✅ MIME type validation
 
 ## Usage
 
@@ -141,6 +143,38 @@ const isDangerous = containsDangerousChars('<script>alert("xss")</script>');
 const isValidLength = isWithinLengthLimit('text', SECURITY_LIMITS.NAME_MAX_LENGTH);
 ```
 
+### Image Validation Example
+
+```typescript
+import {
+  validateImageUri,
+  getImageMimeType,
+  validateImageExtension,
+  IMAGE_MIME_TYPES,
+} from '@umituz/react-native-validation';
+
+// Validate image URI (supports file://, http://, https://, and data: URLs)
+const result = validateImageUri('file:///path/to/image.jpg');
+if (!result.isValid) {
+  console.error(result.error);
+}
+
+// Get MIME type from URI
+const mimeType = getImageMimeType('file:///path/to/image.png');
+// Result: 'image/png'
+
+// Validate file extension
+const extensionResult = validateImageExtension('image.jpg');
+if (!extensionResult.isValid) {
+  console.error(extensionResult.error);
+}
+
+// Use MIME type constants
+if (mimeType === IMAGE_MIME_TYPES.PNG) {
+  console.log('PNG image');
+}
+```
+
 ## API Reference
 
 ### Core Validators
@@ -168,6 +202,23 @@ const isValidLength = isWithinLengthLimit('text', SECURITY_LIMITS.NAME_MAX_LENGT
 - `validateDateOfBirth(date: Date): ValidationResult`
 - `validateAge(age: number): ValidationResult` (13-120 years)
 
+### Image Validators
+
+- `validateImageUri(uri: string, fieldName?: string): ValidationResult` - Validates image URI (supports file://, http://, https://, and data: URLs)
+- `validateImageMimeType(mimeType: string, fieldName?: string): ValidationResult` - Validates MIME type is supported image type
+- `validateImageExtension(uri: string, fieldName?: string): ValidationResult` - Validates file extension is supported image type
+- `validateImageDataUrl(dataUrl: string, fieldName?: string): ValidationResult` - Validates data URL is image type
+- `getImageMimeType(uri: string): string | null` - Get MIME type from URI (supports all URI types)
+
+### MIME Type Utilities
+
+- `getMimeTypeFromExtension(uri: string): string | null` - Get MIME type from file extension
+- `getMimeTypeFromDataUrl(dataUrl: string): string | null` - Get MIME type from data URL
+- `IMAGE_MIME_TYPES` - Supported image MIME types constants
+- `SUPPORTED_IMAGE_MIME_TYPES` - Array of supported image MIME types
+- `EXTENSION_TO_MIME_TYPE` - File extension to MIME type mapping
+- `MIME_TYPE_TO_EXTENSION` - MIME type to file extension mapping
+
 ### Batch Validation
 
 - `batchValidate(validations: Array<{ field: string; validator: () => ValidationResult }>): { isValid: boolean; errors: Record<string, string> }`

package/package.json

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

package/src/index.ts

@@ -40,3 +40,23 @@ export {
   isWithinLengthLimit,
 } from './infrastructure/utils/sanitization';
 
+// Infrastructure Layer - MIME Type Validation
+export {
+  IMAGE_MIME_TYPES,
+  SUPPORTED_IMAGE_MIME_TYPES,
+  EXTENSION_TO_MIME_TYPE,
+  MIME_TYPE_TO_EXTENSION,
+} from './infrastructure/utils/mime-types.constants';
+
+export {
+  getFileExtension,
+  getMimeTypeFromExtension,
+  getMimeTypeFromDataUrl,
+  validateImageMimeType,
+  validateImageExtension,
+  validateImageDataUrl,
+} from './infrastructure/utils/mime-type-validator';
+
+// Infrastructure Layer - Image Validation
+export { validateImageUri, getImageMimeType } from './infrastructure/utils/image-validator';
+

package/src/infrastructure/utils/image-validator.ts

@@ -0,0 +1,78 @@
+/**
+ * Image Validator
+ * Single Responsibility: Validate image files and URIs
+ */
+
+import type { ValidationResult } from '../../domain/entities/ValidationResult';
+import {
+  validateImageExtension,
+  validateImageDataUrl,
+  getMimeTypeFromExtension,
+  getMimeTypeFromDataUrl,
+} from './mime-type-validator';
+
+/**
+ * Check if URI is a local file path
+ */
+function isLocalFileUrl(uri: string): boolean {
+  return uri.startsWith('file://');
+}
+
+/**
+ * Check if URI is a public URL
+ */
+function isPublicUrl(uri: string): boolean {
+  return uri.startsWith('http://') || uri.startsWith('https://');
+}
+
+/**
+ * Check if URI is a data URL
+ */
+function isDataUrl(uri: string): boolean {
+  return uri.startsWith('data:');
+}
+
+/**
+ * Validate image URI (supports file://, http://, https://, and data: URLs)
+ */
+export function validateImageUri(
+  uri: string,
+  fieldName: string = 'Image'
+): ValidationResult {
+  if (!uri || uri.trim() === '') {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  // Validate public URLs (assume they're images if they have image extension)
+  if (isPublicUrl(uri)) {
+    return validateImageExtension(uri, fieldName);
+  }
+
+  // Validate data URLs
+  if (isDataUrl(uri)) {
+    return validateImageDataUrl(uri, fieldName);
+  }
+
+  // Validate local file URLs
+  if (isLocalFileUrl(uri)) {
+    return validateImageExtension(uri, fieldName);
+  }
+
+  // Unknown format
+  return {
+    isValid: false,
+    error: `${fieldName} must be a valid image URL or file path`,
+  };
+}
+
+/**
+ * Get MIME type from URI (supports all URI types)
+ */
+export function getImageMimeType(uri: string): string | null {
+  if (isDataUrl(uri)) {
+    return getMimeTypeFromDataUrl(uri);
+  }
+
+  return getMimeTypeFromExtension(uri);
+}
+

package/src/infrastructure/utils/mime-type-validator.ts

@@ -0,0 +1,102 @@
+/**
+ * MIME Type Validator
+ * Single Responsibility: Validate MIME types
+ */
+
+import type { ValidationResult } from '../../domain/entities/ValidationResult';
+import {
+  SUPPORTED_IMAGE_MIME_TYPES,
+  EXTENSION_TO_MIME_TYPE,
+} from './mime-types.constants';
+
+/**
+ * Get file extension from URI
+ */
+export function getFileExtension(uri: string): string | null {
+  const match = uri.match(/\.([a-z0-9]+)(?:\?|$)/i);
+  return match ? match[1].toLowerCase() : null;
+}
+
+/**
+ * Get MIME type from file extension
+ */
+export function getMimeTypeFromExtension(uri: string): string | null {
+  const extension = getFileExtension(uri);
+  if (!extension) {
+    return null;
+  }
+  return EXTENSION_TO_MIME_TYPE[extension] || null;
+}
+
+/**
+ * Get MIME type from data URL
+ */
+export function getMimeTypeFromDataUrl(dataUrl: string): string | null {
+  const match = dataUrl.match(/^data:([^;]+);/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Validate MIME type is supported image type
+ */
+export function validateImageMimeType(
+  mimeType: string,
+  fieldName: string = 'File'
+): ValidationResult {
+  if (!mimeType) {
+    return { isValid: false, error: `${fieldName} MIME type is required` };
+  }
+
+  if (!SUPPORTED_IMAGE_MIME_TYPES.includes(mimeType as any)) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be an image (JPEG, PNG, WEBP, or GIF)`,
+    };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validate file extension is supported image type
+ */
+export function validateImageExtension(
+  uri: string,
+  fieldName: string = 'File'
+): ValidationResult {
+  const mimeType = getMimeTypeFromExtension(uri);
+  if (!mimeType) {
+    return {
+      isValid: false,
+      error: `${fieldName} must have a valid image extension (jpg, jpeg, png, webp, gif)`,
+    };
+  }
+
+  return validateImageMimeType(mimeType, fieldName);
+}
+
+/**
+ * Validate data URL is image type
+ */
+export function validateImageDataUrl(
+  dataUrl: string,
+  fieldName: string = 'File'
+): ValidationResult {
+  if (!dataUrl || !dataUrl.startsWith('data:')) {
+    return {
+      isValid: false,
+      error: `${fieldName} must be a valid data URL`,
+    };
+  }
+
+  const mimeType = getMimeTypeFromDataUrl(dataUrl);
+  if (!mimeType) {
+    return {
+      isValid: false,
+      error: `${fieldName} must have a valid MIME type`,
+    };
+  }
+
+  return validateImageMimeType(mimeType, fieldName);
+}
+

package/src/infrastructure/utils/mime-types.constants.ts

@@ -0,0 +1,42 @@
+/**
+ * MIME Type Constants
+ * Single Responsibility: Define supported MIME types for validation
+ */
+
+/**
+ * Supported image MIME types
+ */
+export const IMAGE_MIME_TYPES = {
+  JPEG: 'image/jpeg',
+  JPG: 'image/jpeg',
+  PNG: 'image/png',
+  WEBP: 'image/webp',
+  GIF: 'image/gif',
+} as const;
+
+/**
+ * All supported image MIME types as array
+ */
+export const SUPPORTED_IMAGE_MIME_TYPES = Object.values(IMAGE_MIME_TYPES);
+
+/**
+ * File extension to MIME type mapping
+ */
+export const EXTENSION_TO_MIME_TYPE: Record<string, string> = {
+  jpg: IMAGE_MIME_TYPES.JPEG,
+  jpeg: IMAGE_MIME_TYPES.JPEG,
+  png: IMAGE_MIME_TYPES.PNG,
+  webp: IMAGE_MIME_TYPES.WEBP,
+  gif: IMAGE_MIME_TYPES.GIF,
+};
+
+/**
+ * MIME type to file extension mapping
+ */
+export const MIME_TYPE_TO_EXTENSION: Record<string, string> = {
+  [IMAGE_MIME_TYPES.JPEG]: 'jpg',
+  [IMAGE_MIME_TYPES.PNG]: 'png',
+  [IMAGE_MIME_TYPES.WEBP]: 'webp',
+  [IMAGE_MIME_TYPES.GIF]: 'gif',
+};
+