crossws 0.1.2 → 0.2.0

package/dist/adapters/node.cjs

@@ -5,8 +5,8 @@ const websocket = require('../shared/crossws.2ed26345.cjs');
 const require$$0 = require('events');
 const require$$2 = require('http');
 const require$$1 = require('crypto');
-const peer = require('../shared/crossws.6009d265.cjs');
-const error = require('../shared/crossws.deae10fd.cjs');
+const types = require('../shared/crossws.c0275b79.cjs');
+const index = require('../index.cjs');
 require('https');
 require('net');
 require('tls');
@@ -620,51 +620,51 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 
 const _WebSocketServer = /*@__PURE__*/websocket.getDefaultExportFromCjs(websocketServer);
 
-const node = peer.defineWebSocketAdapter(
-  (hooks, options = {}) => {
-    const crossws = peer.createCrossWS(hooks, options);
+const node = types.defineWebSocketAdapter(
+  (options = {}) => {
+    const crossws = types.createCrossWS(options);
     const wss = options.wss || new _WebSocketServer({
       noServer: true,
       ...options.serverOptions
     });
     wss.on("connection", (ws, req) => {
-      const peer$1 = new NodeWSPeer({ node: { ws, req, server: wss } });
-      crossws.open(peer$1);
+      const peer = new NodePeer({ node: { ws, req, server: wss } });
+      crossws.callHook("open", peer);
       ws.on("message", (data, isBinary) => {
-        crossws.$("node:message", peer$1, data, isBinary);
+        crossws.$callHook("node:message", peer, data, isBinary);
         if (Array.isArray(data)) {
           data = Buffer.concat(data);
         }
-        crossws.message(peer$1, new peer.WSMessage(data, isBinary));
+        crossws.callHook("message", peer, new types.Message(data, isBinary));
       });
-      ws.on("error", (error$1) => {
-        crossws.$("node:error", peer$1, error$1);
-        crossws.error(peer$1, new error.WebSocketError(error$1));
+      ws.on("error", (error) => {
+        crossws.$callHook("node:error", peer, error);
+        crossws.callHook("error", peer, new index.WSError(error));
       });
       ws.on("close", (code, reason) => {
-        crossws.$("node:close", peer$1, code, reason);
-        crossws.close(peer$1, {
+        crossws.$callHook("node:close", peer, code, reason);
+        crossws.callHook("close", peer, {
           code,
           reason: reason?.toString()
         });
       });
       ws.on("open", () => {
-        crossws.$("node:open", peer$1);
+        crossws.$callHook("node:open", peer);
       });
       ws.on("ping", (data) => {
-        crossws.$("node:ping", peer$1, data);
+        crossws.$callHook("node:ping", peer, data);
       });
       ws.on("pong", (data) => {
-        crossws.$("node:pong", peer$1, data);
+        crossws.$callHook("node:pong", peer, data);
       });
       ws.on(
         "unexpected-response",
         (req2, res) => {
-          crossws.$("node:unexpected-response", peer$1, req2, res);
+          crossws.$callHook("node:unexpected-response", peer, req2, res);
         }
       );
       ws.on("upgrade", (req2) => {
-        crossws.$("node:upgrade", peer$1, req2);
+        crossws.$callHook("node:upgrade", peer, req2);
       });
     });
     wss.on("headers", function(outgoingHeaders, req) {
@@ -690,7 +690,7 @@ const node = peer.defineWebSocketAdapter(
     };
   }
 );
-class NodeWSPeer extends peer.WSPeer {
+class NodePeer extends types.Peer {
   get id() {
     const socket = this.ctx.node.req.socket;
     if (!socket) {
@@ -709,7 +709,7 @@ class NodeWSPeer extends peer.WSPeer {
     return this.ctx.node.ws.readyState;
   }
   send(message, options) {
-    this.ctx.node.ws.send(peer.toBufferLike(message), {
+    this.ctx.node.ws.send(types.toBufferLike(message), {
       compress: options?.compress,
       binary: options?.binary,
       ...options

package/dist/adapters/node.d.cts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.cjs';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.cjs';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { Duplex as Duplex$1 } from 'node:stream';
 import { EventEmitter } from 'events';
@@ -286,13 +286,13 @@ declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends ty
 type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
-interface AdapterOptions extends CrossWSOptions {
+interface NodeAdapter {
+    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+}
+interface NodeOptions extends AdapterOptions {
     wss?: WebSocketServer;
     serverOptions?: ServerOptions;
 }
-interface Adapter {
-    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
-}
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+declare const _default: Adapter<NodeAdapter, NodeOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type NodeAdapter, type NodeOptions, _default as default };

package/dist/adapters/node.d.mts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.mjs';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.mjs';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { Duplex as Duplex$1 } from 'node:stream';
 import { EventEmitter } from 'events';
@@ -286,13 +286,13 @@ declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends ty
 type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
-interface AdapterOptions extends CrossWSOptions {
+interface NodeAdapter {
+    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+}
+interface NodeOptions extends AdapterOptions {
     wss?: WebSocketServer;
     serverOptions?: ServerOptions;
 }
-interface Adapter {
-    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
-}
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+declare const _default: Adapter<NodeAdapter, NodeOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type NodeAdapter, type NodeOptions, _default as default };

package/dist/adapters/node.d.ts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.js';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.js';
 import { IncomingMessage as IncomingMessage$1 } from 'node:http';
 import { Duplex as Duplex$1 } from 'node:stream';
 import { EventEmitter } from 'events';
@@ -286,13 +286,13 @@ declare class Server<T extends typeof WebSocket = typeof WebSocket, U extends ty
 type WebSocketServer = Server;
 declare function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
 
-interface AdapterOptions extends CrossWSOptions {
+interface NodeAdapter {
+    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
+}
+interface NodeOptions extends AdapterOptions {
     wss?: WebSocketServer;
     serverOptions?: ServerOptions;
 }
-interface Adapter {
-    handleUpgrade(req: IncomingMessage$1, socket: Duplex$1, head: Buffer): void;
-}
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+declare const _default: Adapter<NodeAdapter, NodeOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type NodeAdapter, type NodeOptions, _default as default };

package/dist/adapters/node.mjs

@@ -3,8 +3,8 @@ import { v as validationExports, g as getDefaultExportFromCjs, e as extension$1,
 import require$$0 from 'events';
 import require$$2 from 'http';
 import require$$1 from 'crypto';
-import { d as defineWebSocketAdapter, c as createCrossWS, W as WSMessage, a as WSPeer, t as toBufferLike } from '../shared/crossws.a6b0a7cc.mjs';
-import { W as WebSocketError } from '../shared/crossws.6f7f02b3.mjs';
+import { d as defineWebSocketAdapter, M as Message, P as Peer, t as toBufferLike, c as createCrossWS } from '../shared/crossws.61d46dae.mjs';
+import { WSError } from '../index.mjs';
 import 'https';
 import 'net';
 import 'tls';
@@ -613,50 +613,50 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 const _WebSocketServer = /*@__PURE__*/getDefaultExportFromCjs(websocketServer);
 
 const node = defineWebSocketAdapter(
-  (hooks, options = {}) => {
-    const crossws = createCrossWS(hooks, options);
+  (options = {}) => {
+    const crossws = createCrossWS(options);
     const wss = options.wss || new _WebSocketServer({
       noServer: true,
       ...options.serverOptions
     });
     wss.on("connection", (ws, req) => {
-      const peer = new NodeWSPeer({ node: { ws, req, server: wss } });
-      crossws.open(peer);
+      const peer = new NodePeer({ node: { ws, req, server: wss } });
+      crossws.callHook("open", peer);
       ws.on("message", (data, isBinary) => {
-        crossws.$("node:message", peer, data, isBinary);
+        crossws.$callHook("node:message", peer, data, isBinary);
         if (Array.isArray(data)) {
           data = Buffer.concat(data);
         }
-        crossws.message(peer, new WSMessage(data, isBinary));
+        crossws.callHook("message", peer, new Message(data, isBinary));
       });
       ws.on("error", (error) => {
-        crossws.$("node:error", peer, error);
-        crossws.error(peer, new WebSocketError(error));
+        crossws.$callHook("node:error", peer, error);
+        crossws.callHook("error", peer, new WSError(error));
       });
       ws.on("close", (code, reason) => {
-        crossws.$("node:close", peer, code, reason);
-        crossws.close(peer, {
+        crossws.$callHook("node:close", peer, code, reason);
+        crossws.callHook("close", peer, {
           code,
           reason: reason?.toString()
         });
       });
       ws.on("open", () => {
-        crossws.$("node:open", peer);
+        crossws.$callHook("node:open", peer);
       });
       ws.on("ping", (data) => {
-        crossws.$("node:ping", peer, data);
+        crossws.$callHook("node:ping", peer, data);
       });
       ws.on("pong", (data) => {
-        crossws.$("node:pong", peer, data);
+        crossws.$callHook("node:pong", peer, data);
       });
       ws.on(
         "unexpected-response",
         (req2, res) => {
-          crossws.$("node:unexpected-response", peer, req2, res);
+          crossws.$callHook("node:unexpected-response", peer, req2, res);
         }
       );
       ws.on("upgrade", (req2) => {
-        crossws.$("node:upgrade", peer, req2);
+        crossws.$callHook("node:upgrade", peer, req2);
       });
     });
     wss.on("headers", function(outgoingHeaders, req) {
@@ -682,7 +682,7 @@ const node = defineWebSocketAdapter(
     };
   }
 );
-class NodeWSPeer extends WSPeer {
+class NodePeer extends Peer {
   get id() {
     const socket = this.ctx.node.req.socket;
     if (!socket) {

package/dist/adapters/uws.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const peer = require('../shared/crossws.6009d265.cjs');
+const types = require('../shared/crossws.c0275b79.cjs');
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -8,51 +8,58 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-const uws = peer.defineWebSocketAdapter(
-  (hooks, options = {}) => {
-    const crossws = peer.createCrossWS(hooks, options);
-    const getWSPeer = (ws) => {
+const uws = types.defineWebSocketAdapter(
+  (options = {}) => {
+    const crossws = types.createCrossWS(options);
+    const getPeer = (ws) => {
       const userData = ws.getUserData();
       if (userData._peer) {
         return userData._peer;
       }
-      const peer = new UWSWSPeer({ uws: { ws, userData } });
+      const peer = new UWSPeer({ uws: { ws, userData } });
       userData._peer = peer;
       return peer;
     };
     const websocket = {
       ...options.uws,
       close(ws, code, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:close", peer, ws, code, message);
-        crossws.close(peer, { code, reason: message?.toString() });
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:close", peer, ws, code, message);
+        crossws.callHook("close", peer, { code, reason: message?.toString() });
       },
       drain(ws) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:drain", peer, ws);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:drain", peer, ws);
       },
       message(ws, message, isBinary) {
-        const peer$1 = getWSPeer(ws);
-        crossws.$("uws:message", peer$1, ws, message, isBinary);
-        const msg = new peer.WSMessage(message, isBinary);
-        crossws.message(peer$1, msg);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:message", peer, ws, message, isBinary);
+        const msg = new types.Message(message, isBinary);
+        crossws.callHook("message", peer, msg);
       },
       open(ws) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:open", peer, ws);
-        crossws.open(peer);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:open", peer, ws);
+        crossws.callHook("open", peer);
       },
       ping(ws, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:ping", peer, ws, message);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:ping", peer, ws, message);
       },
       pong(ws, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:pong", peer, ws, message);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:pong", peer, ws, message);
       },
       subscription(ws, topic, newCount, oldCount) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:subscription", peer, ws, topic, newCount, oldCount);
+        const peer = getPeer(ws);
+        crossws.$callHook(
+          "uws:subscription",
+          peer,
+          ws,
+          topic,
+          newCount,
+          oldCount
+        );
       },
       async upgrade(res, req, context) {
         let aborted = false;
@@ -94,7 +101,7 @@ const uws = peer.defineWebSocketAdapter(
     };
   }
 );
-class UWSWSPeer extends peer.WSPeer {
+class UWSPeer extends types.Peer {
   constructor() {
     super(...arguments);
     __publicField(this, "_headers");
@@ -122,7 +129,7 @@ class UWSWSPeer extends peer.WSPeer {
   }
   send(message, options) {
     return this.ctx.uws.ws.send(
-      peer.toBufferLike(message),
+      types.toBufferLike(message),
       options?.binary,
       options?.compress
     );

package/dist/adapters/uws.d.cts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.cjs';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.cjs';
 import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
 
 type UserData = {
@@ -8,12 +8,12 @@ type UserData = {
     context: any;
 };
 type WebSocketHandler = WebSocketBehavior<UserData>;
-interface AdapterOptions extends CrossWSOptions {
-    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
-}
-interface Adapter {
+interface UWSAdapter {
     websocket: WebSocketHandler;
 }
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+interface UWSOptions extends AdapterOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+declare const _default: Adapter<UWSAdapter, UWSOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type UWSAdapter, type UWSOptions, _default as default };

package/dist/adapters/uws.d.mts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.mjs';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.mjs';
 import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
 
 type UserData = {
@@ -8,12 +8,12 @@ type UserData = {
     context: any;
 };
 type WebSocketHandler = WebSocketBehavior<UserData>;
-interface AdapterOptions extends CrossWSOptions {
-    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
-}
-interface Adapter {
+interface UWSAdapter {
     websocket: WebSocketHandler;
 }
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+interface UWSOptions extends AdapterOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+declare const _default: Adapter<UWSAdapter, UWSOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type UWSAdapter, type UWSOptions, _default as default };

package/dist/adapters/uws.d.ts

@@ -1,4 +1,4 @@
-import { CrossWSOptions, WebSocketAdapter } from '../index.js';
+import { A as AdapterOptions, b as Adapter } from '../shared/crossws.a2e5c71e.js';
 import { WebSocketBehavior, HttpRequest, HttpResponse } from 'uWebSockets.js';
 
 type UserData = {
@@ -8,12 +8,12 @@ type UserData = {
     context: any;
 };
 type WebSocketHandler = WebSocketBehavior<UserData>;
-interface AdapterOptions extends CrossWSOptions {
-    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
-}
-interface Adapter {
+interface UWSAdapter {
     websocket: WebSocketHandler;
 }
-declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
+interface UWSOptions extends AdapterOptions {
+    uws?: Exclude<WebSocketBehavior<any>, "close" | "drain" | "message" | "open" | "ping" | "pong" | "subscription" | "upgrade">;
+}
+declare const _default: Adapter<UWSAdapter, UWSOptions>;
 
-export { type Adapter, type AdapterOptions, _default as default };
+export { type UWSAdapter, type UWSOptions, _default as default };

package/dist/adapters/uws.mjs

@@ -1,4 +1,4 @@
-import { d as defineWebSocketAdapter, c as createCrossWS, W as WSMessage, a as WSPeer, t as toBufferLike } from '../shared/crossws.a6b0a7cc.mjs';
+import { d as defineWebSocketAdapter, c as createCrossWS, M as Message, P as Peer, t as toBufferLike } from '../shared/crossws.61d46dae.mjs';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -7,50 +7,57 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 const uws = defineWebSocketAdapter(
-  (hooks, options = {}) => {
-    const crossws = createCrossWS(hooks, options);
-    const getWSPeer = (ws) => {
+  (options = {}) => {
+    const crossws = createCrossWS(options);
+    const getPeer = (ws) => {
       const userData = ws.getUserData();
       if (userData._peer) {
         return userData._peer;
       }
-      const peer = new UWSWSPeer({ uws: { ws, userData } });
+      const peer = new UWSPeer({ uws: { ws, userData } });
       userData._peer = peer;
       return peer;
     };
     const websocket = {
       ...options.uws,
       close(ws, code, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:close", peer, ws, code, message);
-        crossws.close(peer, { code, reason: message?.toString() });
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:close", peer, ws, code, message);
+        crossws.callHook("close", peer, { code, reason: message?.toString() });
       },
       drain(ws) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:drain", peer, ws);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:drain", peer, ws);
       },
       message(ws, message, isBinary) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:message", peer, ws, message, isBinary);
-        const msg = new WSMessage(message, isBinary);
-        crossws.message(peer, msg);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:message", peer, ws, message, isBinary);
+        const msg = new Message(message, isBinary);
+        crossws.callHook("message", peer, msg);
       },
       open(ws) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:open", peer, ws);
-        crossws.open(peer);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:open", peer, ws);
+        crossws.callHook("open", peer);
       },
       ping(ws, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:ping", peer, ws, message);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:ping", peer, ws, message);
       },
       pong(ws, message) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:pong", peer, ws, message);
+        const peer = getPeer(ws);
+        crossws.$callHook("uws:pong", peer, ws, message);
       },
       subscription(ws, topic, newCount, oldCount) {
-        const peer = getWSPeer(ws);
-        crossws.$("uws:subscription", peer, ws, topic, newCount, oldCount);
+        const peer = getPeer(ws);
+        crossws.$callHook(
+          "uws:subscription",
+          peer,
+          ws,
+          topic,
+          newCount,
+          oldCount
+        );
       },
       async upgrade(res, req, context) {
         let aborted = false;
@@ -92,7 +99,7 @@ const uws = defineWebSocketAdapter(
     };
   }
 );
-class UWSWSPeer extends WSPeer {
+class UWSPeer extends Peer {
   constructor() {
     super(...arguments);
     __publicField(this, "_headers");

package/dist/index.cjs

@@ -1,15 +1,17 @@
 'use strict';
 
-const peer = require('./shared/crossws.6009d265.cjs');
-const error = require('./shared/crossws.deae10fd.cjs');
+const types = require('./shared/crossws.c0275b79.cjs');
 
-function defineWebSocketHooks(hooks) {
-  return hooks;
+class WSError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = "WSError";
+  }
 }
 
-exports.WSMessage = peer.WSMessage;
-exports.WSPeer = peer.WSPeer;
-exports.createCrossWS = peer.createCrossWS;
-exports.defineWebSocketAdapter = peer.defineWebSocketAdapter;
-exports.WebSocketError = error.WebSocketError;
-exports.defineWebSocketHooks = defineWebSocketHooks;
+exports.Message = types.Message;
+exports.Peer = types.Peer;
+exports.createCrossWS = types.createCrossWS;
+exports.defineHooks = types.defineHooks;
+exports.defineWebSocketAdapter = types.defineWebSocketAdapter;
+exports.WSError = WSError;