fix: 🚑 changed browser-checking logic to not use context

Using context breaks i18n completely.

Author: arctic-hen7

packages/perseus/src/build.rs

@@ -67,11 +67,7 @@ pub async fn build_template(
                 .await?;
             // Prerender the template using that state
             let prerendered = sycamore::render_to_string(|| {
-                template.render_for_template(
-                    Some(initial_state.clone()),
-                    Rc::clone(&translator),
-                    true,
-                )
+                template.render_for_template(Some(initial_state.clone()), Rc::clone(&translator))
             });
             // Write that prerendered HTML to a static file
             config_manager
@@ -108,7 +104,7 @@ pub async fn build_template(
         // It's safe to add a property to the render options here because `.is_basic()` will only return true if path generation is not being used (or anything else)
         if template.is_basic() {
             let prerendered = sycamore::render_to_string(|| {
-                template.render_for_template(None, Rc::clone(&translator), true)
+                template.render_for_template(None, Rc::clone(&translator))
             });
             let head_str = template.render_head_str(None, Rc::clone(&translator));
             // Write that prerendered HTML to a static file

packages/perseus/src/serve.rs

@@ -69,7 +69,7 @@ async fn render_request_state(
     let state = Some(template.get_request_state(path.to_string(), req).await?);
     // Use that to render the static HTML
     let html = sycamore::render_to_string(|| {
-        template.render_for_template(state.clone(), Rc::clone(&translator), true)
+        template.render_for_template(state.clone(), Rc::clone(&translator))
     });
     let head = template.render_head_str(state.clone(), Rc::clone(&translator));
 
@@ -142,7 +142,7 @@ async fn revalidate(
             .await?,
     );
     let html = sycamore::render_to_string(|| {
-        template.render_for_template(state.clone(), Rc::clone(&translator), true)
+        template.render_for_template(state.clone(), Rc::clone(&translator))
     });
     let head = template.render_head_str(state.clone(), Rc::clone(&translator));
     // Handle revalidation, we need to parse any given time strings into datetimes
@@ -254,7 +254,7 @@ pub async fn get_page_for_template(
                     // We need to generate and cache this page for future usage
                     let state = Some(template.get_build_state(path.to_string()).await?);
                     let html_val = sycamore::render_to_string(|| {
-                        template.render_for_template(state.clone(), Rc::clone(&translator), true)
+                        template.render_for_template(state.clone(), Rc::clone(&translator))
                     });
                     let head_val = template.render_head_str(state.clone(), Rc::clone(&translator));
                     // Handle revalidation, we need to parse any given time strings into datetimes

packages/perseus/src/shell.rs

@@ -259,7 +259,7 @@ pub async fn app_shell(
             // BUG (Sycamore): this will double-render if the component is just text (no nodes)
             sycamore::hydrate_to(
                 // This function provides translator context as needed
-                || template.render_for_template(state, Rc::clone(&translator), false),
+                || template.render_for_template(state, Rc::clone(&translator)),
                 &container_rx_elem,
             );
             checkpoint("page_interactive");
@@ -341,7 +341,6 @@ pub async fn app_shell(
                                         template.render_for_template(
                                             page_data.state,
                                             Rc::clone(&translator),
-                                            false,
                                         )
                                     },
                                     &container_rx_elem,

packages/perseus/src/template.rs

@@ -12,14 +12,8 @@ use std::pin::Pin;
 use std::rc::Rc;
 use sycamore::context::{ContextProvider, ContextProviderProps};
 use sycamore::prelude::{template, GenericNode, Template as SycamoreTemplate};
-
-/// Used to encapsulate whether or not a template is running on the client or server. We use a `struct` so as not to interfere with
-/// any user-set context.
-#[derive(Clone, Debug)]
-pub struct RenderCtx {
-    /// Whether or not we're being executed on the server-side.
-    pub is_server: bool,
-}
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::{JsCast, JsValue};
 
 /// Represents all the different states that can be generated for a single template, allowing amalgamation logic to be run with the knowledge
 /// of what did what (rather than blindly working on a vector).
@@ -217,22 +211,12 @@ impl<G: GenericNode> Template<G> {
         &self,
         props: Option<String>,
         translator: Rc<Translator>,
-        is_server: bool,
     ) -> SycamoreTemplate<G> {
         template! {
             // We provide the translator through context, which avoids having to define a separate variable for every translation due to Sycamore's `template!` macro taking ownership with `move` closures
             ContextProvider(ContextProviderProps {
                 value: Rc::clone(&translator),
-                children: || template! {
-                    // We then provide whether this is being rendered on the client or the server as a context element
-                    // This allows easy specification of client-side-only logic without having to worry about `web_sys` panicking
-                    ContextProvider(ContextProviderProps {
-                        value: RenderCtx {
-                            is_server
-                        },
-                        children: || (self.template)(props)
-                    })
-                }
+                children: || (self.template)(props)
             })
         }
     }
@@ -491,13 +475,19 @@ macro_rules! get_templates_map {
     };
 }
 
-/// Checks in a template if the code is being run on client-side or the server-side. This uses Sycamore context, and so will only work
-/// in a reactive scope.
-#[macro_export]
-macro_rules! is_client {
-    () => {
-        !::sycamore::context::use_context::<::perseus::template::RenderCtx>().is_server;
-    };
+/// Checks in a template if the code is being run on client-side or the server-side. This will work anywhere in your code, and will
+/// return `true` for any browser environment (including web workers).
+pub fn is_client() -> bool {
+    #[wasm_bindgen]
+    extern "C" {
+        type Global;
+
+        #[wasm_bindgen(method, getter, js_name = Window)]
+        fn window(this: &Global) -> JsValue;
+    }
+
+    let global: Global = js_sys::global().unchecked_into();
+    !global.window().is_undefined()
 }
 
 /// A type alias for a `HashMap` of `Template`s.