@wxn0brp/gloves-link-server 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { WebSocketServer } from "ws";
+import { Server_Opts } from "./types.js";
+import { GLSocket } from "./socket.js";
+import FalconFrame from "@wxn0brp/falcon-frame";
+import { Room, Rooms } from "./room.js";
+export declare class GlovesLinkServer {
+    wss: WebSocketServer;
+    private onConnectEvent;
+    logs: boolean;
+    opts: Server_Opts;
+    initStatusTemp: {
+        [key: string]: number;
+    };
+    rooms: Rooms;
+    globalRoom: Room;
+    constructor(opts: Partial<Server_Opts>);
+    private saveSocketStatus;
+    onConnect(handler: (ws: GLSocket) => void): void;
+    broadcast(event: string, ...args: any[]): void;
+    broadcastRoom(roomName: string, event: string, ...args: any[]): void;
+    broadcastWithoutSelf(socket: GLSocket, event: string, ...args: any[]): void;
+    room(name: string): Room;
+    falconFrame(app: FalconFrame, clientDir?: string): void;
+}
+export { GLSocket };

package/dist/index.js

@@ -0,0 +1,113 @@
+import { WebSocketServer } from "ws";
+import { GLSocket } from "./socket.js";
+import { Router } from "@wxn0brp/falcon-frame";
+import { Room } from "./room.js";
+export class GlovesLinkServer {
+    wss;
+    onConnectEvent;
+    logs = false;
+    opts;
+    initStatusTemp = {};
+    rooms = new Map();
+    globalRoom = new Room();
+    constructor(opts) {
+        this.opts = {
+            server: null,
+            logs: false,
+            authFn: () => true,
+            ...opts
+        };
+        if (!this.opts?.server) {
+            throw new Error("Server is not provided");
+        }
+        const { server } = opts;
+        this.wss = new WebSocketServer({ noServer: true });
+        server.on("upgrade", async (request, socket, head) => {
+            const headers = request.headers;
+            let socketSelfId;
+            try {
+                const url = new URL(request.url, `http://${request.headers.host}`);
+                const token = url.searchParams.get("token");
+                socketSelfId = url.searchParams.get("id");
+                const isAuthenticated = await this.opts.authFn({ headers, url, token });
+                if (!isAuthenticated) {
+                    this.saveSocketStatus(socketSelfId, 401);
+                    socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                    socket.destroy();
+                    return;
+                }
+                this.wss.handleUpgrade(request, socket, head, (ws) => {
+                    const glSocket = new GLSocket(ws, this);
+                    glSocket.logs = this.logs;
+                    this.globalRoom.join(glSocket);
+                    this.onConnectEvent(glSocket);
+                    ws.on("close", () => {
+                        glSocket.handlers?.disconnect?.();
+                        glSocket.leaveAllRooms();
+                        this.globalRoom.leave(glSocket);
+                    });
+                });
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === "development")
+                    console.error("[GlovesLinkServer]", err);
+                if (this.logs)
+                    console.warn("[auth] Error during authentication:", err);
+                this.saveSocketStatus(socketSelfId, 500);
+                socket.write("HTTP/1.1 500 Internal Server Error\r\n\r\n");
+                socket.destroy();
+            }
+        });
+    }
+    saveSocketStatus(socketSelfId, status) {
+        if (!socketSelfId)
+            return;
+        this.initStatusTemp[socketSelfId] = status;
+        setTimeout(() => {
+            delete this.initStatusTemp[socketSelfId];
+        }, 10_000);
+    }
+    onConnect(handler) {
+        this.onConnectEvent = handler;
+    }
+    broadcast(event, ...args) {
+        this.globalRoom.emit(event, ...args);
+    }
+    broadcastRoom(roomName, event, ...args) {
+        const room = this.room(roomName);
+        if (!room)
+            return;
+        room.emit(event, ...args);
+    }
+    broadcastWithoutSelf(socket, event, ...args) {
+        this.globalRoom.emitWithoutSelf(socket, event, ...args);
+    }
+    room(name) {
+        return this.rooms.get(name) || this.rooms.set(name, new Room()).get(name);
+    }
+    falconFrame(app, clientDir) {
+        clientDir = clientDir || "node_modules/@wxn0brp/gloves-link-client/dist/";
+        const router = new Router();
+        app.use("/gloves-link", router);
+        router.static("/", clientDir);
+        router.get("/status", (req, res) => {
+            const id = req.query.id;
+            if (!id) {
+                res.status(400).json({ err: true, msg: "No id provided" });
+                return;
+            }
+            const status = this.initStatusTemp[id];
+            if (status === undefined) {
+                res.status(404).json({ err: true, msg: "Socket not found" });
+                return;
+            }
+            res.json({ status });
+            delete this.initStatusTemp[id];
+        });
+        router.get("/*", (req, res) => {
+            res.redirect("/gloves-link/GlovesLinkClient.js");
+            res.end();
+        });
+    }
+}
+export { GLSocket };

