@umituz/react-native-image 1.3.8 → 1.3.9

package/package.json

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

@@ -60,7 +60,6 @@ export {
 // =============================================================================
 
 export { ImageTransformService } from './infrastructure/services/ImageTransformService';
-export { ImageAdvancedTransformService } from './infrastructure/services/ImageAdvancedTransformService';
 export { ImageConversionService } from './infrastructure/services/ImageConversionService';
 export { ImageStorageService } from './infrastructure/services/ImageStorageService';
 export {
@@ -69,10 +68,9 @@ export {
 } from './infrastructure/services/ImageViewerService';
 
 export { ImageBatchService, type BatchOperation, type BatchProcessingOptions, type BatchProcessingResult } from './infrastructure/services/ImageBatchService';
-export { ImageAIEnhancementService, type AutoEnhancementOptions, type EnhancementResult } from './infrastructure/services/ImageAIEnhancementService';
+export { ImageEnhanceService, type AutoEnhancementOptions, type EnhancementResult } from './infrastructure/services/ImageEnhanceService';
 export { ImageMetadataService, type ImageMetadataExtractionOptions } from './infrastructure/services/ImageMetadataService';
 export { ImageQualityPresetService, type QualityPreset, type QualityPresets, IMAGE_QUALITY_PRESETS } from './infrastructure/utils/ImageQualityPresets';
-export { ImageSpecializedEnhancementService } from './infrastructure/services/ImageSpecializedEnhancementService';
 export { ImageTemplateService } from './infrastructure/services/ImageTemplateService';
 
 // =============================================================================
@@ -91,7 +89,7 @@ export {
 } from './presentation/hooks/useImageGallery';
 
 export { useImageBatch } from './presentation/hooks/useImageBatch';
-export { useImageAIEnhancement } from './presentation/hooks/useImageAIEnhancement';
+export { useImageEnhance } from './presentation/hooks/useImageEnhance';
 export { useImageMetadata } from './presentation/hooks/useImageMetadata';
 
 

package/src/infrastructure/services/{ImageAIEnhancementService.ts → ImageEnhanceService.ts}

@@ -1,5 +1,5 @@
 /**
- * Image Infrastructure - AI Enhancement Service
+ * Image Infrastructure - Enhance Service
  * 
  * AI-powered image enhancement and automatic adjustments
  */
@@ -11,7 +11,6 @@ import type {
 } from '../../domain/entities/ImageFilterTypes';
 import { ImageValidator } from '../utils/ImageValidator';
 import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
-import { AIImageAnalysisUtils } from '../utils/AIImageAnalysisUtils';
 
 export interface AutoEnhancementOptions {
   enhanceBrightness?: boolean;
@@ -29,49 +28,7 @@ export interface EnhancementResult {
   improvementScore: number;
 }
 
-export class ImageAIEnhancementService {
-  private static calculateHistogram(imageData: Uint8ClampedArray): number[] {
-    const histogram = new Array(256).fill(0);
-    for (let i = 0; i < imageData.length; i += 4) {
-      const gray = Math.round(0.299 * imageData[i] + 0.587 * imageData[i + 1] + 0.114 * imageData[i + 2]);
-      histogram[gray]++;
-    }
-    return histogram;
-  }
-
-  private static calculateOptimalBrightness(histogram: number[]): number {
-    const totalPixels = histogram.reduce((sum, count) => sum + count, 0);
-    let sum = 0;
-    
-    for (let i = 0; i < 256; i++) {
-      sum += histogram[i] * i;
-    }
-    
-    const meanBrightness = sum / totalPixels;
-    const targetBrightness = 128;
-    
-    return (targetBrightness - meanBrightness) / 255;
-  }
-
-  private static calculateOptimalContrast(histogram: number[]): number {
-    const totalPixels = histogram.reduce((sum, count) => sum + count, 0);
-    let mean = 0;
-    let variance = 0;
-    
-    for (let i = 0; i < 256; i++) {
-      mean += (histogram[i] / totalPixels) * i;
-    }
-    
-    for (let i = 0; i < 256; i++) {
-      variance += (histogram[i] / totalPixels) * Math.pow(i - mean, 2);
-    }
-    
-    const standardDeviation = Math.sqrt(variance);
-    const targetStandardDeviation = 80;
-    
-    return Math.max(-1, Math.min(1, (targetStandardDeviation - standardDeviation) / 100));
-  }
-
+export class ImageEnhanceService {
   static async analyzeImage(uri: string): Promise<ImageQualityMetrics> {
     try {
       const uriValidation = ImageValidator.validateUri(uri);
@@ -105,23 +62,19 @@ export class ImageAIEnhancementService {
         enhanceBrightness = true,
         enhanceContrast = true,
         enhanceColor = true,
-        reduceNoise = false,
-        sharpen = false,
-        targetQuality = 85,
       } = options;
 
-      const originalMetrics = await ImageAIEnhancementService.analyzeImage(uri);
+      const originalMetrics = await this.analyzeImage(uri);
       const adjustments: ImageColorAdjustment = {};
 
       if (enhanceBrightness) adjustments.brightness = 0.1;
       if (enhanceContrast) adjustments.contrast = 0.15;
       if (enhanceColor) adjustments.saturation = 0.1;
 
-      const enhancedMetrics = await ImageAIEnhancementService.analyzeImage(uri);
-      const improvementScore = (
-        (enhancedMetrics.overallQuality - originalMetrics.overallQuality) /
-        originalMetrics.overallQuality
-      ) * 100;
+      const enhancedMetrics = await this.analyzeImage(uri);
+      const improvementScore = originalMetrics.overallQuality > 0 
+        ? ((enhancedMetrics.overallQuality - originalMetrics.overallQuality) / originalMetrics.overallQuality) * 100
+        : 0;
 
       return {
         originalMetrics,
@@ -133,4 +86,38 @@ export class ImageAIEnhancementService {
       throw ImageErrorHandler.handleUnknownError(error, 'autoEnhance');
     }
   }
-}
+
+  static async enhancePortrait(uri: string): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhancePortrait');
+      }
+
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'enhancePortrait');
+    }
+  }
+
+  static async enhanceLandscape(uri: string): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhanceLandscape');
+      }
+
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'enhanceLandscape');
+    }
+  }
+}

