rustolio_utils/

error.rs

//
// SPDX-License-Identifier: MPL-2.0
//
// Copyright (c) 2026 Tobias Binnewies. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

use std::panic::Location;

use wasm_bindgen::JsValue;

use crate::prelude::*;

pub type Result<T> = core::result::Result<T, Error>;

pub struct Error {
    context: String,
    inner: InnerError,

    #[cfg(debug_assertions)]
    caller: &'static Location<'static>,
}

impl Encode for Error {
    #[async_impl]
    async fn encode_async(&self, writer: &mut impl __utils_macros::AsyncEncoder) -> Result<()> {
        self.to_string().encode_async(writer).await?;
        Ok(())
    }
    fn encode_size(&self) -> usize {
        self.context.encode_size()
    }
}

impl Decode for Error {
    #[async_impl]
    async fn decode_async(reader: &mut impl __utils_macros::AsyncDecoder) -> Result<Self> {
        let context = String::decode_async(reader).await?;
        Ok(Self {
            context,
            inner: InnerError::None,
            #[cfg(debug_assertions)]
            caller: Location::caller(), // Placeholder
        })
    }
}

impl Error {
    #[track_caller]
    pub fn new(context: impl std::fmt::Display) -> Self {
        Self::new_inner(context, InnerError::None)
    }

    #[track_caller]
    fn new_inner(context: impl std::fmt::Display, inner: InnerError) -> Self {
        Error {
            context: context.to_string(),
            inner,

            #[cfg(debug_assertions)]
            caller: Location::caller(),
        }
    }

    pub fn context(&self) -> &str {
        &self.context
    }
}

#[cfg(target_arch = "wasm32")]
fn strigify_js(js_value: &JsValue) -> String {
    if let Ok(s) = js_sys::JSON::stringify(js_value) {
        return String::from(s);
    }
    String::from("Failed to stringify")
}

impl std::fmt::Debug for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if !self.context.is_empty() {
            f.write_fmt(format_args!("\"{}\"", &self.context))?;
        }
        match (&self.inner, self.context.is_empty()) {
            (InnerError::None, true) => {
                f.write_str("Error")?;
            }
            (InnerError::None, false) => {}
            (InnerError::Custom(e), _) => {
                f.write_str(": ")?;
                std::fmt::Debug::fmt(e, f)?;
            }
            #[cfg(target_arch = "wasm32")]
            (InnerError::JsValue(j), true) => {
                f.write_str("JS-Error: ")?;
                f.write_str(&strigify_js(j))?;
            }
            #[cfg(target_arch = "wasm32")]
            (InnerError::JsValue(j), false) => {
                f.write_str(": ")?;
                f.write_str(&strigify_js(j))?;
            }
        }

        #[cfg(debug_assertions)]
        {
            f.write_str(" at ")?;
            f.write_fmt(format_args!("{}", self.caller))?;
        }

        Ok(())
    }
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self.context.is_empty() {
                true => match self.inner {
                    InnerError::None => "None Value",
                    InnerError::Custom(_) => "Error",
                    #[cfg(target_arch = "wasm32")]
                    InnerError::JsValue(_) => "JS-Error",
                },
                false => self.context(),
            }
        )
    }
}

impl std::error::Error for Error {}

#[cfg(not(target_arch = "wasm32"))]
trait CustomError: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static {}
#[cfg(not(target_arch = "wasm32"))]
impl<T> CustomError for T where T: std::fmt::Debug + Send + Sync + std::fmt::Display + 'static {}

#[cfg(target_arch = "wasm32")]
trait CustomError: std::fmt::Debug + std::fmt::Display + 'static {}
#[cfg(target_arch = "wasm32")]
impl<T> CustomError for T where T: std::fmt::Debug + std::fmt::Display + 'static {}

#[derive(Debug)]
enum InnerError {
    None,
    #[cfg(target_arch = "wasm32")]
    JsValue(JsValue),
    Custom(Box<dyn CustomError>),
}

pub trait FromCustom
where
    Self: Sized,
{
    #[track_caller]
    fn with_context(self, context: impl std::fmt::Display) -> Error;
}

impl<E> FromCustom for E
where
    E: CustomError,
{
    #[track_caller]
    fn with_context(self, context: impl std::fmt::Display) -> Error {
        Error::new_inner(context, InnerError::Custom(Box::new(self)))
    }
}

pub trait FromCustomError<T>
where
    Self: Sized,
{
    #[track_caller]
    fn context(self, context: impl std::fmt::Display) -> Result<T>;
}

impl<T, E> FromCustomError<T> for std::result::Result<T, E>
where
    E: CustomError,
{
    #[track_caller]
    fn context(self, context: impl std::fmt::Display) -> Result<T> {
        self.map_err(|e| e.with_context(context))
    }
}

impl<T> FromCustomError<T> for Option<T> {
    #[track_caller]
    fn context(self, context: impl std::fmt::Display) -> Result<T> {
        self.ok_or(Error::new_inner(context, InnerError::None))
    }
}

pub trait FromJsValue<T>
where
    Self: Sized,
{
    #[track_caller]
    fn context(self, context: impl std::fmt::Display) -> Result<T>;
}

impl<T> FromJsValue<T> for std::result::Result<T, JsValue> {
    #[track_caller]
    fn context(self, context: impl std::fmt::Display) -> Result<T> {
        #[cfg(not(target_arch = "wasm32"))]
        unreachable!("JsValue cannot be constructed outside wasm32: {}", context);

        #[cfg(target_arch = "wasm32")]
        self.map_err(|e| Error::new_inner(context, InnerError::JsValue(e)))
    }
}

#[cfg(target_arch = "wasm32")]
impl From<JsValue> for Error {
    #[track_caller]
    fn from(value: JsValue) -> Self {
        Error::new_inner("Unreconverable JS-Error", InnerError::JsValue(value))
    }
}

#[cfg(not(target_arch = "wasm32"))]
impl From<JsValue> for Error {
    fn from(_: JsValue) -> Self {
        unreachable!("JsValue cannot be constructed outside wasm32");
    }
}