vortez 5.0.2 → 6.0.0-dev.1

package/build/server/websocket/WebsocketBase.js

@@ -0,0 +1,272 @@
+/**
+ * @author NetFeez <netfeez.dev@gmail.com>
+ * @description adds websocket functionality to Vortez
+ * @license Apache-2.0
+ */
+import { randomUUID } from 'crypto';
+import { Events } from '@netfeez/common';
+import LoggerManager from '../LoggerManager.js';
+import Codec from './Codec.js';
+import Frame from './frame/Frame.js';
+import MessageAssembler from './messageAssembler/MessageAssembler.js';
+const logger = LoggerManager.getInstance().webSocket;
+export class WebsocketBase extends Events {
+    connection;
+    vStatus = 'handshake';
+    vEventBuffer = {};
+    vEventBuffering = true;
+    assembler;
+    surplus = Buffer.alloc(0);
+    constructor(connection) {
+        super();
+        this.connection = connection;
+        this.assembler = new MessageAssembler();
+    }
+    get isClosed() { return this.connection.readableEnded; }
+    get status() { return this.vStatus; }
+    /**
+     * Sends a JSON-serializable object through the WebSocket connection as a text frame. The object is first serialized to a JSON string before being sent.
+     * @param data - The JSON-serializable object to be sent through the WebSocket connection.
+     */
+    sendJson(data) {
+        const jsonString = JSON.stringify(data);
+        this.send(jsonString);
+    }
+    /**
+     * Sends data through the WebSocket connection.
+     * The data can be either a string (which will be sent as a text frame) or a Buffer (which will be sent as a binary frame).
+     * If the connection is not open, a warning is logged and the data is not sent.
+     * @param data - The data to be sent through the WebSocket connection, which can be either a string or a Buffer.
+     * @remarks The method first checks the status of the connection to ensure that it is open before attempting to send data. If the connection is closed or still in the handshake phase, a warning is logged to inform the developer that data cannot be sent in the current state. If the connection is open, the method calls the internal `write` method to handle encoding and sending the data through the WebSocket connection.
+     */
+    send(data) {
+        if (typeof data === 'string')
+            return this.write(Buffer.from(data, 'utf-8'), 0x1);
+        else if (data instanceof Buffer)
+            return this.write(data, 0x2);
+        const stack = new Error().stack || '';
+        return logger.warn('&C3Unsupported data type for Websocket.send. Data must be a string or a Buffer.\nStack trace:\n&C0' + stack);
+    }
+    /**
+     * Sends a ping frame through the WebSocket connection and waits for a corresponding pong response to measure the round-trip time (RTT) of the ping-pong exchange. The method returns a promise that resolves with the measured RTT in milliseconds or rejects if a timeout occurs or if there is an error during the process.
+     * @param options - An optional object containing configuration options for the ping operation, including:
+     *   - `timeout`: The maximum time to wait for a pong response before rejecting the promise (default is 5000 milliseconds).
+     *   - `data`: Optional data to include in the ping frame, which can be a Buffer or a string. If a string is provided, it will be converted to a Buffer using UTF-8 encoding.
+     * @returns A promise that resolves with the measured round-trip time (RTT) in milliseconds if a pong response is received within the specified timeout, or rejects with an error if a timeout occurs or if there is an issue during the ping-pong exchange.
+     */
+    async ping(options = {}) {
+        const { timeout = 5000, data = randomUUID(), } = options;
+        const buffer = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
+        const start = Date.now();
+        return new Promise((resolve, reject) => {
+            const handler = (payload) => {
+                if (payload.equals(buffer)) {
+                    cleanup();
+                    resolve(Date.now() - start);
+                }
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Ping timeout after ${timeout}ms`));
+            }, timeout);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.off('pong', handler);
+            };
+            this.on('pong', handler);
+            try {
+                this.write(buffer, 0x09);
+            }
+            catch (error) {
+                cleanup();
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Closes the WebSocket connection by sending a close frame and ending the connection. If the connection is already closed, this method does nothing.
+      * - It first checks if the connection is already closed, and if so, it simply returns without performing any actions.
+      * - If the connection is not closed, it updates the internal status to 'closed', sends a close frame to the peer, and ends the connection.
+      * @remarks This method ensures that the WebSocket connection is properly closed by sending the appropriate close frame and terminating the connection. It also prevents any further actions from being taken on a closed connection by checking the status before attempting to close it again.
+     */
+    close() {
+        this.write(Buffer.alloc(0), 0x8);
+        this.vStatus = 'closed';
+        this.connection.end();
+    }
+    /**
+     * Writes the given buffer with the specified opcode to the WebSocket connection.
+     * This method is responsible for encoding the data into a WebSocket frame format and sending it through the underlying connection.
+     * In the base implementation, it uses the `encode` method to perform the encoding, which can be overridden in subclasses to provide different encoding strategies (e.g., masking for client-to-server communication).
+     * @param buffer - The data buffer to be encoded and sent through the WebSocket connection.
+     * @param opcode - The opcode indicating the type of frame being sent (e.g., 0x1 for text frames, 0x2 for binary frames).
+     * @remarks This method is designed to be overridden in client-side implementations to allow for different encoding strategies, such as masking frames for client-to-server communication. In the base implementation, it simply encodes the buffer using the standard `encode` method and writes it to the connection, but subclasses can provide their own encoding logic as necessary.
+     */
+    write(buffer, opcode) {
+        if (this.vStatus !== 'open')
+            return logger.warn('&C3Attempted to send data on a WebSocket connection that is not open. Data will not be sent.');
+        if (this.connection.writableEnded ||
+            this.connection.destroyed ||
+            !this.connection.writable) {
+            this.vStatus = 'closed';
+            this.emit('close');
+            const stack = new Error().stack || '';
+            return logger.warn(`&C3Attempted to send data on a WebSocket connection that is already closed. Data will not be sent. ${stack}`);
+        }
+        const frame = this.encode(buffer, opcode);
+        this.connection.write(frame);
+    }
+    /**
+     * flush pending events. This method is used to emit any buffered events that were stored while there were no listeners for those events.
+     * It checks for buffered 'message', 'message:text', 'message:binary', and 'error' events and emits them if there are listeners available.
+     * Additionally, it handles re-emission of 'open' and 'close' events if they were emitted before listeners were added.
+     * This ensures that all relevant events are properly emitted to listeners once they are registered, allowing for correct handling of WebSocket events in the application.
+     *
+     * If you are using this class as a we client, you can use it after add your listeners.
+     *
+     * If you are using this class as a web server, you can use it after routing and executed the action rule on the router o middleware exec (vortez context).
+     *
+     * Here in **Vortez**, the WebsocketSSInit instance is created in the router on receive upgrade request.
+     * Before it is executed the middleware stack -> executed the action rule on the router and automatically is called flush() method to emit the buffered events.
+     * we are sure that the events will be received with your instance of Websocket on server side if you use `vortez`
+     *
+     * If you are using the class as a client ``WebsocketCSInit`` or out of Vortez, you can call it after add your listeners to make sure that you will receive the events emitted during the handshake phase.
+     * @remarks This method is essential for ensuring that all relevant events are emitted to listeners, especially in cases where events may have been emitted before listeners were registered. By calling this method after adding listeners, you can ensure that any buffered events are properly emitted and handled by the listeners, allowing for correct functionality of the WebSocket connection in your application.
+     */
+    flush() {
+        this.vEventBuffering = false;
+        const is = (name) => { return name in this.vEventBuffer; };
+        for (const name in this.vEventBuffer) {
+            if (!is(name))
+                continue;
+            const buffer = this.vEventBuffer[name] ?? [];
+            for (const args of buffer)
+                super.emit(name, ...args);
+            delete this.vEventBuffer[name];
+        }
+    }
+    /**
+     * ====== Override this method in Client side to use different codec ======
+     *
+     * Encodes the given buffer with the specified opcode and sends it through the WebSocket connection. This method is responsible for encoding the data into a WebSocket frame format and writing it to the underlying connection.
+     * In the base implementation, it uses the Codec.encode method to perform the encoding, but this method can be overridden in subclasses (such as WebsocketCSInit) to use a different encoding strategy if needed.
+     * @param buffer - The data buffer to be encoded and sent through the WebSocket connection.
+     * @param opcode - The opcode indicating the type of frame being sent (e.g., 0x1 for text frames, 0x2 for binary frames).
+     * @returns the encoded buffer that was sent through the connection. This allows for further processing or logging of the encoded data if necessary.
+     * @remarks This method is designed to be overridden in client-side implementations to allow for different encoding strategies, such as masking frames for client-to-server communication. In the base implementation, it simply encodes the buffer using the standard Codec.encode method and writes it to the connection, but subclasses can provide their own encoding logic as necessary.
+     */
+    encode(buffer, opcode) {
+        return Codec.encode(buffer, opcode);
+    }
+    /**
+     * Initializes the WebSocket connection by setting up event listeners for incoming data, message assembly, and connection events.
+     * This method is called after a successful handshake to start processing WebSocket frames and messages.
+     * It listens for 'data' events on the socket to process incoming frames, and uses the MessageAssembler to assemble complete messages from the frames.
+     * It also handles control frames (like close and ping) appropriately, emitting events for messages, errors, and connection closures as needed.
+      * @remarks The method sets up a 'data' event listener on the socket to process incoming data buffers. It uses the MessageAssembler to handle the assembly of messages from frames, emitting 'message' events when complete messages are assembled. It also handles control frames such as close and ping, emitting a 'close' event when a close frame is received and responding to ping frames with pong frames. Additionally, it listens for 'close' and 'error' events on the socket to emit corresponding events for the WebSocket instance.
+     */
+    startup() {
+        this.assembler.on('message', (message) => {
+            if (message.isText || message.isBinary) {
+                this.emit('message', message);
+                if (message.isText)
+                    this.emit('message:text', message.payload.toString('utf-8'));
+                else if (message.isBinary)
+                    this.emit('message:binary', message.payload);
+            }
+            else if (message.isClose) {
+                if (this.vStatus === 'closed')
+                    return;
+                if (this.connection.writable && !this.connection.writableEnded) {
+                    try {
+                        this.write(message.payload, 0x8);
+                    }
+                    catch (error) { }
+                }
+                this.vStatus = 'closed';
+                this.connection.end();
+                this.emit('close');
+            }
+            else if (message.isPing) {
+                this.emit('ping', message.payload);
+                this.write(message.payload, 0xA);
+            }
+            else if (message.isPong) {
+                this.emit('pong', message.payload);
+            }
+        });
+        this.assembler.on('error', (error) => {
+            this.vStatus = 'closed';
+            this.emit('error', error);
+            this.encode(Buffer.alloc(0), 0x8);
+            this.connection.end();
+        });
+        this.connection.on('data', (data) => {
+            if (this.surplus.length > 0) {
+                data = Buffer.concat([this.surplus, data]);
+                this.surplus = Buffer.alloc(0);
+            }
+            this.processBuffer(data);
+        });
+        this.connection.on('close', () => {
+            this.vStatus = 'closed';
+            this.emit('close');
+        });
+        this.connection.on('error', this.emit.bind(this, 'error'));
+    }
+    /**
+     * Procesa el buffer recibido, extrayendo todos los frames completos y acumulando el surplus.
+     * Se encarga de manejar errores de parsing y de empujar los frames al assembler.
+     */
+    processBuffer(data) {
+        try {
+            while (data.length > 0) {
+                let result;
+                try {
+                    result = Frame.fromBuffer(data);
+                }
+                catch (error) {
+                    if (error instanceof RangeError) {
+                        this.surplus = data;
+                        break;
+                    }
+                    else if (error instanceof Error) {
+                        this.emit('error', error);
+                        break;
+                    }
+                    else {
+                        this.emit('error', new Error(String(error)));
+                        break;
+                    }
+                }
+                const { frame, chunk, surplus: rest } = result;
+                this.assembler.push(frame);
+                data = rest;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error)
+                this.emit('error', error);
+            else
+                this.emit('error', new Error(String(error)));
+        }
+    }
+    /**
+     * Middleware for emitting events. It handles buffering of messages and errors when there are no listeners, and re-emits 'open' and 'close' events if they were emitted before listeners were added.
+     * This method overrides the base emit method to provide additional functionality specific to WebSocket event handling, such as buffering messages and errors until listeners are available, and ensuring that 'open' and 'close' events are emitted appropriately based on the connection status and listener presence.
+     * @param event - The event to be emitted, which includes the event name and any associated arguments. The method processes the event based on its type and manages buffering and re-emission logic as needed.
+     */
+    emit(...event) {
+        if (!this.vEventBuffering)
+            return super.emit(...event);
+        const [name, ...args] = event;
+        if (this.vEventBuffering && this.eventCount(name) === 0) {
+            this.vEventBuffer[name] = this.vEventBuffer[name] ?? [];
+            this.vEventBuffer[name].push(args);
+        }
+        else
+            super.emit(...event);
+    }
+}
+export default WebsocketBase;
+//# sourceMappingURL=WebsocketBase.js.map

package/build/server/websocket/WebsocketBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketBase.js","sourceRoot":"","sources":["../../../src/server/websocket/WebsocketBase.ts"],"names":[],"mappings":"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"}

package/build/server/websocket/WebsocketCSInit.d.ts

@@ -0,0 +1,57 @@
+import type { Duplex } from 'stream';
+import CSHandShaker from './handshake/CSHandshaker.js';
+import WebsocketBase from './WebsocketBase.js';
+export declare class WebsocketCSInit extends WebsocketBase {
+    protected handshaker: CSHandShaker;
+    request: WebsocketCSInit.Request;
+    constructor(socket: Duplex, request: WebsocketCSInit.Request);
+    protected encode(buffer: Buffer, opcode: number): Buffer;
+    /**
+     * Handles the WebSocket handshake process by listening for 'finish' and 'error' events from the CSHandShaker instance.
+     * When the handshake is completed successfully, it updates the connection status to 'open', initializes the WebSocket connection, and emits an 'open' event. If the handshake fails or encounters an error, it updates the status to 'closed' and emits a 'close' or 'error' event accordingly.
+     * This method is called internally during the construction of the WebsocketCSInit instance to automatically manage the handshake process when a new connection is established.
+     */
+    protected handshake(): void;
+    /**
+     * Establishes a WebSocket connection to the specified URL by performing the necessary handshake process. This method parses the provided URL, creates a socket connection to the server, and then initiates the WebSocket handshake to establish a full-duplex communication channel.
+     * @param url - The WebSocket URL to connect to, which should include the protocol (ws:// or wss://), host, optional port, and path.
+     * @returns A promise that resolves to a Websocket instance representing the established connection if the handshake is successful, or rejects with an error if the handshake fails or if there are issues during the connection process.
+     * @remarks The method first parses the URL to extract the necessary components (protocol, host, port, path), then creates a socket connection based on the protocol (using TLS for wss and a regular TCP socket for ws). After establishing the socket connection, it performs the WebSocket handshake using the CSHandShaker class.
+     * If the handshake is successful, it initializes a new ClientInit instance with the established socket and resolves the promise with this instance. If any errors occur during parsing, socket creation, or handshake, the promise is rejected with the corresponding error.
+     */
+    static connect(url: string): Promise<WebsocketBase>;
+    /**
+     * Creates a socket connection to the specified host and port using the appropriate protocol (TCP for ws and TLS for wss).
+     * This method is used internally to establish the underlying connection before performing the WebSocket handshake.
+     * @param protocol - The protocol to use for the connection, which should be either 'ws:' for a regular TCP connection or 'wss:' for a secure TLS connection.
+     * @param host - The hostname of the server to connect to.
+     * @param port - The port number of the server to connect to.
+     * @returns A Duplex stream representing the established socket connection, which will be used for the WebSocket handshake and subsequent communication.
+     * @remarks The method checks the protocol and creates a socket connection accordingly. For 'wss:', it uses TLS to create a secure connection, while for 'ws:', it creates a standard TCP connection. The returned Duplex stream can then be used for reading and writing data during the WebSocket communication.
+     */
+    static createSocket(protocol: string, host: string, port: number): Duplex;
+    /**
+     * Parses a WebSocket URL and extracts its components (protocol, host, port, path) to create a structured request object. This method is used internally to process the URL provided for establishing a WebSocket connection.
+     * @param url - The WebSocket URL to be parsed, which should include the protocol (ws:// or wss://), host, optional port, and path.
+     * @returns An object containing the parsed components of the URL: protocol, host, port, and path. The port is determined based on the protocol if not explicitly provided in the URL (defaulting to 80 for ws and 443 for wss).
+     * @throws Will throw an error if the URL does not use a valid WebSocket protocol (i.e., if it does not start with ws:// or wss://).
+     */
+    static parseURL(url: string): WebsocketCSInit.Request;
+    /**
+     * Valida si el protocolo es ws o wss. Este método se utiliza internamente para asegurar que solo se acepten URLs con los protocolos correctos durante el proceso de conexión.
+     * @param protocol - El protocolo extraído de la URL, que debe ser 'ws:' o 'wss:'.
+     * @returns Un valor booleano que indica si el protocolo es válido (true) o no (false).
+     */
+    protected static isProtocol(protocol: string): protocol is WebsocketCSInit.Protocol;
+}
+export declare namespace WebsocketCSInit {
+    type Protocol = 'ws:' | 'wss:';
+    interface Request {
+        protocol: Protocol;
+        authority: string;
+        host: string;
+        port: number;
+        path: string;
+    }
+}
+export default WebsocketCSInit;

package/build/server/websocket/WebsocketCSInit.js

@@ -0,0 +1,95 @@
+import net from 'net';
+import tls from 'tls';
+import CSHandShaker from './handshake/CSHandshaker.js';
+import WebsocketBase from './WebsocketBase.js';
+import Codec from './Codec.js';
+export class WebsocketCSInit extends WebsocketBase {
+    handshaker;
+    request;
+    constructor(socket, request) {
+        super(socket);
+        this.handshaker = new CSHandShaker(socket, request.authority, request.path);
+        this.request = request;
+        this.handshake();
+    }
+    encode(buffer, opcode) {
+        return Codec.clientEncode(buffer, opcode);
+    }
+    /**
+     * Handles the WebSocket handshake process by listening for 'finish' and 'error' events from the CSHandShaker instance.
+     * When the handshake is completed successfully, it updates the connection status to 'open', initializes the WebSocket connection, and emits an 'open' event. If the handshake fails or encounters an error, it updates the status to 'closed' and emits a 'close' or 'error' event accordingly.
+     * This method is called internally during the construction of the WebsocketCSInit instance to automatically manage the handshake process when a new connection is established.
+     */
+    handshake() {
+        this.handshaker.once('finish', (status) => {
+            this.vStatus = status;
+            if (status !== 'open')
+                this.emit('close');
+            else {
+                this.startup();
+                this.emit('open');
+            }
+        });
+        this.handshaker.once('error', (error) => {
+            this.vStatus = 'closed';
+            this.emit('error', error);
+        });
+        this.handshaker.start();
+    }
+    /**
+     * Establishes a WebSocket connection to the specified URL by performing the necessary handshake process. This method parses the provided URL, creates a socket connection to the server, and then initiates the WebSocket handshake to establish a full-duplex communication channel.
+     * @param url - The WebSocket URL to connect to, which should include the protocol (ws:// or wss://), host, optional port, and path.
+     * @returns A promise that resolves to a Websocket instance representing the established connection if the handshake is successful, or rejects with an error if the handshake fails or if there are issues during the connection process.
+     * @remarks The method first parses the URL to extract the necessary components (protocol, host, port, path), then creates a socket connection based on the protocol (using TLS for wss and a regular TCP socket for ws). After establishing the socket connection, it performs the WebSocket handshake using the CSHandShaker class.
+     * If the handshake is successful, it initializes a new ClientInit instance with the established socket and resolves the promise with this instance. If any errors occur during parsing, socket creation, or handshake, the promise is rejected with the corresponding error.
+     */
+    static async connect(url) {
+        const request = WebsocketCSInit.parseURL(url);
+        const socket = WebsocketCSInit.createSocket(request.protocol, request.host, request.port);
+        const websocket = new WebsocketCSInit(socket, request);
+        return websocket;
+    }
+    /**
+     * Creates a socket connection to the specified host and port using the appropriate protocol (TCP for ws and TLS for wss).
+     * This method is used internally to establish the underlying connection before performing the WebSocket handshake.
+     * @param protocol - The protocol to use for the connection, which should be either 'ws:' for a regular TCP connection or 'wss:' for a secure TLS connection.
+     * @param host - The hostname of the server to connect to.
+     * @param port - The port number of the server to connect to.
+     * @returns A Duplex stream representing the established socket connection, which will be used for the WebSocket handshake and subsequent communication.
+     * @remarks The method checks the protocol and creates a socket connection accordingly. For 'wss:', it uses TLS to create a secure connection, while for 'ws:', it creates a standard TCP connection. The returned Duplex stream can then be used for reading and writing data during the WebSocket communication.
+     */
+    static createSocket(protocol, host, port) {
+        if (protocol === 'wss:')
+            return tls.connect({ host, port, servername: host });
+        else
+            return net.connect({ host, port });
+    }
+    /**
+     * Parses a WebSocket URL and extracts its components (protocol, host, port, path) to create a structured request object. This method is used internally to process the URL provided for establishing a WebSocket connection.
+     * @param url - The WebSocket URL to be parsed, which should include the protocol (ws:// or wss://), host, optional port, and path.
+     * @returns An object containing the parsed components of the URL: protocol, host, port, and path. The port is determined based on the protocol if not explicitly provided in the URL (defaulting to 80 for ws and 443 for wss).
+     * @throws Will throw an error if the URL does not use a valid WebSocket protocol (i.e., if it does not start with ws:// or wss://).
+     */
+    static parseURL(url) {
+        const parsed = new URL(url);
+        const protocol = parsed.protocol;
+        if (!WebsocketCSInit.isProtocol(protocol))
+            throw new Error('Solo se aceptan protocolos ws:// o wss://');
+        const defaultPort = protocol === 'wss:' ? 443 : 80;
+        const host = parsed.hostname;
+        const port = Number(parsed.port || defaultPort);
+        const path = parsed.pathname + (parsed.search || '');
+        const authority = `${host}:${port}`;
+        return { protocol, host, port, path, authority };
+    }
+    /**
+     * Valida si el protocolo es ws o wss. Este método se utiliza internamente para asegurar que solo se acepten URLs con los protocolos correctos durante el proceso de conexión.
+     * @param protocol - El protocolo extraído de la URL, que debe ser 'ws:' o 'wss:'.
+     * @returns Un valor booleano que indica si el protocolo es válido (true) o no (false).
+     */
+    static isProtocol(protocol) {
+        return ['ws:', 'wss:'].includes(protocol);
+    }
+}
+export default WebsocketCSInit;
+//# sourceMappingURL=WebsocketCSInit.js.map

package/build/server/websocket/WebsocketCSInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketCSInit.js","sourceRoot":"","sources":["../../../src/server/websocket/WebsocketCSInit.ts"],"names":[],"mappings":"AAEA,OAAO,GAAG,MAAM,KAAK,CAAC;AACtB,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,OAAO,YAAY,MAAM,6BAA6B,CAAC;AACvD,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,MAAM,YAAY,CAAC;AAE/B,MAAM,OAAO,eAAgB,SAAQ,aAAa;IACpC,UAAU,CAAe;IAC5B,OAAO,CAA0B;IACxC,YAAmB,MAAc,EAAE,OAAgC;QAAI,KAAK,CAAC,MAAM,CAAC,CAAC;QACjF,IAAI,CAAC,UAAU,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IACkB,MAAM,CAAC,MAAc,EAAE,MAAc;QACpD,OAAO,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;IACD;;;;OAIG;IACO,SAAS;QACf,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,EAAE;YACtC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YACtB,IAAI,MAAM,KAAK,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;iBACrC,CAAC;gBACF,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtB,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YACpC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IACD;;;;;;OAMG;IACI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAW;QACnC,MAAM,OAAO,GAAG,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,MAAM,GAAG,eAAe,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1F,MAAM,SAAS,GAAG,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACvD,OAAO,SAAS,CAAC;IACrB,CAAC;IACD;;;;;;;;OAQG;IACI,MAAM,CAAC,YAAY,CAAC,QAAgB,EAAE,IAAY,EAAE,IAAY;QACnE,IAAI,QAAQ,KAAK,MAAM;YAAE,OAAO,GAAG,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;;YACzE,OAAO,GAAG,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5C,CAAC;IACD;;;;;OAKG;IACI,MAAM,CAAC,QAAQ,CAAC,GAAW;QAC9B,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,QAAQ,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QACxG,MAAM,WAAW,GAAG,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC;QAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,WAAW,CAAC,CAAC;QAChD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;QACrD,MAAM,SAAS,GAAG,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;QACpC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IACrD,CAAC;IACD;;;;OAIG;IACO,MAAM,CAAC,UAAU,CAAC,QAAgB;QACxC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC;CACJ;AAYD,eAAe,eAAe,CAAC"}

package/build/server/websocket/WebsocketSSInit.d.ts

@@ -0,0 +1,24 @@
+import type { Duplex } from 'stream';
+import type Request from '../Request.js';
+import SSHandshaker from './handshake/SSHandshaker.js';
+import WebsocketBase from './WebsocketBase.js';
+export declare class WebsocketSSInit extends WebsocketBase {
+    protected handshaker: SSHandshaker;
+    constructor(request: Request, socket: Duplex);
+    /**
+     * Accepts the WebSocket handshake by validating the client's request and sending the appropriate HTTP response to establish the WebSocket connection. This method should be called after verifying that the client's handshake request is valid and meets the necessary criteria for accepting the connection.
+      * - It generates the Sec-WebSocket-Accept key based on the client's Sec-WebSocket-Key and constructs the HTTP response with the required headers to complete the handshake.
+      * - After sending the response, it updates the internal status to 'open' and emits a 'finish' event with the new status.
+      * @throws Will throw an error if the client's handshake request does not contain a valid Sec-WebSocket-Key or if any other issue occurs during the acceptance process. The error will be emitted as an 'error' event for handling by the caller.
+      */
+    accept(): void;
+    /**
+     * Rejects the WebSocket handshake by sending an HTTP response with the specified status code and reason, and then closes the connection.
+     * @param code - The HTTP status code to indicate the reason for rejection (e.g., 400 for Bad Request).
+     * @param reason - A human-readable string explaining the reason for rejection.
+     * @remarks The generated response will have a JSON body containing the provided code and reason, and will include any specified cookies in the headers. This response can be sent back to the client to indicate that the handshake request was rejected, along with the reason for rejection.
+     */
+    reject(code: number, reason: string): void;
+}
+export declare namespace WebsocketSSInit { }
+export default WebsocketSSInit;

package/build/server/websocket/WebsocketSSInit.js

@@ -0,0 +1,46 @@
+import SSHandshaker from './handshake/SSHandshaker.js';
+import WebsocketBase from './WebsocketBase.js';
+export class WebsocketSSInit extends WebsocketBase {
+    handshaker;
+    constructor(request, socket) {
+        super(socket);
+        this.handshaker = new SSHandshaker(socket, request);
+        this.handshaker.once('error', (error) => {
+            this.vStatus = 'closed';
+            this.emit('error', error);
+        });
+        this.handshaker.once('finish', (status) => {
+            this.vStatus = status;
+            if (status !== 'open')
+                this.emit('close');
+            else {
+                this.startup();
+                this.emit('open');
+            }
+        });
+    }
+    /**
+     * Accepts the WebSocket handshake by validating the client's request and sending the appropriate HTTP response to establish the WebSocket connection. This method should be called after verifying that the client's handshake request is valid and meets the necessary criteria for accepting the connection.
+      * - It generates the Sec-WebSocket-Accept key based on the client's Sec-WebSocket-Key and constructs the HTTP response with the required headers to complete the handshake.
+      * - After sending the response, it updates the internal status to 'open' and emits a 'finish' event with the new status.
+      * @throws Will throw an error if the client's handshake request does not contain a valid Sec-WebSocket-Key or if any other issue occurs during the acceptance process. The error will be emitted as an 'error' event for handling by the caller.
+      */
+    accept() {
+        if (this.vStatus !== 'handshake')
+            return this.emit('error', new Error('Handshake already completed or connection is closed'));
+        this.handshaker.accept();
+    }
+    /**
+     * Rejects the WebSocket handshake by sending an HTTP response with the specified status code and reason, and then closes the connection.
+     * @param code - The HTTP status code to indicate the reason for rejection (e.g., 400 for Bad Request).
+     * @param reason - A human-readable string explaining the reason for rejection.
+     * @remarks The generated response will have a JSON body containing the provided code and reason, and will include any specified cookies in the headers. This response can be sent back to the client to indicate that the handshake request was rejected, along with the reason for rejection.
+     */
+    reject(code, reason) {
+        if (this.vStatus !== 'handshake')
+            return this.emit('error', new Error('Handshake already completed or connection is closed'));
+        this.handshaker.reject(code, reason);
+    }
+}
+export default WebsocketSSInit;
+//# sourceMappingURL=WebsocketSSInit.js.map

package/build/server/websocket/WebsocketSSInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketSSInit.js","sourceRoot":"","sources":["../../../src/server/websocket/WebsocketSSInit.ts"],"names":[],"mappings":"AAIA,OAAO,YAAY,MAAM,6BAA6B,CAAC;AACvD,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAE/C,MAAM,OAAO,eAAgB,SAAQ,aAAa;IACpC,UAAU,CAAe;IACnC,YACI,OAAgB,EAChB,MAAc;QAEd,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,UAAU,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YACpC,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,EAAE;YACtC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YACtB,IAAI,MAAM,KAAK,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;iBACrC,CAAC;gBACF,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IACD;;;;;QAKI;IACG,MAAM;QACT,IAAI,IAAI,CAAC,OAAO,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC,CAAC;QAC9H,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;IAC7B,CAAC;IACD;;;;;OAKG;IACI,MAAM,CAAC,IAAY,EAAE,MAAc;QACtC,IAAI,IAAI,CAAC,OAAO,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC,CAAC;QAC9H,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC;CACJ;AAED,eAAe,eAAe,CAAC"}

package/build/server/websocket/frame/Frame.d.ts

@@ -0,0 +1,31 @@
+import Header from './Header.js';
+export declare class Frame implements Frame.Content {
+    header: Header;
+    payload: Buffer;
+    constructor(data: Frame.Content);
+    get isContinuation(): boolean;
+    get isText(): boolean;
+    get isBinary(): boolean;
+    get isClose(): boolean;
+    get isPing(): boolean;
+    get isPong(): boolean;
+    get isControl(): boolean;
+    /**
+     * Reads the first complete frame from a buffer and returns its surplus.
+     * @throws `RangeError` If the buffer does not contain a complete frame or if the frame size exceeds supported limits.
+     * Note: This method assumes that the buffer starts with a valid frame header and does not perform additional validation on the frame contents.
+     */
+    static fromBuffer(buffer: Buffer): Frame.ReadResult;
+}
+export declare namespace Frame {
+    interface Content {
+        header: Header;
+        payload: Buffer;
+    }
+    interface ReadResult {
+        frame: Frame;
+        chunk: Buffer;
+        surplus: Buffer;
+    }
+}
+export default Frame;

package/build/server/websocket/frame/Frame.js

@@ -0,0 +1,45 @@
+/**
+ * Parser dedicado para extraer solo la cabecera de un frame WebSocket.
+ * Útil para validaciones previas, handshake, o inspección rápida.
+ */
+import Codec from '../Codec.js';
+import Header from './Header.js';
+export class Frame {
+    header;
+    payload;
+    constructor(data) {
+        this.header = data.header;
+        this.payload = data.payload;
+    }
+    get isContinuation() { return this.header.opcode === 0x0; }
+    get isText() { return this.header.opcode === 0x1; }
+    get isBinary() { return this.header.opcode === 0x2; }
+    get isClose() { return this.header.opcode === 0x8; }
+    get isPing() { return this.header.opcode === 0x9; }
+    get isPong() { return this.header.opcode === 0xA; }
+    get isControl() { return this.header.opcode >= 0x8; }
+    /**
+     * Reads the first complete frame from a buffer and returns its surplus.
+     * @throws `RangeError` If the buffer does not contain a complete frame or if the frame size exceeds supported limits.
+     * Note: This method assumes that the buffer starts with a valid frame header and does not perform additional validation on the frame contents.
+     */
+    static fromBuffer(buffer) {
+        const header = Header.fromBuffer(buffer);
+        const expectedSize = BigInt(header.headerSize) + BigInt(header.size);
+        if (BigInt(buffer.length) < expectedSize)
+            throw new RangeError('Incomplete frame data');
+        if (expectedSize > BigInt(Number.MAX_SAFE_INTEGER))
+            throw new RangeError('Frame size exceeds supported buffer limits');
+        const chunkSize = Number(expectedSize);
+        const chunk = buffer.subarray(0, chunkSize);
+        const payload = Codec.decode(chunk, header.headerSize, header.maskKeys);
+        const frame = new Frame({ header: header, payload });
+        return {
+            frame,
+            chunk,
+            surplus: buffer.subarray(chunkSize)
+        };
+    }
+}
+export default Frame;
+//# sourceMappingURL=Frame.js.map

package/build/server/websocket/frame/Frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Frame.js","sourceRoot":"","sources":["../../../../src/server/websocket/frame/Frame.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,MAAM,MAAM,aAAa,CAAC;AAEjC,MAAM,OAAO,KAAK;IACP,MAAM,CAAS;IACf,OAAO,CAAS;IAEvB,YAAmB,IAAmB;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAChC,CAAC;IAED,IAAW,cAAc,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IAC3E,IAAW,MAAM,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IACnE,IAAW,QAAQ,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IACrE,IAAW,OAAO,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IACpE,IAAW,MAAM,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IACnE,IAAW,MAAM,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC;IACnE,IAAW,SAAS,KAAc,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC;IAErE;;;;OAIG;IACI,MAAM,CAAC,UAAU,CAAC,MAAc;QACnC,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACzC,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAErE,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,YAAY;YAAE,MAAM,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAAC;QACxF,IAAI,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,4CAA4C,CAAC,CAAC;QAEvH,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QACvC,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxE,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;QAErD,OAAO;YACH,KAAK;YACL,KAAK;YACL,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;SACtC,CAAC;IACN,CAAC;CACJ;AAcD,eAAe,KAAK,CAAC"}