@umituz/react-native-image 1.1.5 → 1.2.1

package/src/infrastructure/services/ImageAnnotationService.ts

@@ -0,0 +1,189 @@
+/**
+ * Image Infrastructure - Annotation Service
+ * 
+ * Handles text overlay, drawing, and annotation features
+ */
+
+import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
+import { ImageValidator } from '../utils/ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+import { CanvasRenderingService } from '../utils/CanvasRenderingService';
+
+export interface TextOverlay {
+  text: string;
+  x: number;
+  y: number;
+  fontSize?: number;
+  fontFamily?: string;
+  color?: string;
+  backgroundColor?: string;
+  maxWidth?: number;
+  rotation?: number;
+}
+
+export interface DrawingElement {
+  type: 'line' | 'rectangle' | 'circle' | 'arrow' | 'freehand';
+  points: Array<{ x: number; y: number }>;
+  color?: string;
+  strokeWidth?: number;
+  fillColor?: string;
+}
+
+export interface WatermarkOptions {
+  text?: string;
+  imageUri?: string;
+  position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+  opacity?: number;
+  size?: number;
+  margin?: number;
+}
+
+export interface ImageAnnotation {
+  textOverlays?: TextOverlay[];
+  drawings?: DrawingElement[];
+  watermark?: WatermarkOptions;
+}
+
+export class ImageAnnotationService {
+  private static getPositionCoordinates(
+    position: string,
+    imageWidth: number,
+    imageHeight: number,
+    elementWidth: number,
+    elementHeight: number,
+    margin: number = 10
+  ): { x: number; y: number } {
+    switch (position) {
+      case 'top-left':
+        return { x: margin, y: margin };
+      case 'top-right':
+        return { x: imageWidth - elementWidth - margin, y: margin };
+      case 'bottom-left':
+        return { x: margin, y: imageHeight - elementHeight - margin };
+      case 'bottom-right':
+        return { x: imageWidth - elementWidth - margin, y: imageHeight - elementHeight - margin };
+      case 'center':
+        return { 
+          x: (imageWidth - elementWidth) / 2, 
+          y: (imageHeight - elementHeight) / 2 
+        };
+      default:
+        return { x: margin, y: margin };
+    }
+  }
+
+  static async addTextOverlay(
+    uri: string,
+    overlay: TextOverlay
+  ): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'addTextOverlay');
+      }
+
+      // In a real implementation, we would:
+      // 1. Load image into canvas
+      // 2. Apply text overlay using canvas rendering
+      // 3. Export canvas to new URI
+
+      return {
+        uri, // Would be processed URI
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'addTextOverlay');
+    }
+  }
+
+  static async addDrawingElements(
+    uri: string,
+    elements: DrawingElement[]
+  ): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'addDrawingElements');
+      }
+
+      // Mock implementation
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'addDrawingElements');
+    }
+  }
+
+  static async addWatermark(
+    uri: string,
+    options: WatermarkOptions
+  ): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'addWatermark');
+      }
+
+      if (!options.text && !options.imageUri) {
+        throw ImageErrorHandler.createError(
+          'Either text or imageUri must be provided for watermark',
+          IMAGE_ERROR_CODES.VALIDATION_ERROR,
+          'addWatermark'
+        );
+      }
+
+      // Mock implementation
+      return {
+        uri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'addWatermark');
+    }
+  }
+
+  static async applyAnnotation(
+    uri: string,
+    annotation: ImageAnnotation
+  ): Promise<ImageManipulationResult> {
+    try {
+      const uriValidation = ImageValidator.validateUri(uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'applyAnnotation');
+      }
+
+      // Apply all annotations in order
+      let resultUri = uri;
+
+      if (annotation.textOverlays) {
+        for (const overlay of annotation.textOverlays) {
+          const result = await ImageAnnotationService.addTextOverlay(resultUri, overlay);
+          resultUri = result.uri;
+        }
+      }
+
+      if (annotation.drawings) {
+        const result = await ImageAnnotationService.addDrawingElements(resultUri, annotation.drawings);
+        resultUri = result.uri;
+      }
+
+      if (annotation.watermark) {
+        const result = await ImageAnnotationService.addWatermark(resultUri, annotation.watermark);
+        resultUri = result.uri;
+      }
+
+      return {
+        uri: resultUri,
+        width: 0,
+        height: 0,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'applyAnnotation');
+    }
+  }
+}

