moons-ta-client 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moons-ta-client",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "main": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",
@@ -36,5 +36,11 @@
     "npm": "^10.8.0",
     "uuid": "^9.0.0",
     "ws": "^8.17.0"
-  }
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist",
+    "package.json"
+  ]
 }

package/rollup.config.mjs

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-/* 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

@@ -1,44 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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/custom-event-emitter.ts

@@ -1,21 +0,0 @@
-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/scraper.ts

@@ -1,137 +0,0 @@
-import { CustomEventEmitter } from "./custom-event-emitter.js";
-import { CoreServer, Tournament } from "./models/models.js";
-import { TAClient } from "./tournament-assistant-client.js";
-
-const MASTER_ADDRESS = "server.tournamentassistant.net";
-const MASTER_PORT = "8676";
-
-type OnProgress = {
-  totalServers: number;
-  succeededServers: number;
-  failedServers: number;
-  tournaments: Tournament[];
-};
-
-type ScraperEvents = {
-  onProgress: OnProgress;
-};
-
-export function getTournaments(
-  token: string,
-  onProgress: (
-    totalServers: number,
-    succeededServers: number,
-    failedServers: number
-  ) => void,
-  onComplete: (tournaments: Tournament[]) => void
-) {
-  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<ScraperEvents> {
-  private servers: CoreServer[] = [];
-  private tournaments: Tournament[] = [];
-  private token: string;
-
-  private succeededServers = 0;
-  private failedServers = 0;
-
-  constructor(token: string) {
-    super();
-    this.token = token;
-  }
-
-  public 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);
-  }
-
-  private async getTournamentsFromServer(address: string, port: string) {
-    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/src/state-manager.ts

@@ -1,308 +0,0 @@
-import { CustomEventEmitter } from "./custom-event-emitter.js";
-import {
-  User,
-  Tournament,
-  Match,
-  QualifierEvent,
-  CoreServer,
-  State,
-} from "./models/models.js";
-import { Packet } from "./models/packets.js";
-import { v4 as uuidv4 } from "uuid";
-import { Response_ResponseType } from "./models/responses.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 class StateManager extends CustomEventEmitter<StateManagerEvents> {
-  private state: State;
-  private self: string;
-
-  constructor() {
-    super();
-    this.self = uuidv4();
-    this.state = {
-      tournaments: [],
-      knownServers: [],
-    };
-  }
-
-  // --- Packet handler --- //
-  public handlePacket(packet: 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 --- //
-  public getSelfGuid() {
-    return this.self;
-  }
-
-  public getTournaments() {
-    return this.state.tournaments;
-  }
-
-  public getTournament(id: string) {
-    return this.state.tournaments.find((x) => x.guid === id);
-  }
-
-  public getUsers(tournamentId: string) {
-    return this.getTournament(tournamentId)?.users;
-  }
-
-  public getUser(tournamentId: string, userId: string) {
-    return this.getUsers(tournamentId)?.find((x) => x.guid === userId);
-  }
-
-  public getMatches(tournamentId: string) {
-    return this.getTournament(tournamentId)?.matches;
-  }
-
-  public getMatch(tournamentId: string, matchId: string) {
-    return this.getMatches(tournamentId)?.find((x) => x.guid === matchId);
-  }
-
-  public getQualifiers(tournamentId: string) {
-    return this.getTournament(tournamentId)?.qualifiers;
-  }
-
-  public getQualifier(tournamentId: string, qualifierId: string) {
-    return this.getQualifiers(tournamentId)?.find((x) => x.guid === qualifierId);
-  }
-
-  public getKnownServers() {
-    return this.state.knownServers;
-  }
-
-  // --- Event handlers --- //
-  private userConnected = (tournamentId: string, user: User) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.users = [...tournament!.users, user];
-    this.emit("userConnected", [user, tournament!]);
-  };
-
-  private userUpdated = (tournamentId: string, user: 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!]);
-  };
-
-  private userDisconnected = (tournamentId: string, user: User) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.users = tournament!.users.filter((x) => x.guid !== user.guid);
-    this.emit("userDisconnected", [user, tournament!]);
-  };
-
-  private matchCreated = (tournamentId: string, match: Match) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.matches = [...tournament!.matches, match];
-    this.emit("matchCreated", [match, tournament!]);
-  };
-
-  private matchUpdated = (tournamentId: string, match: 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!]);
-  };
-
-  private matchDeleted = (tournamentId: string, match: Match) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.matches = tournament!.matches.filter(
-      (x) => x.guid !== match.guid
-    );
-    this.emit("matchDeleted", [match, tournament!]);
-  };
-
-  private qualifierEventCreated = (
-    tournamentId: string,
-    event: QualifierEvent
-  ) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.qualifiers = [...tournament!.qualifiers, event];
-    this.emit("qualifierCreated", [event, tournament!]);
-  };
-
-  private qualifierEventUpdated = (
-    tournamentId: string,
-    event: QualifierEvent
-  ) => {
-    const tournament = this.getTournament(tournamentId);
-    const index = tournament!.qualifiers.findIndex(
-      (x) => x.guid === event.guid
-    );
-    tournament!.qualifiers[index] = event;
-    this.emit("qualifierUpdated", [event, tournament!]);
-  };
-
-  private qualifierEventDeleted = (
-    tournamentId: string,
-    event: QualifierEvent
-  ) => {
-    const tournament = this.getTournament(tournamentId);
-    tournament!.qualifiers = tournament!.qualifiers.filter(
-      (x) => x.guid !== event.guid
-    );
-    this.emit("qualifierDeleted", [event, tournament!]);
-  };
-
-  private tournamentCreated = (tournament: Tournament) => {
-    this.state.tournaments = [...this.state.tournaments, tournament];
-    this.emit("tournamentCreated", tournament);
-  };
-
-  private tournamentUpdated = (tournament: Tournament) => {
-    const index = this.state.tournaments.findIndex(
-      (x) => x.guid === tournament.guid
-    );
-    this.state.tournaments[index] = tournament;
-    this.emit("tournamentUpdated", tournament);
-  };
-
-  private tournamentDeleted = (tournament: Tournament) => {
-    this.state.tournaments = this.state.tournaments.filter(
-      (x) => x.guid !== tournament.guid
-    );
-    this.emit("tournamentDeleted", tournament);
-  };
-
-  private serverAdded = (server: CoreServer) => {
-    this.state.knownServers = [...this.state.knownServers, server];
-    this.emit("serverAdded", server);
-  };
-
-  private serverDeleted = (server: CoreServer) => {
-    this.state.knownServers = this.state.knownServers.filter(
-      (x) => `${server.address}:${server.port}` !== `${x.address}:${x.port}`
-    );
-    this.emit("serverDeleted", server);
-  };
-}