elit 2.0.1 → 3.0.0

package/dist/ws.mjs

@@ -0,0 +1,358 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ws.ts
+import { EventEmitter } from "events";
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+
+// src/ws.ts
+var ReadyState = /* @__PURE__ */ ((ReadyState2) => {
+  ReadyState2[ReadyState2["CONNECTING"] = 0] = "CONNECTING";
+  ReadyState2[ReadyState2["OPEN"] = 1] = "OPEN";
+  ReadyState2[ReadyState2["CLOSING"] = 2] = "CLOSING";
+  ReadyState2[ReadyState2["CLOSED"] = 3] = "CLOSED";
+  return ReadyState2;
+})(ReadyState || {});
+var CLOSE_CODES = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS: 1005,
+  ABNORMAL: 1006,
+  INVALID_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  EXTENSION_REQUIRED: 1010,
+  INTERNAL_ERROR: 1011,
+  SERVICE_RESTART: 1012,
+  TRY_AGAIN_LATER: 1013,
+  BAD_GATEWAY: 1014,
+  TLS_HANDSHAKE_FAIL: 1015
+};
+function queueCallback(callback, error) {
+  if (callback) {
+    queueMicrotask(() => callback(error));
+  }
+}
+function createNativeWebSocket(url, protocols) {
+  if (runtime === "node" && typeof globalThis.WebSocket === "undefined") {
+    throw new Error("WebSocket is not available. Please use Node.js 18+ or install ws package.");
+  }
+  return new globalThis.WebSocket(url, protocols);
+}
+var WebSocket = class extends EventEmitter {
+  constructor(address, protocols, _options) {
+    super();
+    this.readyState = 0 /* CONNECTING */;
+    this.protocol = "";
+    this.extensions = "";
+    this.binaryType = "nodebuffer";
+    this.url = typeof address === "string" ? address : address.toString();
+    const protocolsArray = Array.isArray(protocols) ? protocols : protocols ? [protocols] : void 0;
+    this._socket = createNativeWebSocket(this.url, protocolsArray);
+    this._setupNativeSocket();
+  }
+  _setupNativeSocket() {
+    this._socket.onopen = () => {
+      this.readyState = 1 /* OPEN */;
+      this.emit("open");
+    };
+    this._socket.onmessage = (event) => {
+      const isBinary = event.data instanceof ArrayBuffer || event.data instanceof Blob;
+      this.emit("message", event.data, isBinary);
+    };
+    this._socket.onclose = (event) => {
+      this.readyState = 3 /* CLOSED */;
+      this.emit("close", event.code, event.reason);
+    };
+    this._socket.onerror = () => {
+      this.emit("error", new Error("WebSocket error"));
+    };
+  }
+  /**
+   * 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"));
+    }
+    try {
+      this._socket.send(data);
+      queueCallback(cb);
+    } catch (error) {
+      queueCallback(cb, error);
+    }
+  }
+  /**
+   * Close the WebSocket connection
+   */
+  close(code, reason) {
+    if (this.readyState === 3 /* CLOSED */ || this.readyState === 2 /* CLOSING */) {
+      return;
+    }
+    this.readyState = 2 /* CLOSING */;
+    this._socket.close(code, typeof reason === "string" ? reason : reason?.toString());
+  }
+  /**
+   * Pause the socket (no-op for native WebSocket)
+   */
+  pause() {
+  }
+  /**
+   * Resume the socket (no-op for native WebSocket)
+   */
+  resume() {
+  }
+  /**
+   * Send a ping frame (no-op for native WebSocket)
+   */
+  ping(_data, _mask, callback) {
+    queueCallback(callback);
+  }
+  /**
+   * Send a pong frame (no-op for native WebSocket)
+   */
+  pong(_data, _mask, callback) {
+    queueCallback(callback);
+  }
+  /**
+   * Terminate the connection
+   */
+  terminate() {
+    this._socket.close();
+    this.readyState = 3 /* CLOSED */;
+  }
+  /**
+   * Get buffered amount
+   */
+  get bufferedAmount() {
+    return this._socket.bufferedAmount || 0;
+  }
+};
+var WebSocketServer = class extends EventEmitter {
+  constructor(options, callback) {
+    super();
+    this.clients = /* @__PURE__ */ new Set();
+    this.options = options || {};
+    this.path = options?.path || "/";
+    if (runtime === "node") {
+      if (options?.server) {
+        this._httpServer = options.server;
+        this._setupUpgradeHandler();
+      } else if (options?.noServer) {
+      } else {
+        const http = __require("http");
+        this._httpServer = http.createServer();
+        this._setupUpgradeHandler();
+        if (options?.port) {
+          this._httpServer.listen(options.port, options.host, callback);
+        }
+      }
+    } else {
+      queueCallback(callback);
+    }
+  }
+  _setupUpgradeHandler() {
+    this._httpServer.on("upgrade", (request, socket, head) => {
+      console.log("[WebSocket] Upgrade request:", request.url, "Expected:", this.path);
+      if (this.path && this.path !== "/" && request.url !== this.path) {
+        console.log("[WebSocket] Path mismatch, ignoring");
+        return;
+      }
+      this.handleUpgrade(request, socket, head, (client) => {
+        console.log("[WebSocket] Client connected");
+        this.emit("connection", client, request);
+      });
+    });
+  }
+  /**
+   * Handle HTTP upgrade for WebSocket
+   */
+  handleUpgrade(request, socket, _head, callback) {
+    const key = request.headers["sec-websocket-key"];
+    if (!key) {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+      return;
+    }
+    const crypto = __require("crypto");
+    const acceptKey = crypto.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
+    const headers = [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${acceptKey}`,
+      "",
+      ""
+    ];
+    socket.write(headers.join("\r\n"));
+    const client = this._createClientFromSocket(socket);
+    if (this.options.clientTracking !== false) {
+      this.clients.add(client);
+      client.on("close", () => {
+        this.clients.delete(client);
+      });
+    }
+    callback(client);
+  }
+  _createClientFromSocket(socket) {
+    const client = Object.create(WebSocket.prototype);
+    EventEmitter.call(client);
+    client.readyState = 1 /* OPEN */;
+    client.url = "ws://localhost";
+    client.protocol = "";
+    client.extensions = "";
+    client.binaryType = "nodebuffer";
+    client._socket = socket;
+    socket.on("data", (data) => {
+      try {
+        const message = this._parseFrame(data);
+        if (message) {
+          client.emit("message", message, false);
+        }
+      } catch (error) {
+        client.emit("error", error);
+      }
+    });
+    socket.on("end", () => {
+      client.readyState = 3 /* CLOSED */;
+      client.emit("close", CLOSE_CODES.NORMAL, "");
+    });
+    socket.on("error", (error) => {
+      client.emit("error", error);
+    });
+    client.send = (data, _options, callback) => {
+      try {
+        const frame = this._createFrame(data);
+        socket.write(frame);
+        queueCallback(callback);
+      } catch (error) {
+        queueCallback(callback, error);
+      }
+    };
+    client.close = (_code, _reason) => {
+      socket.end();
+      client.readyState = 3 /* CLOSED */;
+    };
+    return 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(callback) {
+    this.clients.forEach((client) => client.close());
+    this.clients.clear();
+    if (this._httpServer) {
+      this._httpServer.close(callback);
+    } else {
+      this.emit("close");
+      queueCallback(callback);
+    }
+  }
+  /**
+   * Check if server should handle request
+   */
+  shouldHandle(request) {
+    if (this.path && request.url !== this.path) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get server address
+   */
+  address() {
+    if (this._httpServer && this._httpServer.address) {
+      return this._httpServer.address();
+    }
+    return null;
+  }
+};
+function createWebSocketServer(options, callback) {
+  return new WebSocketServer(options, callback);
+}
+function getRuntime() {
+  return runtime;
+}
+var ws_default = {
+  WebSocket,
+  WebSocketServer,
+  createWebSocketServer,
+  ReadyState,
+  CLOSE_CODES,
+  getRuntime
+};
+export {
+  CLOSE_CODES,
+  ReadyState,
+  WebSocket,
+  WebSocketServer,
+  createWebSocketServer,
+  ws_default as default,
+  getRuntime
+};

package/dist/wss.d.mts

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+import { IncomingMessage } from './http.mjs';
+import { WebSocket, ServerOptions, ReadyState } from './ws.mjs';
+export { CLOSE_CODES, Data } from './ws.mjs';
+import 'node:events';
+
+/**
+ * WebSocket Secure (WSS) module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'ws' package WSS API
+ * - Node.js: uses native WebSocket with HTTPS
+ * - Bun: uses native WebSocket with TLS
+ * - Deno: uses native WebSocket with TLS
+ */
+
+/**
+ * WSS Server options (extends WebSocket ServerOptions with TLS)
+ */
+interface WSSServerOptions extends ServerOptions {
+    key?: string | Buffer;
+    cert?: string | Buffer;
+    ca?: string | Buffer;
+    passphrase?: string;
+    rejectUnauthorized?: boolean;
+    requestCert?: boolean;
+    httpsServer?: any;
+}
+/**
+ * WebSocket Secure client class
+ */
+declare class WSSClient extends WebSocket {
+    constructor(address: string | URL, protocols?: string | string[], options?: any);
+}
+/**
+ * WebSocket Secure Server class
+ */
+declare class WSSServer extends EventEmitter {
+    clients: Set<WebSocket>;
+    options: WSSServerOptions;
+    path: string;
+    private _httpsServer;
+    private _wsServer;
+    constructor(options?: WSSServerOptions, callback?: () => void);
+    private _setupServer;
+    /**
+     * Handle HTTP upgrade for WebSocket
+     */
+    handleUpgrade(request: IncomingMessage, socket: any, head: Buffer, callback: (client: WebSocket) => void): void;
+    /**
+     * Check if server should handle request
+     */
+    shouldHandle(request: IncomingMessage): boolean;
+    /**
+     * Close the server
+     */
+    close(callback?: (err?: Error) => void): void;
+    /**
+     * Get server address
+     */
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+}
+/**
+ * Create WebSocket Secure client
+ */
+declare function createWSSClient(address: string | URL, protocols?: string | string[], options?: any): WSSClient;
+/**
+ * Create WebSocket Secure server
+ */
+declare function createWSSServer(options?: WSSServerOptions, callback?: () => void): WSSServer;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+
+/**
+ * Default export
+ */
+declare const _default: {
+    WSSClient: typeof WSSClient;
+    WSSServer: typeof WSSServer;
+    createWSSClient: typeof createWSSClient;
+    createWSSServer: typeof createWSSServer;
+    ReadyState: typeof ReadyState;
+    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;
+    };
+    getRuntime: typeof getRuntime;
+};
+
+export { ReadyState, ServerOptions, WSSClient, WSSServer, type WSSServerOptions, createWSSClient, createWSSServer, _default as default, getRuntime };

package/dist/wss.d.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+import { IncomingMessage } from './http.js';
+import { WebSocket, ServerOptions, ReadyState } from './ws.js';
+export { CLOSE_CODES, Data } from './ws.js';
+import 'node:events';
+
+/**
+ * WebSocket Secure (WSS) module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'ws' package WSS API
+ * - Node.js: uses native WebSocket with HTTPS
+ * - Bun: uses native WebSocket with TLS
+ * - Deno: uses native WebSocket with TLS
+ */
+
+/**
+ * WSS Server options (extends WebSocket ServerOptions with TLS)
+ */
+interface WSSServerOptions extends ServerOptions {
+    key?: string | Buffer;
+    cert?: string | Buffer;
+    ca?: string | Buffer;
+    passphrase?: string;
+    rejectUnauthorized?: boolean;
+    requestCert?: boolean;
+    httpsServer?: any;
+}
+/**
+ * WebSocket Secure client class
+ */
+declare class WSSClient extends WebSocket {
+    constructor(address: string | URL, protocols?: string | string[], options?: any);
+}
+/**
+ * WebSocket Secure Server class
+ */
+declare class WSSServer extends EventEmitter {
+    clients: Set<WebSocket>;
+    options: WSSServerOptions;
+    path: string;
+    private _httpsServer;
+    private _wsServer;
+    constructor(options?: WSSServerOptions, callback?: () => void);
+    private _setupServer;
+    /**
+     * Handle HTTP upgrade for WebSocket
+     */
+    handleUpgrade(request: IncomingMessage, socket: any, head: Buffer, callback: (client: WebSocket) => void): void;
+    /**
+     * Check if server should handle request
+     */
+    shouldHandle(request: IncomingMessage): boolean;
+    /**
+     * Close the server
+     */
+    close(callback?: (err?: Error) => void): void;
+    /**
+     * Get server address
+     */
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+}
+/**
+ * Create WebSocket Secure client
+ */
+declare function createWSSClient(address: string | URL, protocols?: string | string[], options?: any): WSSClient;
+/**
+ * Create WebSocket Secure server
+ */
+declare function createWSSServer(options?: WSSServerOptions, callback?: () => void): WSSServer;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+
+/**
+ * Default export
+ */
+declare const _default: {
+    WSSClient: typeof WSSClient;
+    WSSServer: typeof WSSServer;
+    createWSSClient: typeof createWSSClient;
+    createWSSServer: typeof createWSSServer;
+    ReadyState: typeof ReadyState;
+    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;
+    };
+    getRuntime: typeof getRuntime;
+};
+
+export { ReadyState, ServerOptions, WSSClient, WSSServer, type WSSServerOptions, createWSSClient, createWSSServer, _default as default, getRuntime };