fix: updated website examples

Author: arctic-hen7

Cargo.toml

@@ -4,7 +4,7 @@ members = [
     "examples/core/*",
     "examples/demos/*",
     "examples/comprehensive/*",
-    # "examples/website/*",
+    "examples/website/*",
     "website",
 ]
 resolver = "2"

examples/website/app_in_a_file/README.md

@@ -10,44 +10,42 @@ pub fn main<G: Html>() -> PerseusApp<G> {
         // Create a new template at `index`, which maps to our landing page
         .template(
             Template::build("index")
-                .template_with_state(index_page)
-                .build_state_fn(get_index_build_state),
+                .view_with_state(index_page)
+                .build_state_fn(get_build_state)
+                .build(),
         )
-        .template(Template::new("about").template(about_page))
+        .template(Template::build("about").view(about_page).build())
 }
 
+#[auto_scope]
 // EXCERPT_START
-#[perseus::template]
-fn index_page<'a, G: Html>(cx: Scope<'a>, props: IndexPropsRx<'a>) -> View<G> {
+fn index_page<G: Html>(cx: Scope, state: &IndexStateRx) -> View<G> {
     view! { cx,
         h1 { (format!(
             "Hello, {}!",
-            props.name.get()
+            state.name.get()
         )) }
         input(
             placeholder = "Name",
-            bind:value = props.name
+            bind:value = state.name
         )
         a(href = "about") { "About" }
     }
 }
 
-#[derive(Serialize, Deserialize, ReactiveState)]
-#[rx(alias = "IndexPropsRx")]
-struct IndexProps {
+#[derive(Serialize, Deserialize, Clone, ReactiveState)]
+#[rx(alias = "IndexStateRx")]
+struct IndexState {
     name: String,
 }
 
 // This function will be run when you build your app, to generate default state
 // ahead-of-time
 #[engine_only_fn]
-async fn get_index_build_state(
-    _info: StateGeneratorInfo<()>,
-) -> RenderFnResultWithCause<IndexProps> {
-    let props = IndexProps {
+async fn get_build_state(_info: StateGeneratorInfo<()>) -> IndexState {
+    IndexState {
         name: "User".to_string(),
-    };
-    Ok(props)
+    }
 }
 // EXCERPT_END
 

examples/website/app_in_a_file/src/main.rs

@@ -1,10 +1,10 @@
-use perseus::{t, Html, PerseusApp, Template};
+use perseus::prelude::*;
 use sycamore::prelude::*;
 
 #[perseus::main(perseus_warp::dflt_server)]
 pub fn main<G: Html>() -> PerseusApp<G> {
     PerseusApp::new()
-        .template(Template::new("index").template(index_page))
+        .template(Template::build("index").view(index_page).build())
         // EXCERPT_START
         .locales_and_translations_manager(
             "en-US",             // Default locale

examples/website/i18n/README.md

@@ -10,6 +10,7 @@ perseus = { path = "../../../packages/perseus" }
 sycamore = "^0.8.1"
 serde = { version = "1", features = [ "derive" ] }
 serde_json = "1"
+thiserror = "1"
 
 [target.'cfg(engine)'.dependencies]
 tokio = { version = "1", features = [ "macros", "rt", "rt-multi-thread" ] }

examples/website/i18n/src/main.rs

@@ -1,38 +1,40 @@
 use perseus::prelude::*;
 use serde::{Deserialize, Serialize};
+use std::io;
 use std::time::Duration;
 use sycamore::prelude::*;
 
 #[perseus::main(perseus_warp::dflt_server)]
 pub fn main<G: Html>() -> PerseusApp<G> {
     PerseusApp::new().template(
         Template::build("post")
-            .template_with_state(post_page)
+            .view_with_state(post_page)
             .build_paths_fn(get_build_paths)
             .build_state_fn(get_build_state)
             // Reload every blog post every day, in case it's changed
             .revalidate_after(Duration::new(60 * 60 * 24, 0))
             // If the user requests a page we haven't created yet, still
             // pass it to `get_build_state()` and cache the output for
             // future users (lazy page building)
-            .incremental_generation(),
+            .incremental_generation()
+            .build(),
     )
 }
 
+#[auto_scope]
 // EXCERPT_START
-#[perseus::template]
-fn post_page<'a, G: Html>(cx: Scope<'a>, props: PostRx<'a>) -> View<G> {
+fn post_page<G: Html>(cx: Scope, state: &PostRx) -> View<G> {
     view! { cx,
-        h1 { (props.title.get()) }
-        p { (props.author.get()) }
+        h1 { (state.title.get()) }
+        p { (state.author.get()) }
         div(
-            dangerously_set_inner_html = &props.content.get()
+            dangerously_set_inner_html = &state.content.get()
         )
     }
 }
 // EXCERPT_END
 
-#[derive(Serialize, Deserialize, ReactiveState)]
+#[derive(Serialize, Deserialize, Clone, ReactiveState)]
 #[rx(alias = "PostRx")]
 struct Post {
     title: String,
@@ -45,24 +47,29 @@ struct Post {
 #[engine_only_fn]
 async fn get_build_state(
     StateGeneratorInfo { path, .. }: StateGeneratorInfo<()>,
-) -> RenderFnResultWithCause<Post> {
+) -> Result<Post, BlamedError<MyError>> {
     let raw_post = match get_post_for_path(path) {
         Ok(post) => post,
         // If the user sends us some bogus path with incremental generation,
         // return a 404 appropriately
-        Err(err) => blame_err!(client, 404, err),
+        Err(err) => {
+            return Err(BlamedError {
+                blame: ErrorBlame::Client(Some(404)),
+                error: MyError,
+            })
+        }
     };
     let html_content = parse_markdown(raw_post.content);
-    let props = Post {
+    let post = Post {
         title: raw_post.title,
         author: raw_post.author,
         content: html_content,
     };
-    Ok(props)
+    Ok(post)
 }
 #[engine_only_fn]
-async fn get_build_paths() -> RenderFnResult<BuildPaths> {
-    Ok(BuildPaths {
+async fn get_build_paths() -> BuildPaths {
+    BuildPaths {
         // These will all become URLs at `/post/<name>`
         paths: vec![
             "welcome".to_string(),
@@ -71,12 +78,15 @@ async fn get_build_paths() -> RenderFnResult<BuildPaths> {
         ],
         // Perseus supports helper state, but we don't need it here
         extra: ().into(),
-    })
+    }
 }
 // EXCERPT_END
 
 // SNIP
-fn get_post_for_path(_path: String) -> Result<Post, std::io::Error> {
+#[derive(thiserror::Error, Debug)]
+#[error("an error!")]
+struct MyError;
+fn get_post_for_path(_path: String) -> Result<Post, io::Error> {
     unimplemented!()
 }
 fn parse_markdown(_content: String) -> String {