crossws 0.3.4 → 0.4.0

package/dist/server/deno.mjs

@@ -0,0 +1,30 @@
+import { serve as serve$1 } from 'srvx/deno';
+import denoAdapter from '../adapters/deno.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = denoAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.deno
+    });
+    server.options.middleware.unshift((req, next) => {
+      if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return ws.handleUpgrade(req, req.runtime.deno.info);
+      }
+      return next();
+    });
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/server/node.d.mts

@@ -0,0 +1,24 @@
+import { ServerPlugin, Server } from 'srvx/types';
+import { W as WSOptions, S as ServerWithWSOptions } from '../shared/crossws.95-eYp2D.mjs';
+import '../index.mjs';
+import '../shared/crossws.BQXMA5bH.mjs';
+import '../adapters/bun.mjs';
+import 'bun';
+import '../adapters/deno.mjs';
+import '../adapters/node.mjs';
+import 'node:http';
+import 'node:stream';
+import 'events';
+import 'node:https';
+import 'node:tls';
+import 'node:url';
+import 'node:zlib';
+import '../adapters/sse.mjs';
+import '../adapters/cloudflare.mjs';
+import '@cloudflare/workers-types';
+import 'cloudflare:workers';
+
+declare function plugin(wsOpts: WSOptions): ServerPlugin;
+declare function serve(options: ServerWithWSOptions): Server;
+
+export { plugin, serve };

package/dist/server/node.mjs

@@ -0,0 +1,43 @@
+import { NodeRequest, serve as serve$1 } from 'srvx/node';
+import nodeAdapter from '../adapters/node.mjs';
+import '../shared/crossws.WpyOHUXc.mjs';
+import '../shared/crossws.CPlNx7g8.mjs';
+import '../shared/crossws.By9qWDAI.mjs';
+import '../shared/crossws.CipVM6lf.mjs';
+import 'stream';
+import 'events';
+import 'http';
+import 'crypto';
+import 'buffer';
+import 'zlib';
+import 'https';
+import 'net';
+import 'tls';
+import 'url';
+import '../shared/crossws.B31KJMcF.mjs';
+
+function plugin(wsOpts) {
+  return (server) => {
+    const ws = nodeAdapter({
+      hooks: wsOpts,
+      resolve: wsOpts.resolve,
+      ...wsOpts.options?.deno
+    });
+    const originalServe = server.serve;
+    server.serve = () => {
+      server.node?.server.on("upgrade", (req, socket, head) => {
+        ws.handleUpgrade(req, socket, head, new NodeRequest(req));
+      });
+      return originalServe.call(server);
+    };
+  };
+}
+function serve(options) {
+  if (options.websocket) {
+    options.plugins ||= [];
+    options.plugins.push(plugin(options.websocket));
+  }
+  return serve$1(options);
+}
+
+export { plugin, serve };

package/dist/shared/crossws.95-eYp2D.d.mts

@@ -0,0 +1,23 @@
+import { ServerRequest, ServerOptions } from 'srvx/types';
+import { Hooks } from '../index.mjs';
+import { BunOptions } from '../adapters/bun.mjs';
+import { DenoOptions } from '../adapters/deno.mjs';
+import { NodeOptions } from '../adapters/node.mjs';
+import { SSEOptions } from '../adapters/sse.mjs';
+import { CloudflareOptions } from '../adapters/cloudflare.mjs';
+
+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;
+};
+
+export type { ServerWithWSOptions as S, WSOptions as W };

package/dist/shared/crossws.B31KJMcF.mjs

