react-websocket 3.6.0 → 4.18.0

package/dist/webtransport.cjs

@@ -0,0 +1,243 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/webtransport.ts
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+const TEXT = 0;
+const BINARY = 1;
+/** The method the client calls for `volatile` sends, where a socket has it. */
+const DATAGRAM = Symbol.for("react-websocket.datagram");
+function closeEvent(code, reason, wasClean) {
+	const init = {
+		code,
+		reason,
+		wasClean
+	};
+	return typeof CloseEvent === "function" ? new CloseEvent("close", init) : Object.assign(new Event("close"), init);
+}
+function bytes(data) {
+	if (typeof data === "string") return [TEXT, new TextEncoder().encode(data)];
+	if (data instanceof ArrayBuffer) return [BINARY, new Uint8Array(data)];
+	return [BINARY, new Uint8Array(data.buffer, data.byteOffset, data.byteLength)];
+}
+/**
+* Connect over [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)
+* behind the same client API. Pass the returned class as the `WebSocket` option: messages go on
+* one reliable, ordered stream, and `volatile` sends go as datagrams, which are never queued or
+* retransmitted, so stale input or cursor positions don't hold up what comes after them.
+*
+* Where WebTransport isn't available, or a session can't be established within `timeout`, it
+* connects with a WebSocket to the client's own URL instead, and keeps doing so for later
+* connections.
+*
+* The server speaks a small framing over WebTransport: see the guide.
+*
+* @example
+* ```ts
+* import { createWebTransportSocket } from 'react-websocket/webtransport';
+*
+* export const game = createWebSocket('wss://game.example.com/play', {
+*   json: true,
+*   WebSocket: createWebTransportSocket()
+* });
+*
+* game.send({ type: 'aim', angle }, { volatile: true }); // a datagram
+* ```
+*/
+function createWebTransportSocket(options = {}) {
+	const mapUrl = options.url ?? ((url) => url.replace(/^ws(s?):/, "https:"));
+	const timeout = options.timeout ?? 5e3;
+	let fallingBack = false;
+	class WebTransportSocket extends EventTarget {
+		static CONNECTING = CONNECTING;
+		static OPEN = OPEN;
+		static CLOSING = CLOSING;
+		static CLOSED = CLOSED;
+		CONNECTING = CONNECTING;
+		OPEN = OPEN;
+		CLOSING = CLOSING;
+		CLOSED = CLOSED;
+		url;
+		extensions = "";
+		onopen = null;
+		onmessage = null;
+		onerror = null;
+		onclose = null;
+		binaryType = "blob";
+		protocol = "";
+		#state = CONNECTING;
+		#transport;
+		#writer;
+		#datagrams;
+		#inner;
+		#buffered = 0;
+		#chain;
+		static get fallingBack() {
+			return fallingBack || typeof WebTransport !== "function";
+		}
+		constructor(url, protocols) {
+			super();
+			if (typeof window === "undefined") throw new Error("react-websocket/webtransport: no WebSocket here (server render?)");
+			for (const type of [
+				"open",
+				"message",
+				"error",
+				"close"
+			]) this.addEventListener(type, (event) => this[`on${type}`]?.call(this, event));
+			this.url = String(url);
+			if (fallingBack || typeof WebTransport !== "function") {
+				this.#fallBack(protocols);
+				return;
+			}
+			this.#connect(protocols);
+		}
+		get readyState() {
+			return this.#state;
+		}
+		get bufferedAmount() {
+			return this.#inner?.bufferedAmount ?? this.#buffered;
+		}
+		send(data) {
+			if (this.#state === CONNECTING) throw new DOMException("WebSocket is still in CONNECTING state", "InvalidStateError");
+			if (this.#state !== OPEN) return;
+			if (this.#inner) return this.#inner.send(data);
+			if (data instanceof Blob || this.#chain) {
+				const chain = (this.#chain ?? Promise.resolve()).then(async () => {
+					this.#write(...bytes(data instanceof Blob ? await data.arrayBuffer() : data));
+					if (this.#chain === chain) this.#chain = void 0;
+				});
+				this.#chain = chain;
+				return;
+			}
+			this.#write(...bytes(data));
+		}
+		/** A `volatile` send from the client: a datagram, unless it's too big for one. */
+		[DATAGRAM](data) {
+			const transport = this.#transport;
+			if (options.datagrams === false || this.#inner || !transport || data instanceof Blob || this.#state !== OPEN) return this.send(data);
+			const [type, payload] = bytes(data);
+			if (payload.byteLength + 1 > transport.datagrams.maxDatagramSize) return this.send(data);
+			const datagram = new Uint8Array(payload.byteLength + 1);
+			datagram[0] = type;
+			datagram.set(payload, 1);
+			this.#datagrams.write(datagram).catch(() => {});
+		}
+		close(code = 1e3, reason = "") {
+			if (this.#state >= CLOSING) return;
+			const connecting = this.#state === CONNECTING;
+			if (this.#inner) this.#inner.close(code, reason);
+			this.#state = CLOSING;
+			if (this.#inner) return;
+			if (!connecting) return this.#transport.close({
+				closeCode: code,
+				reason
+			});
+			this.#transport?.close();
+			setTimeout(() => this.#end(code, reason, true), 0);
+		}
+		async #connect(protocols) {
+			let transport;
+			let timer;
+			try {
+				transport = this.#transport = new WebTransport(mapUrl(this.url), options.transport);
+				await Promise.race([transport.ready, new Promise((_, reject) => timer = setTimeout(reject, timeout, /* @__PURE__ */ new Error("timeout")))]);
+				const stream = await transport.createBidirectionalStream();
+				if (this.#state !== CONNECTING) return transport.close();
+				this.#writer = stream.writable.getWriter();
+				this.#datagrams = transport.datagrams.writable.getWriter();
+				this.#read(stream.readable.getReader());
+				this.#readDatagrams(transport.datagrams.readable.getReader());
+			} catch {
+				this.#transport?.close();
+				this.#transport = void 0;
+				if (this.#state !== CONNECTING) return;
+				if (options.fallback === false) {
+					this.dispatchEvent(new Event("error"));
+					return this.#end(1006, "", false);
+				}
+				fallingBack = true;
+				return this.#fallBack(protocols);
+			} finally {
+				clearTimeout(timer);
+			}
+			transport.closed.then((info) => this.#end(info.closeCode || 1005, info.reason ?? "", true), () => {
+				this.dispatchEvent(new Event("error"));
+				this.#end(1006, "", false);
+			});
+			this.#state = OPEN;
+			this.dispatchEvent(new Event("open"));
+		}
+		#fallBack(protocols) {
+			const Impl = options.fallback === false ? void 0 : options.fallback ?? globalThis.WebSocket;
+			if (!Impl) throw new Error("react-websocket/webtransport: no WebTransport, and no fallback");
+			const inner = this.#inner = new Impl(this.url, protocols);
+			inner.binaryType = "arraybuffer";
+			inner.onopen = () => {
+				this.protocol = inner.protocol;
+				this.#state = OPEN;
+				this.dispatchEvent(new Event("open"));
+			};
+			inner.onmessage = (event) => this.#message(event.data);
+			inner.onerror = () => this.dispatchEvent(new Event("error"));
+			inner.onclose = (event) => this.#end(event.code, event.reason, event.wasClean);
+		}
+		#write(type, payload) {
+			const frame = new Uint8Array(payload.byteLength + 5);
+			const view = new DataView(frame.buffer);
+			view.setUint8(0, type);
+			view.setUint32(1, payload.byteLength);
+			frame.set(payload, 5);
+			this.#buffered += frame.byteLength;
+			this.#writer.write(frame).then(() => this.#buffered -= frame.byteLength, () => {});
+		}
+		/** Reassemble frames from the stream, whatever its chunks. */
+		async #read(reader) {
+			let buffer = /* @__PURE__ */ new Uint8Array(0);
+			try {
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) return;
+					const joined = new Uint8Array(buffer.byteLength + value.byteLength);
+					joined.set(buffer);
+					joined.set(value, buffer.byteLength);
+					buffer = joined;
+					while (buffer.byteLength >= 5) {
+						const view = new DataView(buffer.buffer, buffer.byteOffset);
+						const length = view.getUint32(1);
+						if (buffer.byteLength < 5 + length) break;
+						this.#frame(view.getUint8(0), buffer.slice(5, 5 + length));
+						buffer = buffer.slice(5 + length);
+					}
+				}
+			} catch {}
+		}
+		async #readDatagrams(reader) {
+			try {
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) return;
+					if (value.byteLength) this.#frame(value[0], value.slice(1));
+				}
+			} catch {}
+		}
+		#frame(type, payload) {
+			this.#message(type === TEXT ? new TextDecoder().decode(payload) : payload.buffer);
+		}
+		#message(data) {
+			if (this.#state !== OPEN) return;
+			if (data instanceof ArrayBuffer && this.binaryType === "blob") data = new Blob([data]);
+			this.dispatchEvent(new MessageEvent("message", { data }));
+		}
+		#end(code, reason, wasClean) {
+			if (this.#state === CLOSED) return;
+			this.#state = CLOSED;
+			this.dispatchEvent(closeEvent(code, reason, wasClean));
+		}
+	}
+	return WebTransportSocket;
+}
+//#endregion
+exports.createWebTransportSocket = createWebTransportSocket;
+
+//# sourceMappingURL=webtransport.cjs.map

