Standart Error in Utils

js/utils/MaskProcessingUtils.js

@@ -1,5 +1,6 @@
 import { createModuleLogger } from "./LoggerUtils.js";
 import { createCanvas } from "./CommonUtils.js";
+import { withErrorHandling, createValidationError } from "../ErrorHandler.js";
 const log = createModuleLogger('MaskProcessingUtils');
 /**
  * Processes an image to create a mask with inverted alpha channel
@@ -7,7 +8,10 @@ const log = createModuleLogger('MaskProcessingUtils');
  * @param options - Processing options
  * @returns Promise with processed mask as HTMLCanvasElement
  */
-export async function processImageToMask(sourceImage, options = {}) {
+export const processImageToMask = withErrorHandling(async function (sourceImage, options = {}) {
+    if (!sourceImage) {
+        throw createValidationError("Source image is required", { sourceImage });
+    }
     const { targetWidth = sourceImage.width, targetHeight = sourceImage.height, invertAlpha = true, maskColor = { r: 255, g: 255, b: 255 } } = options;
     log.debug('Processing image to mask:', {
         sourceSize: { width: sourceImage.width, height: sourceImage.height },
@@ -18,7 +22,7 @@ export async function processImageToMask(sourceImage, options = {}) {
     // Create temporary canvas for processing
     const { canvas: tempCanvas, ctx: tempCtx } = createCanvas(targetWidth, targetHeight, '2d', { willReadFrequently: true });
     if (!tempCtx) {
-        throw new Error("Failed to get 2D context for mask processing");
+        throw createValidationError("Failed to get 2D context for mask processing");
     }
     // Draw the source image
     tempCtx.drawImage(sourceImage, 0, 0, targetWidth, targetHeight);
@@ -44,7 +48,7 @@ export async function processImageToMask(sourceImage, options = {}) {
     tempCtx.putImageData(imageData, 0, 0);
     log.debug('Mask processing completed');
     return tempCanvas;
-}
+}, 'processImageToMask');
 /**
  * Processes image data with custom pixel transformation
  * @param sourceImage - Source image or canvas element
@@ -52,11 +56,17 @@ export async function processImageToMask(sourceImage, options = {}) {
  * @param options - Processing options
  * @returns Promise with processed image as HTMLCanvasElement
  */
-export async function processImageWithTransform(sourceImage, pixelTransform, options = {}) {
+export const processImageWithTransform = withErrorHandling(async function (sourceImage, pixelTransform, options = {}) {
+    if (!sourceImage) {
+        throw createValidationError("Source image is required", { sourceImage });
+    }
+    if (!pixelTransform || typeof pixelTransform !== 'function') {
+        throw createValidationError("Pixel transform function is required", { pixelTransform });
+    }
     const { targetWidth = sourceImage.width, targetHeight = sourceImage.height } = options;
     const { canvas: tempCanvas, ctx: tempCtx } = createCanvas(targetWidth, targetHeight, '2d', { willReadFrequently: true });
     if (!tempCtx) {
-        throw new Error("Failed to get 2D context for image processing");
+        throw createValidationError("Failed to get 2D context for image processing");
     }
     tempCtx.drawImage(sourceImage, 0, 0, targetWidth, targetHeight);
     const imageData = tempCtx.getImageData(0, 0, targetWidth, targetHeight);
@@ -70,28 +80,37 @@ export async function processImageWithTransform(sourceImage, pixelTransform, opt
     }
     tempCtx.putImageData(imageData, 0, 0);
     return tempCanvas;
-}
+}, 'processImageWithTransform');
 /**
  * Crops an image to a specific region
  * @param sourceImage - Source image or canvas
  * @param cropArea - Crop area {x, y, width, height}
  * @returns Promise with cropped image as HTMLCanvasElement
  */
-export async function cropImage(sourceImage, cropArea) {
+export const cropImage = withErrorHandling(async function (sourceImage, cropArea) {
+    if (!sourceImage) {
+        throw createValidationError("Source image is required", { sourceImage });
+    }
+    if (!cropArea || typeof cropArea !== 'object') {
+        throw createValidationError("Crop area is required", { cropArea });
+    }
     const { x, y, width, height } = cropArea;
+    if (width <= 0 || height <= 0) {
+        throw createValidationError("Crop area must have positive width and height", { cropArea });
+    }
     log.debug('Cropping image:', {
         sourceSize: { width: sourceImage.width, height: sourceImage.height },
         cropArea
     });
     const { canvas, ctx } = createCanvas(width, height);
     if (!ctx) {
-        throw new Error("Failed to get 2D context for image cropping");
+        throw createValidationError("Failed to get 2D context for image cropping");
     }
     ctx.drawImage(sourceImage, x, y, width, height, // Source rectangle
     0, 0, width, height // Destination rectangle
     );
     return canvas;
-}
+}, 'cropImage');
 /**
  * Applies a mask to an image using viewport positioning
  * @param maskImage - Mask image or canvas
@@ -101,7 +120,16 @@ export async function cropImage(sourceImage, cropArea) {
  * @param maskColor - Mask color (default: white)
  * @returns Promise with processed mask for viewport
  */
-export async function processMaskForViewport(maskImage, targetWidth, targetHeight, viewportOffset, maskColor = { r: 255, g: 255, b: 255 }) {
+export const processMaskForViewport = withErrorHandling(async function (maskImage, targetWidth, targetHeight, viewportOffset, maskColor = { r: 255, g: 255, b: 255 }) {
+    if (!maskImage) {
+        throw createValidationError("Mask image is required", { maskImage });
+    }
+    if (!viewportOffset || typeof viewportOffset !== 'object') {
+        throw createValidationError("Viewport offset is required", { viewportOffset });
+    }
+    if (targetWidth <= 0 || targetHeight <= 0) {
+        throw createValidationError("Target dimensions must be positive", { targetWidth, targetHeight });
+    }
     log.debug("Processing mask for viewport:", {
         sourceSize: { width: maskImage.width, height: maskImage.height },
         targetSize: { width: targetWidth, height: targetHeight },
@@ -109,7 +137,7 @@ export async function processMaskForViewport(maskImage, targetWidth, targetHeigh
     });
     const { canvas: tempCanvas, ctx: tempCtx } = createCanvas(targetWidth, targetHeight, '2d', { willReadFrequently: true });
     if (!tempCtx) {
-        throw new Error("Failed to get 2D context for viewport mask processing");
+        throw createValidationError("Failed to get 2D context for viewport mask processing");
     }
     // Calculate source coordinates based on viewport offset
     const sourceX = -viewportOffset.x;
@@ -139,4 +167,4 @@ export async function processMaskForViewport(maskImage, targetWidth, targetHeigh
     tempCtx.putImageData(imageData, 0, 0);
     log.debug("Viewport mask processing completed");
     return tempCanvas;
-}
+}, 'processMaskForViewport');