feat: added lazy global state instantiation

This makes the `global_state` macro parameter only required on
templates that actually use the global state, which is much more ergonomic.

Author: arctic-hen7

examples/rx_state/src/about.rs

@@ -1,11 +1,10 @@
-use crate::global_state::AppState;
 use crate::index::IndexPropsRx;
 use perseus::{get_render_ctx, Html, Template};
 use sycamore::prelude::{view, Signal};
 use sycamore::view::View;
 
 // This template doesn't have any properties, so there's no point in using the special `template_with_rx_state` macro (but we could)
-#[perseus::template_with_rx_state(component = "AboutPage", global_state = "AppState")]
+#[perseus::template_with_rx_state(component = "AboutPage")]
 pub fn about_page() -> View<G> {
     // Get the page state store manually
     // The index page is just an empty string

packages/perseus-macro/src/template2.rs

@@ -106,11 +106,9 @@ pub struct TemplateArgs {
     /// The name of the type parameter to use (default to `G`).
     #[darling(default)]
     type_param: Option<Ident>,
-    // /// The identifier of the global state type, if there is one.
-    // #[darling(default)]
-    // global_state: Option<Ident>,
-    /// The identifier of the global state.
-    global_state: Ident,
+    /// The identifier of the global state type, if this template needs it.
+    #[darling(default)]
+    global_state: Option<Ident>,
     /// The name of the unreactive properties, if there are any.
     #[darling(default)]
     unrx_props: Option<Ident>,
@@ -129,23 +127,22 @@ pub fn template_impl(input: TemplateFn, args: TemplateArgs) -> TokenStream {
     } = input;
 
     let component_name = &args.component;
-    let global_state = &args.global_state;
     let type_param = match &args.type_param {
         Some(type_param) => type_param.clone(),
         None => Ident::new("G", Span::call_site()),
     };
     // This is only optional if the second argument wasn't provided
-    // let global_state = if fn_args.len() == 2 {
-    //     match &args.global_state {
-    //         Some(global_state) => global_state.clone(),
-    //         None => return syn::Error::new_spanned(&fn_args[0], "template functions with two arguments must declare their global state type (`global_state = `)").to_compile_error()
-    //     }
-    // } else {
-    //     match &args.global_state {
-    //         Some(global_state) => global_state.clone(),
-    //         None => Ident::new("Dummy", Span::call_site()),
-    //     }
-    // };
+    let global_state = if fn_args.len() == 2 {
+        match &args.global_state {
+            Some(global_state) => global_state.clone(),
+            None => return syn::Error::new_spanned(&fn_args[0], "template functions with two arguments must declare their global state type (`global_state = `)").to_compile_error()
+        }
+    } else {
+        match &args.global_state {
+            Some(global_state) => global_state.clone(),
+            None => Ident::new("Dummy", Span::call_site()),
+        }
+    };
     // This is only optional if the first argument wasn't provided
     let unrx_props = if !fn_args.is_empty() {
         match &args.unrx_props {
@@ -159,25 +156,6 @@ pub fn template_impl(input: TemplateFn, args: TemplateArgs) -> TokenStream {
         }
     };
 
-    let manage_global_state = quote! {
-        // Deserialize the global state, make it reactive, and register it with the `RenderCtx`
-        // If it's already there, we'll leave it
-        // This means that we can pass an `Option<String>` around safely and then deal with it at the template site
-        let global_state_refcell = ::perseus::get_render_ctx!().global_state;
-        let global_state = global_state_refcell.borrow();
-        if (&global_state).downcast_ref::<::std::option::Option::<()>>().is_some() {
-            // We can downcast it as the type set by the core render system, so we're the first page to be loaded
-            // In that case, we'll set the global state properly
-            drop(global_state);
-            let mut global_state = global_state_refcell.borrow_mut();
-            // This will be defined if we're the first page
-            let global_state_props = &props.global_state.unwrap();
-            let new_global_state = ::serde_json::from_str::<#global_state>(global_state_props).unwrap().make_rx();
-            *global_state = ::std::boxed::Box::new(new_global_state);
-            // The component function can now access this in `RenderCtx`
-        }
-    };
-
     // We create a wrapper function that can be easily provided to `.template()` that does deserialization automatically if needed
     // This is dependent on what arguments the template takes
     if fn_args.len() == 2 {
@@ -193,7 +171,22 @@ pub fn template_impl(input: TemplateFn, args: TemplateArgs) -> TokenStream {
         };
         quote! {
             #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
-                #manage_global_state
+                // Deserialize the global state, make it reactive, and register it with the `RenderCtx`
+                // If it's already there, we'll leave it
+                // This means that we can pass an `Option<String>` around safely and then deal with it at the template site
+                let global_state_refcell = ::perseus::get_render_ctx!().global_state;
+                let global_state = global_state_refcell.borrow();
+                if (&global_state).downcast_ref::<::std::option::Option::<()>>().is_some() {
+                    // We can downcast it as the type set by the core render system, so we're the first page to be loaded
+                    // In that case, we'll set the global state properly
+                    drop(global_state);
+                    let mut global_state = global_state_refcell.borrow_mut();
+                    // This will be defined if we're the first page
+                    let global_state_props = &props.global_state.unwrap();
+                    let new_global_state = ::serde_json::from_str::<#global_state>(global_state_props).unwrap().make_rx();
+                    *global_state = ::std::boxed::Box::new(new_global_state);
+                    // The component function can now access this in `RenderCtx`
+                }
                 // The user's function
                 // We know this won't be async because Sycamore doesn't allow that
                 #(#attrs)*
@@ -236,7 +229,6 @@ pub fn template_impl(input: TemplateFn, args: TemplateArgs) -> TokenStream {
         let arg = &fn_args[0];
         quote! {
             #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
-                #manage_global_state
                 // 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)*
@@ -270,7 +262,6 @@ pub fn template_impl(input: TemplateFn, args: TemplateArgs) -> TokenStream {
         // There are no arguments
         quote! {
             #vis fn #name<G: ::sycamore::prelude::Html>(props: ::perseus::templates::PageProps) -> ::sycamore::prelude::View<G> {
-                #manage_global_state
                 // 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/html_shell.rs

@@ -110,11 +110,12 @@ impl<'a> HtmlShell<'a> {
             "None".to_string()
         };
 
-        // We put these at the very end of the head (after the delimiter comment) because it doesn't matter if they're expunged on subsequent loads
+        // We put this at the very end of the head (after the delimiter comment) because it doesn't matter if it's expunged on subsequent loads
         let initial_state = format!("window.__PERSEUS_INITIAL_STATE = `{}`;", initial_state);
         self.scripts_after_boundary.push(initial_state.into());
+        // But we'll need the global state as a variable until a template accesses it, so we'll keep it around (even though it should actually instantiate validly and not need this after the initial load)
         let global_state = format!("window.__PERSEUS_GLOBAL_STATE = `{}`;", global_state);
-        self.scripts_after_boundary.push(global_state.into());
+        self.scripts_before_boundary.push(global_state.into());
         // Interpolate the document `<head>` (this should of course be removed between page loads)
         self.head_after_boundary.push((&page_data.head).into());
         // And set the content

packages/perseus/src/shell.rs

@@ -295,19 +295,20 @@ pub async fn app_shell(
             checkpoint("initial_state_present");
             // Unset the initial state variable so we perform subsequent renders correctly
             // This monstrosity is needed until `web-sys` adds a `.set()` method on `Window`
+            // We don't do this for the global state because it should hang around uninitialized until a template wants it (if we remove it before then, we're stuffed)
             Reflect::set(
                 &JsValue::from(web_sys::window().unwrap()),
                 &JsValue::from("__PERSEUS_INITIAL_STATE"),
                 &JsValue::undefined(),
             )
             .unwrap();
-            // Also do this for the global state
-            Reflect::set(
-                &JsValue::from(web_sys::window().unwrap()),
-                &JsValue::from("__PERSEUS_GLOBAL_STATE"),
-                &JsValue::undefined(),
-            )
-            .unwrap();
+            // // Also do this for the global state
+            // Reflect::set(
+            //     &JsValue::from(web_sys::window().unwrap()),
+            //     &JsValue::from("__PERSEUS_GLOBAL_STATE"),
+            //     &JsValue::undefined(),
+            // )
+            // .unwrap();
             // We need to move the server-rendered content from its current container to the reactive container (otherwise Sycamore can't work with it properly)
             let initial_html = initial_container.inner_html();
             container_rx_elem.set_inner_html(&initial_html);