@umituz/react-native-image 1.3.8 → 1.3.10

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,
-    };
-};