crossws 0.4.2 → 0.4.3

package/dist/adapters/cloudflare.mjs

@@ -1,227 +1,181 @@
-import { env } from 'cloudflare:workers';
-import { M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.WpyOHUXc.mjs';
-import { a as adapterUtils, g as getPeers, A as AdapterHookable } from '../shared/crossws.CPlNx7g8.mjs';
-import { S as StubRequest } from '../shared/crossws.B31KJMcF.mjs';
-import { W as WSError } from '../shared/crossws.By9qWDAI.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";
+import { t as WSError } from "../_chunks/error.mjs";
+import { env } from "cloudflare:workers";
 
+//#region src/adapters/cloudflare.ts
 const cloudflareAdapter = (opts = {}) => {
-  const hooks = new AdapterHookable(opts);
-  const globalPeers = /* @__PURE__ */ new Map();
-  const resolveDurableStub = opts.resolveDurableStub || ((_req, env$1, _context) => {
-    const bindingName = opts.bindingName || "$DurableObject";
-    const binding = (env$1 || env)[bindingName];
-    if (binding) {
-      const instanceId = binding.idFromName(opts.instanceName || "crossws");
-      return binding.get(instanceId);
-    }
-  });
-  const { publish: durablePublish, ...utils } = adapterUtils(globalPeers);
-  return {
-    ...utils,
-    handleUpgrade: async (request, cfEnv, cfCtx) => {
-      const stub = await resolveDurableStub(
-        request,
-        cfEnv,
-        cfCtx
-      );
-      if (stub) {
-        return stub.fetch(
-          request
-        );
-      }
-      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
-      if (endResponse) {
-        return endResponse;
-      }
-      const peers = getPeers(
-        globalPeers,
-        namespace
-      );
-      const pair = new WebSocketPair();
-      const client = pair[0];
-      const server = pair[1];
-      const peer = new CloudflareFallbackPeer({
-        ws: client,
-        peers,
-        wsServer: server,
-        request,
-        cfEnv,
-        cfCtx,
-        context,
-        namespace
-      });
-      peers.add(peer);
-      server.accept();
-      hooks.callHook("open", peer);
-      server.addEventListener("message", (event) => {
-        hooks.callHook(
-          "message",
-          peer,
-          new Message(event.data, peer, event)
-        );
-      });
-      server.addEventListener("error", (event) => {
-        peers.delete(peer);
-        hooks.callHook("error", peer, new WSError(event.error));
-      });
-      server.addEventListener("close", (event) => {
-        peers.delete(peer);
-        hooks.callHook("close", peer, event);
-        server.close();
-      });
-      return new Response(null, {
-        status: 101,
-        webSocket: client,
-        headers: upgradeHeaders
-      });
-    },
-    handleDurableInit: async (obj, state, env) => {
-    },
-    handleDurableUpgrade: async (obj, request) => {
-      const { upgradeHeaders, endResponse, namespace } = await hooks.upgrade(
-        request
-      );
-      if (endResponse) {
-        return endResponse;
-      }
-      const peers = getPeers(globalPeers, namespace);
-      const pair = new WebSocketPair();
-      const client = pair[0];
-      const server = pair[1];
-      const peer = CloudflareDurablePeer._restore(
-        obj,
-        server,
-        request,
-        namespace
-      );
-      peers.add(peer);
-      obj.ctx.acceptWebSocket(server);
-      await hooks.callHook("open", peer);
-      return new Response(null, {
-        status: 101,
-        webSocket: client,
-        headers: upgradeHeaders
-      });
-    },
-    handleDurableMessage: async (obj, ws, message) => {
-      const peer = CloudflareDurablePeer._restore(obj, ws);
-      await hooks.callHook("message", peer, new Message(message, peer));
-    },
-    handleDurableClose: async (obj, ws, code, reason, wasClean) => {
-      const peer = CloudflareDurablePeer._restore(obj, ws);
-      const peers = getPeers(globalPeers, peer.namespace);
-      peers.delete(peer);
-      const details = { code, reason, wasClean };
-      await hooks.callHook("close", peer, details);
-    },
-    handleDurablePublish: async (_obj, topic, data, opts2) => {
-      return durablePublish(topic, data, opts2);
-    },
-    publish: async (topic, data, opts2) => {
-      const stub = await resolveDurableStub(void 0, env, void 0);
-      if (!stub) {
-        throw new Error("[crossws] Durable Object binding cannot be resolved.");
-      }
-      try {
-        return await stub.webSocketPublish(topic, data, opts2);
-      } catch (error) {
-        console.error(error);
-        throw error;
-      }
-    }
-  };
+	const hooks = new AdapterHookable(opts);
+	const globalPeers = /* @__PURE__ */ new Map();
+	const resolveDurableStub = opts.resolveDurableStub || ((_req, env$1, _context) => {
+		const bindingName = opts.bindingName || "$DurableObject";
+		const binding = (env$1 || env)[bindingName];
+		if (binding) {
+			const instanceId = binding.idFromName(opts.instanceName || "crossws");
+			return binding.get(instanceId);
+		}
+	});
+	const { publish: durablePublish, ...utils } = adapterUtils(globalPeers);
+	return {
+		...utils,
+		handleUpgrade: async (request, cfEnv, cfCtx) => {
+			const stub = await resolveDurableStub(request, cfEnv, cfCtx);
+			if (stub) return stub.fetch(request);
+			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
+			if (endResponse) return endResponse;
+			const peers = getPeers(globalPeers, namespace);
+			const pair = new WebSocketPair();
+			const client = pair[0];
+			const server = pair[1];
+			const peer = new CloudflareFallbackPeer({
+				ws: client,
+				peers,
+				wsServer: server,
+				request,
+				cfEnv,
+				cfCtx,
+				context,
+				namespace
+			});
+			peers.add(peer);
+			server.accept();
+			hooks.callHook("open", peer);
+			server.addEventListener("message", (event) => {
+				hooks.callHook("message", peer, new Message(event.data, peer, event));
+			});
+			server.addEventListener("error", (event) => {
+				peers.delete(peer);
+				hooks.callHook("error", peer, new WSError(event.error));
+			});
+			server.addEventListener("close", (event) => {
+				peers.delete(peer);
+				hooks.callHook("close", peer, event);
+				server.close();
+			});
+			return new Response(null, {
+				status: 101,
+				webSocket: client,
+				headers: upgradeHeaders
+			});
+		},
+		handleDurableInit: async (obj, state, env$1) => {},
+		handleDurableUpgrade: async (obj, request) => {
+			const { upgradeHeaders, endResponse, namespace } = await hooks.upgrade(request);
+			if (endResponse) return endResponse;
+			const peers = getPeers(globalPeers, namespace);
+			const pair = new WebSocketPair();
+			const client = pair[0];
+			const server = pair[1];
+			const peer = CloudflareDurablePeer._restore(obj, server, request, namespace);
+			peers.add(peer);
+			obj.ctx.acceptWebSocket(server);
+			await hooks.callHook("open", peer);
+			return new Response(null, {
+				status: 101,
+				webSocket: client,
+				headers: upgradeHeaders
+			});
+		},
+		handleDurableMessage: async (obj, ws, message) => {
+			const peer = CloudflareDurablePeer._restore(obj, ws);
+			await hooks.callHook("message", peer, new Message(message, peer));
+		},
+		handleDurableClose: async (obj, ws, code, reason, wasClean) => {
+			const peer = CloudflareDurablePeer._restore(obj, ws);
+			getPeers(globalPeers, peer.namespace).delete(peer);
+			const details = {
+				code,
+				reason,
+				wasClean
+			};
+			await hooks.callHook("close", peer, details);
+		},
+		handleDurablePublish: async (_obj, topic, data, opts$1) => {
+			return durablePublish(topic, data, opts$1);
+		},
+		publish: async (topic, data, opts$1) => {
+			const stub = await resolveDurableStub(void 0, env, void 0);
+			if (!stub) throw new Error("[crossws] Durable Object binding cannot be resolved.");
+			try {
+				return await stub.webSocketPublish(topic, data, opts$1);
+			} catch (error) {
+				console.error(error);
+				throw error;
+			}
+		}
+	};
+};
+var cloudflare_default = cloudflareAdapter;
+var CloudflareDurablePeer = class CloudflareDurablePeer extends Peer {
+	get peers() {
+		return new Set(this.#getwebsockets().map((ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)));
+	}
+	#getwebsockets() {
+		return this._internal.durable.ctx.getWebSockets();
+	}
+	send(data) {
+		return this._internal.ws.send(toBufferLike(data));
+	}
+	subscribe(topic) {
+		super.subscribe(topic);
+		const state = getAttachedState(this._internal.ws);
+		if (!state.t) state.t = /* @__PURE__ */ new Set();
+		state.t.add(topic);
+		setAttachedState(this._internal.ws, state);
+	}
+	publish(topic, data) {
+		const websockets = this.#getwebsockets();
+		if (websockets.length < 2) return;
+		const dataBuff = toBufferLike(data);
+		for (const ws of websockets) {
+			if (ws === this._internal.ws) continue;
+			if (getAttachedState(ws).t?.has(topic)) ws.send(dataBuff);
+		}
+	}
+	close(code, reason) {
+		this._internal.ws.close(code, reason);
+	}
+	static _restore(durable, ws, request, namespace) {
+		let peer = ws._crosswsPeer;
+		if (peer) return peer;
+		const state = ws.deserializeAttachment() || {};
+		peer = ws._crosswsPeer = new CloudflareDurablePeer({
+			ws,
+			request: request || new StubRequest(state.u || ""),
+			namespace: namespace || state.n || "",
+			durable
+		});
+		if (state.i) peer._id = state.i;
+		if (request?.url) state.u = request.url;
+		state.i = peer.id;
+		setAttachedState(ws, state);
+		return peer;
+	}
+};
+var CloudflareFallbackPeer = class extends Peer {
+	send(data) {
+		this._internal.wsServer.send(toBufferLike(data));
+		return 0;
+	}
+	publish(_topic, _message) {
+		console.warn("[crossws] [cloudflare] pub/sub support requires Durable Objects.");
+	}
+	close(code, reason) {
+		this._internal.ws.close(code, reason);
+	}
 };
-class CloudflareDurablePeer extends Peer {
-  get peers() {
-    return new Set(
-      this.#getwebsockets().map(
-        (ws) => CloudflareDurablePeer._restore(this._internal.durable, ws)
-      )
-    );
-  }
-  #getwebsockets() {
-    return this._internal.durable.ctx.getWebSockets();
-  }
-  send(data) {
-    return this._internal.ws.send(toBufferLike(data));
-  }
-  subscribe(topic) {
-    super.subscribe(topic);
-    const state = getAttachedState(this._internal.ws);
-    if (!state.t) {
-      state.t = /* @__PURE__ */ new Set();
-    }
-    state.t.add(topic);
-    setAttachedState(this._internal.ws, state);
-  }
-  publish(topic, data) {
-    const websockets = this.#getwebsockets();
-    if (websockets.length < 2) {
-      return;
-    }
-    const dataBuff = toBufferLike(data);
-    for (const ws of websockets) {
-      if (ws === this._internal.ws) {
-        continue;
-      }
-      const state = getAttachedState(ws);
-      if (state.t?.has(topic)) {
-        ws.send(dataBuff);
-      }
-    }
-  }
-  close(code, reason) {
-    this._internal.ws.close(code, reason);
-  }
-  static _restore(durable, ws, request, namespace) {
-    let peer = ws._crosswsPeer;
-    if (peer) {
-      return peer;
-    }
-    const state = ws.deserializeAttachment() || {};
-    peer = ws._crosswsPeer = new CloudflareDurablePeer({
-      ws,
-      request: request || new StubRequest(state.u || ""),
-      namespace: namespace || state.n || "",
-      durable
-    });
-    if (state.i) {
-      peer._id = state.i;
-    }
-    if (request?.url) {
-      state.u = request.url;
-    }
-    state.i = peer.id;
-    setAttachedState(ws, state);
-    return peer;
-  }
-}
-class CloudflareFallbackPeer extends Peer {
-  send(data) {
-    this._internal.wsServer.send(toBufferLike(data));
-    return 0;
-  }
-  publish(_topic, _message) {
-    console.warn(
-      "[crossws] [cloudflare] pub/sub support requires Durable Objects."
-    );
-  }
-  close(code, reason) {
-    this._internal.ws.close(code, reason);
-  }
-}
 function getAttachedState(ws) {
-  let state = ws._crosswsState;
-  if (state) {
-    return state;
-  }
-  state = ws.deserializeAttachment() || {};
-  ws._crosswsState = state;
-  return state;
+	let state = ws._crosswsState;
+	if (state) return state;
+	state = ws.deserializeAttachment() || {};
+	ws._crosswsState = state;
+	return state;
 }
 function setAttachedState(ws, state) {
-  ws._crosswsState = state;
-  ws.serializeAttachment(state);
+	ws._crosswsState = state;
+	ws.serializeAttachment(state);
 }
 
