@wxn0brp/gloves-link-server 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -1,9 +1,13 @@
-import { WebSocketServer } from "ws";
-import { Server_Opts } from "./types.js";
-import { GLSocket } from "./socket.js";
 import FalconFrame, { Router } from "@wxn0brp/falcon-frame";
-import { Room, Rooms } from "./room.js";
+import http from "http";
+import { WebSocketServer } from "ws";
 import { Namespace } from "./namespace.js";
+import { Room, Rooms } from "./room.js";
+import { GLSocket } from "./socket.js";
+import { Server_Opts } from "./types.js";
+/**
+ * GlovesLinkServer class provides a WebSocket server with namespace and room functionality
+ */
 export declare class GlovesLinkServer {
     wss: WebSocketServer;
     logs: boolean;
@@ -14,13 +18,56 @@ export declare class GlovesLinkServer {
     }>;
     rooms: Rooms;
     namespaces: Map<string, Namespace>;
+    /**
+     * Creates a new GlovesLinkServer instance
+     * @param opts - Server options including the HTTP server instance
+     */
     constructor(opts: Partial<Server_Opts>);
+    createServer(server: http.Server): void;
+    /**
+     * Saves the status of a socket connection for temporary tracking
+     * @param socketSelfId - The ID of the socket
+     * @param namespace - The namespace of the socket
+     * @param status - The status code to save
+     * @param msg - Optional message to save with the status
+     * @private
+     */
     private saveSocketStatus;
+    /**
+     * Gets or creates a namespace by path
+     * @param path - The path for the namespace
+     * @returns The namespace instance
+     */
     of(path: string): Namespace;
+    /**
+     * Broadcasts an event to all sockets in a room
+     * @param roomName - The name of the room to broadcast to
+     * @param event - The event name to broadcast
+     * @param args - Arguments to send with the event
+     */
     broadcastRoom(roomName: string, event: string, ...args: any[]): void;
+    /**
+     * Gets or creates a room by name
+     * @param name - The name of the room
+     * @returns The room instance
+     */
     room(name: string): Room;
+    /**
+     * Creates a router for handling status requests
+     * @returns A router instance for status endpoints
+     */
     statusRouter(): Router;
+    /**
+     * Creates a router for serving client files
+     * @param clientDir - Optional directory path for client files, defaults to node_modules/@wxn0brp/gloves-link-client/dist/
+     * @returns A router instance for client file serving
+     */
     clientRouter(clientDir?: string): Router;
+    /**
+     * Integrates the GlovesLink server with a FalconFrame application
+     * @param app - The FalconFrame application instance
+     * @param clientDir - Optional directory path for client files, or false to disable client serving
+     */
     falconFrame(app: FalconFrame, clientDir?: string | false): void;
 }
 export { GLSocket, Namespace, Server_Opts };

package/dist/index.js

@@ -1,8 +1,11 @@
-import { WebSocketServer } from "ws";
-import { GLSocket } from "./socket.js";
 import { Router } from "@wxn0brp/falcon-frame";
-import { Room } from "./room.js";
+import { WebSocketServer } from "ws";
 import { Namespace } from "./namespace.js";