package/src/infrastructure/services/ImageTemplateService.ts

@@ -7,12 +7,16 @@ import { MemeTemplateOptions } from '../../domain/entities/ImageTemplateTypes';
  */
 export class ImageTemplateService {
   /**
-   * Generates a Memegen.link URL for a given template and texts
+   * Generates a meme URL for a given template and texts
    * 
    * @param options Meme configuration (templateKey, topText, bottomText)
-   * @returns Formatted memegen.link URL
+   * @param baseUrl Optional base URL for the image generation service
+   * @returns Formatted image URL
    */
-  static generateMemeUrl(options: MemeTemplateOptions): string {
+  static generateMemeUrl(
+    options: MemeTemplateOptions, 
+    baseUrl: string = 'https://api.memegen.link'
+  ): string {
     const { templateKey, topText = '', bottomText = '', style, width, height } = options;
     
     // Internal helper for memegen-specific encoding
@@ -32,7 +36,9 @@ export class ImageTemplateService {
     const top = encodeMemeText(topText);
     const bottom = encodeMemeText(bottomText);
 
-    let url = `https://api.memegen.link/images/${templateKey}/${top}/${bottom}.png`;
+    // Ensure baseUrl doesn't have a trailing slash
+    const base = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    let url = `${base}/images/${templateKey}/${top}/${bottom}.png`;
     
     const params: string[] = [];
     if (style) params.push(`style=${style}`);

package/src/infrastructure/services/ImageTransformService.ts

@@ -136,4 +136,94 @@ export class ImageTransformService {
             throw ImageErrorHandler.handleUnknownError(error, 'flip');
         }
     }
+
+    static async manipulate(
+        uri: string,
+        action: ImageManipulateAction,
+        options?: ImageSaveOptions
+    ): Promise<ImageManipulationResult> {
+        try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'manipulate');
+            }
+
+            const actions: ImageManipulator.Action[] = [];
+            
+            if (action.resize) {
+                const dimValidation = ImageValidator.validateDimensions(action.resize);
+                if (!dimValidation.isValid) {
+                    throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'manipulate');
+                }
+                actions.push({ resize: action.resize });
+            }
+            
+            if (action.crop) {
+                const dimValidation = ImageValidator.validateDimensions(action.crop);
+                if (!dimValidation.isValid) {
+                    throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'manipulate');
+                }
+                actions.push({ crop: action.crop });
+            }
+            
+            if (action.rotate) {
+                const rotationValidation = ImageValidator.validateRotation(action.rotate);
+                if (!rotationValidation.isValid) {
+                    throw ImageErrorHandler.createError(rotationValidation.error!, IMAGE_ERROR_CODES.VALIDATION_ERROR, 'manipulate');
+                }
+                actions.push({ rotate: action.rotate });
+            }
+            
+            if (action.flip) {
+                if (action.flip.horizontal) actions.push({ flip: ImageManipulator.FlipType.Horizontal });
+                if (action.flip.vertical) actions.push({ flip: ImageManipulator.FlipType.Vertical });
+            }
+
+            return await ImageManipulator.manipulateAsync(
+                uri,
+                actions,
+                this.buildSaveOptions(options)
+            );
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'manipulate');
+        }
+    }
+
+    static async resizeToFit(
+        uri: string,
+        maxWidth: number,
+        maxHeight: number,
+        options?: ImageSaveOptions
+    ): Promise<ImageManipulationResult> {
+        try {
+            const dimValidation = ImageValidator.validateDimensions({ width: maxWidth, height: maxHeight });
+            if (!dimValidation.isValid) {
+                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'resizeToFit');
+            }
+
+            const dimensions = ImageUtils.fitToSize(maxWidth, maxHeight, maxWidth, maxHeight);
+            return this.resize(uri, dimensions.width, dimensions.height, options);
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'resizeToFit');
+        }
+    }
+
+    static async cropToSquare(
+        uri: string,
+        width: number,
+        height: number,
+        options?: ImageSaveOptions
+    ): Promise<ImageManipulationResult> {
+        try {
+            const dimValidation = ImageValidator.validateDimensions({ width, height });
+            if (!dimValidation.isValid) {
+                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'cropToSquare');
+            }
+
+            const cropArea = ImageUtils.getSquareCrop(width, height);
+            return this.crop(uri, cropArea, options);
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'cropToSquare');
+        }
+    }
 }

