refactor: simplified error router states

BREAKING CHANGE: removed `RouterLoadState::ErrorLoaded` entirely (you
should now rely solely on error views, which will be able to poll the
last router state, which probably contributed to/caused the error)

Author: arctic-hen7

examples/core/router_state/Cargo.toml

@@ -6,7 +6,8 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-perseus = { path = "../../../packages/perseus", features = [ "hydrate" ] }
+# TODO This doesn't work with hydration for some reason...
+perseus = { path = "../../../packages/perseus", features = [  ] }
 sycamore = "^0.8.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

examples/core/router_state/src/templates/index.rs

@@ -27,19 +27,15 @@ fn router_state_page<G: Html>(cx: Scope) -> View<G> {
                     path,
                 } => format!("Loading {} (template: {}).", *path, template_name),
                 RouterLoadState::Server => "We're on the server.".to_string(),
-                // Since this code is running in a page, it's a little pointless to handle an error
-                // page, which would replace this page (we wouldn't be able to
-                // display anything if this happened)
-                RouterLoadState::ErrorLoaded { .. } => unreachable!(),
             };
             load_state_str.set(new_str);
         });
     }
 
     view! { cx,
-        a(href = "about", id = "about-link") { "About!" }
-
         p { (load_state_str.get()) }
+
+        a(href = "about", id = "about-link") { "About!" }
     }
 }
 

packages/perseus/src/reactor/initial_load.rs

@@ -23,6 +23,8 @@ impl<G: Html> Reactor<G> {
     /// Gets the initial view to hydrate, which will be the same as what the
     /// engine-side rendered and provided. This will automatically extract
     /// the current path from the browser.
+    ///
+    /// This will set the router state to `Loaded` if it succeeds.
     pub(crate) fn get_initial_view<'a>(
         &self,
         cx: Scope<'a>,
@@ -128,7 +130,14 @@ impl<G: Html> Reactor<G> {
 
                 // Render the actual template to the root (done imperatively due to child
                 // scopes)
-                let (view, disposer) = entity.render_for_template_client(full_path, state, cx)?;
+                let (view, disposer) =
+                    entity.render_for_template_client(full_path.clone(), state, cx)?;
+
+                // Update the router state
+                self.router_state.set_load_state(RouterLoadState::Loaded {
+                    template_name: entity.get_path(),
+                    path: full_path,
+                });
 
                 Ok(InitialView::View(view, disposer))
             }

packages/perseus/src/reactor/start.rs

@@ -237,6 +237,7 @@ impl Reactor<BrowserNodeType> {
                     page_disposer.update(disposer);
                 }
 
+                // Note that the router state has already been correctly set to `Loaded`
                 (view, false)
             }
             // On a redirect, return a view that just redirects straight away (of course,

packages/perseus/src/reactor/state.rs

@@ -30,10 +30,9 @@ impl<G: Html> Freeze for Reactor<G> {
                 // It would be impressive to manage this timing, but it's fine to go to the route we
                 // were in the middle of loading when we thaw
                 RouterLoadState::Loading { path, .. } => Some(path.clone()),
-                // If we encounter this during re-hydration, we won't try to set the URL in the
-                // browser
-                RouterLoadState::ErrorLoaded { .. } => None,
                 RouterLoadState::Server => None,
+                // Error states are no longer propagated to the router, so we will attempt
+                // to pick up the last successful load implicitly
             },
             state_store: self.state_store.freeze_to_hash_map(),
         };
@@ -86,9 +85,9 @@ impl<G: Html> Reactor<G> {
         if let Some(frozen_route) = route {
             let curr_route = match &*self.router_state.get_load_state_rc().get_untracked() {
                 // If we've loaded a page, or we're about to, only change the route if necessary
-                RouterLoadState::Loaded { path, .. }
-                | RouterLoadState::Loading { path, .. }
-                | RouterLoadState::ErrorLoaded { path } => path.clone(),
+                RouterLoadState::Loaded { path, .. } | RouterLoadState::Loading { path, .. } => {
+                    path.clone()
+                }
                 // Since this function is only defined on the browser-side, this should
                 // be completely impossible (note that the user can't change the router
                 // state manually)

packages/perseus/src/reactor/subsequent_load.rs

@@ -151,19 +151,20 @@ impl<G: Html> Reactor<G> {
                     .await?;
 
                 let template_name = entity.get_path();
+                // Now return the view that should be rendered
+                let (view, disposer) = entity.render_for_template_client(
+                    full_path.clone(),
+                    TemplateState::from_value(page_data.state),
+                    cx,
+                )?;
+
                 // Pre-emptively update the router state
                 checkpoint("page_interactive");
                 // Update the router state
                 self.router_state.set_load_state(RouterLoadState::Loaded {
                     template_name,
-                    path: full_path.clone(),
+                    path: full_path,
                 });
-                // Now return the view that should be rendered
-                let (view, disposer) = entity.render_for_template_client(
-                    full_path,
-                    TemplateState::from_value(page_data.state),
-                    cx,
-                )?;
 
                 Ok((view, disposer))
             }

packages/perseus/src/router/router_state.rs

@@ -100,6 +100,12 @@ impl RouterState {
 /// The current load state of the router. You can use this to be warned of when
 /// a new page is about to be loaded (and display a loading bar or the like,
 /// perhaps).
+///
+/// In the event of an error, the router state will be left untouched (allowing
+/// it to be inspected in error views with reactor access to determine what the
+/// last page was, and therefore where the error likely occurred; usually, the
+/// last page will be in a `Loading` state). Popup errors will not cause any
+/// change to this state.
 #[derive(Clone, Debug)]
 pub enum RouterLoadState {
     /// The page has been loaded.
@@ -110,12 +116,6 @@ pub enum RouterLoadState {
         /// we're using i18n).
         path: PathMaybeWithLocale,
     },
-    /// An error page has been loaded. Note that this will not account for any
-    /// popup errors.
-    ErrorLoaded {
-        /// The path of this error.
-        path: PathMaybeWithLocale,
-    },
     /// A new page is being loaded, and will soon replace whatever is currently
     /// loaded. The name of the new template is attached.
     Loading {