Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/security-union/yew-websocket
Yew Rust / Wasm for using WebSockets
https://github.com/security-union/yew-websocket
rust rust-lang yew yew-framework
Last synced: about 2 months ago
JSON representation
Yew Rust / Wasm for using WebSockets
- Host: GitHub
- URL: https://github.com/security-union/yew-websocket
- Owner: security-union
- License: mit
- Created: 2022-09-11T03:31:30.000Z (over 2 years ago)
- Default Branch: master
- Last Pushed: 2024-03-07T00:03:07.000Z (10 months ago)
- Last Synced: 2024-03-07T01:26:58.826Z (10 months ago)
- Topics: rust, rust-lang, yew, yew-framework
- Language: Rust
- Homepage:
- Size: 404 KB
- Stars: 15
- Watchers: 3
- Forks: 3
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
# yew-websocket
[](https://crates.io/crates/yew-websocket)
[](https://docs.rs/yew-websocket)
Rust yew websocket service written with love :)
Supports yew version 0.20.0
This crate is based on the original yew websocket service that used to be part of the core library.
https://github.com/yewstack/yew/blob/0.18.0/packages/yew/src/services/websocket.rs
For some reason, the core team decided to kill it.
I tried using the suggested libraries (wasm-sockets or gloo-net), but those are not properly integrated with yew.
## Sample
```rust
use anyhow::Error;
use serde_derive::{Deserialize, Serialize};
use yew_websocket::macros::Json;
use yew::{html, Component, Context, Html};
use yew_websocket::websocket::{WebSocketService, WebSocketStatus, WebSocketTask};
type AsBinary = bool;
pub enum Format {
Json,
Toml,
}
pub enum WsAction {
Connect,
SendData(AsBinary),
Disconnect,
Lost,
}
pub enum Msg {
WsAction(WsAction),
WsReady(Result),
}
impl From for Msg {
fn from(action: WsAction) -> Self {
Msg::WsAction(action)
}
}
/// This type is used as a request which sent to websocket connection.
#[derive(Serialize, Debug)]
struct WsRequest {
value: u32,
}
/// This type is an expected response from a websocket connection.
#[derive(Deserialize, Debug)]
pub struct WsResponse {
value: u32,
}
pub struct Model {
pub fetching: bool,
pub data: Option,
pub ws: Option,
}
impl Model {
fn view_data(&self) -> Html {
if let Some(value) = self.data {
html! {
{ value }
}
} else {
html! {
{ "Data hasn't fetched yet." }
}
}
}
}
impl Component for Model {
type Message = Msg;
type Properties = ();
fn create(ctx: &Context) -> Self {
Self {
fetching: false,
data: None,
ws: None,
}
}
fn update(&mut self, ctx: &Context, msg: Self::Message) -> bool {
match msg {
Msg::WsAction(action) => match action {
WsAction::Connect => {
let callback = ctx.link().callback(|Json(data)| Msg::WsReady(data));
let notification = ctx.link().batch_callback(|status| match status {
WebSocketStatus::Opened => None,
WebSocketStatus::Closed | WebSocketStatus::Error => {
Some(WsAction::Lost.into())
}
});
let task = WebSocketService::connect(
"wss://echo.websocket.events/",
callback,
notification,
)
.unwrap();
self.ws = Some(task);
true
}
WsAction::SendData(binary) => {
let request = WsRequest { value: 321 };
if binary {
self.ws.as_mut().unwrap().send_binary(Json(&request));
} else {
self.ws.as_mut().unwrap().send(Json(&request));
}
false
}
WsAction::Disconnect => {
self.ws.take();
true
}
WsAction::Lost => {
self.ws = None;
true
}
},
Msg::WsReady(response) => {
self.data = response.map(|data| data.value).ok();
true
}
}
}
fn view(&self, ctx: &Context) -> Html {
html! {
{ self.view_data() }
{ "Connect To WebSocket" }
{ "Send To WebSocket" }
{ "Send To WebSocket [binary]" }
{ "Close WebSocket connection" }
}
}
}
fn main() {
yew::Renderer::::new().render();
}
```