Events: Initial code

src/classes/client.ts

@@ -5,6 +5,7 @@ import { HolodexApiClient } from "holodex.js";
 
 import Logging from "./logging.js";
 import MeteoriumInteractionManager from "../interactions/index.js";
+import MeteoriumEventManager from "../events/index.js";
 
 function parseDotEnvConfig() {
     if (!process.env.METEORIUM_BOT_TOKEN) config();
@@ -23,6 +24,7 @@ export default class MeteoriumClient extends Client<true> {
     public config = parseDotEnvConfig();
     public db = new PrismaClient();
     public interactions = new MeteoriumInteractionManager(this);
+    public events = new MeteoriumEventManager(this);
     public holodex = new HolodexApiClient({ apiKey: this.config.HolodexApiKey });
 
     public async login() {

src/events/eventsEntry.ts

@@ -0,0 +1,12 @@
+import type { Awaitable, ClientEvents } from "discord.js";
+import type MeteoriumClient from "../classes/client.js";
+
+export * as ReadyInit from "./readyInit.js";
+export * as InteractionHandler from "./interactionHandler.js";
+export * as PresenceResumption from "./presenceResumption.js";
+
+export type MeteoriumEvent<EventName extends keyof ClientEvents> = {
+    event: EventName;
+    callback(client: MeteoriumClient, ...args: ClientEvents[EventName]): Awaitable<any>;
+    once: boolean;
+};

src/events/index.ts

@@ -0,0 +1,42 @@
+import { ClientEvents, Collection } from "discord.js";
+import type MeteoriumClient from "../classes/client.js";
+import type { LoggingNamespace } from "../classes/logging.js";
+
+import * as events from "./eventsEntry.js";
+
+export default class MeteoriumEventManager {
+    public events: Collection<string, events.MeteoriumEvent<any>>;
+    public client: MeteoriumClient;
+    public logging: LoggingNamespace;
+
+    public constructor(client: MeteoriumClient) {
+        this.events = new Collection();
+        this.client = client;
+        this.logging = client.logging.registerNamespace("EventManager");
+    }
+
+    public register() {
+        const regNS = this.logging.getNamespace("Registration");
+
+        regNS.info("Registering events");
+        for (const [Name, { Event }] of Object.entries(events)) {
+            regNS.verbose(`Registering -> ${Name}${Event.once ? " (Once)" : ""}`);
+            this.events.set(Name, Event);
+        }
+
+        return;
+    }
+
+    public hook() {
+        const hookNS = this.logging.registerNamespace("Hooking");
+
+        hookNS.info("Hooking events to client");
+        for (const [Name, Event] of this.events) {
+            hookNS.verbose(`Hooking -> ${Name}`);
+            if (Event.once) this.client.once(Event.event, Event.callback);
+            else this.client.on(Event.event, Event.callback);
+        }
+
+        return;
+    }
+}

src/events/interactionHandler.ts

@@ -0,0 +1,7 @@
+import type { MeteoriumEvent } from "./eventsEntry.js";
+
+export const Event: MeteoriumEvent<"interactionCreate"> = {
+    event: "interactionCreate",
+    async callback(client, interaction) {},
+    once: false,
+};

src/events/presenceResumption.ts

@@ -0,0 +1,7 @@
+import type { MeteoriumEvent } from "./eventsEntry.js";
+
+export const Event: MeteoriumEvent<"shardResume"> = {
+    event: "shardResume",
+    async callback(client) {},
+    once: false,
+};

src/events/readyInit.ts

@@ -0,0 +1,7 @@
+import type { MeteoriumEvent } from "./eventsEntry.js";
+
+export const Event: MeteoriumEvent<"ready"> = {
+    event: "ready",
+    async callback(client) {},
+    once: true,
+};