crossws 0.4.2 → 0.4.3

package/dist/_chunks/_request.mjs

@@ -0,0 +1,82 @@
+//#region src/_request.ts
+const StubRequest = /* @__PURE__ */ (() => {
+	class StubRequest {
+		url;
+		_signal;
+		_headers;
+		_init;
+		constructor(url, init = {}) {
+			this.url = url;
+			this._init = init;
+		}
+		get headers() {
+			if (!this._headers) this._headers = new Headers(this._init?.headers);
+			return this._headers;
+		}
+		clone() {
+			return new StubRequest(this.url, this._init);
+		}
+		get method() {
+			return "GET";
+		}
+		get signal() {
+			return this._signal ??= new AbortSignal();
+		}
+		get cache() {
+			return "default";
+		}
+		get credentials() {
+			return "same-origin";
+		}
+		get destination() {
+			return "";
+		}
+		get integrity() {
+			return "";
+		}
+		get keepalive() {
+			return false;
+		}
+		get redirect() {
+			return "follow";
+		}
+		get mode() {
+			return "cors";
+		}
+		get referrer() {
+			return "about:client";
+		}
+		get referrerPolicy() {
+			return "";
+		}
+		get body() {
+			return null;
+		}
+		get bodyUsed() {
+			return false;
+		}
+		arrayBuffer() {
+			return Promise.resolve(/* @__PURE__ */ new ArrayBuffer(0));
+		}
+		blob() {
+			return Promise.resolve(new Blob());
+		}
+		bytes() {
+			return Promise.resolve(new Uint8Array());
+		}
+		formData() {
+			return Promise.resolve(new FormData());
+		}
+		json() {
+			return Promise.resolve(JSON.parse(""));
+		}
+		text() {
+			return Promise.resolve("");
+		}
+	}
+	Object.setPrototypeOf(StubRequest.prototype, globalThis.Request.prototype);
+	return StubRequest;
+})();
+
+//#endregion
+export { StubRequest as t };

package/dist/_chunks/_types.d.mts

@@ -0,0 +1,24 @@
+import { a as Hooks } from "./adapter.mjs";
+import { n as BunOptions } from "./bun.mjs";
+import { n as CloudflareOptions } from "./cloudflare.mjs";
+import { n as DenoOptions } from "./deno.mjs";
+import { n as NodeOptions } from "./node.mjs";
+import { n as SSEOptions } from "./sse.mjs";
+import { Server, ServerOptions, ServerPlugin, ServerRequest } from "srvx";
+
+//#region src/server/_types.d.ts
+type WSOptions = Partial<Hooks> & {
+  resolve?: (req: ServerRequest) => Partial<Hooks> | Promise<Partial<Hooks>>;
+  options?: {
+    bun?: BunOptions;
+    deno?: DenoOptions;
+    node?: NodeOptions;
+    sse?: SSEOptions;
+    cloudflare?: CloudflareOptions;
+  };
+};
+type ServerWithWSOptions = ServerOptions & {
+  websocket?: WSOptions;
+};
+//#endregion
+export { WSOptions as n, ServerWithWSOptions as t };

package/dist/_chunks/adapter.d.mts

