Copy edited and added Trunk install instructions

examples/counter-isomorphic/README.md

@@ -10,7 +10,7 @@ To run it as a server side app with hydration, first you should run
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
 
-to generate the Webassembly to provide hydration features for the server.
+to generate the WebAssembly to provide hydration features for the server.
 Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
 
 ```bash

examples/counter/README.md

@@ -3,3 +3,5 @@
 This example creates a simple counter in a client side rendered app with Rust and WASM!
 
 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/counters-stable/README.md

@@ -1,8 +1,10 @@
 # Leptos Counters Example on Rust Stable
 
-This example showcases a basic leptos app with many counters. It is a good example of how to setup a basic reactive app with signals and effects, and how to interact with browser events. Unlike the other counters example, it will compile on Rust stable
+This example showcases a basic Leptos app with many counters. It is a good example of how to setup a basic reactive app with signals and effects, and how to interact with browser events. Unlike the other counters example, it will compile on Rust stable, because it has the `stable` feature enabled.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
 
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/counters/README.md

@@ -1,8 +1,10 @@
 # Leptos Counters Example
 
-This example showcases a basic leptos app with many counters. It is a good example of how to setup a basic reactive app with signals and effects, and how to interact with browser events. Unlike the other counters example, it will compile on Rust stable
+This example showcases a basic Leptos app with many counters. It is a good example of how to set up a basic reactive app with signals and effects, and how to interact with browser events.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
 
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/fetch/README.md

@@ -1,7 +1,10 @@
 # Client Side Fetch
 
-This example shows how to fetch data from the client in Webassembly
+This example shows how to fetch data from the client in WebAssembly.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
+
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/gtk/README.md

@@ -1,7 +1,8 @@
 # Leptos in a GTK App
 
-This example creates a basic GTK app that uses leptos' reactive primitives.
+This example creates a basic GTK app that uses Leptos’s reactive primitives.
 
 ## Build and Run
-Unlike the other examples, this has a variety of build preqrequisites that are out of scope of this crate. More detail on that can be found [here](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation.html). The example comes from [here](https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html) and should be 
+
+Unlike the other examples, this has a variety of build prerequisites that are out of scope of this crate. More detail on that can be found [here](https://gtk-rs.org/gtk4-rs/stable/latest/book/installation.html). The example comes from [here](https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html) and should be
 runnable with `cargo run` if you have the GTK prerequisites installed.

examples/hackernews-axum/README.md

@@ -3,18 +3,27 @@
 This example creates a basic clone of the Hacker News site. It showcases Leptos' ability to create both a client-side rendered app, and a server side rendered app with hydration, in a single repository. This repo differs from the main Hacker News example by using Axum as it's server.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
+
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)
 
 ## Server Side Rendering With Hydration
-To run it as a server side app with hydration, first you should run 
+
+To run it as a server side app with hydration, first you should run
+
 ```bash
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
-to generate the Webassembly to provide hydration features for the server.
-Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration. 
+
+to generate the WebAssembly to hydrate the HTML that is generated on the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
 ```bash
 cargo run --no-default-features --features=ssr
 ```
+
 > Note that if your hydration code changes, you will have to rerun the wasm-pack command above
 > This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!

examples/hackernews/README.md

@@ -1,20 +1,29 @@
 # Leptos Hacker News Example
 
-This example creates a basic clone of the Hacker News site. It showcases Leptos' ability to create both a client-side rendered app, and a server side rendered app with hydration, in a single repository. It uses Actix as it's backend.
+This example creates a basic clone of the Hacker News site. It showcases Leptos’s ability to create both a client-side rendered app, and a server side rendered app with hydration, in a single repository. It uses Actix as its backend.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
+
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)
 
 ## Server Side Rendering With Hydration
