@umituz/react-native-design-system 2.6.110 → 2.6.112

package/src/image/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/image/infrastructure/utils/ImageFilterUtils.ts

@@ -0,0 +1,21 @@
+/**
+ * Infrastructure - Filter Utils
+ *
+ * Legacy wrapper for backward compatibility. Use specific filter classes directly.
+ */
+
+import { BasicFilters } from './filters/BasicFilters';
+import { SpecialFilters } from './filters/SpecialFilters';
+import { FilterHelpers } from './filters/FilterHelpers';
+
+export class ImageFilterUtils {
+  static applyBrightness = BasicFilters.applyBrightness;
+  static applyContrast = BasicFilters.applyContrast;
+  static applySaturation = BasicFilters.applySaturation;
+  static applyVintage = SpecialFilters.applyVintage;
+  static applyBlur = SpecialFilters.applyBlur;
+  static applyIntensity = FilterHelpers.applyIntensity;
+}
+
+// Re-export for convenience
+export { BasicFilters, SpecialFilters, FilterHelpers };

package/src/image/infrastructure/utils/ImageQualityPresets.ts

@@ -0,0 +1,110 @@
+/**
+ * Image Infrastructure - Quality Presets
+ * 
+ * Predefined quality settings for different use cases
+ */
+
+import type { SaveFormat } from '../../domain/entities/ImageTypes';
+import { IMAGE_CONSTANTS } from '../../domain/entities/ImageConstants';
+
+export interface QualityPreset {
+  format: SaveFormat;
+  quality: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  description: string;
+}
+
+export interface QualityPresets {
+  web: QualityPreset;
+  mobile: QualityPreset;
+  print: QualityPreset;
+  thumbnail: QualityPreset;
+  preview: QualityPreset;
+  archive: QualityPreset;
+}
+
+export const IMAGE_QUALITY_PRESETS: QualityPresets = {
+  web: {
+    format: 'jpeg',
+    quality: 0.8,
+    maxWidth: 1920,
+    maxHeight: 1080,
+    description: 'Optimized for web use with good balance of quality and size',
+  },
+  mobile: {
+    format: 'jpeg',
+    quality: 0.7,
+    maxWidth: 1080,
+    maxHeight: 1920,
+    description: 'Optimized for mobile devices with smaller file size',
+  },
+  print: {
+    format: 'png',
+    quality: 1.0,
+    maxWidth: 3000,
+    maxHeight: 3000,
+    description: 'High quality for printing with maximum detail',
+  },
+  thumbnail: {
+    format: 'jpeg',
+    quality: 0.6,
+    maxWidth: IMAGE_CONSTANTS.thumbnailSize,
+    maxHeight: IMAGE_CONSTANTS.thumbnailSize,
+    description: 'Small thumbnail for preview use',
+  },
+  preview: {
+    format: 'jpeg',
+    quality: 0.5,
+    maxWidth: 800,
+    maxHeight: 600,
+    description: 'Quick preview with very small file size',
+  },
+  archive: {
+    format: 'png',
+    quality: 0.9,
+    description: 'High quality archival storage with lossless compression',
+  },
+};
+
+export class ImageQualityPresetService {
+  static getPreset(name: keyof QualityPresets): QualityPreset {
+    return IMAGE_QUALITY_PRESETS[name];
+  }
+
+  static getAllPresets(): QualityPresets {
+    return IMAGE_QUALITY_PRESETS;
+  }
+
+  static getCustomPreset(options: {
+    format?: SaveFormat;
+    quality?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+  }): QualityPreset {
+    return {
+      format: options.format || 'jpeg',
+      quality: options.quality || IMAGE_CONSTANTS.defaultQuality,
+      maxWidth: options.maxWidth,
+      maxHeight: options.maxHeight,
+      description: 'Custom quality preset',
+    };
+  }
+
+  static optimizeForUseCase(
+    useCase: 'web' | 'mobile' | 'print' | 'thumbnail' | 'preview' | 'archive',
+    customOptions?: Partial<QualityPreset>
+  ): QualityPreset {
+    const preset = IMAGE_QUALITY_PRESETS[useCase];
+    
+    if (!customOptions) {
+      return preset;
+    }
+
+    return {
+      ...preset,
+      ...customOptions,
+      description: `${preset.description} (modified)`,
+    };
+  }
+}

package/src/image/infrastructure/utils/ImageTransformUtils.ts

