last echo: {last()}
> ); } function Demo() { const [mounted, setMounted] = createSignal(true); return ( <>Status: {labels[state()]}
> ); } render(() =>Status: {labels[state()]}
; ``` ### `createWSMessage` Returns a reactive `AccessorLast message: {message() ?? "(none yet)"}
> ); } render(() =>Last message: {message()}
; ``` > **Note — "latest wins" semantics.** `createWSMessage` uses a signal internally. In Solid 2.0, signal writes are batched: if two messages arrive before the reactive flush, only the second is seen by effects. This is fine for "current state" displays, but if your protocol can burst messages and you need to process every one, use [`wsMessageIterable`](#wsmessageiterable) or [`createWSData`](#createwsdata) instead. ### `makeReconnectingWS` Returns a `WebSocket`-shaped proxy that transparently opens a new underlying connection whenever the server closes it involuntarily. ```tsx repl import { render } from "@solidjs/web"; import { createSignal, onCleanup } from "solid-js"; import { makeReconnectingWS } from "@solid-primitives/websocket"; function Demo() { const [opens, setOpens] = createSignal(0); const ws = makeReconnectingWS("wss://echo.websocket.org", undefined, { delay: 1000 }); // listeners are re-attached to every new underlying connection ws.addEventListener("open", () => setOpens(n => n + 1)); onCleanup(() => ws.close()); // a deliberate close stops reconnecting return ( <> {/* simulate a dropped connection: reconnects automatically after `delay` */}connections opened: {opens()}
> ); } render(() =>Last message: {message() ?? "(none yet)"}
> ); } render(() =>heartbeats answered: {beats()}
; } render(() =>Latest (transformed): {shout()}
(ws, { transform: JSON.parse }); return (Waiting for first quote…}> ); ``` Comparison with `createWSMessage`: | | `createWSMessage` | `createWSData` | | ---------------------------------------- | ------------------------- | -------------------------------- | | Drops burst messages | Yes | No | | Works with `price()) ? "stale" : ""}> Bid: {price().bid} / Ask: {price().ask}
` | No | Yes | | `isPending()` support | No | Yes | | `latest()` support | No | Yes | | Returns `undefined` before first message | Yes | No — throws (suspends) | | Best for | Simple last-value display | State-source WS, real-time feeds | ### `createWSStore` ```tsx repl import { render } from "@solidjs/web"; import { createWS, createWSStore } from "@solid-primitives/websocket"; function Demo() { const ws = createWS("wss://echo.websocket.org"); // note: echo.websocket.org sends a greeting on connect, which is counted too const [state, setState] = createWSStore(ws, { initial: { count: 0, last: "" }, patch(draft, msg: string) { draft.count++; draft.last = msg; }, }); return ( <> {state.count} messages, last: {state.last}
> ); } render(() =>, document.getElementById("app")!); ``` ```ts function createWSStore ( ws: WebSocket, options: { initial: S; patch: (draft: S, msg: T) => void; }, ): [store: Store, setStore: StoreSetter]; ``` A reactive store driven by WebSocket messages as incremental patches. `patch` is called for each incoming message with a mutable draft of the store — mutate it directly, no return value needed. The event listener is removed on owner disposal. ```tsx interface AppState { users: string[]; status: "connecting" | "online" | "offline"; } const ws = createReconnectingWS("wss://app.example.com"); const [state] = createWSStore(ws, { initial: { users: [], status: "connecting" }, patch(draft, msg) { Object.assign(draft, JSON.parse(msg)); }, }); return Users online: {state.users.length}
; ``` You can also use the returned setter to apply local updates: ```ts const [state, setState] = createWSStore(ws, { initial: { count: 0 }, patch }); // imperative write from a button click, etc. setState(s => { s.count = 0; }); ``` --- ## Composing with `action` (request/response pattern) For protocols with correlated request/response over a shared WebSocket, Solid `action` is used: ```ts const queryServer = action(function* (payload: RequestPayload) { const id = crypto.randomUUID(); setOptimisticState(draft => { draft.loading = true; }); ws.send(JSON.stringify({ ...payload, id })); const response: ResponsePayload = yield new Promise(resolve => { const handler = (e: MessageEvent) => { const msg = JSON.parse(e.data); if (msg.id === id) { ws.removeEventListener("message", handler); resolve(msg); } }; ws.addEventListener("message", handler); }); refresh(() => serverData()); return response; }); ``` --- ## Type reference ```ts type WSMessage = string | ArrayBufferLike | ArrayBufferView | Blob; type WSReconnectOptions = { delay?: number; // ms between reconnect attempts — default: 3000 retries?: number; // max reconnect attempts — default: Infinity }; type ReconnectingWebSocket = WebSocket & { reconnect: () => void; send: ((msg: WSMessage) => void) & { before?: () => void }; }; type WSHeartbeatOptions = { message?: WSMessage; // default: "ping" interval?: number; // ms between heartbeats — default: 1000 wait?: number; // ms to wait for pong before reconnecting — default: 1500 }; type WSDataOptions= { transform?: (msg: T) => U; // map each raw message before the memo value updates }; type WSStoreOptions = { initial: S; // starting store state patch: (draft: S, msg: T) => void; // mutate the draft for each incoming message }; ``` ## Changelog See [CHANGELOG.md](./CHANGELOG.md)