@firtoz/websocket-do 10.0.0 → 13.0.0

package/src/standardSchemaRpc.ts

@@ -0,0 +1,83 @@
+import {
+	type StandardSchemaWebSocketClientOptions,
+	StandardSchemaWebSocketClient,
+} from "./StandardSchemaWebSocketClient";
+
+export type StandardSchemaWebSocketRpcSessionConstructorOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> = Omit<
+	StandardSchemaWebSocketClientOptions<TClientMsg, TServerMsg>,
+	"onMessage"
+> & {
+	onMessage: (
+		message: TServerMsg,
+		session: StandardSchemaWebSocketRpcSession<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>,
+	) => void;
+};
+
+/**
+ * WebSocket client session with a pending map for request/response RPC and a
+ * monotonic id helper. Wire formats stay in your Standard Schema schemas; you dispatch
+ * {@link TServerMsg} in `onMessage` (typically with `switch` + `exhaustiveGuard`)
+ * and resolve/reject entries in {@link pending}.
+ */
+export class StandardSchemaWebSocketRpcSession<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> {
+	readonly pending = new Map<string, TPending>();
+	readonly client: StandardSchemaWebSocketClient<TClientMsg, TServerMsg>;
+	private idSeq = 0;
+
+	constructor(
+		options: StandardSchemaWebSocketRpcSessionConstructorOptions<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>,
+	) {
+		const { onMessage, ...clientOptions } = options;
+		this.client = new StandardSchemaWebSocketClient({
+			...clientOptions,
+			onMessage: (message) => {
+				onMessage(message, this);
+			},
+		});
+	}
+
+	nextId(prefix: string): string {
+		return `${prefix}-${++this.idSeq}`;
+	}
+
+	rejectAllPending(reason: Error): void {
+		for (const [, pending] of this.pending) {
+			pending.reject(reason);
+		}
+		this.pending.clear();
+	}
+
+	close(code?: number, reason?: string): void {
+		this.client.close(code, reason);
+	}
+}
+
+export function createStandardSchemaWebSocketRpcSession<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+>(
+	options: StandardSchemaWebSocketRpcSessionConstructorOptions<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	>,
+): StandardSchemaWebSocketRpcSession<TClientMsg, TServerMsg, TPending> {
+	return new StandardSchemaWebSocketRpcSession(options);
+}

package/src/standardSchemaRpcReact.ts

@@ -0,0 +1,107 @@
+import type { DependencyList, RefObject } from "react";
+import { useEffect, useRef, useState } from "react";
+import {
+	type StandardSchemaWebSocketRpcSession,
+	type StandardSchemaWebSocketRpcSessionConstructorOptions,
+	createStandardSchemaWebSocketRpcSession,
+} from "./standardSchemaRpc";
+
+/** Options for {@link useStandardSchemaWebSocketRpc} (same as constructor options for {@link StandardSchemaWebSocketRpcSession}). */
+export type UseStandardSchemaWebSocketRpcOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+> = StandardSchemaWebSocketRpcSessionConstructorOptions<
+	TClientMsg,
+	TServerMsg,
+	TPending
+>;
+
+/**
+ * Connects a {@link StandardSchemaWebSocketRpcSession} in an effect: rejects all pending
+ * RPCs and closes the socket on cleanup or when `deps` change.
+ *
+ * Callback refs keep the latest `onMessage` / `onOpen` / `onClose` without
+ * listing them in `deps`, so inline handlers do not reconnect every render.
+ *
+ * Pass `deps` as the second argument; keep it aligned with values used to
+ * build `url` / `webSocket`.
+ */
+export function useStandardSchemaWebSocketRpc<
+	TClientMsg,
+	TServerMsg,
+	TPending extends { reject: (error: Error) => void },
+>(
+	options: UseStandardSchemaWebSocketRpcOptions<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	>,
+	deps: DependencyList,
+): {
+	ready: boolean;
+	sessionRef: RefObject<StandardSchemaWebSocketRpcSession<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	> | null>;
+} {
+	const { onMessage, onOpen, onClose, ...clientOptions } = options;
+
+	const onMessageRef = useRef(onMessage);
+	onMessageRef.current = onMessage;
+	const onOpenRef = useRef(onOpen);
+	onOpenRef.current = onOpen;
+	const onCloseRef = useRef(onClose);
+	onCloseRef.current = onClose;
+
+	const [ready, setReady] = useState(false);
+	const sessionRef = useRef<StandardSchemaWebSocketRpcSession<
+		TClientMsg,
+		TServerMsg,
+		TPending
+	> | null>(null);
+
+	useEffect(() => {
+		let cancelled = false;
+		setReady(false);
+
+		const session = createStandardSchemaWebSocketRpcSession<
+			TClientMsg,
+			TServerMsg,
+			TPending
+		>({
+			...clientOptions,
+			onMessage: (msg, s) => {
+				onMessageRef.current(msg, s);
+			},
+			onOpen: (event) => {
+				if (!cancelled) {
+					setReady(true);
+				}
+				onOpenRef.current?.(event);
+			},
+			onClose: (event) => {
+				if (!cancelled) {
+					setReady(false);
+				}
+				onCloseRef.current?.(event);
+			},
+		});
+
+		sessionRef.current = session;
+		if (session.client.socket.readyState === WebSocket.OPEN) {
+			setReady(true);
+		}
+
+		return () => {
+			cancelled = true;
+			sessionRef.current = null;
+			session.rejectAllPending(new Error("WebSocket closed"));
+			session.close();
+		};
+		// biome-ignore lint/correctness/useExhaustiveDependencies: deps is the explicit contract
+	}, deps);
+
+	return { ready, sessionRef };
+}

package/src/zodMsgpack.ts

@@ -1,13 +0,0 @@
-import { pack, unpack } from "msgpackr";
-import type { ZodType } from "zod";
-
-export const zodMsgpack = <T>(schema: ZodType<T>) => ({
-	encode(value: T): Uint8Array {
-		const validated = schema.parse(value);
-		const packed = pack(validated);
-		return new Uint8Array(packed);
-	},
-	decode(bytes: Uint8Array): T {
-		return schema.parse(unpack(bytes));
-	},
-});