fix: made page state store work with multiple pages in single template

This is fine if you're using the `#[template(...)]` macro, but if you
aren't then you'll need to change some things.

Author: arctic-hen7

examples/rx_state/src/about.rs

@@ -11,7 +11,8 @@ pub fn about_page() -> View<G> {
     let pss = get_render_ctx!().page_state_store;
     // Get the state from the index page
     // If the user hasn't visited there yet, this won't exist
-    let username = match pss.get::<IndexPropsRx>() {
+    // The index page is just an empty string
+    let username = match pss.get::<IndexPropsRx>("") {
         Some(IndexPropsRx { username }) => username,
         None => Signal::new("".to_string()),
     };

packages/perseus-macro/src/head.rs

@@ -120,7 +120,7 @@ pub fn head_impl(input: HeadFn) -> TokenStream {
     if arg.is_some() {
         // There's an argument that will be provided as a `String`, so the wrapper will deserialize it
         quote! {
-            #vis fn #name(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<::sycamore::prelude::SsrNode> {
+            #vis fn #name(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<::sycamore::prelude::SsrNode> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*
@@ -129,14 +129,14 @@ pub fn head_impl(input: HeadFn) -> TokenStream {
                 }
                 #name(
                     // If there are props, they will always be provided, the compiler just doesn't know that
-                    ::serde_json::from_str(&props.unwrap()).unwrap()
+                    ::serde_json::from_str(&props.state.unwrap()).unwrap()
                 )
             }
         }
     } else {
         // There are no arguments
         quote! {
-            #vis fn #name(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<::sycamore::prelude::SsrNode> {
+            #vis fn #name(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<::sycamore::prelude::SsrNode> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*

packages/perseus-macro/src/template.rs

@@ -120,7 +120,7 @@ pub fn template_impl(input: TemplateFn, component_name: Ident) -> TokenStream {
     if arg.is_some() {
         // There's an argument that will be provided as a `String`, so the wrapper will deserialize it
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*
@@ -130,15 +130,15 @@ pub fn template_impl(input: TemplateFn, component_name: Ident) -> TokenStream {
                 ::sycamore::prelude::view! {
                     #component_name(
                         // If there are props, they will always be provided, the compiler just doesn't know that
-                        ::serde_json::from_str(&props.unwrap()).unwrap()
+                        ::serde_json::from_str(&props.state.unwrap()).unwrap()
                     )
                 }
             }
         }
     } else {
         // There are no arguments
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*
@@ -200,7 +200,7 @@ pub fn template_with_rx_state_impl(input: TemplateFn, attr_args: AttributeArgs)
         // There's an argument that will be provided as a `String`, so the wrapper will deserialize it
         // We'll also make it reactive and potentially add it to the global store
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*
@@ -214,14 +214,14 @@ pub fn template_with_rx_state_impl(input: TemplateFn, attr_args: AttributeArgs)
                             // If they are, we'll use them (so state persists for templates across the whole app)
                             // TODO Isolate this for pages
                             let mut pss = ::perseus::get_render_ctx!().page_state_store;
-                            match pss.get() {
+                            match pss.get(&props.path) {
                                 Some(old_state) => old_state,
                                 None => {
                                     // If there are props, they will always be provided, the compiler just doesn't know that
                                     // If the user is using this macro, they sure should be using `#[make_rx(...)]` or similar!
-                                    let rx_props = ::serde_json::from_str::<#unrx_ty>(&props.unwrap()).unwrap().make_rx();
+                                    let rx_props = ::serde_json::from_str::<#unrx_ty>(&props.state.unwrap()).unwrap().make_rx();
                                     // They aren't in there, so insert them
-                                    pss.add(rx_props.clone());
+                                    pss.add(&props.path, rx_props.clone());
                                     rx_props
                                 }
                             }
@@ -233,7 +233,7 @@ pub fn template_with_rx_state_impl(input: TemplateFn, attr_args: AttributeArgs)
     } else {
         // There are no arguments
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::std::option::Option<::std::string::String>) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
                 // The user's function, with Sycamore component annotations and the like preserved
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*

packages/perseus/src/build.rs

@@ -4,7 +4,7 @@ use crate::errors::*;
 use crate::locales::Locales;
 use crate::router::RouterState;
 use crate::state::PageStateStore;
-use crate::templates::TemplateMap;
+use crate::templates::{PageProps, TemplateMap};
 use crate::translations_manager::TranslationsManager;
 use crate::translator::Translator;
 use crate::{
@@ -94,13 +94,20 @@ async fn gen_state_for_path(
         Some(stripped) => stripped.to_string(),
         None => full_path_without_locale,
     };
-    // Add the current locale to the front of that na dencode it as a URL so we can store a flat series of files
+    // Add the current locale to the front of that and dencode it as a URL so we can store a flat series of files
     // BUG: insanely nested paths won't work whatsoever if the filename is too long, maybe hash instead?
     let full_path_encoded = format!(
         "{}-{}",
         translator.get_locale(),
         urlencoding::encode(&full_path_without_locale)
     );
+    // And we'll need the full path with the locale for the `PageProps`
+    // If it's `xx-XX`, we should just have it without the locale (this may be interacted with by users)
+    let locale = translator.get_locale();
+    let full_path_with_locale = match locale.as_str() {
+        "xx-XX" => full_path_without_locale.clone(),
+        locale => format!("{}/{}", locale, &full_path_without_locale),
+    };
 
     // Handle static initial state generation
     // We'll only write a static state if one is explicitly generated
@@ -120,7 +127,10 @@ async fn gen_state_for_path(
         // Prerender the template using that state
         let prerendered = sycamore::render_to_string(|| {
             template.render_for_template(
-                Some(initial_state.clone()),
+                PageProps {
+                    path: full_path_with_locale.clone(),
+                    state: Some(initial_state.clone()),
+                },
                 translator,
                 true,
                 RouterState::default(),
@@ -133,7 +143,13 @@ async fn gen_state_for_path(
             .await?;
         // Prerender the document `<head>` with that state
         // If the page also uses request state, amalgamation will be applied as for the normal content
-        let head_str = template.render_head_str(Some(initial_state), translator);
+        let head_str = template.render_head_str(
+            PageProps {
+                path: full_path_with_locale.clone(),
+                state: Some(initial_state.clone()),
+            },
+            translator,
+        );
         mutable_store
             .write(
                 &format!("static/{}.head.html", full_path_encoded),
@@ -155,7 +171,10 @@ async fn gen_state_for_path(
         // Prerender the template using that state
         let prerendered = sycamore::render_to_string(|| {
             template.render_for_template(
-                Some(initial_state.clone()),
+                PageProps {
+                    path: full_path_with_locale.clone(),
+                    state: Some(initial_state.clone()),
+                },
                 translator,
                 true,
                 RouterState::default(),
@@ -168,7 +187,13 @@ async fn gen_state_for_path(
             .await?;
         // Prerender the document `<head>` with that state
         // If the page also uses request state, amalgamation will be applied as for the normal content
-        let head_str = template.render_head_str(Some(initial_state), translator);
+        let head_str = template.render_head_str(
+            PageProps {
+                path: full_path_with_locale.clone(),
+                state: Some(initial_state),
+            },
+            translator,
+        );
         immutable_store
             .write(
                 &format!("static/{}.head.html", full_path_encoded),
@@ -200,14 +225,23 @@ async fn gen_state_for_path(
     if template.is_basic() {
         let prerendered = sycamore::render_to_string(|| {
             template.render_for_template(
-                None,
+                PageProps {
+                    path: full_path_with_locale.clone(),
+                    state: None,
+                },
                 translator,
                 true,
                 RouterState::default(),
                 PageStateStore::default(),
             )
         });
-        let head_str = template.render_head_str(None, translator);
+        let head_str = template.render_head_str(
+            PageProps {
+                path: full_path_with_locale,
+                state: None,
+            },
+            translator,
+        );
         // Write that prerendered HTML to a static file
         immutable_store
             .write(&format!("static/{}.html", full_path_encoded), &prerendered)

packages/perseus/src/page_state_store.rs

@@ -3,23 +3,37 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
+/// A key type for the `PageStateStore` that denotes both a page's state type and its URL.
+#[derive(Hash, PartialEq, Eq)]
+pub struct PageStateKey {
+    state_type: TypeId,
+    url: String,
+}
+
 /// A container for page state in Perseus. This is designed as a context store, in which one of each type can be stored. Therefore, it acts very similarly to Sycamore's context system,
 /// though it's specifically designed for each page to store one reactive properties object. In theory, you could interact with this entirely independently of Perseus' state interface,
 /// though this isn't recommended.
+///
+/// Note that the same pages in different locales will have different entries here. If you need to store state for a page across locales, you should use the global state system instead. For apps
+/// not using i18n, the page URL will not include any locale.
 // TODO Make this work with multiple pages for a single template
 #[derive(Default, Clone)]
 pub struct PageStateStore {
     /// A map of type IDs to anything, allowing one storage of each type (each type is intended to a properties `struct` for a template). Entries must be `Clone`able becasue we assume them
     /// to be `Signal`s or `struct`s composed of `Signal`s.
     // Technically, this should be `Any + Clone`, but that's not possible without something like `dyn_clone`, and we don't need it because we can restrict on the methods instead!
-    map: Rc<RefCell<HashMap<TypeId, Box<dyn Any>>>>,
+    map: Rc<RefCell<HashMap<PageStateKey, Box<dyn Any>>>>,
 }
 impl PageStateStore {
-    /// Gets an element out of the state by its type.
-    pub fn get<T: Any + Clone>(&self) -> Option<T> {
+    /// Gets an element out of the state by its type and URL.
+    pub fn get<T: Any + Clone>(&self, url: &str) -> Option<T> {
         let type_id = TypeId::of::<T>();
+        let key = PageStateKey {
+            state_type: type_id,
+            url: url.to_string(),
+        };
         let map = self.map.borrow();
-        map.get(&type_id).map(|val| {
+        map.get(&key).map(|val| {
             if let Some(val) = val.downcast_ref::<T>() {
                 (*val).clone()
             } else {
@@ -28,16 +42,24 @@ impl PageStateStore {
             }
         })
     }
-    /// Adds a new element to the state by its type. Any existing element with the same type will be silently overriden (use `.contains()` to check first if needed).
-    pub fn add<T: Any + Clone>(&mut self, val: T) {
+    /// Adds a new element to the state by its type and URL. Any existing element with the same type and URL will be silently overriden (use `.contains()` to check first if needed).
+    pub fn add<T: Any + Clone>(&mut self, url: &str, val: T) {
         let type_id = TypeId::of::<T>();
+        let key = PageStateKey {
+            state_type: type_id,
+            url: url.to_string(),
+        };
         let mut map = self.map.borrow_mut();
-        map.insert(type_id, Box::new(val));
+        map.insert(key, Box::new(val));
     }
-    /// Checks if the state contains the element of the given type.
-    pub fn contains<T: Any + Clone>(&self) -> bool {
+    /// Checks if the state contains the element of the given type for the given page.
+    pub fn contains<T: Any + Clone>(&self, url: &str) -> bool {
         let type_id = TypeId::of::<T>();
-        self.map.borrow().contains_key(&type_id)
+        let key = PageStateKey {
+            state_type: type_id,
+            url: url.to_string(),
+        };
+        self.map.borrow().contains_key(&key)
     }
 }