@umituz/react-native-image 1.1.0 → 1.1.2

package/src/presentation/hooks/useImage.ts

@@ -1,393 +1,22 @@
 /**
- * Image Domain - useImage Hook
- *
- * React hook for image manipulation operations.
- * Provides image resizing, cropping, rotating, and format conversion.
+ * useImage Hook
+ * 
+ * Aggregator hook that combines transformation and conversion capabilities.
+ * Kept simple and modular.
  */
 
-import { useState, useCallback } from 'react';
-import { ImageService } from '../../infrastructure/services/ImageService';
-import type {
-  ImageManipulateAction,
-  ImageSaveOptions,
-  ImageManipulationResult,
-  SaveFormat,
-} from '../../domain/entities/Image';
+import { useImageTransform } from './useImageTransform';
+import { useImageConversion } from './useImageConversion';
 
-/**
- * useImage hook for image manipulation
- *
- * USAGE:
- * ```typescript
- * const { resize, crop, rotate, compress, isProcessing } = useImage();
- *
- * // Resize image
- * const resized = await resize(imageUri, 800, 600);
- *
- * // Crop image
- * const cropped = await crop(imageUri, { originX: 0, originY: 0, width: 500, height: 500 });
- *
- * // Compress image
- * const compressed = await compress(imageUri, 0.7);
- * ```
- */
 export const useImage = () => {
-  const [isProcessing, setIsProcessing] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  /**
-   * Resize image
-   */
-  const resize = useCallback(
-    async (
-      uri: string,
-      width?: number,
-      height?: number,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.resize(uri, width, height, options);
-
-        if (!result) {
-          setError('Failed to resize image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to resize image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Crop image
-   */
-  const crop = useCallback(
-    async (
-      uri: string,
-      cropArea: { originX: number; originY: number; width: number; height: number },
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.crop(uri, cropArea, options);
-
-        if (!result) {
-          setError('Failed to crop image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to crop image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Rotate image
-   */
-  const rotate = useCallback(
-    async (
-      uri: string,
-      degrees: number,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.rotate(uri, degrees, options);
-
-        if (!result) {
-          setError('Failed to rotate image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to rotate image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Flip image
-   */
-  const flip = useCallback(
-    async (
-      uri: string,
-      flipOptions: { horizontal?: boolean; vertical?: boolean },
-      saveOptions?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.flip(uri, flipOptions, saveOptions);
-
-        if (!result) {
-          setError('Failed to flip image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to flip image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Perform multiple manipulations
-   */
-  const manipulate = useCallback(
-    async (
-      uri: string,
-      action: ImageManipulateAction,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.manipulate(uri, action, options);
-
-        if (!result) {
-          setError('Failed to manipulate image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to manipulate image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Compress image
-   */
-  const compress = useCallback(
-    async (uri: string, quality: number = 0.8): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.compress(uri, quality);
-
-        if (!result) {
-          setError('Failed to compress image');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to compress image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Resize to fit within max dimensions
-   */
-  const resizeToFit = useCallback(
-    async (
-      uri: string,
-      maxWidth: number,
-      maxHeight: number,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.resizeToFit(uri, maxWidth, maxHeight, options);
-
-        if (!result) {
-          setError('Failed to resize image to fit');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to resize image to fit';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Create thumbnail
-   */
-  const createThumbnail = useCallback(
-    async (
-      uri: string,
-      size: number = 200,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.createThumbnail(uri, size, options);
-
-        if (!result) {
-          setError('Failed to create thumbnail');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to create thumbnail';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Crop to square
-   */
-  const cropToSquare = useCallback(
-    async (
-      uri: string,
-      width: number,
-      height: number,
-      options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.cropToSquare(uri, width, height, options);
-
-        if (!result) {
-          setError('Failed to crop to square');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to crop to square';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Convert image format
-   */
-  const convertFormat = useCallback(
-    async (
-      uri: string,
-      format: SaveFormat,
-      quality?: number
-    ): Promise<ImageManipulationResult | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const result = await ImageService.convertFormat(uri, format, quality);
-
-        if (!result) {
-          setError('Failed to convert image format');
-        }
-
-        return result;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to convert image format';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
-
-  /**
-   * Save image to device
-   */
-  const saveImage = useCallback(
-    async (uri: string, filename?: string): Promise<string | null> => {
-      setIsProcessing(true);
-      setError(null);
-
-      try {
-        const savedUri = await ImageService.saveImage(uri, filename);
-
-        if (!savedUri) {
-          setError('Failed to save image');
-        }
-
-        return savedUri;
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : 'Failed to save image';
-        setError(errorMessage);
-        return null;
-      } finally {
-        setIsProcessing(false);
-      }
-    },
-    []
-  );
+  const transform = useImageTransform();
+  const conversion = useImageConversion();
 
   return {
-    // Functions
-    resize,
-    crop,
-    rotate,
-    flip,
-    manipulate,
-    compress,
-    resizeToFit,
-    createThumbnail,
-    cropToSquare,
-    convertFormat,
-    saveImage,
-
-    // State
-    isProcessing,
-    error,
+    ...transform,
+    ...conversion,
+    // Combined state
+    isProcessing: transform.isTransforming || conversion.isConverting,
+    error: transform.transformError || conversion.conversionError,
   };
 };
-

package/src/presentation/hooks/useImageConversion.ts

@@ -0,0 +1,26 @@
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageConversionService } from '../../infrastructure/services/ImageConversionService';
+import { ImageStorageService } from '../../infrastructure/services/ImageStorageService';
+import type { ImageSaveOptions, SaveFormat } from '../../domain/entities/ImageTypes';
+
+export const useImageConversion = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    const compress = useCallback((uri: string, quality: number = 0.8) =>
+        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]);
+
+    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]);
+
+    return {
+        compress, convertFormat, createThumbnail, saveImage,
+        isConverting: isProcessing, conversionError: error,
+    };
+};

package/src/presentation/hooks/useImageGallery.ts

@@ -10,7 +10,7 @@ import { ImageViewerService } from '../../infrastructure/services/ImageViewerSer
 import type {
   ImageViewerItem,
   ImageGalleryOptions,
-} from '../../domain/entities/Image';
+} from '../../domain/entities/ImageTypes';
 
 /**
  * useImageGallery hook return type

package/src/presentation/hooks/useImageOperation.ts

@@ -0,0 +1,33 @@
+import { useState, useCallback } from 'react';
+
+/**
+ * Generic hook to handle image operation states (loading, error)
+ * adhering to DRY principles.
+ */
+export const useImageOperation = () => {
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    const execute = useCallback(async <T>(
+        operation: () => Promise<T | null>,
+        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);
+            return null;
+        } finally {
+            setIsProcessing(false);
+        }
+    }, []);
+
+    return { isProcessing, error, execute };
+};

package/src/presentation/hooks/useImageTransform.ts

@@ -0,0 +1,37 @@
+import { useCallback } from 'react';
+import { useImageOperation } from './useImageOperation';
+import { ImageTransformService } from '../../infrastructure/services/ImageTransformService';
+import type {
+    ImageManipulateAction,
+    ImageSaveOptions,
+} from '../../domain/entities/ImageTypes';
+
+export const useImageTransform = () => {
+    const { isProcessing, error, execute } = useImageOperation();
+
+    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) =>
+        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) =>
+        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]);
+
+    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 cropToSquare = useCallback((uri: string, w: number, h: number, opts?: ImageSaveOptions) =>
+        execute(() => ImageTransformService.cropToSquare(uri, w, h, opts), 'Failed to crop square'), [execute]);
+
+    return {
+        resize, crop, rotate, flip, manipulate, resizeToFit, cropToSquare,
+        isTransforming: isProcessing, transformError: error,
+    };
+};