+import { Room } from "./room.js";
+import { GLSocket } from "./socket.js";
+/**
+ * GlovesLinkServer class provides a WebSocket server with namespace and room functionality
+ */
 export class GlovesLinkServer {
     wss;
     logs = false;
@@ -10,17 +13,18 @@ export class GlovesLinkServer {
     initStatusTemp = {};
     rooms = new Map();
     namespaces = new Map();
+    /**
+     * Creates a new GlovesLinkServer instance
+     * @param opts - Server options including the HTTP server instance
+     */
     constructor(opts) {
         this.opts = {
-            server: null,
             logs: false,
             ...opts
         };
-        if (!this.opts?.server) {
-            throw new Error("Server is not provided");
-        }
-        const { server } = opts;
         this.wss = new WebSocketServer({ noServer: true });
+    }
+    createServer(server) {
         server.on("upgrade", async (request, socket, head) => {
             const headers = request.headers;
             let socketSelfId;
@@ -36,7 +40,12 @@ export class GlovesLinkServer {
                     socket.destroy();
                     return;
                 }
-                const authResult = await namespace.authFn({ headers, url, token, request, socket, head });
+                const data = url.searchParams.has("data") ? JSON.parse(url.searchParams.get("data")) : {};
+                const authResult = await namespace.authFn({
+                    token, data,
+                    url, headers,
+                    request, socket, head,
+                });
                 if (!authResult || authResult.status !== 200) {
                     this.saveSocketStatus(socketSelfId, pathname, authResult?.status || 401, authResult?.msg || "Unauthorized");
                     socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
@@ -68,6 +77,14 @@ export class GlovesLinkServer {
             }
         });
     }
+    /**
+     * Saves the status of a socket connection for temporary tracking
+     * @param socketSelfId - The ID of the socket
+     * @param namespace - The namespace of the socket
+     * @param status - The status code to save
+     * @param msg - Optional message to save with the status
+     * @private
+     */
     saveSocketStatus(socketSelfId, namespace, status, msg) {
         if (!socketSelfId)
             return;
@@ -80,6 +97,11 @@ export class GlovesLinkServer {
             delete this.initStatusTemp[id];
         }, 10_000);
     }
+    /**
+     * Gets or creates a namespace by path
+     * @param path - The path for the namespace
+     * @returns The namespace instance
+     */
     of(path) {
         let namespace = this.namespaces.get(path);
         if (!namespace) {
@@ -88,15 +110,30 @@ export class GlovesLinkServer {
         }
         return namespace;
     }
+    /**
+     * Broadcasts an event to all sockets in a room
+     * @param roomName - The name of the room to broadcast to
+     * @param event - The event name to broadcast
+     * @param args - Arguments to send with the event
+     */
     broadcastRoom(roomName, event, ...args) {
         const room = this.room(roomName);
         if (!room)
             return;
         room.emit(event, ...args);
     }
+    /**
+     * Gets or creates a room by name
+     * @param name - The name of the room
+     * @returns The room instance
+     */
     room(name) {
         return this.rooms.get(name) || this.rooms.set(name, new Room()).get(name);
     }
+    /**
+     * Creates a router for handling status requests
+     * @returns A router instance for status endpoints
+     */
     statusRouter() {
         const router = new Router();
         router.get("/status", (req, res) => {
@@ -120,6 +157,11 @@ export class GlovesLinkServer {
         });
         return router;
     }
+    /**
+     * Creates a router for serving client files
+     * @param clientDir - Optional directory path for client files, defaults to node_modules/@wxn0brp/gloves-link-client/dist/
+     * @returns A router instance for client file serving
+     */
     clientRouter(clientDir) {
         const router = new Router();
         clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
@@ -130,6 +172,11 @@ export class GlovesLinkServer {
         });
         return router;
     }
+    /**
+     * Integrates the GlovesLink server with a FalconFrame application
+     * @param app - The FalconFrame application instance
+     * @param clientDir - Optional directory path for client files, or false to disable client serving
+     */
     falconFrame(app, clientDir) {
         const router = new Router();
         app.use("/gloves-link", router);

package/dist/namespace.d.ts

@@ -2,16 +2,49 @@ import { AuthFn } from "./types.js";
 import { GLSocket } from "./socket.js";
 import { Room } from "./room.js";
 import { GlovesLinkServer } from "./index.js";
+/**
+ * Namespace class represents a logical grouping of sockets that can communicate with each other
+ */
 export declare class Namespace {
     name: string;
     private server;
     private onConnectEvent;
     authFn: AuthFn;
     room: Room;
+    /**
+     * Creates a new Namespace instance
+     * @param name - The name of the namespace
+     * @param server - The GlovesLinkServer instance
+     */
     constructor(name: string, server: GlovesLinkServer);
+    /**
+     * Sets the connection event handler for this namespace
+     * @param handler - The function to be called when a socket connects to this namespace
+     * @returns The current Namespace instance for chaining
+     */
     onConnect(handler: (ws: GLSocket) => void): this;
+    /**
+     * Sets the authentication function for this namespace
+     * @param authFn - The authentication function to be used for this namespace
+     * @returns The current Namespace instance for chaining
+     */
     auth(authFn: AuthFn): this;
+    /**
+     * Gets the connection event handler for this namespace
+     * @returns The connection event handler function
+     */
     get onConnectHandler(): (ws: GLSocket) => void;
+    /**
+     * Emits an event to all sockets in the namespace's room
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
     emit(event: string, ...args: any[]): void;
+    /**
+     * Emits an event to all sockets in the namespace's room except the specified socket
+     * @param socket - The socket to exclude from the emission
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
     emitWithoutSelf(socket: GLSocket, event: string, ...args: any[]): void;
 }

package/dist/namespace.js

@@ -1,29 +1,62 @@
+/**
+ * Namespace class represents a logical grouping of sockets that can communicate with each other
+ */
 export class Namespace {
     name;
     server;
     onConnectEvent = () => { };
     authFn = async () => ({ status: 200 });
     room;
+    /**
+     * Creates a new Namespace instance
+     * @param name - The name of the namespace
+     * @param server - The GlovesLinkServer instance
+     */
     constructor(name, server) {
         this.name = name;
         this.server = server;
         const roomName = `gls-namespace-${name}`;
         this.room = this.server.room(roomName);
     }
+    /**
+     * Sets the connection event handler for this namespace
+     * @param handler - The function to be called when a socket connects to this namespace
+     * @returns The current Namespace instance for chaining
+     */
     onConnect(handler) {
         this.onConnectEvent = handler;
         return this;
     }
+    /**
+     * Sets the authentication function for this namespace
+     * @param authFn - The authentication function to be used for this namespace
+     * @returns The current Namespace instance for chaining
+     */
     auth(authFn) {
         this.authFn = authFn;
         return this;
     }
+    /**
+     * Gets the connection event handler for this namespace
+     * @returns The connection event handler function
+     */
     get onConnectHandler() {
         return this.onConnectEvent;
     }
+    /**
+     * Emits an event to all sockets in the namespace's room
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
     emit(event, ...args) {
         this.room.emit(event, ...args);
     }
+    /**
+     * Emits an event to all sockets in the namespace's room except the specified socket
+     * @param socket - The socket to exclude from the emission
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
     emitWithoutSelf(socket, event, ...args) {
         this.room.emitWithoutSelf(socket, event, ...args);
     }

package/dist/room.d.ts

@@ -1,22 +1,84 @@
 import EventEmitter from "events";
 import { GLSocket } from "./socket.js";
 export type Rooms = Map<string, Room>;
+/**
+ * Room class represents a collection of sockets that can communicate with each other
+ */
 export declare class Room {
     clients: Set<GLSocket>;
     eventEmitter: EventEmitter<any>;
+    /**
+     * Adds a socket to the room
+     * @param socket - The socket to add to the room
+     */
     join(socket: GLSocket): void;
+    /**
+     * Removes a socket from the room
+     * @param socket - The socket to remove from the room
+     */
     leave(socket: GLSocket): void;
+    /**
+     * Removes all sockets from the room
+     */
     leaveAll(): void;
+    /**
+     * Registers a handler for when a socket joins the room
+     * @param handler - The function to be called when a socket joins the room
+     * @returns The current Room instance for chaining
+     */
     onJoin(handler: (socket: GLSocket, room: Room) => void): this;
+    /**
+     * Registers a handler for when a socket leaves the room
+     * @param handler - The function to be called when a socket leaves the room
+     * @returns The current Room instance for chaining
+     */
     onLeave(handler: (socket: GLSocket, room: Room) => void): this;
+    /**
+     * Gets the number of clients in the room
+     * @returns The number of clients in the room
+     */
     get size(): number;
+    /**
+     * Gets an array of all clients in the room
+     * @returns An array containing all the sockets in the room
+     */
     get sockets(): GLSocket<{
         _id?: string;
     }>[];
+    /**
+     * Emits an event to all clients in the room
+     * @param evtName - The name of the event to emit
+     * @param data - The data to send with the event
+     */
     emit(evtName: string, ...data: any): void;
+    /**
+     * Emits an event to all clients in the room except the specified socket
+     * @param socket - The socket to exclude from the emission
+     * @param evtName - The name of the event to emit
+     * @param data - The data to send with the event
+     */
     emitWithoutSelf(socket: GLSocket, evtName: string, ...data: any): void;
+    /**
+     * Checks if a socket is in the room
+     * @param socket - The socket to check
+     * @returns True if the socket is in the room, false otherwise
+     */
     has(socket: GLSocket): boolean;
 }
+/**
+ * Adds a socket to a room by name, creating the room if it doesn't exist
+ * @param socket - The socket to add to the room
+ * @param name - The name of the room to join
+ */
 export declare function joinSocketToRoom(socket: GLSocket, name: string): void;
+/**
+ * Removes a socket from a room by name
+ * @param socket - The socket to remove from the room
+ * @param roomName - The name of the room to leave
+ */
 export declare function leaveSocketFromRoom(socket: GLSocket, roomName: string): void;
+/**
+ * Removes a socket from all rooms it has joined
+ * @param socket - The socket to remove from all rooms
+ */
 export declare function leaveAllSocketFromRoom(socket: GLSocket): void;

package/dist/room.js

@@ -1,38 +1,81 @@
 import EventEmitter from "events";
+/**
+ * Room class represents a collection of sockets that can communicate with each other
+ */
 export class Room {
     clients = new Set();
     eventEmitter = new EventEmitter();
+    /**
+     * Adds a socket to the room
+     * @param socket - The socket to add to the room
+     */
     join(socket) {
         this.clients.add(socket);
         this.eventEmitter.emit("join", socket, this);
     }
+    /**
+     * Removes a socket from the room
+     * @param socket - The socket to remove from the room
+     */
     leave(socket) {
         this.clients.delete(socket);
         this.eventEmitter.emit("leave", socket, this);
     }
+    /**
+     * Removes all sockets from the room
+     */
     leaveAll() {
         this.clients.clear();
         this.eventEmitter.emit("leaveAll", this);
     }
+    /**
+     * Registers a handler for when a socket joins the room
+     * @param handler - The function to be called when a socket joins the room
+     * @returns The current Room instance for chaining
+     */
     onJoin(handler) {
         this.eventEmitter.on("join", handler);
         return this;
     }
+    /**
+     * Registers a handler for when a socket leaves the room
+     * @param handler - The function to be called when a socket leaves the room
+     * @returns The current Room instance for chaining
+     */
     onLeave(handler) {
         this.eventEmitter.on("leave", handler);
         return this;
     }
+    /**
+     * Gets the number of clients in the room
+     * @returns The number of clients in the room
+     */
     get size() {
         return this.clients.size;
     }
+    /**
+     * Gets an array of all clients in the room
+     * @returns An array containing all the sockets in the room
+     */
     get sockets() {
         return Array.from(this.clients);
     }
+    /**
+     * Emits an event to all clients in the room
+     * @param evtName - The name of the event to emit
+     * @param data - The data to send with the event
+     */
     emit(evtName, ...data) {
         for (const socket of this.clients) {
             socket.emit(evtName, ...data);
         }
     }
+    /**
+     * Emits an event to all clients in the room except the specified socket
+     * @param socket - The socket to exclude from the emission
+     * @param evtName - The name of the event to emit
+     * @param data - The data to send with the event
+     */
     emitWithoutSelf(socket, evtName, ...data) {
         for (const client of this.clients) {
             if (client === socket)
@@ -40,15 +83,30 @@ export class Room {
             client.emit(evtName, ...data);
         }
     }
+    /**
+     * Checks if a socket is in the room
+     * @param socket - The socket to check
+     * @returns True if the socket is in the room, false otherwise
+     */
     has(socket) {
         return this.clients.has(socket);
     }
 }
+/**
+ * Adds a socket to a room by name, creating the room if it doesn't exist
+ * @param socket - The socket to add to the room
+ * @param name - The name of the room to join
+ */
 export function joinSocketToRoom(socket, name) {
     const rooms = socket.server.rooms;
     const room = rooms.get(name) || rooms.set(name, new Room()).get(name);
     room.join(socket);
 }
+/**
+ * Removes a socket from a room by name
+ * @param socket - The socket to remove from the room
+ * @param roomName - The name of the room to leave
+ */
 export function leaveSocketFromRoom(socket, roomName) {
     const rooms = socket.server.rooms;
     const room = rooms.get(roomName);
@@ -59,6 +117,10 @@ export function leaveSocketFromRoom(socket, roomName) {
         return;
     rooms.delete(roomName);
 }
+/**
+ * Removes a socket from all rooms it has joined
+ * @param socket - The socket to remove from all rooms
+ */
 export function leaveAllSocketFromRoom(socket) {
     const rooms = socket.server.rooms;
     for (const room of rooms.values())

package/dist/socket.d.ts

@@ -1,5 +1,10 @@
 import { WebSocket } from "ws";
 import { GlovesLinkServer } from "./index.js";
+import { Room, Rooms } from "./room.js";
+/**
+ * GLSocket class represents a WebSocket connection with additional functionality
+ * @template T - The type of user data associated with the socket
+ */
 export declare class GLSocket<T = {
     _id?: string;
 }> {
@@ -15,14 +20,74 @@ export declare class GLSocket<T = {
         [key: string]: Function;
     };
     rooms: Set<string>;
+    /**
+     * Creates a new GLSocket instance
+     * @param ws - The underlying WebSocket connection
+     * @param server - The GlovesLinkServer instance
+     * @param id - Optional ID for the socket, will be generated if not provided
+     */
     constructor(ws: WebSocket, server: GlovesLinkServer, id?: string);
+    /**
+     * Internal method to handle incoming messages from the WebSocket
+     * @param raw - The raw message string received from the WebSocket
+     */
     _handle(raw: string): void;
+    /**
+     * Registers an event handler for the specified event
+     * @param evt - The event name to listen for
+     * @param handler - The function to be called when the event is received
+     */
     on(evt: string, handler: (...args: any[]) => void | any): void;
+    /**
+     * Sends an event to the connected WebSocket client
+     * @param evt - The event name to send
+     * @param args - The arguments to pass with the event
+     */
     emit(evt: string, ...args: any[]): void;
+    /**
+     * Sends an event to the connected WebSocket client (alias for emit)
+     * @param evt - The event name to send
+     * @param args - The arguments to pass with the event
+     * @returns The result of the emit method
+     */
     send(evt: string, ...args: any[]): void;
+    /**
+     * Closes the WebSocket connection
+     */
     close(): void;
+    /**
+     * Joins the socket to a room
+     * @param roomName - The name of the room to join
+     */
     joinRoom(roomName: string): void;
+    /**
+     * Removes the socket from a room
+     * @param roomName - The name of the room to leave
+     */
     leaveRoom(roomName: string): void;
+    /**
+     * Removes the socket from all rooms it has joined
+     */
     leaveAllRooms(): void;
+    /**
+     * Gets the namespace associated with this socket
+     * @returns The namespace object or undefined if not found
+     */
     getNamespace(): import("./namespace.js").Namespace;
+    /**
+     * Gets the room associated with this socket's namespace
+     * @returns The room object or undefined if namespace is not found
+     */
+    namespaceRoom(): Room;
+    /**
+     * Gets a room from the server by name
+     * @param roomName - The name of the room to retrieve
+     * @returns The room object
+     */
+    serverRoom(roomName: string): Room;
+    /**
+     * Gets all rooms from the server
+     * @returns A map of all rooms on the server
+     */
+    serverRooms(): Rooms;
 }

package/dist/socket.js

@@ -1,4 +1,8 @@
 import { joinSocketToRoom, leaveSocketFromRoom } from "./room.js";
+/**
+ * GLSocket class represents a WebSocket connection with additional functionality
+ * @template T - The type of user data associated with the socket
+ */
 export class GLSocket {
     ws;
     server;
@@ -10,6 +14,12 @@ export class GLSocket {
     logs = false;
     handlers;
     rooms = new Set();
+    /**
+     * Creates a new GLSocket instance
+     * @param ws - The underlying WebSocket connection
+     * @param server - The GlovesLinkServer instance
+     * @param id - Optional ID for the socket, will be generated if not provided
+     */
     constructor(ws, server, id) {
         this.ws = ws;
         this.server = server;
@@ -18,6 +28,10 @@ export class GLSocket {
         this.handlers = {};
         this.ws.on("message", (raw) => this._handle(raw));
     }
+    /**
+     * Internal method to handle incoming messages from the WebSocket
+     * @param raw - The raw message string received from the WebSocket
+     */
     _handle(raw) {
         let msg;
         try {
@@ -53,9 +67,19 @@ export class GLSocket {
         }
         this.handlers[evt]?.(...data);
     }
+    /**
+     * Registers an event handler for the specified event
+     * @param evt - The event name to listen for
+     * @param handler - The function to be called when the event is received
+     */
     on(evt, handler) {
         this.handlers[evt] = handler;
     }
+    /**
+     * Sends an event to the connected WebSocket client
+     * @param evt - The event name to send
+     * @param args - The arguments to pass with the event
+     */
     emit(evt, ...args) {
         const ackI = args.map((data, i) => {
             if (typeof data === "function")
@@ -73,27 +97,73 @@ export class GLSocket {
             ackI: ackI.length ? ackI : undefined
         }));
     }
+    /**
+     * Sends an event to the connected WebSocket client (alias for emit)
+     * @param evt - The event name to send
+     * @param args - The arguments to pass with the event
+     * @returns The result of the emit method
+     */
     send(evt, ...args) {
         return this.emit(evt, ...args);
     }
+    /**
+     * Closes the WebSocket connection
+     */
     close() {
         this.ws.close();
     }
+    /**
+     * Joins the socket to a room
+     * @param roomName - The name of the room to join
+     */
     joinRoom(roomName) {
         joinSocketToRoom(this, roomName);
         this.rooms.add(roomName);
     }
+    /**
+     * Removes the socket from a room
+     * @param roomName - The name of the room to leave
+     */
     leaveRoom(roomName) {
         leaveSocketFromRoom(this, roomName);
         this.rooms.delete(roomName);
     }
+    /**
+     * Removes the socket from all rooms it has joined
+     */
     leaveAllRooms() {
         for (const roomName of this.rooms) {
             leaveSocketFromRoom(this, roomName);
         }
         this.rooms.clear();
     }
+    /**
+     * Gets the namespace associated with this socket
+     * @returns The namespace object or undefined if not found
+     */
     getNamespace() {
         return this.server.namespaces.get(this.namespace);
     }
+    /**
+     * Gets the room associated with this socket's namespace
+     * @returns The room object or undefined if namespace is not found
+     */
+    namespaceRoom() {
+        return this.getNamespace()?.room;
+    }
+    /**
+     * Gets a room from the server by name
+     * @param roomName - The name of the room to retrieve
+     * @returns The room object
+     */
+    serverRoom(roomName) {
+        return this.server.room(roomName);
+    }
+    /**
+     * Gets all rooms from the server
+     * @returns A map of all rooms on the server
+     */
+    serverRooms() {
+        return this.server.rooms;
+    }
 }

package/dist/types.d.ts

@@ -1,7 +1,6 @@
 import http from "http";
 import Stream from "stream";
 export interface Server_Opts {
-    server: http.Server;
     logs: boolean;
 }
 export interface Server_DataEvent {
@@ -20,6 +19,7 @@ export interface Server_Auth_Opts {
     request: http.IncomingMessage;
     socket: Stream.Duplex;
     head: Buffer<ArrayBufferLike>;
+    data?: Record<string, any>;
 }
 export interface AuthFnResult {
     status: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/gloves-link-server",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",