@wxn0brp/gloves-link-server 0.0.13 → 0.1.0-beta.0

package/dist/http.d.ts

@@ -0,0 +1,18 @@
+import { Router } from "@wxn0brp/falcon-frame";
+import { SocketStatus } from "./types.js";
+import { GlovesLinkServer } from "./index.js";
+/**
+ * Saves the status of a socket connection for temporary tracking
+ */
+export declare function saveSocketStatus(wss: GlovesLinkServer, socketStatus: SocketStatus): void;
+/**
+ * Creates a router for handling status requests
+ * @returns A router instance for status endpoints
+ */
+export declare function 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
+ */
+export declare function clientRouter(clientDir?: string): Router;

package/dist/http.js

@@ -0,0 +1,60 @@
+import { Router } from "@wxn0brp/falcon-frame";
+/**
+ * Saves the status of a socket connection for temporary tracking
+ */
+export function saveSocketStatus(wss, socketStatus) {
+    const { namespace, socketSelfId, status, msg } = socketStatus;
+    if (!socketSelfId)
+        return;
+    const id = namespace + "-" + socketSelfId;
+    wss.initStatusTemp[id] = {
+        status,
+        msg
+    };
+    setTimeout(() => {
+        delete wss.initStatusTemp[id];
+    }, wss.opts.statusTimeout);
+}
+/**
+ * Creates a router for handling status requests
+ * @returns A router instance for status endpoints
+ */
+export function statusRouter() {
+    const router = new Router();
+    router.get("/status", (req, res) => {
+        const id = req.query.id;
+        if (!id) {
+            res.status(400).json({ err: true, msg: "No id provided" });
+            return;
+        }
+        const path = req.query.path;
+        if (!path) {
+            res.status(400).json({ err: true, msg: "No path provided" });
+            return;
+        }
+        const statusKey = path + "-" + id;
+        const status = this.initStatusTemp[statusKey];
+        if (status === undefined) {
+            res.status(404).json({ err: true, msg: "Socket not found" });
+            return;
+        }
+        res.json({ err: false, status });
+        delete this.initStatusTemp[statusKey];
+    });
+    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
+ */
+export function clientRouter(clientDir) {
+    const router = new Router();
+    clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
+    router.static("/", clientDir);
+    router.get("/*", (req, res) => {
+        res.redirect("/gloves-link/GlovesLinkClient.js");
+        res.end();
+    });
+    return router;
+}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import FalconFrame, { Router } from "@wxn0brp/falcon-frame";
+import FalconFrame from "@wxn0brp/falcon-frame";
 import http from "http";
 import { WebSocketServer } from "ws";
 import { Namespace } from "./namespace.js";
-import { Room, Rooms } from "./room.js";
+import { Room } from "./room.js";
 import { GLSocket } from "./socket.js";
 import { Server_Opts } from "./types.js";
 /**
@@ -15,23 +15,13 @@ export declare class GlovesLinkServer {
         status: number;
         msg?: string;
     }>;
-    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;
+    attachToHttpServer(server: http.Server): void;
     /**
      * Gets or creates a namespace by path
      * @param path - The path for the namespace
@@ -46,22 +36,18 @@ export declare class GlovesLinkServer {
      */
     broadcastRoom(roomName: string, event: string, ...args: any[]): void;
     /**
-     * Gets or creates a room by name
+     * Gets or creates a room by name (from the root namespace)
      * @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
+     * Emits an event to the socket associated with the specified user ID
+     * @param userId - The user ID to target
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
      */
-    clientRouter(clientDir?: string): Router;
+    emitToUserId(userId: string, event: string, ...args: any[]): void;
     /**
      * Integrates the GlovesLink server with a FalconFrame application
      * @param app - The FalconFrame application instance

package/dist/index.js

@@ -1,7 +1,8 @@
 import { Router } from "@wxn0brp/falcon-frame";
 import { WebSocketServer } from "ws";
+import { clientRouter, saveSocketStatus, statusRouter } from "./http.js";
 import { Namespace } from "./namespace.js";
-import { Room } from "./room.js";
+import { getRoom } from "./room.js";
 import { GLSocket } from "./socket.js";
 /**
  * GlovesLinkServer class provides a WebSocket server with namespace and room functionality
@@ -10,7 +11,6 @@ export class GlovesLinkServer {
     wss;
     opts;
     initStatusTemp = {};
-    rooms = new Map();
     namespaces = new Map();
     /**
      * Creates a new GlovesLinkServer instance
@@ -19,11 +19,12 @@ export class GlovesLinkServer {
     constructor(opts) {
         this.opts = {
             logs: false,
+            statusTimeout: 10_000,
             ...opts
         };
         this.wss = new WebSocketServer({ noServer: true });
     }
-    createServer(server) {
+    attachToHttpServer(server) {
         server.on("upgrade", async (request, socket, head) => {
             const headers = request.headers;
             let socketSelfId;
@@ -31,10 +32,15 @@ export class GlovesLinkServer {
                 const url = new URL(request.url, `http://${request.headers.host}`);
                 const token = url.searchParams.get("token");
                 socketSelfId = url.searchParams.get("id");
+                const type = url.searchParams.get("type");
                 const { pathname } = url;
                 const namespace = this.namespaces.get(pathname);
                 if (!namespace) {
-                    this.saveSocketStatus(socketSelfId, pathname, 404);
+                    saveSocketStatus(this, {
+                        socketSelfId,
+                        namespace: pathname,
+                        status: 404
+                    });
                     socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
                     socket.destroy();
                     return;
@@ -47,7 +53,12 @@ export class GlovesLinkServer {
                 };
                 const authResult = await namespace.authFn(authData);
                 if (!authResult || authResult.status !== 200) {
-                    this.saveSocketStatus(socketSelfId, pathname, authResult?.status || 401, authResult?.msg || "Unauthorized");
+                    saveSocketStatus(this, {
+                        socketSelfId,
+                        namespace: pathname,
+                        status: authResult?.status || 401,
+                        msg: authResult?.msg || "Unauthorized"
+                    });
                     socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
                     socket.destroy();
                     return;
@@ -57,14 +68,24 @@ export class GlovesLinkServer {
                     glSocket.logs = this.opts.logs;
                     glSocket.authData = authData;
                     glSocket.authResult = authResult;
+                    glSocket.dataFormatType = type && ["json", "bin"].includes(type) ? type : "json";
                     if (typeof authResult.user === "object" && authResult.user !== null)
                         glSocket.user = authResult.user;
-                    glSocket.namespace = pathname;
-                    namespace.room.join(glSocket);
-                    namespace.onConnectHandler(glSocket, authData, authResult);
+                    glSocket.namespacePath = pathname;
+                    glSocket.namespace = namespace;
+                    namespace._room.join(glSocket);
+                    const userId = authResult?.user?._id;
+                    if (userId)
+                        getRoom(namespace.users, userId).join(glSocket);
+                    namespace._onConnectHandler(glSocket, authData, authResult);
                     ws.on("close", () => {
-                        glSocket.handlers?.disconnect?.();
-                        namespace.room.leave(glSocket);
+                        glSocket.handlers.emit("disconnect");
+                        namespace._room.leave(glSocket);
+                        glSocket.leaveAllRooms();
+                        if (userId) {
+                            const room = getRoom(namespace.users, userId);
+                            room.leave(glSocket);
+                        }
                     });
                 });
             }
@@ -73,32 +94,16 @@ export class GlovesLinkServer {
                     console.error("[GlovesLinkServer]", err);
                 if (this.opts.logs)
                     console.warn("[ws auth] Error during authentication:", err);
-                this.saveSocketStatus(socketSelfId, "/", 500);
+                saveSocketStatus(this, {
+                    socketSelfId,
+                    namespace: "/",
+                    status: 500
+                });
                 socket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
                 socket.destroy();
             }
         });
     }
-    /**
-     * 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;
-        const id = namespace + "-" + socketSelfId;
-        this.initStatusTemp[id] = {
-            status,
-            msg
-        };
-        setTimeout(() => {
-            delete this.initStatusTemp[id];
-        }, 10_000);
-    }
     /**
      * Gets or creates a namespace by path
      * @param path - The path for the namespace
@@ -125,54 +130,21 @@ export class GlovesLinkServer {
         room.emit(event, ...args);
     }
     /**
-     * Gets or creates a room by name
+     * Gets or creates a room by name (from the root namespace)
      * @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) => {
-            const id = req.query.id;
-            if (!id) {
-                res.status(400).json({ err: true, msg: "No id provided" });
-                return;
-            }
-            const path = req.query.path;
-            if (!path) {
-                res.status(400).json({ err: true, msg: "No path provided" });
-                return;
-            }
-            const status = this.initStatusTemp[path + "-" + id];
-            if (status === undefined) {
-                res.status(404).json({ err: true, msg: "Socket not found" });
-                return;
-            }
-            res.json({ status });
-            delete this.initStatusTemp[id];
-        });
-        return router;
+        return this.of("/").room(name);
     }
     /**
-     * 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
+     * Emits an event to the socket associated with the specified user ID
+     * @param userId - The user ID to target
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
      */
-    clientRouter(clientDir) {
-        const router = new Router();
-        clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
-        router.static("/", clientDir);
-        router.get("/*", (req, res) => {
-            res.redirect("/gloves-link/GlovesLinkClient.js");
-            res.end();
-        });
-        return router;
+    emitToUserId(userId, event, ...args) {
+        this.namespaces.forEach((ns) => ns.emitToUserId(userId, event, ...args));
     }
     /**
      * Integrates the GlovesLink server with a FalconFrame application
@@ -182,9 +154,9 @@ export class GlovesLinkServer {
     falconFrame(app, clientDir) {
         const router = new Router();
         app.use("/gloves-link", router);
-        router.use(this.statusRouter());
+        router.use(statusRouter());
         if (clientDir !== false)
-            router.use(this.clientRouter(clientDir));
+            router.use(clientRouter(clientDir));
     }
 }
 export { GLSocket, Namespace };

package/dist/namespace.d.ts

@@ -1,16 +1,18 @@
-import { AuthFn, OnConnect } from "./types.js";
-import { GLSocket } from "./socket.js";
-import { Room } from "./room.js";
 import { GlovesLinkServer } from "./index.js";
+import { Room, Rooms } from "./room.js";
+import { GLSocket } from "./socket.js";
+import { AuthFn, OnConnect } from "./types.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;
+    _onConnectHandler: OnConnect;
     authFn: AuthFn;
-    room: Room;
+    _room: Room;
+    rooms: Rooms;
+    users: Rooms;
     /**
      * Creates a new Namespace instance
      * @param name - The name of the namespace
@@ -29,17 +31,18 @@ export declare class 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(): OnConnect;
     /**
      * 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;
+    /**
+     * Gets or creates a room by name
+     * @param name - The name of the room to get or create
+     * @returns The Room instance
+     */
+    room(name: string): Room;
     /**
      * Emits an event to all sockets in the namespace's room except the specified socket
      * @param socket - The socket to exclude from the emission
@@ -47,4 +50,11 @@ export declare class Namespace {
      * @param args - The arguments to pass with the event
      */
     emitWithoutSelf(socket: GLSocket, event: string, ...args: any[]): void;
+    /**
+     * Emits an event to the socket associated with the specified user ID
+     * @param userId - The user ID to target
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
+    emitToUserId(userId: string, event: string, ...args: any[]): void;
 }

package/dist/namespace.js

@@ -1,12 +1,15 @@
+import { getRoom, Room } from "./room.js";
 /**
  * Namespace class represents a logical grouping of sockets that can communicate with each other
  */
 export class Namespace {
     name;
     server;
-    onConnectEvent = () => { };
+    _onConnectHandler = () => { };
     authFn = async () => ({ status: 200 });
-    room;
+    _room = new Room();
+    rooms = new Map();
+    users = new Map();
     /**
      * Creates a new Namespace instance
      * @param name - The name of the namespace
@@ -15,8 +18,6 @@ export class Namespace {
     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
@@ -24,7 +25,7 @@ export class Namespace {
      * @returns The current Namespace instance for chaining
      */
     onConnect(handler) {
-        this.onConnectEvent = handler;
+        this._onConnectHandler = handler;
         return this;
     }
     /**
@@ -36,20 +37,21 @@ export class Namespace {
         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);
+        this._room.emit(event, ...args);
+    }
+    /**
+     * Gets or creates a room by name
+     * @param name - The name of the room to get or create
+     * @returns The Room instance
+     */
+    room(name) {
+        return getRoom(this.rooms, name);
     }
     /**
      * Emits an event to all sockets in the namespace's room except the specified socket
@@ -58,6 +60,15 @@ export class Namespace {
      * @param args - The arguments to pass with the event
      */
     emitWithoutSelf(socket, event, ...args) {
-        this.room.emitWithoutSelf(socket, event, ...args);
+        this._room.emitWithoutSelf(socket, event, ...args);
+    }
+    /**
+     * Emits an event to the socket associated with the specified user ID
+     * @param userId - The user ID to target
+     * @param event - The event name to emit
+     * @param args - The arguments to pass with the event
+     */
+    emitToUserId(userId, event, ...args) {
+        this.users.get(userId)?.emit(event, ...args);
     }
 }

package/dist/room.d.ts

@@ -5,7 +5,7 @@ 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>;
+    _clients: Set<GLSocket>;
     eventEmitter: EventEmitter<any>;
     /**
      * Adds a socket to the room
@@ -66,19 +66,9 @@ export declare class Room {
     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
+ * Gets or creates a room by name
+ * @param rooms - The map of rooms to search in
+ * @param name - The name of the room to get or create
+ * @returns The Room instance
  */
-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;
+export declare function getRoom(rooms: Rooms, name: string): Room;

package/dist/room.js

@@ -3,14 +3,15 @@ import EventEmitter from "events";
  * Room class represents a collection of sockets that can communicate with each other
  */
 export class Room {
-    clients = new Set();
+    _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._clients.add(socket);
+        socket.rooms.add(this);
         this.eventEmitter.emit("join", socket, this);
     }
     /**
@@ -18,15 +19,21 @@ export class Room {
      * @param socket - The socket to remove from the room
      */
     leave(socket) {
-        this.clients.delete(socket);
+        this._clients.delete(socket);
+        socket.rooms.delete(this);
         this.eventEmitter.emit("leave", socket, this);
+        if (this._clients.size === 0)
+            this.eventEmitter.emit("empty", this);
     }
     /**
      * Removes all sockets from the room
      */
     leaveAll() {
-        this.clients.clear();
+        for (const socket of this._clients)
+            socket.rooms.delete(this);
+        this._clients.clear();
         this.eventEmitter.emit("leaveAll", this);
+        this.eventEmitter.emit("empty", this);
     }
     /**
      * Registers a handler for when a socket joins the room
@@ -51,14 +58,14 @@ export class Room {
      * @returns The number of clients in the room
      */
     get size() {
-        return this.clients.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);
+        return Array.from(this._clients);
     }
     /**
      * Emits an event to all clients in the room
@@ -66,7 +73,7 @@ export class Room {
      * @param data - The data to send with the event
      */
     emit(evtName, ...data) {
-        for (const socket of this.clients) {
+        for (const socket of this._clients) {
             socket.emit(evtName, ...data);
         }
     }
@@ -77,7 +84,7 @@ export class Room {
      * @param data - The data to send with the event
      */
     emitWithoutSelf(socket, evtName, ...data) {
-        for (const client of this.clients) {
+        for (const client of this._clients) {
             if (client === socket)
                 continue;
             client.emit(evtName, ...data);
@@ -89,40 +96,21 @@ export class Room {
      * @returns True if the socket is in the room, false otherwise
      */
     has(socket) {
-        return this.clients.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
+ * Gets or creates a room by name
+ * @param rooms - The map of rooms to search in
+ * @param name - The name of the room to get or create
+ * @returns The Room instance
  */
-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);
-    if (!room)
-        return;
-    room.leave(socket);
-    if (room.size > 0)
-        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())
-        room.leave(socket);
+export function getRoom(rooms, name) {
+    const existedRoom = rooms.get(name);
+    if (existedRoom)
+        return existedRoom;
+    const createdRoom = new Room();
+    rooms.set(name, createdRoom);
+    createdRoom.eventEmitter.on("empty", () => rooms.delete(name));
+    return createdRoom;
 }

package/dist/socket.d.ts

@@ -1,7 +1,8 @@
 import { WebSocket } from "ws";
-import { GlovesLinkServer } from "./index.js";
-import { Room, Rooms } from "./room.js";
+import { GlovesLinkServer, Namespace } from "./index.js";
+import { Room } from "./room.js";
 import { AuthFnResult, Server_Auth_Opts } from "./types.js";
+import EventEmitter from "events";
 /**
  * GLSocket class represents a WebSocket connection with additional functionality
  * @template T - The type of user data associated with the socket
@@ -13,16 +14,16 @@ export declare class GLSocket<T = {
     server: GlovesLinkServer;
     id: string;
     user: T;
-    namespace: string;
+    namespacePath: string;
+    namespace: Namespace;
+    rooms: Set<Room>;
     ackIdCounter: number;
     ackCallbacks: Map<number, Function>;
     logs: boolean;
-    handlers: {
-        [key: string]: Function;
-    };
-    rooms: Set<string>;
+    handlers: EventEmitter<any>;
     authData: Server_Auth_Opts;
     authResult: AuthFnResult;
+    dataFormatType: "json" | "bin";
     /**
      * Creates a new GLSocket instance
      * @param ws - The underlying WebSocket connection
@@ -57,41 +58,25 @@ export declare class GLSocket<T = {
     /**
      * Closes the WebSocket connection
      */
-    close(): void;
+    disconnect(): void;
     /**
      * Joins the socket to a room
      * @param roomName - The name of the room to join
      */
-    joinRoom(roomName: string): void;
+    joinRoom(roomOrName: Room | string): void;
     /**
      * Removes the socket from a room
      * @param roomName - The name of the room to leave
      */
-    leaveRoom(roomName: string): void;
+    leaveRoom(roomOrName: Room | 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
+     * Gets a room by name
+     * @param name - The name of the room to get
+     * @returns The room object or undefined if not found
      */
-    serverRooms(): Rooms;
-    disconnect(): void;
+    room(name: string): Room;
 }

package/dist/socket.js

@@ -1,4 +1,5 @@
-import { joinSocketToRoom, leaveSocketFromRoom } from "./room.js";
+import { parse, stringify } from "./transport.js";
+import EventEmitter from "events";
 /**
  * GLSocket class represents a WebSocket connection with additional functionality
  * @template T - The type of user data associated with the socket
@@ -8,14 +9,16 @@ export class GLSocket {
     server;
     id;
     user;
+    namespacePath;
     namespace;
+    rooms = new Set();
     ackIdCounter = 1;
     ackCallbacks = new Map();
     logs = false;
-    handlers;
-    rooms = new Set();
+    handlers = new EventEmitter();
     authData;
     authResult;
+    dataFormatType = "json";
     /**
      * Creates a new GLSocket instance
      * @param ws - The underlying WebSocket connection
@@ -27,21 +30,17 @@ export class GLSocket {
         this.server = server;
         this.id = id || Date.now().toString(36) + Math.random().toString(36).substring(2, 10);
         this.user = { _id: this.id };
-        this.handlers = {};
-        this.ws.on("message", (raw) => this._handle(raw));
+        this.ws.on("message", (raw) => this._handle(raw.toString()));
     }
     /**
      * Internal method to handle incoming messages from the WebSocket
      * @param raw - The raw message string received from the WebSocket
      */
     _handle(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw);
-        }
-        catch {
+        const msg = parse(this.dataFormatType, raw);
+        if (!msg) {
             if (this.logs)
-                console.warn("[ws] Invalid JSON:", raw);
+                console.warn(`[ws] Invalid format (${this.dataFormatType}):`, raw);
             return;
         }
         if ("ack" in msg) {
@@ -67,7 +66,7 @@ export class GLSocket {
                     break;
                 const ackId = data[ackIndex];
                 data[ackIndex] = (...res) => {
-                    this.ws.send(JSON.stringify({ ack: ackId, data: res }));
+                    this.ws.send(stringify(this.dataFormatType, { ack: ackId, data: res }));
                 };
             }
         }
@@ -79,7 +78,7 @@ export class GLSocket {
      * @param handler - The function to be called when the event is received
      */
     on(evt, handler) {
-        this.handlers[evt] = handler;
+        this.handlers.on(evt, handler);
     }
     /**
      * Sends an event to the connected WebSocket client
@@ -97,7 +96,7 @@ export class GLSocket {
             this.ackCallbacks.set(ackId, args[ackIndex]);
             args[ackIndex] = ackId;
         }
-        this.ws.send(JSON.stringify({
+        this.ws.send(stringify(this.dataFormatType, {
             evt,
             data: args || undefined,
             ackI: ackI.length ? ackI : undefined
@@ -115,64 +114,38 @@ export class GLSocket {
     /**
      * Closes the WebSocket connection
      */
-    close() {
+    disconnect() {
         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);
+    joinRoom(roomOrName) {
+        const room = typeof roomOrName === "string" ? this.room(roomOrName) : roomOrName;
+        room.join(this);
     }
     /**
      * Removes the socket from a room
      * @param roomName - The name of the room to leave
      */
-    leaveRoom(roomName) {
-        leaveSocketFromRoom(this, roomName);
-        this.rooms.delete(roomName);
+    leaveRoom(roomOrName) {
+        const room = typeof roomOrName === "string" ? this.room(roomOrName) : roomOrName;
+        room.leave(this);
     }
     /**
      * Removes the socket from all rooms it has joined
      */
     leaveAllRooms() {
-        for (const roomName of this.rooms) {
-            leaveSocketFromRoom(this, roomName);
-        }
-        this.rooms.clear();
+        for (const room of this.rooms.values())
+            room.leave(this);
     }
     /**
-     * Gets the namespace associated with this socket
-     * @returns The namespace object or undefined if not found
+     * Gets a room by name
+     * @param name - The name of the room to get
+     * @returns The room 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;
-    }
-    disconnect() {
-        this.ws.close();
+    room(name) {
+        return this.namespace.room(name);
     }
 }

package/dist/transport.d.ts

@@ -0,0 +1,3 @@
+import { Server_AckEvent, Server_DataEvent } from "./types.js";
+export declare function parse(type: string, raw: string): Server_DataEvent | Server_AckEvent;
+export declare function stringify(type: "json" | "bin", data: any): string;

package/dist/transport.js

@@ -0,0 +1,47 @@
+const DELIMITER = process.env.GLOVES_LINK_DELIMITER || "\b";
+export function parse(type, raw) {
+    if (type === "json") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const [evt, ack, ackIdsString, ...contentString] = raw.split(DELIMITER);
+        const contents = contentString.map(value => {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        });
+        if (ack) {
+            return {
+                ack: Number(ack),
+                data: contents,
+            };
+        }
+        const ackIds = ackIdsString.split(",").filter(Boolean).map(Number);
+        return {
+            evt,
+            ackI: ackIds,
+            data: contents,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function stringify(type, data) {
+    if (type === "json")
+        return JSON.stringify(data);
+    return [
+        data.evt ?? "",
+        (data.ack ?? ""),
+        (data.ackI || []).join(","),
+        ...data.data.map(JSON.stringify)
+    ].join(DELIMITER);
+}

package/dist/types.d.ts

@@ -3,6 +3,7 @@ import Stream from "stream";
 import { GLSocket } from "./socket.js";
 export interface Server_Opts {
     logs: boolean;
+    statusTimeout: number;
 }
 export interface Server_DataEvent {
     evt: string;
@@ -30,3 +31,9 @@ export interface AuthFnResult {
 }
 export type AuthFn = (data: Server_Auth_Opts) => Promise<AuthFnResult>;
 export type OnConnect = (socket: GLSocket, auth: Server_Auth_Opts, result: AuthFnResult) => void;
+export interface SocketStatus {
+    socketSelfId: string;
+    namespace: string;
+    status: number;
+    msg?: string;
+}

package/package.json

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