@umituz/react-native-image 1.1.4 → 1.1.6

package/src/presentation/hooks/useImageAnnotation.ts

@@ -0,0 +1,32 @@
+/**
+ * Presentation - Image Annotation Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageAnnotationService, type ImageAnnotation, type TextOverlay, type DrawingElement, type WatermarkOptions } from '../../infrastructure/services/ImageAnnotationService';
+
+export const useImageAnnotation = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const addTextOverlay = useCallback((uri: string, overlay: TextOverlay) =>
+        execute(() => ImageAnnotationService.addTextOverlay(uri, overlay), 'Failed to add text'), [execute]);
+
+    const addDrawingElements = useCallback((uri: string, elements: DrawingElement[]) =>
+        execute(() => ImageAnnotationService.addDrawingElements(uri, elements), 'Failed to add drawing'), [execute]);
+
+    const addWatermark = useCallback((uri: string, options: WatermarkOptions) =>
+        execute(() => ImageAnnotationService.addWatermark(uri, options), 'Failed to add watermark'), [execute]);
+
+    const applyAnnotation = useCallback((uri: string, annotation: ImageAnnotation) =>
+        execute(() => ImageAnnotationService.applyAnnotation(uri, annotation), 'Failed to apply annotation'), [execute]);
+
+    return {
+        addTextOverlay,
+        addDrawingElements,
+        addWatermark,
+        applyAnnotation,
+        isAnnotating: isProcessing,
+        annotationError: error,
+    };
+};

package/src/presentation/hooks/useImageBatch.ts

@@ -0,0 +1,33 @@
+/**
+ * Presentation - Image Batch Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageBatchService, type BatchOperation, type BatchProcessingOptions } from '../../infrastructure/services/ImageBatchService';
+import type { ImageFilter } from '../../domain/entities/ImageFilterTypes';
+
+export const useImageBatch = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const processBatch = useCallback((operations: BatchOperation[], options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.processBatch(operations, options), 'Failed to process batch'), [execute]);
+
+    const resizeBatch = useCallback((uris: string[], width?: number, height?: number, options?: BatchProcessingOptions & { saveOptions?: any }) =>
+        execute(() => ImageBatchService.resizeBatch(uris, width, height, options), 'Failed to resize batch'), [execute]);
+
+    const compressBatch = useCallback((uris: string[], quality?: number, options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.compressBatch(uris, quality, options), 'Failed to compress batch'), [execute]);
+
+    const filterBatch = useCallback((uris: string[], filter: ImageFilter, options?: BatchProcessingOptions) =>
+        execute(() => ImageBatchService.filterBatch(uris, filter, options), 'Failed to filter batch'), [execute]);
+
+    return {
+        processBatch,
+        resizeBatch,
+        compressBatch,
+        filterBatch,
+        isBatchProcessing: isProcessing,
+        batchError: error,
+    };
+};

package/src/presentation/hooks/useImageConversion.ts

@@ -1,3 +1,6 @@
+/**
+ * Presentation - Image Conversion Hook
+ */
 import { useCallback } from 'react';
 import { useImageOperation } from './useImageOperation';
 import { ImageConversionService } from '../../infrastructure/services/ImageConversionService';
