@umituz/react-native-image 1.3.1 → 1.3.3

package/src/infrastructure/utils/CropTool.ts

@@ -1,260 +0,0 @@
-/**
- * Infrastructure - Crop Tool
- * 
- * Advanced cropping with aspect ratio and grid guides
- */
-
-export interface CropConfig {
-  aspectRatio?: number;
-  lockAspectRatio?: boolean;
-  showGrid?: boolean;
-  minSize?: { width: number; height: number };
-  maxSize?: { width: number; height: number };
-}
-
-export interface CropArea {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-export interface CropPreset {
-  name: string;
-  aspectRatio: number;
-  icon: string;
-}
-
-export class CropTool {
-  private static readonly PRESETS: CropPreset[] = [
-    { name: 'Free', aspectRatio: 0, icon: 'crop-free' },
-    { name: '1:1', aspectRatio: 1, icon: 'crop-square' },
-    { name: '4:3', aspectRatio: 4/3, icon: 'crop-landscape' },
-    { name: '3:4', aspectRatio: 3/4, icon: 'crop-portrait' },
-    { name: '16:9', aspectRatio: 16/9, icon: 'crop-widescreen' },
-    { name: '9:16', aspectRatio: 9/16, icon: 'crop-vertical' },
-  ];
-
-  static getPresets(): CropPreset[] {
-    return this.PRESETS;
-  }
-
-  static constrainToAspectRatio(
-    width: number,
-    height: number,
-    aspectRatio: number
-  ): { width: number; height: number } {
-    if (aspectRatio === 0) return { width, height };
-
-    const currentRatio = width / height;
-    
-    if (currentRatio > aspectRatio) {
-      // Width is too large, constrain it
-      return {
-        width: height * aspectRatio,
-        height,
-      };
-    } else {
-      // Height is too large, constrain it
-      return {
-        width,
-        height: width / aspectRatio,
-      };
-    }
-  }
-
-  static constrainToBounds(
-    area: CropArea,
-    bounds: { width: number; height: number }
-  ): CropArea {
-    let { x, y, width, height } = area;
-
-    // Ensure area is within bounds
-    if (x < 0) {
-      width += x;
-      x = 0;
-    }
-    if (y < 0) {
-      height += y;
-      y = 0;
-    }
-
-    if (x + width > bounds.width) {
-      width = bounds.width - x;
-    }
-    if (y + height > bounds.height) {
-      height = bounds.height - y;
-    }
-
-    return { x, y, width, height };
-  }
-
-  static applyMinimumSize(
-    area: CropArea,
-    minSize: { width: number; height: number }
-  ): CropArea {
-    const { width, height } = area;
-    
-    return {
-      ...area,
-      width: Math.max(width, minSize.width),
-      height: Math.max(height, minSize.height),
-    };
-  }
-
-  static applyMaximumSize(
-    area: CropArea,
-    maxSize: { width: number; height: number }
-  ): CropArea {
-    const { width, height } = area;
-    
-    return {
-      ...area,
-      width: Math.min(width, maxSize.width),
-      height: Math.min(height, maxSize.height),
-    };
-  }
-
-  static centerCrop(
-    imageWidth: number,
-    imageHeight: number,
-    targetWidth?: number,
-    targetHeight?: number
-  ): CropArea {
-    if (!targetWidth && !targetHeight) {
-      return {
-        x: 0,
-        y: 0,
-        width: imageWidth,
-        height: imageHeight,
-      };
-    }
-
-    if (!targetHeight) {
-      targetHeight = targetWidth! * (imageHeight / imageWidth);
-    }
-    if (!targetWidth) {
-      targetWidth = targetHeight! * (imageWidth / imageHeight);
-    }
-
-    return {
-      x: (imageWidth - targetWidth) / 2,
-      y: (imageHeight - targetHeight) / 2,
-      width: targetWidth,
-      height: targetHeight,
-    };
-  }
-
-  static drawCropOverlay(
-    ctx: CanvasRenderingContext2D,
-    cropArea: CropArea,
-    config: CropConfig
-  ): void {
-    const { x, y, width, height } = cropArea;
-
-    // Draw semi-transparent overlay outside crop area
-    ctx.save();
-    ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
-    
-    // Top overlay
-    ctx.fillRect(0, 0, ctx.canvas.width, y);
-    // Bottom overlay
-    ctx.fillRect(0, y + height, ctx.canvas.width, ctx.canvas.height - y - height);
-    // Left overlay
-    ctx.fillRect(0, y, x, height);
-    // Right overlay
-    ctx.fillRect(x + width, y, ctx.canvas.width - x - width, height);
-    
-    // Draw crop area border
-    ctx.strokeStyle = '#ffffff';
-    ctx.lineWidth = 2;
-    ctx.setLineDash([5, 5]);
-    ctx.strokeRect(x, y, width, height);
-
-    // Draw corner handles
-    ctx.fillStyle = '#ffffff';
-    const handleSize = 8;
-    ctx.fillRect(x - handleSize/2, y - handleSize/2, handleSize, handleSize);
-    ctx.fillRect(x + width - handleSize/2, y - handleSize/2, handleSize, handleSize);
-    ctx.fillRect(x - handleSize/2, y + height - handleSize/2, handleSize, handleSize);
-    ctx.fillRect(x + width - handleSize/2, y + height - handleSize/2, handleSize, handleSize);
-
-    ctx.setLineDash([]);
-    ctx.restore();
-
-    // Draw grid if enabled
-    if (config.showGrid) {
-      this.drawGrid(ctx, cropArea);
-    }
-  }
-
-  private static drawGrid(
-    ctx: CanvasRenderingContext2D,
-    cropArea: CropArea
-  ): void {
-    const { x, y, width, height } = cropArea;
-    
-    ctx.save();
-    ctx.strokeStyle = 'rgba(255, 255, 255, 0.3)';
-    ctx.lineWidth = 1;
-    ctx.setLineDash([2, 3]);
-
-    // Third lines
-    ctx.beginPath();
-    ctx.moveTo(x + width/3, y);
-    ctx.lineTo(x + width/3, y + height);
-    ctx.moveTo(x + 2*width/3, y);
-    ctx.lineTo(x + 2*width/3, y + height);
-    ctx.moveTo(x, y + height/3);
-    ctx.lineTo(x + width, y + height/3);
-    ctx.moveTo(x, y + 2*height/3);
-    ctx.lineTo(x + width, y + 2*height/3);
-    ctx.stroke();
-
-    // Center lines
-    ctx.strokeStyle = 'rgba(255, 255, 255, 0.5)';
-    ctx.setLineDash([5, 2]);
-    ctx.beginPath();
-    ctx.moveTo(x + width/2, y);
-    ctx.lineTo(x + width/2, y + height);
-    ctx.moveTo(x, y + height/2);
-    ctx.lineTo(x + width, y + height/2);
-    ctx.stroke();
-
-    ctx.restore();
-  }
-
-  static getCropFromSelection(
-    startPoint: { x: number; y: number },
-    endPoint: { x: number; y: number },
-    config: CropConfig
-  ): CropArea {
-    const x = Math.min(startPoint.x, endPoint.x);
-    const y = Math.min(startPoint.y, endPoint.y);
-    const width = Math.abs(endPoint.x - startPoint.x);
-    const height = Math.abs(endPoint.y - startPoint.y);
-
-    let cropArea = { x, y, width, height };
-
-    // Apply aspect ratio constraint if locked
-    if (config.lockAspectRatio && config.aspectRatio) {
-      const constrained = this.constrainToAspectRatio(width, height, config.aspectRatio);
-      cropArea = {
-        x,
-        y,
-        width: constrained.width,
-        height: constrained.height,
-      };
-    }
-
-    // Apply size constraints
-    if (config.minSize) {
-      cropArea = this.applyMinimumSize(cropArea, config.minSize);
-    }
-    if (config.maxSize) {
-      cropArea = this.applyMaximumSize(cropArea, config.maxSize);
-    }
-
-    return cropArea;
-  }
-}

package/src/infrastructure/utils/DrawingEngine.ts

@@ -1,210 +0,0 @@
-/**
- * Infrastructure - Drawing Engine
- * 
- * Core drawing functionality for editor tools
- */
-
-export type DrawingPath = Array<{ x: number; y: number; pressure?: number }>;
-
-export interface DrawingContext {
-  canvas: HTMLCanvasElement | any;
-  ctx: CanvasRenderingContext2D | any;
-  scale: number;
-  offset: { x: number; y: number };
-}
-
-export interface DrawingConfig {
-  color: string;
-  size: number;
-  opacity: number;
-  style: 'normal' | 'marker' | 'spray';
-  smoothing: boolean;
-}
-
-export class DrawingEngine {
-  private static smoothPath(path: DrawingPath): DrawingPath {
-    if (path.length < 3) return path;
-
-    const smoothed: DrawingPath = [path[0]];
-
-    for (let i = 1; i < path.length - 1; i++) {
-      const prev = path[i - 1];
-      const curr = path[i];
-      const next = path[i + 1];
-
-      smoothed.push({
-        x: curr.x * 0.5 + (prev.x + next.x) * 0.25,
-        y: curr.y * 0.5 + (prev.y + next.y) * 0.25,
-        pressure: curr.pressure,
-      });
-    }
-
-    smoothed.push(path[path.length - 1]);
-    return smoothed;
-  }
-
-  private static drawMarker(
-    ctx: CanvasRenderingContext2D,
-    from: { x: number; y: number },
-    to: { x: number; y: number },
-    config: DrawingConfig
-  ): void {
-    ctx.globalAlpha = config.opacity * 0.3;
-    const strokeWidth = (config as any).strokeWidth || config.size * 2;
-    ctx.lineWidth = strokeWidth;
-
-    ctx.beginPath();
-    ctx.moveTo(from.x, from.y);
-    ctx.lineTo(to.x, to.y);
-    ctx.stroke();
-  }
-
-  private static drawSpray(
-    ctx: CanvasRenderingContext2D,
-    point: { x: number; y: number },
-    config: DrawingConfig
-  ): void {
-    const density = config.size * 2;
-    const radius = config.size;
-
-    for (let i = 0; i < density; i++) {
-      const angle = Math.random() * Math.PI * 2;
-      const distance = Math.random() * radius;
-      const x = point.x + Math.cos(angle) * distance;
-      const y = point.y + Math.sin(angle) * distance;
-
-      ctx.globalAlpha = config.opacity * Math.random() * 0.5;
-      ctx.fillRect(x, y, 1, 1);
-    }
-  }
-
-  static drawStroke(
-    ctx: CanvasRenderingContext2D,
-    path: DrawingPath,
-    config: DrawingConfig
-  ): void {
-    if (path.length < 2) return;
-
-    const smoothedPath = config.smoothing ? this.smoothPath(path) : path;
-
-    ctx.lineCap = 'round';
-    ctx.lineJoin = 'round';
-    ctx.strokeStyle = config.color;
-    ctx.globalAlpha = config.opacity;
-
-    switch (config.style) {
-      case 'marker':
-        this.drawMarker(ctx, smoothedPath[0], smoothedPath[smoothedPath.length - 1], config);
-        break;
-
-      case 'spray':
-        smoothedPath.forEach(point => this.drawSpray(ctx, point, config));
-        break;
-
-      default:
-        ctx.lineWidth = config.size;
-        ctx.beginPath();
-        ctx.moveTo(smoothedPath[0].x, smoothedPath[0].y);
-
-        for (let i = 1; i < smoothedPath.length; i++) {
-          ctx.lineTo(smoothedPath[i].x, smoothedPath[i].y);
-        }
-        ctx.stroke();
-    }
-  }
-
-  static drawShape(
-    ctx: CanvasRenderingContext2D,
-    type: 'rectangle' | 'circle' | 'line' | 'arrow',
-    start: { x: number; y: number },
-    end: { x: number; y: number },
-    config: Partial<DrawingConfig>
-  ): void {
-    const cfg = config as any;
-    const color = cfg.color || '#000000';
-    const size = cfg.size || 2;
-    const opacity = cfg.opacity || 1;
-    const strokeWidth = cfg.strokeWidth || 2;
-
-    ctx.strokeStyle = color;
-    ctx.fillStyle = color;
-    ctx.lineWidth = strokeWidth;
-    ctx.globalAlpha = opacity;
-    ctx.lineCap = 'round';
-
-    switch (type) {
-      case 'rectangle':
-        const width = end.x - start.x;
-        const height = end.y - start.y;
-        ctx.strokeRect(start.x, start.y, width, height);
-        break;
-
-      case 'circle':
-        const radius = Math.sqrt(
-          Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2)
-        );
-        ctx.beginPath();
-        ctx.arc(start.x, start.y, radius, 0, 2 * Math.PI);
-        ctx.stroke();
-        break;
-
-      case 'line':
-        ctx.beginPath();
-        ctx.moveTo(start.x, start.y);
-        ctx.lineTo(end.x, end.y);
-        ctx.stroke();
-        break;
-
-      case 'arrow':
-        const angle = Math.atan2(end.y - start.y, end.x - start.x);
-        const arrowLength = 15;
-        const arrowAngle = Math.PI / 6;
-
-        // Draw line
-        ctx.beginPath();
-        ctx.moveTo(start.x, start.y);
-        ctx.lineTo(end.x, end.y);
-        ctx.stroke();
-
-        // Draw arrowhead
-        ctx.beginPath();
-        ctx.moveTo(end.x, end.y);
-        ctx.lineTo(
-          end.x - arrowLength * Math.cos(angle - arrowAngle),
-          end.y - arrowLength * Math.sin(angle - arrowAngle)
-        );
-        ctx.moveTo(end.x, end.y);
-        ctx.lineTo(
-          end.x - arrowLength * Math.cos(angle + arrowAngle),
-          end.y - arrowLength * Math.sin(angle + arrowAngle)
-        );
-        ctx.stroke();
-        break;
-    }
-  }
-
-  static erase(
-    ctx: CanvasRenderingContext2D,
-    position: { x: number; y: number },
-    size: number
-  ): void {
-    ctx.globalCompositeOperation = 'destination-out';
-    ctx.beginPath();
-    ctx.arc(position.x, position.y, size, 0, 2 * Math.PI);
-    ctx.fill();
-    ctx.globalCompositeOperation = 'source-over';
-  }
-
-  static createDrawingContext(
-    canvas: HTMLCanvasElement | any,
-    scale: number = 1,
-    offset: { x: number; y: number } = { x: 0, y: 0 }
-  ): DrawingContext {
-    return {
-      canvas,
-      ctx: canvas.getContext('2d'),
-      scale,
-      offset,
-    };
-  }
-}