package/dist/webtransport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webtransport.cjs","names":[],"sources":["../src/webtransport.ts"],"sourcesContent":["// An entry with no imports: it only implements the `WebSocket` interface.\n\n/** Options for {@link createWebTransportSocket}. */\nexport interface WebTransportSocketOptions {\n  /**\n   * The WebTransport URL for the client's WebSocket URL.\n   * @default `ws:` and `wss:` become `https:`\n   */\n  url?: (url: string) => string;\n  /** Options for the `WebTransport` constructor, e.g. `serverCertificateHashes` in development. */\n  transport?: WebTransportOptions;\n  /**\n   * The `WebSocket` to connect with where WebTransport isn't available, or when a session can't be\n   * established, to the client's own URL. `false` fails the connection instead.\n   * @default the global WebSocket\n   */\n  fallback?: typeof WebSocket | false;\n  /**\n   * How long to wait for a WebTransport session before falling back, in ms. UDP is blocked on\n   * some networks, where the attempt only fails after a long time.\n   * @default 5000\n   */\n  timeout?: number;\n  /**\n   * Send `volatile` messages as datagrams, which can be lost even while connected. `false` sends\n   * every message on the stream.\n   * @default true\n   */\n  datagrams?: boolean;\n}\n\n/** The class from {@link createWebTransportSocket}. */\nexport interface WebTransportWebSocket {\n  new (url: string | URL, protocols?: string | string[]): WebSocket;\n  readonly prototype: WebSocket;\n  readonly CONNECTING: 0;\n  readonly OPEN: 1;\n  readonly CLOSING: 2;\n  readonly CLOSED: 3;\n  /** Whether connections go over WebSocket now, because WebTransport is missing or failed. */\n  readonly fallingBack: boolean;\n}\n\nconst CONNECTING = 0;\nconst OPEN = 1;\nconst CLOSING = 2;\nconst CLOSED = 3;\nconst TEXT = 0;\nconst BINARY = 1;\n\n/** The method the client calls for `volatile` sends, where a socket has it. */\nconst DATAGRAM = Symbol.for('react-websocket.datagram');\n\ntype Data = Parameters<WebSocket['send']>[0];\n\nfunction closeEvent(code: number, reason: string, wasClean: boolean): Event {\n  const init = { code, reason, wasClean };\n  // Node 22 has no CloseEvent.\n  return typeof CloseEvent === 'function'\n    ? new CloseEvent('close', init)\n    : Object.assign(new Event('close'), init);\n}\n\nfunction bytes(data: Exclude<Data, Blob>): [number, Uint8Array] {\n  if (typeof data === 'string') return [TEXT, new TextEncoder().encode(data)];\n  if (data instanceof ArrayBuffer) return [BINARY, new Uint8Array(data)];\n  return [BINARY, new Uint8Array(data.buffer, data.byteOffset, data.byteLength)];\n}\n\n/**\n * Connect over [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)\n * behind the same client API. Pass the returned class as the `WebSocket` option: messages go on\n * one reliable, ordered stream, and `volatile` sends go as datagrams, which are never queued or\n * retransmitted, so stale input or cursor positions don't hold up what comes after them.\n *\n * Where WebTransport isn't available, or a session can't be established within `timeout`, it\n * connects with a WebSocket to the client's own URL instead, and keeps doing so for later\n * connections.\n *\n * The server speaks a small framing over WebTransport: see the guide.\n *\n * @example\n * ```ts\n * import { createWebTransportSocket } from 'react-websocket/webtransport';\n *\n * export const game = createWebSocket('wss://game.example.com/play', {\n *   json: true,\n *   WebSocket: createWebTransportSocket()\n * });\n *\n * game.send({ type: 'aim', angle }, { volatile: true }); // a datagram\n * ```\n */\nexport function createWebTransportSocket(\n  options: WebTransportSocketOptions = {}\n): WebTransportWebSocket {\n  const mapUrl = options.url ?? ((url: string) => url.replace(/^ws(s?):/, 'https:'));\n  const timeout = options.timeout ?? 5000;\n  let fallingBack = false;\n\n  class WebTransportSocket extends EventTarget implements WebSocket {\n    static readonly CONNECTING = CONNECTING;\n    static readonly OPEN = OPEN;\n    static readonly CLOSING = CLOSING;\n    static readonly CLOSED = CLOSED;\n    readonly CONNECTING = CONNECTING;\n    readonly OPEN = OPEN;\n    readonly CLOSING = CLOSING;\n    readonly CLOSED = CLOSED;\n\n    readonly url: string;\n    readonly extensions = '';\n    onopen: WebSocket['onopen'] = null;\n    onmessage: WebSocket['onmessage'] = null;\n    onerror: WebSocket['onerror'] = null;\n    onclose: WebSocket['onclose'] = null;\n    binaryType: BinaryType = 'blob';\n    protocol = '';\n\n    #state: WebSocket['readyState'] = CONNECTING;\n    #transport: WebTransport | undefined;\n    #writer: WritableStreamDefaultWriter<Uint8Array> | undefined;\n    #datagrams: WritableStreamDefaultWriter<Uint8Array> | undefined;\n    #inner: WebSocket | undefined;\n    // Bytes handed to the stream and not yet written, like `bufferedAmount`.\n    #buffered = 0;\n    // Sends waiting for a Blob to be read, so they keep their order.\n    #chain: Promise<void> | undefined;\n\n    static get fallingBack() {\n      return fallingBack || typeof WebTransport !== 'function';\n    }\n\n    constructor(url: string | URL, protocols?: string | string[]) {\n      super();\n      if (typeof window === 'undefined') {\n        throw new Error('react-websocket/webtransport: no WebSocket here (server render?)');\n      }\n      for (const type of ['open', 'message', 'error', 'close'] as const) {\n        this.addEventListener(type, event =>\n          (this[`on${type}`] as ((event: Event) => void) | null)?.call(this, event)\n        );\n      }\n      this.url = String(url);\n      if (fallingBack || typeof WebTransport !== 'function') {\n        this.#fallBack(protocols);\n        return;\n      }\n      void this.#connect(protocols);\n    }\n\n    get readyState() {\n      return this.#state;\n    }\n\n    get bufferedAmount() {\n      return this.#inner?.bufferedAmount ?? this.#buffered;\n    }\n\n    send(data: Data) {\n      if (this.#state === CONNECTING) {\n        throw new DOMException('WebSocket is still in CONNECTING state', 'InvalidStateError');\n      }\n      if (this.#state !== OPEN) return;\n      if (this.#inner) return this.#inner.send(data);\n      if (data instanceof Blob || this.#chain) {\n        const chain = (this.#chain ?? Promise.resolve()).then(async () => {\n          this.#write(...bytes(data instanceof Blob ? await data.arrayBuffer() : data));\n          if (this.#chain === chain) this.#chain = undefined;\n        });\n        this.#chain = chain;\n        return;\n      }\n      this.#write(...bytes(data));\n    }\n\n    /** A `volatile` send from the client: a datagram, unless it's too big for one. */\n    [DATAGRAM](data: Data) {\n      const transport = this.#transport;\n      if (\n        options.datagrams === false ||\n        this.#inner ||\n        !transport ||\n        data instanceof Blob ||\n        this.#state !== OPEN\n      ) {\n        return this.send(data);\n      }\n      const [type, payload] = bytes(data);\n      if (payload.byteLength + 1 > transport.datagrams.maxDatagramSize) return this.send(data);\n      const datagram = new Uint8Array(payload.byteLength + 1);\n      datagram[0] = type;\n      datagram.set(payload, 1);\n      this.#datagrams!.write(datagram).catch(() => {});\n    }\n\n    close(code = 1000, reason = '') {\n      if (this.#state >= CLOSING) return;\n      const connecting = this.#state === CONNECTING;\n      // First, so that a code the socket rejects throws before anything has changed.\n      if (this.#inner) this.#inner.close(code, reason);\n      this.#state = CLOSING;\n      if (this.#inner) return;\n      if (!connecting) return this.#transport!.close({ closeCode: code, reason });\n      // Not open yet: give up on the session, and report this close rather than its failure.\n      this.#transport?.close();\n      setTimeout(() => this.#end(code, reason, true), 0);\n    }\n\n    async #connect(protocols: string | string[] | undefined) {\n      let transport: WebTransport;\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      try {\n        transport = this.#transport = new WebTransport(mapUrl(this.url), options.transport);\n        await Promise.race([\n          transport.ready,\n          new Promise((_, reject) => (timer = setTimeout(reject, timeout, new Error('timeout'))))\n        ]);\n        const stream = await transport.createBidirectionalStream();\n        if (this.#state !== CONNECTING) return transport.close();\n        this.#writer = stream.writable.getWriter();\n        this.#datagrams = transport.datagrams.writable.getWriter();\n        void this.#read(stream.readable.getReader());\n        void this.#readDatagrams(transport.datagrams.readable.getReader());\n      } catch {\n        // No session: fall back to a WebSocket for this connection and the ones after it.\n        this.#transport?.close();\n        this.#transport = undefined;\n        // Closed while connecting: `close()` reports its own code.\n        if (this.#state !== CONNECTING) return;\n        if (options.fallback === false) {\n          this.dispatchEvent(new Event('error'));\n          return this.#end(1006, '', false);\n        }\n        fallingBack = true;\n        return this.#fallBack(protocols);\n      } finally {\n        clearTimeout(timer);\n      }\n      transport.closed.then(\n        // A session ended without a code reports 0: like a WebSocket closed without a status.\n        info => this.#end(info.closeCode || 1005, info.reason ?? '', true),\n        () => {\n          this.dispatchEvent(new Event('error'));\n          this.#end(1006, '', false);\n        }\n      );\n      this.#state = OPEN;\n      this.dispatchEvent(new Event('open'));\n    }\n\n    #fallBack(protocols: string | string[] | undefined) {\n      const Impl =\n        options.fallback === false ? undefined : (options.fallback ?? globalThis.WebSocket);\n      if (!Impl) {\n        throw new Error('react-websocket/webtransport: no WebTransport, and no fallback');\n      }\n      const inner = (this.#inner = new Impl(this.url, protocols));\n      inner.binaryType = 'arraybuffer';\n      inner.onopen = () => {\n        this.protocol = inner.protocol;\n        this.#state = OPEN;\n        this.dispatchEvent(new Event('open'));\n      };\n      inner.onmessage = event => this.#message(event.data);\n      inner.onerror = () => this.dispatchEvent(new Event('error'));\n      inner.onclose = event => this.#end(event.code, event.reason, event.wasClean);\n    }\n\n    #write(type: number, payload: Uint8Array) {\n      const frame = new Uint8Array(payload.byteLength + 5);\n      const view = new DataView(frame.buffer);\n      view.setUint8(0, type);\n      view.setUint32(1, payload.byteLength);\n      frame.set(payload, 5);\n      this.#buffered += frame.byteLength;\n      this.#writer!.write(frame).then(\n        () => (this.#buffered -= frame.byteLength),\n        () => {}\n      );\n    }\n\n    /** Reassemble frames from the stream, whatever its chunks. */\n    async #read(reader: ReadableStreamDefaultReader<Uint8Array>) {\n      let buffer = new Uint8Array(0);\n      try {\n        for (;;) {\n          const { value, done } = await reader.read();\n          if (done) return;\n          const joined = new Uint8Array(buffer.byteLength + value.byteLength);\n          joined.set(buffer);\n          joined.set(value, buffer.byteLength);\n          buffer = joined;\n          while (buffer.byteLength >= 5) {\n            const view = new DataView(buffer.buffer, buffer.byteOffset);\n            const length = view.getUint32(1);\n            if (buffer.byteLength < 5 + length) break;\n            this.#frame(view.getUint8(0), buffer.slice(5, 5 + length));\n            buffer = buffer.slice(5 + length);\n          }\n        }\n      } catch {\n        // The session closed; `closed` reports it.\n      }\n    }\n\n    async #readDatagrams(reader: ReadableStreamDefaultReader<Uint8Array>) {\n      try {\n        for (;;) {\n          const { value, done } = await reader.read();\n          if (done) return;\n          if (value.byteLength) this.#frame(value[0]!, value.slice(1));\n        }\n      } catch {\n        // The session closed; `closed` reports it.\n      }\n    }\n\n    #frame(type: number, payload: Uint8Array) {\n      this.#message(type === TEXT ? new TextDecoder().decode(payload) : payload.buffer);\n    }\n\n    #message(data: unknown) {\n      if (this.#state !== OPEN) return;\n      if (data instanceof ArrayBuffer && this.binaryType === 'blob') data = new Blob([data]);\n      this.dispatchEvent(new MessageEvent('message', { data }));\n    }\n\n    #end(code: number, reason: string, wasClean: boolean) {\n      if (this.#state === CLOSED) return;\n      this.#state = CLOSED;\n      this.dispatchEvent(closeEvent(code, reason, wasClean));\n    }\n  }\n\n  return WebTransportSocket as unknown as WebTransportWebSocket;\n}\n"],"mappings":"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"}