package/dist/room.d.ts

@@ -0,0 +1,20 @@
+import EventEmitter from "events";
+import { GLSocket } from "./socket.js";
+export type Rooms = Map<string, Room>;
+export declare class Room {
+    clients: Set<GLSocket>;
+    eventEmitter: EventEmitter<[never]>;
+    join(socket: GLSocket): void;
+    leave(socket: GLSocket): void;
+    leaveAll(): void;
+    onJoin(handler: (socket: GLSocket, room: Room) => void): this;
+    onLeave(handler: (socket: GLSocket, room: Room) => void): this;
+    get size(): number;
+    get sockets(): GLSocket[];
+    emit(evtName: string, ...data: any): void;
+    emitWithoutSelf(socket: GLSocket, evtName: string, ...data: any): void;
+    has(socket: GLSocket): boolean;
+}
+export declare function joinSocketToRoom(socket: GLSocket, name: string): void;
+export declare function leaveSocketFromRoom(socket: GLSocket, roomName: string): void;
+export declare function leaveAllSocketFromRoom(socket: GLSocket): void;

package/dist/room.js

@@ -0,0 +1,66 @@
+import EventEmitter from "events";
+export class Room {
+    clients = new Set();
+    eventEmitter = new EventEmitter();
+    join(socket) {
+        this.clients.add(socket);
+        this.eventEmitter.emit("join", socket, this);
+    }
+    leave(socket) {
+        this.clients.delete(socket);
+        this.eventEmitter.emit("leave", socket, this);
+    }
+    leaveAll() {
+        this.clients.clear();
+        this.eventEmitter.emit("leaveAll", this);
+    }
+    onJoin(handler) {
+        this.eventEmitter.on("join", handler);
+        return this;
+    }
+    onLeave(handler) {
+        this.eventEmitter.on("leave", handler);
+        return this;
+    }
+    get size() {
+        return this.clients.size;
+    }
+    get sockets() {
+        return Array.from(this.clients);
+    }
+    emit(evtName, ...data) {
+        for (const socket of this.clients) {
+            socket.emit(evtName, ...data);
+        }
+    }
+    emitWithoutSelf(socket, evtName, ...data) {
+        for (const client of this.clients) {
+            if (client === socket)
+                continue;
+            client.emit(evtName, ...data);
+        }
+    }
+    has(socket) {
+        return this.clients.has(socket);
+    }
+}
+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);
+}
+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);
+}
+export function leaveAllSocketFromRoom(socket) {
+    const rooms = socket.server.rooms;
+    for (const room of rooms.values())
+        room.leave(socket);
+}

package/dist/socket.d.ts

@@ -0,0 +1,23 @@
+import { WebSocket } from "ws";
+import { GlovesLinkServer } from "./index.js";
+export declare class GLSocket {
+    ws: WebSocket;
+    server: GlovesLinkServer;
+    id: string;
+    ackIdCounter: number;
+    ackCallbacks: Map<number, Function>;
+    logs: boolean;
+    handlers: {
+        [key: string]: Function;
+    };
+    rooms: Set<string>;
+    constructor(ws: WebSocket, server: GlovesLinkServer, id?: string);
+    _handle(raw: string): void;
+    on(evt: string, handler: (...args: any[]) => void | any): void;
+    emit(evt: string, ...args: any[]): void;
+    send(evt: string, ...args: any[]): void;
+    close(): void;
+    joinRoom(roomName: string): void;
+    leaveRoom(roomName: string): void;
+    leaveAllRooms(): void;
+}

package/dist/socket.js