@@ -0,0 +1,83 @@
+const StubRequest = /* @__PURE__ */ (() => {
+  class StubRequest2 {
+    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 StubRequest2(this.url, this._init);
+    }
+    // --- dummy ---
+    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(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(StubRequest2.prototype, globalThis.Request.prototype);
+  return StubRequest2;
+})();
+
+export { StubRequest as S };

package/dist/shared/{crossws.ChIJSJVK.d.mts → crossws.BQXMA5bH.d.mts}

@@ -294,4 +294,4 @@ interface WebSocket extends EventTarget {
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
-export type { CloseEvent as C, Event as E, MessageEvent as M, WebSocket as W, EventTarget as a };
+export type { CloseEvent as C, EventTarget as E, MessageEvent as M, WebSocket as W, Event as a };

package/dist/shared/{crossws.D9ehKjSh.mjs → crossws.CPlNx7g8.mjs}

@@ -6,7 +6,8 @@ class AdapterHookable {
   callHook(name, arg1, arg2) {
     const globalHook = this.options.hooks?.[name];
     const globalPromise = globalHook?.(arg1, arg2);
-    const resolveHooksPromise = this.options.resolve?.(arg1);
+    const request = arg1.request || arg1;
+    const resolveHooksPromise = this.options.resolve?.(request);
     if (!resolveHooksPromise) {
       return globalPromise;
     }
@@ -19,28 +20,32 @@ class AdapterHookable {
     );
   }
   async upgrade(request) {
-    let context = request.context;
-    if (!context) {
-      context = {};
-      Object.defineProperty(request, "context", {
-        enumerable: true,
-        value: context
-      });
-    }
+    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 };
+        return { context, namespace };
+      }
+      if (res.namespace) {
+        namespace = res.namespace;
       }
-      if (res.ok === false) {
-        return { context, endResponse: res };
+      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
         };
       }
@@ -49,38 +54,52 @@ class AdapterHookable {
       if (errResponse instanceof Response) {
         return {
           context,
+          namespace,
           endResponse: errResponse
         };
       }
       throw error;
     }
-    return { context };
+    return { context, namespace };
   }
 }
 function defineHooks(hooks) {
   return hooks;
 }
 
