what I'm talking about

.github/workflows/run-cargo-make-task.yml

@@ -84,11 +84,6 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
-      - name: Install Chrome Webriver
-        run: |
-          sudo apt-get update
-          sudo apt-get install chromium-chromedriver
-
       # Run Cargo Make Task
       - name: ${{ inputs.cargo_make_task }}
         run: |

CONTRIBUTING.md

@@ -70,25 +70,6 @@ are a few guidelines that will make it a better experience for everyone:
   `cargo-make` and using `cargo make check && cargo make test && cargo make
 check-examples`.
 
-## Before Submitting a PR
-
-We have a fairly extensive CI setup that runs both lints (like `rustfmt` and `clippy`) 
-and tests on PRs. You can run most of these locally if you have `cargo-make` installed.
-
-If you added an example, make sure to add it to the list in `examples/Makefile.toml`.
-
-From the root directory of the repo, run 
-- `cargo +nightly fmt`
-- `cargo +nightly make check`
-- `cargo +nightly make test`
-- `cargo +nightly make check-examples`
-- `cargo +nightly make --profile=github-actions ci`
-
-If you modified an example:
-- `cd examples/your_example`
-- `cargo +nightly fmt -- --config-path ../..`
-- `cargo +nightly make --profile=github-actions verify-flow`
-
 ## Architecture
 
 See [ARCHITECTURE.md](./ARCHITECTURE.md).

Cargo.toml

