elit 3.6.6 → 3.6.7

package/dist/ws.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/ws.ts
+// src/server/ws/index.ts
 var ws_exports = {};
 __export(ws_exports, {
   CLOSE_CODES: () => CLOSE_CODES,
@@ -29,16 +29,8 @@ __export(ws_exports, {
   getRuntime: () => getRuntime
 });
 module.exports = __toCommonJS(ws_exports);
-var import_events = require("events");
-
-// src/runtime.ts
-var runtime = (() => {
-  if (typeof Deno !== "undefined") return "deno";
-  if (typeof Bun !== "undefined") return "bun";
-  return "node";
-})();
 
-// src/ws.ts
+// src/server/ws/constants.ts
 var ReadyState = /* @__PURE__ */ ((ReadyState2) => {
   ReadyState2[ReadyState2["CONNECTING"] = 0] = "CONNECTING";
   ReadyState2[ReadyState2["OPEN"] = 1] = "OPEN";
@@ -63,6 +55,18 @@ var CLOSE_CODES = {
   BAD_GATEWAY: 1014,
   TLS_HANDSHAKE_FAIL: 1015
 };
+
+// src/server/ws/server.ts
+var import_events2 = require("events");
+
+// src/shares/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+
+// src/server/ws/utils.ts
 function queueCallback(callback, error) {
   if (callback) {
     queueMicrotask(() => callback(error));
@@ -78,6 +82,73 @@ function getRequestPath(url) {
   const [pathname = "/"] = (url || "/").split("?");
   return pathname || "/";
 }
+function isIgnorableConnectionError(error) {
+  const errorCode = error?.code;
+  return errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE";
+}
+function coerceBunMessage(message) {
+  const isBinary = typeof message !== "string";
+  const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+  return { payload, isBinary };
+}
+function parseFrame(data) {
+  if (data.length < 2) {
+    return null;
+  }
+  const firstByte = data[0];
+  const secondByte = data[1];
+  const opcode = firstByte & 15;
+  const isMasked = (secondByte & 128) === 128;
+  let payloadLength = secondByte & 127;
+  let offset = 2;
+  if (payloadLength === 126) {
+    payloadLength = data.readUInt16BE(2);
+    offset = 4;
+  } else if (payloadLength === 127) {
+    payloadLength = Number(data.readBigUInt64BE(2));
+    offset = 10;
+  }
+  let payload = data.subarray(offset);
+  if (isMasked) {
+    const maskKey = data.subarray(offset, offset + 4);
+    payload = data.subarray(offset + 4, offset + 4 + payloadLength);
+    for (let index = 0; index < payload.length; index += 1) {
+      payload[index] ^= maskKey[index % 4];
+    }
+  }
+  if (opcode === 1) {
+    return payload.toString("utf8");
+  }
+  return null;
+}
+function createFrame(data) {
+  const payload = typeof data === "string" ? Buffer.from(data) : data;
+  const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
+  let frame;
+  let offset = 2;
+  if (payloadLength < 126) {
+    frame = Buffer.allocUnsafe(2 + payloadLength);
+    frame[1] = payloadLength;
+  } else if (payloadLength < 65536) {
+    frame = Buffer.allocUnsafe(4 + payloadLength);
+    frame[1] = 126;
+    frame.writeUInt16BE(payloadLength, 2);
+    offset = 4;
+  } else {
+    frame = Buffer.allocUnsafe(10 + payloadLength);
+    frame[1] = 127;
+    frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+    offset = 10;
+  }
+  frame[0] = 129;
+  if (Buffer.isBuffer(payload)) {
+    payload.copy(frame, offset);
+  }
+  return frame;
+}
+
+// src/server/ws/websocket.ts
+var import_events = require("events");
 var WebSocket = class extends import_events.EventEmitter {
   constructor(address, protocols, _options) {
     super();
@@ -108,12 +179,13 @@ var WebSocket = class extends import_events.EventEmitter {
     };
   }
   /**
-   * Send data through WebSocket
+   * Send data through WebSocket.
    */
   send(data, options, callback) {
     const cb = typeof options === "function" ? options : callback;
     if (this.readyState !== 1 /* OPEN */) {
-      return queueCallback(cb, new Error("WebSocket is not open"));
+      queueCallback(cb, new Error("WebSocket is not open"));
+      return;
     }
     try {
       this._socket.send(data);
@@ -123,7 +195,7 @@ var WebSocket = class extends import_events.EventEmitter {
     }
   }
   /**
-   * Close the WebSocket connection
+   * Close the WebSocket connection.
    */
   close(code, reason) {
     if (this.readyState === 3 /* CLOSED */ || this.readyState === 2 /* CLOSING */) {
@@ -133,42 +205,44 @@ var WebSocket = class extends import_events.EventEmitter {
     this._socket.close(code, typeof reason === "string" ? reason : reason?.toString());
   }
   /**
-   * Pause the socket (no-op for native WebSocket)
+   * Pause the socket (no-op for native WebSocket).
    */
   pause() {
   }
   /**
-   * Resume the socket (no-op for native WebSocket)
+   * Resume the socket (no-op for native WebSocket).
    */
   resume() {
   }
   /**
-   * Send a ping frame (no-op for native WebSocket)
+   * Send a ping frame (no-op for native WebSocket).
    */
   ping(_data, _mask, callback) {
     queueCallback(callback);
   }
   /**
-   * Send a pong frame (no-op for native WebSocket)
+   * Send a pong frame (no-op for native WebSocket).
    */
   pong(_data, _mask, callback) {
     queueCallback(callback);
   }
   /**
-   * Terminate the connection
+   * Terminate the connection.
    */
   terminate() {
     this._socket.close();
     this.readyState = 3 /* CLOSED */;
   }
   /**
-   * Get buffered amount
+   * Get buffered amount.
    */
   get bufferedAmount() {
     return this._socket.bufferedAmount || 0;
   }
 };
-var WebSocketServer = class extends import_events.EventEmitter {
+
+// src/server/ws/server.ts
+var WebSocketServer = class extends import_events2.EventEmitter {
   constructor(options, callback) {
     super();
     this.clients = /* @__PURE__ */ new Set();
@@ -179,8 +253,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
       if (options?.server) {
         this._httpServer = options.server;
         this._setupUpgradeHandler();
-      } else if (options?.noServer) {
-      } else {
+      } else if (!options?.noServer) {
         const http = require("http");
         this._httpServer = http.createServer();
         this._ownsHttpServer = true;
@@ -214,7 +287,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
     });
   }
   /**
-   * Handle HTTP upgrade for WebSocket
+   * Handle HTTP upgrade for WebSocket.
    */
   handleUpgrade(request, socket, _head, callback) {
     const key = request.headers["sec-websocket-key"];
@@ -244,7 +317,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
   }
   _createClientFromSocket(socket) {
     const client = Object.create(WebSocket.prototype);
-    import_events.EventEmitter.call(client);
+    import_events2.EventEmitter.call(client);
     client.readyState = 1 /* OPEN */;
     client.url = "ws://localhost";
     client.protocol = "";
@@ -253,7 +326,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
     client._socket = socket;
     socket.on("data", (data) => {
       try {
-        const message = this._parseFrame(data);
+        const message = parseFrame(data);
         if (message) {
           client.emit("message", message, false);
         }
@@ -266,33 +339,31 @@ var WebSocketServer = class extends import_events.EventEmitter {
       client.emit("close", CLOSE_CODES.NORMAL, "");
     });
     socket.on("error", (error) => {
-      const errorCode = error.code;
-      if (errorCode === "ECONNABORTED" || errorCode === "ECONNRESET" || errorCode === "EPIPE") {
+      if (isIgnorableConnectionError(error)) {
         return;
       }
       client.emit("error", error);
     });
     client.send = (data, _options, callback) => {
       if (!socket.writable || client.readyState !== 1 /* OPEN */) {
-        const err = new Error("WebSocket is not open");
-        err.code = "WS_NOT_OPEN";
-        queueCallback(callback, err);
+        const error = new Error("WebSocket is not open");
+        error.code = "WS_NOT_OPEN";
+        queueCallback(callback, error);
         return;
       }
       try {
-        const frame = this._createFrame(data);
-        socket.write(frame, (err) => {
-          if (err) {
-            const errorCode = err.code;
-            if (errorCode !== "ECONNABORTED" && errorCode !== "ECONNRESET" && errorCode !== "EPIPE") {
-              queueCallback(callback, err);
-            } else {
-              client.readyState = 3 /* CLOSED */;
-              queueCallback(callback);
-            }
-          } else {
+        const frame = createFrame(data);
+        socket.write(frame, (error) => {
+          if (!error) {
             queueCallback(callback);
+            return;
           }
+          if (isIgnorableConnectionError(error)) {
+            client.readyState = 3 /* CLOSED */;
+            queueCallback(callback);
+            return;
+          }
+          queueCallback(callback, error);
         });
       } catch (error) {
         queueCallback(callback, error);
@@ -306,7 +377,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
   }
   _createClientFromBunSocket(socket) {
     const client = Object.create(WebSocket.prototype);
-    import_events.EventEmitter.call(client);
+    import_events2.EventEmitter.call(client);
     client.readyState = 1 /* OPEN */;
     client.url = "ws://localhost";
     client.protocol = "";
@@ -330,7 +401,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
         return;
       }
       client.readyState = 2 /* CLOSING */;
-      socket.close(code ?? CLOSE_CODES.NORMAL, reason);
+      socket.close(code ?? CLOSE_CODES.NORMAL, typeof reason === "string" ? reason : reason?.toString());
     };
     client.terminate = () => {
       socket.close();
@@ -361,8 +432,7 @@ var WebSocketServer = class extends import_events.EventEmitter {
     if (!client) {
       return;
     }
-    const isBinary = typeof message !== "string";
-    const payload = typeof message === "string" ? message : message instanceof ArrayBuffer ? Buffer.from(message) : ArrayBuffer.isView(message) ? Buffer.from(message.buffer, message.byteOffset, message.byteLength) : Buffer.from(String(message));
+    const { payload, isBinary } = coerceBunMessage(message);
     client.emit("message", payload, isBinary);
   }
   _handleBunClose(socket, code, reason) {
@@ -374,77 +444,24 @@ var WebSocketServer = class extends import_events.EventEmitter {
     client.emit("close", code, typeof reason === "string" ? reason : reason?.toString() || "");
     this.clients.delete(client);
   }
-  _parseFrame(data) {
-    if (data.length < 2) return null;
-    const firstByte = data[0];
-    const secondByte = data[1];
-    const opcode = firstByte & 15;
-    const isMasked = (secondByte & 128) === 128;
-    let payloadLength = secondByte & 127;
-    let offset = 2;
-    if (payloadLength === 126) {
-      payloadLength = data.readUInt16BE(2);
-      offset = 4;
-    } else if (payloadLength === 127) {
-      payloadLength = Number(data.readBigUInt64BE(2));
-      offset = 10;
-    }
-    let payload = data.subarray(offset);
-    if (isMasked) {
-      const maskKey = data.subarray(offset, offset + 4);
-      payload = data.subarray(offset + 4, offset + 4 + payloadLength);
-      for (let i = 0; i < payload.length; i++) {
-        payload[i] ^= maskKey[i % 4];
-      }
-    }
-    if (opcode === 1) {
-      return payload.toString("utf8");
-    }
-    return null;
-  }
-  _createFrame(data) {
-    const payload = typeof data === "string" ? Buffer.from(data) : data;
-    const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
-    let frame;
-    let offset = 2;
-    if (payloadLength < 126) {
-      frame = Buffer.allocUnsafe(2 + payloadLength);
-      frame[1] = payloadLength;
-    } else if (payloadLength < 65536) {
-      frame = Buffer.allocUnsafe(4 + payloadLength);
-      frame[1] = 126;
-      frame.writeUInt16BE(payloadLength, 2);
-      offset = 4;
-    } else {
-      frame = Buffer.allocUnsafe(10 + payloadLength);
-      frame[1] = 127;
-      frame.writeBigUInt64BE(BigInt(payloadLength), 2);
-      offset = 10;
-    }
-    frame[0] = 129;
-    if (Buffer.isBuffer(payload)) {
-      payload.copy(frame, offset);
-    }
-    return frame;
-  }
   /**
-   * Close the server
+   * Close the server.
    */
   close(callback) {
     this.clients.forEach((client) => client.close());
     this.clients.clear();
     if (this._httpServer && this._ownsHttpServer) {
       this._httpServer.close(callback);
-    } else {
-      if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
-        this._httpServer.unregisterWebSocketServer(this);
-      }
-      this.emit("close");
-      queueCallback(callback);
+      return;
+    }
+    if (runtime === "bun" && this._httpServer?.unregisterWebSocketServer) {
+      this._httpServer.unregisterWebSocketServer(this);
     }
+    this.emit("close");
+    queueCallback(callback);
   }
   /**
-   * Check if server should handle request
+   * Check if server should handle request.
    */
   shouldHandle(request) {
     if (this.path && getRequestPath(request.url) !== this.path) {
@@ -453,10 +470,10 @@ var WebSocketServer = class extends import_events.EventEmitter {
     return true;
   }
   /**
-   * Get server address
+   * Get server address.
    */
   address() {
-    if (this._httpServer && this._httpServer.address) {
+    if (this._httpServer?.address) {
       return this._httpServer.address();
     }
     return null;
@@ -465,9 +482,13 @@ var WebSocketServer = class extends import_events.EventEmitter {
 function createWebSocketServer(options, callback) {
   return new WebSocketServer(options, callback);
 }
+
+// src/server/ws/runtime.ts
 function getRuntime() {
   return runtime;
 }
+
+// src/server/ws/ws.ts
 var ws_default = {
   WebSocket,
   WebSocketServer,

package/dist/ws.d.ts

@@ -1,129 +1,11 @@
+import { W as WebSocket, S as ServerOptions, R as ReadyState } from './websocket-XfyK23zD.js';
+export { C as CLOSE_CODES, D as Data, a as SendOptions, V as VerifyClientCallback } from './websocket-XfyK23zD.js';
 import { EventEmitter } from 'events';
-import { IncomingMessage } from './http.js';
+import { I as IncomingMessage } from './types-DAisuVr5.js';
 import 'node:events';
 
 /**
- * WebSocket module with unified API across runtimes
- * Pure implementation without external dependencies
- * - Node.js: uses native 'ws' module (built-in WebSocket implementation)
- * - Bun: uses native WebSocket
- * - Deno: uses native WebSocket
- */
-
-/**
- * WebSocket ready state
- */
-declare enum ReadyState {
-    CONNECTING = 0,
-    OPEN = 1,
-    CLOSING = 2,
-    CLOSED = 3
-}
-/**
- * WebSocket close codes
- */
-declare const CLOSE_CODES: {
-    readonly NORMAL: 1000;
-    readonly GOING_AWAY: 1001;
-    readonly PROTOCOL_ERROR: 1002;
-    readonly UNSUPPORTED_DATA: 1003;
-    readonly NO_STATUS: 1005;
-    readonly ABNORMAL: 1006;
-    readonly INVALID_DATA: 1007;
-    readonly POLICY_VIOLATION: 1008;
-    readonly MESSAGE_TOO_BIG: 1009;
-    readonly EXTENSION_REQUIRED: 1010;
-    readonly INTERNAL_ERROR: 1011;
-    readonly SERVICE_RESTART: 1012;
-    readonly TRY_AGAIN_LATER: 1013;
-    readonly BAD_GATEWAY: 1014;
-    readonly TLS_HANDSHAKE_FAIL: 1015;
-};
-/**
- * WebSocket data types
- */
-type Data = string | Buffer | ArrayBuffer | Buffer[];
-/**
- * WebSocket send options
- */
-interface SendOptions {
-    binary?: boolean;
-    compress?: boolean;
-    fin?: boolean;
-    mask?: boolean;
-}
-/**
- * WebSocket server options
- */
-interface ServerOptions {
-    host?: string;
-    port?: number;
-    backlog?: number;
-    server?: any;
-    verifyClient?: VerifyClientCallback;
-    handleProtocols?: (protocols: Set<string>, request: IncomingMessage) => string | false;
-    path?: string;
-    noServer?: boolean;
-    clientTracking?: boolean;
-    perMessageDeflate?: boolean | object;
-    maxPayload?: number;
-}
-/**
- * Verify client callback
- */
-type VerifyClientCallback = (info: {
-    origin: string;
-    secure: boolean;
-    req: IncomingMessage;
-}, callback?: (result: boolean, code?: number, message?: string) => void) => boolean | void;
-/**
- * WebSocket class - Pure implementation
- */
-declare class WebSocket extends EventEmitter {
-    readyState: ReadyState;
-    url: string;
-    protocol: string;
-    extensions: string;
-    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
-    /** @internal */
-    _socket: any;
-    constructor(address: string | URL, protocols?: string | string[], _options?: any);
-    private _setupNativeSocket;
-    /**
-     * Send data through WebSocket
-     */
-    send(data: Data, options?: SendOptions | ((err?: Error) => void), callback?: (err?: Error) => void): void;
-    /**
-     * Close the WebSocket connection
-     */
-    close(code?: number, reason?: string | Buffer): void;
-    /**
-     * Pause the socket (no-op for native WebSocket)
-     */
-    pause(): void;
-    /**
-     * Resume the socket (no-op for native WebSocket)
-     */
-    resume(): void;
-    /**
-     * Send a ping frame (no-op for native WebSocket)
-     */
-    ping(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
-    /**
-     * Send a pong frame (no-op for native WebSocket)
-     */
-    pong(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
-    /**
-     * Terminate the connection
-     */
-    terminate(): void;
-    /**
-     * Get buffered amount
-     */
-    get bufferedAmount(): number;
-}
-/**
- * WebSocket Server - Server-side WebSocket implementation
+ * WebSocket server implementation.
  */
 declare class WebSocketServer extends EventEmitter {
     clients: Set<WebSocket>;
@@ -134,7 +16,7 @@ declare class WebSocketServer extends EventEmitter {
     constructor(options?: ServerOptions, callback?: () => void);
     private _setupUpgradeHandler;
     /**
-     * Handle HTTP upgrade for WebSocket
+     * Handle HTTP upgrade for WebSocket.
      */
     handleUpgrade(request: IncomingMessage, socket: any, _head: Buffer, callback: (client: WebSocket) => void): void;
     private _createClientFromSocket;
@@ -142,18 +24,16 @@ declare class WebSocketServer extends EventEmitter {
     _handleBunOpen(socket: any, request?: Partial<IncomingMessage>): void;
     _handleBunMessage(socket: any, message: any): void;
     _handleBunClose(socket: any, code: number, reason: any): void;
-    private _parseFrame;
-    private _createFrame;
     /**
-     * Close the server
+     * Close the server.
      */
     close(callback?: (err?: Error) => void): void;
     /**
-     * Check if server should handle request
+     * Check if server should handle request.
      */
     shouldHandle(request: IncomingMessage): boolean;
     /**
-     * Get server address
+     * Get server address.
      */
     address(): {
         port: number;
@@ -162,13 +42,23 @@ declare class WebSocketServer extends EventEmitter {
     } | null;
 }
 /**
- * Create WebSocket server
+ * Create WebSocket server.
  */
 declare function createWebSocketServer(options?: ServerOptions, callback?: () => void): WebSocketServer;
+
 /**
- * Get current runtime
+ * Get current runtime.
  */
 declare function getRuntime(): 'node' | 'bun' | 'deno';
+
+/**
+ * WebSocket module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * - Node.js: uses native 'ws' module (built-in WebSocket implementation)
+ * - Bun: uses native WebSocket
+ * - Deno: uses native WebSocket
+ */
+
 /**
  * Default export
  */
@@ -197,4 +87,4 @@ declare const _default: {
     getRuntime: typeof getRuntime;
 };
 
-export { CLOSE_CODES, type Data, ReadyState, type SendOptions, type ServerOptions, type VerifyClientCallback, WebSocket, WebSocketServer, createWebSocketServer, _default as default, getRuntime };
+export { ReadyState, ServerOptions, WebSocket, WebSocketServer, createWebSocketServer, _default as default, getRuntime };