@umituz/react-native-image 1.1.3 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-image",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Image manipulation and viewing for React Native apps - resize, crop, rotate, flip, compress, gallery viewer",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -56,4 +56,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/src/domain/entities/ImageConstants.ts

@@ -1,21 +1,38 @@
 /**
- * Image Constants
+ * Image Domain - Configuration Constants
  */
 import { SaveFormat } from "./ImageTypes";
 
-export const IMAGE_CONSTANTS = {
-    MAX_WIDTH: 2048,
-    MAX_HEIGHT: 2048,
-    DEFAULT_QUALITY: 0.8,
-    THUMBNAIL_SIZE: 200,
-    COMPRESS_QUALITY: {
-        LOW: 0.5,
-        MEDIUM: 0.7,
-        HIGH: 0.9,
+export interface ImageConfiguration {
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+    readonly defaultQuality: number;
+    readonly thumbnailSize: number;
+    readonly compressQuality: {
+        readonly low: number;
+        readonly medium: number;
+        readonly high: number;
+    };
+    readonly format: {
+        readonly jpeg: SaveFormat;
+        readonly png: SaveFormat;
+        readonly webp: SaveFormat;
+    };
+}
+
+export const IMAGE_CONSTANTS: ImageConfiguration = {
+    maxWidth: 2048,
+    maxHeight: 2048,
+    defaultQuality: 0.8,
+    thumbnailSize: 200,
+    compressQuality: {
+        low: 0.5,
+        medium: 0.7,
+        high: 0.9,
     },
-    FORMAT: {
-        JPEG: 'jpeg' as SaveFormat,
-        PNG: 'png' as SaveFormat,
-        WEBP: 'webp' as SaveFormat,
+    format: {
+        jpeg: 'jpeg' as SaveFormat,
+        png: 'png' as SaveFormat,
+        webp: 'webp' as SaveFormat,
     },
-} as const;
+};

package/src/domain/entities/ImageTypes.ts

@@ -1,5 +1,5 @@
 /**
- * Image Type Definitions
+ * Image Domain - Core Type Definitions
  */
 
 export enum ImageFormat {
@@ -16,11 +16,28 @@ export enum ImageOrientation {
     SQUARE = 'square',
 }
 
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+
+export interface ImageCropArea {
+    originX: number;
+    originY: number;
+    width: number;
+    height: number;
+}
+
+export interface ImageFlipOptions {
+    vertical?: boolean;
+    horizontal?: boolean;
+}
+
 export interface ImageManipulateAction {
-    resize?: { width?: number; height?: number };
-    crop?: { originX: number; originY: number; width: number; height: number };
+    resize?: Partial<ImageDimensions>;
+    crop?: ImageCropArea;
     rotate?: number;
-    flip?: { vertical?: boolean; horizontal?: boolean };
+    flip?: ImageFlipOptions;
 }
 
 export interface ImageSaveOptions {
@@ -36,10 +53,8 @@ export interface ImageManipulationResult {
     base64?: string;
 }
 
-export interface ImageMetadata {
+export interface ImageMetadata extends ImageDimensions {
     uri: string;
-    width: number;
-    height: number;
     format?: ImageFormat;
     size?: number;
     orientation?: ImageOrientation;

package/src/domain/utils/ImageUtils.ts

@@ -1,7 +1,7 @@
 /**
- * Image Utilities
+ * Image Domain - Utility Functions
  */
-import { ImageFormat, ImageOrientation, ImageManipulateAction } from "../entities/ImageTypes";
+import { ImageFormat, ImageOrientation, ImageDimensions, ImageCropArea } from "../entities/ImageTypes";
 import { IMAGE_CONSTANTS } from "../entities/ImageConstants";
 
 export class ImageUtils {
@@ -20,7 +20,7 @@ export class ImageUtils {
         height: number,
         maxWidth: number,
         maxHeight: number
-    ): { width: number; height: number } {
+    ): ImageDimensions {
         const aspectRatio = ImageUtils.getAspectRatio(width, height);
         let newWidth = width;
         let newHeight = height;
@@ -44,8 +44,8 @@ export class ImageUtils {
     static getThumbnailSize(
         width: number,
         height: number,
-        thumbnailSize: number = IMAGE_CONSTANTS.THUMBNAIL_SIZE
-    ): { width: number; height: number } {
+        thumbnailSize: number = IMAGE_CONSTANTS.thumbnailSize
+    ): ImageDimensions {
         return ImageUtils.fitToSize(width, height, thumbnailSize, thumbnailSize);
     }
 
@@ -77,7 +77,7 @@ export class ImageUtils {
         }
     }
 
-    static getSquareCrop(width: number, height: number): { originX: number; originY: number; width: number; height: number } {
+    static getSquareCrop(width: number, height: number): ImageCropArea {
         const size = Math.min(width, height);
         const originX = (width - size) / 2;
         const originY = (height - size) / 2;

package/src/index.ts

@@ -21,6 +21,9 @@ export type {
   ImageGalleryOptions,
   ImageOperationResult,
   SaveFormat,
+  ImageDimensions,
+  ImageCropArea,
+  ImageFlipOptions,
 } from './domain/entities/ImageTypes';
 
 export {
@@ -36,6 +39,7 @@ export { ImageUtils } from './domain/utils/ImageUtils';
 // =============================================================================
 
 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 {

package/src/infrastructure/services/ImageAdvancedTransformService.ts

@@ -0,0 +1,106 @@
+/**
+ * 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/ImageConversionService.ts

@@ -1,8 +1,7 @@
 /**
- * Image Conversion Service
+ * Image Infrastructure - Conversion Service
  * 
- * Handles format conversion, compression, and thumbnail generation.
- * (Thumbnail is treated as a specialized compression/resize)
+ * Handles format conversion, compression, and thumbnail generation
  */
 
 import * as ImageManipulator from 'expo-image-manipulator';
@@ -13,20 +12,33 @@ import type {
 } from '../../domain/entities/ImageTypes';
 import { IMAGE_CONSTANTS } from '../../domain/entities/ImageConstants';
 import { ImageTransformService } from './ImageTransformService';
+import { ImageAdvancedTransformService } from './ImageAdvancedTransformService';
+import { ImageValidator } from '../utils/ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
 
 export class ImageConversionService {
     static async compress(
         uri: string,
-        quality: number = IMAGE_CONSTANTS.DEFAULT_QUALITY
-    ): Promise<ImageManipulationResult | null> {
+        quality: number = IMAGE_CONSTANTS.defaultQuality
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'compress');
+            }
+
+            const qualityValidation = ImageValidator.validateQuality(quality);
+            if (!qualityValidation.isValid) {
+                throw ImageErrorHandler.createError(qualityValidation.error!, IMAGE_ERROR_CODES.INVALID_QUALITY, 'compress');
+            }
+
             return await ImageManipulator.manipulateAsync(
                 uri,
                 [],
                 { compress: quality }
             );
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'compress');
         }
     }
 
@@ -34,33 +46,54 @@ export class ImageConversionService {
         uri: string,
         format: SaveFormat,
         quality?: number
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'convertFormat');
+            }
+
+            const compressQuality = quality ?? IMAGE_CONSTANTS.defaultQuality;
+            const qualityValidation = ImageValidator.validateQuality(compressQuality);
+            if (!qualityValidation.isValid) {
+                throw ImageErrorHandler.createError(qualityValidation.error!, IMAGE_ERROR_CODES.INVALID_QUALITY, 'convertFormat');
+            }
+
             return await ImageManipulator.manipulateAsync(
                 uri,
                 [],
                 {
-                    compress: quality || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(format),
+                    compress: compressQuality,
+                    format: ImageTransformService['mapFormat'](format),
                 }
             );
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'convertFormat');
         }
     }
 
     static async createThumbnail(
         uri: string,
-        size: number = IMAGE_CONSTANTS.THUMBNAIL_SIZE,
+        size: number = IMAGE_CONSTANTS.thumbnailSize,
         options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
-            return ImageTransformService.resizeToFit(uri, size, size, {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'createThumbnail');
+            }
+
+            const dimValidation = ImageValidator.validateDimensions({ width: size, height: size });
+            if (!dimValidation.isValid) {
+                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'createThumbnail');
+            }
+
+            return await ImageAdvancedTransformService.resizeToFit(uri, size, size, {
                 ...options,
-                compress: options?.compress || IMAGE_CONSTANTS.COMPRESS_QUALITY.MEDIUM,
+                compress: options?.compress ?? IMAGE_CONSTANTS.compressQuality.medium,
             });
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'createThumbnail');
         }
     }
 }

package/src/infrastructure/services/ImageStorageService.ts

@@ -1,22 +1,37 @@
 /**
- * Image Storage Service
+ * Image Infrastructure - Storage Service
  * 
- * Handles saving images to the device filesystem.
- * Wraps @umituz/react-native-filesystem.
+ * Handles saving images to the device filesystem
  */
 
 import { FileSystemService } from '@umituz/react-native-filesystem';
+import { ImageValidator } from '../utils/ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
 
 export class ImageStorageService {
     static async saveImage(
         uri: string,
         filename?: string
-    ): Promise<string | null> {
+    ): Promise<string> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'saveImage');
+            }
+
             const result = await FileSystemService.copyToDocuments(uri, filename);