package/src/infrastructure/utils/FilterProcessor.ts

@@ -147,44 +147,43 @@ export class FilterProcessor {
   }
 
   static applyFilter(
-    imageData: ImageData,
+    imageData: Uint8ClampedArray,
+    width: number,
+    height: number,
     filterState: FilterState
-  ): ImageData {
+  ): Uint8ClampedArray {
     const preset = this.getPreset(filterState.id);
     if (!preset || !filterState.enabled) {
       return imageData;
     }
 
-    let processedData = new Uint8ClampedArray(imageData.data);
+    let processedData = new Uint8ClampedArray(imageData);
 
     // Apply filter based on preset type
     switch (filterState.id) {
       case 'brightness':
-        processedData = this.applyBrightness(processedData, filterState.parameters.brightness) as any;
+        processedData = this.applyBrightness(processedData, filterState.parameters.brightness);
         break;
       case 'contrast':
-        processedData = this.applyContrast(processedData, filterState.parameters.contrast) as any;
+        processedData = this.applyContrast(processedData, filterState.parameters.contrast);
         break;
       case 'saturation':
-        processedData = this.applySaturation(processedData, filterState.parameters.saturation) as any;
+        processedData = this.applySaturation(processedData, filterState.parameters.saturation);
         break;
       case 'vintage':
-        processedData = this.applyVintage(processedData, filterState.parameters.intensity, filterState.parameters.warmth) as any;
+        processedData = this.applyVintage(processedData, filterState.parameters.intensity, filterState.parameters.warmth);
         break;
       case 'blur':
-        processedData = this.applyBlur(processedData, filterState.parameters.radius) as any;
+        processedData = this.applyBlur(processedData, filterState.parameters.radius, width, height);
         break;
     }
 
     // Apply intensity
     if (filterState.intensity < 100) {
-      processedData = this.applyIntensity(imageData.data, processedData, filterState.intensity / 100) as any;
+      processedData = this.applyIntensity(imageData, processedData, filterState.intensity / 100);
     }
 
-    return {
-      ...imageData,
-      data: processedData,
-    };
+    return processedData;
   }
 
   private static applyBrightness(
@@ -282,12 +281,12 @@ export class FilterProcessor {
 
   private static applyBlur(
     data: Uint8ClampedArray,
-    radius: number
+    radius: number,
+    width: number,
+    height: number
   ): Uint8ClampedArray {
     // Simple box blur implementation
     const result = new Uint8ClampedArray(data);
-    const width = Math.sqrt(data.length / 4);
-    const height = width;
     const size = Math.floor(radius) || 1;
 
     for (let y = 0; y < height; y++) {
@@ -336,26 +335,5 @@ export class FilterProcessor {
     return result;
   }
 
-  static createPreview(
-    imageData: ImageData,
-    filterState: FilterState,
-    previewSize: { width: number; height: number }
-  ): ImageData {
-    // Create a smaller preview version
-    const previewCanvas = document.createElement('canvas') || {} as any;
-    previewCanvas.width = previewSize.width;
-    previewCanvas.height = previewSize.height;
-    const ctx = previewCanvas.getContext('2d');
-
-    if (!ctx) return imageData;
-
-    // Scale down the image for preview
-    ctx.drawImage(
-      {} as HTMLImageElement, // Would be the actual image
-      0, 0, previewSize.width, previewSize.height
-    );
-
-    const previewImageData = ctx.getImageData(0, 0, previewSize.width, previewSize.height);
-    return this.applyFilter(previewImageData, filterState);
-  }
+
 }

package/src/infrastructure/utils/{AIImageAnalysisUtils.ts → ImageAnalysisUtils.ts}

@@ -1,10 +1,10 @@
 /**
- * Image Infrastructure - AI Image Analysis
+ * Image Infrastructure - Image Analysis
  * 
- * Advanced image analysis utilities
+ * Image analysis utilities
  */
 
-export class AIImageAnalysisUtils {
+export class ImageAnalysisUtils {
   static calculateColorBalance(imageData: Uint8ClampedArray): {
     redBalance: number;
     greenBalance: number;

package/src/infrastructure/utils/LayerManager.ts

@@ -13,44 +13,7 @@ export interface LayerComposition {
 }
 
 export class LayerManager {
-  static composeLayers(
-    layers: Array<{
-      canvas: HTMLCanvasElement | any;
-      opacity: number;
-      visible: boolean;
-      x?: number;
-      y?: number;
-    }>,
-    composition: LayerComposition
-  ): HTMLCanvasElement | any {
-    // Create composition canvas
-    const composedCanvas = document.createElement('canvas') || {} as any;
-    composedCanvas.width = composition.width;
-    composedCanvas.height = composition.height;
-    const ctx = composedCanvas.getContext('2d');
-
-    if (!ctx) return composedCanvas;
-
-    // Clear canvas with background color
-    ctx.fillStyle = composition.backgroundColor || '#ffffff';
-    ctx.fillRect(0, 0, composition.width, composition.height);
-
-    // Draw each layer
-    layers.forEach(layer => {
-      if (!layer.visible) return;
 
-      ctx.save();
-      ctx.globalAlpha = layer.opacity;
-      ctx.drawImage(
-        layer.canvas,
-        layer.x || 0,
-        layer.y || 0
-      );
-      ctx.restore();
-    });
-
-    return composedCanvas;
-  }
 
   static mergeLayers(
     layers: Array<{
@@ -110,49 +73,5 @@ export class LayerManager {
     return result.map((layer, index) => ({ ...layer, index }));
   }
 
-  static flattenLayers(
-    layers: Array<{
-      canvas: HTMLCanvasElement | any;
-      opacity: number;
-      visible: boolean;
-    }>,
-    composition: LayerComposition
-  ): HTMLCanvasElement | any {
-    return LayerManager.composeLayers(layers, composition);
-  }
-
-  static createLayerCanvas(
-    width: number,
-    height: number,
-    transparent: boolean = true
-  ): HTMLCanvasElement | any {
-    const canvas = document.createElement('canvas') || {} as any;
-    canvas.width = width;
-    canvas.height = height;
-    
-    if (!transparent) {
-      const ctx = canvas.getContext('2d');
-      if (ctx) {
-        ctx.fillStyle = '#ffffff';
-        ctx.fillRect(0, 0, width, height);
-      }
-    }
 
-    return canvas;
-  }
-
-  static clearLayer(
-    canvas: HTMLCanvasElement | any,
-    preserveAlpha: boolean = true
-  ): void {
-    const ctx = canvas.getContext('2d');
-    if (!ctx) return;
-
-    if (preserveAlpha) {
-      ctx.clearRect(0, 0, canvas.width, canvas.height);
-    } else {
-      ctx.fillStyle = 'transparent';
-      ctx.fillRect(0, 0, canvas.width, canvas.height);
-    }
-  }
 }

package/src/presentation/hooks/useImageEnhance.ts

@@ -0,0 +1,32 @@
+/**
+ * Presentation - Image Enhance Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageEnhanceService, type AutoEnhancementOptions } from '../../infrastructure/services/ImageEnhanceService';
+
+export const useImageEnhance = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const autoEnhance = useCallback((uri: string, options?: AutoEnhancementOptions) =>
+        execute(() => ImageEnhanceService.autoEnhance(uri, options), 'Failed to auto enhance'), [execute]);
+
+    const enhancePortrait = useCallback((uri: string) =>
+        execute(() => ImageEnhanceService.enhancePortrait(uri), 'Failed to enhance portrait'), [execute]);
+
+    const enhanceLandscape = useCallback((uri: string) =>
+        execute(() => ImageEnhanceService.enhanceLandscape(uri), 'Failed to enhance landscape'), [execute]);
+
+    const analyzeImage = useCallback((uri: string) =>
+        execute(() => ImageEnhanceService.analyzeImage(uri), 'Failed to analyze image'), [execute]);
+
+    return {
+        autoEnhance,
+        enhancePortrait,
+        enhanceLandscape,
+        analyzeImage,
+        isEnhancing: isProcessing,
+        enhancementError: error,
+    };
+};

package/src/presentation/hooks/useImageTransform.ts

@@ -4,7 +4,6 @@
 import { useCallback } from 'react';
 import { useImageOperation } from './useImageOperation';
 import { ImageTransformService } from '../../infrastructure/services/ImageTransformService';
-import { ImageAdvancedTransformService } from '../../infrastructure/services/ImageAdvancedTransformService';
 import type {
     ImageManipulateAction,
     ImageSaveOptions,
@@ -28,13 +27,13 @@ export const useImageTransform = () => {
         execute(() => ImageTransformService.flip(uri, flipParams, options), 'Failed to flip'), [execute]);
 
     const manipulate = useCallback((uri: string, action: ImageManipulateAction, options?: ImageSaveOptions) =>
-        execute(() => ImageAdvancedTransformService.manipulate(uri, action, options), 'Failed to manipulate'), [execute]);
+        execute(() => ImageTransformService.manipulate(uri, action, options), 'Failed to manipulate'), [execute]);
 
     const resizeToFit = useCallback((uri: string, maxWidth: number, maxHeight: number, options?: ImageSaveOptions) =>
-        execute(() => ImageAdvancedTransformService.resizeToFit(uri, maxWidth, maxHeight, options), 'Failed to resize to fit'), [execute]);
+        execute(() => ImageTransformService.resizeToFit(uri, maxWidth, maxHeight, options), 'Failed to resize to fit'), [execute]);
 
     const cropToSquare = useCallback((uri: string, width: number, height: number, options?: ImageSaveOptions) =>
-        execute(() => ImageAdvancedTransformService.cropToSquare(uri, width, height, options), 'Failed to crop square'), [execute]);
+        execute(() => ImageTransformService.cropToSquare(uri, width, height, options), 'Failed to crop square'), [execute]);
 
     return {
         resize, crop, rotate, flip, manipulate, resizeToFit, cropToSquare,

package/src/infrastructure/services/ImageAdvancedTransformService.ts

@@ -1,106 +0,0 @@
-/**
- * Image Infrastructure - Advanced Transform Service
- */
-
-import * as ImageManipulator from 'expo-image-manipulator';
-import type {
-    ImageManipulateAction,
-    ImageSaveOptions,
-    ImageManipulationResult,
-} from '../../domain/entities/ImageTypes';
-import { ImageTransformService } from './ImageTransformService';
-import { ImageUtils } from '../../domain/utils/ImageUtils';
-import { ImageValidator } from '../utils/ImageValidator';
-import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
-
-export class ImageAdvancedTransformService {
-    static async manipulate(
-        uri: string,
-        action: ImageManipulateAction,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
-        try {
-            const uriValidation = ImageValidator.validateUri(uri);
-            if (!uriValidation.isValid) {
-                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'manipulate');
-            }
-
-            const actions: ImageManipulator.Action[] = [];
-            
-            if (action.resize) {
-                const dimValidation = ImageValidator.validateDimensions(action.resize);
-                if (!dimValidation.isValid) {
-                    throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'manipulate');
-                }
-                actions.push({ resize: action.resize });
-            }
-            
-            if (action.crop) {
-                const dimValidation = ImageValidator.validateDimensions(action.crop);
-                if (!dimValidation.isValid) {
-                    throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'manipulate');
-                }
-                actions.push({ crop: action.crop });
-            }
-            
-            if (action.rotate) {
-                const rotationValidation = ImageValidator.validateRotation(action.rotate);
-                if (!rotationValidation.isValid) {
-                    throw ImageErrorHandler.createError(rotationValidation.error!, IMAGE_ERROR_CODES.VALIDATION_ERROR, 'manipulate');
-                }
-                actions.push({ rotate: action.rotate });
-            }
-            
-            if (action.flip) {
-                if (action.flip.horizontal) actions.push({ flip: ImageManipulator.FlipType.Horizontal });
-                if (action.flip.vertical) actions.push({ flip: ImageManipulator.FlipType.Vertical });
-            }
-
-            return await ImageManipulator.manipulateAsync(
-                uri,
-                actions,
-                ImageTransformService['buildSaveOptions'](options)
-            );
-        } catch (error) {
-            throw ImageErrorHandler.handleUnknownError(error, 'manipulate');
-        }
-    }
-
-    static async resizeToFit(
-        uri: string,
-        maxWidth: number,
-        maxHeight: number,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
-        try {
-            const dimValidation = ImageValidator.validateDimensions({ width: maxWidth, height: maxHeight });
-            if (!dimValidation.isValid) {
-                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'resizeToFit');
-            }
-
-            const dimensions = ImageUtils.fitToSize(maxWidth, maxHeight, maxWidth, maxHeight);
-            return ImageTransformService.resize(uri, dimensions.width, dimensions.height, options);
-        } catch (error) {
-            throw ImageErrorHandler.handleUnknownError(error, 'resizeToFit');
-        }
-    }
-
-    static async cropToSquare(
-        uri: string,
-        width: number,
-        height: number,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
-        try {
-            const dimValidation = ImageValidator.validateDimensions({ width, height });
-            if (!dimValidation.isValid) {
-                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'cropToSquare');
-            }
-
-            const cropArea = ImageUtils.getSquareCrop(width, height);
-            return ImageTransformService.crop(uri, cropArea, options);
-        } catch (error) {
-            throw ImageErrorHandler.handleUnknownError(error, 'cropToSquare');
-        }
-    }
-}

package/src/infrastructure/services/ImageSpecializedEnhancementService.ts

@@ -1,57 +0,0 @@
-/**
- * Image Infrastructure - Specialized Enhancement
- * 
- * Portrait and landscape specific enhancement services
- */
-
-import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
-import { ImageValidator } from '../utils/ImageValidator';
-import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
-
-export class ImageSpecializedEnhancementService {
-  static async enhancePortrait(uri: string): Promise<ImageManipulationResult> {
-    try {
-      const uriValidation = ImageValidator.validateUri(uri);
-      if (!uriValidation.isValid) {
-        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhancePortrait');
-      }
-
-      // Portrait-specific enhancements:
-      // - Skin smoothing
-      // - Eye enhancement
-      // - Face detection and lighting adjustment
-      // - Background blur (bokeh effect)
-
-      return {
-        uri,
-        width: 0,
-        height: 0,
-      };
-    } catch (error) {
-      throw ImageErrorHandler.handleUnknownError(error, 'enhancePortrait');
-    }
-  }
-
-  static async enhanceLandscape(uri: string): Promise<ImageManipulationResult> {
-    try {
-      const uriValidation = ImageValidator.validateUri(uri);
-      if (!uriValidation.isValid) {
-        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhanceLandscape');
-      }
-
-      // Landscape-specific enhancements:
-      // - Sky enhancement
-      // - Green tone adjustment
-      // - HDR effect simulation
-      // - Perspective correction
-
-      return {
-        uri,
-        width: 0,
-        height: 0,
-      };
-    } catch (error) {
-      throw ImageErrorHandler.handleUnknownError(error, 'enhanceLandscape');
-    }
-  }
-}

package/src/presentation/hooks/useImageAIEnhancement.ts

@@ -1,33 +0,0 @@
-/**
- * Presentation - Image AI Enhancement Hook
- */
-
-import { useCallback } from 'react';
-import { useImageOperation } from './useImageOperation';
-import { ImageAIEnhancementService, type AutoEnhancementOptions, type EnhancementResult } from '../../infrastructure/services/ImageAIEnhancementService';
-import { ImageSpecializedEnhancementService } from '../../infrastructure/services/ImageSpecializedEnhancementService';
-
-export const useImageAIEnhancement = () => {
-    const { isProcessing, error, execute } = useImageOperation();
-
-    const autoEnhance = useCallback((uri: string, options?: AutoEnhancementOptions) =>
-        execute(() => ImageAIEnhancementService.autoEnhance(uri, options), 'Failed to auto enhance'), [execute]);
-
-    const enhancePortrait = useCallback((uri: string) =>
-        execute(() => ImageSpecializedEnhancementService.enhancePortrait(uri), 'Failed to enhance portrait'), [execute]);
-
-    const enhanceLandscape = useCallback((uri: string) =>
-        execute(() => ImageSpecializedEnhancementService.enhanceLandscape(uri), 'Failed to enhance landscape'), [execute]);
-
-    const analyzeImage = useCallback((uri: string) =>
-        execute(() => ImageAIEnhancementService.analyzeImage(uri), 'Failed to analyze image'), [execute]);
-
-    return {
-        autoEnhance,
-        enhancePortrait,
-        enhanceLandscape,
-        analyzeImage,
-        isEnhancing: isProcessing,
-        enhancementError: error,
-    };
-};