more work on use_webtransport

src/use_webtransport.rs

@@ -4,6 +4,7 @@ use default_struct_builder::DefaultBuilder;
 use leptos::leptos_dom::helpers::TimeoutHandle;
 use leptos::*;
 use std::rc::Rc;
+use std::time::Duration;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 
@@ -51,7 +52,28 @@ pub fn use_webtransport_with_options(
     let reconnect_timer_ref = store_value(None::<TimeoutHandle>);
     let reconnect_count_ref = store_value(0_u64);
 
-    let connect = move || {
+    let connect_ref = store_value(None::<Rc<dyn Fn()>>);
+
+    let reconnect = Rc::new(move || {
+        if reconnect_count_ref.get_value() < reconnect_limit
+            && ready_state.get_untracked() == ConnectionReadyState::Open
+        {
+            reconnect_timer_ref.set_value(
+                set_timeout_with_handle(
+                    move || {
+                        if let Some(connect) = connect_ref.get_value() {
+                            connect();
+                            reconnect_count_ref.update_value(|current| *current += 1);
+                        }
+                    },
+                    Duration::from_millis(reconnect_interval),
+                )
+                .ok(),
+            )
+        }
+    });
+
+    connect_ref.set_value(Some(Rc::new(move || {
         let transport = transport_ref.get_value();
 
         reconnect_timer_ref.set_value(None);
@@ -77,26 +99,53 @@ pub fn use_webtransport_with_options(
                 }
             }
         });
-    };
+    })));
 
     let open = {
         move || {
             reconnect_count_ref.set_value(0);
+            if let Some(connect) = connect_ref.get_value() {
+                connect();
+            }
         }
     };
 
-    UseWebtransportReturn {}
+    let close = move || {
+        reconnect_count_ref.set_value(reconnect_limit);
+        if let Some(transport) = transport_ref.get_value() {
+            transport.close();
+            set_ready_state.set(ConnectionReadyState::Closing);
+
+            spawn_local(async move {
+                let result = JsFuture::from(transport.closed()).await;
+                set_ready_state.set(ConnectionReadyState::Closed);
+
+                match result {
+                    Ok(_) => {
+                        on_close();
+                    }
+                    Err(e) => {
+                        // TODO : handle error?
+                    }
+                }
+            });
+        }
+    };
+
+    UseWebtransportReturn {
+        ready_state: ready_state.into(),
+    }
 }
 
 /// Options for [`use_webtransport_with_options`].
 #[derive(DefaultBuilder)]
 pub struct UseWebTransportOptions {
     /// Callback when `WebTransport` is ready.
-    on_open: Box<dyn CloneableFn>,
+    on_open: Rc<dyn Fn()>,
     /// Error callback.
-    on_error: Box<dyn CloneableFnWithArg<WebTransportError>>,
+    on_error: Rc<dyn Fn(WebTransportError)>,
     /// Callback when `WebTransport` is closed.
-    on_close: Box<dyn CloneableFn>,
+    on_close: Rc<dyn Fn()>,
     /// Retry times. Defaults to 3.
     reconnect_limit: u64,
     /// Retry interval in ms. Defaults to 3000.
@@ -110,9 +159,9 @@ pub struct UseWebTransportOptions {
 impl Default for UseWebTransportOptions {
     fn default() -> Self {
         Self {
-            on_open: Box::new(|| {}),
+            on_open: Rc::new(|| {}),
-            on_error: Box::new(|_| {}),
+            on_error: Rc::new(|_| {}),
-            on_close: Box::new(|| {}),
+            on_close: Rc::new(|| {}),
             reconnect_limit: 3,
             reconnect_interval: 3000,
             immediate: true,