moons-ta-client 1.0.2 → 1.0.4

package/dist/scraper.d.ts

@@ -0,0 +1,2 @@
+import { Tournament } from "./models/models.js";
+export declare function getTournaments(token: string, onProgress: (totalServers: number, succeededServers: number, failedServers: number) => void, onComplete: (tournaments: Tournament[]) => void): void;

package/dist/scraper.js

@@ -0,0 +1,87 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { TAClient } from "./tournament-assistant-client.js";
+const MASTER_ADDRESS = "server.tournamentassistant.net";
+const MASTER_PORT = "8676";
+export function getTournaments(token, onProgress, onComplete) {
+    const scraper = new Scraper(token);
+    scraper.on("onProgress", (progress) => {
+        onProgress(progress.totalServers, progress.succeededServers, progress.failedServers);
+        if (progress.failedServers + progress.succeededServers ===
+            progress.totalServers) {
+            onComplete(progress.tournaments);
+        }
+    });
+    scraper.getTournaments();
+}
+class Scraper extends CustomEventEmitter {
+    servers = [];
+    tournaments = [];
+    token;
+    succeededServers = 0;
+    failedServers = 0;
+    constructor(token) {
+        super();
+        this.token = token;
+    }
+    getTournaments() {
+        const masterClient = new TAClient();
+        masterClient.setAuthToken(this.token);
+        masterClient.on("connectedToServer", async (response) => {
+            this.servers = response.state.knownServers;
+            this.tournaments = response.state.tournaments;
+            masterClient.disconnect();
+            //We successfully got tournaments from the master server
+            this.succeededServers++;
+            this.emit("onProgress", {
+                totalServers: this.servers.length,
+                succeededServers: this.succeededServers,
+                failedServers: this.failedServers,
+                tournaments: this.tournaments,
+            });
+            //Just running this map kicks off all the Promises, so no need to await them.
+            //This is probably a sin. If anyone knows the proper way to do this, hit me up on discord
+            this.servers
+                .filter((x) => `${x.address}:${x.websocketPort}` !==
+                `${MASTER_ADDRESS}:${MASTER_PORT}`)
+                .map((x) => this.getTournamentsFromServer(x.address, `${x.websocketPort}`));
+        });
+        masterClient.on("failedToConnectToServer", () => {
+            //We failed to get tournaments from the master server
+            this.failedServers++;
+            this.emit("onProgress", {
+                totalServers: this.servers.length,
+                succeededServers: this.succeededServers,
+                failedServers: this.failedServers,
+                tournaments: this.tournaments,
+            });
+        });
+        masterClient.connect(MASTER_ADDRESS, MASTER_PORT);
+    }
+    async getTournamentsFromServer(address, port) {
+        const client = new TAClient();
+        client.setAuthToken(this.token);
+        client.on("connectedToServer", (response) => {
+            this.tournaments = [...this.tournaments, ...response.state.tournaments];
+            client.disconnect();
+            //We successfully got tournaments from the server
+            this.succeededServers++;
+            this.emit("onProgress", {
+                totalServers: this.servers.length,
+                succeededServers: this.succeededServers,
+                failedServers: this.failedServers,
+                tournaments: this.tournaments,
+            });
+        });
+        client.on("failedToConnectToServer", () => {
+            //We failed to get tournaments from the server
+            this.failedServers++;
+            this.emit("onProgress", {
+                totalServers: this.servers.length,
+                succeededServers: this.succeededServers,
+                failedServers: this.failedServers,
+                tournaments: this.tournaments,
+            });
+        });
+        client.connect(address, port);
+    }
+}

package/dist/state-manager.d.ts

