refactor(ext/canvas): use concrete error type (#26111)

4 files changed, 26 insertions, 9 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 84a57f036..2500b5a2c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1386,6 +1386,7 @@ dependencies = [
  "deno_webgpu",
  "image",
  "serde",
+ "thiserror",
 ]
 
 [[package]]
diff --git a/ext/canvas/Cargo.toml b/ext/canvas/Cargo.toml
index 47c37560e..78c674348 100644
--- a/ext/canvas/Cargo.toml
+++ b/ext/canvas/Cargo.toml
@@ -18,3 +18,4 @@ deno_core.workspace = true
 deno_webgpu.workspace = true
 image = { version = "0.24.7", default-features = false, features = ["png"] }
 serde = { workspace = true, features = ["derive"] }
+thiserror.workspace = true
diff --git a/ext/canvas/lib.rs b/ext/canvas/lib.rs
index 72173f133..defb288ac 100644
--- a/ext/canvas/lib.rs
+++ b/ext/canvas/lib.rs
@@ -1,7 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use deno_core::error::type_error;
-use deno_core::error::AnyError;
 use deno_core::op2;
 use deno_core::ToJsBuffer;
 use image::imageops::FilterType;
@@ -13,6 +11,14 @@ use serde::Deserialize;
 use serde::Serialize;
 use std::path::PathBuf;
 
+#[derive(Debug, thiserror::Error)]
+pub enum CanvasError {
+  #[error("Color type '{0:?}' not supported")]
+  UnsupportedColorType(ColorType),
+  #[error(transparent)]
+  Image(#[from] image::ImageError),
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "snake_case")]
 enum ImageResizeQuality {
@@ -43,7 +49,7 @@ struct ImageProcessArgs {
 fn op_image_process(
   #[buffer] buf: &[u8],
   #[serde] args: ImageProcessArgs,
-) -> Result<ToJsBuffer, AnyError> {
+) -> ToJsBuffer {
   let view =
     RgbaImage::from_vec(args.width, args.height, buf.to_vec()).unwrap();
 
@@ -105,7 +111,7 @@ fn op_image_process(
     }
   }
 
-  Ok(image_out.to_vec().into())
+  image_out.to_vec().into()
 }
 
 #[derive(Debug, Serialize)]
@@ -117,17 +123,16 @@ struct DecodedPng {
 
 #[op2]
 #[serde]
-fn op_image_decode_png(#[buffer] buf: &[u8]) -> Result<DecodedPng, AnyError> {
+fn op_image_decode_png(
+  #[buffer] buf: &[u8],
+) -> Result<DecodedPng, CanvasError> {
   let png = image::codecs::png::PngDecoder::new(buf)?;
 
   let (width, height) = png.dimensions();
 
   // TODO(@crowlKats): maybe use DynamicImage https://docs.rs/image/0.24.7/image/enum.DynamicImage.html ?
   if png.color_type() != ColorType::Rgba8 {
-    return Err(type_error(format!(
-      "Color type '{:?}' not supported",
-      png.color_type()
-    )));
+    return Err(CanvasError::UnsupportedColorType(png.color_type()));
   }
 
   // read_image will assert that the buffer is the correct size, so we need to fill it with zeros
diff --git a/runtime/errors.rs b/runtime/errors.rs
index 59928965b..daec653d1 100644
--- a/runtime/errors.rs
+++ b/runtime/errors.rs
@@ -11,6 +11,7 @@
 
 use deno_broadcast_channel::BroadcastChannelError;
 use deno_cache::CacheError;
+use deno_canvas::CanvasError;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_core::url;
@@ -155,6 +156,13 @@ pub fn get_nix_error_class(error: &nix::Error) -> &'static str {
   }
 }
 
+fn get_canvas_error(e: &CanvasError) -> &'static str {
+  match e {
+    CanvasError::UnsupportedColorType(_) => "TypeError",
+    CanvasError::Image(_) => "Error",
+  }
+}
+
 pub fn get_cache_error(error: &CacheError) -> &'static str {
   match error {
     CacheError::Sqlite(_) => "Error",
@@ -186,6 +194,8 @@ pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
     .or_else(|| deno_web::get_error_class_name(e))
     .or_else(|| deno_webstorage::get_not_supported_error_class_name(e))
     .or_else(|| deno_websocket::get_network_error_class_name(e))
+    .or_else(|| deno_websocket::get_network_error_class_name(e))
+    .or_else(|| e.downcast_ref::<CanvasError>().map(get_canvas_error))
     .or_else(|| e.downcast_ref::<CacheError>().map(get_cache_error))
     .or_else(|| {
       e.downcast_ref::<BroadcastChannelError>()