-export { cloudflareAdapter as default };
+//#endregion
+export { cloudflare_default as default };

package/dist/adapters/deno.d.mts

@@ -1,19 +1,2 @@
-import { Adapter, AdapterInstance, AdapterOptions } from '../index.mjs';
-import '../shared/crossws.BQXMA5bH.mjs';
-
-interface DenoAdapter extends AdapterInstance {
-    handleUpgrade(req: Request, info: ServeHandlerInfo): Promise<Response>;
-}
-interface DenoOptions extends AdapterOptions {
-}
-type ServeHandlerInfo = {
-    remoteAddr?: {
-        transport: string;
-        hostname: string;
-        port: number;
-    };
-};
-declare const denoAdapter: Adapter<DenoAdapter, DenoOptions>;
-
-export { denoAdapter as default };
-export type { DenoAdapter, DenoOptions };
+import { n as DenoOptions, r as denoAdapter, t as DenoAdapter } from "../_chunks/deno.mjs";
+export { DenoAdapter, DenoOptions, denoAdapter as default };

package/dist/adapters/deno.mjs

@@ -1,78 +1,69 @@
-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 { W as WSError } from '../shared/crossws.By9qWDAI.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 WSError } from "../_chunks/error.mjs";
 
+//#region src/adapters/deno.ts
 const denoAdapter = (options = {}) => {
-  if (typeof Deno === "undefined") {
-    throw new Error(
-      "[crossws] Using Deno adapter in an incompatible environment."
-    );
-  }
-  const hooks = new AdapterHookable(options);
-  const globalPeers = /* @__PURE__ */ new Map();
-  return {
-    ...adapterUtils(globalPeers),
-    handleUpgrade: async (request, info) => {
-      const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
-      if (endResponse) {
-        return endResponse;
-      }
-      const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
-      const upgrade = Deno.upgradeWebSocket(request, {
-        // @ts-expect-error Setting headers is currently not supported in Deno
-        // https://github.com/denoland/deno/issues/19277
-        headers,
-        protocol: headers.get("sec-websocket-protocol") ?? ""
-      });
-      const peers = getPeers(globalPeers, namespace);
-      const peer = new DenoPeer({
-        ws: upgrade.socket,
-        request,
-        peers,
-        denoInfo: info,
-        context,
-        namespace
-      });
-      peers.add(peer);
-      upgrade.socket.addEventListener("open", () => {
-        hooks.callHook("open", peer);
-      });
-      upgrade.socket.addEventListener("message", (event) => {
-        hooks.callHook("message", peer, new Message(event.data, peer, event));
-      });
-      upgrade.socket.addEventListener("close", () => {
-        peers.delete(peer);
-        hooks.callHook("close", peer, {});
-      });
-      upgrade.socket.addEventListener("error", (error) => {
-        peers.delete(peer);
-        hooks.callHook("error", peer, new WSError(error));
-      });
-      return upgrade.response;
-    }
-  };
+	if (typeof Deno === "undefined") throw new Error("[crossws] Using Deno adapter in an incompatible environment.");
+	const hooks = new AdapterHookable(options);
+	const globalPeers = /* @__PURE__ */ new Map();
+	return {
+		...adapterUtils(globalPeers),
+		handleUpgrade: async (request, info) => {
+			const { upgradeHeaders, endResponse, context, namespace } = await hooks.upgrade(request);
+			if (endResponse) return endResponse;
+			const headers = upgradeHeaders instanceof Headers ? upgradeHeaders : new Headers(upgradeHeaders);
+			const upgrade = Deno.upgradeWebSocket(request, {
+				headers,
+				protocol: headers.get("sec-websocket-protocol") ?? ""
+			});
+			const peers = getPeers(globalPeers, namespace);
+			const peer = new DenoPeer({
+				ws: upgrade.socket,
+				request,
+				peers,
+				denoInfo: info,
+				context,
+				namespace
+			});
+			peers.add(peer);
+			upgrade.socket.addEventListener("open", () => {
+				hooks.callHook("open", peer);
+			});
+			upgrade.socket.addEventListener("message", (event) => {
+				hooks.callHook("message", peer, new Message(event.data, peer, event));
+			});
+			upgrade.socket.addEventListener("close", () => {
+				peers.delete(peer);
+				hooks.callHook("close", peer, {});
+			});
+			upgrade.socket.addEventListener("error", (error) => {
+				peers.delete(peer);
+				hooks.callHook("error", peer, new WSError(error));
+			});
+			return upgrade.response;
+		}
+	};
+};
+var deno_default = denoAdapter;
+var DenoPeer = class extends Peer {
+	get remoteAddress() {
+		return this._internal.denoInfo.remoteAddr?.hostname;
+	}
+	send(data) {
+		return this._internal.ws.send(toBufferLike(data));
+	}
+	publish(topic, data) {
+		const dataBuff = toBufferLike(data);
+		for (const peer of this._internal.peers) if (peer !== this && peer._topics.has(topic)) peer._internal.ws.send(dataBuff);
+	}
+	close(code, reason) {
+		this._internal.ws.close(code, reason);
+	}
+	terminate() {
+		this._internal.ws.terminate();
+	}
 };
-class DenoPeer extends Peer {
-  get remoteAddress() {
-    return this._internal.denoInfo.remoteAddr?.hostname;
-  }
-  send(data) {
-    return this._internal.ws.send(toBufferLike(data));
-  }
-  publish(topic, data) {
-    const dataBuff = toBufferLike(data);
-    for (const peer of this._internal.peers) {
-      if (peer !== this && peer._topics.has(topic)) {
-        peer._internal.ws.send(dataBuff);
-      }
-    }
-  }
-  close(code, reason) {
-    this._internal.ws.close(code, reason);
-  }
-  terminate() {
-    this._internal.ws.terminate();
-  }
-}
 
-export { denoAdapter as default };
+//#endregion
+export { deno_default as default };