wip: remove runner on hook and then update docs

packages/router/src/platform/web.rs

@@ -49,7 +49,8 @@ impl<R: Routable> RouterService<R> {
 }
 
 pub fn use_router_service<R: Routable>(cx: &ScopeState) -> Option<&Rc<RouterService<R>>> {
-    cx.use_hook(|_| cx.consume_state::<RouterService<R>>(), |f| f.as_ref())
+    cx.use_hook(|_| cx.consume_state::<RouterService<R>>())
+        .as_ref()
 }
 
 /// This hould only be used once per app
@@ -57,7 +58,7 @@ pub fn use_router_service<R: Routable>(cx: &ScopeState) -> Option<&Rc<RouterServ
 /// You can manually parse the route if you want, but the derived `parse` method on `Routable` will also work just fine
 pub fn use_router<R: Routable>(cx: &ScopeState, mut parse: impl FnMut(&str) -> R + 'static) -> &R {
     // for the web, attach to the history api
-    cx.use_hook(
+    let state = cx.use_hook(
         #[cfg(not(feature = "web"))]
         |_| {},
         #[cfg(feature = "web")]
@@ -112,15 +113,13 @@ pub fn use_router<R: Routable>(cx: &ScopeState, mut parse: impl FnMut(&str) -> R
 
             service
         },
-        |state| {
-            let base = state.base_ur.borrow();
-            if let Some(base) = base.as_ref() {
-                //
-                let path = format!("{}{}", base, state.get_current_route());
-            }
-            let history = state.history_service.borrow();
+    );
 
-            state.historic_routes.last().unwrap()
-        },
-    )
+    let base = state.base_ur.borrow();
+    if let Some(base) = base.as_ref() {
+        let path = format!("{}{}", base, state.get_current_route());
+    }
+
+    let history = state.history_service.borrow();
+    state.historic_routes.last().unwrap()
 }

packages/router/src/userouter.rs

@@ -4,30 +4,27 @@ use crate::{Routable, RouterCfg, RouterService};
 use dioxus_core::ScopeState;
 
 /// Initialize the app's router service and provide access to `Link` components
-pub fn use_router<'a, R: Routable>(cx: &'a ScopeState, cfg: impl FnOnce(&mut RouterCfg)) -> &'a R {
-    cx.use_hook(
-        |_| {
-            let svc: RouterService<R> = RouterService {
-                regen_route: cx.schedule_update(),
-                pending_routes: RefCell::new(Vec::new()),
-            };
-            let first_path = R::default();
-            cx.provide_context(svc);
-            UseRouterInner {
-                svc: cx.consume_context::<RouterService<R>>().unwrap(),
-                history: vec![first_path],
-            }
-        },
-        |f| {
-            let mut pending_routes = f.svc.pending_routes.borrow_mut();
+pub fn use_router<'a, R: Routable>(cx: &'a ScopeState, _cfg: impl FnOnce(&mut RouterCfg)) -> &'a R {
+    let router = cx.use_hook(|_| {
+        let svc: RouterService<R> = RouterService {
+            regen_route: cx.schedule_update(),
+            pending_routes: RefCell::new(Vec::new()),
+        };
+        let first_path = R::default();
+        cx.provide_context(svc);
+        UseRouterInner {
+            svc: cx.consume_context::<RouterService<R>>().unwrap(),
+            history: vec![first_path],
+        }
+    });
 
-            for route in pending_routes.drain(..) {
-                f.history.push(route);
-            }
+    let mut pending_routes = router.svc.pending_routes.borrow_mut();
 
-            f.history.last().unwrap()
-        },
-    )
+    for route in pending_routes.drain(..) {
+        router.history.push(route);
+    }
+
+    router.history.last().unwrap()
 }
 
 struct UseRouterInner<R: Routable> {