chore: rename ctx to cx

docs/platforms/04-concurrency.md

@@ -1,10 +1,11 @@
 ## Concurrency
-In Dioxus, VNodes are asynchronous and can their rendering can be paused at any time by awaiting a future. Hooks can combine this functionality with the Context and Subscription APIs to craft dynamic and efficient user experiences. 
+
+In Dioxus, VNodes are asynchronous and can their rendering can be paused at any time by awaiting a future. Hooks can combine this functionality with the Context and Subscription APIs to craft dynamic and efficient user experiences.
 
 ```rust
-fn user_data(ctx: Context<()>) -> VNode {
+fn user_data(cx: Context<()>) -> VNode {
     // Register this future as a task
-    use_suspense(ctx, async {
+    use_suspense(cx, async {
         // Continue on with the component as usual, waiting for data to arrive
         let Profile { name, birthday, .. } = fetch_data().await;
         html! {
@@ -16,4 +17,5 @@ fn user_data(ctx: Context<()>) -> VNode {
     })
 }
 ```
-Asynchronous components are powerful but can also be easy to misuse as they pause rendering for the component and its children. Refer to the concurrent guide for information on how to best use async components. 
+
+Asynchronous components are powerful but can also be easy to misuse as they pause rendering for the component and its children. Refer to the concurrent guide for information on how to best use async components.

docs/platforms/05-liveview.md

@@ -1,12 +1,13 @@
 ## Liveview
+
 With the Context, Subscription, and Asynchronous APIs, we've built Dioxus Liveview: a coupling of frontend and backend to deliver user experiences that do not require dedicated API development. Instead of building and maintaining frontend-specific API endpoints, components can directly access databases, server caches, and other services directly from the component.
 
 These set of features are still experimental. Currently, we're still working on making these components more ergonomic
 
 ```rust
-fn live_component(ctx: &Context<()>) -> VNode {
+fn live_component(cx: &Context<()>) -> VNode {
     use_live_component(
-        ctx,
+        cx,
         // Rendered via the client
         #[cfg(target_arch = "wasm32")]
         || html! { <div> {"Loading data from server..."} </div> },

docs/platforms/06-components.md

@@ -8,8 +8,8 @@ struct MyProps {
     name: String
 }
 
-fn Example(ctx: Context<MyProps>) -> VNode {
-    html! { <div> "Hello {ctx.ctx.name}!" </div> }
+fn Example(cx: Context<MyProps>) -> VNode {
+    html! { <div> "Hello {cx.cx.name}!" </div> }
 }
 ```
 
@@ -18,14 +18,14 @@ Here, the `Context` object is used to access hook state, create subscriptions, a
 ```rust
 // A very terse component!
 #[fc]
-fn Example(ctx: Context, name: String) -> VNode {
+fn Example(cx: Context, name: String) -> VNode {
     html! { <div> "Hello {name}!" </div> }
 }
 
 // or
 
 #[functional_component]
-static Example: FC = |ctx, name: String| html! { <div> "Hello {name}!" </div> };
+static Example: FC = |cx, name: String| html! { <div> "Hello {name}!" </div> };
 ```
 
 The final output of components must be a tree of VNodes. We provide an html macro for using JSX-style syntax to write these, though, you could use any macro, DSL, templating engine, or the constructors directly.