moons-ta-client 1.0.2 → 1.0.4

package/dist/client.d.ts

@@ -0,0 +1,22 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { Packet } from "./models/packets.js";
+export type ClientEvents = {
+    packetReceived: Packet;
+    connectedToServer: {};
+    failedToConnectToServer: {};
+    disconnectedFromServer: {};
+};
+export declare class Client extends CustomEventEmitter<ClientEvents> {
+    private address;
+    private port;
+    private token;
+    private websocket;
+    private websocketWasConnected;
+    constructor(address: string, port: string, token?: string);
+    get isConnected(): boolean;
+    get readyState(): 0 | 2 | 1 | 3 | undefined;
+    connect(): void;
+    disconnect(): void;
+    setToken(token: string): void;
+    send(packet: Packet, ids?: string[]): void;
+}

package/dist/client.js

@@ -0,0 +1,77 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { Packet } from "./models/packets.js";
+import WebSocket from "ws";
+export class Client extends CustomEventEmitter {
+    address;
+    port;
+    token;
+    websocket;
+    websocketWasConnected = false;
+    constructor(address, port, token) {
+        super();
+        this.address = address;
+        this.port = port;
+        this.token = token ?? "";
+    }
+    get isConnected() {
+        return this.websocket?.readyState === WebSocket.OPEN;
+    }
+    get readyState() {
+        return this.websocket?.readyState;
+    }
+    connect() {
+        this.websocket = new WebSocket(`wss://${this.address}:${this.port}`);
+        this.websocket.binaryType = "arraybuffer";
+        if (!this.websocket) {
+            this.emit("failedToConnectToServer", {});
+            return;
+        }
+        this.websocket.onopen = () => {
+            this.websocketWasConnected = true;
+            this.emit("connectedToServer", {});
+        };
+        this.websocket.onmessage = (event) => {
+            if (event.data instanceof ArrayBuffer) {
+                const packet = Packet.fromBinary(new Uint8Array(event.data));
+                this.emit("packetReceived", packet);
+            }
+        };
+        this.websocket.onclose = () => {
+            if (this.websocketWasConnected) {
+                this.emit("disconnectedFromServer", {});
+            }
+            else {
+                this.emit("failedToConnectToServer", {});
+            }
+        };
+        this.websocket.onerror = (error) => {
+            console.error(error);
+        };
+    }
+    disconnect() {
+        this.websocket?.close();
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    send(packet, ids) {
+        let toSend = packet;
+        toSend.token = this.token;
+        if (ids) {
+            const toForward = {
+                packet,
+                forwardTo: ids,
+            };
+            toSend = {
+                token: this.token,
+                from: packet.from,
+                id: packet.id,
+                packet: {
+                    oneofKind: "forwardingPacket",
+                    forwardingPacket: toForward,
+                },
+            };
+        }
+        this.websocket?.send(Packet.toBinary(toSend));
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const masterAddress = "server.tournamentassistant.net";
+export declare const masterPort = "8676";
+export declare const version = "1.0.7";
+export declare const versionCode = 107;

package/{src/constants.ts → dist/constants.js}

@@ -1,4 +1,4 @@
 export const masterAddress = "server.tournamentassistant.net";
 export const masterPort = "8676";
 export const version = "1.0.7";
-export const versionCode = 107;
+export const versionCode = 107;

package/dist/custom-event-emitter.d.ts

@@ -0,0 +1,7 @@
+export declare class CustomEventEmitter<T extends Record<string, any>> {
+    private emitter;
+    get on(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void;
+    get once(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void;
+    get emit(): <K extends Extract<keyof T, string | symbol>>(eventName: K, params: T[K]) => void;
+    get removeListener(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void;
+}

package/dist/custom-event-emitter.js

@@ -0,0 +1,16 @@
+import { EventEmitter } from 'events';
+export class CustomEventEmitter {
+    emitter = new EventEmitter();
+    get on() {
+        return this.emitter.on.bind(this.emitter);
+    }
+    get once() {
+        return this.emitter.once.bind(this.emitter);
+    }
+    get emit() {
+        return this.emitter.emit.bind(this.emitter);
+    }
+    get removeListener() {
+        return this.emitter.removeListener.bind(this.emitter);
+    }
+}