fix: ✏️ updated all instances of *WASM* to *Wasm*

Author: arctic-hen7

README.md

@@ -22,7 +22,7 @@ Support every major rendering strategy and provide developers the ability to eff
 
 ## Motivation
 
-There is a sore lack of Rust frameworks for frontend development that support more than just SPAs and client-side rendering, and so Perseus was born. We need something like NextJS for WASM.
+There is a sore lack of Rust frameworks for frontend development that support more than just SPAs and client-side rendering, and so Perseus was born. We need something like NextJS for Wasm.
 
 ## Roadmap
 

docs/src/integrations/actix-web.md

@@ -52,7 +52,7 @@ async fn main() -> std::io::Result<()> {
 }
 ```
 
-When you use the integration, you'll have to define a few options to tell it what exactly to serve. Specifically, you'll need to tell it where your `index.html` file, your JS bundle, and your WASM bundle all are. In addition, you'll need to a provide it with a template map (which you'll often define a getter function for as above).
+When you use the integration, you'll have to define a few options to tell it what exactly to serve. Specifically, you'll need to tell it where your `index.html` file, your JS bundle, and your Wasm bundle all are. In addition, you'll need to a provide it with a template map (which you'll often define a getter function for as above).
 
 Also, because this plugs into an existing server, you have full control over hosting options, like the port to be used!
 

docs/src/serving.md

@@ -1,33 +1,33 @@
 # Serving
 
-*You only need this page if you're not using the Perseus CLI, which performs this process for you!*
+_You only need this page if you're not using the Perseus CLI, which performs this process for you!_
 
 Having generated a large number of static files, you'll need a system to host your files for you! Due to the dynamic nature of some rendering strategies, Perseus needs to be involved in this process (for executing request-time logic), and so it provides a simple API interface for serving pages.
 
 Perseus aims to be agnostic as to what framework you use to host your files, and any framework that gives you access to request headers and wildcard paths should work (in other words, any framework worth its salt).
 
 If you're using one of our supported integrations, you don't have to bother with this page, nearly all of it can be done for you!
 
-- [Actix Web](./integrations/actix-web.md)
-- *More coming soon...*
+-   [Actix Web](./integrations/actix-web.md)
+-   _More coming soon..._
 
 ## Endpoints
 
 Here are the endpoints that a server for Perseus must serve:
 
-- `/.perseus/page/*` – used to serve the JSON data that the app shell needs to render a page (`*` should be extractable as a filename, e.g. `{filename:.*}` in Actix Web)
-- `/.perseus/bundle.js` – the JavaScript bundle file that calls your WASM code (see [tutorial on building your first app](./tutorials/first_app/intro.md))
-- `/.perseus/bundle.wasm` – the WASM bundle file that contains your code (see [tutorial on building your first app](./tutorials/first_app/intro.md))
-- `*` (anything else) – any page that the user actually requests, which will return the app shell to do the heavy lifting (or more accurately an HTML file that includes the bundle)
+-   `/.perseus/page/*` – used to serve the JSON data that the app shell needs to render a page (`*` should be extractable as a filename, e.g. `{filename:.*}` in Actix Web)
+-   `/.perseus/bundle.js` – the JavaScript bundle file that calls your Wasm code (see [tutorial on building your first app](./tutorials/first_app/intro.md))
+-   `/.perseus/bundle.wasm` – the Wasm bundle file that contains your code (see [tutorial on building your first app](./tutorials/first_app/intro.md))
+-   `*` (anything else) – any page that the user actually requests, which will return the app shell to do the heavy lifting (or more accurately an HTML file that includes the bundle)
 
 ## Usage
 
 This example shows what would be done to acquire a page for any framework. You'll need to have access to these data to get a page:
 
-- The page path the user requested, e.g. `/post/test` for a request to `/.perseus/page/post/test`
-- Data about the HTTP request the user sent (see below)
-- A map of templates produced with [`get_templates_map!`]() (API docs WIP)
-- A [config manager](./config_managers.md)
+-   The page path the user requested, e.g. `/post/test` for a request to `/.perseus/page/post/test`
+-   Data about the HTTP request the user sent (see below)
+-   A map of templates produced with [`get_templates_map!`]() (API docs WIP)
+-   A [config manager](./config_managers.md)
 
 ```rust,no_run,no_playground
 use perseus::{get_page};
@@ -46,7 +46,7 @@ match page_data {
 
 ## Request Data
 
-Perseus needs access to information about HTTP requests so it can perform tasks related to the *request state* strategy, which provides access to headers and the like. Internally, Perseus uses [`http::Request`](https://docs.rs/http/0.2.4/http/request/struct.Request.html) for this, with the body type `()` (payloads are irrelevant in requests that ask for a page at a URL).
+Perseus needs access to information about HTTP requests so it can perform tasks related to the _request state_ strategy, which provides access to headers and the like. Internally, Perseus uses [`http::Request`](https://docs.rs/http/0.2.4/http/request/struct.Request.html) for this, with the body type `()` (payloads are irrelevant in requests that ask for a page at a URL).
 
 Unfortunately, different web server frameworks represent request data differently, and so you'll need to convert from your framework's system to `http`'s. When integrations are ready, this will be done for you!
 
@@ -77,19 +77,19 @@ pub fn convert_req(raw: &actix_web::HttpRequest) -> Result<Request, String> {
 		// Any custom data should therefore be sent in headers (if you're doing that, consider a dedicated API)
 		.body(())
 		.map_err(|err| format!("converting actix web request to perseus-compliant request failed: '{}'", err))?;
-	
+
 	Ok(req)
 }
 ```
 
 Notably, the data that need to be converted are:
 
-- Headers
-- URI to which the request was sent
-- HTTP method (subject to change in future Perseus versions, currently `GET`)
-- HTTP version used
+-   Headers
+-   URI to which the request was sent
+-   HTTP method (subject to change in future Perseus versions, currently `GET`)
+-   HTTP version used
 
-Note that mis-converting any of these data will not affect Perseus (which doesn't require any of them to function), only your own code. So if you have no intention of using the *request state* strategy in your app, you could theoretically just parse an empty request to Perseus like so:
+Note that mis-converting any of these data will not affect Perseus (which doesn't require any of them to function), only your own code. So if you have no intention of using the _request state_ strategy in your app, you could theoretically just parse an empty request to Perseus like so:
 
 ```rust
 use perseus::HttpRequest

docs/src/tutorials/first_app/setup.md

@@ -10,7 +10,7 @@ After you've done this, make sure everything works by running `cargo` in a termi
 
 ## Build Tools
 
-Perseus is built on top of WASM (WebAssembly), which basically lets you use programming languages other than JavaScript to build websites/webapps. That tech is *really* complicated, and you'll need two particular build tools to make your code work.
+Perseus is built on top of Wasm (WebAssembly), which basically lets you use programming languages other than JavaScript to build websites/webapps. That tech is _really_ complicated, and you'll need two particular build tools to make your code work.
 
 The first one is [`wasm-pack`](), which helps to compile your Rust code to WebAssembly (sort of like how you'd compile code normally, but specially for the browser). You can install it with this command:
 
@@ -20,12 +20,14 @@ cargo install wasm-pack
 
 Now, you should be able to type `wasm-pack` in your terminal to get another help page!
 
-The next tool is one you might be familiar with if you're coming from the JavaScript world: [Rollup](https://rollupjs.org). Rollup is a bundling tool for JavaScript, and it works really nicely with WASM. If you loathe JavaScript with a passion, don't worry, the only JavaScript in Perseus just invokes your (infinitely superior) Rust code! You can install Rollup with the following command:
+The next tool is one you might be familiar with if you're coming from the JavaScript world: [Rollup](https://rollupjs.org). Rollup is a bundling tool for JavaScript, and it works really nicely with Wasm. If you loathe JavaScript with a passion, don't worry, the only JavaScript in Perseus just invokes your (infinitely superior) Rust code! You can install Rollup with the following command:
 
 ```
 npm i -g rollup
 ```
+
 or
+
 ```
 yarn global add rollup
 ```

examples/basic/Cargo.toml

@@ -15,6 +15,6 @@ sycamore-router = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1" # Possibly don't need?
 
-# This section is needed for WASM Pack (which we use instead of Trunk for flexibility)
+# This section is needed for Wasm Pack (which we use instead of Trunk for flexibility)
 [lib]
 crate-type = ["cdylib", "rlib"]

examples/cli/.perseus/Cargo.toml

@@ -1,4 +1,4 @@
-# This crate defines the user's app in terms that WASM can understand, making development significantly simpler.
+# This crate defines the user's app in terms that Wasm can understand, making development significantly simpler.
 # IMPORTANT: spacing matters in this file for runtime replacements, do NOT change it!
 
 [package]
@@ -23,7 +23,7 @@ console_error_panic_hook = "0.1.6"
 urlencoding = "2.1"
 futures = "0.3"
 
-# This section is needed for WASM Pack (which we use instead of Trunk for flexibility)
+# This section is needed for Wasm Pack (which we use instead of Trunk for flexibility)
 [lib]
 crate-type = ["cdylib", "rlib"]
 

examples/cli/.perseus/server/Cargo.toml

@@ -1,4 +1,4 @@
-# This crate defines the user's app in terms that WASM can understand, making development significantly simpler.
+# This crate defines the user's app in terms that Wasm can understand, making development significantly simpler.
 # IMPORTANT: spacing matters in this file for runtime replacements, do NOT change it!
 
 [package]

examples/cli/.perseus/server/src/main.rs

@@ -7,7 +7,7 @@ use std::env;
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
     // So we don't have to define a different `FsConfigManager` just for the server, we shift the execution context to the same level as everything else
-    // The server has to be a separate crate because otherwise the dependencies don't work with WASM bundling
+    // The server has to be a separate crate because otherwise the dependencies don't work with Wasm bundling
     env::set_current_dir("../").unwrap();
 
     let host = env::var("HOST").unwrap_or_else(|_| "localhost".to_string());

examples/cli/.perseus/src/lib.rs

@@ -8,7 +8,7 @@ use sycamore::prelude::{template, StateHandle};
 use sycamore_router::{HistoryIntegration, Router, RouterProps};
 use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
 
-/// The entrypoint into the app itself. This will be compiled to WASM and actually executed, rendering the rest of the app.
+/// The entrypoint into the app itself. This will be compiled to Wasm and actually executed, rendering the rest of the app.
 #[wasm_bindgen]
 pub fn run() -> Result<(), JsValue> {
     // Panics should always go to the console

examples/cli/Cargo.toml

@@ -15,6 +15,6 @@ sycamore-router = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1" # Possibly don't need?
 
-# This section is needed for WASM Pack (which we use instead of Trunk for flexibility)
+# This section is needed for Wasm Pack (which we use instead of Trunk for flexibility)
 [lib]
 crate-type = ["cdylib", "rlib"]

packages/perseus-actix-web/src/configurer.rs

@@ -12,7 +12,7 @@ pub struct Options {
     /// The locales on the filesystem of the file that will invoke your JavaScript bundle. This should have something like `init()` in
     /// it.
     pub js_init: String,
-    /// The location on the filesystem of your WASM bundle.
+    /// The location on the filesystem of your Wasm bundle.
     pub wasm_bundle: String,
     /// The location on the filesystem of your `index.html` file that includes the JS bundle.
     pub index: String,
@@ -51,7 +51,7 @@ pub async fn configurer<C: ConfigManager + 'static, T: TranslationsManager + 'st
             .data(config_manager.clone())
             .data(translations_manager.clone())
             .data(opts.clone())
-            // TODO chunk JS and WASM bundles
+            // TODO chunk JS and Wasm bundles
             // These allow getting the basic app code (not including the static data)
             // This contains everything in the spirit of a pseudo-SPA
             .route("/.perseus/main.js", web::get().to(js_init))