@umituz/react-native-image 1.3.9 → 1.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-image",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "description": "Image manipulation and viewing for React Native apps - resize, crop, rotate, flip, compress, gallery viewer",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -40,7 +40,8 @@
     "react": ">=18.2.0",
     "react-native": ">=0.74.0",
     "react-native-gesture-handler": ">=2.0.0",
-    "react-native-reanimated": ">=3.0.0"
+    "react-native-reanimated": ">=3.0.0",
+    "@react-native-community/slider": ">=4.0.0"
   },
   "devDependencies": {
     "@umituz/react-native-design-system": "latest",
@@ -51,8 +52,13 @@
     "@types/react": "~19.1.10",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "react-native-gesture-handler": "~2.16.1",
+    "react-native-gesture-handler": "^2.20.0",
     "react-native-reanimated": "~3.16.1",
+    "react-native-safe-area-context": ">=4.0.0",
+    "@react-native-async-storage/async-storage": ">=1.0.0",
+    "zustand": ">=4.0.0",
+    "@umituz/react-native-filesystem": "latest",
+    "@react-native-community/slider": ">=4.0.0",
     "typescript": "~5.9.2"
   },
   "publishConfig": {

package/src/index.ts

@@ -78,6 +78,9 @@ export { ImageTemplateService } from './infrastructure/services/ImageTemplateSer
 // =============================================================================
 
 export { ImageGallery, type ImageGalleryProps } from './presentation/components/ImageGallery';
+export { TextEditorSheet, type TextEditorSheetProps } from './presentation/components/editor/TextEditorSheet';
+export { StickerPickerSheet, type StickerPickerSheetProps } from './presentation/components/editor/StickerPickerSheet';
+export { FilterPickerSheet, type FilterPickerSheetProps } from './presentation/components/editor/FilterPickerSheet';
 
 export { useImage } from './presentation/hooks/useImage';
 export { useImageTransform } from './presentation/hooks/useImageTransform';

package/src/infrastructure/services/ImageConversionService.ts

@@ -12,9 +12,9 @@ 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';
+import { ImageTransformUtils } from '../utils/ImageTransformUtils';
 
 export class ImageConversionService {
     static async compress(
@@ -22,15 +22,8 @@ export class ImageConversionService {
         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');
-            }
+            ImageValidator.validateUri(uri);
+            ImageValidator.validateQuality(quality);
 
             return await ImageManipulator.manipulateAsync(
                 uri,
@@ -48,23 +41,14 @@ export class ImageConversionService {
         quality?: number
     ): Promise<ImageManipulationResult> {
         try {
-            const uriValidation = ImageValidator.validateUri(uri);
-            if (!uriValidation.isValid) {
-                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'convertFormat');
-            }
-
+            ImageValidator.validateUri(uri);
             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: compressQuality,
-                    format: ImageTransformService['mapFormat'](format),
+                    format: ImageTransformUtils.mapFormat(format),
                 }
             );
         } catch (error) {
@@ -78,17 +62,8 @@ export class ImageConversionService {
         options?: ImageSaveOptions
     ): Promise<ImageManipulationResult> {
         try {
-            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, {
+            ImageValidator.validateUri(uri);
+            return await ImageTransformService.resizeToFit(uri, size, size, {
                 ...options,
                 compress: options?.compress ?? IMAGE_CONSTANTS.compressQuality.medium,
             });

package/src/infrastructure/services/ImageEditorService.ts

@@ -1,13 +1,18 @@
 /**
- * Infrastructure - Advanced Editor Service
+ * Infrastructure - Editor Service
  * 
- * Core editing functionality with history management
+ * Core editing functionality with layer and tool management
  */
 
-import { EditorTool, type EditorState, type EditorLayer, type EditorHistory, type EditorOptions } from '../../domain/entities/EditorTypes';
-import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
-import { ImageValidator } from '../utils/ImageValidator';
+import { 
+  EditorTool, 
+  type EditorState, 
+  type EditorLayer, 
+  type EditorHistory, 
+  type EditorOptions 
+} from '../../domain/entities/EditorTypes';
 import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+import { ImageEditorHistoryUtils } from '../utils/ImageEditorHistoryUtils';
 
 export class ImageEditorService {
   private static generateId(): string {
@@ -45,10 +50,7 @@ export class ImageEditorService {
     };
   }
 
-  static addLayer(
-    state: EditorState,
-    name?: string
-  ): EditorState {
+  static addLayer(state: EditorState, name?: string): EditorState {
     const newLayer: EditorLayer = {
       id: ImageEditorService.generateId(),
       name: name || `Layer ${state.layers.length}`,
@@ -58,177 +60,68 @@ export class ImageEditorService {
       elements: [],
     };
 
-    const newHistory: EditorHistory = {
-      id: ImageEditorService.generateId(),
-      timestamp: new Date(),
-      layers: [...state.layers, newLayer],
-    };
-
-    const newHistoryState = ImageEditorService.addToHistory(state, newHistory);
-
-    return {
-      ...newHistoryState,
-      layers: [...state.layers, newLayer],
+    return ImageEditorService.commitHistory(state, [...state.layers, newLayer], {
       selectedLayer: newLayer.id,
-      isDirty: true,
-    };
+    });
   }
 
-  static removeLayer(
-    state: EditorState,
-    layerId: string
-  ): EditorState {
+  static removeLayer(state: EditorState, layerId: string): EditorState {
     if (state.layers.length <= 1) {
-      throw ImageErrorHandler.createError(
-        'Cannot remove the last layer',
-        IMAGE_ERROR_CODES.VALIDATION_ERROR,
-        'removeLayer'
-      );
+      throw ImageErrorHandler.createError('Cannot remove background', IMAGE_ERROR_CODES.VALIDATION_ERROR, 'removeLayer');
     }
 
     const newLayers = state.layers.filter(layer => layer.id !== layerId);
-    const newHistory: EditorHistory = {
-      id: ImageEditorService.generateId(),
-      timestamp: new Date(),
-      layers: newLayers,
-    };
-
-    const newHistoryState = ImageEditorService.addToHistory(state, newHistory);
-
-    return {
-      ...newHistoryState,
-      layers: newLayers,
+    return ImageEditorService.commitHistory(state, newLayers, {
       selectedLayer: newLayers[0].id,
-      isDirty: true,
-    };
+    });
   }
 
-  static updateLayer(
-    state: EditorState,
-    layerId: string,
-    updates: Partial<EditorLayer>
-  ): EditorState {
-    const newLayers = state.layers.map(layer =>
-      layer.id === layerId ? { ...layer, ...updates } : layer
-    );
-
-    const newHistory: EditorHistory = {
-      id: ImageEditorService.generateId(),
-      timestamp: new Date(),
-      layers: newLayers,
-    };
-
-    const newHistoryState = ImageEditorService.addToHistory(state, newHistory);
-
-    return {
-      ...newHistoryState,
-      layers: newLayers,
-      isDirty: true,
-    };
+  static updateLayer(state: EditorState, layerId: string, updates: Partial<EditorLayer>): EditorState {
+    const newLayers = state.layers.map(layer => layer.id === layerId ? { ...layer, ...updates } : layer);
+    return ImageEditorService.commitHistory(state, newLayers);
   }
 
-  static addElementToLayer(
-    state: EditorState,
-    layerId: string,
-    element: any
-  ): EditorState {
-    const targetLayer = state.layers.find(layer => layer.id === layerId);
-    if (!targetLayer) {
-      throw ImageErrorHandler.createError(
-        'Layer not found',
-        IMAGE_ERROR_CODES.VALIDATION_ERROR,
-        'addElementToLayer'
-      );
+  static addElementToLayer(state: EditorState, layerId: string, element: any): EditorState {
+    const layer = state.layers.find(l => l.id === layerId);
+    if (!layer || layer.locked) {
+      throw ImageErrorHandler.createError('Invalid layer operation', IMAGE_ERROR_CODES.VALIDATION_ERROR, 'addElementToLayer');
     }
 
-    if (targetLayer.locked) {
-      throw ImageErrorHandler.createError(
-        'Cannot add element to locked layer',
-        IMAGE_ERROR_CODES.VALIDATION_ERROR,
-        'addElementToLayer'
-      );
-    }
-
-    const newLayers = state.layers.map(layer =>
-      layer.id === layerId
-        ? { ...layer, elements: [...layer.elements, element] }
-        : layer
+    const newLayers = state.layers.map(l => 
+      l.id === layerId ? { ...l, elements: [...l.elements, element] } : l
     );
 
-    const newHistory: EditorHistory = {
+    return ImageEditorService.commitHistory(state, newLayers);
+  }
+
+  private static commitHistory(
+    state: EditorState, 
+    newLayers: EditorLayer[], 
+    additionalState: Partial<EditorState> = {}
+  ): EditorState {
+    const history: EditorHistory = {
       id: ImageEditorService.generateId(),
       timestamp: new Date(),
       layers: newLayers,
     };
 
-    const newHistoryState = ImageEditorService.addToHistory(state, newHistory);
-
     return {
-      ...newHistoryState,
+      ...ImageEditorHistoryUtils.addToHistory(state, history),
+      ...additionalState,
       layers: newLayers,
       isDirty: true,
     };
   }
 
-  static undo(state: EditorState): EditorState {
-    if (state.historyIndex <= 0) {
-      return state;
-    }
-
-    const newIndex = state.historyIndex - 1;
-    const historyState = state.history[newIndex];
-
-    return {
-      ...state,
-      layers: historyState.layers,
-      historyIndex: newIndex,
-      isDirty: true,
-    };
-  }
-
-  static redo(state: EditorState): EditorState {
-    if (state.historyIndex >= state.history.length - 1) {
-      return state;
-    }
-
-    const newIndex = state.historyIndex + 1;
-    const historyState = state.history[newIndex];
-
-    return {
-      ...state,
-      layers: historyState.layers,
-      historyIndex: newIndex,
-      isDirty: true,
-    };
-  }
-
-  private static addToHistory(
-    state: EditorState,
-    newHistory: EditorHistory,
-    maxHistory: number = 50
-  ): EditorState {
-    const newHistoryArray = [...state.history.slice(0, state.historyIndex + 1), newHistory];
-
-    // Keep only the last maxHistory states
-    if (newHistoryArray.length > maxHistory) {
-      newHistoryArray.shift();
-    }
-
-    return {
-      ...state,
-      history: newHistoryArray,
-      historyIndex: newHistoryArray.length - 1,
-    };
-  }
+  static undo = ImageEditorHistoryUtils.undo;
+  static redo = ImageEditorHistoryUtils.redo;
+  static canUndo = ImageEditorHistoryUtils.canUndo;
+  static canRedo = ImageEditorHistoryUtils.canRedo;
 
   static setTool(state: EditorState, tool: EditorTool): EditorState {
     return { ...state, tool };
   }
 
-  static setSelectedLayer(state: EditorState, layerId?: string): EditorState {
-    return { ...state, selectedLayer: layerId };
-  }
-
   static setZoom(state: EditorState, zoom: number): EditorState {
     return { ...state, zoom: Math.max(0.1, Math.min(5, zoom)) };
   }
@@ -237,38 +130,7 @@ export class ImageEditorService {
     return { ...state, pan };
   }
 
-  static canUndo(state: EditorState): boolean {
-    return state.historyIndex > 0;
-  }
-
-  static canRedo(state: EditorState): boolean {
-    return state.historyIndex < state.history.length - 1;
-  }
-
   static getVisibleLayers(state: EditorState): EditorLayer[] {
     return state.layers.filter(layer => layer.visible);
   }
-
-  static getActiveLayers(state: EditorState): EditorLayer[] {
-    return state.layers.filter(layer => layer.visible && !layer.locked);
-  }
-
-  static exportState(state: EditorState): EditorState {
-    return {
-      ...state,
-      currentUri: undefined,
-    };
-  }
-
-  static importState(data: any, uri: string): EditorState {
-    try {
-      return {
-        ...data,
-        originalUri: uri,
-        currentUri: undefined,
-      };
-    } catch (error) {
-      throw ImageErrorHandler.handleUnknownError(error, 'importState');
-    }
-  }
 }

package/src/infrastructure/services/ImageTransformService.ts

@@ -9,221 +9,81 @@ import type {
     ImageManipulateAction,
     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';
+import { ImageTransformUtils } from '../utils/ImageTransformUtils';
 
 export class ImageTransformService {
-    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> {
+    static async resize(uri: string, width?: number, height?: number, options?: ImageSaveOptions): 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 } }],
-                this.buildSaveOptions(options)
-            );
+            ImageValidator.validateUri(uri);
+            ImageValidator.validateDimensions({ width, height });
+            return await ImageManipulator.manipulateAsync(uri, [{ resize: { width, height } }], ImageTransformUtils.buildSaveOptions(options));
         } catch (error) {
             throw ImageErrorHandler.handleUnknownError(error, 'resize');
         }
     }
 
-    static async crop(
-        uri: string,
-        cropArea: ImageCropArea,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
+    static async crop(uri: string, cropArea: ImageCropArea, options?: ImageSaveOptions): 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 }],
-                this.buildSaveOptions(options)
-            );
+            ImageValidator.validateUri(uri);
+            ImageValidator.validateDimensions(cropArea);
+            return await ImageManipulator.manipulateAsync(uri, [{ crop: cropArea }], ImageTransformUtils.buildSaveOptions(options));
         } catch (error) {
             throw ImageErrorHandler.handleUnknownError(error, 'crop');
         }
     }
 
-    static async rotate(
-        uri: string,
-        degrees: number,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
+    static async rotate(uri: string, degrees: number, options?: ImageSaveOptions): 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 }],
-                this.buildSaveOptions(options)
-            );
+            ImageValidator.validateUri(uri);
+            ImageValidator.validateRotation(degrees);
+            return await ImageManipulator.manipulateAsync(uri, [{ rotate: degrees }], ImageTransformUtils.buildSaveOptions(options));
         } catch (error) {
             throw ImageErrorHandler.handleUnknownError(error, 'rotate');
         }
     }
 
-    static async flip(
-        uri: string,
-        flip: ImageFlipOptions,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
+    static async flip(uri: string, flip: ImageFlipOptions, options?: ImageSaveOptions): Promise<ImageManipulationResult> {
         try {
-            const uriValidation = ImageValidator.validateUri(uri);
-            if (!uriValidation.isValid) {
-                throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'flip');
-            }
-
+            ImageValidator.validateUri(uri);
             const actions: ImageManipulator.Action[] = [];
             if (flip.horizontal) actions.push({ flip: ImageManipulator.FlipType.Horizontal });
             if (flip.vertical) actions.push({ flip: ImageManipulator.FlipType.Vertical });
-
-            return await ImageManipulator.manipulateAsync(
-                uri,
-                actions,
-                this.buildSaveOptions(options)
-            );
+            return await ImageManipulator.manipulateAsync(uri, actions, ImageTransformUtils.buildSaveOptions(options));
         } catch (error) {
             throw ImageErrorHandler.handleUnknownError(error, 'flip');
         }
     }
 
-    static async manipulate(
-        uri: string,
-        action: ImageManipulateAction,
-        options?: ImageSaveOptions
-    ): Promise<ImageManipulationResult> {
+    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');
-            }
-
+            ImageValidator.validateUri(uri);
             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.resize) actions.push({ resize: action.resize });
+            if (action.crop) 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,
-                this.buildSaveOptions(options)
-            );
+            return await ImageManipulator.manipulateAsync(uri, actions, ImageTransformUtils.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 resizeToFit(uri: string, maxWidth: number, maxHeight: number, options?: ImageSaveOptions): Promise<ImageManipulationResult> {
+        const dimensions = ImageUtils.fitToSize(maxWidth, maxHeight, maxWidth, maxHeight);
+        return this.resize(uri, dimensions.width, dimensions.height, options);
     }
 
-    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');
-        }
+    static async cropToSquare(uri: string, width: number, height: number, options?: ImageSaveOptions): Promise<ImageManipulationResult> {
+        const cropArea = ImageUtils.getSquareCrop(width, height);
+        return this.crop(uri, cropArea, options);
     }
 }