package/dist/webtransport.d.cts

@@ -0,0 +1,67 @@
+//#region src/webtransport.d.ts
+/** Options for {@link createWebTransportSocket}. */
+export interface WebTransportSocketOptions {
+  /**
+   * The WebTransport URL for the client's WebSocket URL.
+   * @default `ws:` and `wss:` become `https:`
+   */
+  url?: (url: string) => string;
+  /** Options for the `WebTransport` constructor, e.g. `serverCertificateHashes` in development. */
+  transport?: WebTransportOptions;
+  /**
+   * The `WebSocket` to connect with where WebTransport isn't available, or when a session can't be
+   * established, to the client's own URL. `false` fails the connection instead.
+   * @default the global WebSocket
+   */
+  fallback?: typeof WebSocket | false;
+  /**
+   * How long to wait for a WebTransport session before falling back, in ms. UDP is blocked on
+   * some networks, where the attempt only fails after a long time.
+   * @default 5000
+   */
+  timeout?: number;
+  /**
+   * Send `volatile` messages as datagrams, which can be lost even while connected. `false` sends
+   * every message on the stream.
+   * @default true
+   */
+  datagrams?: boolean;
+}
+/** The class from {@link createWebTransportSocket}. */
+export interface WebTransportWebSocket {
+  new (url: string | URL, protocols?: string | string[]): WebSocket;
+  readonly prototype: WebSocket;
+  readonly CONNECTING: 0;
+  readonly OPEN: 1;
+  readonly CLOSING: 2;
+  readonly CLOSED: 3;
+  /** Whether connections go over WebSocket now, because WebTransport is missing or failed. */
+  readonly fallingBack: boolean;
+}
+/**
+ * Connect over [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)
+ * behind the same client API. Pass the returned class as the `WebSocket` option: messages go on
+ * one reliable, ordered stream, and `volatile` sends go as datagrams, which are never queued or
+ * retransmitted, so stale input or cursor positions don't hold up what comes after them.
+ *
+ * Where WebTransport isn't available, or a session can't be established within `timeout`, it
+ * connects with a WebSocket to the client's own URL instead, and keeps doing so for later
+ * connections.
+ *
+ * The server speaks a small framing over WebTransport: see the guide.
+ *
+ * @example
+ * ```ts
+ * import { createWebTransportSocket } from 'react-websocket/webtransport';
+ *
+ * export const game = createWebSocket('wss://game.example.com/play', {
+ *   json: true,
+ *   WebSocket: createWebTransportSocket()
+ * });
+ *
+ * game.send({ type: 'aim', angle }, { volatile: true }); // a datagram
+ * ```
+ */
+export declare function createWebTransportSocket(options?: WebTransportSocketOptions): WebTransportWebSocket;
+//#endregion
+//# sourceMappingURL=webtransport.d.cts.map