package/src/infrastructure/utils/FilterEffects.ts

@@ -1,51 +0,0 @@
-/**
- * Image Infrastructure - Filter Effects
- * 
- * Advanced filter effects and color processing
- */
-
-export class FilterEffects {
-  static applyVintage(imageData: ImageData): ImageData {
-    let data = FilterEffects.applySepia(imageData, 0.8);
-    const { width, height } = imageData;
-    const centerX = width / 2;
-    const centerY = height / 2;
-    const maxDistance = Math.sqrt(centerX * centerX + centerY * centerY);
-
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        const distance = Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2);
-        const vignette = 1 - (distance / maxDistance) * 0.7;
-        const i = (y * width + x) * 4;
-        
-        data.data[i] *= vignette;
-        data.data[i + 1] *= vignette;
-        data.data[i + 2] *= vignette;
-      }
-    }
-
-    return data;
-  }
-
-  static applySepia(imageData: ImageData, intensity: number = 1): ImageData {
-    const data = new Uint8ClampedArray(imageData.data);
-    for (let i = 0; i < data.length; i += 4) {
-      const r = data[i];
-      const g = data[i + 1];
-      const b = data[i + 2];
-
-      data[i] = Math.min(255, (r * (1 - (0.607 * intensity))) + (g * (0.769 * intensity)) + (b * (0.189 * intensity)));
-      data[i + 1] = Math.min(255, (r * (0.349 * intensity)) + (g * (1 - (0.314 * intensity))) + (b * (0.168 * intensity)));
-      data[i + 2] = Math.min(255, (r * (0.272 * intensity)) + (g * (0.534 * intensity)) + (b * (1 - (0.869 * intensity))));
-    }
-    return FilterEffects.createCanvasImageData(imageData.width, imageData.height, data);
-  }
-
-  static createCanvasImageData(
-    width: number,
-    height: number,
-    data: Uint8ClampedArray
-  ): ImageData {
-    return { data, width, height } as ImageData;
-  }
-}

