@umituz/react-native-image 1.3.13 → 1.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-image",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "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/EditorTypes.ts

@@ -1,180 +1,23 @@
 /**
- * Domain - Advanced Editor Types
+ * Domain - Editor Types (Main Export)
+ *
+ * Central export point for all editor-related types
  */
 
-export enum EditorTool {
-  MOVE = 'move',
-  BRUSH = 'brush',
-  ERASER = 'eraser',
-  TEXT = 'text',
-  SHAPE = 'shape',
-  CROP = 'crop',
-  FILTER = 'filter',
-  STICKER = 'sticker',
-  SELECT = 'select',
-}
+// Tools
+export * from './editor/EditorToolTypes';
 
-export enum ShapeType {
-  RECTANGLE = 'rectangle',
-  CIRCLE = 'circle',
-  LINE = 'line',
-  ARROW = 'arrow',
-  TRIANGLE = 'triangle',
-  STAR = 'star',
-  HEART = 'heart',
-}
+// Elements
+export * from './editor/EditorElementTypes';
 
-export enum BrushStyle {
-  NORMAL = 'normal',
-  MARKER = 'marker',
-  SPRAY = 'spray',
-  PENCIL = 'pencil',
-  CALIGRAPHY = 'caligraphy',
-}
+// Layers & History
+export * from './editor/EditorLayerTypes';
 
-export interface EditorPoint {
-  x: number;
-  y: number;
-}
+// State
+export * from './editor/EditorStateTypes';
 
-export interface EditorDimensions {
-  width: number;
-  height: number;
-}
+// Configuration
+export * from './editor/EditorConfigTypes';
 
-export interface EditorStroke {
-  points: EditorPoint[];
-  color: string;
-  size: number;
-  style: BrushStyle;
-  opacity: number;
-}
-
-export interface EditorShape {
-  type: ShapeType;
-  startPoint: EditorPoint;
-  endPoint: EditorPoint;
-  color: string;
-  strokeWidth: number;
-  fillColor?: string;
-  opacity: number;
-  rotation?: number;
-}
-
-export interface EditorText {
-  id: string;
-  text: string;
-  position: EditorPoint;
-  fontSize: number;
-  fontFamily: string;
-  color: string;
-  backgroundColor?: string;
-  rotation: number;
-  opacity: number;
-  maxWidth?: number;
-  textAlign: 'left' | 'center' | 'right';
-  fontWeight: 'normal' | 'bold';
-  fontStyle: 'normal' | 'italic';
-}
-
-export interface EditorSticker {
-  id: string;
-  uri: string;
-  position: EditorPoint;
-  size: EditorDimensions;
-  rotation: number;
-  opacity: number;
-  scale: number;
-}
-
-export interface EditorLayer {
-  id: string;
-  name: string;
-  visible: boolean;
-  opacity: number;
-  locked: boolean;
-  elements: Array<{
-    type: 'stroke' | 'shape' | 'text' | 'sticker';
-    data: EditorStroke | EditorShape | EditorText | EditorSticker;
-  }>;
-}
-
-export interface EditorSelection {
-  bounds: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  elements: string[];
-}
-
-export interface EditorHistory {
-  id: string;
-  timestamp: Date;
-  layers: EditorLayer[];
-  thumbnail?: string;
-}
-
-export interface EditorCropArea {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  aspectRatio?: number;
-}
-
-export interface EditorFilter {
-  type: string;
-  intensity: number;
-  preview?: string;
-}
-
-export interface EditorState {
-  originalUri: string;
-  currentUri?: string;
-  tool: EditorTool;
-  selectedLayer?: string;
-  layers: EditorLayer[];
-  history: EditorHistory[];
-  historyIndex: number;
-  selection?: EditorSelection;
-  cropArea?: EditorCropArea;
-  activeFilter?: EditorFilter;
-  isDirty: boolean;
-  dimensions: EditorDimensions;
-  zoom: number;
-  pan: EditorPoint;
-}
-
-export interface EditorOptions {
-  maxLayers?: number;
-  maxHistory?: number;
-  enableUndo?: boolean;
-  enableRedo?: boolean;
-  enableFilters?: boolean;
-  enableShapes?: boolean;
-  enableText?: boolean;
-  enableStickers?: boolean;
-  enableCrop?: boolean;
-  brushSizeRange?: [number, number];
-  strokeWidthRange?: [number, number];
-  fontSizeRange?: [number, number];
-  defaultColors?: string[];
-  stickerPacks?: string[];
-  customFonts?: string[];
-}
-
-export interface EditorEvent {
-  type: 'toolChange' | 'layerAdd' | 'layerRemove' | 'layerUpdate' | 'selectionChange' | 'historyChange';
-  data: any;
-}
-
-export interface EditorExportOptions {
-  format: 'jpeg' | 'png' | 'webp';
-  quality: number;
-  backgroundColor?: string;
-  includeHiddenLayers?: boolean;
-  flattenLayers?: boolean;
-  maxSize?: number;
-}
+// Filters
+export * from './editor/EditorFilterTypes';