@@ -0,0 +1,174 @@
+import { a as WebSocket } from "./web.mjs";
+
+//#region src/error.d.ts
+declare class WSError extends Error {
+  constructor(...args: any[]);
+}
+//#endregion
+//#region src/utils.d.ts
+declare const kNodeInspect: unique symbol;
+//#endregion
+//#region src/peer.d.ts
+interface PeerContext extends Record<string, unknown> {}
+interface AdapterInternal {
+  ws: unknown;
+  request: Request;
+  namespace: string;
+  peers?: Set<Peer>;
+  context?: PeerContext;
+}
+declare abstract class Peer<Internal extends AdapterInternal = AdapterInternal> {
+  #private;
+  protected _internal: Internal;
+  protected _topics: Set<string>;
+  protected _id?: string;
+  constructor(internal: Internal);
+  get context(): PeerContext;
+  get namespace(): string;
+  /**
+       * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
+       */
+  get id(): string;
+  /** IP address of the peer */
+  get remoteAddress(): string | undefined;
+  /** upgrade request */
+  get request(): Request;
+  /**
+       * Get the [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) instance.
+       *
+       * **Note:** crossws adds polyfill for the following properties if native values are not available:
+       * - `protocol`: Extracted from the `sec-websocket-protocol` header.
+       * - `extensions`: Extracted from the `sec-websocket-extensions` header.
+       * - `url`: Extracted from the request URL (http -> ws).
+       * */
+  get websocket(): Partial<WebSocket>;
+  /** All connected peers to the server */
+  get peers(): Set<Peer>;
+  /** All topics, this peer has been subscribed to. */
+  get topics(): Set<string>;
+  abstract close(code?: number, reason?: string): void;
+  /** Abruptly close the connection */
+  terminate(): void;
+  /** Subscribe to a topic */
+  subscribe(topic: string): void;
+  /** Unsubscribe from a topic */
+  unsubscribe(topic: string): void;
+  /** Send a message to the peer. */
+  abstract send(data: unknown, options?: {
+    compress?: boolean;
+  }): number | void | undefined;
+  /** Send message to subscribes of topic */
+  abstract publish(topic: string, data: unknown, options?: {
+    compress?: boolean;
+  }): void;
+  toString(): string;
+  [Symbol.toPrimitive](): string;
+  [Symbol.toStringTag](): "WebSocket";
+  [kNodeInspect](): unknown;
+}
+//#endregion
+//#region src/message.d.ts
+declare class Message implements Partial<MessageEvent> {
+  #private;
+  /** Access to the original [message event](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/message_event) if available. */
+  readonly event?: MessageEvent;
+  /** Access to the Peer that emitted the message. */
+  readonly peer?: Peer;
+  /** Raw message data (can be of any type). */
+  readonly rawData: unknown;
+  constructor(rawData: unknown, peer: Peer, event?: MessageEvent);
+  /**
+       * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the message.
+       */
+  get id(): string;
+  /**
+       * Get data as [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) value.
+       *
+       * If raw data is in any other format or string, it will be automatically converted and encoded.
+       */
+  uint8Array(): Uint8Array;
+  /**
+       * Get data as [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) or [SharedArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) value.
+       *
+       * If raw data is in any other format or string, it will be automatically converted and encoded.
+       */
+  arrayBuffer(): ArrayBuffer | SharedArrayBuffer;
+  /**
+       * Get data as [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) value.
+       *
+       * If raw data is in any other format or string, it will be automatically converted and encoded. */
+  blob(): Blob;
+  /**
+       * Get stringified text version of the message.
+       *
+       * If raw data is in any other format, it will be automatically converted and decoded.
+       */
+  text(): string;
+  /**
+       * Get parsed version of the message text with [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse).
+       */
+  json<T = unknown>(): T;
+  /**
+       * Message data (value varies based on `peer.websocket.binaryType`).
+       */
+  get data(): unknown;
+  toString(): string;
+  [Symbol.toPrimitive](): string;
+  [kNodeInspect](): unknown;
+}
+//#endregion
+//#region src/hooks.d.ts
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (request: Request & {
+  readonly context?: PeerContext;
+}) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type MaybePromise<T> = T | Promise<T>;
+interface Hooks {
+  /**
+       * Upgrading a request to a WebSocket connection.
+       *
+       * - You can throw a Response to abort the upgrade.
+       * - You can return { headers } to modify the response.
+       * - You can return { namespace } to change the pub/sub namespace.
+       * - You can return { context } to provide a custom peer context.
+       *
+       * @param request
+       * @throws {Response}
+       */
+  upgrade: (request: Request & {
+    readonly context?: Record<string, unknown>;
+  }) => MaybePromise<{
+    headers?: HeadersInit;
+    namespace?: string;
+    context?: PeerContext;
+  } | Response | void>;
+  /** A message is received */
+  message: (peer: Peer, message: Message) => MaybePromise<void>;
+  /** A socket is opened */
+  open: (peer: Peer) => MaybePromise<void>;
+  /** A socket is closed */
+  close: (peer: Peer, details: {
+    code?: number;
+    reason?: string;
+  }) => MaybePromise<void>;
+  /** An error occurs */
+  error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+//#endregion
+//#region src/adapter.d.ts
+interface AdapterInstance {
+  readonly peers: Map<string, Set<Peer>>;
+  readonly publish: (topic: string, data: unknown, options?: {
+    compress?: boolean;
+    namespace?: string;
+  }) => void;
+}
+interface AdapterOptions {
+  resolve?: ResolveHooks;
+  getNamespace?: (request: Request) => string;
+  hooks?: Partial<Hooks>;
+}
+type Adapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT extends AdapterInstance = AdapterInstance, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+//#endregion
+export { Hooks as a, Message as c, PeerContext as d, WSError as f, defineWebSocketAdapter as i, AdapterInternal as l, AdapterInstance as n, ResolveHooks as o, AdapterOptions as r, defineHooks as s, Adapter as t, Peer as u };

package/dist/_chunks/adapter.mjs

@@ -0,0 +1,93 @@
+//#region src/hooks.ts
+var AdapterHookable = class {
+	options;
+	constructor(options) {
+		this.options = options || {};
+	}
+	callHook(name, arg1, arg2) {
+		const globalHook = this.options.hooks?.[name];
+		const globalPromise = globalHook?.(arg1, arg2);
+		const request = arg1.request || arg1;
+		const resolveHooksPromise = this.options.resolve?.(request);
+		if (!resolveHooksPromise) return globalPromise;
+		const resolvePromise = resolveHooksPromise instanceof Promise ? resolveHooksPromise.then((hooks) => hooks?.[name]) : resolveHooksPromise?.[name];
+		return Promise.all([globalPromise, resolvePromise]).then(([globalRes, hook]) => {
+			const hookResPromise = hook?.(arg1, arg2);
+			return hookResPromise instanceof Promise ? hookResPromise.then((hookRes) => hookRes || globalRes) : hookResPromise || globalRes;
+		});
+	}
+	async upgrade(request) {
+		let namespace = this.options.getNamespace?.(request) ?? new URL(request.url).pathname;
+		const context = request.context || {};
+		try {
+			const res = await this.callHook("upgrade", request);
+			if (!res) return {
+				context,
+				namespace
+			};
+			if (res.namespace) namespace = res.namespace;
+			if (res.context) Object.assign(context, res.context);
+			if (res instanceof Response) return {
+				context,
+				namespace,
+				endResponse: res
+			};
+			if (res.headers) return {
+				context,
+				namespace,
+				upgradeHeaders: res.headers
+			};
+		} catch (error) {
+			const errResponse = error.response || error;
+			if (errResponse instanceof Response) return {
+				context,
+				namespace,
+				endResponse: errResponse
+			};
+			throw error;
+		}
+		return {
+			context,
+			namespace
+		};
+	}
+};
+function defineHooks(hooks) {
+	return hooks;
+}
+
+//#endregion
+//#region src/adapter.ts
+function adapterUtils(globalPeers) {
+	return {
+		peers: globalPeers,
+		publish(topic, message, options) {
+			for (const peers of options?.namespace ? [globalPeers.get(options.namespace) || []] : globalPeers.values()) {
+				let firstPeerWithTopic;
+				for (const peer of peers) if (peer.topics.has(topic)) {
+					firstPeerWithTopic = peer;
+					break;
+				}
+				if (firstPeerWithTopic) {
+					firstPeerWithTopic.send(message, options);
+					firstPeerWithTopic.publish(topic, message, options);
+				}
+			}
+		}
+	};
+}
+function getPeers(globalPeers, namespace) {
+	if (!namespace) throw new Error("Websocket publish namespace missing.");
+	let peers = globalPeers.get(namespace);
+	if (!peers) {
+		peers = /* @__PURE__ */ new Set();
+		globalPeers.set(namespace, peers);
+	}
+	return peers;
+}
+function defineWebSocketAdapter(factory) {
+	return factory;
+}
+
+//#endregion
+export { defineHooks as a, AdapterHookable as i, defineWebSocketAdapter as n, getPeers as r, adapterUtils as t };

package/dist/_chunks/bun.d.mts

@@ -0,0 +1,38 @@
+import { d as PeerContext, n as AdapterInstance, r as AdapterOptions, t as Adapter, u as Peer } from "./adapter.mjs";
+import { Server, ServerWebSocket, WebSocketHandler } from "bun";
+
+//#region src/adapters/bun.d.ts
+interface BunAdapter extends AdapterInstance {
+  websocket: WebSocketHandler<ContextData>;
+  handleUpgrade(req: Request, server: Server<ContextData>): Promise<Response | undefined>;
+}
+interface BunOptions extends AdapterOptions {}
+type ContextData = {
+  peer?: BunPeer;
+  namespace: string;
+  request: Request;
+  server?: Server<ContextData>;
+  context: PeerContext;
+};
+declare const bunAdapter: Adapter<BunAdapter, BunOptions>;
+declare class BunPeer extends Peer<{
+  ws: ServerWebSocket<ContextData>;
+  namespace: string;
+  request: Request;
+  peers: Set<BunPeer>;
+}> {
+  get remoteAddress(): string;
+  get context(): PeerContext;
+  send(data: unknown, options?: {
+    compress?: boolean;
+  }): number;
+  publish(topic: string, data: unknown, options?: {
+    compress?: boolean;
+  }): number;
+  subscribe(topic: string): void;
+  unsubscribe(topic: string): void;
+  close(code?: number, reason?: string): void;
+  terminate(): void;
+}
+//#endregion
+export { BunOptions as n, bunAdapter as r, BunAdapter as t };

package/dist/_chunks/cloudflare.d.mts

@@ -0,0 +1,45 @@
+import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+import { a as WebSocket$1 } from "./web.mjs";
+import { DurableObject } from "cloudflare:workers";
+import * as CF from "@cloudflare/workers-types";
+
+//#region src/adapters/cloudflare.d.ts
+type WSDurableObjectStub = CF.DurableObjectStub & {
+  webSocketPublish?: (topic: string, data: unknown, opts: any) => Promise<void>;
+};
+type ResolveDurableStub = (req: CF.Request | undefined, env: unknown, context: CF.ExecutionContext | undefined) => WSDurableObjectStub | undefined | Promise<WSDurableObjectStub | undefined>;
+interface CloudflareOptions extends AdapterOptions {
+  /**
+       * Durable Object binding name from environment.
+       *
+       * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+       *
+       * @default "$DurableObject"
+       */
+  bindingName?: string;
+  /**
+       * Durable Object instance name.
+       *
+       * **Note:** This option will be ignored if `resolveDurableStub` is provided.
+       *
+       * @default "crossws"
+       */
+  instanceName?: string;
+  /**
+       * Custom function that resolves Durable Object binding to handle the WebSocket upgrade.
+       *
+       * **Note:** This option will override `bindingName` and `instanceName`.
+       */
+  resolveDurableStub?: ResolveDurableStub;
+}
+declare const cloudflareAdapter: Adapter<CloudflareDurableAdapter, CloudflareOptions>;
+interface CloudflareDurableAdapter extends AdapterInstance {
+  handleUpgrade(req: Request | CF.Request, env: unknown, context: CF.ExecutionContext): Promise<Response>;
+  handleDurableInit(obj: DurableObject, state: DurableObjectState, env: unknown): void;
+  handleDurableUpgrade(obj: DurableObject, req: Request | CF.Request): Promise<Response>;
+  handleDurableMessage(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, message: ArrayBuffer | string): Promise<void>;
+  handleDurablePublish: (obj: DurableObject, topic: string, data: unknown, opts: any) => Promise<void>;
+  handleDurableClose(obj: DurableObject, ws: WebSocket | CF.WebSocket | WebSocket$1, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+//#endregion
+export { CloudflareOptions as n, cloudflareAdapter as r, CloudflareDurableAdapter as t };

package/dist/_chunks/deno.d.mts

@@ -0,0 +1,17 @@
+import { n as AdapterInstance, r as AdapterOptions, t as Adapter } from "./adapter.mjs";
+
+//#region src/adapters/deno.d.ts
+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>;
+//#endregion
+export { DenoOptions as n, denoAdapter as r, DenoAdapter as t };

package/dist/_chunks/error.mjs

@@ -0,0 +1,10 @@
+//#region src/error.ts
+var WSError = class extends Error {
+	constructor(...args) {
+		super(...args);
+		this.name = "WSError";
+	}
+};
+
+//#endregion
+export { WSError as t };