@@ -0,0 +1,50 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { User, Tournament, Match, QualifierEvent, CoreServer } from "./models/models.js";
+import { Packet } from "./models/packets.js";
+type StateManagerEvents = {
+    userConnected: [User, Tournament];
+    userUpdated: [User, Tournament];
+    userDisconnected: [User, Tournament];
+    matchCreated: [Match, Tournament];
+    matchUpdated: [Match, Tournament];
+    matchDeleted: [Match, Tournament];
+    qualifierCreated: [QualifierEvent, Tournament];
+    qualifierUpdated: [QualifierEvent, Tournament];
+    qualifierDeleted: [QualifierEvent, Tournament];
+    tournamentCreated: Tournament;
+    tournamentUpdated: Tournament;
+    tournamentDeleted: Tournament;
+    serverAdded: CoreServer;
+    serverDeleted: CoreServer;
+};
+export declare class StateManager extends CustomEventEmitter<StateManagerEvents> {
+    private state;
+    private self;
+    constructor();
+    handlePacket(packet: Packet): void;
+    getSelfGuid(): string;
+    getTournaments(): Tournament[];
+    getTournament(id: string): Tournament | undefined;
+    getUsers(tournamentId: string): User[] | undefined;
+    getUser(tournamentId: string, userId: string): User | undefined;
+    getMatches(tournamentId: string): Match[] | undefined;
+    getMatch(tournamentId: string, matchId: string): Match | undefined;
+    getQualifiers(tournamentId: string): QualifierEvent[] | undefined;
+    getQualifier(tournamentId: string, qualifierId: string): QualifierEvent | undefined;
+    getKnownServers(): CoreServer[];
+    private userConnected;
+    private userUpdated;
+    private userDisconnected;
+    private matchCreated;
+    private matchUpdated;
+    private matchDeleted;
+    private qualifierEventCreated;
+    private qualifierEventUpdated;
+    private qualifierEventDeleted;
+    private tournamentCreated;
+    private tournamentUpdated;
+    private tournamentDeleted;
+    private serverAdded;
+    private serverDeleted;
+}
+export {};

package/dist/state-manager.js