-            return result.success && result.uri ? result.uri : null;
-        } catch {
-            return null;
+            
+            if (!result.success || !result.uri) {
+                throw ImageErrorHandler.createError(
+                    'Failed to save image to filesystem',
+                    IMAGE_ERROR_CODES.STORAGE_FAILED,
+                    'saveImage'
+                );
+            }
+
+            return result.uri;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'saveImage');
         }
     }
 }

package/src/infrastructure/services/ImageTransformService.ts

@@ -1,8 +1,7 @@
 /**
- * Image Transform Service
+ * Image Infrastructure - Transform Service
  * 
- * Handles basic geometric transformations: resize, crop, rotate, flip.
- * Also handles combined manipulations.
+ * Handles geometric transformations: resize, crop, rotate, flip
  */
 
 import * as ImageManipulator from 'expo-image-manipulator';
@@ -11,58 +10,79 @@ import type {
     ImageSaveOptions,
     ImageManipulationResult,
     SaveFormat,
+    ImageCropArea,
+    ImageFlipOptions,
 } from '../../domain/entities/ImageTypes';
 import { IMAGE_CONSTANTS } from '../../domain/entities/ImageConstants';
 import { ImageUtils } from '../../domain/utils/ImageUtils';
+import { ImageValidator } from '../utils/ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
 
 export class ImageTransformService {
-    /**
-     * Helper to map SaveFormat to Manipulator format
-     */
-    static mapFormat(format?: SaveFormat): ImageManipulator.SaveFormat {
+    private static mapFormat(format?: SaveFormat): ImageManipulator.SaveFormat {
         if (format === 'png') return ImageManipulator.SaveFormat.PNG;
         if (format === 'webp') return ImageManipulator.SaveFormat.WEBP;
         return ImageManipulator.SaveFormat.JPEG;
     }
 
+    private static buildSaveOptions(options?: ImageSaveOptions): ImageManipulator.SaveOptions {
+        return {
+            compress: options?.compress ?? IMAGE_CONSTANTS.defaultQuality,
+            format: this.mapFormat(options?.format),
+            base64: options?.base64,
+        };
+    }
+
     static async resize(
         uri: string,
         width?: number,
         height?: number,
         options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'resize');
+            }
+
+            const dimValidation = ImageValidator.validateDimensions({ width, height });
+            if (!dimValidation.isValid) {
+                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'resize');
+            }
+
             return await ImageManipulator.manipulateAsync(
                 uri,
                 [{ resize: { width, height } }],
-                {
-                    compress: options?.compress || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(options?.format),
-                    base64: options?.base64,
-                }
+                this.buildSaveOptions(options)
             );
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'resize');
         }
     }
 
     static async crop(
         uri: string,
-        cropArea: { originX: number; originY: number; width: number; height: number },
+        cropArea: ImageCropArea,
         options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'crop');
