1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//!
//!  Errors produced by this crate.
//!

use base64::DecodeError;
use thiserror::Error;
use wasm_bindgen::prelude::*;
use workflow_wasm::jserror::*;

#[derive(Error, Debug)]
pub enum Error {
    #[error("{0}")]
    Custom(String),

    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("Chrome error: {0}")]
    ChromeError(#[from] workflow_chrome::error::Error),

    // #[error("JavaScript error: {0:?}")]
    // JsValue(Sendable<JsValue>),
    #[error("{0}")]
    JsValue(JsErrorData),

    #[error("Base64 decode error: {0}")]
    DecodeError(DecodeError),

    #[error("Not found: {0}")]
    NotFound(String),

    #[error("Not a text data: {0}")]
    DataIsNotAString(String),

    #[error("Not a buffer data: {0}")]
    DataIsNotABuffer(String),

    #[error(transparent)]
    SerdeJson(#[from] serde_json::Error),

    #[error("invalid path: {0}")]
    InvalidPath(String),

    #[error("Unable to obtain user home directory")]
    HomeDir(String),

    #[error("No file metadata")]
    Metadata,

    #[error(transparent)]
    FasterHex(#[from] faster_hex::Error),

    #[error("This operation is not supported")]
    NotSupported,
}

impl From<Error> for JsValue {
    fn from(err: Error) -> Self {
        match err {
            Error::JsValue(js_err) => js_err.into(),
            _ => err.into(),
        }
    }
}

// impl From<Error> for JsErrorData {
//     fn from(err: Error) -> Self {
//         match err {
//             Error::JsValue(js_err) => js_err.into(),
//             _ => err.into(),
//         }
//     }
// }

impl From<JsValue> for Error {
    fn from(error: JsValue) -> Error {
        Error::JsValue(error.into())
    }
}

impl From<JsErrorData> for Error {
    fn from(error: JsErrorData) -> Error {
        Error::JsValue(error)
    }
}

impl From<DecodeError> for Error {
    fn from(error: DecodeError) -> Error {
        Error::DecodeError(error)
    }
}

impl From<String> for Error {
    fn from(error: String) -> Error {
        Error::Custom(error)
    }
}

impl Error {
    pub fn code(&self) -> Option<&str> {
        match self {
            Error::JsValue(js_err) => js_err.code().as_deref(),
            _ => None,
        }
    }
}