package/dist/webtransport.d.ts

@@ -0,0 +1,67 @@
+//#region src/webtransport.d.ts
+/** Options for {@link createWebTransportSocket}. */
+export interface WebTransportSocketOptions {
+  /**
+   * The WebTransport URL for the client's WebSocket URL.
+   * @default `ws:` and `wss:` become `https:`
+   */
+  url?: (url: string) => string;
+  /** Options for the `WebTransport` constructor, e.g. `serverCertificateHashes` in development. */
+  transport?: WebTransportOptions;
+  /**
+   * The `WebSocket` to connect with where WebTransport isn't available, or when a session can't be
+   * established, to the client's own URL. `false` fails the connection instead.
+   * @default the global WebSocket
+   */
+  fallback?: typeof WebSocket | false;
+  /**
+   * How long to wait for a WebTransport session before falling back, in ms. UDP is blocked on
+   * some networks, where the attempt only fails after a long time.
+   * @default 5000
+   */
+  timeout?: number;
+  /**
+   * Send `volatile` messages as datagrams, which can be lost even while connected. `false` sends
+   * every message on the stream.
+   * @default true
+   */
+  datagrams?: boolean;
+}
+/** The class from {@link createWebTransportSocket}. */
+export interface WebTransportWebSocket {
+  new (url: string | URL, protocols?: string | string[]): WebSocket;
+  readonly prototype: WebSocket;
+  readonly CONNECTING: 0;
+  readonly OPEN: 1;
+  readonly CLOSING: 2;
+  readonly CLOSED: 3;
+  /** Whether connections go over WebSocket now, because WebTransport is missing or failed. */
+  readonly fallingBack: boolean;
+}
+/**
+ * Connect over [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)
+ * behind the same client API. Pass the returned class as the `WebSocket` option: messages go on
+ * one reliable, ordered stream, and `volatile` sends go as datagrams, which are never queued or
+ * retransmitted, so stale input or cursor positions don't hold up what comes after them.
+ *
+ * Where WebTransport isn't available, or a session can't be established within `timeout`, it
+ * connects with a WebSocket to the client's own URL instead, and keeps doing so for later
+ * connections.
+ *
+ * The server speaks a small framing over WebTransport: see the guide.
+ *
+ * @example
+ * ```ts
+ * import { createWebTransportSocket } from 'react-websocket/webtransport';
+ *
+ * export const game = createWebSocket('wss://game.example.com/play', {
+ *   json: true,
+ *   WebSocket: createWebTransportSocket()
+ * });
+ *
+ * game.send({ type: 'aim', angle }, { volatile: true }); // a datagram
+ * ```
+ */
+export declare function createWebTransportSocket(options?: WebTransportSocketOptions): WebTransportWebSocket;
+//#endregion
+//# sourceMappingURL=webtransport.d.ts.map

