dx-ether-rs 0.1.1

use dioxus::{logger::tracing, prelude::*};

use crate::adapters::ether_adapter::EtherAdapter;

pub struct UseEtherInitialize {
    pub allowed_info_log: Option<bool>,
    pub allowed_error_log: Option<bool>,
}

pub fn use_ether_initialize(options: Option<UseEtherInitialize>) -> (Signal<String>, Signal<bool>) {
    let options = options.unwrap_or(UseEtherInitialize {
        allowed_info_log: Some(true),
        allowed_error_log: Some(true),
    });

    let allowed_info_log = use_memo(move || options.allowed_info_log.unwrap_or(true));
    let allowed_error_log = use_memo(move || options.allowed_error_log.unwrap_or(true));

    let mut error = use_signal(String::new);
    let mut loading = use_signal(|| true);

    use_future(move || {
        let allowed_info_log = allowed_info_log();
        let allowed_error_log = allowed_error_log();

        async move {
            match EtherAdapter::new().wait_js_scripts().await {
                Ok(_) => {
                    loading.set(false);

                    if allowed_info_log {
                        tracing::info!("Ether has initialized.");
                    }
                }
                Err(e) => {
                    error.set(e.to_string());
                    loading.set(false);

                    if allowed_error_log {
                        tracing::error!("Ether has been failed: {}", e.to_string());
                    }
                }
            };
        }
    });

    (error, loading)
}