crossws 0.4.2 → 0.4.4

package/dist/adapters/sse.mjs

@@ -1,122 +1,102 @@
-import { M as Message, P as Peer, a as toString } from '../shared/crossws.WpyOHUXc.mjs';
-import { a as adapterUtils, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
+import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
+import { i as toString, n as Message, t as Peer } from "../_chunks/peer.mjs";
 
+//#region src/adapters/sse.ts
 const sseAdapter = (opts = {}) => {
-  const hooks = new AdapterHookable(opts);
-  const globalPeers = /* @__PURE__ */ new Map();
-  const peersMap = opts.bidir ? /* @__PURE__ */ new Map() : void 0;
-  return {
-    ...adapterUtils(globalPeers),
-    fetch: async (request) => {
-      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
-      if (endResponse) {
-        return endResponse;
-      }
-      let peer;
-      if (opts.bidir && request.body && request.headers.has("x-crossws-id")) {
-        const id = request.headers.get("x-crossws-id");
-        peer = peersMap?.get(id);
-        if (!peer) {
-          return new Response("invalid peer id", { status: 400 });
-        }
-        const stream = request.body.pipeThrough(new TextDecoderStream());
-        try {
-          for await (const chunk of stream) {
-            hooks.callHook("message", peer, new Message(chunk, peer));
-          }
-        } catch {
-          await stream.cancel().catch(() => {
-          });
-        }
-        return new Response(null, {});
-      } else {
-        const ws = new SSEWebSocketStub();
-        const peers = getPeers(globalPeers, namespace);
-        peer = new SSEPeer({
-          peers,
-          peersMap,
-          request,
-          hooks,
-          ws,
-          context,
-          namespace
-        });
-        peers.add(peer);
-        if (opts.bidir) {
-          peersMap.set(peer.id, peer);
-          peer._sendEvent("crossws-id", peer.id);
-        }
-      }
-      let headers = {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
-      };
-      if (opts.bidir) {
-        headers["x-crossws-id"] = peer.id;
-      }
-      if (upgradeHeaders) {
-        headers = new Headers(headers);
-        for (const [key, value] of new Headers(upgradeHeaders)) {
-          headers.set(key, value);
-        }
-      }
-      return new Response(peer._sseStream, { headers });
-    }
-  };
+	const hooks = new AdapterHookable(opts);
+	const globalPeers = /* @__PURE__ */ new Map();
+	const peersMap = opts.bidir ? /* @__PURE__ */ new Map() : void 0;
+	return {
+		...adapterUtils(globalPeers),
+		fetch: async (request) => {
+			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
+			if (endResponse) return endResponse;
+			let peer;
+			if (opts.bidir && request.body && request.headers.has("x-crossws-id")) {
+				const id = request.headers.get("x-crossws-id");
+				peer = peersMap?.get(id);
+				if (!peer) return new Response("invalid peer id", { status: 400 });
+				const stream = request.body.pipeThrough(new TextDecoderStream());
+				try {
+					for await (const chunk of stream) hooks.callHook("message", peer, new Message(chunk, peer));
+				} catch {
+					await stream.cancel().catch(() => {});
+				}
+				return new Response(null, {});
+			} else {
+				const ws = new SSEWebSocketStub();
+				const peers = getPeers(globalPeers, namespace);
+				peer = new SSEPeer({
+					peers,
+					peersMap,
+					request,
+					hooks,
+					ws,
+					context,
+					namespace
+				});
+				peers.add(peer);
+				if (opts.bidir) {
+					peersMap.set(peer.id, peer);
+					peer._sendEvent("crossws-id", peer.id);
+				}
+			}
+			let headers = {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive"
+			};
+			if (opts.bidir) headers["x-crossws-id"] = peer.id;
+			if (upgradeHeaders) {
+				headers = new Headers(headers);
+				for (const [key, value] of new Headers(upgradeHeaders)) headers.set(key, value);
+			}
+			return new Response(peer._sseStream, { headers });
+		}
+	};
+};
+var sse_default = sseAdapter;
+var SSEPeer = class extends Peer {
+	_sseStream;
+	_sseStreamController;
+	constructor(_internal) {
+		super(_internal);
+		_internal.ws.readyState = 0;
+		this._sseStream = new ReadableStream({
+			start: (controller) => {
+				_internal.ws.readyState = 1;
+				this._sseStreamController = controller;
+				_internal.hooks.callHook("open", this);
+			},
+			cancel: () => {
+				_internal.ws.readyState = 2;
+				_internal.peers.delete(this);
+				_internal.peersMap?.delete(this.id);
+				Promise.resolve(this._internal.hooks.callHook("close", this)).finally(() => {
+					_internal.ws.readyState = 3;
+				});
+			}
+		}).pipeThrough(new TextEncoderStream());
+	}
+	_sendEvent(event, data) {
+		const lines = data.split("\n");
+		this._sseStreamController?.enqueue(`event: ${event}\n${lines.map((l) => `data: ${l}`)}\n\n`);
+	}
+	send(data) {
+		this._sendEvent("message", toString(data));
+		return 0;
+	}
+	publish(topic, data) {
+		const dataBuff = toString(data);
+		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._sendEvent("message", dataBuff);
+	}
+	close() {
+		this._sseStreamController?.close();
+	}
+};
+var SSEWebSocketStub = class {
+	readyState;
 };
-class SSEPeer extends Peer {
-  _sseStream;
-  // server -> client
-  _sseStreamController;
-  constructor(_internal) {
-    super(_internal);
-    _internal.ws.readyState = 0;
-    this._sseStream = new ReadableStream({
-      start: (controller) => {
-        _internal.ws.readyState = 1;
-        this._sseStreamController = controller;
-        _internal.hooks.callHook("open", this);
-      },
-      cancel: () => {
-        _internal.ws.readyState = 2;
-        _internal.peers.delete(this);
-        _internal.peersMap?.delete(this.id);
-        Promise.resolve(this._internal.hooks.callHook("close", this)).finally(
-          () => {
-            _internal.ws.readyState = 3;
-          }
-        );
-      }
-    }).pipeThrough(new TextEncoderStream());
-  }
-  _sendEvent(event, data) {
-    const lines = data.split("\n");
-    this._sseStreamController?.enqueue(
-      `event: ${event}
-${lines.map((l) => `data: ${l}`)}
-
-`
-    );
-  }
-  send(data) {
-    this._sendEvent("message", toString(data));
-    return 0;
-  }
-  publish(topic, data) {
-    const dataBuff = toString(data);
-    for (const peer of this._internal.peers) {
-      if (peer !== this && peer._topics.has(topic)) {
-        peer._sendEvent("message", dataBuff);
-      }
-    }
-  }
-  close() {
-    this._sseStreamController?.close();
-  }
-}
-class SSEWebSocketStub {
-  readyState;
-}
 
-export { sseAdapter as default };
+//#endregion
+export { sse_default as default };

package/dist/adapters/uws.d.mts

@@ -1,62 +1,62 @@
-import { Adapter, AdapterInstance, Peer, PeerContext, AdapterOptions } from '../index.mjs';
-import { W as WebSocket } from '../shared/crossws.BQXMA5bH.mjs';
-import uws from 'uWebSockets.js';
+import { d as PeerContext, n as AdapterInstance, r as AdapterOptions, t as Adapter, u as Peer } from "../_chunks/adapter.mjs";
+import { a as WebSocket } from "../_chunks/web.mjs";
+import uws from "uWebSockets.js";
 
+//#region src/_request.d.ts
 declare const StubRequest: {
-    new (url: string, init?: RequestInit): Request;
+  new (url: string, init?: RequestInit): Request;
 };
-
+//#endregion
+//#region src/adapters/uws.d.ts
 type UserData = {
-    peer?: UWSPeer;
-    req: uws.HttpRequest;
-    res: uws.HttpResponse;
-    webReq: UWSReqProxy;
-    protocol: string;
-    extensions: string;
-    context: PeerContext;
-    namespace: string;
+  peer?: UWSPeer;
+  req: uws.HttpRequest;
+  res: uws.HttpResponse;
+  webReq: UWSReqProxy;
+  protocol: string;
+  extensions: string;
+  context: PeerContext;
+  namespace: string;
 };
 type WebSocketHandler = uws.WebSocketBehavior<UserData>;
 interface UWSAdapter extends AdapterInstance {
-    websocket: WebSocketHandler;
+  websocket: WebSocketHandler;
 }
 interface UWSOptions extends AdapterOptions {
-    uws?: Exclude<uws.WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+  uws?: Exclude<uws.WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
 }
 declare const uwsAdapter: Adapter<UWSAdapter, UWSOptions>;
-
 declare class UWSPeer extends Peer<{
-    peers: Set<UWSPeer>;
-    request: UWSReqProxy;
-    namespace: string;
-    uws: uws.WebSocket<UserData>;
-    ws: UwsWebSocketProxy;
-    uwsData: UserData;
+  peers: Set<UWSPeer>;
+  request: UWSReqProxy;
+  namespace: string;
+  uws: uws.WebSocket<UserData>;
+  ws: UwsWebSocketProxy;
+  uwsData: UserData;
 }> {
-    get remoteAddress(): string | undefined;
-    get context(): PeerContext;
-    send(data: unknown, options?: {
-        compress?: boolean;
-    }): number;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    publish(topic: string, message: string, options?: {
-        compress?: boolean;
-    }): number;
-    close(code?: number, reason?: uws.RecognizedString): void;
-    terminate(): void;
+  get remoteAddress(): string | undefined;
+  get context(): PeerContext;
+  send(data: unknown, options?: {
+    compress?: boolean;
+  }): number;
+  subscribe(topic: string): void;
+  unsubscribe(topic: string): void;
+  publish(topic: string, message: string, options?: {
+    compress?: boolean;
+  }): number;
+  close(code?: number, reason?: uws.RecognizedString): void;
+  terminate(): void;
 }
 declare class UWSReqProxy extends StubRequest {
-    constructor(req: uws.HttpRequest);
+  constructor(req: uws.HttpRequest);
 }
 declare class UwsWebSocketProxy implements Partial<WebSocket> {
-    private _uws;
-    readyState?: number;
-    constructor(_uws: uws.WebSocket<UserData>);
-    get bufferedAmount(): number;
-    get protocol(): string;
-    get extensions(): string;
+  private _uws;
+  readyState?: number;
+  constructor(_uws: uws.WebSocket<UserData>);
+  get bufferedAmount(): number;
+  get protocol(): string;
+  get extensions(): string;
 }
-
-export { uwsAdapter as default };
-export type { UWSAdapter, UWSOptions };
+//#endregion
+export { UWSAdapter, UWSOptions, uwsAdapter as default };

package/dist/adapters/uws.mjs

@@ -1,181 +1,158 @@
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
-import { a as adapterUtils, A as AdapterHookable, g as getPeers } from '../shared/crossws.CPlNx7g8.mjs';
-import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
+import { i as AdapterHookable, r as getPeers, t as adapterUtils } from "../_chunks/adapter.mjs";
+import { n as Message, r as toBufferLike, t as Peer } from "../_chunks/peer.mjs";
+import { t as StubRequest } from "../_chunks/_request.mjs";
 
+//#region src/adapters/uws.ts
 const uwsAdapter = (options = {}) => {
-  const hooks = new AdapterHookable(options);
-  const globalPeers = /* @__PURE__ */ new Map();
-  return {
-    ...adapterUtils(globalPeers),
-    websocket: {
-      ...options.uws,
-      close(ws, code, message) {
-        const peers = getPeers(globalPeers, ws.getUserData().namespace);
-        const peer = getPeer(ws, peers);
-        peer._internal.ws.readyState = 2;
-        peers.delete(peer);
-        hooks.callHook("close", peer, {
-          code,
-          reason: message?.toString()
-        });
-        peer._internal.ws.readyState = 3;
-      },
-      message(ws, message, isBinary) {
-        const peers = getPeers(globalPeers, ws.getUserData().namespace);
-        const peer = getPeer(ws, peers);
-        hooks.callHook("message", peer, new Message(message, peer));
-      },
-      open(ws) {
-        const peers = getPeers(globalPeers, ws.getUserData().namespace);
-        const peer = getPeer(ws, peers);
-        peers.add(peer);
-        hooks.callHook("open", peer);
-      },
-      async upgrade(res, req, uwsContext) {
-        let aborted = false;
-        res.onAborted(() => {
-          aborted = true;
-        });
-        const webReq = new UWSReqProxy(req);
-        const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(webReq);
-        if (endResponse) {
-          res.writeStatus(`${endResponse.status} ${endResponse.statusText}`);
-          for (const [key, value] of endResponse.headers) {
-            res.writeHeader(key, value);
-          }
-          if (endResponse.body) {
-            for await (const chunk of endResponse.body) {
-              if (aborted) break;
-              res.write(chunk);
-            }
-          }
-          if (!aborted) {
-            res.end();
-          }
-          return;
-        }
-        if (aborted) {
-          return;
-        }
-        res.writeStatus("101 Switching Protocols");
-        if (upgradeHeaders) {
-          const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
-          for (const [key, value] of headers) {
-            res.writeHeader(key, value);
-          }
-        }
-        res.cork(() => {
-          const key = req.getHeader("sec-websocket-key");
-          const protocol = req.getHeader("sec-websocket-protocol");
-          const extensions = req.getHeader("sec-websocket-extensions");
-          res.upgrade(
-            {
-              req,
-              res,
-              webReq,
-              protocol,
-              extensions,
-              context,
-              namespace
-            },
-            key,
-            "",
-            extensions,
-            uwsContext
-          );
-        });
-      }
-    }
-  };
+	const hooks = new AdapterHookable(options);
+	const globalPeers = /* @__PURE__ */ new Map();
+	return {
+		...adapterUtils(globalPeers),
+		websocket: {
+			...options.uws,
+			close(ws, code, message) {
+				const peers = getPeers(globalPeers, ws.getUserData().namespace);
+				const peer = getPeer(ws, peers);
+				peer._internal.ws.readyState = 2;
+				peers.delete(peer);
+				hooks.callHook("close", peer, {
+					code,
+					reason: message?.toString()
+				});
+				peer._internal.ws.readyState = 3;
+			},
+			message(ws, message, isBinary) {
+				const peer = getPeer(ws, getPeers(globalPeers, ws.getUserData().namespace));
+				hooks.callHook("message", peer, new Message(message, peer));
+			},
+			open(ws) {
+				const peers = getPeers(globalPeers, ws.getUserData().namespace);
+				const peer = getPeer(ws, peers);
+				peers.add(peer);
+				hooks.callHook("open", peer);
+			},
+			async upgrade(res, req, uwsContext) {
+				let aborted = false;
+				res.onAborted(() => {
+					aborted = true;
+				});
+				const webReq = new UWSReqProxy(req);
+				const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(webReq);
+				if (endResponse) {
+					res.writeStatus(`${endResponse.status} ${endResponse.statusText}`);
+					for (const [key, value] of endResponse.headers) res.writeHeader(key, value);
+					if (endResponse.body) for await (const chunk of endResponse.body) {
+						if (aborted) break;
+						res.write(chunk);
+					}
+					if (!aborted) res.end();
+					return;
+				}
+				if (aborted) return;
+				res.writeStatus("101 Switching Protocols");
+				if (upgradeHeaders) {
+					const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
+					for (const [key, value] of headers) res.writeHeader(key, value);
+				}
+				res.cork(() => {
+					const key = req.getHeader("sec-websocket-key");
+					const protocol = req.getHeader("sec-websocket-protocol");
+					const extensions = req.getHeader("sec-websocket-extensions");
+					res.upgrade({
+						req,
+						res,
+						webReq,
+						protocol,
+						extensions,
+						context,
+						namespace
+					}, key, "", extensions, uwsContext);
+				});
+			}
+		}
+	};
 };
+var uws_default = uwsAdapter;
 function getPeer(uws, peers) {
-  const uwsData = uws.getUserData();
-  if (uwsData.peer) {
-    return uwsData.peer;
-  }
-  const peer = new UWSPeer({
-    peers,
-    uws,
-    ws: new UwsWebSocketProxy(uws),
-    request: uwsData.webReq,
-    namespace: uwsData.namespace,
-    uwsData
-  });
-  uwsData.peer = peer;
-  return peer;
-}
-class UWSPeer extends Peer {
-  get remoteAddress() {
-    try {
-      const addr = new TextDecoder().decode(
-        this._internal.uws.getRemoteAddressAsText()
-      );
-      return addr;
-    } catch {
-    }
-  }
-  get context() {
-    return this._internal.uwsData.context;
-  }
-  send(data, options) {
-    const dataBuff = toBufferLike(data);
-    const isBinary = typeof dataBuff !== "string";
-    return this._internal.uws.send(dataBuff, isBinary, options?.compress);
-  }
-  subscribe(topic) {
-    this._topics.add(topic);
-    this._internal.uws.subscribe(topic);
-  }
-  unsubscribe(topic) {
-    this._topics.delete(topic);
-    this._internal.uws.unsubscribe(topic);
-  }
-  publish(topic, message, options) {
-    const data = toBufferLike(message);
-    const isBinary = typeof data !== "string";
-    this._internal.uws.publish(topic, data, isBinary, options?.compress);
-    return 0;
-  }
-  close(code, reason) {
-    this._internal.uws.end(code, reason);
-  }
-  terminate() {
-    this._internal.uws.close();
-  }
-}
-class UWSReqProxy extends StubRequest {
-  constructor(req) {
-    const rawHeaders = [];
-    let host = "localhost";
-    let proto = "http";
-    req.forEach((key, value) => {
-      if (key === "host") {
-        host = value;
-      } else if (key === "x-forwarded-proto" && value === "https") {
-        proto = "https";
-      }
-      rawHeaders.push([key, value]);
-    });
-    const query = req.getQuery();
-    const pathname = req.getUrl();
-    const url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
-    super(url, { headers: rawHeaders });
-  }
-}
-class UwsWebSocketProxy {
-  constructor(_uws) {
-    this._uws = _uws;
-  }
-  readyState = 1;
-  get bufferedAmount() {
-    return this._uws?.getBufferedAmount();
-  }
-  get protocol() {
-    return this._uws?.getUserData().protocol;
-  }
-  get extensions() {
-    return this._uws?.getUserData().extensions;
-  }
+	const uwsData = uws.getUserData();
+	if (uwsData.peer) return uwsData.peer;
+	const peer = new UWSPeer({
+		peers,
+		uws,
+		ws: new UwsWebSocketProxy(uws),
+		request: uwsData.webReq,
+		namespace: uwsData.namespace,
+		uwsData
+	});
+	uwsData.peer = peer;
+	return peer;
 }
+var UWSPeer = class extends Peer {
+	get remoteAddress() {
+		try {
+			return new TextDecoder().decode(this._internal.uws.getRemoteAddressAsText());
+		} catch {}
+	}
+	get context() {
+		return this._internal.uwsData.context;
+	}
+	send(data, options) {
+		const dataBuff = toBufferLike(data);
+		const isBinary = typeof dataBuff !== "string";
+		return this._internal.uws.send(dataBuff, isBinary, options?.compress);
+	}
+	subscribe(topic) {
+		this._topics.add(topic);
+		this._internal.uws.subscribe(topic);
+	}
+	unsubscribe(topic) {
+		this._topics.delete(topic);
+		this._internal.uws.unsubscribe(topic);
+	}
+	publish(topic, message, options) {
+		const data = toBufferLike(message);
+		const isBinary = typeof data !== "string";
+		this._internal.uws.publish(topic, data, isBinary, options?.compress);
+		return 0;
+	}
+	close(code, reason) {
+		this._internal.uws.end(code, reason);
+	}
+	terminate() {
+		this._internal.uws.close();
+	}
+};
+var UWSReqProxy = class extends StubRequest {
+	constructor(req) {
+		const rawHeaders = [];
+		let host = "localhost";
+		let proto = "http";
+		req.forEach((key, value) => {
+			if (key === "host") host = value;
+			else if (key === "x-forwarded-proto" && value === "https") proto = "https";
+			rawHeaders.push([key, value]);
+		});
+		const query = req.getQuery();
+		const pathname = req.getUrl();
+		const url = `${proto}://${host}${pathname}${query ? `?${query}` : ""}`;
+		super(url, { headers: rawHeaders });
+	}
+};
+var UwsWebSocketProxy = class {
+	readyState = 1;
+	constructor(_uws) {
+		this._uws = _uws;
+	}
+	get bufferedAmount() {
+		return this._uws?.getBufferedAmount();
+	}
+	get protocol() {
+		return this._uws?.getUserData().protocol;
+	}
+	get extensions() {
+		return this._uws?.getUserData().extensions;
+	}
+};
 
-export { uwsAdapter as default };
+//#endregion
+export { uws_default as default };