@@ -0,0 +1,91 @@
+import { joinSocketToRoom, leaveAllSocketFromRoom, leaveSocketFromRoom } from "./room.js";
+export class GLSocket {
+    ws;
+    server;
+    id;
+    ackIdCounter = 1;
+    ackCallbacks = new Map();
+    logs = false;
+    handlers;
+    rooms = new Set();
+    constructor(ws, server, id) {
+        this.ws = ws;
+        this.server = server;
+        this.id = id || Date.now().toString(36) + Math.random().toString(36).substring(2, 10);
+        this.handlers = {};
+        this.ws.on("message", (raw) => this._handle(raw));
+    }
+    _handle(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            if (this.logs)
+                console.warn("[ws] Invalid JSON:", raw);
+            return;
+        }
+        if ("ack" in msg) {
+            const ackId = msg.ack;
+            const ackCallback = this.ackCallbacks.get(ackId);
+            if (ackCallback) {
+                this.ackCallbacks.delete(ackId);
+                ackCallback(...msg.data);
+            }
+            return;
+        }
+        const { evt, data, ackI } = msg;
+        if (!evt || (data && !Array.isArray(data)))
+            return;
+        if (Array.isArray(ackI)) {
+            for (let i = 0; i < ackI.length; i++) {
+                const ackIndex = ackI[i];
+                if (!data[ackIndex])
+                    break;
+                const ackId = data[ackIndex];
+                data[ackIndex] = (...res) => {
+                    this.ws.send(JSON.stringify({ ack: ackId, data: res }));
+                };
+            }
+        }
+        this.handlers[evt]?.(...data);
+    }
+    on(evt, handler) {
+        this.handlers[evt] = handler;
+    }
+    emit(evt, ...args) {
+        const ackI = args.map((data, i) => {
+            if (typeof data === "function")
+                return i;
+        }).filter(i => i !== undefined);
+        for (let i = 0; i < ackI.length; i++) {
+            const ackIndex = ackI[i];
+            const ackId = this.ackIdCounter++;
+            this.ackCallbacks.set(ackId, args[ackIndex]);
+            args[ackIndex] = ackId;
+        }
+        this.ws.send(JSON.stringify({
+            evt,
+            data: args || undefined,
+            ackI: ackI.length ? ackI : undefined
+        }));
+    }
+    send(evt, ...args) {
+        return this.emit(evt, ...args);
+    }
+    close() {
+        this.ws.close();
+    }
+    joinRoom(roomName) {
+        joinSocketToRoom(this, roomName);
+        this.rooms.add(roomName);
+    }
+    leaveRoom(roomName) {
+        leaveSocketFromRoom(this, roomName);
+        this.rooms.delete(roomName);
+    }
+    leaveAllRooms() {
+        leaveAllSocketFromRoom(this);
+        this.rooms.clear();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import http from "http";
+export interface Server_Opts {
+    server: http.Server;
+    logs: boolean;
+    authFn: AuthFn;
+}
+export interface Server_DataEvent {
+    evt: string;
+    data: any[];
+    ackI?: number[];
+}
+export interface Server_AckEvent {
+    ack: number;
+    data: any[];
+}
+export interface Server_Auth_Opts {
+    headers: http.IncomingHttpHeaders;
+    url: URL;
+    token?: string;
+}
+export type AuthFn = (data: Server_Auth_Opts) => boolean | Promise<boolean>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@wxn0brp/gloves-link-server",
+    "version": "0.0.3",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "author": "wxn0brP",
+    "license": "MIT",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/wxn0brP/GlovesLink-server.git"
+    },
+    "homepage": "https://github.com/wxn0brP/GlovesLink",
+    "scripts": {
+        "build": "tsc && tsc-alias"
+    },
+    "devDependencies": {
+        "@wxn0brp/falcon-frame": "^0.5.3",
+        "@types/bun": "*",
+        "@types/ws": "^8.18.1",
+        "tsc-alias": "*",
+        "typescript": "*"
+    },
+    "peerDependencies": {
+        "@wxn0brp/falcon-frame": ">=0.5.3"
+    },
+    "peerDependenciesMeta": {
+        "@wxn0brp/falcon-frame": {
+            "optional": true
+        }
+    },
+    "dependencies": {
+        "ws": "^8.18.3"
+    },
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./*": {
+            "types": "./dist/*.d.ts",
+            "import": "./dist/*.js",
+            "default": "./dist/*.js"
+        }
+    }
+}