@hyperneutrino/djs-lite 1.0.1 → 1.1.0

package/bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "bot-framework",

package/index.ts

@@ -1,13 +1,22 @@
 import {
     ApplicationCommandType,
     AutocompleteInteraction,
+    ButtonInteraction,
+    ChannelSelectMenuInteraction,
     Client,
     CommandInteraction,
     Events,
+    MentionableSelectMenuInteraction,
+    MessageComponentInteraction,
+    ModalSubmitInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+    UserSelectMenuInteraction,
     type Awaitable,
     type BaseApplicationCommandData,
     type ChatInputApplicationCommandData,
     type ChatInputCommandInteraction,
+    type ClientEvents,
     type MessageApplicationCommandData,
     type MessageContextMenuCommandInteraction,
     type UserApplicationCommandData,
@@ -16,11 +25,16 @@ import {
 import fs from "node:fs/promises";
 import path from "node:path";
 
+// TODO: comments (requires some refactoring of types to do right)
+
 process.on("uncaughtException", (err) => console.error(err));
 
-type Handler<T extends CommandInteraction | AutocompleteInteraction> = (interaction: T) => Awaitable<unknown>;
+type Handler<T extends CommandInteraction | AutocompleteInteraction | MessageComponentInteraction | ModalSubmitInteraction> = (
+    interaction: T,
+    ...args: any[]
+) => Awaitable<unknown>;
 
-class Command<T extends BaseApplicationCommandData, U extends CommandInteraction, Z extends boolean = false> {
+abstract class Command<T extends BaseApplicationCommandData, U extends CommandInteraction, Z extends boolean = false> {
     data: T;
     handler: Handler<U>;
     autocomplete: Handler<AutocompleteInteraction> | null;
@@ -43,7 +57,33 @@ export class SlashCommand extends Command<ChatInputApplicationCommandData & { ty
 export class UserCommand extends Command<UserApplicationCommandData, UserContextMenuCommandInteraction> {}
 export class MessageCommand extends Command<MessageApplicationCommandData, MessageContextMenuCommandInteraction> {}
 
-export async function loadCommands(client: Client<true>, directory: string) {
+abstract class ComponentResponder<T extends ModalSubmitInteraction | MessageComponentInteraction> {
+    handler: Handler<T>;
+
+    constructor(handler: Handler<T>) {
+        this.handler = handler;
+    }
+}
+
+export class ModalResponder extends ComponentResponder<ModalSubmitInteraction> {}
+export class ButtonResponder extends ComponentResponder<ButtonInteraction> {}
+export class StringSelectResponder extends ComponentResponder<StringSelectMenuInteraction> {}
+export class UserSelectResponder extends ComponentResponder<UserSelectMenuInteraction> {}
+export class RoleSelectResponder extends ComponentResponder<RoleSelectMenuInteraction> {}
+export class MentionSelectResponder extends ComponentResponder<MentionableSelectMenuInteraction> {}
+export class ChannelSelectResponder extends ComponentResponder<ChannelSelectMenuInteraction> {}
+
+export class EventHandler<T extends keyof ClientEvents> {
+    event: T;
+    handler: (...args: ClientEvents[T]) => unknown;
+
+    constructor({ event, handler }: { event: T; handler: (...args: ClientEvents[T]) => unknown }) {
+        this.event = event;
+        this.handler = handler;
+    }
+}
+
+export async function loadCommands(client: Client<true>, directory: string, guildId?: string) {
     const files = await fs.readdir(path.resolve(directory), { recursive: false, withFileTypes: true });
 
     const commandData: (ChatInputApplicationCommandData | UserApplicationCommandData | MessageApplicationCommandData)[] = [];
@@ -56,37 +96,54 @@ export async function loadCommands(client: Client<true>, directory: string) {
 
     await Promise.all(
         files.map(async (file) => {
-            const { default: item } = await import(path.resolve(file.parentPath, file.name));
+            const absolutePath = path.resolve(file.parentPath, file.name);
+
+            const { default: item } = await import(absolutePath);
 
             if (item instanceof SlashCommand) {
-                commandData.push(item.data);
                 slashCommandHandlers.set(item.data.name, item.handler);
                 if (item.autocomplete) slashCommandAutocompletes.set(item.data.name, item.autocomplete);
             } else if (item instanceof UserCommand) {
-                commandData.push(item.data);
                 userCommandHandlers.set(item.data.name, item.handler);
             } else if (item instanceof MessageCommand) {
-                commandData.push(item.data);
                 messageCommandHandlers.set(item.data.name, item.handler);
             } else {
-                console.warn(`WARN Command loader did not recognize the export from ${file.name} as a command.`);
+                throw new Error(
+                    `Loading commands failed: export from ${path.relative(path.resolve(directory), absolutePath)} was not an instance of <Type>Command.`,
+                );
             }
+
+            commandData.push(item.data);
         }),
     );
 
-    await client.application.commands.set(commandData);
-
     client.on(Events.InteractionCreate, (interaction) => {
         if (interaction.isChatInputCommand()) slashCommandHandlers.get(interaction.commandName)?.(interaction);
         else if (interaction.isUserContextMenuCommand()) userCommandHandlers.get(interaction.commandName)?.(interaction);
         else if (interaction.isMessageContextMenuCommand()) messageCommandHandlers.get(interaction.commandName)?.(interaction);
         else if (interaction.isAutocomplete()) slashCommandAutocompletes.get(interaction.commandName)?.(interaction);
     });
+
+    if (guildId) {
+        const testGuild = client.guilds.resolve(guildId);
+        if (!testGuild)
+            throw new Error(`Provided test guild (${guildId}) can not be found, please make sure the bot you started this project on is in this guild.`);
+        await testGuild.commands.set(commandData);
+    } else {
+        await client.application.commands.set(commandData);
+    }
 }
 
 export async function loadInteractions(client: Client<true>, directory: string, argumentSeparator: string = ":") {
     const files = await fs.readdir(path.resolve(directory), { recursive: true, withFileTypes: true });
-    const handlers = new Map<string, Function>();
+
+    const modalHandlers = new Map<string, Handler<ModalSubmitInteraction>>();
+    const buttonHandlers = new Map<string, Handler<ButtonInteraction>>();
+    const stringHandlers = new Map<string, Handler<StringSelectMenuInteraction>>();
+    const userHandlers = new Map<string, Handler<UserSelectMenuInteraction>>();
+    const roleHandlers = new Map<string, Handler<RoleSelectMenuInteraction>>();
+    const mentionHandlers = new Map<string, Handler<MentionableSelectMenuInteraction>>();
+    const channelHandlers = new Map<string, Handler<ChannelSelectMenuInteraction>>();
 
     await Promise.all(
         files.map(async (file) => {
@@ -94,11 +151,18 @@ export async function loadInteractions(client: Client<true>, directory: string,
 
             const absolutePath = path.resolve(file.parentPath, file.name);
             const relativePath = path.relative(path.resolve(directory), absolutePath);
-
-            const { default: handler } = await import(absolutePath).catch(() => null);
-            if (typeof handler !== "function") return console.warn(`WARN Command loader did not recognize the export from ${relativePath} as a command.`);
-
-            handlers.set(relativePath.replace(/\.[^/.]+$/, ""), handler);
+            const handlerKey = relativePath.replace(/\.[^/.]+$/, "");
+
+            const { default: item } = await import(absolutePath).catch(() => null);
+
+            if (item instanceof ModalResponder) modalHandlers.set(handlerKey, item.handler);
+            else if (item instanceof ButtonResponder) buttonHandlers.set(handlerKey, item.handler);
+            else if (item instanceof StringSelectResponder) stringHandlers.set(handlerKey, item.handler);
+            else if (item instanceof UserSelectResponder) userHandlers.set(handlerKey, item.handler);
+            else if (item instanceof RoleSelectResponder) roleHandlers.set(handlerKey, item.handler);
+            else if (item instanceof MentionSelectResponder) mentionHandlers.set(handlerKey, item.handler);
+            else if (item instanceof ChannelSelectResponder) channelHandlers.set(handlerKey, item.handler);
+            else throw new Error(`Loading interactions failed: export from ${relativePath} was not an instance of <InteractionType>Responder.`);
         }),
     );
 
@@ -108,6 +172,36 @@ export async function loadInteractions(client: Client<true>, directory: string,
         const [, userId, path, ...args] = interaction.customId.split(argumentSeparator);
         if (!path || (userId && interaction.user.id !== userId)) return;
 
-        handlers.get(path)?.(interaction, ...args);
+        if (interaction.isModalSubmit()) modalHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isButton()) buttonHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isStringSelectMenu()) stringHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isUserSelectMenu()) userHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isRoleSelectMenu()) roleHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isMentionableSelectMenu()) mentionHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isChannelSelectMenu()) channelHandlers.get(path)?.(interaction, ...args);
     });
 }
+
+export async function loadEvents(client: Client<true>, directory: string, recursive: boolean = false) {
+    const files = await fs.readdir(path.resolve(directory), { recursive, withFileTypes: true });
+    const handlers: Partial<{ [K in keyof ClientEvents]: ((...args: ClientEvents[K]) => unknown)[] }> = {};
+
+    await Promise.all(
+        files.map(async (file) => {
+            if (file.isDirectory()) return;
+
+            const absolutePath = path.resolve(file.parentPath, file.name);
+
+            const { default: item } = await import(absolutePath);
+
+            if (item instanceof EventHandler) (handlers[item.event as keyof ClientEvents] ??= []).push(item.handler);
+            else {
+                throw new Error(
+                    `Loading events failed: export from ${path.relative(path.resolve(directory), absolutePath)} was not an instance of EventHandler<T>.`,
+                );
+            }
+        }),
+    );
+
+    Object.entries(handlers).forEach(([key, handlers]) => client.on(key, (...args) => handlers.forEach((handler) => (handler as any)(...args))));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@hyperneutrino/djs-lite",
     "private": false,
-    "version": "1.0.1",
+    "version": "1.1.0",
     "module": "index.ts",
     "type": "module",
     "devDependencies": {