-To run it as a server side app with hydration, first you should run 
+
+To run it as a server side app with hydration, first you should run
+
 ```bash
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
-to generate the Webassembly to provide hydration features for the server.
-Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration. 
+
+to generate the WebAssembly to hydrate the HTML that is generated on the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
 ```bash
 cargo run --no-default-features --features=ssr
 ```
+
 > Note that if your hydration code changes, you will have to rerun the wasm-pack command above
 > This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!

examples/parent-child/README.md

@@ -1,14 +1,17 @@
 # Parent Child Example
 
- This example highlights four different ways that child components can communicate with their parent:
+This example highlights four different ways that child components can communicate with their parent:
+
 1. <ButtonA/>: passing a WriteSignal as one of the child component props,
-    for the child component to write into and the parent to read
+   for the child component to write into and the parent to read
 2. <ButtonB/>: passing a closure as one of the child component props, for
-    the child component to call
-3.  <ButtonC/>: adding a simple event listener on the child component itself
-4.  <ButtonD/>: providing a context that is used in the component (rather than prop drilling)
+   the child component to call
+3. <ButtonC/>: adding a simple event listener on the child component itself
+4. <ButtonD/>: providing a context that is used in the component (rather than prop drilling)
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
+
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
 app into one CSR bundle
 
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/router/README.md

@@ -1,8 +1,11 @@
 # Leptos Router Example
 
-This example demonstrates how Leptos' router for client side routing.
+This example demonstrates how Leptos’s router for client side routing.
 
 ## Build and Run it
+
 ```bash
 trunk serve --open
 ```
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/todo-app-cbor/README.md

@@ -2,19 +2,21 @@
 
 This example creates a basic todo app with an Actix backend that uses Leptos' server functions to call sqlx from the client and seamlessly run it on the server. It is identical to the todo-app-sqlite example, but utilizes CBOR encoding for one of the server functions
 
-## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
-
 ## Server Side Rendering With Hydration
-To run it as a server side app with hydration, first you should run 
+
+To run it as a server side app with hydration, first you should run
+
 ```bash
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
-to generate the Webassembly to provide hydration features for the server.
-Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration. 
+
+to generate the WebAssembly to hydrate the HTML that is generated on the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
 ```bash
 cargo run --no-default-features --features=ssr
 ```
+
 > Note that if your hydration code changes, you will have to rerun the wasm-pack command above
-> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!
+> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!

examples/todo-app-sqlite-axum/README.md

@@ -1,21 +1,22 @@
 # Leptos Todo App Sqlite with Axum
 
-This example creates a basic todo app with an Axum backend that uses Leptos' server functions to call sqlx from the client and seamlessly
-run it on the server
-
-## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CRS bundle
+This example creates a basic todo app with an Axum backend that uses Leptos' server functions to call sqlx from the client and seamlessly run it on the server.
 
 ## Server Side Rendering With Hydration
-To run it as a server side app with hydration, first you should run 
+
+To run it as a server side app with hydration, first you should run
+
 ```bash
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
-to generate the Webassembly to provide hydration features for the server.
-Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration. 
+
+to generate the WebAssembly to hydrate the HTML that is generated on the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
 ```bash
 cargo run --no-default-features --features=ssr
 ```
+
 > Note that if your hydration code changes, you will have to rerun the wasm-pack command above
-> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!
+> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!

examples/todo-app-sqlite/README.md

@@ -1,20 +1,22 @@
-# Leptos Todo App Sqlite 
+# Leptos Todo App Sqlite
 
 This example creates a basic todo app with an Actix backend that uses Leptos' server functions to call sqlx from the client and seamlessly run it on the server
 
-## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
-
 ## Server Side Rendering With Hydration
-To run it as a server side app with hydration, first you should run 
+
+To run it as a server side app with hydration, first you should run
+
 ```bash
 wasm-pack build --target=web --no-default-features --features=hydrate
 ```
-to generate the Webassembly to provide hydration features for the server.
-Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration. 
+
+to generate the WebAssembly to hydrate the HTML that is generated on the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
 ```bash
 cargo run --no-default-features --features=ssr
 ```
+
 > Note that if your hydration code changes, you will have to rerun the wasm-pack command above
-> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!
+> This should be temporary, and vastly improve once cargo-leptos becomes ready for prime time!

examples/todomvc/README.md

@@ -1,7 +1,10 @@
 # Leptos TodoMVC
 
-This is a Leptos implementation of the TodoMVC example that most frameworks have.
+This is a Leptos implementation of the TodoMVC example common to many frameworks. This is a relatively-simple application but shows off features like interaction between components and state management.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
+
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/view-tests/README.md

@@ -1,8 +1,10 @@
 # Leptos View Tests
 
-This is a collection of mostly internal view tests for Leptos. Feel free to look if curious.
+This is a collection of mostly internal view tests for Leptos. Feel free to look if curious to see a variety of ways you can build identical views!
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle
 
+To run it as a Client Side App, you can issue `trunk serve --open` in the root. This will build the entire
+app into one CSR bundle.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)