@@ -0,0 +1,196 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { v4 as uuidv4 } from "uuid";
+import { Response_ResponseType } from "./models/responses.js";
+export class StateManager extends CustomEventEmitter {
+    state;
+    self;
+    constructor() {
+        super();
+        this.self = uuidv4();
+        this.state = {
+            tournaments: [],
+            knownServers: [],
+        };
+    }
+    // --- Packet handler --- //
+    handlePacket(packet) {
+        if (packet.packet.oneofKind === "event") {
+            const event = packet.packet.event;
+            switch (event.changedObject.oneofKind) {
+                case "userAdded": {
+                    this.userConnected(event.changedObject.userAdded.tournamentId, event.changedObject.userAdded.user);
+                    break;
+                }
+                case "userUpdated": {
+                    this.userUpdated(event.changedObject.userUpdated.tournamentId, event.changedObject.userUpdated.user);
+                    break;
+                }
+                case "userLeft": {
+                    this.userDisconnected(event.changedObject.userLeft.tournamentId, event.changedObject.userLeft.user);
+                    break;
+                }
+                case "matchCreated": {
+                    this.matchCreated(event.changedObject.matchCreated.tournamentId, event.changedObject.matchCreated.match);
+                    break;
+                }
+                case "matchUpdated": {
+                    this.matchUpdated(event.changedObject.matchUpdated.tournamentId, event.changedObject.matchUpdated.match);
+                    break;
+                }
+                case "matchDeleted": {
+                    this.matchDeleted(event.changedObject.matchDeleted.tournamentId, event.changedObject.matchDeleted.match);
+                    break;
+                }
+                case "qualifierCreated": {
+                    this.qualifierEventCreated(event.changedObject.qualifierCreated.tournamentId, event.changedObject.qualifierCreated.event);
+                    break;
+                }
+                case "qualifierUpdated": {
+                    this.qualifierEventUpdated(event.changedObject.qualifierUpdated.tournamentId, event.changedObject.qualifierUpdated.event);
+                    break;
+                }
+                case "qualifierDeleted": {
+                    this.qualifierEventDeleted(event.changedObject.qualifierDeleted.tournamentId, event.changedObject.qualifierDeleted.event);
+                    break;
+                }
+                case "tournamentCreated": {
+                    this.tournamentCreated(event.changedObject.tournamentCreated.tournament);
+                    break;
+                }
+                case "tournamentUpdated": {
+                    this.tournamentUpdated(event.changedObject.tournamentUpdated.tournament);
+                    break;
+                }
+                case "tournamentDeleted": {
+                    this.tournamentDeleted(event.changedObject.tournamentDeleted.tournament);
+                    break;
+                }
+                case "serverAdded": {
+                    this.serverAdded(event.changedObject.serverAdded.server);
+                    break;
+                }
+                case "serverDeleted": {
+                    this.serverDeleted(event.changedObject.serverDeleted.server);
+                    break;
+                }
+            }
+        }
+        else if (packet.packet.oneofKind === "response") {
+            const response = packet.packet.response;
+            if (response.details.oneofKind === "connect") {
+                const connect = response.details.connect;
+                if (response.type === Response_ResponseType.Success) {
+                    this.state = connect.state;
+                }
+            }
+            else if (response.details.oneofKind === "join") {
+                const join = response.details.join;
+                if (response.type === Response_ResponseType.Success) {
+                    this.state = join.state;
+                    this.self = join.selfGuid;
+                }
+            }
+        }
+    }
+    // --- Helpers --- //
+    getSelfGuid() {
+        return this.self;
+    }
+    getTournaments() {
+        return this.state.tournaments;
+    }
+    getTournament(id) {
+        return this.state.tournaments.find((x) => x.guid === id);
+    }
+    getUsers(tournamentId) {
+        return this.getTournament(tournamentId)?.users;
+    }
+    getUser(tournamentId, userId) {
+        return this.getUsers(tournamentId)?.find((x) => x.guid === userId);
+    }
+    getMatches(tournamentId) {
+        return this.getTournament(tournamentId)?.matches;
+    }
+    getMatch(tournamentId, matchId) {
+        return this.getMatches(tournamentId)?.find((x) => x.guid === matchId);
+    }
+    getQualifiers(tournamentId) {
+        return this.getTournament(tournamentId)?.qualifiers;
+    }
+    getQualifier(tournamentId, qualifierId) {
+        return this.getQualifiers(tournamentId)?.find((x) => x.guid === qualifierId);
+    }
+    getKnownServers() {
+        return this.state.knownServers;
+    }
+    // --- Event handlers --- //
+    userConnected = (tournamentId, user) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.users = [...tournament.users, user];
+        this.emit("userConnected", [user, tournament]);
+    };
+    userUpdated = (tournamentId, user) => {
+        const tournament = this.getTournament(tournamentId);
+        const index = tournament.users.findIndex((x) => x.guid === user.guid);
+        tournament.users[index] = user;
+        this.emit("userUpdated", [user, tournament]);
+    };
+    userDisconnected = (tournamentId, user) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.users = tournament.users.filter((x) => x.guid !== user.guid);
+        this.emit("userDisconnected", [user, tournament]);
+    };
+    matchCreated = (tournamentId, match) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.matches = [...tournament.matches, match];
+        this.emit("matchCreated", [match, tournament]);
+    };
+    matchUpdated = (tournamentId, match) => {
+        const tournament = this.getTournament(tournamentId);
+        const index = tournament.matches.findIndex((x) => x.guid === match.guid);
+        tournament.matches[index] = match;
+        this.emit("matchUpdated", [match, tournament]);
+    };
+    matchDeleted = (tournamentId, match) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.matches = tournament.matches.filter((x) => x.guid !== match.guid);
+        this.emit("matchDeleted", [match, tournament]);
+    };
+    qualifierEventCreated = (tournamentId, event) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.qualifiers = [...tournament.qualifiers, event];
+        this.emit("qualifierCreated", [event, tournament]);
+    };
+    qualifierEventUpdated = (tournamentId, event) => {
+        const tournament = this.getTournament(tournamentId);
+        const index = tournament.qualifiers.findIndex((x) => x.guid === event.guid);
+        tournament.qualifiers[index] = event;
+        this.emit("qualifierUpdated", [event, tournament]);
+    };
+    qualifierEventDeleted = (tournamentId, event) => {
+        const tournament = this.getTournament(tournamentId);
+        tournament.qualifiers = tournament.qualifiers.filter((x) => x.guid !== event.guid);
+        this.emit("qualifierDeleted", [event, tournament]);
+    };
+    tournamentCreated = (tournament) => {
+        this.state.tournaments = [...this.state.tournaments, tournament];
+        this.emit("tournamentCreated", tournament);
+    };
+    tournamentUpdated = (tournament) => {
+        const index = this.state.tournaments.findIndex((x) => x.guid === tournament.guid);
+        this.state.tournaments[index] = tournament;
+        this.emit("tournamentUpdated", tournament);
+    };
+    tournamentDeleted = (tournament) => {
+        this.state.tournaments = this.state.tournaments.filter((x) => x.guid !== tournament.guid);
+        this.emit("tournamentDeleted", tournament);
+    };
+    serverAdded = (server) => {
+        this.state.knownServers = [...this.state.knownServers, server];
+        this.emit("serverAdded", server);
+    };
+    serverDeleted = (server) => {
+        this.state.knownServers = this.state.knownServers.filter((x) => `${server.address}:${server.port}` !== `${x.address}:${x.port}`);
+        this.emit("serverDeleted", server);
+    };
+}

