moons-ta-client 1.0.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "moons-ta-client",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "node": "./dist/index.js",
+      "default": "./dist/index.esm.js"
+    }
+  },
+  "scripts": {
+    "fix-imports": "node ./scripts/fixImports.mjs",
+    "build:tsc": "tsc",
+    "build:bundle": "node ./scripts/esbuild.mjs",
+    "build:bundle-dts": "rollup -c rollup.config.mjs",
+    "build": "npm run fix-imports && npm run build:tsc && npm run build:bundle && npm run build:bundle-dts"
+  },
+  "devDependencies": {
+    "@types/events": "^3.0.0",
+    "@types/uuid": "^8.3.4",
+    "@types/ws": "^8.5.10",
+    "esbuild": "^0.19.12",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "esbuild-plugin-globals": "^0.2.0",
+    "rollup": "^4.17.2",
+    "rollup-plugin-dts": "^6.1.1",
+    "tslib": "^2.3.1",
+    "typescript": "^4.5.4"
+  },
+  "dependencies": {
+    "@protobuf-ts/plugin": "^2.6.0",
+    "events": "^3.3.0",
+    "install": "^0.13.0",
+    "npm": "^10.8.0",
+    "uuid": "^9.0.0",
+    "ws": "^8.17.0"
+  }
+}

package/rollup.config.mjs

@@ -0,0 +1,16 @@
+import dts from 'rollup-plugin-dts';
+import path from 'path';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url); // get the resolved path to the file
+const __dirname = path.dirname(__filename); // get the name of the directory
+
+export default {
+    input: join(__dirname, './dist/index.d.ts'), // Entry point of your type definitions
+    output: {
+        file: join(__dirname, './dist/index.d.ts'), // Output file
+        format: 'es'
+    },
+    plugins: [dts()]
+};

package/scripts/esbuild.mjs

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import pkg from '../package.json' assert { type: 'json' };
+import esbuild from 'esbuild';
+import GlobalsPlugin from 'esbuild-plugin-globals';
+import { polyfillNode } from "esbuild-plugin-polyfill-node";
+
+esbuild.build({
+    entryPoints: ['src/index.ts'],
+    bundle: true,
+    outfile: pkg.exports['.'].default,
+    globalName: 'TournamentAssistantClient',
+    platform: 'browser',
+    define: {
+        global: 'window',
+    },
+    target: ['chrome80'],
+    format: 'esm',
+    plugins: [
+        GlobalsPlugin({
+            ws: 'WebSocket',
+        }),
+        polyfillNode(),
+    ],
+});

package/scripts/fixImports.mjs

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path'
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url); // get the resolved path to the file
+const __dirname = path.dirname(__filename); // get the name of the directory
+const directoryPath = path.join(__dirname, '../src/models');
+
+fs.readdir(directoryPath, (err, files) => {
+    if (err) {
+        return console.error('Unable to scan directory: ' + err);
+    }
+
+    files.forEach((file) => {
+        const filePath = path.join(directoryPath, file);
+
+        fs.readFile(filePath, 'utf8', (err, data) => {
+            if (err) {
+                return console.error('Unable to read file: ' + err);
+            }
+
+            const updatedData = data
+                .replace(/import\s+(.*?)\s+from\s+['"](\.\/.+?)['"]/g, (match, p1, p2) => {
+                    if (!p2.endsWith('.js')) {
+                        return `import ${p1} from '${p2}.js'`;
+                    }
+                    return match;
+                })
+                .replace(/export\s+.*?from\s+['"](\.\/.+?)['"]/g, (match, p1) => {
+                    if (!p1.endsWith('.js')) {
+                        return match.replace(p1, `${p1}.js`);
+                    }
+                    return match;
+                });
+
+            fs.writeFile(filePath, updatedData, 'utf8', (err) => {
+                if (err) {
+                    return console.error('Unable to write file: ' + err);
+                }
+                console.log(`Updated file: ${filePath}`);
+            });
+        });
+    });
+});

package/src/client.ts