+            }
+
+            const dimValidation = ImageValidator.validateDimensions(cropArea);
+            if (!dimValidation.isValid) {
+                throw ImageErrorHandler.createError(dimValidation.error!, IMAGE_ERROR_CODES.INVALID_DIMENSIONS, 'crop');
+            }
+
             return await ImageManipulator.manipulateAsync(
                 uri,
                 [{ crop: cropArea }],
-                {
-                    compress: options?.compress || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(options?.format),
-                    base64: options?.base64,
-                }
+                this.buildSaveOptions(options)
             );
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'crop');
         }
     }
 
@@ -70,28 +90,39 @@ export class ImageTransformService {
         uri: string,
         degrees: number,
         options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'rotate');
+            }
+
+            const rotationValidation = ImageValidator.validateRotation(degrees);
+            if (!rotationValidation.isValid) {
+                throw ImageErrorHandler.createError(rotationValidation.error!, IMAGE_ERROR_CODES.VALIDATION_ERROR, 'rotate');
+            }
+
             return await ImageManipulator.manipulateAsync(
                 uri,
                 [{ rotate: degrees }],
-                {
-                    compress: options?.compress || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(options?.format),
-                    base64: options?.base64,
-                }
+                this.buildSaveOptions(options)
             );
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'rotate');
         }
     }
 
     static async flip(
         uri: string,
-        flip: { horizontal?: boolean; vertical?: boolean },
+        flip: ImageFlipOptions,
         options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
+    ): Promise<ImageManipulationResult> {
         try {
+            const uriValidation = ImageValidator.validateUri(uri);
+            if (!uriValidation.isValid) {
+                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'flip');
+            }
+
             const actions: ImageManipulator.Action[] = [];
             if (flip.horizontal) actions.push({ flip: ImageManipulator.FlipType.Horizontal });
             if (flip.vertical) actions.push({ flip: ImageManipulator.FlipType.Vertical });
@@ -99,74 +130,10 @@ export class ImageTransformService {
             return await ImageManipulator.manipulateAsync(
                 uri,
                 actions,
-                {
-                    compress: options?.compress || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(options?.format),
-                    base64: options?.base64,
-                }
-            );
-        } catch {
-            return null;
-        }
-    }
-
-    static async manipulate(
-        uri: string,
-        action: ImageManipulateAction,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
-        try {
-            const actions: ImageManipulator.Action[] = [];
-            if (action.resize) actions.push({ resize: action.resize });
-            if (action.crop) {
-                // @ts-ignore - guarded by check above
-                actions.push({ crop: action.crop });
-            }
-            if (action.rotate) 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,
-                {
-                    compress: options?.compress || IMAGE_CONSTANTS.DEFAULT_QUALITY,
-                    format: ImageTransformService.mapFormat(options?.format),
-                    base64: options?.base64,
-                }
+                this.buildSaveOptions(options)
             );
-        } catch {
-            return null;
-        }
-    }
-
-    static async resizeToFit(
-        uri: string,
-        maxWidth: number,
-        maxHeight: number,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
-        try {
-            const dimensions = ImageUtils.fitToSize(maxWidth, maxHeight, maxWidth, maxHeight);
-            return ImageTransformService.resize(uri, dimensions.width, dimensions.height, options);
-        } catch {
-            return null;
-        }
-    }
-
-    static async cropToSquare(
-        uri: string,
-        width: number,
-        height: number,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult | null> {
-        try {
-            const cropArea = ImageUtils.getSquareCrop(width, height);
-            return ImageTransformService.crop(uri, cropArea, options);
-        } catch {
-            return null;
+        } catch (error) {
+            throw ImageErrorHandler.handleUnknownError(error, 'flip');
         }
     }
 }