package/src/domain/entities/editor/EditorConfigTypes.ts

@@ -0,0 +1,35 @@
+/**
+ * Domain - Editor Configuration Types
+ */
+
+export interface EditorOptions {
+  maxLayers?: number;
+  maxHistory?: number;
+  enableUndo?: boolean;
+  enableRedo?: boolean;
+  enableFilters?: boolean;
+  enableShapes?: boolean;
+  enableText?: boolean;
+  enableStickers?: boolean;
+  enableCrop?: boolean;
+  brushSizeRange?: [number, number];
+  strokeWidthRange?: [number, number];
+  fontSizeRange?: [number, number];
+  defaultColors?: string[];
+  stickerPacks?: string[];
+  customFonts?: string[];
+}
+
+export interface EditorExportOptions {
+  format: 'jpeg' | 'png' | 'webp';
+  quality: number;
+  backgroundColor?: string;
+  includeHiddenLayers?: boolean;
+  flattenLayers?: boolean;
+  maxSize?: number;
+}
+
+export interface EditorEvent {
+  type: 'toolChange' | 'layerAdd' | 'layerRemove' | 'layerUpdate' | 'selectionChange' | 'historyChange';
+  data: unknown;
+}

package/src/domain/entities/editor/EditorElementTypes.ts

@@ -0,0 +1,60 @@
+/**
+ * Domain - Editor Element Types
+ */
+
+import type { ShapeType } from './EditorToolTypes';
+
+export interface EditorPoint {
+  x: number;
+  y: number;
+}
+
+export interface EditorDimensions {
+  width: number;
+  height: number;
+}
+
+export interface EditorStroke {
+  points: EditorPoint[];
+  color: string;
+  size: number;
+  style: string;
+  opacity: number;
+}
+
+export interface EditorShape {
+  type: ShapeType;
+  startPoint: EditorPoint;
+  endPoint: EditorPoint;
+  color: string;
+  strokeWidth: number;
+  fillColor?: string;
+  opacity: number;
+  rotation?: number;
+}
+
+export interface EditorText {
+  id: string;
+  text: string;
+  position: EditorPoint;
+  fontSize: number;
+  fontFamily: string;
+  color: string;
+  backgroundColor?: string;
+  rotation: number;
+  opacity: number;
+  maxWidth?: number;
+  textAlign: 'left' | 'center' | 'right';
+  fontWeight: 'normal' | 'bold';
+  fontStyle: 'normal' | 'italic';
+}
+
+export interface EditorSticker {
+  id: string;
+  uri: string;
+  position: EditorPoint;
+  size: EditorDimensions;
+  rotation: number;
+  opacity: number;
+  scale: number;
+}

package/src/domain/entities/editor/EditorFilterTypes.ts

@@ -0,0 +1,9 @@
+/**
+ * Domain - Editor Filter Types
+ */
+
+export interface EditorFilter {
+  type: string;
+  intensity: number;
+  preview?: string;
+}

package/src/domain/entities/editor/EditorLayerTypes.ts

@@ -0,0 +1,34 @@
+/**
+ * Domain - Editor Layer Types
+ */
+
+import type { EditorStroke, EditorShape, EditorText, EditorSticker } from './EditorElementTypes';
+
+export interface EditorLayer {
+  id: string;
+  name: string;
+  visible: boolean;
+  opacity: number;
+  locked: boolean;
+  elements: Array<{
+    type: 'stroke' | 'shape' | 'text' | 'sticker';
+    data: EditorStroke | EditorShape | EditorText | EditorSticker;
+  }>;
+}
+
+export interface EditorHistory {
+  id: string;
+  timestamp: Date;
+  layers: EditorLayer[];
+  thumbnail?: string;
+}
+
+export interface EditorSelection {
+  bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  elements: string[];
+}

package/src/domain/entities/editor/EditorStateTypes.ts