@@ -0,0 +1,25 @@
+/**
+ * Infrastructure - Transform Utils
+ * 
+ * Internal utilities for image transformations
+ */
+
+import * as ImageManipulator from 'expo-image-manipulator';
+import type { SaveFormat, ImageSaveOptions } from '../../domain/entities/ImageTypes';
+import { IMAGE_CONSTANTS } from '../../domain/entities/ImageConstants';
+
+export class ImageTransformUtils {
+  static mapFormat(format?: SaveFormat): ImageManipulator.SaveFormat {
+    if (format === 'png') return ImageManipulator.SaveFormat.PNG;
+    if (format === 'webp') return ImageManipulator.SaveFormat.WEBP;
+    return ImageManipulator.SaveFormat.JPEG;
+  }
+
+  static buildSaveOptions(options?: ImageSaveOptions): ImageManipulator.SaveOptions {
+    return {
+      compress: options?.compress ?? IMAGE_CONSTANTS.defaultQuality,
+      format: this.mapFormat(options?.format),
+      base64: options?.base64,
+    };
+  }
+}

package/src/image/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/image/infrastructure/utils/LayerManager.ts

@@ -0,0 +1,77 @@
+/**
+ * Infrastructure - Layer Manager
+ * 
+ * Manages editor layers with composition and rendering
+ */
+
+export type LayerOperation = 'add' | 'remove' | 'move' | 'merge' | 'duplicate';
+
+export interface LayerComposition {
+  width: number;
+  height: number;
+  backgroundColor?: string;
+}
+
+export class LayerManager {
+
+
+  static mergeLayers(
+    layers: Array<{
+      id: string;
+      name: string;
+      elements: any[];
+    }>,
+    targetIds: string[]
+  ): Array<{
+    id: string;
+    name: string;
+    elements: any[];
+  }> {
+    const targetLayers = layers.filter(layer => targetIds.includes(layer.id));
+    const otherLayers = layers.filter(layer => !targetIds.includes(layer.id));
+
+    if (targetLayers.length === 0) return layers;
+
+    // Merge elements from target layers
+    const mergedElements = targetLayers.flatMap(layer => layer.elements);
+    const mergedLayer = {
+      id: Math.random().toString(36).substr(2, 9),
+      name: targetLayers.map(l => l.name).join(' + '),
+      elements: mergedElements,
+    };
+
+    return [...otherLayers, mergedLayer];
+  }
+
+  static duplicateLayer(
+    layer: {
+      id: string;
+      name: string;
+      elements: any[];
+    }
+  ): {
+    id: string;
+    name: string;
+    elements: any[];
+  } {
+    return {
+      id: Math.random().toString(36).substr(2, 9),
+      name: `${layer.name} Copy`,
+      elements: [...layer.elements],
+    };
+  }
+
+  static reorderLayers(
+    layers: Array<{ id: string; index?: number }>,
+    fromIndex: number,
+    toIndex: number
+  ): Array<{ id: string; index?: number }> {
+    const result = [...layers];
+    const [moved] = result.splice(fromIndex, 1);
+    result.splice(toIndex, 0, moved);
+    
+    return result.map((layer, index) => ({ ...layer, index }));
+  }
+
+
+}

package/src/image/infrastructure/utils/MetadataExtractor.ts