package/dist/tournament-assistant-client.d.ts

@@ -0,0 +1,114 @@
+import { CustomEventEmitter } from "./custom-event-emitter.js";
+import { User, Match, QualifierEvent, CoreServer, Tournament, GameplayParameters, Map, QualifierEvent_EventSettings, QualifierEvent_LeaderboardSort, Tournament_TournamentSettings_Team, Tournament_TournamentSettings_Pool, Permissions, RealtimeScore } from "./models/models.js";
+import { StateManager } from "./state-manager.js";
+import { Response, Response_Connect } from "./models/responses.js";
+import { Request_LoadSong } from "./models/requests.js";
+import { Channel, Push_SongFinished } from "./models/index.js";
+export * from "./scraper.js";
+export * from "./models/models.js";
+export type ResponseFromUser = {
+    userId: string;
+    response: Response;
+};
+type TAClientEvents = {
+    connectedToServer: Response_Connect;
+    connectingToServer: {};
+    failedToConnectToServer: {};
+    disconnectedFromServer: {};
+    authorizationRequestedFromServer: string;
+    authorizedWithServer: string;
+    failedToAuthorizeWithServer: {};
+    loadSongRequested: [string, string, Request_LoadSong];
+    songFinished: Push_SongFinished;
+    realtimeScore: RealtimeScore;
+    responseReceived: ResponseFromUser;
+    joinedTournament: {};
+    failedToJoinTournament: {};
+    createdTournament: {};
+    updatedTournament: {};
+    deletedTournament: {};
+    failedToCreateTournament: {};
+    failedToUpdateTournament: {};
+    failedToDeleteTournament: {};
+    createdMatch: {};
+    updatedMatch: {};
+    deletedMatch: {};
+    failedToCreateMatch: {};
+    failedToUpdateMatch: {};
+    failedToDeleteMatch: {};
+    createdQualifier: {};
+    updatedQualifier: {};
+    deletedQualifier: {};
+    failedToCreateQualifier: {};
+    failedToUpdateQualifier: {};
+    failedToDeleteQualifier: {};
+};
+export declare class TAClient extends CustomEventEmitter<TAClientEvents> {
+    stateManager: StateManager;
+    private client?;
+    private token;
+    private shouldHeartbeat;
+    private heartbeatInterval;
+    constructor();
+    get isConnected(): boolean;
+    get isConnecting(): boolean;
+    connect(serverAddress: string, port: string): Promise<Response>;
+    disconnect(): void;
+    setAuthToken(token: string): void;
+    private forwardToUsers;
+    private sendCommand;
+    private sendRequest;
+    sendResponse(response: Response, to?: string[]): Promise<void>;
+    playSong: (gameplayParameters: GameplayParameters, userIds: string[]) => void;
+    returnToMenu: (userIds: string[]) => void;
+    showLoadedImage: (userIds: string[]) => void;
+    delayTestFinished: (userIds: string[]) => void;
+    joinTournament: (tournamentId: string) => Promise<Response>;
+    getLeaderboard: (tournamentId: string, qualifierId: string, mapId: string) => Promise<Response>;
+    loadSong: (levelId: string, userIds: string[]) => Promise<ResponseFromUser[]>;
+    loadImage: (bitmap: Uint8Array, userIds: string[]) => Promise<ResponseFromUser[]>;
+    private handlePacket;
+    updateUser: (tournamentId: string, user: User) => Promise<Response>;
+    createMatch: (tournamentId: string, match: Match) => Promise<Response>;
+    addUserToMatch: (tournamentId: string, matchId: string, userId: string) => Promise<Response>;
+    removeUserFromMatch: (tournamentId: string, matchId: string, userId: string) => Promise<Response>;
+    setMatchLeader: (tournamentId: string, matchId: string, userId: string) => Promise<Response>;
+    setMatchMap: (tournamentId: string, matchId: string, map: Map) => Promise<Response>;
+    deleteMatch: (tournamentId: string, matchId: string) => Promise<Response>;
+    createQualifierEvent: (tournamentId: string, event: QualifierEvent) => Promise<Response>;
+    setQualifierName: (tournamentId: string, qualifierId: string, qualifierName: string) => Promise<Response>;
+    setQualifierImage: (tournamentId: string, qualifierId: string, qualifierImage: Uint8Array) => Promise<Response>;
+    setQualifierInfoChannel: (tournamentId: string, qualifierId: string, infoChannel: Channel) => Promise<Response>;
+    setQualifierFlags: (tournamentId: string, qualifierId: string, qualifierFlags: QualifierEvent_EventSettings) => Promise<Response>;
+    setQualifierLeaderboardSort: (tournamentId: string, qualifierId: string, qualifierLeaderboardSort: QualifierEvent_LeaderboardSort) => Promise<Response>;
+    addQualifierMap: (tournamentId: string, qualifierId: string, map: Map) => Promise<Response>;
+    updateQualifierMap: (tournamentId: string, qualifierId: string, map: Map) => Promise<Response>;
+    removeQualifierMap: (tournamentId: string, qualifierId: string, mapId: string) => Promise<Response>;
+    deleteQualifierEvent: (tournamentId: string, qualifierId: string) => Promise<Response>;
+    addAuthorizedUser: (tournamentId: string, discordId: string, permissionFlags: Permissions) => Promise<Response>;
+    removeAuthorizedUser: (tournamentId: string, discordId: string) => Promise<Response>;
+    getAuthorizedUsers: (tournamentId: string) => Promise<Response>;
+    getDiscordInfo: (tournamentId: string, discordId: string) => Promise<Response>;
+    createTournament: (tournament: Tournament) => Promise<Response>;
+    setTournamentName: (tournamentId: string, tournamentName: string) => Promise<Response>;
+    setTournamentImage: (tournamentId: string, tournamentImage: Uint8Array) => Promise<Response>;
+    setTournamentEnableTeams: (tournamentId: string, enableTeams: boolean) => Promise<Response>;
+    setTournamentEnablePools: (tournamentId: string, enablePools: boolean) => Promise<Response>;
+    setTournamentShowTournamentButton: (tournamentId: string, showTournamentButton: boolean) => Promise<Response>;
+    setTournamentShowQualifierButton: (tournamentId: string, showQualifierButton: boolean) => Promise<Response>;
+    setTournamentAllowUnauthorizedView: (tournamentId: string, allowUnauthorizedView: boolean) => Promise<Response>;
+    setTournamentScoreUpdateFrequency: (tournamentId: string, scoreUpdateFrequency: number) => Promise<Response>;
+    setTournamentBannedMods: (tournamentId: string, bannedMods: string[]) => Promise<Response>;
+    addTournamentTeam: (tournamentId: string, team: Tournament_TournamentSettings_Team) => Promise<Response>;
+    setTournamentTeamName: (tournamentId: string, teamId: string, teamName: string) => Promise<Response>;
+    setTournamentTeamImage: (tournamentId: string, teamId: string, teamImage: Uint8Array) => Promise<Response>;
+    removeTournamentTeam: (tournamentId: string, teamId: string) => Promise<Response>;
+    addTournamentPool: (tournamentId: string, pool: Tournament_TournamentSettings_Pool) => Promise<Response>;
+    setTournamentPoolName: (tournamentId: string, poolId: string, poolName: string) => Promise<Response>;
+    addTournamentPoolMap: (tournamentId: string, poolId: string, map: Map) => Promise<Response>;
+    updateTournamentPoolMap: (tournamentId: string, poolId: string, map: Map) => Promise<Response>;
+    removeTournamentPoolMap: (tournamentId: string, poolId: string, mapId: string) => Promise<Response>;
+    removeTournamentPool: (tournamentId: string, poolId: string) => Promise<Response>;
+    deleteTournament: (tournamentId: string) => Promise<Response>;
+    addServer: (server: CoreServer, authToken?: string) => Promise<Response>;
+}