feat: add prevent default attribute and upgrade router

packages/router/src/components/link.rs

@@ -37,10 +37,8 @@ pub struct LinkProps<'a> {
     attributes: Option<&'a [Attribute<'a>]>,
 }
 
-#[allow(non_snake_case)]
 pub fn Link<'a>(cx: Scope<'a, LinkProps<'a>>) -> Element {
-    log::debug!("rendering link {:?}", cx.scope_id());
-    let service = cx.consume_context::<RouterService>()?;
+    let service = cx.consume_context::<RouterService>().unwrap();
     cx.render(rsx! {
         a {
             href: "{cx.props.to}",
@@ -48,10 +46,7 @@ pub fn Link<'a>(cx: Scope<'a, LinkProps<'a>>) -> Element {
             id: format_args!("{}", cx.props.id.unwrap_or("")),
 
             prevent_default: "onclick",
-            onclick: move |_| {
-                log::debug!("clicked");
-                service.push_route(cx.props.to.clone());
-            },
+            onclick: move |_| service.push_route(cx.props.to.clone()),
 
             &cx.props.children
         }

packages/router/src/components/route.rs

@@ -11,7 +11,11 @@ use crate::{RouteContext, RouterService};
 #[derive(Props)]
 pub struct RouteProps<'a> {
     to: &'a str,
+
     children: Element<'a>,
+
+    #[props(default)]
+    fallback: bool,
 }
 
 pub fn Route<'a>(cx: Scope<'a, RouteProps<'a>>) -> Element {
@@ -34,15 +38,18 @@ pub fn Route<'a>(cx: Scope<'a, RouteProps<'a>>) -> Element {
         });
 
         // submit our rout
-        router_root.register_total_route(route_context.total_route.clone(), cx.scope_id());
+        router_root.register_total_route(
+            route_context.total_route.clone(),
+            cx.scope_id(),
+            cx.props.fallback,
+        );
 
         Some(RouteInner {})
     });
 
-    log::debug!("rendering route {:?}", cx.scope_id());
+    log::debug!("Checking route {}", cx.props.to);
 
     if router_root.should_render(cx.scope_id()) {
-        log::debug!("route {:?} produced nodes", cx.scope_id());
         cx.render(rsx!(&cx.props.children))
     } else {
         None

packages/router/src/components/router.rs

@@ -15,14 +15,13 @@ pub struct RouterProps<'a> {
     onchange: Option<&'a Fn(&'a str)>,
 }
 
+#[allow(non_snake_case)]
 pub fn Router<'a>(cx: Scope<'a, RouterProps<'a>>) -> Element {
-    let p = cx.use_hook(|_| {
+    cx.use_hook(|_| {
         let update = cx.schedule_update_any();
         cx.provide_context(RouterService::new(update, cx.scope_id()))
     });
 
-    log::debug!("rendering router {:?}", cx.scope_id());
-
     cx.render(rsx!(
         div { &cx.props.children }
     ))

packages/router/src/lib.rs

@@ -31,6 +31,8 @@ mod hooks {
 pub use hooks::*;
 
 mod components {
+    #![allow(non_snake_case)]
+
     mod router;
     pub use router::*;
 

packages/router/src/service.rs

@@ -1,13 +1,18 @@
 use gloo::history::{BrowserHistory, History, HistoryListener};
-use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use std::{
+    cell::{Cell, RefCell},
+    collections::HashMap,
+    rc::Rc,
+};
 
 use dioxus_core::ScopeId;
 
 pub struct RouterService {
     pub(crate) regen_route: Rc<dyn Fn(ScopeId)>,
-    history: RefCell<BrowserHistory>,
+    history: Rc<RefCell<BrowserHistory>>,
     registerd_routes: RefCell<RouteSlot>,
-    slots: RefCell<HashMap<ScopeId, String>>,
+    slots: Rc<RefCell<Vec<(ScopeId, String)>>>,
+    root_found: Rc<Cell<bool>>,
     cur_root: RefCell<String>,
     listener: HistoryListener,
 }
@@ -31,9 +36,20 @@ impl RouterService {
         let location = history.location();
         let path = location.path();
 
-        let regen = Rc::clone(&regen_route);
+        let slots: Rc<RefCell<Vec<(ScopeId, String)>>> = Default::default();
+
+        let _slots = slots.clone();
+
+        let root_found = Rc::new(Cell::new(false));
+        let regen = regen_route.clone();
+        let _root_found = root_found.clone();
         let listener = history.listen(move || {
-            regen(root_scope);
+            _root_found.set(false);
+            // checking if the route is valid is cheap, so we do it
+            for (slot, _) in _slots.borrow_mut().iter().rev() {
+                log::debug!("regenerating slot {:?}", slot);
+                regen(*slot);
+            }
         });
 
         Self {
@@ -42,9 +58,10 @@ impl RouterService {
                 total: String::from("/"),
                 rest: Vec::new(),
             }),
-            history: RefCell::new(history),
+            root_found,
+            history: Rc::new(RefCell::new(history)),
             regen_route,
-            slots: Default::default(),
+            slots,
             cur_root: RefCell::new(path.to_string()),
             listener,
         }
@@ -54,20 +71,37 @@ impl RouterService {
         self.history.borrow_mut().push(route);
     }
 
-    pub fn register_total_route(&self, route: String, scope: ScopeId) {
-        self.slots.borrow_mut().insert(scope, route);
+    pub fn register_total_route(&self, route: String, scope: ScopeId, fallback: bool) {
+        self.slots.borrow_mut().push((scope, route));
     }
 
     pub fn should_render(&self, scope: ScopeId) -> bool {
+        if self.root_found.get() {
+            return false;
+        }
+
         let location = self.history.borrow().location();
         let path = location.path();
 
         let roots = self.slots.borrow();
 
-        let root = roots.get(&scope);
+        let root = roots.iter().find(|(id, route)| id == &scope);
 
+        // fallback logic
         match root {
-            Some(r) => r == path,
+            Some((_id, route)) => {
+                if route == path {
+                    self.root_found.set(true);
+                    true
+                } else {
+                    if route == "" {
+                        self.root_found.set(true);
+                        true
+                    } else {
+                        false
+                    }
+                }
+            }
             None => false,
         }
     }