feat: start implement mvp

src/lib/services/imageService.ts

@@ -0,0 +1,213 @@
+import { type ImageUploadResult, type ImageCropResult } from "../types/panel";
+import { ImageError } from "../types/errors";
+import {
+  validateImageFile,
+  validateImageUrl,
+  loadImage,
+  getImageDimensions,
+  calculateAspectRatioFit,
+} from "../utils/imageValidator";
+import { handleError, logError } from "../utils/errorHandler";
+
+export class ImageService {
+  async handleFileUpload(file: File): Promise<ImageUploadResult> {
+    try {
+      // Validate file
+      const validation = validateImageFile(file);
+      if (!validation.isValid) {
+        return {
+          success: false,
+          error: validation.error,
+        };
+      }
+
+      // Convert file to base64
+      const base64 = await this.fileToBase64(file);
+
+      return {
+        success: true,
+        image: base64,
+      };
+    } catch (error) {
+      logError(error, "File upload failed");
+      return {
+        success: false,
+        error: handleError(error, "Ошибка загрузки файла"),
+      };
+    }
+  }
+
+  async handleUrlUpload(url: string): Promise<ImageUploadResult> {
+    try {
+      // Validate URL
+      const urlValidation = validateImageUrl(url);
+      if (!urlValidation.isValid) {
+        return {
+          success: false,
+          error: urlValidation.error,
+        };
+      }
+
+      // Load image
+      const img = await loadImage(url);
+
+      // Validate loaded image
+      const imgValidation = getImageDimensions(img);
+      if (imgValidation.width === 0 || imgValidation.height === 0) {
+        return {
+          success: false,
+          error: "Не удалось загрузить изображение по указанному URL",
+        };
+      }
+
+      // Convert to base64
+      const base64 = await this.imageToBase64(img);
+
+      return {
+        success: true,
+        image: base64,
+      };
+    } catch (error) {
+      logError(error, "URL upload failed");
+      return {
+        success: false,
+        error: handleError(error, "Ошибка загрузки изображения по URL"),
+      };
+    }
+  }
+
+  async handlePasteUpload(pasteEvent: ClipboardEvent): Promise<ImageUploadResult> {
+    try {
+      const items = pasteEvent.clipboardData?.items;
+      if (!items || items.length === 0) {
+        return {
+          success: false,
+          error: "В буфер обмена не найдено изображений",
+        };
+      }
+
+      // Find image item
+      let imageItem: DataTransferItem | null = null;
+      for (let i = 0; i < items.length; i++) {
+        if (items[i].type.indexOf("image") !== -1) {
+          imageItem = items[i];
+          break;
+        }
+      }
+
+      if (!imageItem) {
+        return {
+          success: false,
+          error: "В буфер обмена не найдено изображений",
+        };
+      }
+
+      // Get file from clipboard item
+      const file = imageItem.getAsFile();
+      if (!file) {
+        return {
+          success: false,
+          error: "Не удалось получить файл из буфера обмена",
+        };
+      }
+
+      // Validate and process file
+      const validation = validateImageFile(file);
+      if (!validation.isValid) {
+        return {
+          success: false,
+          error: validation.error,
+        };
+      }
+
+      const base64 = await this.fileToBase64(file);
+
+      return {
+        success: true,
+        image: base64,
+      };
+    } catch (error) {
+      logError(error, "Paste upload failed");
+      return {
+        success: false,
+        error: handleError(error, "Ошибка вставки изображения"),
+      };
+    }
+  }
+
+  async cropImage(
+    imageSrc: string,
+    cropArea: { x: number; y: number; width: number; height: number },
+  ): Promise<ImageCropResult> {
+    try {
+      const img = await loadImage(imageSrc);
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+
+      if (!ctx) {
+        throw new ImageError("Не удалось создать контекст canvas");
+      }
+
+      // Set canvas size to crop area
+      canvas.width = cropArea.width;
+      canvas.height = cropArea.height;
+
+      // Draw cropped image
+      ctx.drawImage(
+        img,
+        cropArea.x,
+        cropArea.y,
+        cropArea.width,
+        cropArea.height,
+        0,
+        0,
+        cropArea.width,
+        cropArea.height,
+      );
+
+      // Convert to base64
+      const croppedImage = canvas.toDataURL("image/png");
+
+      return {
+        success: true,
+        croppedImage,
+      };
+    } catch (error) {
+      logError(error, "Image cropping failed");
+      return {
+        success: false,
+        error: handleError(error, "Ошибка обрезки изображения"),
+      };
+    }
+  }
+
+  private fileToBase64(file: File): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = () => reject(new ImageError("Ошибка чтения файла"));
+      reader.readAsDataURL(file);
+    });
+  }
+
+  private imageToBase64(img: HTMLImageElement): Promise<string> {
+    return new Promise((resolve, reject) => {
+      try {
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+
+        if (!ctx) {
+          throw new ImageError("Не удалось создать контекст canvas");
+        }
+
+        canvas.width = img.naturalWidth;
+        canvas.height = img.naturalHeight;
+
+        ctx.drawImage(img, 0, 0);
+        resolve(canvas.toDataURL("image/png"));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+}