package/src/infrastructure/utils/ShapeRenderer.ts

@@ -1,168 +0,0 @@
-/**
- * Infrastructure - Shape Renderer
- * 
- * Advanced shape drawing with different styles
- */
-
-export interface ShapeStyle {
-  fill?: string;
-  stroke?: string;
-  strokeWidth?: number;
-  dash?: number[];
-  opacity?: number;
-}
-
-export class ShapeRenderer {
-  static drawRoundedRect(
-    ctx: CanvasRenderingContext2D,
-    x: number,
-    y: number,
-    width: number,
-    height: number,
-    radius: number,
-    style: ShapeStyle
-  ): void {
-    ctx.save();
-    
-    ctx.globalAlpha = style.opacity || 1;
-    ctx.strokeStyle = style.stroke || '#000000';
-    ctx.fillStyle = style.fill || 'transparent';
-    ctx.lineWidth = style.strokeWidth || 2;
-    
-    if (style.dash) {
-      ctx.setLineDash(style.dash);
-    }
-
-    ctx.beginPath();
-    ctx.moveTo(x + radius, y);
-    ctx.lineTo(x + width - radius, y);
-    ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
-    ctx.lineTo(x + width, y + height - radius);
-    ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
-    ctx.lineTo(x + radius, y + height);
-    ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
-    ctx.lineTo(x, y + radius);
-    ctx.quadraticCurveTo(x, y, x + radius, y);
-    ctx.closePath();
-
-    if (style.fill) ctx.fill();
-    if (style.stroke) ctx.stroke();
-
-    ctx.restore();
-  }
-
-  static drawStar(
-    ctx: CanvasRenderingContext2D,
-    cx: number,
-    cy: number,
-    outerRadius: number,
-    innerRadius: number,
-    points: number,
-    style: ShapeStyle
-  ): void {
-    ctx.save();
-    
-    ctx.globalAlpha = style.opacity || 1;
-    ctx.strokeStyle = style.stroke || '#000000';
-    ctx.fillStyle = style.fill || 'transparent';
-    ctx.lineWidth = style.strokeWidth || 2;
-
-    ctx.beginPath();
-    for (let i = 0; i < points * 2; i++) {
-      const angle = (Math.PI * i) / points - Math.PI / 2;
-      const radius = i % 2 === 0 ? outerRadius : innerRadius;
-      const x = cx + Math.cos(angle) * radius;
-      const y = cy + Math.sin(angle) * radius;
-
-      if (i === 0) {
-        ctx.moveTo(x, y);
-      } else {
-        ctx.lineTo(x, y);
-      }
-    }
-    ctx.closePath();
-
-    if (style.fill) ctx.fill();
-    if (style.stroke) ctx.stroke();
-
-    ctx.restore();
-  }
-
-  static drawHeart(
-    ctx: CanvasRenderingContext2D,
-    x: number,
-    y: number,
-    size: number,
-    style: ShapeStyle
-  ): void {
-    ctx.save();
-    
-    ctx.globalAlpha = style.opacity || 1;
-    ctx.strokeStyle = style.stroke || '#000000';
-    ctx.fillStyle = style.fill || 'transparent';
-    ctx.lineWidth = style.strokeWidth || 2;
-
-    ctx.beginPath();
-    const topCurveHeight = size * 0.3;
-    ctx.moveTo(x, y + topCurveHeight);
-
-    // Top left curve
-    ctx.bezierCurveTo(
-      x, y,
-      x - size / 2, y,
-      x - size / 2, y + topCurveHeight
-    );
-
-    // Bottom left curve
-    ctx.bezierCurveTo(
-      x - size / 2, y + (size + topCurveHeight) / 2,
-      x, y + (size + topCurveHeight) / 1.5,
-      x, y + size
-    );
-
-    // Bottom right curve
-    ctx.bezierCurveTo(
-      x, y + (size + topCurveHeight) / 1.5,
-      x + size / 2, y + (size + topCurveHeight) / 2,
-      x + size / 2, y + topCurveHeight
-    );
-
-    // Top right curve
-    ctx.bezierCurveTo(
-      x + size / 2, y,
-      x, y,
-      x, y + topCurveHeight
-    );
-
-    ctx.closePath();
-
-    if (style.fill) ctx.fill();
-    if (style.stroke) ctx.stroke();
-
-    ctx.restore();
-  }
-
-  static drawTriangle(
-    ctx: CanvasRenderingContext2D,
-    points: Array<{ x: number; y: number }>,
-    style: ShapeStyle
-  ): void {
-    ctx.save();
-    
-    ctx.globalAlpha = style.opacity || 1;
-    ctx.strokeStyle = style.stroke || '#000000';
-    ctx.fillStyle = style.fill || 'transparent';
-    ctx.lineWidth = style.strokeWidth || 2;
-
-    ctx.beginPath();
-    ctx.moveTo(points[0].x, points[0].y);
-    ctx.lineTo(points[1].x, points[1].y);
-    ctx.lineTo(points[2].x, points[2].y);
-    ctx.closePath();
-
-    if (style.fill) ctx.fill();
-    if (style.stroke) ctx.stroke();
-
-    ctx.restore();
-  }
-}