@@ -0,0 +1,83 @@
+/**
+ * Image Infrastructure - Metadata Extractor Utilities
+ *
+ * Helper functions for extracting metadata from images
+ */
+
+import type { ImageMetadataExtractionOptions } from '../../infrastructure/services/ImageMetadataService';
+import { ImageErrorHandler } from './ImageErrorHandler';
+
+export class MetadataExtractor {
+  static async getImageDimensions(uri: string): Promise<{ width: number; height: number }> {
+    try {
+      // In a real implementation, we would use:
+      // - expo-image-manipulator for basic dimensions
+      // - react-native-image-picker for metadata
+      // - react-native-exif-reader for EXIF data
+
+      // Mock implementation
+      return {
+        width: Math.floor(Math.random() * 2000) + 100,
+        height: Math.floor(Math.random() * 2000) + 100,
+      };
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'getDimensions');
+    }
+  }
+
+  static async getFileSize(uri: string): Promise<number> {
+    try {
+      // In real implementation, use expo-file-system or similar
+      return Math.floor(Math.random() * 5000000) + 10000; // Random size between 10KB-5MB
+    } catch (error) {
+      throw ImageErrorHandler.handleUnknownError(error, 'getFileSize');
+    }
+  }
+
+  static async extractExifData(uri: string): Promise<any> {
+    try {
+      // Mock EXIF data extraction
+      return {
+        DateTimeOriginal: new Date().toISOString(),
+        Make: 'Mock Camera',
+        Model: 'Mock Phone',
+        ISO: Math.floor(Math.random() * 1600) + 100,
+        FocalLength: Math.random() * 50 + 10,
+        Flash: Math.random() > 0.5,
+        ExposureTime: `1/${Math.floor(Math.random() * 1000) + 100}`,
+        FNumber: Math.random() * 8 + 1.4,
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  static async extractGPSData(uri: string): Promise<{ latitude: number; longitude: number } | null> {
+    try {
+      // Mock GPS data extraction
+      return Math.random() > 0.7 ? {
+        latitude: Math.random() * 180 - 90,
+        longitude: Math.random() * 360 - 180,
+      } : null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  static detectFormat(uri: string): string {
+    const extension = uri.toLowerCase().split('.').pop();
+    switch (extension) {
+      case 'jpg':
+      case 'jpeg':
+        return 'JPEG';
+      case 'png':
+        return 'PNG';
+      case 'webp':
+        return 'WebP';
+      case 'gif':
+        return 'GIF';
+      default:
+        return 'Unknown';
+    }
+  }
+}

package/src/image/infrastructure/utils/filters/BasicFilters.ts

@@ -0,0 +1,61 @@
+/**
+ * Infrastructure - Basic Image Filters
+ *
+ * Core filter operations: brightness, contrast, saturation
+ */
+
+export class BasicFilters {
+  static applyBrightness(
+    data: Uint8ClampedArray,
+    brightness: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const adjustment = brightness * 2.55;
+
+    for (let i = 0; i < result.length; i += 4) {
+      result[i] = Math.min(255, Math.max(0, result[i] + adjustment));
+      result[i + 1] = Math.min(255, Math.max(0, result[i + 1] + adjustment));
+      result[i + 2] = Math.min(255, Math.max(0, result[i + 2] + adjustment));
+    }
+
+    return result;
+  }
+
+  static applyContrast(
+    data: Uint8ClampedArray,
+    contrast: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const factor = (259 * (contrast * 2.55 + 255)) / (255 * (259 - contrast * 2.55));
+
+    for (let i = 0; i < result.length; i += 4) {
+      result[i] = Math.min(255, Math.max(0, factor * (result[i] - 128) + 128));
+      result[i + 1] = Math.min(255, Math.max(0, factor * (result[i + 1] - 128) + 128));
+      result[i + 2] = Math.min(255, Math.max(0, factor * (result[i + 2] - 128) + 128));
+    }
+
+    return result;
+  }
+
+  static applySaturation(
+    data: Uint8ClampedArray,
+    saturation: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const adjustment = 1 + (saturation / 100);
+
+    for (let i = 0; i < result.length; i += 4) {
+      const r = result[i];
+      const g = result[i + 1];
+      const b = result[i + 2];
+
+      const gray = 0.299 * r + 0.587 * g + 0.114 * b;
+
+      result[i] = Math.min(255, Math.max(0, gray + adjustment * (r - gray)));
+      result[i + 1] = Math.min(255, Math.max(0, gray + adjustment * (g - gray)));
+      result[i + 2] = Math.min(255, Math.max(0, gray + adjustment * (b - gray)));
+    }
+
+    return result;
+  }
+}

package/src/image/infrastructure/utils/filters/FilterHelpers.ts

@@ -0,0 +1,21 @@
+/**
+ * Infrastructure - Filter Helper Utilities
+ *
+ * Common helper functions for filter operations
+ */
+
+export class FilterHelpers {
+  static applyIntensity(
+    originalData: Uint8ClampedArray,
+    processedData: Uint8ClampedArray,
+    intensity: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(originalData.length);
+
+    for (let i = 0; i < originalData.length; i++) {
+      result[i] = originalData[i] * (1 - intensity) + processedData[i] * intensity;
+    }
+
+    return result;
+  }
+}

package/src/image/infrastructure/utils/filters/SpecialFilters.ts

@@ -0,0 +1,84 @@
+/**
+ * Infrastructure - Special Image Filters
+ *
+ * Advanced filter operations: vintage, blur
+ */
+
+export class SpecialFilters {
+  static applyVintage(
+    data: Uint8ClampedArray,
+    intensity: number,
+    warmth: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const factor = intensity / 100;
+    const warmFactor = warmth / 100;
+
+    for (let i = 0; i < result.length; i += 4) {
+      let r = result[i];
+      let g = result[i + 1];
+      let b = result[i + 2];
+
+      const tr = 0.393 * r + 0.769 * g + 0.189 * b;
+      const tg = 0.349 * r + 0.686 * g + 0.168 * b;
+      const tb = 0.272 * r + 0.534 * g + 0.131 * b;
+
+      r = r * (1 - factor) + tr * factor;
+      g = g * (1 - factor) + tg * factor;
+      b = b * (1 - factor) + tb * factor;
+
+      if (warmFactor > 0) {
+        result[i] = Math.min(255, r + warmFactor * 20);
+        result[i + 1] = Math.min(255, g + warmFactor * 10);
+        result[i + 2] = Math.min(255, b * (1 - warmFactor * 0.3));
+      } else {
+        result[i] = r;
+        result[i + 1] = g;
+        result[i + 2] = Math.min(255, b * (1 - Math.abs(warmFactor) * 0.3));
+      }
+    }
+
+    return result;
+  }
+
+  static applyBlur(
+    data: Uint8ClampedArray,
+    radius: number,
+    width: number,
+    height: number
+  ): Uint8ClampedArray {
+    const result = new Uint8ClampedArray(data);
+    const size = Math.floor(radius) || 1;
+
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        let r = 0, g = 0, b = 0, a = 0;
+        let count = 0;
+
+        for (let dy = -size; dy <= size; dy++) {
+          for (let dx = -size; dx <= size; dx++) {
+            const ny = y + dy;
+            const nx = x + dx;
+
+            if (ny >= 0 && ny < height && nx >= 0 && nx < width) {
+              const idx = (ny * width + nx) * 4;
+              r += data[idx];
+              g += data[idx + 1];
+              b += data[idx + 2];
+              a += data[idx + 3];
+              count++;
+            }
+          }
+        }
+
+        const idx = (y * width + x) * 4;
+        result[idx] = r / count;
+        result[idx + 1] = g / count;
+        result[idx + 2] = b / count;
+        result[idx + 3] = a / count;
+      }
+    }
+
+    return result;
+  }
+}

package/src/image/infrastructure/utils/validation/image-validator.ts

@@ -0,0 +1,77 @@
+/**
+ * Image Validator
+ * Single Responsibility: Validate image files and URIs
+ */
+
+import type { ValidationResult } from '../../../domain/entities/ValidationResult';
+import {
+  validateImageExtension,
+  validateImageDataUrl,
+  getMimeTypeFromExtension,
+  getMimeTypeFromDataUrl,
+} from './mime-type-validator';
+
+/**
+ * Check if URI is a local file path
+ */
+function isLocalFileUrl(uri: string): boolean {
+  return uri.startsWith('file://');
+}
+
+/**
+ * Check if URI is a public URL
+ */
+function isPublicUrl(uri: string): boolean {
+  return uri.startsWith('http://') || uri.startsWith('https://');
+}
+
+/**
+ * Check if URI is a data URL
+ */
+function isDataUrl(uri: string): boolean {
+  return uri.startsWith('data:');
+}
+
+/**
+ * Validate image URI (supports file://, http://, https://, and data: URLs)
+ */
+export function validateImageUri(
+  uri: string,
+  fieldName: string = 'Image'
+): ValidationResult {
+  if (!uri || uri.trim() === '') {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  // Validate public URLs (assume they're images if they have image extension)
+  if (isPublicUrl(uri)) {
+    return validateImageExtension(uri, fieldName);
+  }
+
+  // Validate data URLs
+  if (isDataUrl(uri)) {
+    return validateImageDataUrl(uri, fieldName);
+  }
+
+  // Validate local file URLs
+  if (isLocalFileUrl(uri)) {
+    return validateImageExtension(uri, fieldName);
+  }
+
+  // Unknown format
+  return {
+    isValid: false,
+    error: `${fieldName} must be a valid image URL or file path`,
+  };
+}
+
+/**
+ * Get MIME type from URI (supports all URI types)
+ */
+export function getImageMimeType(uri: string): string | null {
+  if (isDataUrl(uri)) {
+    return getMimeTypeFromDataUrl(uri);
+  }
+
+  return getMimeTypeFromExtension(uri);
+}