@@ -0,0 +1,101 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { Packet, ForwardingPacket } from "./models/packets.js";
+import WebSocket from "ws";
+
+// Created by Moon on 6/11/2022
+
+export type ClientEvents = {
+  packetReceived: Packet;
+  connectedToServer: {};
+  failedToConnectToServer: {};
+  disconnectedFromServer: {};
+};
+
+export class Client extends CustomEventEmitter<ClientEvents> {
+  private address: string;
+  private port: string;
+  private token: string;
+  private websocket: WebSocket | undefined;
+  private websocketWasConnected = false;
+
+  constructor(address: string, port: string, token?: string) {
+    super();
+    this.address = address;
+    this.port = port;
+    this.token = token ?? "";
+  }
+
+  public get isConnected() {
+    return this.websocket?.readyState === WebSocket.OPEN;
+  }
+
+  public get readyState() {
+    return this.websocket?.readyState;
+  }
+
+  public 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);
+    };
+  }
+
+  public disconnect() {
+    this.websocket?.close();
+  }
+
+  public setToken(token: string) {
+    this.token = token;
+  }
+
+  public send(packet: Packet, ids?: string[]): void {
+    let toSend = packet;
+    toSend.token = this.token;
+
+    if (ids) {
+      const toForward: ForwardingPacket = {
+        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/src/constants.ts

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

package/src/custom-event-emitter.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from 'events';
+
+export class CustomEventEmitter<T extends Record<string, any>> {
+    private emitter = new EventEmitter();
+
+    public get on(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void {
+        return this.emitter.on.bind(this.emitter);
+    }
+
+    public get once(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void {
+        return this.emitter.once.bind(this.emitter);
+    }
+
+    public get emit(): <K extends Extract<keyof T, string | symbol>>(eventName: K, params: T[K]) => void {
+        return this.emitter.emit.bind(this.emitter);
+    }
+
+    public get removeListener(): <K extends Extract<keyof T, string | symbol>>(eventName: K, fn: (params: T[K]) => void) => void {
+        return this.emitter.removeListener.bind(this.emitter);
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./tournament-assistant-client.js";
+export * from "./custom-event-emitter.js";
+export * from "./models/index.js";
+export * from "./constants.js";

package/src/models/commands.ts

@@ -0,0 +1,303 @@
+// @generated by protobuf-ts 2.8.2
+// @generated from protobuf file "commands.proto" (package "proto.packets", syntax proto3)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Channel } from './discord.js';
+import { GameplayParameters } from './models.js';
+/**
+ * ---- Commands (DO something!) ---- //
+ *
+ * @generated from protobuf message proto.packets.Command
+ */
+export interface Command {
+    /**
+     * @generated from protobuf oneof: type
+     */
+    type: {
+        oneofKind: "heartbeat";
+        /**
+         * @generated from protobuf field: bool heartbeat = 1;
+         */
+        heartbeat: boolean; // Is this really a command?
+    } | {
+        oneofKind: "returnToMenu";
+        /**
+         * @generated from protobuf field: bool return_to_menu = 2;
+         */
+        returnToMenu: boolean;
+    } | {
+        oneofKind: "delayTestFinish";
+        /**
+         * @generated from protobuf field: bool delay_test_finish = 3;
+         */
+        delayTestFinish: boolean;
+    } | {
+        oneofKind: "streamSyncShowImage";
+        /**
+         * @generated from protobuf field: bool stream_sync_show_image = 4;
+         */
+        streamSyncShowImage: boolean;
+    } | {
+        oneofKind: "playSong";
+        /**
+         * @generated from protobuf field: proto.packets.Command.PlaySong play_song = 6;
+         */
+        playSong: Command_PlaySong;
+    } | {
+        oneofKind: "sendBotMessage";
+        /**
+         * @generated from protobuf field: proto.packets.Command.SendBotMessage send_bot_message = 7;
+         */
+        sendBotMessage: Command_SendBotMessage;
+    } | {
+        oneofKind: "discordAuthorize";
+        /**
+         * @generated from protobuf field: string discord_authorize = 9;
+         */
+        discordAuthorize: string;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message proto.packets.Command.PlaySong
+ */
+export interface Command_PlaySong {
+    /**
+     * @generated from protobuf field: proto.models.GameplayParameters gameplay_parameters = 1;
+     */
+    gameplayParameters?: GameplayParameters;
+}
+/**
+ * @generated from protobuf message proto.packets.Command.SendBotMessage
+ */
+export interface Command_SendBotMessage {
+    /**
+     * @generated from protobuf field: proto.discord.Channel channel = 1;
+     */
+    channel?: Channel;
+    /**
+     * @generated from protobuf field: string message = 2;
+     */
+    message: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Command$Type extends MessageType<Command> {
+    constructor() {
+        super("proto.packets.Command", [
+            { no: 1, name: "heartbeat", kind: "scalar", oneof: "type", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "return_to_menu", kind: "scalar", oneof: "type", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "delay_test_finish", kind: "scalar", oneof: "type", T: 8 /*ScalarType.BOOL*/ },
+            { no: 4, name: "stream_sync_show_image", kind: "scalar", oneof: "type", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "play_song", kind: "message", oneof: "type", T: () => Command_PlaySong },
+            { no: 7, name: "send_bot_message", kind: "message", oneof: "type", T: () => Command_SendBotMessage },
+            { no: 9, name: "discord_authorize", kind: "scalar", oneof: "type", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Command>): Command {
+        const message = { type: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Command>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Command): Command {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool heartbeat */ 1:
+                    message.type = {
+                        oneofKind: "heartbeat",
+                        heartbeat: reader.bool()
+                    };
+                    break;
+                case /* bool return_to_menu */ 2:
+                    message.type = {
+                        oneofKind: "returnToMenu",
+                        returnToMenu: reader.bool()
+                    };
+                    break;
+                case /* bool delay_test_finish */ 3:
+                    message.type = {
+                        oneofKind: "delayTestFinish",
+                        delayTestFinish: reader.bool()
+                    };
+                    break;
+                case /* bool stream_sync_show_image */ 4:
+                    message.type = {
+                        oneofKind: "streamSyncShowImage",
+                        streamSyncShowImage: reader.bool()
+                    };
+                    break;
+                case /* proto.packets.Command.PlaySong play_song */ 6:
+                    message.type = {
+                        oneofKind: "playSong",
+                        playSong: Command_PlaySong.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).playSong)
+                    };
+                    break;
+                case /* proto.packets.Command.SendBotMessage send_bot_message */ 7:
+                    message.type = {
+                        oneofKind: "sendBotMessage",
+                        sendBotMessage: Command_SendBotMessage.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).sendBotMessage)
+                    };
+                    break;
+                case /* string discord_authorize */ 9:
+                    message.type = {
+                        oneofKind: "discordAuthorize",
+                        discordAuthorize: reader.string()
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Command, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool heartbeat = 1; */
+        if (message.type.oneofKind === "heartbeat")
+            writer.tag(1, WireType.Varint).bool(message.type.heartbeat);
+        /* bool return_to_menu = 2; */
+        if (message.type.oneofKind === "returnToMenu")
+            writer.tag(2, WireType.Varint).bool(message.type.returnToMenu);
+        /* bool delay_test_finish = 3; */
+        if (message.type.oneofKind === "delayTestFinish")
+            writer.tag(3, WireType.Varint).bool(message.type.delayTestFinish);
+        /* bool stream_sync_show_image = 4; */
+        if (message.type.oneofKind === "streamSyncShowImage")
+            writer.tag(4, WireType.Varint).bool(message.type.streamSyncShowImage);
+        /* proto.packets.Command.PlaySong play_song = 6; */
+        if (message.type.oneofKind === "playSong")
+            Command_PlaySong.internalBinaryWrite(message.type.playSong, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Command.SendBotMessage send_bot_message = 7; */
+        if (message.type.oneofKind === "sendBotMessage")
+            Command_SendBotMessage.internalBinaryWrite(message.type.sendBotMessage, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* string discord_authorize = 9; */
+        if (message.type.oneofKind === "discordAuthorize")
+            writer.tag(9, WireType.LengthDelimited).string(message.type.discordAuthorize);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Command
+ */
+export const Command = new Command$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Command_PlaySong$Type extends MessageType<Command_PlaySong> {
+    constructor() {
+        super("proto.packets.Command.PlaySong", [
+            { no: 1, name: "gameplay_parameters", kind: "message", T: () => GameplayParameters }
+        ]);
+    }
+    create(value?: PartialMessage<Command_PlaySong>): Command_PlaySong {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Command_PlaySong>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Command_PlaySong): Command_PlaySong {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.GameplayParameters gameplay_parameters */ 1:
+                    message.gameplayParameters = GameplayParameters.internalBinaryRead(reader, reader.uint32(), options, message.gameplayParameters);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Command_PlaySong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.GameplayParameters gameplay_parameters = 1; */
+        if (message.gameplayParameters)
+            GameplayParameters.internalBinaryWrite(message.gameplayParameters, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Command.PlaySong
+ */
+export const Command_PlaySong = new Command_PlaySong$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Command_SendBotMessage$Type extends MessageType<Command_SendBotMessage> {
+    constructor() {
+        super("proto.packets.Command.SendBotMessage", [
+            { no: 1, name: "channel", kind: "message", T: () => Channel },
+            { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Command_SendBotMessage>): Command_SendBotMessage {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Command_SendBotMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Command_SendBotMessage): Command_SendBotMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.discord.Channel channel */ 1:
+                    message.channel = Channel.internalBinaryRead(reader, reader.uint32(), options, message.channel);
+                    break;
+                case /* string message */ 2:
+                    message.message = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Command_SendBotMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.discord.Channel channel = 1; */
+        if (message.channel)
+            Channel.internalBinaryWrite(message.channel, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string message = 2; */
+        if (message.message !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.message);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Command.SendBotMessage
+ */
+export const Command_SendBotMessage = new Command_SendBotMessage$Type();