package/src/infrastructure/services/ImageViewerService.ts

@@ -1,8 +1,7 @@
 /**
- * Image Domain - Image Viewer Service
+ * Image Infrastructure - Viewer Service
  *
- * Service for image viewing and gallery using react-native-image-viewing.
- * Provides full-screen image viewer with zoom, swipe, and gallery features.
+ * Provides configuration for react-native-image-viewing component
  */
 
 import type {
@@ -10,9 +9,6 @@ import type {
   ImageGalleryOptions,
 } from '../../domain/entities/ImageTypes';
 
-/**
- * Image viewer configuration
- */
 export interface ImageViewerConfig {
   images: ImageViewerItem[];
   index?: number;
@@ -21,26 +17,11 @@ export interface ImageViewerConfig {
   options?: ImageGalleryOptions;
 }
 
-/**
- * Image viewer service
- *
- * NOTE: This service provides configuration for react-native-image-viewing component.
- * The actual viewer component is rendered in the presentation layer.
- */
 export class ImageViewerService {
-  /**
-   * Prepare images for viewer
-   * Converts image URIs to viewer format
-   */
   static prepareImages(uris: string[]): ImageViewerItem[] {
-    return uris.map(uri => ({
-      uri,
-    }));
+    return uris.map(uri => ({ uri }));
   }
 
-  /**
-   * Prepare images with metadata
-   */
   static prepareImagesWithMetadata(items: ImageViewerItem[]): ImageViewerItem[] {
     return items.map(item => ({
       uri: item.uri,
@@ -51,9 +32,6 @@ export class ImageViewerService {
     }));
   }
 
-  /**
-   * Create viewer configuration
-   */
   static createViewerConfig(
     images: ImageViewerItem[],
     startIndex: number = 0,
@@ -74,9 +52,6 @@ export class ImageViewerService {
     };
   }
 
-  /**
-   * Get default gallery options
-   */
   static getDefaultOptions(): ImageGalleryOptions {
     return {
       index: 0,

package/src/infrastructure/utils/ImageErrorHandler.ts

@@ -0,0 +1,40 @@
+/**
+ * Image Infrastructure - Error Handler
+ */
+export class ImageError extends Error {
+    constructor(
+        message: string,
+        public readonly code: string,
+        public readonly operation?: string
+    ) {
+        super(message);
+        this.name = 'ImageError';
+    }
+}
+
+export const IMAGE_ERROR_CODES = {
+    INVALID_URI: 'INVALID_URI',
+    INVALID_DIMENSIONS: 'INVALID_DIMENSIONS',
+    INVALID_QUALITY: 'INVALID_QUALITY',
+    MANIPULATION_FAILED: 'MANIPULATION_FAILED',
+    CONVERSION_FAILED: 'CONVERSION_FAILED',
+    STORAGE_FAILED: 'STORAGE_FAILED',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+} as const;
+
+export type ImageErrorCode = typeof IMAGE_ERROR_CODES[keyof typeof IMAGE_ERROR_CODES];
+
+export class ImageErrorHandler {
+    static createError(message: string, code: ImageErrorCode, operation?: string): ImageError {
+        return new ImageError(message, code, operation);
+    }
+
+    static handleUnknownError(error: unknown, operation?: string): ImageError {
+        if (error instanceof ImageError) {
+            return error;
+        }
+        
+        const message = error instanceof Error ? error.message : 'Unknown error occurred';
+        return new ImageError(message, IMAGE_ERROR_CODES.MANIPULATION_FAILED, operation);
+    }
+}

package/src/infrastructure/utils/ImageValidator.ts

@@ -0,0 +1,59 @@
+/**
+ * Image Infrastructure - Validation Utilities
+ */
+import { ImageDimensions } from '../../domain/entities/ImageTypes';
+
+export interface ValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+
+export class ImageValidator {
+    static validateUri(uri: string): ValidationResult {
+        if (!uri || typeof uri !== 'string') {
+            return { isValid: false, error: 'URI is required and must be a string' };
+        }
+        
+        if (!uri.startsWith('file://') && 
+            !uri.startsWith('content://') && 
+            !uri.startsWith('http://') && 
+            !uri.startsWith('https://') && 
+            !uri.startsWith('data:image/')) {
+            return { isValid: false, error: 'Invalid URI format' };
+        }
+        
+        return { isValid: true };
+    }
+
+    static validateDimensions(dimensions: Partial<ImageDimensions>): ValidationResult {
+        if (dimensions.width !== undefined) {
+            if (typeof dimensions.width !== 'number' || dimensions.width <= 0) {
+                return { isValid: false, error: 'Width must be a positive number' };
+            }
+        }
+        
+        if (dimensions.height !== undefined) {
+            if (typeof dimensions.height !== 'number' || dimensions.height <= 0) {
+                return { isValid: false, error: 'Height must be a positive number' };
+            }
+        }
+        
+        return { isValid: true };
+    }
+
+    static validateQuality(quality: number): ValidationResult {
+        if (typeof quality !== 'number' || quality < 0 || quality > 1) {
+            return { isValid: false, error: 'Quality must be a number between 0 and 1' };
+        }
+        
+        return { isValid: true };
+    }
+
+    static validateRotation(degrees: number): ValidationResult {
+        if (typeof degrees !== 'number') {
+            return { isValid: false, error: 'Degrees must be a number' };
+        }
+        
+        return { isValid: true };
+    }
+}

package/src/presentation/components/GalleryHeader.tsx

@@ -1,25 +1,28 @@
 /**
- * GalleryHeader Component
- * Header for ImageGallery with edit and close buttons
+ * Presentation - Gallery Header Component
  * 
- * This component should be implemented by the consumer app
- * using their own design system and safe area handling.
+ * NOTE: This component should be implemented by consumer app
+ * using their design system and safe area handling
  */
 
 import React from 'react';
 import { View, TouchableOpacity, StyleSheet, Text } from 'react-native';
 
 interface GalleryHeaderProps {
-    onEdit: () => void;
+    onEdit?: () => void;
     onClose: () => void;
 }
 
 export function GalleryHeader({ onEdit, onClose }: GalleryHeaderProps) {
     return (
         <View style={styles.container}>
-            <TouchableOpacity style={styles.button} onPress={onEdit}>
-                <Text style={styles.buttonText}>Edit</Text>
-            </TouchableOpacity>
+            {onEdit ? (
+                <TouchableOpacity style={styles.button} onPress={onEdit}>
+                    <Text style={styles.buttonText}>Edit</Text>
+                </TouchableOpacity>
+            ) : (
+                <View style={styles.spacer} />
+            )}
 
             <TouchableOpacity style={styles.button} onPress={onClose}>
                 <Text style={styles.buttonText}>✕</Text>
@@ -42,6 +45,9 @@ const styles = StyleSheet.create({
         alignItems: 'center',
         backgroundColor: 'rgba(0, 0, 0, 0.5)',
     },
+    spacer: {
+        width: 48,
+    },
     button: {
         flexDirection: 'row',
         alignItems: 'center',

package/src/presentation/components/ImageGallery.tsx

@@ -1,14 +1,12 @@
 /**
- * Image Gallery Component
+ * Presentation - Image Gallery Component
  * 
- * A wrapper around react-native-image-viewing that provides
- * theme integration, standard configuration, and optional editing.
+ * Wrapper around react-native-image-viewing with theme integration
  */
 
 import React, { useCallback } from 'react';
 import ImageViewing from 'react-native-image-viewing';
-import * as ImageManipulator from 'expo-image-manipulator';
-import { useAppDesignTokens } from '@umituz/react-native-design-system-theme';
+// import { useAppDesignTokens } from '@umituz/react-native-design-system-theme';
 import type { ImageViewerItem, ImageGalleryOptions } from '../../domain/entities/ImageTypes';
 import { GalleryHeader } from './GalleryHeader';
 
@@ -33,14 +31,14 @@ export const ImageGallery: React.FC<ImageGalleryProps> = ({
     onImageChange,
     enableEditing = false,
 }) => {
-    const tokens = useAppDesignTokens();
+    // const tokens = useAppDesignTokens();
     const [currentIndex, setCurrentIndex] = React.useState(index);
 
     React.useEffect(() => {
         setCurrentIndex(index);
     }, [index]);
 
-    const bg = backgroundColor || tokens.colors.backgroundPrimary;
+    const bg = backgroundColor || '#000000';
 
     const viewerImages = React.useMemo(
         () => images.map((img) => ({ uri: img.uri })),
@@ -52,20 +50,9 @@ export const ImageGallery: React.FC<ImageGalleryProps> = ({
         if (!currentImage || !onImageChange) return;
 
         try {
-            const result = await ImageManipulator.manipulateAsync(
-                currentImage.uri,
-                [],
-                {
-                    compress: 1,
-                    format: ImageManipulator.SaveFormat.JPEG,
-                }
-            );
-
-            if (result.uri) {
-                await onImageChange(result.uri, currentIndex);
-            }
+            await onImageChange(currentImage.uri, currentIndex);
         } catch (error) {
-            // Silent fail
+            // Consumer should handle editing logic
         }
     }, [images, currentIndex, onImageChange]);
 
@@ -78,10 +65,9 @@ export const ImageGallery: React.FC<ImageGalleryProps> = ({
     );
 
     const headerComponent = useCallback(() => {
-        if (!enableEditing) return null;
         return (
             <GalleryHeader
-                onEdit={handleEdit}
+                onEdit={enableEditing ? handleEdit : undefined}
                 onClose={onDismiss}
             />
         );

package/src/presentation/hooks/useImage.ts

@@ -1,8 +1,7 @@
 /**
- * useImage Hook
+ * Presentation - Image Hook
  * 
- * Aggregator hook that combines transformation and conversion capabilities.
- * Kept simple and modular.
+ * Aggregator hook combining transformation and conversion capabilities
  */
 
 import { useImageTransform } from './useImageTransform';

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/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/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,