@umituz/react-native-image 1.3.8 → 1.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-image",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "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",
@@ -53,6 +54,11 @@
     "react-native": "0.81.5",
     "react-native-gesture-handler": "~2.16.1",
     "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

@@ -60,7 +60,6 @@ export {
 // =============================================================================
 
 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 {
@@ -69,10 +68,9 @@ export {
 } from './infrastructure/services/ImageViewerService';
 
 export { ImageBatchService, type BatchOperation, type BatchProcessingOptions, type BatchProcessingResult } from './infrastructure/services/ImageBatchService';
-export { ImageAIEnhancementService, type AutoEnhancementOptions, type EnhancementResult } from './infrastructure/services/ImageAIEnhancementService';
+export { ImageEnhanceService, type AutoEnhancementOptions, type EnhancementResult } from './infrastructure/services/ImageEnhanceService';
 export { ImageMetadataService, type ImageMetadataExtractionOptions } from './infrastructure/services/ImageMetadataService';
 export { ImageQualityPresetService, type QualityPreset, type QualityPresets, IMAGE_QUALITY_PRESETS } from './infrastructure/utils/ImageQualityPresets';
-export { ImageSpecializedEnhancementService } from './infrastructure/services/ImageSpecializedEnhancementService';
 export { ImageTemplateService } from './infrastructure/services/ImageTemplateService';
 
 // =============================================================================
@@ -80,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';
@@ -91,7 +92,7 @@ export {
 } from './presentation/hooks/useImageGallery';
 
 export { useImageBatch } from './presentation/hooks/useImageBatch';
-export { useImageAIEnhancement } from './presentation/hooks/useImageAIEnhancement';
+export { useImageEnhance } from './presentation/hooks/useImageEnhance';
 export { useImageMetadata } from './presentation/hooks/useImageMetadata';
 
 

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/{ImageAIEnhancementService.ts → ImageEnhanceService.ts}

@@ -1,5 +1,5 @@
 /**
- * Image Infrastructure - AI Enhancement Service
+ * Image Infrastructure - Enhance Service
  * 
  * AI-powered image enhancement and automatic adjustments
  */
@@ -11,7 +11,6 @@ import type {
 } from '../../domain/entities/ImageFilterTypes';
 import { ImageValidator } from '../utils/ImageValidator';
 import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
-import { AIImageAnalysisUtils } from '../utils/AIImageAnalysisUtils';
 
 export interface AutoEnhancementOptions {
   enhanceBrightness?: boolean;
@@ -29,49 +28,7 @@ export interface EnhancementResult {
   improvementScore: number;
 }
 
-export class ImageAIEnhancementService {
-  private static calculateHistogram(imageData: Uint8ClampedArray): number[] {
-    const histogram = new Array(256).fill(0);
-    for (let i = 0; i < imageData.length; i += 4) {
-      const gray = Math.round(0.299 * imageData[i] + 0.587 * imageData[i + 1] + 0.114 * imageData[i + 2]);
-      histogram[gray]++;
-    }
-    return histogram;
-  }
-
-  private static calculateOptimalBrightness(histogram: number[]): number {
-    const totalPixels = histogram.reduce((sum, count) => sum + count, 0);
-    let sum = 0;
-    
-    for (let i = 0; i < 256; i++) {
-      sum += histogram[i] * i;
-    }
-    
-    const meanBrightness = sum / totalPixels;
-    const targetBrightness = 128;
-    
-    return (targetBrightness - meanBrightness) / 255;
-  }
-
-  private static calculateOptimalContrast(histogram: number[]): number {
-    const totalPixels = histogram.reduce((sum, count) => sum + count, 0);
-    let mean = 0;
-    let variance = 0;
-    
-    for (let i = 0; i < 256; i++) {
-      mean += (histogram[i] / totalPixels) * i;
-    }
-    
-    for (let i = 0; i < 256; i++) {
-      variance += (histogram[i] / totalPixels) * Math.pow(i - mean, 2);
-    }
-    
-    const standardDeviation = Math.sqrt(variance);
-    const targetStandardDeviation = 80;
-    
-    return Math.max(-1, Math.min(1, (targetStandardDeviation - standardDeviation) / 100));
-  }
-
+export class ImageEnhanceService {
   static async analyzeImage(uri: string): Promise<ImageQualityMetrics> {
     try {
       const uriValidation = ImageValidator.validateUri(uri);
@@ -105,23 +62,19 @@ export class ImageAIEnhancementService {
         enhanceBrightness = true,
         enhanceContrast = true,
         enhanceColor = true,
-        reduceNoise = false,
-        sharpen = false,
-        targetQuality = 85,
       } = options;
 
-      const originalMetrics = await ImageAIEnhancementService.analyzeImage(uri);
+      const originalMetrics = await this.analyzeImage(uri);
       const adjustments: ImageColorAdjustment = {};
 
       if (enhanceBrightness) adjustments.brightness = 0.1;
       if (enhanceContrast) adjustments.contrast = 0.15;
       if (enhanceColor) adjustments.saturation = 0.1;
 
-      const enhancedMetrics = await ImageAIEnhancementService.analyzeImage(uri);
-      const improvementScore = (
-        (enhancedMetrics.overallQuality - originalMetrics.overallQuality) /
-        originalMetrics.overallQuality
-      ) * 100;
+      const enhancedMetrics = await this.analyzeImage(uri);
+      const improvementScore = originalMetrics.overallQuality > 0 
+        ? ((enhancedMetrics.overallQuality - originalMetrics.overallQuality) / originalMetrics.overallQuality) * 100
+        : 0;
 
       return {
         originalMetrics,
@@ -133,4 +86,38 @@ export class ImageAIEnhancementService {
       throw ImageErrorHandler.handleUnknownError(error, 'autoEnhance');
     }
   }
-}
+
+  static async enhancePortrait(uri: string): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhancePortrait');
+      }
+
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'enhancePortrait');
+    }
+  }
+
+  static async enhanceLandscape(uri: string): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'enhanceLandscape');
+      }
+
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'enhanceLandscape');
+    }
+  }
+}

package/src/infrastructure/services/ImageTemplateService.ts

@@ -7,12 +7,16 @@ import { MemeTemplateOptions } from '../../domain/entities/ImageTemplateTypes';
  */
 export class ImageTemplateService {
   /**
-   * Generates a Memegen.link URL for a given template and texts
+   * Generates a meme URL for a given template and texts
    * 
    * @param options Meme configuration (templateKey, topText, bottomText)
-   * @returns Formatted memegen.link URL
+   * @param baseUrl Optional base URL for the image generation service
+   * @returns Formatted image URL
    */
-  static generateMemeUrl(options: MemeTemplateOptions): string {
+  static generateMemeUrl(
+    options: MemeTemplateOptions, 
+    baseUrl: string = 'https://api.memegen.link'
+  ): string {
     const { templateKey, topText = '', bottomText = '', style, width, height } = options;
     
     // Internal helper for memegen-specific encoding
@@ -32,7 +36,9 @@ export class ImageTemplateService {
     const top = encodeMemeText(topText);
     const bottom = encodeMemeText(bottomText);
 
-    let url = `https://api.memegen.link/images/${templateKey}/${top}/${bottom}.png`;
+    // Ensure baseUrl doesn't have a trailing slash
+    const base = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    let url = `${base}/images/${templateKey}/${top}/${bottom}.png`;
     
     const params: string[] = [];
     if (style) params.push(`style=${style}`);