@@ -0,0 +1,35 @@
+/**
+ * Domain - Editor State Types
+ */
+
+import type { EditorTool } from './EditorToolTypes';
+import type { EditorLayer } from './EditorLayerTypes';
+import type { EditorSelection } from './EditorLayerTypes';
+import type { EditorHistory } from './EditorLayerTypes';
+import type { EditorPoint, EditorDimensions } from './EditorElementTypes';
+import type { EditorFilter } from './EditorFilterTypes';
+
+export interface EditorCropArea {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  aspectRatio?: number;
+}
+
+export interface EditorState {
+  originalUri: string;
+  currentUri?: string;
+  tool: EditorTool;
+  selectedLayer?: string;
+  layers: EditorLayer[];
+  history: EditorHistory[];
+  historyIndex: number;
+  selection?: EditorSelection;
+  cropArea?: EditorCropArea;
+  activeFilter?: EditorFilter;
+  isDirty: boolean;
+  dimensions: EditorDimensions;
+  zoom: number;
+  pan: EditorPoint;
+}

package/src/domain/entities/editor/EditorToolTypes.ts

@@ -0,0 +1,33 @@
+/**
+ * Domain - Editor Tool Types
+ */
+
+export enum EditorTool {
+  MOVE = 'move',
+  BRUSH = 'brush',
+  ERASER = 'eraser',
+  TEXT = 'text',
+  SHAPE = 'shape',
+  CROP = 'crop',
+  FILTER = 'filter',
+  STICKER = 'sticker',
+  SELECT = 'select',
+}
+
+export enum ShapeType {
+  RECTANGLE = 'rectangle',
+  CIRCLE = 'circle',
+  LINE = 'line',
+  ARROW = 'arrow',
+  TRIANGLE = 'triangle',
+  STAR = 'star',
+  HEART = 'heart',
+}
+
+export enum BrushStyle {
+  NORMAL = 'normal',
+  MARKER = 'marker',
+  SPRAY = 'spray',
+  PENCIL = 'pencil',
+  CALIGRAPHY = 'caligraphy',
+}

package/src/infrastructure/services/ImageBatchService.ts

@@ -1,14 +1,11 @@
 /**
  * Image Infrastructure - Batch Processing Service
- * 
+ *
  * Handles processing multiple images concurrently with progress tracking
  */
 
 import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
