@umituz/react-native-image 1.3.17 → 1.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-image",
-  "version": "1.3.17",
+  "version": "1.3.18",
   "description": "Image manipulation and viewing for React Native apps - resize, crop, rotate, flip, compress, gallery viewer",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/entities/ValidationResult.ts

@@ -0,0 +1,15 @@
+/**
+ * Validation Result Interface
+ * Represents the outcome of a validation operation
+ */
+export interface ValidationResult {
+  /**
+   * Whether the validation passed
+   */
+  isValid: boolean;
+
+  /**
+   * Error message if validation failed
+   */
+  error?: string;
+}

package/src/index.ts

@@ -97,3 +97,27 @@ export { useImageEnhance } from './presentation/hooks/useImageEnhance';
 export { useImageMetadata } from './presentation/hooks/useImageMetadata';
 
 
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Validation
+// =============================================================================
+
+export type { ValidationResult } from './domain/entities/ValidationResult';
+export {
+  getFileExtension,
+  getMimeTypeFromExtension,
+  getMimeTypeFromDataUrl,
+  validateImageMimeType,
+  validateImageExtension,
+  validateImageDataUrl,
+} from './infrastructure/utils/validation/mime-type-validator';
+export {
+  validateImageUri,
+  getImageMimeType,
+} from './infrastructure/utils/validation/image-validator';
+export {
+  IMAGE_MIME_TYPES,
+  SUPPORTED_IMAGE_MIME_TYPES,
+  EXTENSION_TO_MIME_TYPE,
+  MIME_TYPE_TO_EXTENSION,
+} from './infrastructure/utils/validation/mime-types.constants';

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

@@ -0,0 +1,77 @@
+/**
+ * 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/validation/mime-type-validator.ts

@@ -0,0 +1,101 @@
+/**
+ * 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/validation/mime-types.constants.ts

@@ -0,0 +1,41 @@
+/**
+ * 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',
+};