allow nested routes

packages/router/examples/static_generation.rs

@@ -28,22 +28,25 @@ async fn main() {
     .invalidate_after(Duration::from_secs(10))
     .build();
 
+    println!(
+        "SITE MAP:\n{}",
+        Route::SITE_MAP
+            .iter()
+            .flat_map(|route| route.flatten().into_iter())
+            .map(|route| {
+                route
+                    .iter()
+                    .map(|segment| segment.to_string())
+                    .collect::<Vec<_>>()
+                    .join("")
+            })
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+
     pre_cache_static_routes::<Route, _>(&mut renderer)
         .await
         .unwrap();
-
-    for _ in 0..1_000_000 {
-        for id in 0..10 {
-            render_route(
-                &mut renderer,
-                Route::Post { id },
-                &mut tokio::io::sink(),
-                |_| {},
-            )
-            .await
-            .unwrap();
-        }
-    }
 }
 
 #[inline_props]
@@ -82,6 +85,64 @@ fn Home(cx: Scope) -> Element {
     }
 }
 
+mod inner {
+    use dioxus::prelude::*;
+    use dioxus_router::prelude::*;
+
+    #[rustfmt::skip]
+    #[derive(Clone, Debug, PartialEq, Routable)]
+    pub enum Route {
+        #[nest("/blog")]
+            #[route("/")]
+            Blog {},
+            #[route("/post/index")]
+            PostHome {},
+            #[route("/post/:id")]
+            Post {
+                id: usize,
+            },
+        #[end_nest]
+        #[route("/")]
+        Home {},
+    }
+
+    #[inline_props]
+    fn Blog(cx: Scope) -> Element {
+        render! {
+            div {
+                "Blog"
+            }
+        }
+    }
+
+    #[inline_props]
+    fn Post(cx: Scope, id: usize) -> Element {
+        render! {
+            div {
+                "PostId: {id}"
+            }
+        }
+    }
+
+    #[inline_props]
+    fn PostHome(cx: Scope) -> Element {
+        render! {
+            div {
+                "Post"
+            }
+        }
+    }
+
+    #[inline_props]
+    fn Home(cx: Scope) -> Element {
+        render! {
+            div {
+                "Home"
+            }
+        }
+    }
+}
+
 #[rustfmt::skip]
 #[derive(Clone, Debug, PartialEq, Routable)]
 enum Route {
@@ -97,4 +158,6 @@ enum Route {
     #[end_nest]
     #[route("/")]
     Home {},
+    #[child("/hello_world")]
+    HelloWorldRoute(inner::Route)
 }

packages/router/src/incremental.rs

@@ -25,6 +25,7 @@ where
         let mut full_path = String::new();
         for segment in &route {
             match segment {
+                SegmentType::Child => {}
                 SegmentType::Static(s) => {
                     full_path += "/";
                     full_path += s;
@@ -43,6 +44,7 @@ where
                     render_route(renderer, route, &mut tokio::io::sink(), |_| {}).await?;
                 }
                 Err(e) => {
+                    log::info!("@ route: {}", full_path);
                     log::error!("Error pre-caching static route: {}", e);
                 }
             }

packages/router/src/routable.rs

@@ -172,12 +172,15 @@ pub enum SegmentType {
     Dynamic(&'static str),
     /// A catch all route segment
     CatchAll(&'static str),
+    /// A child router
+    Child,
 }
 
 impl Display for SegmentType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             SegmentType::Static(s) => write!(f, "/{}", s),
+            SegmentType::Child => Ok(()),
             SegmentType::Dynamic(s) => write!(f, "/:{}", s),
             SegmentType::CatchAll(s) => write!(f, "/:...{}", s),
         }