package/src/infrastructure/services/ImageBatchService.ts

@@ -0,0 +1,199 @@
+/**
+ * Image Infrastructure - Batch Processing Service
+ * 
+ * Handles processing multiple images concurrently with progress tracking
+ */
+
+import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
+import type { ImageFilter } from '../../domain/entities/ImageFilterTypes';
+import { ImageTransformService } from './ImageTransformService';
+import { ImageConversionService } from './ImageConversionService';
+import { ImageFilterService } from './ImageFilterService';
+import { ImageValidator } from '../utils/ImageValidator';
+import { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+
+export interface BatchProcessingOptions {
+  concurrency?: number;
+  onProgress?: (completed: number, total: number, currentUri?: string) => void;
+  onError?: (error: Error, uri: string) => void;
+}
+
+export interface BatchProcessingResult {
+  successful: Array<{
+    uri: string;
+    result: ImageManipulationResult;
+  }>;
+  failed: Array<{
+    uri: string;
+    error: Error;
+  }>;
+  totalProcessed: number;
+  successCount: number;
+  failureCount: number;
+}
+
+export interface BatchOperation {
+  uri: string;
+  type: 'resize' | 'crop' | 'filter' | 'compress' | 'convert';
+  params: any;
+  options?: any;
+}
+
+export class ImageBatchService {
+  private static async processBatchItem(
+    operation: BatchOperation,
+    options: BatchProcessingOptions = {}
+  ): Promise<{ uri: string; result: ImageManipulationResult | null; error?: Error }> {
+    try {
+      const uriValidation = ImageValidator.validateUri(operation.uri);
+      if (!uriValidation.isValid) {
+        throw ImageErrorHandler.createError(uriValidation.error!, IMAGE_ERROR_CODES.INVALID_URI, 'batchProcess');
+      }
+
+      let result: ImageManipulationResult;
+
+      switch (operation.type) {
+        case 'resize':
+          result = await ImageTransformService.resize(
+            operation.uri,
+            operation.params.width,
+            operation.params.height,
+            operation.options
+          );
+          break;
+
+        case 'crop':
+          result = await ImageTransformService.crop(
+            operation.uri,
+            operation.params,
+            operation.options
+          );
+          break;
+
+        case 'filter':
+          result = await ImageFilterService.applyFilter(
+            operation.uri,
+            operation.params
+          );
+          break;
+
+        case 'compress':
+          result = await ImageConversionService.compress(
+            operation.uri,
+            operation.params.quality
+          );
+          break;
+
+        case 'convert':
+          result = await ImageConversionService.convertFormat(
+            operation.uri,
+            operation.params.format,
+            operation.params.quality
+          );
+          break;
+
+        default:
+          throw ImageErrorHandler.createError(
+            `Unknown operation type: ${operation.type}`,
+            IMAGE_ERROR_CODES.VALIDATION_ERROR,
+            'batchProcess'
+          );
+      }
+
+      return { uri: operation.uri, result };
+    } catch (error) {
+      return { 
+        uri: operation.uri, 
+        result: null, 
+        error: error instanceof Error ? error : new Error('Unknown error')
+      };
+    }
+  }
+
+  static async processBatch(
+    operations: BatchOperation[],
+    options: BatchProcessingOptions = {}
+  ): Promise<BatchProcessingResult> {
+    const concurrency = options.concurrency || 3;
+    const successful: Array<{ uri: string; result: ImageManipulationResult }> = [];
+    const failed: Array<{ uri: string; error: Error }> = [];
+
+    let completed = 0;
+    const total = operations.length;
+
+    // Process operations in chunks based on concurrency
+    for (let i = 0; i < operations.length; i += concurrency) {
+      const chunk = operations.slice(i, i + concurrency);
+      
+      const chunkResults = await Promise.all(
+        chunk.map(operation => this.processBatchItem(operation, options))
+      );
+
+      // Process results
+      for (const result of chunkResults) {
+        completed++;
+        
+        options.onProgress?.(completed, total, result.uri);
+
+        if (result.error) {
+          failed.push({ uri: result.uri, error: result.error });
+          options.onError?.(result.error, result.uri);
+        } else if (result.result) {
+          successful.push({ uri: result.uri, result: result.result });
+        }
+      }
+    }
+
+    return {
+      successful,
+      failed,
+      totalProcessed: total,
+      successCount: successful.length,
+      failureCount: failed.length,
+    };
+  }
+
+  static async resizeBatch(
+    uris: string[],
+    width?: number,
+    height?: number,
+    options: BatchProcessingOptions & { saveOptions?: any } = {}
+  ): Promise<BatchProcessingResult> {
+    const operations: BatchOperation[] = uris.map(uri => ({
+      uri,
+      type: 'resize' as const,
+      params: { width, height },
+      options: options.saveOptions,
+    }));
+
+    return this.processBatch(operations, options);
+  }
+
+  static async compressBatch(
+    uris: string[],
+    quality: number = 0.8,
+    options: BatchProcessingOptions = {}
+  ): Promise<BatchProcessingResult> {
+    const operations: BatchOperation[] = uris.map(uri => ({
+      uri,
+      type: 'compress' as const,
+      params: { quality },
+    }));
+
+    return this.processBatch(operations, options);
+  }
+
+  static async filterBatch(
+    uris: string[],
+    filter: ImageFilter,
+    options: BatchProcessingOptions = {}
+  ): Promise<BatchProcessingResult> {
+    const operations: BatchOperation[] = uris.map(uri => ({
+      uri,
+      type: 'filter' as const,
+      params: filter,
+    }));
+
+    return this.processBatch(operations, options);
+  }
+}

package/src/infrastructure/services/ImageEditorService.ts

@@ -0,0 +1,274 @@
+/**
+ * Infrastructure - Advanced Editor Service
+ * 
+ * Core editing functionality with history 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 { ImageErrorHandler, IMAGE_ERROR_CODES } from '../utils/ImageErrorHandler';
+
+export class ImageEditorService {
+  private static generateId(): string {
+    return Math.random().toString(36).substr(2, 9);
+  }
+
+  static createInitialState(
+    uri: string,
+    dimensions: { width: number; height: number },
+    options: EditorOptions = {}
+  ): EditorState {
+    const defaultLayer: EditorLayer = {
+      id: 'background',
+      name: 'Background',
+      visible: true,
+      opacity: 1,
+      locked: true,
+      elements: [],
+    };
+
+    return {
+      originalUri: uri,
+      tool: EditorTool.MOVE,
+      layers: [defaultLayer],
+      history: [{
+        id: ImageEditorService.generateId(),
+        timestamp: new Date(),
+        layers: [defaultLayer],
+      }],
+      historyIndex: 0,
+      isDirty: false,
+      dimensions,
+      zoom: 1,
+      pan: { x: 0, y: 0 },
+    };
+  }
+
+  static addLayer(
+    state: EditorState,
+    name?: string
+  ): EditorState {
+    const newLayer: EditorLayer = {
+      id: ImageEditorService.generateId(),
+      name: name || `Layer ${state.layers.length}`,
+      visible: true,
+      opacity: 1,
+      locked: false,
+      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],
+      selectedLayer: newLayer.id,
+      isDirty: true,
+    };
+  }
+
+  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'
+      );
+    }
+
+    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,
+      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 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'
+      );
+    }
+
+    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 newHistory: EditorHistory = {
+      id: ImageEditorService.generateId(),
+      timestamp: new Date(),
+      layers: newLayers,
+    };
+
+    const newHistoryState = ImageEditorService.addToHistory(state, newHistory);
+
+    return {
+      ...newHistoryState,
+      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 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)) };
+  }
+
+  static setPan(state: EditorState, pan: { x: number; y: number }): EditorState {
+    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');
+    }
+  }
+}