Add DomExceptionName

Author: jackkleeman

modules/llrt_abort/src/abort_signal.rs

@@ -3,7 +3,7 @@
 use std::sync::{Arc, RwLock};
 
 use llrt_events::{Emitter, EventEmitter, EventList};
-use llrt_exceptions::DOMException;
+use llrt_exceptions::{DOMException, DOMExceptionName};
 use llrt_utils::mc_oneshot;
 use rquickjs::{
     class::{Trace, Tracer},
@@ -160,7 +160,11 @@ impl<'js> AbortSignal<'js> {
     pub fn send_aborted(this: This<Class<'js, Self>>, ctx: Ctx<'js>) -> Result<()> {
         let mut borrow = this.borrow_mut();
         borrow.aborted = true;
-        let reason = get_reason_or_dom_exception(&ctx, borrow.reason.as_ref(), "AbortError")?;
+        let reason = get_reason_or_dom_exception(
+            &ctx,
+            borrow.reason.as_ref(),
+            DOMExceptionName::AbortError,
+        )?;
         borrow.reason = Some(reason.clone());
         borrow.sender.send(reason);
         drop(borrow);
@@ -179,7 +183,8 @@ impl<'js> AbortSignal<'js> {
 
     #[qjs(static)]
     pub fn timeout(ctx: Ctx<'js>, milliseconds: u64) -> Result<Class<'js, Self>> {
-        let timeout_error = get_reason_or_dom_exception(&ctx, None, "TimeoutError")?;
+        let timeout_error =
+            get_reason_or_dom_exception(&ctx, None, DOMExceptionName::TimeoutError)?;
 
         let signal = Self::new();
         let signal_instance = Class::instance(ctx.clone(), signal)?;
@@ -221,12 +226,12 @@ impl<'js> AbortSignal<'js> {
 fn get_reason_or_dom_exception<'js>(
     ctx: &Ctx<'js>,
     reason: Option<&Value<'js>>,
-    name: &str,
+    name: DOMExceptionName,
 ) -> Result<Value<'js>> {
     let reason = if let Some(reason) = reason {
         reason.clone()
     } else {
-        let ex = DOMException::new(ctx.clone(), Opt(None), Opt(Some(name.into())))?;
+        let ex = DOMException::new_with_name(ctx, name, String::new())?;
         Class::instance(ctx.clone(), ex)?.into_value()
     };
     Ok(reason)

modules/llrt_exceptions/src/lib.rs

@@ -6,56 +6,64 @@ use rquickjs::{atom::PredefinedAtom, function::Opt, Class, Ctx, Object, Result};
 #[rquickjs::class]
 #[derive(rquickjs::class::Trace, rquickjs::JsLifetime)]
 pub struct DOMException {
+    name: DOMExceptionName,
     message: String,
-    name: String,
     stack: String,
-    code: u8,
+}
+
+// https://webidl.spec.whatwg.org/#dfn-error-names-table
+#[derive(rquickjs::class::Trace, Debug)]
+pub enum DOMExceptionName {
+    IndexSizeError,
+    HierarchyRequestError,
+    WrongDocumentError,
+    InvalidCharacterError,
+    NoModificationAllowedError,
+    NotFoundError,
+    NotSupportedError,
+    InUseAttributeError,
+    InvalidStateError,
+    SyntaxError,
+    InvalidModificationError,
+    NamespaceError,
+    InvalidAccessError,
+    TypeMismatchError,
+    SecurityError,
+    NetworkError,
+    AbortError,
+    URLMismatchError,
+    QuotaExceededError,
+    TimeoutError,
+    InvalidNodeTypeError,
+    DataCloneError,
+    Error,
+    Other(String),
 }
 
 #[rquickjs::methods]
 impl DOMException {
     #[qjs(constructor)]
     pub fn new(ctx: Ctx<'_>, message: Opt<String>, name: Opt<String>) -> Result<Self> {
-        let primordials = BasePrimordials::get(&ctx)?;
+        let message = message.0.unwrap_or_default();
+        let name = name
+            .0
+            .map(DOMExceptionName::from)
+            .unwrap_or(DOMExceptionName::Error);
+
+        Self::new_with_name(&ctx, name, message)
+    }
+
+    #[qjs(skip)]
+    pub fn new_with_name(ctx: &Ctx<'_>, name: DOMExceptionName, message: String) -> Result<Self> {
+        let primordials = BasePrimordials::get(ctx)?;
 
         let new: Object = primordials
             .constructor_error
             .construct((message.clone(),))?;
 
-        let message = message.0.unwrap_or(String::from(""));
-        let name = name.0.unwrap_or(String::from("Error"));
-
-        // https://webidl.spec.whatwg.org/#dfn-error-names-table
-        let code = match name.as_str() {
-            "IndexSizeError" => 1,
-            "HierarchyRequestError" => 3,
-            "WrongDocumentError" => 4,
-            "InvalidCharacterError" => 5,
-            "NoModificationAllowedError" => 7,
-            "NotFoundError" => 8,
-            "NotSupportedError" => 9,
-            "InUseAttributeError" => 10,
-            "InvalidStateError" => 11,
-            "SyntaxError" => 12,
-            "InvalidModificationError" => 13,
-            "NamespaceError" => 14,
-            "InvalidAccessError" => 15,
-            "TypeMismatchError" => 17,
-            "SecurityError" => 18,
-            "NetworkError" => 19,
-            "AbortError" => 20,
-            "URLMismatchError" => 21,
-            "QuotaExceededError" => 22,
-            "TimeoutError" => 23,
-            "InvalidNodeTypeError" => 24,
-            "DataCloneError" => 25,
-            _ => 0,
-        };
-
         Ok(Self {
-            message,
             name,
-            code,
+            message,
             stack: new.get::<_, String>(PredefinedAtom::Stack)?,
         })
     }
@@ -66,13 +74,38 @@ impl DOMException {
     }
 
     #[qjs(get)]
-    pub fn name(&self) -> String {
-        self.name.clone()
+    pub fn name(&self) -> &str {
+        self.name.as_str()
     }
 
     #[qjs(get)]
     pub fn code(&self) -> u8 {
-        self.code
+        match self.name {
+            DOMExceptionName::IndexSizeError => 1,
+            DOMExceptionName::HierarchyRequestError => 3,
+            DOMExceptionName::WrongDocumentError => 4,
+            DOMExceptionName::InvalidCharacterError => 5,
+            DOMExceptionName::NoModificationAllowedError => 7,
+            DOMExceptionName::NotFoundError => 8,
+            DOMExceptionName::NotSupportedError => 9,
+            DOMExceptionName::InUseAttributeError => 10,
+            DOMExceptionName::InvalidStateError => 11,
+            DOMExceptionName::SyntaxError => 12,
+            DOMExceptionName::InvalidModificationError => 13,
+            DOMExceptionName::NamespaceError => 14,
+            DOMExceptionName::InvalidAccessError => 15,
+            DOMExceptionName::TypeMismatchError => 17,
+            DOMExceptionName::SecurityError => 18,
+            DOMExceptionName::NetworkError => 19,
+            DOMExceptionName::AbortError => 20,
+            DOMExceptionName::URLMismatchError => 21,
+            DOMExceptionName::QuotaExceededError => 22,
+            DOMExceptionName::TimeoutError => 23,
+            DOMExceptionName::InvalidNodeTypeError => 24,
+            DOMExceptionName::DataCloneError => 25,
+            DOMExceptionName::Error => 0,
+            DOMExceptionName::Other(_) => 0,
+        }
     }
 
     #[qjs(get)]
@@ -84,10 +117,71 @@ impl DOMException {
     #[qjs(rename = PredefinedAtom::ToString)]
     pub fn to_string(&self) -> String {
         if self.message.is_empty() {
-            return self.name.clone();
+            return self.name().to_string();
         }
 
-        [self.name.as_str(), self.message.as_str()].join(": ")
+        [self.name(), self.message.as_str()].join(": ")
+    }
+}
+
+impl From<String> for DOMExceptionName {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "IndexSizeError" => DOMExceptionName::IndexSizeError,
+            "HierarchyRequestError" => DOMExceptionName::HierarchyRequestError,
+            "WrongDocumentError" => DOMExceptionName::WrongDocumentError,
+            "InvalidCharacterError" => DOMExceptionName::InvalidCharacterError,
+            "NoModificationAllowedError" => DOMExceptionName::NoModificationAllowedError,
+            "NotFoundError" => DOMExceptionName::NotFoundError,
+            "NotSupportedError" => DOMExceptionName::NotSupportedError,
+            "InUseAttributeError" => DOMExceptionName::InUseAttributeError,
+            "InvalidStateError" => DOMExceptionName::InvalidStateError,
+            "SyntaxError" => DOMExceptionName::SyntaxError,
+            "InvalidModificationError" => DOMExceptionName::InvalidModificationError,
+            "NamespaceError" => DOMExceptionName::NamespaceError,
+            "InvalidAccessError" => DOMExceptionName::InvalidAccessError,
+            "TypeMismatchError" => DOMExceptionName::TypeMismatchError,
+            "SecurityError" => DOMExceptionName::SecurityError,
+            "NetworkError" => DOMExceptionName::NetworkError,
+            "AbortError" => DOMExceptionName::AbortError,
+            "URLMismatchError" => DOMExceptionName::URLMismatchError,
+            "QuotaExceededError" => DOMExceptionName::QuotaExceededError,
+            "TimeoutError" => DOMExceptionName::TimeoutError,
+            "InvalidNodeTypeError" => DOMExceptionName::InvalidNodeTypeError,
+            "DataCloneError" => DOMExceptionName::DataCloneError,
+            _ => DOMExceptionName::Other(value),
+        }
+    }
+}
+
+impl DOMExceptionName {
+    fn as_str(&self) -> &str {
+        match self {
+            DOMExceptionName::IndexSizeError => "IndexSizeError",
+            DOMExceptionName::HierarchyRequestError => "HierarchyRequestError",
+            DOMExceptionName::WrongDocumentError => "WrongDocumentError",
+            DOMExceptionName::InvalidCharacterError => "InvalidCharacterError",
+            DOMExceptionName::NoModificationAllowedError => "NoModificationAllowedError",
+            DOMExceptionName::NotFoundError => "NotFoundError",
+            DOMExceptionName::NotSupportedError => "NotSupportedError",
+            DOMExceptionName::InUseAttributeError => "InUseAttributeError",
+            DOMExceptionName::InvalidStateError => "InvalidStateError",
+            DOMExceptionName::SyntaxError => "SyntaxError",
+            DOMExceptionName::InvalidModificationError => "InvalidModificationError",
+            DOMExceptionName::NamespaceError => "NamespaceError",
+            DOMExceptionName::InvalidAccessError => "InvalidAccessError",
+            DOMExceptionName::TypeMismatchError => "TypeMismatchError",
+            DOMExceptionName::SecurityError => "SecurityError",
+            DOMExceptionName::NetworkError => "NetworkError",
+            DOMExceptionName::AbortError => "AbortError",
+            DOMExceptionName::URLMismatchError => "URLMismatchError",
+            DOMExceptionName::QuotaExceededError => "QuotaExceededError",
+            DOMExceptionName::TimeoutError => "TimeoutError",
+            DOMExceptionName::InvalidNodeTypeError => "InvalidNodeTypeError",
+            DOMExceptionName::DataCloneError => "DataCloneError",
+            DOMExceptionName::Error => "Error",
+            DOMExceptionName::Other(name) => name.as_str(),
+        }
     }
 }