-import { ImageTransformService } from './ImageTransformService';
-import { ImageConversionService } from './ImageConversionService';
-import { ImageValidator } from '../utils/ImageValidator';
-import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+import { BatchProcessor } from '../utils/BatchProcessor';
 
 export interface BatchProcessingOptions {
   concurrency?: number;
@@ -33,74 +30,11 @@ export interface BatchProcessingResult {
 export interface BatchOperation {
   uri: string;
   type: 'resize' | 'crop' | 'filter' | 'compress' | 'convert';
-  params: any;
-  options?: any;
+  params: Record<string, unknown>;
+  options?: Record<string, unknown>;
 }
 
 export class ImageBatchService {
-  private static async processBatchItem(
-    operation: BatchOperation,
-    options: BatchProcessingOptions = {}
-  ): Promise<{ uri: string; result: ImageManipulationResult | null; error?: Error }> {
-    try {
-      const uriValidation = ImageValidator.validateUri(operation.uri);
-      if (!uriValidation.isValid) {
-        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'batchProcess');
-      }
-
-      let result: ImageManipulationResult;
-
-      switch (operation.type) {
-        case 'resize':
-          result = await ImageTransformService.resize(
-            operation.uri,
-            operation.params.width,
-            operation.params.height,
-            operation.options
-          );
-          break;
-
-        case 'crop':
-          result = await ImageTransformService.crop(
-            operation.uri,
-            operation.params,
-            operation.options
-          );
-          break;
-
-        case 'compress':
-          result = await ImageConversionService.compress(
-            operation.uri,
-            operation.params.quality
-          );
-          break;
-
-        case 'convert':
-          result = await ImageConversionService.convertFormat(
-            operation.uri,
-            operation.params.format,
-            operation.params.quality
-          );
-          break;
-
-        default:
-          throw ImageErrorHandler.createError(
-            `Unknown operation type: ${operation.type}`,
-            IMAGE_ERROR_CODES.VALIDATION_ERROR,
-            'batchProcess'
-          );
-      }
-
-      return { uri: operation.uri, result };
-    } catch (error) {
-      return { 
-        uri: operation.uri, 
-        result: null, 
-        error: error instanceof Error ? error : new Error('Unknown error')
-      };
-    }
-  }
-
   static async processBatch(
     operations: BatchOperation[],
     options: BatchProcessingOptions = {}
@@ -115,15 +49,15 @@ export class ImageBatchService {
     // Process operations in chunks based on concurrency
     for (let i = 0; i < operations.length; i += concurrency) {
       const chunk = operations.slice(i, i + concurrency);
-      
+
       const chunkResults = await Promise.all(
-        chunk.map(operation => this.processBatchItem(operation, options))
+        chunk.map(operation => BatchProcessor.processBatchItem(operation, options))
       );
 
       // Process results
       for (const result of chunkResults) {
         completed++;
-        
+
         options.onProgress?.(completed, total, result.uri);
 
         if (result.error) {
@@ -148,7 +82,7 @@ export class ImageBatchService {
     uris: string[],
     width?: number,
     height?: number,
-    options: BatchProcessingOptions & { saveOptions?: any } = {}
+    options: BatchProcessingOptions & { saveOptions?: Record<string, unknown> } = {}
   ): Promise<BatchProcessingResult> {
     const operations: BatchOperation[] = uris.map(uri => ({
       uri,
@@ -162,7 +96,7 @@ export class ImageBatchService {
 
   static async compressBatch(
     uris: string[],
-    quality: number = 0.8,
+    quality = 0.8,
     options: BatchProcessingOptions = {}
   ): Promise<BatchProcessingResult> {
     const operations: BatchOperation[] = uris.map(uri => ({

package/src/infrastructure/services/ImageMetadataService.ts

@@ -1,12 +1,13 @@
 /**
  * Image Infrastructure - Metadata Service
- * 
+ *
  * Extracts and manages image metadata including EXIF data
  */
 
 import type { ImageMetadataExtended } from '../../domain/entities/ImageFilterTypes';
 import { ImageValidator } from '../utils/ImageValidator';
 import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+import { MetadataExtractor } from '../utils/MetadataExtractor';
 
 export interface ImageMetadataExtractionOptions {
   includeExif?: boolean;
@@ -15,78 +16,6 @@ export interface ImageMetadataExtractionOptions {
 }
 
 export class ImageMetadataService {
-  private static async getImageDimensions(uri: string): Promise<{ width: number; height: number }> {
-    try {
-      // In a real implementation, we would use:
-      // - expo-image-manipulator for basic dimensions
-      // - react-native-image-picker for metadata
-      // - react-native-exif-reader for EXIF data
-      
-      // Mock implementation
-      return {
-        width: Math.floor(Math.random() * 2000) + 100,
-        height: Math.floor(Math.random() * 2000) + 100,
-      };
-    } catch (error) {
-      throw ImageErrorHandler.handleUnknownError(error, 'getDimensions');
-    }
-  }
-
-  private static async getFileSize(uri: string): Promise<number> {
-    try {
-      // In real implementation, use expo-file-system or similar
-      return Math.floor(Math.random() * 5000000) + 10000; // Random size between 10KB-5MB
-    } catch (error) {
-      throw ImageErrorHandler.handleUnknownError(error, 'getFileSize');
-    }
-  }
-
-  private static async extractExifData(uri: string): Promise<any> {
-    try {
-      // Mock EXIF data extraction
-      return {
-        DateTimeOriginal: new Date().toISOString(),
-        Make: 'Mock Camera',
-        Model: 'Mock Phone',
-        ISO: Math.floor(Math.random() * 1600) + 100,
-        FocalLength: Math.random() * 50 + 10,
-        Flash: Math.random() > 0.5,
-        ExposureTime: `1/${Math.floor(Math.random() * 1000) + 100}`,
-        FNumber: Math.random() * 8 + 1.4,
-      };
-    } catch (error) {
-      return null;
-    }
-  }
-
-  private static async extractGPSData(uri: string): Promise<{ latitude: number; longitude: number } | null> {
-    try {
-      // Mock GPS data extraction
-      return Math.random() > 0.7 ? {
-        latitude: Math.random() * 180 - 90,
-        longitude: Math.random() * 360 - 180,
-      } : null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  private static detectFormat(uri: string): string {
-    const extension = uri.toLowerCase().split('.').pop();
-    switch (extension) {
-      case 'jpg':
-      case 'jpeg':
-        return 'JPEG';
-      case 'png':
-        return 'PNG';
-      case 'webp':
-        return 'WebP';
-      case 'gif':
-        return 'GIF';
-      default:
-        return 'Unknown';
-    }
-  }
 
   static async extractMetadata(
     uri: string,
@@ -105,23 +34,23 @@ export class ImageMetadataService {
       } = options;
 
       // Get basic image info
-      const dimensions = await ImageMetadataService.getImageDimensions(uri);
-      const size = await ImageMetadataService.getFileSize(uri);
-      const format = ImageMetadataService.detectFormat(uri);
+      const dimensions = await MetadataExtractor.getImageDimensions(uri);
+      const size = await MetadataExtractor.getFileSize(uri);
+      const format = MetadataExtractor.detectFormat(uri);
 
       // Build metadata object
       const metadata: ImageMetadataExtended = {
         format,
         size,
         dimensions,
-        colorSpace: 'sRGB', // Default assumption
+        colorSpace: 'sRGB',
         hasAlpha: format === 'PNG' || format === 'WebP',
         orientation: 1,
       };
 
       // Extract EXIF data if requested
       if (includeExif) {
-        const exifData = await ImageMetadataService.extractExifData(uri);
+        const exifData = await MetadataExtractor.extractExifData(uri);
         if (exifData) {
           metadata.creationDate = exifData.DateTimeOriginal ? new Date(exifData.DateTimeOriginal) : undefined;
           metadata.modificationDate = new Date();
@@ -140,7 +69,7 @@ export class ImageMetadataService {
 
       // Extract GPS data if requested
       if (includeGPS) {
-        const gps = await ImageMetadataService.extractGPSData(uri);
+        const gps = await MetadataExtractor.extractGPSData(uri);
         metadata.gps = gps || undefined;
       }
 
@@ -161,9 +90,9 @@ export class ImageMetadataService {
         throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'getBasicInfo');
       }
 
-      const dimensions = await ImageMetadataService.getImageDimensions(uri);
-      const size = await ImageMetadataService.getFileSize(uri);
-      const format = ImageMetadataService.detectFormat(uri);
+      const dimensions = await MetadataExtractor.getImageDimensions(uri);
+      const size = await MetadataExtractor.getFileSize(uri);
+      const format = MetadataExtractor.detectFormat(uri);
 
       return {
         format,
@@ -177,8 +106,8 @@ export class ImageMetadataService {
 
   static async hasMetadata(uri: string): Promise<boolean> {
     try {
-      const exifData = await ImageMetadataService.extractExifData(uri);
-      const gpsData = await ImageMetadataService.extractGPSData(uri);
+      const exifData = await MetadataExtractor.extractExifData(uri);
+      const gpsData = await MetadataExtractor.extractGPSData(uri);
       return !!(exifData || gpsData);
     } catch {
       return false;

package/src/infrastructure/utils/BatchProcessor.ts

@@ -0,0 +1,95 @@
+/**
+ * Image Infrastructure - Batch Processor Utilities
+ *
+ * Helper functions for batch processing operations
+ */
+
+import type { ImageManipulationResult, ImageCropArea, SaveFormat } from '../../domain/entities/ImageTypes';
+import type { BatchOperation, BatchProcessingOptions } from '../services/ImageBatchService';
+import { ImageTransformService } from '../services/ImageTransformService';
+import { ImageConversionService } from '../services/ImageConversionService';
+import { ImageValidator } from './ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from './ImageErrorHandler';
+
+export class BatchProcessor {
+  static async processBatchItem(
+    operation: BatchOperation,
+    options: BatchProcessingOptions = {}
+  ): Promise<{ uri: string; result: ImageManipulationResult | null; error?: Error }> {
+    try {
+      const uriValidation = ImageValidator.validateUri(operation.uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'batchProcess');
+      }
+
+      let result: ImageManipulationResult;
+
+      switch (operation.type) {
+        case 'resize':
+          result = await ImageTransformService.resize(
+            operation.uri,
+            operation.params.width as number | undefined,
+            operation.params.height as number | undefined,
+            operation.options
+          );
+          break;
+
+        case 'crop':
+          result = await ImageTransformService.crop(
+            operation.uri,
+            operation.params as unknown as ImageCropArea,
+            operation.options
+          );
+          break;
+
+        case 'compress':
+          result = await ImageConversionService.compress(
+            operation.uri,
+            operation.params.quality as number
+          );
+          break;
+
+        case 'convert':
+          result = await ImageConversionService.convertFormat(
+            operation.uri,
+            operation.params.format as SaveFormat,
+            operation.params.quality as number
+          );
+          break;
+
+        default:
+          throw ImageErrorHandler.createError(
+            `Unknown operation type: ${operation.type}`,
+            IMAGE_ERROR_CODES.VALIDATION_ERROR,
+            'batchProcess'
+          );
+      }
+
+      return { uri: operation.uri, result };
+    } catch (error) {
+      return {
+        uri: operation.uri,
+        result: null,
+        error: error instanceof Error ? error : new Error('Unknown error')
+      };
+    }
+  }
+
+  static async processBatchInChunks<T>(
+    items: T[],
+    processor: (item: T) => Promise<unknown>,
+    concurrency: number,
+    onProgress?: (completed: number, total: number) => void
+  ): Promise<void> {
+    let completed = 0;
+    const total = items.length;
+
+    for (let i = 0; i < items.length; i += concurrency) {
+      const chunk = items.slice(i, i + concurrency);
+      await Promise.all(chunk.map(processor));
+      completed += chunk.length;
+      onProgress?.(completed, total);
+    }
+  }
+}
+

package/src/infrastructure/utils/ImageFilterUtils.ts

@@ -1,152 +1,21 @@
 /**
  * Infrastructure - Filter Utils
- * 
- * Low-level filter implementations for raw pixel data
+ *
+ * Legacy wrapper for backward compatibility. Use specific filter classes directly.
  */
 
-export class ImageFilterUtils {
-  static applyBrightness(
-    data: Uint8ClampedArray,
-    brightness: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(data);
-    const adjustment = brightness * 2.55;
-
-    for (let i = 0; i < result.length; i += 4) {
-      result[i] = Math.min(255, Math.max(0, result[i] + adjustment));
-      result[i + 1] = Math.min(255, Math.max(0, result[i + 1] + adjustment));
-      result[i + 2] = Math.min(255, Math.max(0, result[i + 2] + adjustment));
-    }
-
-    return result;
-  }
-
-  static applyContrast(
-    data: Uint8ClampedArray,
-    contrast: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(data);
-    const factor = (259 * (contrast * 2.55 + 255)) / (255 * (259 - contrast * 2.55));
-
-    for (let i = 0; i < result.length; i += 4) {
-      result[i] = Math.min(255, Math.max(0, factor * (result[i] - 128) + 128));
-      result[i + 1] = Math.min(255, Math.max(0, factor * (result[i + 1] - 128) + 128));
-      result[i + 2] = Math.min(255, Math.max(0, factor * (result[i + 2] - 128) + 128));
-    }
-
-    return result;
-  }
-
-  static applySaturation(
-    data: Uint8ClampedArray,
-    saturation: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(data);
-    const adjustment = 1 + (saturation / 100);
-
-    for (let i = 0; i < result.length; i += 4) {
-      const r = result[i];
-      const g = result[i + 1];
-      const b = result[i + 2];
-
-      const gray = 0.299 * r + 0.587 * g + 0.114 * b;
-
-      result[i] = Math.min(255, Math.max(0, gray + adjustment * (r - gray)));
-      result[i + 1] = Math.min(255, Math.max(0, gray + adjustment * (g - gray)));
-      result[i + 2] = Math.min(255, Math.max(0, gray + adjustment * (b - gray)));
-    }
-
-    return result;
-  }
-
-  static applyVintage(
-    data: Uint8ClampedArray,
-    intensity: number,
-    warmth: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(data);
-    const factor = intensity / 100;
-    const warmFactor = warmth / 100;
-
-    for (let i = 0; i < result.length; i += 4) {
-      let r = result[i];
-      let g = result[i + 1];
-      let b = result[i + 2];
-
-      const tr = 0.393 * r + 0.769 * g + 0.189 * b;
-      const tg = 0.349 * r + 0.686 * g + 0.168 * b;
-      const tb = 0.272 * r + 0.534 * g + 0.131 * b;
+import { BasicFilters } from './filters/BasicFilters';
+import { SpecialFilters } from './filters/SpecialFilters';
+import { FilterHelpers } from './filters/FilterHelpers';
 
-      r = r * (1 - factor) + tr * factor;
-      g = g * (1 - factor) + tg * factor;
-      b = b * (1 - factor) + tb * factor;
-
-      if (warmFactor > 0) {
-        result[i] = Math.min(255, r + warmFactor * 20);
-        result[i + 1] = Math.min(255, g + warmFactor * 10);
-        result[i + 2] = Math.min(255, b * (1 - warmFactor * 0.3));
-      } else {
-        result[i] = r;
-        result[i + 1] = g;
-        result[i + 2] = Math.min(255, b * (1 - Math.abs(warmFactor) * 0.3));
-      }
-    }
-
-    return result;
-  }
-
-  static applyBlur(
-    data: Uint8ClampedArray,
-    radius: number,
-    width: number,
-    height: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(data);
-    const size = Math.floor(radius) || 1;
-
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        let r = 0, g = 0, b = 0, a = 0;
-        let count = 0;
-
-        for (let dy = -size; dy <= size; dy++) {
-          for (let dx = -size; dx <= size; dx++) {
-            const ny = y + dy;
-            const nx = x + dx;
-
-            if (ny >= 0 && ny < height && nx >= 0 && nx < width) {
-              const idx = (ny * width + nx) * 4;
-              r += data[idx];
-              g += data[idx + 1];
-              b += data[idx + 2];
-              a += data[idx + 3];
-              count++;
-            }
-          }
-        }
-
-        const idx = (y * width + x) * 4;
-        result[idx] = r / count;
-        result[idx + 1] = g / count;
-        result[idx + 2] = b / count;
-        result[idx + 3] = a / count;
-      }
-    }
-
-    return result;
-  }
-
-  static applyIntensity(
-    originalData: Uint8ClampedArray,
-    processedData: Uint8ClampedArray,
-    intensity: number
-  ): Uint8ClampedArray {
-    const result = new Uint8ClampedArray(originalData.length);
-
-    for (let i = 0; i < originalData.length; i++) {
-      result[i] = originalData[i] * (1 - intensity) + processedData[i] * intensity;
-    }
-
-    return result;
-  }
+export class ImageFilterUtils {
+  static applyBrightness = BasicFilters.applyBrightness;
+  static applyContrast = BasicFilters.applyContrast;
+  static applySaturation = BasicFilters.applySaturation;
+  static applyVintage = SpecialFilters.applyVintage;
+  static applyBlur = SpecialFilters.applyBlur;
+  static applyIntensity = FilterHelpers.applyIntensity;
 }
+
+// Re-export for convenience
+export { BasicFilters, SpecialFilters, FilterHelpers };

package/src/infrastructure/utils/MetadataExtractor.ts

@@ -0,0 +1,83 @@
+/**
+ * Image Infrastructure - Metadata Extractor Utilities
+ *
+ * Helper functions for extracting metadata from images
+ */
+
+import type { ImageMetadataExtractionOptions } from '../../infrastructure/services/ImageMetadataService';
+import { ImageErrorHandler } from './ImageErrorHandler';
+
+export class MetadataExtractor {
+  static async getImageDimensions(uri: string): Promise<{ width: number; height: number }> {
+    try {
+      // In a real implementation, we would use:
+      // - expo-image-manipulator for basic dimensions
+      // - react-native-image-picker for metadata
+      // - react-native-exif-reader for EXIF data
+
+      // Mock implementation
+      return {
+        width: Math.floor(Math.random() * 2000) + 100,
+        height: Math.floor(Math.random() * 2000) + 100,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'getDimensions');
+    }
+  }
+
+  static async getFileSize(uri: string): Promise<number> {
+    try {
+      // In real implementation, use expo-file-system or similar
+      return Math.floor(Math.random() * 5000000) + 10000; // Random size between 10KB-5MB
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'getFileSize');
+    }
+  }
+
+  static async extractExifData(uri: string): Promise<any> {
+    try {
+      // Mock EXIF data extraction
+      return {
+        DateTimeOriginal: new Date().toISOString(),
+        Make: 'Mock Camera',
+        Model: 'Mock Phone',
+        ISO: Math.floor(Math.random() * 1600) + 100,
+        FocalLength: Math.random() * 50 + 10,
+        Flash: Math.random() > 0.5,
+        ExposureTime: `1/${Math.floor(Math.random() * 1000) + 100}`,
+        FNumber: Math.random() * 8 + 1.4,
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  static async extractGPSData(uri: string): Promise<{ latitude: number; longitude: number } | null> {
+    try {
+      // Mock GPS data extraction
+      return Math.random() > 0.7 ? {
+        latitude: Math.random() * 180 - 90,
+        longitude: Math.random() * 360 - 180,
+      } : null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  static detectFormat(uri: string): string {
+    const extension = uri.toLowerCase().split('.').pop();
+    switch (extension) {
+      case 'jpg':
+      case 'jpeg':
+        return 'JPEG';
+      case 'png':
+        return 'PNG';
+      case 'webp':
+        return 'WebP';
+      case 'gif':
+        return 'GIF';
+      default:
+        return 'Unknown';
+    }
+  }
+}

package/src/infrastructure/utils/filters/BasicFilters.ts

@@ -0,0 +1,61 @@
+/**
+ * Infrastructure - Basic Image Filters
+ *
+ * Core filter operations: brightness, contrast, saturation
+ */
+
+export class BasicFilters {
+  static applyBrightness(
+    data: Uint8ClampedArray,
+    brightness: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const adjustment = brightness * 2.55;
+
+    for (let i = 0; i < result.length; i += 4) {
+      result[i] = Math.min(255, Math.max(0, result[i] + adjustment));
+      result[i + 1] = Math.min(255, Math.max(0, result[i + 1] + adjustment));
+      result[i + 2] = Math.min(255, Math.max(0, result[i + 2] + adjustment));
+    }
+
+    return result;
+  }
+
+  static applyContrast(
+    data: Uint8ClampedArray,
+    contrast: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const factor = (259 * (contrast * 2.55 + 255)) / (255 * (259 - contrast * 2.55));
+
+    for (let i = 0; i < result.length; i += 4) {
+      result[i] = Math.min(255, Math.max(0, factor * (result[i] - 128) + 128));
+      result[i + 1] = Math.min(255, Math.max(0, factor * (result[i + 1] - 128) + 128));
+      result[i + 2] = Math.min(255, Math.max(0, factor * (result[i + 2] - 128) + 128));
+    }
+
+    return result;
+  }
+
+  static applySaturation(
+    data: Uint8ClampedArray,
+    saturation: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const adjustment = 1 + (saturation / 100);
+
+    for (let i = 0; i < result.length; i += 4) {
+      const r = result[i];
+      const g = result[i + 1];
+      const b = result[i + 2];
+
+      const gray = 0.299 * r + 0.587 * g + 0.114 * b;
+
+      result[i] = Math.min(255, Math.max(0, gray + adjustment * (r - gray)));
+      result[i + 1] = Math.min(255, Math.max(0, gray + adjustment * (g - gray)));
+      result[i + 2] = Math.min(255, Math.max(0, gray + adjustment * (b - gray)));
+    }
+
+    return result;
+  }
+}

package/src/infrastructure/utils/filters/FilterHelpers.ts

@@ -0,0 +1,21 @@
+/**
+ * Infrastructure - Filter Helper Utilities
+ *
+ * Common helper functions for filter operations
+ */
+
+export class FilterHelpers {
+  static applyIntensity(
+    originalData: Uint8ClampedArray,
+    processedData: Uint8ClampedArray,
+    intensity: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(originalData.length);
+
+    for (let i = 0; i < originalData.length; i++) {
+      result[i] = originalData[i] * (1 - intensity) + processedData[i] * intensity;
+    }
+
+    return result;
+  }
+}

package/src/infrastructure/utils/filters/SpecialFilters.ts

@@ -0,0 +1,84 @@
+/**
+ * Infrastructure - Special Image Filters
+ *
+ * Advanced filter operations: vintage, blur
+ */
+
+export class SpecialFilters {
+  static applyVintage(
+    data: Uint8ClampedArray,
+    intensity: number,
+    warmth: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const factor = intensity / 100;
+    const warmFactor = warmth / 100;
+
+    for (let i = 0; i < result.length; i += 4) {
+      let r = result[i];
+      let g = result[i + 1];
+      let b = result[i + 2];
+
+      const tr = 0.393 * r + 0.769 * g + 0.189 * b;
+      const tg = 0.349 * r + 0.686 * g + 0.168 * b;
+      const tb = 0.272 * r + 0.534 * g + 0.131 * b;
+
+      r = r * (1 - factor) + tr * factor;
+      g = g * (1 - factor) + tg * factor;
+      b = b * (1 - factor) + tb * factor;
+
+      if (warmFactor > 0) {
+        result[i] = Math.min(255, r + warmFactor * 20);
+        result[i + 1] = Math.min(255, g + warmFactor * 10);
+        result[i + 2] = Math.min(255, b * (1 - warmFactor * 0.3));
+      } else {
+        result[i] = r;
+        result[i + 1] = g;
+        result[i + 2] = Math.min(255, b * (1 - Math.abs(warmFactor) * 0.3));
+      }
+    }
+
+    return result;
+  }
+
+  static applyBlur(
+    data: Uint8ClampedArray,
+    radius: number,
+    width: number,
+    height: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const size = Math.floor(radius) || 1;
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        let r = 0, g = 0, b = 0, a = 0;
+        let count = 0;
+
+        for (let dy = -size; dy <= size; dy++) {
+          for (let dx = -size; dx <= size; dx++) {
+            const ny = y + dy;
+            const nx = x + dx;
+
+            if (ny >= 0 && ny < height && nx >= 0 && nx < width) {
+              const idx = (ny * width + nx) * 4;
+              r += data[idx];
+              g += data[idx + 1];
+              b += data[idx + 2];
+              a += data[idx + 3];
+              count++;
+            }
+          }
+        }
+
+        const idx = (y * width + x) * 4;
+        result[idx] = r / count;
+        result[idx + 1] = g / count;
+        result[idx + 2] = b / count;
+        result[idx + 3] = a / count;
+      }
+    }
+
+    return result;
+  }
+}