Fixed example squiglies.

packages/liveview/Cargo.toml

@@ -35,7 +35,8 @@ axum = { version = "0.5.1", optional = true, features = ["ws"] }
 tower = { version = "0.4.12", optional = true }
 
 [dev-dependencies]
-dioxus-liveview = { path = "./", features = ["warp"] }
+tokio = { version = "1", features = ["full"] }
+dioxus = { path = "../../" }
 warp = "0.3"
 axum = { version = "0.5.1", features = ["ws"] }
 tower = "0.4.12"

packages/liveview/examples/axum.rs

@@ -0,0 +1,38 @@
+use axum::{
+    extract::ws::WebSocketUpgrade, response::Html, response::IntoResponse, routing::get, Extension,
+    Router,
+};
+use dioxus_core::{Element, LazyNodes, Scope};
+use dioxus_liveview::Liveview;
+
+#[tokio::main]
+async fn main() {
+    #[cfg(feature = "axum")]
+    {
+        pretty_env_logger::init();
+
+        let addr: std::net::SocketAddr = ([127, 0, 0, 1], 3030).into();
+
+        let view = dioxus_liveview::new(addr);
+        let body = view.body("<title>Dioxus Liveview</title>");
+
+        let app = Router::new()
+            .route("/", get(move || async { Html(body) }))
+            .route(
+                "/app",
+                get(move |ws: WebSocketUpgrade| async move {
+                    ws.on_upgrade(move |socket| async move {
+                        view.upgrade(socket, app).await;
+                    })
+                }),
+            );
+        axum::Server::bind(&addr.to_string().parse().unwrap())
+            .serve(app.into_make_service())
+            .await
+            .unwrap();
+    }
+}
+
+fn app(cx: Scope) -> Element {
+    cx.render(LazyNodes::new(|f| f.text(format_args!("hello world!"))))
+}

packages/liveview/examples/warp.rs

@@ -5,26 +5,28 @@ use warp::Filter;
 
 #[tokio::main]
 async fn main() {
-    pretty_env_logger::init();
+    #[cfg(feature = "warp")]
+    {
+        pretty_env_logger::init();
 
-    let addr = ([127, 0, 0, 1], 3030);
+        let addr = ([127, 0, 0, 1], 3030);
 
-    // todo: compactify this routing under one liveview::app method
-    let view = liveview::new(addr);
-    let body = view.body("<title>Dioxus LiveView</title>");
+        // todo: compactify this routing under one liveview::app method
+        let view = liveview::new(addr);
+        let body = view.body("<title>Dioxus LiveView</title>");
 
-    let routes = warp::path::end()
-        .map(move || warp::reply::html(body.clone()))
-        .or(warp::path("app")
-            .and(warp::ws())
-            .and(warp::any().map(move || view.clone()))
-            .map(|ws: Ws, view: liveview::Liveview| {
-                ws.on_upgrade(|socket| async move {
-                    view.upgrade(socket, app).await;
-                })
-            }));
-
-    warp::serve(routes).run(addr).await;
+        let routes = warp::path::end()
+            .map(move || warp::reply::html(body.clone()))
+            .or(warp::path("app")
+                .and(warp::ws())
+                .and(warp::any().map(move || view.clone()))
+                .map(|ws: Ws, view: liveview::Liveview| {
+                    ws.on_upgrade(|socket| async move {
+                        view.upgrade(socket, app).await;
+                    })
+                }));
+        warp::serve(routes).run(addr).await;
+    }
 }
 
 fn app(cx: Scope) -> Element {

packages/liveview/src/adapters/axum_adapter.rs

@@ -7,14 +7,22 @@ use futures_util::{
 };
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::UnboundedReceiverStream;
+use tokio_util::task::LocalPoolHandle;
 
-pub async fn connect(socket: WebSocket, liveview: Liveview, app: fn(Scope) -> Element) {
+#[cfg(feature = "axum")]
+impl crate::Liveview {
+    pub async fn upgrade(&self, ws: WebSocket, app: fn(Scope) -> Element) {
+        connect(ws, self.pool.clone(), app).await;
+    }
+}
+
+pub async fn connect(socket: WebSocket, pool: LocalPoolHandle, app: fn(Scope) -> Element) {
     let (mut user_ws_tx, mut user_ws_rx) = socket.split();
     let (event_tx, event_rx) = mpsc::unbounded_channel();
     let (edits_tx, edits_rx) = mpsc::unbounded_channel();
     let mut edits_rx = UnboundedReceiverStream::new(edits_rx);
     let mut event_rx = UnboundedReceiverStream::new(event_rx);
-    let vdom_fut = liveview.pool.clone().spawn_pinned(move || async move {
+    let vdom_fut = pool.clone().spawn_pinned(move || async move {
         let mut vdom = VirtualDom::new(app);
         let edits = vdom.rebuild();
         let serialized = serde_json::to_string(&edits.edits).unwrap();

packages/liveview/src/adapters/warp_adapter.rs

@@ -6,6 +6,7 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 use tokio_util::task::LocalPoolHandle;
 use warp::ws::{Message, WebSocket};
 
+#[cfg(feature = "warp")]
 impl crate::Liveview {
     pub async fn upgrade(&self, ws: warp::ws::WebSocket, app: fn(Scope) -> Element) {
         connect(ws, self.pool.clone(), app).await;