@@ -26,22 +26,22 @@ members = [
 exclude = ["benchmarks", "examples"]
 
 [workspace.package]
-version = "0.4.8"
+version = "0.4.5"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", version = "0.4.8" }
-leptos_dom = { path = "./leptos_dom", version = "0.4.8" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.4.8" }
-leptos_macro = { path = "./leptos_macro", version = "0.4.8" }
-leptos_reactive = { path = "./leptos_reactive", version = "0.4.8" }
-leptos_server = { path = "./leptos_server", version = "0.4.8" }
-server_fn = { path = "./server_fn", version = "0.4.8" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.4.8" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.4.8" }
-leptos_config = { path = "./leptos_config", version = "0.4.8" }
-leptos_router = { path = "./router", version = "0.4.8" }
-leptos_meta = { path = "./meta", version = "0.4.8" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.4.8" }
+leptos = { path = "./leptos", version = "0.4.5" }
+leptos_dom = { path = "./leptos_dom", version = "0.4.5" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.4.5" }
+leptos_macro = { path = "./leptos_macro", version = "0.4.5" }
+leptos_reactive = { path = "./leptos_reactive", version = "0.4.5" }
+leptos_server = { path = "./leptos_server", version = "0.4.5" }
+server_fn = { path = "./server_fn", version = "0.4.5" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.4.5" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.4.5" }
+leptos_config = { path = "./leptos_config", version = "0.4.5" }
+leptos_router = { path = "./router", version = "0.4.5" }
+leptos_meta = { path = "./meta", version = "0.4.5" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.4.5" }
 
 [profile.release]
 codegen-units = 1

Makefile.toml

@@ -20,18 +20,6 @@ cwd = "examples"
 command = "cargo"
 args = ["make", "ci-clean"]
 
-[tasks.check-examples]
-workspace = false
-cwd = "examples"
-command = "cargo"
-args = ["make", "check-clean"]
-
-[tasks.build-examples]
-workspace = false
-cwd = "examples"
-command = "cargo"
-args = ["make", "build-clean"]
-
 [tasks.clean-examples]
 workspace = false
 cwd = "examples"

README.md

@@ -88,6 +88,8 @@ targets = ["wasm32-unknown-unknown"]
 
 The `nightly` feature enables the function call syntax for accessing and setting signals, as opposed to `.get()` and `.set()`. This leads to a consistent mental model in which accessing a reactive value of any kind (a signal, memo, or derived signal) is always represented as a function call. This is only possible with nightly Rust and the `nightly` feature.
 
+> Note: The `nightly` feature is present on the main branch version right now, but not in 0.3.x. For 0.3.x, nightly is the default and `stable` has a special feature.
+
 ## `cargo-leptos`
 
 [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
@@ -105,7 +107,7 @@ Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ### What’s up with the name?
 
-_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refined, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
+_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
 
 ### Is it production ready?
 

cargo-make/lint.toml

@@ -1,11 +1,9 @@
-[tasks.lint]
-dependencies = ["check-format-flow", "clippy-each-feature"]
+[tasks.pre-clippy]
+env = { CARGO_MAKE_CLIPPY_ARGS = "--all-targets --all-features -- -D warnings" }
+
+[tasks.check-style]
+dependencies = ["check-format-flow", "clippy-flow"]
 
 [tasks.check-format]
 env = { LEPTOS_PROJECT_DIRECTORY = "../" }
 args = ["fmt", "--", "--check", "--config-path", "${LEPTOS_PROJECT_DIRECTORY}"]
-
-[tasks.clippy-each-feature]
-dependencies = ["install-clippy"]
-command = "cargo"
-args = ["hack", "clippy", "--all", "--each-feature", "--no-dev-deps"]

cargo-make/main.toml

@@ -13,3 +13,6 @@ RUSTFLAGS = "-D warnings"
 
 [tasks.ci]
 dependencies = ["lint", "test"]
+
+[tasks.lint]
+dependencies = ["check-format-flow"]

docs/book/src/02_getting_started.md

@@ -26,7 +26,7 @@ cargo init leptos-tutorial
 cargo add leptos --features=csr,nightly
 ```
 
-Or you can leave off `nightly` if you're using stable Rust
+Or you can leave off `nighly` if you're using stable Rust
 ```bash
 cargo add leptos --features=csr
 ```

docs/book/src/15_global_state.md

@@ -136,7 +136,7 @@ view! { cx,
 
 In this example, clicking the button will cause the text inside `<p>` to be updated, cloning `state.name` again! Because signals are the atomic unit of reactivity, updating any field of the signal triggers updates to everything that depends on the signal.
 
-There’s a better way. You can take fine-grained, reactive slices by using [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html) or [`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html) (which uses `create_memo` but also provides a setter). “Memoizing” a value means creating a new reactive value which will only update when it changes. “Memoizing a slice” means creating a new reactive value which will only update when some field of the state struct updates.
+There’s a better way. You can use take fine-grained, reactive slices by using [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html) or [`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html) (which uses `create_memo` but also provides a setter). “Memoizing” a value means creating a new reactive value which will only update when it changes. “Memoizing a slice” means creating a new reactive value which will only update when some field of the state struct updates.
 
 Here, instead of reading from the state signal directly, we create “slices” of that state with fine-grained updates via `create_slice`. Each slice signal only updates when the particular piece of the larger struct it accesses updates. This means you can create a single root signal, and then take independent, fine-grained slices of it in different components, each of which can update without notifying the others of changes.
 

docs/book/src/SUMMARY.md

@@ -43,5 +43,5 @@
   - [Responses and Redirects](./server/27_response.md)
 - [Progressive Enhancement and Graceful Degradation](./progressive_enhancement/README.md)
   - [`<ActionForm/>`s](./progressive_enhancement/action_form.md)
-- [Deployment](./deployment.md)
+- [Deployment]()
 - [Appendix: Optimizing WASM Binary Size](./appendix_binary_size.md)

docs/book/src/async/11_suspense.md

@@ -69,34 +69,6 @@ Every time one of the resources is reloading, the `"Loading..."` fallback will s
 
 This inversion of the flow of control makes it easier to add or remove individual resources, as you don’t need to handle the matching yourself. It also unlocks some massive performance improvements during server-side rendering, which we’ll talk about during a later chapter.
 
-## `<Await/>`
-
-In you’re simply trying to wait for some `Future` to resolve before rendering, you may find the `<Await/>` component helpful in reducing boilerplate. `<Await/>` essentially combines a resource with the source argument `|| ()` with a `<Suspense/>` with no fallback.
-
-In other words:
-
-1. It only polls the `Future` once, and does not respond to any reactive changes.
-2. It does not render anything until the `Future` resolves.
-3. After the `Future` resolves, its binds its data to whatever variable name you choose and then renders its children with that variable in scope.
-
-```rust
-async fn fetch_monkeys(monkey: i32) -> i32 {
-    // maybe this didn't need to be async
-    monkey * 2
-}
-view! { cx,
-    <Await
-        // `future` provides the `Future` to be resolved
-        future=|cx| fetch_monkeys(3)
-        // the data is bound to whatever variable name you provide
-        bind:data
-    >
-        // you receive the data by reference and can use it in your view here
-        <p>{*data} " little monkeys, jumping on the bed."</p>
-    </Await>
-}
-```
-
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs)
 
 <iframe src="https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/deployment.md

@@ -1,74 +0,0 @@
-# Deployment
-
-There are as many ways to deploy a web application as there are developers, let alone applications. But there are a couple useful tips to keep in mind when deploying an app.
-
-## General Advice
-
-1. Remember: Always deploy Rust apps built in `--release` mode, not debug mode. This has a huge effect on both performance and binary size.
-2. Test locally in release mode as well. The framework applies certain optimizations in release mode that it does not apply in debug mode, so it’s possible for bugs to surface at this point. (If your app behaves differently or you do encounter a bug, it’s likely a framework-level bug and you should open a GitHub issue with a reproduction.)
-
-> We asked users to submit their deployment setups to help with this chapter. I’ll quote from them below, but you can read the full thread [here](https://github.com/leptos-rs/leptos/issues/1152).
-
-## Deploying a Client-Side-Rendered App
-
-If you’ve been building an app that only uses client-side rendering, working with Trunk as a dev server and build tool, the process is quite easy.
-
-```bash
-trunk build --release
-```
-
-`trunk build` will create a number of build artifacts in a `dist/` directory. Publishing `dist` somewhere online should be all you need to deploy your app. This should work very similarly to deploying any JavaScript application.
-
-> Read more: [Deploying to Vercel with GitHub Actions](https://github.com/leptos-rs/leptos/issues/1152#issuecomment-1577861900).
-
-## Deploying a Full-Stack App
-
-The most popular way for people to deploy full-stack apps built with `cargo-leptos` is to use a cloud hosting service that supports deployment via a Docker build. Here’s a sample `Dockerfile`, which is based on the one we use to deploy the Leptos website.
-
-```dockerfile
-# Get started with a build env with Rust nightly
-FROM rustlang/rust:nightly-bullseye as builder
-
-# If you’re using stable, use this instead
-# FROM rust:1.70-bullseye as builder
-
-# Install cargo-binstall, which makes it easier to install other
-# cargo extensions like cargo-leptos
-RUN wget https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz
-RUN tar -xvf cargo-binstall-x86_64-unknown-linux-musl.tgz
-RUN cp cargo-binstall /usr/local/cargo/bin
-
-# Install cargo-leptos
-RUN cargo binstall cargo-leptos -y
-
-# Add the WASM target
-RUN rustup target add wasm32-unknown-unknown
-
-# Make an /app dir, which everything will eventually live in
-RUN mkdir -p /app
-WORKDIR /app
-COPY . .
-
-# Build the app
-RUN cargo leptos build --release -vv
-
-FROM rustlang/rust:nightly-bullseye as runner
-# Copy the server binary to the /app directory
-COPY --from=builder /app/target/server/release/leptos_website /app/
-# /target/site contains our JS/WASM/CSS, etc.
-COPY --from=builder /app/target/site /app/site
-# Copy Cargo.toml if it’s needed at runtime
-COPY --from=builder /app/Cargo.toml /app/
-WORKDIR /app
-
-# Set any required env variables and
-ENV RUST_LOG="info"
-ENV APP_ENVIRONMENT="production"
-ENV LEPTOS_SITE_ADDR="0.0.0.0:8080"
-ENV LEPTOS_SITE_ROOT="site"
-EXPOSE 8080
-# Run the server
-CMD ["/app/leptos_website"]
-```
-
-> Read more: [`gnu` and `musl` build files for Leptos apps](https://github.com/leptos-rs/leptos/issues/1152#issuecomment-1634916088).

docs/book/src/reactivity/14_create_effect.md

@@ -109,34 +109,6 @@ create_effect(cx, move |prev_value| {
 
 Every time `count` is updated, this effect wil rerun. This is what allows reactive, fine-grained updates to the DOM.
 
-## Explicit, Cancelable Tracking with `watch`
-
-In addition to `create_effect`, Leptos provides a [`watch`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.watch.html) function, which can be used for two main purposes:
-
-1. Separating tracking and responding to changes by explicitly passing in a set of values to track.
-2. Canceling tracking by calling a stop function.
-
-Like `create_resource`, `watch` takes a first argument, which is reactively tracked, and a second, which is not. Whenever a reactive value in its `deps` argument is changed, the `callback` is run. `watch` returns a function that can be called to stop tracking the dependencies.
-
-```rust
-let (num, set_num) = create_signal(cx, 0);
-
-let stop = watch(
-    cx,
-    move || num.get(),
-    move |num, prev_num, _| {
-        log::debug!("Number: {}; Prev: {:?}", num, prev_num);
-    },
-    false,
-);
-
-set_num.set(1); // > "Number: 1; Prev: Some(0)"
-
-stop(); // stop watching
-
-set_num.set(2); // (nothing happens)
-```
-
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
 
 <iframe src="https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/16_routes.md

@@ -24,7 +24,7 @@ use leptos_router::*;
 
 Routing behavior is provided by the [`<Router/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Router.html) component. This should usually be somewhere near the root of your application, the rest of the app.
 
-> You shouldn’t try to use multiple `<Router/>`s in your app. Remember that the router drives global state: if you have multiple routers, which one decides what to do when the URL changes?
+> You shouldn’t try to use multiple `<Router/>`s in your app. Remember that the router drives global state: if you have multiple routers, which ones decides what to do when the URL changes?
 
 Let’s start with a simple `<App/>` component using the router:
 
@@ -87,17 +87,15 @@ The `view` is a function that takes a `Scope` and returns a view.
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
-  <Route path="/*any" view=NotFound/>
+  <Route path="/" view=|cx| view! { cx, <Home/> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users/> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile/> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound/> }/>
 </Routes>
 ```
 
-> `view` takes a `Fn(Scope) -> impl IntoView`. If a component has no props, it is a function that takes `Scope` and returns `impl IntoView`, so it can be passed directly into the `view`. In this case, `view=Home` is just a shorthand for `|cx| view! { cx, <Home/> }`.
+> The router scores each route to see how good a match it is, so you can define your routes in any order.
 
 Now if you navigate to `/` or to `/users` you’ll get the home page or the `<Users/>`. If you go to `/users/3` or `/blahblah` you’ll get a user profile or your 404 page (`<NotFound/>`). On every navigation, the router determines which `<Route/>` should be matched, and therefore what content should be displayed where the `<Routes/>` component is defined.
 
-Note that you can define your routes in any order. The router scores each route to see how good a match it is, rather than simply trying to match them top to bottom.
-
 Simple enough?

docs/book/src/router/17_nested_routing.md

@@ -4,10 +4,10 @@ We just defined the following set of routes:
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
-  <Route path="/*any" view=NotFound/>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
 </Routes>
 ```
 
@@ -17,11 +17,11 @@ Well... you can!
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
   </Route>
-  <Route path="/*any" view=NotFound/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
 </Routes>
 ```
 
@@ -39,8 +39,8 @@ Let’s look back at our practical example.
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
 </Routes>
 ```
 
@@ -53,8 +53,8 @@ Let’s say I use nested routes instead:
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
   </Route>
 </Routes>
 ```
@@ -68,9 +68,9 @@ I actually need to add a fallback route
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
-    <Route path="" view=NoUser/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+    <Route path="" view=|cx| view! { cx, <NoUser /> }/>
   </Route>
 </Routes>
 ```
@@ -94,8 +94,8 @@ You can easily define this with nested routes
 
 ```rust
 <Routes>
-  <Route path="/contacts" view=ContactList>
-    <Route path=":id" view=ContactInfo/>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }/>
     <Route path="" view=|cx| view! { cx,
       <p>"Select a contact to view more info."</p>
     }/>
@@ -107,11 +107,11 @@ You can go even deeper. Say you want to have tabs for each contact’s address,
 
 ```rust
 <Routes>
-  <Route path="/contacts" view=ContactList>
-    <Route path=":id" view=ContactInfo>
-      <Route path="" view=EmailAndPhone/>
-      <Route path="address" view=Address/>
-      <Route path="messages" view=Messages/>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }>
+      <Route path="" view=|cx| view! { cx, <EmailAndPhone/> }/>
+      <Route path="address" view=|cx| view! { cx, <Address/> }/>
+      <Route path="messages" view=|cx| view! { cx, <Messages/> }/>
     </Route>
     <Route path="" view=|cx| view! { cx,
       <p>"Select a contact to view more info."</p>
@@ -201,9 +201,12 @@ fn App(cx: Scope) -> impl IntoView {
                     // /contacts has nested routes
                     <Route
                         path="/contacts"
-                        view=ContactList
+                        view=|cx| view! { cx, <ContactList/> }
+                    >
                         // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
+                        <Route path=":id" view=|cx| view! { cx,
+                            <ContactInfo/>
+                        }>
                             <Route path="" view=|cx| view! { cx,
                                 <div class="tab">
                                     "(Contact Info)"

docs/book/src/router/18_params_and_queries.md

@@ -36,14 +36,6 @@ struct ContactSearch {
 ```
 
 > Note: The `Params` derive macro is located at `leptos::Params`, and the `Params` trait is at `leptos_router::Params`. If you avoid using glob imports like `use leptos::*;`, make sure you’re importing the right one for the derive macro.
->
-> If you are not using the `nightly` feature, you will get the error
->
-> ```
-> no function or associated item named `into_param` found for struct `std::string::String` in the current scope
-> ```
->
-> At the moment, supporting both `T: FromStr` and `Option<T>` for typed params requires a nightly feature. You can fix this by simply changing the struct to use `q: Option<String>` instead of `q: String`.
 
 Now we can use them in a component. Imagine a URL that has both params and a query, like `/contacts/:id?q=Search`.
 
@@ -116,10 +108,12 @@ fn App(cx: Scope) -> impl IntoView {
                     // /contacts has nested routes
                     <Route
                         path="/contacts"
-                        view=ContactList
+                        view=|cx| view! { cx, <ContactList/> }
                     >
                         // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
+                        <Route path=":id" view=|cx| view! { cx,
+                            <ContactInfo/>
+                        }>
                             <Route path="" view=|cx| view! { cx,
                                 <div class="tab">
                                     "(Contact Info)"

docs/book/src/router/19_a.md

@@ -11,27 +11,11 @@ The router will bail out of handling an `<a>` click under a number of situations
 
 In other words, the router will only try to do a client-side navigation when it’s pretty sure it can handle it, and it will upgrade every `<a>` element to get this special behavior.
 
-> This also means that if you need to opt out of client-side routing, you can do so easily. For example, if you have a link to another page on the same domain, but which isn’t part of your Leptos app, you can just use `<a rel="external">` to tell the router it isn’t something it can handle.
-
 The router also provides an [`<A>`](https://docs.rs/leptos_router/latest/leptos_router/fn.A.html) component, which does two additional things:
 
 1. Correctly resolves relative nested routes. Relative routing with ordinary `<a>` tags can be tricky. For example, if you have a route like `/post/:id`, `<A href="1">` will generate the correct relative route, but `<a href="1">` likely will not (depending on where it appears in your view.) `<A/>` resolves routes relative to the path of the nested route within which it appears.
 2. Sets the `aria-current` attribute to `page` if this link is the active link (i.e., it’s a link to the page you’re on). This is helpful for accessibility and for styling. For example, if you want to set the link a different color if it’s a link to the page you’re currently on, you can match this attribute with a CSS selector.
 
-## Navigating Programmatically
-
-Your most-used methods of navigating between pages should be with `<a>` and `<form>` elements or with the enhanced `<A/>` and `<Form/>` components. Using links and forms to navigate is the best solution for accessibility and graceful degradation.
-
-On occasion, though, you’ll want to navigate programmatically, i.e., call a function that can navigate to a new page. In that case, you should use the [`use_navigate`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_navigate.html) function.
-```rust
-let navigate = leptos_router::use_navigate(cx);
-navigate("/somewhere", Default::default());
-```
-
-> You should almost never do something like `<button on:click=move |_| navigate(/* ... */)>`. Any `on:click` that navigates should be an `<a>`, for reasons of accessibility.
-
-The second argument here is a set of [`NavigateOptions`](https://docs.rs/leptos_router/latest/leptos_router/struct.NavigateOptions.html), which includes options to resolve the navigation relative to the current route as the `<A/>` component does, replace it in the navigation stack, include some navigation state, and maintain the current scroll state on navigation.
-
 > Once again, this is the same example. Check out the relative `<A/>` components, and take a look at the CSS in `index.html` to see the ARIA-based styling.
 
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
@@ -68,10 +52,12 @@ fn App(cx: Scope) -> impl IntoView {
                     // /contacts has nested routes
                     <Route
                         path="/contacts"
-                        view=ContactList
+                        view=|cx| view! { cx, <ContactList/> }
                     >
                         // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
+                        <Route path=":id" view=|cx| view! { cx,
+                            <ContactInfo/>
+                        }>
                             <Route path="" view=|cx| view! { cx,
                                 <div class="tab">
                                     "(Contact Info)"

docs/book/src/router/20_form.md

@@ -80,7 +80,7 @@ fn App(cx: Scope) -> impl IntoView {
             <h1><code>"<Form/>"</code></h1>
             <main>
                 <Routes>
-                    <Route path="" view=FormExample/>
+                    <Route path="" view=|cx| view! { cx, <FormExample/> }/>
                 </Routes>
             </main>
         </Router>

docs/book/src/server/25_server_functions.md

@@ -113,7 +113,7 @@ Server functions are a cool technology, but it’s very important to remember. *
 
 So far, everything I’ve said is actually framework agnostic. (And in fact, the Leptos server function crate has been integrated into Dioxus as well!) Server functions are simply a way of defining a function-like RPC call that leans on Web standards like HTTP requests and URL encoding.
 
-But in a way, they also provide the last missing primitive in our story so far. Because a server function is just a plain Rust async function, it integrates perfectly with the async Leptos primitives we discussed [earlier](https://leptos-rs.github.io/leptos/async/index.html). So you can easily integrate your server functions with the rest of your applications:
+But in a way, they also provide the last missing primitive in our story so far. Because a server function is just a plain Rust async function, it integrates perfectly with the async Leptos primitives we discussed [earlier](../async/README.md). So you can easily integrate your server functions with the rest of your applications:
 
 - Create **resources** that call the server function to load data from the server
 - Read these resources under `<Suspense/>` or `<Transition/>` to enable streaming SSR and fallback states while data loads.

docs/book/src/server/26_extractors.md

@@ -6,9 +6,9 @@ The server functions we looked at in the last chapter showed how to run code on
 
 We call Leptos a “full-stack” framework, but “full-stack” is always a misnomer (after all, it never means everything from the browser to your power company.) For us, “full stack” means that your Leptos app can run in the browser, and can run on the server, and can integrate the two, drawing together the unique features available in each; as we’ve seen in the book so far, a button click on the browser can drive a database read on the server, both written in the same Rust module. But Leptos itself doesn’t provide the server (or the database, or the operating system, or the firmware, or the electrical cables...)
 
-Instead, Leptos provides integrations for the two most popular Rust web server frameworks, Actix Web ([`leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/)) and Axum ([`leptos_axum`](https://docs.rs/leptos_axum/latest/leptos_axum/)). We’ve built integrations with each server’s router so that you can simply plug your Leptos app into an existing server with `.leptos_routes()`, and easily handle server function calls.
+Instead, Leptos provides integrations for the two most popular Rust web server frameworks, Actix Web ([`leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/)) and Axum ([`leptos_axum`](https://docs.rs/leptos_actix/latest/leptos_axum/)). We’ve built integrations with each server’s router so that you can simply plug your Leptos app into an existing server with `.leptos_routes()`, and easily handle server function calls.
 
-> If you haven’t seen our [Actix](https://github.com/leptos-rs/start) and [Axum](https://github.com/leptos-rs/start-axum) templates, now’s a good time to check them out.
+> If haven’t seen our [Actix](https://github.com/leptos-rs/start) and [Axum](https://github.com/leptos-rs/start-axum) templates, now’s a good time to check them out.
 
 ## Using Extractors
 
@@ -43,7 +43,7 @@ pub async fn actix_extract(cx: Scope) -> Result<String, ServerFnError> {
 
 ## Axum Extractors
 
-The syntax for the [`leptos_axum::extract`](https://docs.rs/leptos_axum/latest/leptos_axum/fn.extract.html) function is very similar. (**Note**: This is available on the git main branch, but has not been released as of writing.) Note that Axum extractors return a `Result`, so you’ll need to add something to handle the error case.
+The syntax for the `leptos_axum::extract` function is very similar. (**Note**: This is available on the git main branch, but has not been released as of writing.) Note that Axum extractors return a `Result`, so you’ll need to add something to handle the error case.
 
 ```rust
 #[server(AxumExtract, "/api")]
@@ -62,21 +62,7 @@ pub async fn axum_extract(cx: Scope) -> Result<String, ServerFnError> {
 
 These are relatively simple examples accessing basic data from the server. But you can use extractors to access things like headers, cookies, database connection pools, and more, using the exact same `extract()` pattern.
 
-The Axum `extract` function only supports extractors for which the state is `()`. If you need an extractor that uses `State`, you should use [`extract_with_state`](https://docs.rs/leptos_axum/latest/leptos_axum/fn.extract_with_state.html). This requires you to provide the state. You can do this by extending the existing `LeptosOptions` state using the Axum `FromRef` pattern, which providing the state as context during render and server functions with custom handlers.
-
-```rust
-use axum::extract::FromRef;
-
-/// Derive FromRef to allow multiple items in state, using Axum’s
-/// SubStates pattern.
-#[derive(FromRef, Debug, Clone)]
-pub struct AppState{
-    pub leptos_options: LeptosOptions,
-    pub pool: SqlitePool
-}
-```
-
-[Click here for an example of providing context in custom handlers](https://github.com/leptos-rs/leptos/blob/19ea6fae6aec2a493d79cc86612622d219e6eebb/examples/session_auth_axum/src/main.rs#L24-L44).
+> Note: For now, the Axum `extract` function only supports extractors for which the state is `()`, i.e., you can't yet use it to extract `State(_)`. You can access `State(_)` by using a custom handler that extracts the state and then provides it via context. [Click here for an example](https://github.com/leptos-rs/leptos/blob/a5f73b441c079f9138102b3a7d8d4828f045448c/examples/session_auth_axum/src/main.rs#L91-L92).
 
 ## A Note about Data-Loading Patterns
 

docs/book/src/ssr/23_ssr_modes.md

@@ -8,12 +8,7 @@ If you’ve ever listened to streaming music or watched a video online, I’m su
 
 Let me say a little more about what I mean.
 
-Leptos supports all four different modes of rendering HTML that includes asynchronous data:
-
-1. [Synchronous Rendering](#synchronous-rendering)
-1. [Async Rendering](#async-rendering)
-1. [In-Order streaming](#in-order-streaming)
-1. [Out-of-Order Streaming](#out-of-order-streaming)
+Leptos supports all four different of these different ways to render HTML that includes asynchronous data.
 
 ## Synchronous Rendering
 
@@ -69,7 +64,7 @@ If you’re using server-side rendering, the synchronous mode is almost never wh
 
 5. **Partially-blocked streaming**: “Partially-blocked” streaming is useful when you have multiple separate `<Suspense/>` components on the page. If one of them reads from one or more “blocking resources” (see below), the fallback will not be sent; rather, the server will wait until that `<Suspense/>` has resolved and then replace the fallback with the resolved fragment on the server, which means that it is included in the initial HTML response and appears even if JavaScript is disabled or not supported. Other `<Suspense/>` stream in out of order as usual.
 
-This is useful when you have multiple `<Suspense/>` on the page, and one is more important than the other: think of a blog post and comments, or product information and reviews. It is _not_ useful if there’s only one `<Suspense/>`, or if every `<Suspense/>` reads from blocking resources. In those cases it is a slower form of `async` rendering.
+This is useful when you have multiple `<Suspense/>` on the page, and one is more important than the other: think of a blog post and comments, or product information and reviews. It is *not* useful if there’s only one `<Suspense/>`, or if every `<Suspense/>` reads from blocking resources. In those cases it is a slower form of `async` rendering.
 
 - _Pros_: Works if JavaScript is disabled or not supported on the user’s device.
 - _Cons_
@@ -84,13 +79,13 @@ Because it offers the best blend of performance characteristics, Leptos defaults
 ```rust
 <Routes>
 	// We’ll load the home page with out-of-order streaming and <Suspense/>
-	<Route path="" view=HomePage/>
+	<Route path="" view=|cx| view! { cx, <HomePage/> }/>
 
 	// We'll load the posts with async rendering, so they can set
 	// the title and metadata *after* loading the data
 	<Route
 		path="/post/:id"
-		view=Post
+		view=|cx| view! { cx, <Post/> }
 		ssr=SsrMode::Async
 	/>
 </Routes>

docs/book/src/view/01_basic_component.md

@@ -139,7 +139,7 @@ view! { cx,
 Remember—and this is _very important_—only functions are reactive. This means that
 `{count}` and `{count()}` do very different things in your view. `{count}` passes
 in a function, telling the framework to update the view every time `count` changes.
-`{count()}` accesses the value of `count` once, and passes an `i32` into the view,
+`{count()}` access the value of `count` once, and passes an `i32` into the view,
 rendering it once, unreactively. You can see the difference in the CodeSandbox below!
 
 Let’s make one final change. `set_count(3)` is a pretty useless thing for a click handler to do. Let’s replace “set this value to 3” with “increment this value by 1”:

docs/book/src/view/03_components.md

@@ -219,25 +219,9 @@ where
 This is a perfectly reasonable way to write this component: `progress` now takes
 any value that implements this `Fn()` trait.
 
-This generic can also be specified inline:
-
-```rust
-#[component]
-fn ProgressBar<F: Fn() -> i32 + 'static>(
-    cx: Scope,
-    #[prop(default = 100)] max: u16,
-    progress: F,
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-```
-
-> Note that generic component props _can’t_ be specified with an `impl` yet (`progress: impl Fn() -> i32 + 'static,`), in part because they’re actually used to generate a `struct ProgressBarProps`, and struct fields cannot be `impl` types. The `#[component]` macro may be further improved in the future to allow inline `impl` generic props.
+> Note that generic component props _cannot_ be specified inline (as `<F: Fn() -> i32>`)
+> or as `progress: impl Fn() -> i32 + 'static,`, in part because they’re actually used to generate
+> a `struct ProgressBarProps`, and struct fields cannot be `impl` types.
 
 ### `into` Props
 
@@ -287,81 +271,6 @@ fn App(cx: Scope) -> impl IntoView {
 }
 ```
 
-### Optional Generic Props
-
-Note that you can’t specify optional generic props for a component. Let’s see what would happen if you try:
-
-```rust,compile_fail
-#[component]
-fn ProgressBar<F: Fn() -> i32 + 'static>(
-    cx: Scope,
-    #[prop(optional)] progress: Option<F>,
-) -> impl IntoView {
-    progress.map(|progress| {
-        view! { cx,
-            <progress
-                max=100
-                value=progress
-            />
-        }
-    })
-}
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <ProgressBar/>
-    }
-}
-```
-
-Rust helpfully gives the error
-
-```
-xx |         <ProgressBar/>
-   |          ^^^^^^^^^^^ cannot infer type of the type parameter `F` declared on the function `ProgressBar`
-   |
-help: consider specifying the generic argument
-   |
-xx |         <ProgressBar::<F>/>
-   |                     +++++
-```
-
-There are just two problems:
-
-1. Leptos’s view macro doesn’t support specifying a generic on a component with this turbofish syntax.
-2. Even if you could, specifying the correct type here is not possible; closures and functions in general are unnameable types. The compiler can display them with a shorthand, but you can’t specify them.
-
-However, you can get around this by providing a concrete type using `Box<dyn _>` or `&dyn _`:
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    #[prop(optional)] progress: Option<Box<dyn Fn() -> i32>>,
-) -> impl IntoView {
-    progress.map(|progress| {
-        view! { cx,
-            <progress
-                max=100
-                value=progress
-            />
-        }
-    })
-}
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <ProgressBar/>
-    }
-}
-```
-
-Because the Rust compiler now knows the concrete type of the prop, and therefore its size in memory even in the `None` case, this compiles fine.
-
-> In this particular case, `&dyn Fn() -> i32` will cause lifetime issues, but in other cases, it may be a possibility.
-
 ## Documenting Components
 
 This is one of the least essential but most important sections of this book.

docs/book/src/view/09_component_children.md

@@ -115,11 +115,11 @@ Calling it like this will create a list:
 
 ```rust
 view! { cx,
-    <WrapsChildren>
+    <WrappedChildren>
         "A"
         "B"
         "C"
-    </WrapsChildren>
+    </WrappedChildren>
 }
 ```
 

examples/Makefile.toml

@@ -5,34 +5,32 @@ CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
 CARGO_MAKE_CARGO_BUILD_TEST_FLAGS = ""
 CARGO_MAKE_WORKSPACE_EMULATION = true
 CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = [
-  "animated_show",
-  "counter",
-  "counter_isomorphic",
-  "counters",
-  "counters_stable",
-  "counter_url_query",
-  "counter_without_macros",
-  "error_boundary",
-  "errors_axum",
-  "fetch",
-  "hackernews",
-  "hackernews_axum",
-  "js-framework-benchmark",
-  "leptos-tailwind-axum",
-  "login_with_token_csr_only",
-  "parent_child",
-  "router",
-  "session_auth_axum",
-  "slots",
-  "ssr_modes",
-  "ssr_modes_axum",
-  "tailwind",
-  "tailwind_csr_trunk",
-  "timer",
-  "todo_app_sqlite",
-  "todo_app_sqlite_axum",
-  "todo_app_sqlite_viz",
-  "todomvc",
+    "counter",
+    "counter_isomorphic",
+    "counters",
+    "counters_stable",
+    "counter_without_macros",
+    "error_boundary",
+    "errors_axum",
+    "fetch",
+    "hackernews",
+    "hackernews_axum",
+    "js-framework-benchmark",
+    "leptos-tailwind-axum",
+    "login_with_token_csr_only",
+    "parent_child",
+    "router",
+    "session_auth_axum",
+    "slots",
+    "ssr_modes",
+    "ssr_modes_axum",
+    "tailwind",
+    "tailwind_csr_trunk",
+    "timer",
+    "todo_app_sqlite",
+    "todo_app_sqlite_axum",
+    "todo_app_sqlite_viz",
+    "todomvc",
 ]
 
 [tasks.gen-members]
@@ -47,65 +45,3 @@ grep -v gtk |
 jq -R -s -c 'split("\n")[:-1]')
 echo "CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = $examples"
 '''
-
-[tasks.test-runner-report]
-workspace = false
-description = "report ci test runners for each example - OPTION: [all]"
-script = '''
-BOLD="\e[1m"
-GREEN="\e[0;32m"
-ITALIC="\e[3m"
-YELLOW="\e[0;33m"
-RESET="\e[0m"
-
-echo
-echo "${YELLOW}Test Runner Report${RESET}"
-echo "${ITALIC}Pass the option \"all\" to show all the examples${RESET}"
-echo
-
-makefile_paths=$(find . -name Makefile.toml -not -path '*/target/*' |
-  sed 's%./%%' |
-  sed 's%/Makefile.toml%%' |
-  grep -v Makefile.toml |
-  sort -u)
-
-start_path=$(pwd)
-
-for path in $makefile_paths; do
-  cd $path
-
-  test_runner=
-
-  test_count=$(grep -rl -E "#\[(test|rstest)\]" | wc -l)
-  if [ $test_count -gt 0 ]; then
-    test_runner="-C"
-  fi
-
-  while read -r line; do
-    case $line in
-      *"wasm-test.toml"*)
-          test_runner=$test_runner"-W"
-        ;;
-      *"playwright-test.toml"*)
-          test_runner=$test_runner"-P"
-        ;;
-      *"cargo-leptos-test.toml"*)
-          test_runner=$test_runner"-L"
-        ;;
-    esac
-  done <"./Makefile.toml"
-
-  if [ ! -z "$1" ]; then
-    # Show all examples
-    echo "$path ${BOLD}${test_runner}${RESET}"
-  elif [ ! -z $test_runner ]; then
-    # Filter out examples that do not run tests in `ci`
-    echo "$path ${BOLD}${test_runner}${RESET}"
-  fi
-
-  cd ${start_path}
-done
-echo
-echo "${ITALIC}Runners: C = Cargo Test, L = Cargo Leptos Test, P = Playwright Test, W = WASM Test${RESET}"
-echo
-'''

examples/animated_show/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "animated-show"
-version = "0.1.0"
-edition = "2021"
-
-[profile.release]
-codegen-units = 1
-lto = true
-
-[dependencies]
-leptos = { path = "../../leptos", features = ["csr"] }
-console_log = "1"
-log = "0.4"
-console_error_panic_hook = "0.1.7"

examples/animated_show/Makefile.toml

@@ -1 +0,0 @@
-extend = [{ path = "../cargo-make/main.toml" }]

examples/animated_show/README.md

@@ -1,9 +0,0 @@
-# `<AnimatedShow>` combined with CSS animations
-
-This is a very simple example of the `<AnimatedShow>` component.
-
-This component is an extension for the `<Show>` component and it will not take in a fallback, but it will unmount the
-component from the DOM after a given duration. This makes it possible to have really easy unmount animations with just
-CSS.
-
-Just execute `trunk serve` to start the demo.

examples/animated_show/index.html

@@ -1,42 +0,0 @@
-<!DOCTYPE html>
-<html>
-	<head>
-		<link data-trunk rel="rust" data-wasm-opt="z"/>
-		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-		<style>
-			.hover-me {
-				width: 100px;
-				margin: 1rem;
-				padding: 1rem;
-				text-align: center;
-				cursor: pointer;
-				border: 1px solid grey;
-			}
-			.here-i-am {
-				width: 100px;
-				margin: 1rem;
-				padding: 1rem;
-				text-align: center;
-				color: white;
-				font-weight: bold;
-				background: black;
-			}
-
-			@keyframes fade-in {
-				from { opacity: 0; }
-				to { opacity: 1; }
-			}
-			@keyframes fade-out {
-				from { opacity: 1; }
-				to { opacity: 0; }
-			}
-			.fade-in-1000 {
-				animation: 1000ms fade-in forwards;
-			}
-			.fade-out-1000 {
-				animation: 1000ms fade-out forwards;
-			}
-		</style>
-	</head>
-	<body></body>
-</html>

examples/animated_show/src/lib.rs

@@ -1,34 +0,0 @@
-use core::time::Duration;
-use leptos::*;
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let show = create_rw_signal(cx, false);
-
-    // the CSS classes in this example are just written directly inside the `index.html`
-    view! { cx,
-        <div
-            class="hover-me"
-            on:mouseenter=move |_| show.set(true)
-            on:mouseleave=move |_| show.set(false)
-        >
-            "Hover Me"
-        </div>
-
-        <AnimatedShow
-            when=show
-            // optional CSS class which will be applied if `when == true`
-            show_class="fade-in-1000"
-            // optional CSS class which will be applied if `when == false` and before the
-            // `hide_delay` starts -> makes CSS unmount animations really easy
-            hide_class="fade-out-1000"
-            // the given unmount delay which should match your unmount animation duration
-            hide_delay=Duration::from_millis(1000)
-        >
-            // provide any `Children` inside here
-            <div class="here-i-am">
-                "Here I Am!"
-            </div>
-        </AnimatedShow>
-    }
-}

examples/animated_show/src/main.rs

@@ -1,12 +0,0 @@
-use animated_show::App;
-use leptos::*;
-
-pub fn main() {
-    _ = console_log::init_with_level(log::Level::Debug);
-    console_error_panic_hook::set_once();
-    mount_to_body(|cx| {
-        view! { cx,
-            <App />
-        }
-    })
-}

examples/cargo-make/cargo-leptos-test.toml

@@ -1,7 +1,5 @@
-extend = { path = "./cargo-leptos.toml" }
-
 [tasks.integration-test]
-dependencies = ["install-cargo-leptos", "cargo-leptos-e2e"]
+dependencies = ["cargo-leptos-e2e"]
 
 [tasks.cargo-leptos-e2e]
 command = "cargo"

examples/cargo-make/cargo-leptos.toml

@@ -1,55 +0,0 @@
-[tasks.install-cargo-leptos]
-install_crate = { crate_name = "cargo-leptos", binary = "cargo-leptos", test_arg = "--help" }
-
-[tasks.build]
-clear = true
-command = "cargo"
-args = ["leptos", "build"]
-
-[tasks.check]
-clear = true
-dependencies = ["check-debug", "check-release"]
-
-[tasks.check-debug]
-toolchain = "nightly"
-command = "cargo"
-args = ["check-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.check-release]
-toolchain = "nightly"
-command = "cargo"
-args = ["check-all-features", "--release"]
-install_crate = "cargo-all-features"
-
-[tasks.start-client]
-command = "cargo"
-args = ["leptos", "watch"]
-
-[tasks.stop-client]
-condition = { env_set = ["APP_PROCESS_NAME"] }
-script = '''
-  if [ ! -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    pkill -f todo_app_sqlite
-  fi
-
-  if [ ! -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    pkill -f cargo-leptos
-  fi
-'''
-
-[tasks.client-status]
-condition = { env_set = ["APP_PROCESS_NAME"] }
-script = '''
-  if [ -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    echo "  ${APP_PROCESS_NAME} is not running"
-  else
-    echo "  ${APP_PROCESS_NAME} is up"
-  fi
-
-  if [ -z $(pidof cargo-leptos) ]; then
-    echo "  cargo-leptos is not running"
-  else
-    echo "  cargo-leptos is up"
-  fi
-'''

examples/cargo-make/compile.toml

@@ -1,11 +0,0 @@
-[tasks.build]
-toolchain = "nightly"
-command = "cargo"
-args = ["build-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.check]
-toolchain = "nightly"
-command = "cargo"
-args = ["check-all-features"]
-install_crate = "cargo-all-features"

examples/cargo-make/main.toml

@@ -1,5 +1,4 @@
 extend = [
-    { path = "../cargo-make/compile.toml" },
     { path = "../cargo-make/clean.toml" },
     { path = "../cargo-make/lint.toml" },
     { path = "../cargo-make/node.toml" },
@@ -10,6 +9,9 @@ extend = [
 [tasks.ci]
 dependencies = ["prepare", "lint", "build", "test-flow", "integration-test"]
 
+[tasks.ci-clean]
+dependencies = ["ci", "clean"]
+
 [tasks.prepare]
 dependencies = ["setup-node"]
 
@@ -18,17 +20,6 @@ dependencies = ["check-style"]
 
 [tasks.integration-test]
 
-# Support Local Runs
-
-[tasks.ci-clean]
-dependencies = ["ci", "clean"]
-
-[tasks.check-clean]
-dependencies = ["check", "clean"]
-
-[tasks.build-clean]
-dependencies = ["build", "clean"]
-
 # ALIASES
 
 [tasks.verify-flow]

examples/cargo-make/webdriver.toml

@@ -1,30 +0,0 @@
-[tasks.start-webdriver]
-script = '''
-  BOLD="\e[1m"
-  GREEN="\e[0;32m"
-  RED="\e[0;31m"
-  RESET="\e[0m"
-
-  if command -v chromedriver; then
-    if [ -z $(pidof chromedriver) ]; then
-      chromedriver --port=4444 &
-    fi
-  else
-    echo "${RED}${BOLD}ERROR${RESET} - chromedriver is required by this task"
-    exit 1
-  fi
-'''
-
-[tasks.stop-webdriver]
-script = '''
-  pkill -f "chromedriver"
-'''
-
-[tasks.webdriver-status]
-script = '''
-  if [ -z $(pidof chromedriver) ]; then
-    echo chromedriver is not running
-  else
-    echo chromedriver is up
-  fi
-'''

examples/counter/Makefile.toml

@@ -2,3 +2,13 @@ extend = [
     { path = "../cargo-make/main.toml" },
     { path = "../cargo-make/wasm-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counter_isomorphic/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counter_url_query/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "counter_url_query"
-version = "0.1.0"
-edition = "2021"
-
-[profile.release]
-codegen-units = 1
-lto = true
-
-[dependencies]
-leptos = { path = "../../leptos", features = ["csr", "nightly"] }
-leptos_router = { path = "../../router", features = ["csr"] }
-console_log = "1"
-log = "0.4"
-console_error_panic_hook = "0.1.7"
-
-[dev-dependencies]
-wasm-bindgen = "0.2"
-wasm-bindgen-test = "0.3.0"
-web-sys = "0.3"

examples/counter_url_query/Makefile.toml

@@ -1 +0,0 @@
-extend = [{ path = "../cargo-make/main.toml" }]

examples/counter_url_query/README.md

@@ -1,7 +0,0 @@
-# Leptos Query Counter Example
-
-This example creates a simple counter whose state is persisted and synced in the url with query params.
-
-To run it, just issue the `trunk serve --open` command in the example root. This will build the app, run it, and open a new browser to serve it.
-
-> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/counter_url_query/index.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<html>
-	<head>
-		<link data-trunk rel="rust" data-wasm-opt="z"/>
-		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-	</head>
-	<body></body>
-</html>

examples/counter_url_query/src/lib.rs

@@ -1,39 +0,0 @@
-use leptos::*;
-use leptos_router::*;
-
-/// A simple counter component.
-///
-/// You can use doc comments like this to document your component.
-#[component]
-pub fn SimpleQueryCounter(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_query_signal::<i32>(cx, "count");
-    let clear = move |_| set_count(None);
-    let decrement = move |_| set_count(Some(count().unwrap_or(0) - 1));
-    let increment = move |_| set_count(Some(count().unwrap_or(0) + 1));
-
-    let (msg, set_msg) = create_query_signal::<String>(cx, "message");
-    let update_msg = move |ev| {
-        let new_msg = event_target_value(&ev);
-        if new_msg.is_empty() {
-            set_msg(None);
-        } else {
-            set_msg(Some(new_msg));
-        }
-    };
-
-    view! { cx,
-        <div>
-            <button on:click=clear>"Clear"</button>
-            <button on:click=decrement>"-1"</button>
-            <span>"Value: " {move || count().unwrap_or(0)} "!"</span>
-            <button on:click=increment>"+1"</button>
-
-            <br />
-
-            <input
-                prop:value=move || msg().unwrap_or_default()
-                on:input=update_msg
-            />
-        </div>
-    }
-}

examples/counter_url_query/src/main.rs

@@ -1,17 +0,0 @@
-use counter_url_query::SimpleQueryCounter;
-use leptos::*;
-use leptos_router::*;
-
-pub fn main() {
-    _ = console_log::init_with_level(log::Level::Debug);
-    console_error_panic_hook::set_once();
-    mount_to_body(|cx| {
-        view! { cx,
-            <Router>
-                <Routes>
-                    <Route path="" view=SimpleQueryCounter />
-                </Routes>
-            </Router>
-        }
-    })
-}

examples/counter_without_macros/Makefile.toml

@@ -4,13 +4,11 @@ extend = [
 ]
 
 [tasks.build]
-toolchain = "stable"
 command = "cargo"
-args = ["build-all-features"]
+args = ["+stable", "build-all-features"]
 install_crate = "cargo-all-features"
 
 [tasks.check]
-toolchain = "stable"
 command = "cargo"
-args = ["check-all-features"]
+args = ["+stable", "check-all-features"]
 install_crate = "cargo-all-features"

examples/counters/Makefile.toml

@@ -2,3 +2,13 @@ extend = [
     { path = "../cargo-make/main.toml" },
     { path = "../cargo-make/wasm-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counters_stable/Makefile.toml

@@ -6,13 +6,6 @@ extend = [
 ]
 
 [tasks.build]
-toolchain = "stable"
 command = "cargo"
-args = ["build-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.check]
-toolchain = "stable"
-command = "cargo"
-args = ["check-all-features"]
+args = ["+stable", "build-all-features"]
 install_crate = "cargo-all-features"

examples/error_boundary/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/errors_axum/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/errors_axum/src/landing.rs

@@ -34,7 +34,7 @@ pub fn App(cx: Scope) -> impl IntoView {
             </header>
             <main>
                 <Routes>
-                    <Route path="" view=ExampleErrors/>
+                    <Route path="" view=|cx| view! { cx, <ExampleErrors/> }/>
                 </Routes>
             </main>
         </Router>

examples/fetch/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/hackernews/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/hackernews/src/routes/nav.rs

@@ -21,7 +21,7 @@ pub fn Nav(cx: Scope) -> impl IntoView {
                 <A href="/job">
                     <strong>"Jobs"</strong>
                 </A>
-                <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
+                <a class="github" href="http://github.com/gbj/leptos" target="_blank" rel="noreferrer">
                     "Built with Leptos"
                 </a>
             </nav>

examples/hackernews_axum/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/hackernews_axum/src/routes/nav.rs

@@ -21,7 +21,7 @@ pub fn Nav(cx: Scope) -> impl IntoView {
                 <A href="/job">
                     <strong>"Jobs"</strong>
                 </A>
-                <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
+                <a class="github" href="http://github.com/gbj/leptos" target="_blank" rel="noreferrer">
                     "Built with Leptos"
                 </a>
             </nav>

examples/js-framework-benchmark/Makefile.toml

@@ -4,15 +4,13 @@ extend = [
 ]
 
 [tasks.build]
-toolchain = "nightly"
 command = "cargo"
-args = ["build-all-features", "--target", "wasm32-unknown-unknown"]
+args = ["+nightly", "build-all-features", "--target", "wasm32-unknown-unknown"]
 install_crate = "cargo-all-features"
 
 [tasks.check]
-toolchain = "nightly"
 command = "cargo"
-args = ["check-all-features", "--target", "wasm32-unknown-unknown"]
+args = ["+nightly", "check-all-features", "--target", "wasm32-unknown-unknown"]
 install_crate = "cargo-all-features"
 
 [tasks.pre-clippy]

examples/leptos-tailwind-axum/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/login_with_token_csr_only/Makefile.toml

@@ -1 +1,11 @@
 extend = { path = "../cargo-make/main.toml" }
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/parent_child/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/router/Makefile.toml

@@ -3,3 +3,13 @@ extend = [
     { path = "../cargo-make/trunk_server.toml" },
     { path = "../cargo-make/playwright-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/session_auth_axum/Makefile.toml

@@ -1 +1,11 @@
 extend = { path = "../cargo-make/main.toml" }
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/session_auth_axum/src/todo.rs

@@ -170,7 +170,7 @@ pub fn TodoApp(cx: Scope) -> impl IntoView {
             <hr/>
             <main>
                 <Routes>
-                    <Route path="" view=Todos/> //Route
+                    <Route path="" view=|cx| view! { cx, <Todos/> }/> //Route
                     <Route path="signup" view=move |cx| view! {
                         cx,
                         <Signup action=signup/>

examples/slots/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/ssr_modes/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/ssr_modes_axum/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/tailwind/Makefile.toml

@@ -2,3 +2,13 @@ extend = [
     { path = "../cargo-make/main.toml" },
     { path = "../cargo-make/cargo-leptos-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/tailwind_csr_trunk/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/timer/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/todo_app_sqlite/Cargo.toml

@@ -62,8 +62,7 @@ site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
 reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
-end2end-cmd = "cargo make test-ui"
-end2end-dir = "e2e"
+end2end-cmd = "npx playwright test"
 #  The browserlist query used for optimizing the CSS.
 browserquery = "defaults"
 # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head

examples/todo_app_sqlite/Makefile.toml

@@ -1,24 +1,20 @@
-extend = [
-  { path = "../cargo-make/main.toml" },
-  { path = "../cargo-make/webdriver.toml" },
-  { path = "../cargo-make/cargo-leptos.toml" },
-]
+extend = { path = "../cargo-make/main.toml" }
 
-[env]
-APP_PROCESS_NAME = "todo_app_sqlite"
-
-[tasks.integration-test]
-dependencies = [
-  "install-cargo-leptos",
-  "start-webdriver",
-  "test-e2e-with-auto-start",
-]
-
-[tasks.test-e2e-with-auto-start]
+[tasks.build]
 command = "cargo"
-args = ["leptos", "end-to-end"]
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
 
-[tasks.test-ui]
-cwd = "./e2e"
+[tasks.check]
+clear = true
+dependencies = ["check-debug", "check-release"]
+
+[tasks.check-debug]
 command = "cargo"
-args = ["make", "test-ui", "${@}"]
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check-release]
+command = "cargo"
+args = ["+nightly", "check-all-features", "--release"]
+install_crate = "cargo-all-features"

examples/todo_app_sqlite/README.md

@@ -52,23 +52,3 @@ wasm-pack build --target=web --debug --no-default-features --features=hydrate
 ```bash
 cargo run --no-default-features --features=ssr
 ```
-
-## Testing
-
-This example includes quality checks and end-to-end testing.
-
-To get started run this once.
-
-```bash
-cargo make ci
-```
-
-To only run the UI tests...
-
-```bash
-cargo make start-webdriver
-cargo leptos watch # or cargo run...
-cargo make test-ui
-```
-
-_See the [E2E README](./e2e/README.md) for more information about the testing strategy._

examples/todo_app_sqlite/e2e/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "todo_app_sqlite_e2e"
-version = "0.1.0"
-edition = "2021"
-
-[dev-dependencies]
-anyhow = "1.0.72"
-async-trait = "0.1.72"
-cucumber = "0.19.1"
-fantoccini = "0.19.3"
-pretty_assertions = "1.4.0"
-serde_json = "1.0.104"
-tokio = { version = "1.29.1", features = ["macros", "rt-multi-thread", "time"] }
-url = "2.4.0"
-
-[[test]]
-name = "manage_todos"
-harness = false       # Allow Cucumber to print output instead of libtest

examples/todo_app_sqlite/e2e/Makefile.toml

@@ -1,11 +0,0 @@
-extend = { path = "../../cargo-make/main.toml" }
-
-[tasks.test]
-env = { RUN_AUTOMATICALLY = false }
-condition = { env_true = ["RUN_AUTOMATICALLY"] }
-
-[tasks.ci]
-
-[tasks.test-ui]
-command = "cargo"
-args = ["test", "--test", "manage_todos", "--", "--fail-fast", "${@}"]

examples/todo_app_sqlite/e2e/README.md

@@ -1,33 +0,0 @@
-# E2E Testing
-
-This example demonstrates e2e testing with Rust using executable requirements.
-
-## Testing Stack
-
-|    |      Role      |  Description |
-|---|---|---|
-| [Cucumber](https://github.com/cucumber-rs/cucumber/tree/main) | Test Runner | Run [Gherkin](https://cucumber.io/docs/gherkin/reference/) specifications as Rust tests |
-| [Fantoccini](https://github.com/jonhoo/fantoccini/tree/main) | Browser Client | Interact with web pages through WebDriver |
-| [Cargo Leptos ](https://github.com/leptos-rs/cargo-leptos) | Build Tool |  Compile example and start the server and end-2-end tests |
-| [chromedriver](https://chromedriver.chromium.org/downloads) | WebDriver | Provide WebDriver for Chrome
-
-## Testing Organization
-
-Testing is organized around what a user can do and see/not see.
-
-Here is a brief overview of how things fit together.
-
-```bash
-features                    # Specify test scenarios
-tests
-├── fixtures
-│   ├── action.rs           # Perform a user action (click, type, etc.)
-│   ├── check.rs            # Assert what a user can see/not see
-│   ├── find.rs             # Query page elements
-│   ├── mod.rs
-│   └── world
-│       ├── action_steps.rs # Map Gherkin steps to user actions
-│       ├── check_steps.rs  # Map Gherkin steps to user expectations
-│       └── mod.rs
-└── manage_todos.rs         # Test main 
-```

examples/todo_app_sqlite/e2e/features/add_todo.feature

@@ -1,17 +0,0 @@
-@add_todo
-Feature: Add Todo
-
-    Background:
-        Given I see the app
-
-    @add_todo-see
-    Scenario: Should see the todo
-        Given I set the todo as Buy Bread
-        When I click the Add button
-        Then I see the todo named Buy Bread
-
-    # @allow.skipped
-    @add_todo-style
-    Scenario: Should see the pending todo
-        When I add a todo as Buy Oranges
-        Then I see the pending todo

examples/todo_app_sqlite/e2e/features/delete_todo.feature

@@ -1,18 +0,0 @@
-@delete_todo
-Feature: Delete Todo
-
-    Background:
-        Given I see the app
-
-    @serial
-    @delete_todo-remove
-    Scenario: Should not see the deleted todo
-        Given I add a todo as Buy Yogurt
-        When I delete the todo named Buy Yogurt
-        Then I do not see the todo named Buy Yogurt
-
-    @serial
-    @delete_todo-message
-    Scenario: Should see the empty list message
-        When I empty the todo list
-        Then I see the empty list message is No tasks were found.

examples/todo_app_sqlite/e2e/features/open_app.feature

@@ -1,12 +0,0 @@
-@open_app
-Feature: Open App
-
-  @open_app-title
-  Scenario: Should see the home page title
-    When I open the app
-    Then I see the page title is My Tasks
-
-  @open_app-label
-  Scenario: Should see the input label
-    When I open the app
-    Then I see the label of the input is Add a Todo

examples/todo_app_sqlite/e2e/tests/fixtures/action.rs

@@ -1,60 +0,0 @@
-use super::{find, world::HOST};
-use anyhow::Result;
-use fantoccini::Client;
-use std::result::Result::Ok;
-use tokio::{self, time};
-
-pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
-    let url = format!("{}{}", HOST, path);
-    client.goto(&url).await?;
-
-    Ok(())
-}
-
-pub async fn add_todo(client: &Client, text: &str) -> Result<()> {
-    fill_todo(client, text).await?;
-    click_add_button(client).await?;
-    Ok(())
-}
-
-pub async fn fill_todo(client: &Client, text: &str) -> Result<()> {
-    let textbox = find::todo_input(client).await;
-    textbox.send_keys(text).await?;
-
-    Ok(())
-}
-
-pub async fn click_add_button(client: &Client) -> Result<()> {
-    let add_button = find::add_button(client).await;
-    add_button.click().await?;
-
-    Ok(())
-}
-
-pub async fn empty_todo_list(client: &Client) -> Result<()> {
-    let todos = find::todos(client).await;
-
-    for _todo in todos {
-        let _ = delete_first_todo(client).await?;
-    }
-
-    Ok(())
-}
-
-pub async fn delete_first_todo(client: &Client) -> Result<()> {
-    if let Some(element) = find::first_delete_button(client).await {
-        element.click().await.expect("Failed to delete todo");
-        time::sleep(time::Duration::from_millis(250)).await;
-    }
-
-    Ok(())
-}
-
-pub async fn delete_todo(client: &Client, text: &str) -> Result<()> {
-    if let Some(element) = find::delete_button(client, text).await {
-        element.click().await?;
-        time::sleep(time::Duration::from_millis(250)).await;
-    }
-
-    Ok(())
-}

examples/todo_app_sqlite/e2e/tests/fixtures/check.rs

@@ -1,57 +0,0 @@
-use super::find;
-use anyhow::{Ok, Result};
-use fantoccini::{Client, Locator};
-use pretty_assertions::assert_eq;
-
-pub async fn text_on_element(
-    client: &Client,
-    selector: &str,
-    expected_text: &str,
-) -> Result<()> {
-    let element = client
-        .wait()
-        .for_element(Locator::Css(selector))
-        .await
-        .expect(
-            format!("Element not found by Css selector `{}`", selector)
-                .as_str(),
-        );
-
-    let actual = element.text().await?;
-    assert_eq!(&actual, expected_text);
-
-    Ok(())
-}
-
-pub async fn todo_present(
-    client: &Client,
-    text: &str,
-    expected: bool,
-) -> Result<()> {
-    let todo_present = is_todo_present(client, text).await;
-
-    assert_eq!(todo_present, expected);
-
-    Ok(())
-}
-
-async fn is_todo_present(client: &Client, text: &str) -> bool {
-    let todos = find::todos(client).await;
-
-    for todo in todos {
-        let todo_title = todo.text().await.expect("Todo title not found");
-        if todo_title == text {
-            return true;
-        }
-    }
-
-    false
-}
-
-pub async fn todo_is_pending(client: &Client) -> Result<()> {
-    if let None = find::pending_todo(client).await {
-        assert!(false, "Pending todo not found");
-    }
-
-    Ok(())
-}

examples/todo_app_sqlite/e2e/tests/fixtures/find.rs

@@ -1,63 +0,0 @@
-use fantoccini::{elements::Element, Client, Locator};
-
-pub async fn todo_input(client: &Client) -> Element {
-    let textbox = client
-        .wait()
-        .for_element(Locator::Css("input[name='title"))
-        .await
-        .expect("Todo textbox not found");
-
-    textbox
-}
-
-pub async fn add_button(client: &Client) -> Element {
-    let button = client
-        .wait()
-        .for_element(Locator::Css("input[value='Add']"))
-        .await
-        .expect("");
-
-    button
-}
-
-pub async fn first_delete_button(client: &Client) -> Option<Element> {
-    if let Ok(element) = client
-        .wait()
-        .for_element(Locator::Css("li:first-child input[value='X']"))
-        .await
-    {
-        return Some(element);
-    }
-
-    None
-}
-
-pub async fn delete_button(client: &Client, text: &str) -> Option<Element> {
-    let selector = format!("//*[text()='{text}']//input[@value='X']");
-    if let Ok(element) =
-        client.wait().for_element(Locator::XPath(&selector)).await
-    {
-        return Some(element);
-    }
-
-    None
-}
-
-pub async fn pending_todo(client: &Client) -> Option<Element> {
-    if let Ok(element) =
-        client.wait().for_element(Locator::Css(".pending")).await
-    {
-        return Some(element);
-    }
-
-    None
-}
-
-pub async fn todos(client: &Client) -> Vec<Element> {
-    let todos = client
-        .find_all(Locator::Css("li"))
-        .await
-        .expect("Todo List not found");
-
-    todos
-}

examples/todo_app_sqlite/e2e/tests/fixtures/mod.rs

@@ -1,4 +0,0 @@
-pub mod action;
-pub mod check;
-pub mod find;
-pub mod world;

examples/todo_app_sqlite/e2e/tests/fixtures/world/action_steps.rs

@@ -1,57 +0,0 @@
-use crate::fixtures::{action, world::AppWorld};
-use anyhow::{Ok, Result};
-use cucumber::{given, when};
-
-#[given("I see the app")]
-#[when("I open the app")]
-async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::goto_path(client, "").await?;
-
-    Ok(())
-}
-
-#[given(regex = "^I add a todo as (.*)$")]
-#[when(regex = "^I add a todo as (.*)$")]
-async fn i_add_a_todo_titled(world: &mut AppWorld, text: String) -> Result<()> {
-    let client = &world.client;
-    action::add_todo(client, text.as_str()).await?;
-
-    Ok(())
-}
-
-#[given(regex = "^I set the todo as (.*)$")]
-async fn i_set_the_todo_as(world: &mut AppWorld, text: String) -> Result<()> {
-    let client = &world.client;
-    action::fill_todo(client, &text).await?;
-
-    Ok(())
-}
-
-#[when(regex = "I click the Add button$")]
-async fn i_click_the_button(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::click_add_button(client).await?;
-
-    Ok(())
-}
-
-#[when(regex = "^I delete the todo named (.*)$")]
-async fn i_delete_the_todo_named(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    action::delete_todo(client, text.as_str()).await?;
-
-    Ok(())
-}
-
-#[given("the todo list is empty")]
-#[when("I empty the todo list")]
-async fn i_empty_the_todo_list(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::empty_todo_list(client).await?;
-
-    Ok(())
-}

examples/todo_app_sqlite/e2e/tests/fixtures/world/check_steps.rs

@@ -1,67 +0,0 @@
-use crate::fixtures::{check, world::AppWorld};
-use anyhow::{Ok, Result};
-use cucumber::then;
-
-#[then(regex = "^I see the page title is (.*)$")]
-async fn i_see_the_page_title_is(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    check::text_on_element(client, "h1", &text).await?;
-
-    Ok(())
-}
-
-#[then(regex = "^I see the label of the input is (.*)$")]
-async fn i_see_the_label_of_the_input_is(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    check::text_on_element(client, "label", &text).await?;
-
-    Ok(())
-}
-
-#[then(regex = "^I see the todo named (.*)$")]
-async fn i_see_the_todo_is_present(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    check::todo_present(client, text.as_str(), true).await?;
-
-    Ok(())
-}
-
-#[then("I see the pending todo")]
-async fn i_see_the_pending_todo(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-
-    check::todo_is_pending(client).await?;
-
-    Ok(())
-}
-
-#[then(regex = "^I see the empty list message is (.*)$")]
-async fn i_see_the_empty_list_message_is(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    check::text_on_element(client, "ul p", &text).await?;
-
-    Ok(())
-}
-
-#[then(regex = "^I do not see the todo named (.*)$")]
-async fn i_do_not_see_the_todo_is_present(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
-    let client = &world.client;
-    check::todo_present(client, text.as_str(), false).await?;
-
-    Ok(())
-}

examples/todo_app_sqlite/e2e/tests/fixtures/world/mod.rs

@@ -1,39 +0,0 @@
-pub mod action_steps;
-pub mod check_steps;
-
-use anyhow::Result;
-use cucumber::World;
-use fantoccini::{
-    error::NewSessionError, wd::Capabilities, Client, ClientBuilder,
-};
-
-pub const HOST: &str = "http://127.0.0.1:3000";
-
-#[derive(Debug, World)]
-#[world(init = Self::new)]
-pub struct AppWorld {
-    pub client: Client,
-}
-
-impl AppWorld {
-    async fn new() -> Result<Self, anyhow::Error> {
-        let webdriver_client = build_client().await?;
-
-        Ok(Self {
-            client: webdriver_client,
-        })
-    }
-}
-
-async fn build_client() -> Result<Client, NewSessionError> {
-    let mut cap = Capabilities::new();
-    let arg = serde_json::from_str("{\"args\": [\"-headless\"]}").unwrap();
-    cap.insert("goog:chromeOptions".to_string(), arg);
-
-    let client = ClientBuilder::native()
-        .capabilities(cap)
-        .connect("http://localhost:4444")
-        .await?;
-
-    Ok(client)
-}

examples/todo_app_sqlite/e2e/tests/manage_todos.rs

@@ -1,14 +0,0 @@
-mod fixtures;
-
-use anyhow::Result;
-use cucumber::World;
-use fixtures::world::AppWorld;
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    AppWorld::cucumber()
-        .fail_on_skipped()
-        .run_and_exit("./features")
-        .await;
-    Ok(())
-}

examples/todo_app_sqlite/src/main.rs

@@ -1,4 +1,5 @@
 use cfg_if::cfg_if;
+use leptos::*;
 mod todo;
 
 // boilerplate to run in different modes
@@ -8,7 +9,6 @@ cfg_if! {
         use actix_files::{Files};
         use actix_web::*;
         use crate::todo::*;
-        use leptos::*;
         use leptos_actix::{generate_route_list, LeptosRoutes};
 
         #[get("/style.css")]

examples/todo_app_sqlite_axum/Cargo.toml

@@ -65,8 +65,7 @@ site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
 reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
-end2end-cmd = "cargo make test-ui"
-end2end-dir = "e2e"
+end2end-cmd = "npx playwright test"
 #  The browserlist query used for optimizing the CSS.
 browserquery = "defaults"
 # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head

examples/todo_app_sqlite_axum/Makefile.toml

@@ -1,24 +1,11 @@
-extend = [
-    { path = "../cargo-make/main.toml" },
-    { path = "../cargo-make/webdriver.toml" },
-    { path = "../cargo-make/cargo-leptos.toml" },
-]
+extend = { path = "../cargo-make/main.toml" }
 
-[env]
-APP_PROCESS_NAME = "todo_app_sqlite_axum"
-
-[tasks.integration-test]
-dependencies = [
-    "install-cargo-leptos",
-    "start-webdriver",
-    "test-e2e-with-auto-start",
-]
-
-[tasks.test-e2e-with-auto-start]
+[tasks.build]
 command = "cargo"
-args = ["leptos", "end-to-end"]
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
 
-[tasks.test-ui]
-cwd = "./e2e"
+[tasks.check]
 command = "cargo"
-args = ["make", "test-ui", "${@}"]
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/todo_app_sqlite_axum/README.md

@@ -40,23 +40,3 @@ wasm-pack build --target=web --debug --no-default-features --features=hydrate
 ```bash
 cargo run --no-default-features --features=ssr
 ```
-
-## Testing
-
-This example includes quality checks and end-to-end testing.
-
-To get started run this once.
-
-```bash
-cargo make ci
-```
-
-To only run the UI tests...
-
-```bash
-cargo make start-webdriver
-cargo leptos watch # or cargo run...
-cargo make test-ui
-```
-
-_See the [E2E README](./e2e/README.md) for more information about the testing strategy._

examples/todo_app_sqlite_axum/e2e/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "todo_app_sqlite_axum_e2e"
-version = "0.1.0"
-edition = "2021"
-
-[dev-dependencies]
-anyhow = "1.0.72"
-async-trait = "0.1.72"
-cucumber = "0.19.1"
-fantoccini = "0.19.3"
-pretty_assertions = "1.4.0"
-serde_json = "1.0.104"
-tokio = { version = "1.29.1", features = ["macros", "rt-multi-thread", "time"] }
-url = "2.4.0"
-
-[[test]]
-name = "manage_todos"
-harness = false       # Allow Cucumber to print output instead of libtest

examples/todo_app_sqlite_axum/e2e/Makefile.toml

@@ -1,11 +0,0 @@
-extend = { path = "../../cargo-make/main.toml" }
-
-[tasks.test]
-env = { RUN_AUTOMATICALLY = false }
-condition = { env_true = ["RUN_AUTOMATICALLY"] }
-
-[tasks.ci]
-
-[tasks.test-ui]
-command = "cargo"
-args = ["test", "--test", "manage_todos", "--", "--fail-fast", "${@}"]

examples/todo_app_sqlite_axum/e2e/README.md

@@ -1,33 +0,0 @@
-# E2E Testing
-
-This example demonstrates e2e testing with Rust using executable requirements.
-
-## Testing Stack
-
-|    |      Role      |  Description |
-|---|---|---|
-| [Cucumber](https://github.com/cucumber-rs/cucumber/tree/main) | Test Runner | Run [Gherkin](https://cucumber.io/docs/gherkin/reference/) specifications as Rust tests |
-| [Fantoccini](https://github.com/jonhoo/fantoccini/tree/main) | Browser Client | Interact with web pages through WebDriver |
-| [Cargo Leptos ](https://github.com/leptos-rs/cargo-leptos) | Build Tool |  Compile example and start the server and end-2-end tests |
-| [chromedriver](https://chromedriver.chromium.org/downloads) | WebDriver | Provide WebDriver for Chrome
-
-## Testing Organization
-
-Testing is organized around what a user can do and see/not see.
-
-Here is a brief overview of how things fit together.
-
-```bash
-features                    # Specify test scenarios
-tests
-├── fixtures
-│   ├── action.rs           # Perform a user action (click, type, etc.)
-│   ├── check.rs            # Assert what a user can see/not see
-│   ├── find.rs             # Query page elements
-│   ├── mod.rs
-│   └── world
-│       ├── action_steps.rs # Map Gherkin steps to user actions
-│       ├── check_steps.rs  # Map Gherkin steps to user expectations
-│       └── mod.rs
-└── manage_todos.rs         # Test main 
-```

examples/todo_app_sqlite_axum/e2e/features/add_todo.feature

@@ -1,16 +0,0 @@
-@add_todo
-Feature: Add Todo
-
-    Background:
-        Given I see the app
-
-    @add_todo-see
-    Scenario: Should see the todo
-        Given I set the todo as Buy Bread
-        When I click the Add button
-        Then I see the todo named Buy Bread
-
-    @add_todo-style
-    Scenario: Should see the pending todo
-        When I add a todo as Buy Oranges
-        Then I see the pending todo

examples/todo_app_sqlite_axum/e2e/features/delete_todo.feature

@@ -1,18 +0,0 @@
-@delete_todo
-Feature: Delete Todo
-
-    Background:
-        Given I see the app
-
-    @serial
-    @delete_todo-remove
-    Scenario: Should not see the deleted todo
-        Given I add a todo as Buy Yogurt
-        When I delete the todo named Buy Yogurt
-        Then I do not see the todo named Buy Yogurt
-
-    @serial
-    @delete_todo-message
-    Scenario: Should see the empty list message
-        When I empty the todo list
-        Then I see the empty list message is No tasks were found.

examples/todo_app_sqlite_axum/e2e/features/open_app.feature

@@ -1,12 +0,0 @@
-@open_app
-Feature: Open App
-
-  @open_app-title
-  Scenario: Should see the home page title
-    When I open the app
-    Then I see the page title is My Tasks
-
-  @open_app-label
-  Scenario: Should see the input label
-    When I open the app
-    Then I see the label of the input is Add a Todo

examples/todo_app_sqlite_axum/e2e/tests/fixtures/action.rs

@@ -1,60 +0,0 @@
-use super::{find, world::HOST};
-use anyhow::Result;
-use fantoccini::Client;
-use std::result::Result::Ok;
-use tokio::{self, time};
-
-pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
-    let url = format!("{}{}", HOST, path);
-    client.goto(&url).await?;
-
-    Ok(())
-}
-
-pub async fn add_todo(client: &Client, text: &str) -> Result<()> {
-    fill_todo(client, text).await?;
-    click_add_button(client).await?;
-    Ok(())
-}
-
-pub async fn fill_todo(client: &Client, text: &str) -> Result<()> {
-    let textbox = find::todo_input(client).await;
-    textbox.send_keys(text).await?;
-
-    Ok(())
-}
-
-pub async fn click_add_button(client: &Client) -> Result<()> {
-    let add_button = find::add_button(client).await;
-    add_button.click().await?;
-
-    Ok(())
-}
-
-pub async fn empty_todo_list(client: &Client) -> Result<()> {
-    let todos = find::todos(client).await;
-
-    for _todo in todos {
-        let _ = delete_first_todo(client).await?;
-    }
-
-    Ok(())
-}
-
-pub async fn delete_first_todo(client: &Client) -> Result<()> {
-    if let Some(element) = find::first_delete_button(client).await {
-        element.click().await.expect("Failed to delete todo");
-        time::sleep(time::Duration::from_millis(250)).await;
-    }
-
-    Ok(())
-}
-
-pub async fn delete_todo(client: &Client, text: &str) -> Result<()> {
-    if let Some(element) = find::delete_button(client, text).await {
-        element.click().await?;
-        time::sleep(time::Duration::from_millis(250)).await;
-    }
-
-    Ok(())
-}

examples/todo_app_sqlite_axum/e2e/tests/fixtures/check.rs

@@ -1,57 +0,0 @@
-use super::find;
-use anyhow::{Ok, Result};
-use fantoccini::{Client, Locator};
-use pretty_assertions::assert_eq;
-
-pub async fn text_on_element(
-    client: &Client,
-    selector: &str,
-    expected_text: &str,
-) -> Result<()> {
-    let element = client
-        .wait()
-        .for_element(Locator::Css(selector))
-        .await
-        .expect(
-            format!("Element not found by Css selector `{}`", selector)
-                .as_str(),
-        );
-
-    let actual = element.text().await?;
-    assert_eq!(&actual, expected_text);
-
-    Ok(())
-}
-
-pub async fn todo_present(
-    client: &Client,
-    text: &str,
-    expected: bool,
-) -> Result<()> {
-    let todo_present = is_todo_present(client, text).await;
-
-    assert_eq!(todo_present, expected);
-
-    Ok(())
-}
-
-async fn is_todo_present(client: &Client, text: &str) -> bool {
-    let todos = find::todos(client).await;
-
-    for todo in todos {
-        let todo_title = todo.text().await.expect("Todo title not found");
-        if todo_title == text {
-            return true;
-        }
-    }
-
-    false
-}
-
-pub async fn todo_is_pending(client: &Client) -> Result<()> {
-    if let None = find::pending_todo(client).await {
-        assert!(false, "Pending todo not found");
-    }
-
-    Ok(())
-}