Struct JsError

pub struct JsError { /* private fields */ }

Available on crate feature dep_wasm_bindgen only.

Convenience type for use on exported fn() -> Result<T, JsError> functions, where you wish to throw a JavaScript Error object.

You can get wasm_bindgen to throw basic errors by simply returning Err(JsError::new("message")) from such a function.

For more complex error handling, JsError implements From<T> where T: std::error::Error by converting it to a string, so you can use it with ?. Many Rust error types already do this, and you can use thiserror to derive Display implementations easily or use any number of boxed error types that implement it already.

To allow JavaScript code to catch only your errors, you may wish to add a subclass of Error in a JS module, and then implement Into<JsValue> directly on a type and instantiate that subclass. In that case, you would not need JsError at all.

Basic example

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn throwing_function() -> Result<(), JsError> {
    Err(JsError::new("message"))
}

Complex Example

use wasm_bindgen::prelude::*;

#[derive(Debug, Clone)]
enum MyErrorType {
    SomeError,
}

use core::fmt;
impl std::error::Error for MyErrorType {}
impl fmt::Display for MyErrorType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "display implementation becomes the error message")
    }
}

fn internal_api() -> Result<(), MyErrorType> {
    Err(MyErrorType::SomeError)
}

#[wasm_bindgen]
pub fn throwing_function() -> Result<(), JsError> {
    internal_api()?;
    Ok(())
}

Implementations

impl JsError

pub fn new(s: &str) -> JsError

Available on crate feature dep_js_sys only.

Construct a JavaScript Error object with a string message

Trait Implementations

impl Clone for JsError

fn clone(&self) -> JsError

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<E> From<E> for JsError

where E: Error,

fn from(error: E) -> JsError

Converts to this type from the input type.

impl From<JsError> for JsValue

fn from(error: JsError) -> JsValue

Converts to this type from the input type.

impl IntoWasmAbi for JsError

type Abi = <JsValue as IntoWasmAbi>::Abi

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> <JsError as IntoWasmAbi>::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.