-function adapterUtils(peers) {
+function adapterUtils(globalPeers) {
   return {
-    peers,
+    peers: globalPeers,
     publish(topic, message, options) {
-      let firstPeerWithTopic;
-      for (const peer of peers) {
-        if (peer.topics.has(topic)) {
-          firstPeerWithTopic = peer;
-          break;
+      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);
         }
-      }
-      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;
 }
 
-export { AdapterHookable as A, adapterUtils as a, defineWebSocketAdapter as b, defineHooks as d };
+export { AdapterHookable as A, adapterUtils as a, defineWebSocketAdapter as b, defineHooks as d, getPeers as g };

package/dist/shared/{crossws.DelSCW9g.mjs → crossws.CipVM6lf.mjs}

@@ -1,6 +1,6 @@
+import require$$0$2 from 'stream';
 import require$$0$3 from 'events';
 import require$$2 from 'http';
-import require$$0$2 from 'stream';
 import require$$1 from 'crypto';
 import require$$0$1 from 'buffer';
 import require$$0 from 'zlib';
@@ -743,6 +743,14 @@ function requirePermessageDeflate () {
 	  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
 	  this[kError][kStatusCode] = 1009;
 	  this.removeListener('data', inflateOnData);
+
+	  //
+	  // The choice to employ `zlib.reset()` over `zlib.close()` is dictated by the
+	  // fact that in Node.js versions prior to 13.10.0, the callback for
+	  // `zlib.flush()` is not called if `zlib.close()` is used. Utilizing
+	  // `zlib.reset()` ensures that either the callback is invoked or an error is
+	  // emitted.
+	  //
 	  this.reset();
 	}
 
@@ -758,6 +766,12 @@ function requirePermessageDeflate () {
 	  // closed when an error is emitted.
 	  //
 	  this[kPerMessageDeflate]._inflate = null;
+
+	  if (this[kError]) {
+	    this[kCallback](this[kError]);
+	    return;
+	  }
+
 	  err[kStatusCode] = 1007;
 	  this[kCallback](err);
 	}
@@ -1639,8 +1653,6 @@ function requireReceiver () {
 	return receiver;
 }
 
-requireReceiver();
-
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
 
 var sender;
@@ -1649,6 +1661,8 @@ var hasRequiredSender;
 function requireSender () {
 	if (hasRequiredSender) return sender;
 	hasRequiredSender = 1;
+
+	const { Duplex } = require$$0$2;
 	const { randomFillSync } = require$$1;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -2197,7 +2211,7 @@ function requireSender () {
 	  /**
 	   * Sends a frame.
 	   *
-	   * @param {Buffer[]} list The frame to send
+	   * @param {(Buffer | String)[]} list The frame to send
 	   * @param {Function} [cb] Callback
 	   * @private
 	   */
@@ -2249,8 +2263,6 @@ function requireSender () {
 	return sender;
 }
 
-requireSender();
-
 var eventTarget;
 var hasRequiredEventTarget;
 
@@ -2777,6 +2789,7 @@ function requireWebsocket () {
 	const net = require$$3;
 	const tls = require$$4;
 	const { randomBytes, createHash } = require$$1;
+	const { Duplex, Readable } = require$$0$2;
 	const { URL } = require$$7;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -3476,7 +3489,7 @@ function requireWebsocket () {
 	  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {
 	    invalidUrlMessage =
 	      'The URL\'s protocol must be one of "ws:", "wss:", ' +
-	      '"http:", "https", or "ws+unix:"';
+	      '"http:", "https:", or "ws+unix:"';
 	  } else if (isIpcUrl && !parsedUrl.pathname) {
 	    invalidUrlMessage = "The URL's pathname is empty";
 	  } else if (parsedUrl.hash) {
@@ -4157,6 +4170,182 @@ function requireWebsocket () {
 	return websocket;
 }
 
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
+
+var stream;
+var hasRequiredStream;
+
+function requireStream () {
+	if (hasRequiredStream) return stream;
+	hasRequiredStream = 1;
+
+	requireWebsocket();
+	const { Duplex } = require$$0$2;
+
+	/**
+	 * Emits the `'close'` event on a stream.
+	 *
+	 * @param {Duplex} stream The stream.
+	 * @private
+	 */
+	function emitClose(stream) {
+	  stream.emit('close');
+	}
+
+	/**
+	 * The listener of the `'end'` event.
+	 *
+	 * @private
+	 */
+	function duplexOnEnd() {
+	  if (!this.destroyed && this._writableState.finished) {
+	    this.destroy();
+	  }
+	}
+
+	/**
+	 * The listener of the `'error'` event.
+	 *
+	 * @param {Error} err The error
+	 * @private
+	 */
+	function duplexOnError(err) {
+	  this.removeListener('error', duplexOnError);
+	  this.destroy();
+	  if (this.listenerCount('error') === 0) {
+	    // Do not suppress the throwing behavior.
+	    this.emit('error', err);
+	  }
+	}
+
+	/**
+	 * Wraps a `WebSocket` in a duplex stream.
+	 *
+	 * @param {WebSocket} ws The `WebSocket` to wrap
+	 * @param {Object} [options] The options for the `Duplex` constructor
+	 * @return {Duplex} The duplex stream
+	 * @public
+	 */
+	function createWebSocketStream(ws, options) {
+	  let terminateOnDestroy = true;
+
+	  const duplex = new Duplex({
+	    ...options,
+	    autoDestroy: false,
+	    emitClose: false,
+	    objectMode: false,
+	    writableObjectMode: false
+	  });
+
+	  ws.on('message', function message(msg, isBinary) {
+	    const data =
+	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+	    if (!duplex.push(data)) ws.pause();
+	  });
+
+	  ws.once('error', function error(err) {
+	    if (duplex.destroyed) return;
+
+	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+	    //
+	    // - If the `'error'` event is emitted before the `'open'` event, then
+	    //   `ws.terminate()` is a noop as no socket is assigned.
+	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+	    //   event of the `Receiver` object. The listener already closes the
+	    //   connection by calling `ws.close()`. This allows a close frame to be
+	    //   sent to the other peer. If `ws.terminate()` is called right after this,
+	    //   then the close frame might not be sent.
+	    terminateOnDestroy = false;
+	    duplex.destroy(err);
+	  });
+
+	  ws.once('close', function close() {
+	    if (duplex.destroyed) return;
+
+	    duplex.push(null);
+	  });
+
+	  duplex._destroy = function (err, callback) {
+	    if (ws.readyState === ws.CLOSED) {
+	      callback(err);
+	      process.nextTick(emitClose, duplex);
+	      return;
+	    }
+
+	    let called = false;
+
+	    ws.once('error', function error(err) {
+	      called = true;
+	      callback(err);
+	    });
+
+	    ws.once('close', function close() {
+	      if (!called) callback(err);
+	      process.nextTick(emitClose, duplex);
+	    });
+
+	    if (terminateOnDestroy) ws.terminate();
+	  };
+
+	  duplex._final = function (callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._final(callback);
+	      });
+	      return;
+	    }
+
+	    // If the value of the `_socket` property is `null` it means that `ws` is a
+	    // client websocket and the handshake failed. In fact, when this happens, a
+	    // socket is never assigned to the websocket. Wait for the `'error'` event
+	    // that will be emitted by the websocket.
+	    if (ws._socket === null) return;
+
+	    if (ws._socket._writableState.finished) {
+	      callback();
+	      if (duplex._readableState.endEmitted) duplex.destroy();
+	    } else {
+	      ws._socket.once('finish', function finish() {
+	        // `duplex` is not destroyed here because the `'end'` event will be
+	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+	        callback();
+	      });
+	      ws.close();
+	    }
+	  };
+
+	  duplex._read = function () {
+	    if (ws.isPaused) ws.resume();
+	  };
+
+	  duplex._write = function (chunk, encoding, callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._write(chunk, encoding, callback);
+	      });
+	      return;
+	    }
+
+	    ws.send(chunk, callback);
+	  };
+
+	  duplex.on('end', duplexOnEnd);
+	  duplex.on('error', duplexOnError);
+	  return duplex;
+	}
+
+	stream = createWebSocketStream;
+	return stream;
+}
+
+requireStream();
+
+requireReceiver();
+
+requireSender();
+
 var websocketExports = requireWebsocket();
 const _WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
 
@@ -4241,6 +4430,7 @@ function requireWebsocketServer () {
 
 	const EventEmitter = require$$0$3;
 	const http = require$$2;
+	const { Duplex } = require$$0$2;
 	const { createHash } = require$$1;
 
 	const extension = requireExtension();

package/dist/shared/{crossws.BS81iGZK.mjs → crossws.WpyOHUXc.mjs}

@@ -1,10 +1,8 @@
-import { randomUUID } from 'uncrypto';
-
 const kNodeInspect = /* @__PURE__ */ Symbol.for(
   "nodejs.util.inspect.custom"
 );
 function toBufferLike(val) {
-  if (val === undefined || val === null) {
+  if (val === void 0 || val === null) {
     return "";
   }
   const type = typeof val;
@@ -76,7 +74,7 @@ class Message {
    */
   get id() {
     if (!this.#id) {
-      this.#id = randomUUID();
+      this.#id = crypto.randomUUID();
     }
     return this.#id;
   }
@@ -210,7 +208,13 @@ class Message {
     return this.text();
   }
   [kNodeInspect]() {
-    return { data: this.rawData };
+    return {
+      message: {
+        id: this.id,
+        peer: this.peer,
+        text: this.text()
+      }
+    };
   }
 }
 
@@ -226,18 +230,21 @@ class Peer {
   get context() {
     return this._internal.context ??= {};
   }
+  get namespace() {
+    return this._internal.namespace;
+  }
   /**
    * Unique random [uuid v4](https://developer.mozilla.org/en-US/docs/Glossary/UUID) identifier for the peer.
    */
   get id() {
     if (!this._id) {
-      this._id = randomUUID();
+      this._id = crypto.randomUUID();
     }
     return this._id;
   }
   /** IP address of the peer */
   get remoteAddress() {
-    return undefined;
+    return void 0;
   }
   /** upgrade request */
   get request() {
@@ -290,14 +297,12 @@ class Peer {
     return "WebSocket";
   }
   [kNodeInspect]() {
-    return Object.fromEntries(
-      [
-        ["id", this.id],
-        ["remoteAddress", this.remoteAddress],
-        ["peers", this.peers],
-        ["webSocket", this.websocket]
-      ].filter((p) => p[1])
-    );
+    return {
+      peer: {
+        id: this.id,
+        ip: this.remoteAddress
+      }
+    };
   }
 }
 function createWsProxy(ws, request) {
@@ -313,7 +318,7 @@ function createWsProxy(ws, request) {
             return request?.headers?.get("sec-websocket-extensions") || "";
           }
           case "url": {
-            return request?.url?.replace(/^http/, "ws") || undefined;
+            return request?.url?.replace(/^http/, "ws") || void 0;
           }
         }
       }