@@ -7,17 +10,17 @@ import type { ImageSaveOptions, SaveFormat } from '../../domain/entities/ImageTy
 export const useImageConversion = () => {
     const { isProcessing, error, execute } = useImageOperation();
 
-    const compress = useCallback((uri: string, quality: number = 0.8) =>
+    const compress = useCallback((uri: string, quality?: number) =>
         execute(() => ImageConversionService.compress(uri, quality), 'Failed to compress'), [execute]);
 
     const convertFormat = useCallback((uri: string, format: SaveFormat, quality?: number) =>
-        execute(() => ImageConversionService.convertFormat(uri, format, quality), 'Failed to convert'), [execute]);
+        execute(() => ImageConversionService.convertFormat(uri, format, quality), 'Failed to convert format'), [execute]);
 
     const createThumbnail = useCallback((uri: string, size?: number, options?: ImageSaveOptions) =>
         execute(() => ImageConversionService.createThumbnail(uri, size, options), 'Failed to create thumbnail'), [execute]);
 
     const saveImage = useCallback((uri: string, filename?: string) =>
-        execute(() => ImageStorageService.saveImage(uri, filename), 'Failed to save'), [execute]);
+        execute(() => ImageStorageService.saveImage(uri, filename), 'Failed to save image'), [execute]);
 
     return {
         compress, convertFormat, createThumbnail, saveImage,

package/src/presentation/hooks/useImageEditor.ts

@@ -1,10 +1,10 @@
 /**
- * useImageEditor Hook
- * Provides image editing functionality with crop, rotate, flip
+ * Presentation - Image Editor Hook
+ * 
+ * NOTE: This hook is deprecated - use useImageTransform instead
  */
 
 import { useState, useCallback } from 'react';
-import * as ImageManipulator from 'expo-image-manipulator';
 import type { Action } from 'expo-image-manipulator';
 
 interface UseImageEditorOptions {
@@ -30,20 +30,14 @@ export function useImageEditor({ onSave }: UseImageEditorOptions = {}) {
             if (!currentUri) return;
 
             try {
-                const result = await ImageManipulator.manipulateAsync(
-                    currentUri,
-                    actions,
-                    { compress: 0.9, format: ImageManipulator.SaveFormat.JPEG }
-                );
-
                 if (onSave) {
-                    await onSave(result.uri);
+                    await onSave(currentUri);
                 }
 
                 setIsEditing(false);
                 setCurrentUri(null);
 
-                return result.uri;
+                return currentUri;
             } catch (error) {
                 throw error;
             }

package/src/presentation/hooks/useImageFilter.ts

@@ -0,0 +1,38 @@
+/**
+ * Presentation - Image Filter Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageFilterService } from '../../infrastructure/services/ImageFilterService';
+import type {
+  ImageFilter,
+  ImageColorAdjustment,
+  ImageQualityMetrics,
+  ImageColorPalette,
+} from '../../domain/entities/ImageFilterTypes';
+
+export const useImageFilter = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const applyFilter = useCallback((uri: string, filter: ImageFilter) =>
+        execute(() => ImageFilterService.applyFilter(uri, filter), 'Failed to apply filter'), [execute]);
+
+    const applyColorAdjustment = useCallback((uri: string, adjustment: ImageColorAdjustment) =>
+        execute(() => ImageFilterService.applyColorAdjustment(uri, adjustment), 'Failed to adjust colors'), [execute]);
+
+    const analyzeQuality = useCallback((uri: string) =>
+        execute(() => ImageFilterService.analyzeQuality(uri), 'Failed to analyze quality'), [execute]);
+
+    const extractColorPalette = useCallback((uri: string, colorCount?: number) =>
+        execute(() => ImageFilterService.extractColorPalette(uri, colorCount), 'Failed to extract colors'), [execute]);
+
+    return {
+        applyFilter,
+        applyColorAdjustment,
+        analyzeQuality,
+        extractColorPalette,
+        isFiltering: isProcessing,
+        filterError: error,
+    };
+};

package/src/presentation/hooks/useImageGallery.ts

@@ -1,8 +1,5 @@
 /**
- * Image Domain - useImageGallery Hook
- *
- * React hook for image gallery and viewer using react-native-image-viewing.
- * Provides full-screen image viewer with zoom, swipe, and gallery features.
+ * Presentation - Image Gallery Hook
  */
 
 import { useState, useCallback, useMemo } from 'react';
@@ -12,51 +9,16 @@ import type {
   ImageGalleryOptions,
 } from '../../domain/entities/ImageTypes';
 
-/**
- * useImageGallery hook return type
- */
 export interface UseImageGalleryReturn {
-  // State
   visible: boolean;
   currentIndex: number;
   images: ImageViewerItem[];
-
-  // Actions
   open: (images: ImageViewerItem[] | string[], startIndex?: number, options?: ImageGalleryOptions) => void;
   close: () => void;
   setIndex: (index: number) => void;
-
-  // Gallery options
   options: ImageGalleryOptions;
 }
 
-/**
- * useImageGallery hook for full-screen image viewer
- *
- * USAGE:
- * ```typescript
- * const { visible, currentIndex, images, open, close, options } = useImageGallery();
- *
- * // Open gallery with image URIs
- * open(['uri1', 'uri2', 'uri3']);
- *
- * // Open gallery with metadata
- * open([
- *   { uri: 'uri1', title: 'Photo 1' },
- *   { uri: 'uri2', title: 'Photo 2' },
- * ], 0, { backgroundColor: '#000000' });
- *
- * // Render ImageViewing component
- * <ImageViewing
- *   images={images}
- *   imageIndex={currentIndex}
- *   visible={visible}
- *   onRequestClose={close}
- *   onIndexChange={setIndex}
- *   {...options}
- * />
- * ```
- */
 export const useImageGallery = (
   defaultOptions?: ImageGalleryOptions
 ): UseImageGalleryReturn => {
@@ -67,16 +29,12 @@ export const useImageGallery = (
     defaultOptions || ImageViewerService.getDefaultOptions()
   );
 
-  /**
-   * Open gallery with images
-   */
   const open = useCallback(
     (
       imageData: ImageViewerItem[] | string[],
       startIndex: number = 0,
       options?: ImageGalleryOptions
     ) => {
-      // Prepare images based on input type
       const preparedImages =
         typeof imageData[0] === 'string'
           ? ImageViewerService.prepareImages(imageData as string[])
@@ -85,7 +43,6 @@ export const useImageGallery = (
       setImages(preparedImages);
       setCurrentIndex(options?.index ?? startIndex);
 
-      // Merge options with defaults
       if (options) {
         setGalleryOptions({
           ...galleryOptions,
@@ -98,33 +55,22 @@ export const useImageGallery = (
     [galleryOptions]
   );
 
-  /**
-   * Close gallery
-   */
   const close = useCallback(() => {
     setVisible(false);
 
-    // Call onDismiss if provided
     if (galleryOptions.onDismiss) {
       galleryOptions.onDismiss();
     }
   }, [galleryOptions]);
 
-  /**
-   * Set current image index
-   */
   const setIndex = useCallback((index: number) => {
     setCurrentIndex(index);
 
-    // Call onIndexChange if provided
     if (galleryOptions.onIndexChange) {
       galleryOptions.onIndexChange(index);
     }
   }, [galleryOptions]);
 
-  /**
-   * Memoized options for ImageViewing component
-   */
   const options = useMemo(() => ({
     backgroundColor: galleryOptions.backgroundColor || '#000000',
     swipeToCloseEnabled: galleryOptions.swipeToCloseEnabled ?? true,
@@ -132,17 +78,12 @@ export const useImageGallery = (
   }), [galleryOptions]);
 
   return {
-    // State
     visible,
     currentIndex,
     images,
-
-    // Actions
     open,
     close,
     setIndex,
-
-    // Gallery options
     options,
   };
 };

package/src/presentation/hooks/useImageMetadata.ts

@@ -0,0 +1,28 @@
+/**
+ * Presentation - Image Metadata Hook
+ */
+
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageMetadataService, type ImageMetadataExtractionOptions } from '../../infrastructure/services/ImageMetadataService';
+
+export const useImageMetadata = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const extractMetadata = useCallback((uri: string, options?: ImageMetadataExtractionOptions) =>
+        execute(() => ImageMetadataService.extractMetadata(uri, options), 'Failed to extract metadata'), [execute]);
+
+    const getBasicInfo = useCallback((uri: string) =>
+        execute(() => ImageMetadataService.getBasicInfo(uri), 'Failed to get basic info'), [execute]);
+
+    const hasMetadata = useCallback((uri: string) =>
+        execute(() => ImageMetadataService.hasMetadata(uri), 'Failed to check metadata'), [execute]);
+
+    return {
+        extractMetadata,
+        getBasicInfo,
+        hasMetadata,
+        isExtracting: isProcessing,
+        metadataError: error,
+    };
+};

package/src/presentation/hooks/useImageOperation.ts

@@ -1,28 +1,32 @@
-import { useState, useCallback } from 'react';
-
 /**
- * Generic hook to handle image operation states (loading, error)
- * adhering to DRY principles.
+ * Presentation - Image Operation Hook
+ * 
+ * Generic state management for async image operations
  */
+
+import { useState, useCallback } from 'react';
+import { ImageError } from '../../infrastructure/utils/ImageErrorHandler';
+
 export const useImageOperation = () => {
     const [isProcessing, setIsProcessing] = useState(false);
     const [error, setError] = useState<string | null>(null);
 
     const execute = useCallback(async <T>(
-        operation: () => Promise<T | null>,
+        operation: () => Promise<T>,
         errorMessage: string
     ): Promise<T | null> => {
         setIsProcessing(true);
         setError(null);
+        
         try {
             const result = await operation();
-            if (!result) {
-                setError(errorMessage);
-                return null;
-            }
             return result;
         } catch (err) {
-            setError(err instanceof Error ? err.message : errorMessage);
+            if (err instanceof ImageError) {
+                setError(err.message);
+            } else {
+                setError(err instanceof Error ? err.message : errorMessage);
+            }
             return null;
         } finally {
             setIsProcessing(false);

package/src/presentation/hooks/useImageTransform.ts

@@ -1,9 +1,15 @@
+/**
+ * Presentation - Image Transform Hook
+ */
 import { useCallback } from 'react';
 import { useImageOperation } from './useImageOperation';
 import { ImageTransformService } from '../../infrastructure/services/ImageTransformService';
+import { ImageAdvancedTransformService } from '../../infrastructure/services/ImageAdvancedTransformService';
 import type {
     ImageManipulateAction,
     ImageSaveOptions,
+    ImageCropArea,
+    ImageFlipOptions,
 } from '../../domain/entities/ImageTypes';
 
 export const useImageTransform = () => {
@@ -12,23 +18,23 @@ export const useImageTransform = () => {
     const resize = useCallback((uri: string, width?: number, height?: number, options?: ImageSaveOptions) =>
         execute(() => ImageTransformService.resize(uri, width, height, options), 'Failed to resize'), [execute]);
 
-    const crop = useCallback((uri: string, cropArea: any, options?: ImageSaveOptions) =>
+    const crop = useCallback((uri: string, cropArea: ImageCropArea, options?: ImageSaveOptions) =>
         execute(() => ImageTransformService.crop(uri, cropArea, options), 'Failed to crop'), [execute]);
 
     const rotate = useCallback((uri: string, degrees: number, options?: ImageSaveOptions) =>
         execute(() => ImageTransformService.rotate(uri, degrees, options), 'Failed to rotate'), [execute]);
 
-    const flip = useCallback((uri: string, flipParams: any, options?: ImageSaveOptions) =>
+    const flip = useCallback((uri: string, flipParams: ImageFlipOptions, options?: ImageSaveOptions) =>
         execute(() => ImageTransformService.flip(uri, flipParams, options), 'Failed to flip'), [execute]);
 
     const manipulate = useCallback((uri: string, action: ImageManipulateAction, options?: ImageSaveOptions) =>
-        execute(() => ImageTransformService.manipulate(uri, action, options), 'Failed to manipulate'), [execute]);
+        execute(() => ImageAdvancedTransformService.manipulate(uri, action, options), 'Failed to manipulate'), [execute]);
 
-    const resizeToFit = useCallback((uri: string, w: number, h: number, opts?: ImageSaveOptions) =>
-        execute(() => ImageTransformService.resizeToFit(uri, w, h, opts), 'Failed to resize to fit'), [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]);
 
-    const cropToSquare = useCallback((uri: string, w: number, h: number, opts?: ImageSaveOptions) =>
-        execute(() => ImageTransformService.cropToSquare(uri, w, h, opts), 'Failed to crop square'), [execute]);
+    const cropToSquare = useCallback((uri: string, width: number, height: number, options?: ImageSaveOptions) =>
+        execute(() => ImageAdvancedTransformService.cropToSquare(uri, width, height, options), 'Failed to crop square'), [execute]);
 
     return {
         resize, crop, rotate, flip, manipulate, resizeToFit, cropToSquare,