package/dist/webtransport.js

@@ -0,0 +1,242 @@
+//#region src/webtransport.ts
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+const TEXT = 0;
+const BINARY = 1;
+/** The method the client calls for `volatile` sends, where a socket has it. */
+const DATAGRAM = Symbol.for("react-websocket.datagram");
+function closeEvent(code, reason, wasClean) {
+	const init = {
+		code,
+		reason,
+		wasClean
+	};
+	return typeof CloseEvent === "function" ? new CloseEvent("close", init) : Object.assign(new Event("close"), init);
+}
+function bytes(data) {
+	if (typeof data === "string") return [TEXT, new TextEncoder().encode(data)];
+	if (data instanceof ArrayBuffer) return [BINARY, new Uint8Array(data)];
+	return [BINARY, new Uint8Array(data.buffer, data.byteOffset, data.byteLength)];
+}
+/**
+* Connect over [WebTransport](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)
+* behind the same client API. Pass the returned class as the `WebSocket` option: messages go on
+* one reliable, ordered stream, and `volatile` sends go as datagrams, which are never queued or
+* retransmitted, so stale input or cursor positions don't hold up what comes after them.
+*
+* Where WebTransport isn't available, or a session can't be established within `timeout`, it
+* connects with a WebSocket to the client's own URL instead, and keeps doing so for later
+* connections.
+*
+* The server speaks a small framing over WebTransport: see the guide.
+*
+* @example
+* ```ts
+* import { createWebTransportSocket } from 'react-websocket/webtransport';
+*
+* export const game = createWebSocket('wss://game.example.com/play', {
+*   json: true,
+*   WebSocket: createWebTransportSocket()
+* });
+*
+* game.send({ type: 'aim', angle }, { volatile: true }); // a datagram
+* ```
+*/
+function createWebTransportSocket(options = {}) {
+	const mapUrl = options.url ?? ((url) => url.replace(/^ws(s?):/, "https:"));
+	const timeout = options.timeout ?? 5e3;
+	let fallingBack = false;
+	class WebTransportSocket extends EventTarget {
+		static CONNECTING = CONNECTING;
+		static OPEN = OPEN;
+		static CLOSING = CLOSING;
+		static CLOSED = CLOSED;
+		CONNECTING = CONNECTING;
+		OPEN = OPEN;
+		CLOSING = CLOSING;
+		CLOSED = CLOSED;
+		url;
+		extensions = "";
+		onopen = null;
+		onmessage = null;
+		onerror = null;
+		onclose = null;
+		binaryType = "blob";
+		protocol = "";
+		#state = CONNECTING;
+		#transport;
+		#writer;
+		#datagrams;
+		#inner;
+		#buffered = 0;
+		#chain;
+		static get fallingBack() {
+			return fallingBack || typeof WebTransport !== "function";
+		}
+		constructor(url, protocols) {
+			super();
+			if (typeof window === "undefined") throw new Error("react-websocket/webtransport: no WebSocket here (server render?)");
+			for (const type of [
+				"open",
+				"message",
+				"error",
+				"close"
+			]) this.addEventListener(type, (event) => this[`on${type}`]?.call(this, event));
+			this.url = String(url);
+			if (fallingBack || typeof WebTransport !== "function") {
+				this.#fallBack(protocols);
+				return;
+			}
+			this.#connect(protocols);
+		}
+		get readyState() {
+			return this.#state;
+		}
+		get bufferedAmount() {
+			return this.#inner?.bufferedAmount ?? this.#buffered;
+		}
+		send(data) {
+			if (this.#state === CONNECTING) throw new DOMException("WebSocket is still in CONNECTING state", "InvalidStateError");
+			if (this.#state !== OPEN) return;
+			if (this.#inner) return this.#inner.send(data);
+			if (data instanceof Blob || this.#chain) {
+				const chain = (this.#chain ?? Promise.resolve()).then(async () => {
+					this.#write(...bytes(data instanceof Blob ? await data.arrayBuffer() : data));
+					if (this.#chain === chain) this.#chain = void 0;
+				});
+				this.#chain = chain;
+				return;
+			}
+			this.#write(...bytes(data));
+		}
+		/** A `volatile` send from the client: a datagram, unless it's too big for one. */
+		[DATAGRAM](data) {
+			const transport = this.#transport;
+			if (options.datagrams === false || this.#inner || !transport || data instanceof Blob || this.#state !== OPEN) return this.send(data);
+			const [type, payload] = bytes(data);
+			if (payload.byteLength + 1 > transport.datagrams.maxDatagramSize) return this.send(data);
+			const datagram = new Uint8Array(payload.byteLength + 1);
+			datagram[0] = type;
+			datagram.set(payload, 1);
+			this.#datagrams.write(datagram).catch(() => {});
+		}
+		close(code = 1e3, reason = "") {
+			if (this.#state >= CLOSING) return;
+			const connecting = this.#state === CONNECTING;
+			if (this.#inner) this.#inner.close(code, reason);
+			this.#state = CLOSING;
+			if (this.#inner) return;
+			if (!connecting) return this.#transport.close({
+				closeCode: code,
+				reason
+			});
+			this.#transport?.close();
+			setTimeout(() => this.#end(code, reason, true), 0);
+		}
+		async #connect(protocols) {
+			let transport;
+			let timer;
+			try {
+				transport = this.#transport = new WebTransport(mapUrl(this.url), options.transport);
+				await Promise.race([transport.ready, new Promise((_, reject) => timer = setTimeout(reject, timeout, /* @__PURE__ */ new Error("timeout")))]);
+				const stream = await transport.createBidirectionalStream();
+				if (this.#state !== CONNECTING) return transport.close();
+				this.#writer = stream.writable.getWriter();
+				this.#datagrams = transport.datagrams.writable.getWriter();
+				this.#read(stream.readable.getReader());
+				this.#readDatagrams(transport.datagrams.readable.getReader());
+			} catch {
+				this.#transport?.close();
+				this.#transport = void 0;
+				if (this.#state !== CONNECTING) return;
+				if (options.fallback === false) {
+					this.dispatchEvent(new Event("error"));
+					return this.#end(1006, "", false);
+				}
+				fallingBack = true;
+				return this.#fallBack(protocols);
+			} finally {
+				clearTimeout(timer);
+			}
+			transport.closed.then((info) => this.#end(info.closeCode || 1005, info.reason ?? "", true), () => {
+				this.dispatchEvent(new Event("error"));
+				this.#end(1006, "", false);
+			});
+			this.#state = OPEN;
+			this.dispatchEvent(new Event("open"));
+		}
+		#fallBack(protocols) {
+			const Impl = options.fallback === false ? void 0 : options.fallback ?? globalThis.WebSocket;
+			if (!Impl) throw new Error("react-websocket/webtransport: no WebTransport, and no fallback");
+			const inner = this.#inner = new Impl(this.url, protocols);
+			inner.binaryType = "arraybuffer";
+			inner.onopen = () => {
+				this.protocol = inner.protocol;
+				this.#state = OPEN;
+				this.dispatchEvent(new Event("open"));
+			};
+			inner.onmessage = (event) => this.#message(event.data);
+			inner.onerror = () => this.dispatchEvent(new Event("error"));
+			inner.onclose = (event) => this.#end(event.code, event.reason, event.wasClean);
+		}
+		#write(type, payload) {
+			const frame = new Uint8Array(payload.byteLength + 5);
+			const view = new DataView(frame.buffer);
+			view.setUint8(0, type);
+			view.setUint32(1, payload.byteLength);
+			frame.set(payload, 5);
+			this.#buffered += frame.byteLength;
+			this.#writer.write(frame).then(() => this.#buffered -= frame.byteLength, () => {});
+		}
+		/** Reassemble frames from the stream, whatever its chunks. */
+		async #read(reader) {
+			let buffer = /* @__PURE__ */ new Uint8Array(0);
+			try {
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) return;
+					const joined = new Uint8Array(buffer.byteLength + value.byteLength);
+					joined.set(buffer);
+					joined.set(value, buffer.byteLength);
+					buffer = joined;
+					while (buffer.byteLength >= 5) {
+						const view = new DataView(buffer.buffer, buffer.byteOffset);
+						const length = view.getUint32(1);
+						if (buffer.byteLength < 5 + length) break;
+						this.#frame(view.getUint8(0), buffer.slice(5, 5 + length));
+						buffer = buffer.slice(5 + length);
+					}
+				}
+			} catch {}
+		}
+		async #readDatagrams(reader) {
+			try {
+				for (;;) {
+					const { value, done } = await reader.read();
+					if (done) return;
+					if (value.byteLength) this.#frame(value[0], value.slice(1));
+				}
+			} catch {}
+		}
+		#frame(type, payload) {
+			this.#message(type === TEXT ? new TextDecoder().decode(payload) : payload.buffer);
+		}
+		#message(data) {
+			if (this.#state !== OPEN) return;
+			if (data instanceof ArrayBuffer && this.binaryType === "blob") data = new Blob([data]);
+			this.dispatchEvent(new MessageEvent("message", { data }));
+		}
+		#end(code, reason, wasClean) {
+			if (this.#state === CLOSED) return;
+			this.#state = CLOSED;
+			this.dispatchEvent(closeEvent(code, reason, wasClean));
+		}
+	}
+	return WebTransportSocket;
+}
+//#endregion
+export { createWebTransportSocket };
+
+//# sourceMappingURL=webtransport.js.map