ROBLOX Module

export interface Settings {
  /**
   * The token for the module.
   */
  TOKEN: string;
  /**
   * The flags for the module.
   */
  Flags: string[];
}

/**
 * @class SkyTeamModule
 * @author h1ddenscript
 * @description This module is used to setup the SkyTeam system within a SkyTeam Alliance Members' game.
 */
export default class {
  private Settings: Settings;
  public API: string = "http://localhost:4000";
  public RemoteEvent: RemoteEvent = new Instance("RemoteEvent");
  public Slocked: boolean = false;
  public InitalizationError: string | undefined;

  constructor(Settings: Settings) {
    script.Parent = ReplicatedStorage;
    this.Settings = Settings;
  }

  /**
   * @method Initialize
   * @description Hot method is used to initialize the module.
   */
  public Initialize(): void {
    this.RemoteEvent.Name = ".SKYTEAM_CLIENT_RUNTIME";
    this.RemoteEvent.Parent = ReplicatedStorage;

    // Clone client script to existing players
    for (const Player of Players.GetPlayers()) {
      const ClientScript = script.WaitForChild("client").Clone();
      ClientScript.Parent = Player.WaitForChild("PlayerGui");
    }

    // Handle new players joining
    Players.PlayerAdded.Connect((Player) => {
      const ClientScript = script.WaitForChild("client").Clone();
      ClientScript.Parent = Player.WaitForChild("PlayerGui");

      if (this.InitalizationError) {
        this.PublicError("SERVER_INIT_ERROR", {
          Body: this.InitalizationError,
        });
      }
    });

    // Test API connectivity
    this.TestServices().catch((err) => {
      warn(err);
      this.InitalizationError = err;
      this.PublicError("SERVER_INIT_ERROR", {
        Body: `SkyTeam module failed to initialize. Please contact a developer. Error: ${err}`,
      });
    });
  }

  private async TestServices(): Promise<any> {
    return new Promise(async (resolve, reject) => {
      const [success, result] = pcall(() => {
        HttpService.GetAsync("https://example.com/");
      });

      if (!success) {
        reject(result);
        return;
      }

      resolve(result);
    });
  }

  private async PublicError<T extends EventTypeKeys>(
    WhichEvent: T,
    args: EventTypes[T],
  ) {
    this.RemoteEvent.FireAllClients(WhichEvent, args);
  }
}

import SkyTeamModule from "module";

const SkyTeam = new SkyTeamModule({
  TOKEN: "YAY",
  Flags: ["flag1", "flag2"],
}).Initialize();

import Roact from "@rbxts/roact";
import { Players, ReplicatedStorage } from "@rbxts/services";
import ErrorMessage from "./ErrorMessage";
import type { EventTypeKeys, EventTypes } from "../shared/CommunicationTypes";

const ClientCommunication = ReplicatedStorage.WaitForChild(
  ".SKYTEAM_CLIENT_RUNTIME",
) as RemoteEvent;
const Player = Players.LocalPlayer;

wait(0.5);

/**
 * This is a really hacky way to mount it w/o serverside replication
 * I'm just scared of weird scripts ppl might use that could break it
 * if we just left it in playergui
 */
if (script.Parent?.IsA("PlayerGui")) {
  script.Clone().Parent = Player.WaitForChild("PlayerScripts");
} else {
  script.Parent = undefined;

  ClientCommunication.OnClientEvent.Connect(
    (eventType: EventTypeKeys, rawargs: unknown) => {
      switch (eventType) {
        case "SERVER_INIT_ERROR": {
          const args = rawargs as EventTypes["SERVER_INIT_ERROR"];

          Roact.mount(
            <ErrorMessage
              BackgroundColor={Color3.fromRGB(255, 149, 0)}
              ElementColor={Color3.fromRGB(71, 41, 0)}
              Title="Service Initialization Error"
              Body={args.Body}
            />,
            Player.WaitForChild("PlayerGui"),
          );
          break;
        }
      }
    },
  );
}

// Define interfaces for each event type's arguments
export interface ServerInitErrorArgs {
  Body: string;
}

export interface UnknownArgs {
  // Add any properties for UNKNOWN event type if needed
}

// Map event types to their respective argument types
export interface EventTypes {
  SERVER_INIT_ERROR: ServerInitErrorArgs;
  UNKNOWN: UnknownArgs;
}

// Keys
export type EventTypeKeys = keyof EventTypes;