@hyperneutrino/djs-lite 1.5.0 → 1.6.0

package/index.ts

@@ -31,6 +31,10 @@ import path from "node:path";
 
 process.on("uncaughtException", (err) => console.error(err));
 
+const identity = <T>(value: T): T => value;
+
+type Wrapper<T extends Function> = (fn: T) => T;
+
 type Handler<T extends CommandInteraction | AutocompleteInteraction | MessageComponentInteraction | ModalSubmitInteraction> = (
     interaction: T,
     ...args: T extends MessageComponentInteraction | ModalSubmitInteraction ? (string | undefined)[] : []
@@ -95,11 +99,11 @@ abstract class ComponentHandler<T extends ModalSubmitInteraction | MessageCompon
 
 export class ModalHandler extends ComponentHandler<ModalSubmitInteraction> {}
 export class ButtonHandler extends ComponentHandler<ButtonInteraction> {}
-export class StringSelectHandler extends ComponentHandler<StringSelectMenuInteraction> {}
-export class UserSelectHandler extends ComponentHandler<UserSelectMenuInteraction> {}
-export class RoleSelectHandler extends ComponentHandler<RoleSelectMenuInteraction> {}
-export class MentionSelectHandler extends ComponentHandler<MentionableSelectMenuInteraction> {}
-export class ChannelSelectHandler extends ComponentHandler<ChannelSelectMenuInteraction> {}
+export class StringSelectMenuHandler extends ComponentHandler<StringSelectMenuInteraction> {}
+export class UserSelectMenuHandler extends ComponentHandler<UserSelectMenuInteraction> {}
+export class RoleSelectMenuHandler extends ComponentHandler<RoleSelectMenuInteraction> {}
+export class MentionableSelectMenuHandler extends ComponentHandler<MentionableSelectMenuInteraction> {}
+export class ChannelSelectMenuHandler extends ComponentHandler<ChannelSelectMenuInteraction> {}
 
 export class EventHandler<T extends keyof ClientEvents> {
     event: T;
@@ -120,6 +124,7 @@ async function importAll(
     await Promise.all(
         files.map(async (file) => {
             if (file.isDirectory()) return;
+            if (file.name.startsWith(".")) return;
 
             const absolutePath = path.resolve(file.parentPath, file.name);
             const relativePath = path.join(directory, path.relative(path.resolve(directory), absolutePath));
@@ -185,7 +190,19 @@ async function loadSubcommandsAndGroups(directory: string): Promise<{
     };
 }
 
-export async function loadCommands(client: Client<true>, directory: string, guildId?: string) {
+export async function loadCommands(
+    client: Client<true>,
+    directory: string,
+    config?: {
+        guildId?: string;
+        wrappers?: {
+            slashCommands?: Wrapper<Handler<ChatInputCommandInteraction>>;
+            userCommands?: Wrapper<Handler<UserContextMenuCommandInteraction>>;
+            messageCommands?: Wrapper<Handler<MessageContextMenuCommandInteraction>>;
+            autocompletes?: Wrapper<Handler<AutocompleteInteraction>>;
+        };
+    },
+) {
     const commandData: (ChatInputApplicationCommandData | UserApplicationCommandData | MessageApplicationCommandData)[] = [];
 
     const slashCommandHandlers = new Map<string, Handler<ChatInputCommandInteraction>>();
@@ -197,18 +214,18 @@ export async function loadCommands(client: Client<true>, directory: string, guil
     await importAll({ directory, recursive: false }, async ({ file, absolutePath, relativePath, item }) => {
         if (item instanceof SlashCommand) {
             commandData.push({ ...item.data, type: ApplicationCommandType.ChatInput });
-            slashCommandHandlers.set(item.data.name, item.handler);
-            if (item.autocomplete) slashCommandAutocompletes.set(item.data.name, item.autocomplete);
+            slashCommandHandlers.set(item.data.name, (config?.wrappers?.slashCommands ?? identity)(item.handler));
+            if (item.autocomplete) slashCommandAutocompletes.set(item.data.name, (config?.wrappers?.autocompletes ?? identity)(item.autocomplete));
         } else if (item instanceof UserCommand) {
             commandData.push({ ...item.data, type: ApplicationCommandType.User });
-            userCommandHandlers.set(item.data.name, item.handler);
+            userCommandHandlers.set(item.data.name, (config?.wrappers?.userCommands ?? identity)(item.handler));
         } else if (item instanceof MessageCommand) {
             commandData.push({ ...item.data, type: ApplicationCommandType.Message });
-            messageCommandHandlers.set(item.data.name, item.handler);
+            messageCommandHandlers.set(item.data.name, (config?.wrappers?.messageCommands ?? identity)(item.handler));
         } else if (item instanceof SlashCommandWithSubcommands) {
             const { options, handler } = await loadSubcommandsAndGroups(relativePath.replace(/\.[^/.]+$/, ""));
             commandData.push({ ...item.data, options });
-            slashCommandHandlers.set(item.data.name, handler);
+            slashCommandHandlers.set(item.data.name, (config?.wrappers?.slashCommands ?? identity)(handler));
         } else {
             throw new Error(`Loading commands failed: export from ${absolutePath} was not an instance of <Type>Command.`);
         }
@@ -234,10 +251,12 @@ export async function loadCommands(client: Client<true>, directory: string, guil
         await fs.mkdir(".cache", { recursive: true }).catch(() => null);
         await fs.writeFile(".cache/command-data.json", JSON.stringify(commandData)).catch(() => null);
 
-        if (guildId) {
-            const testGuild = client.guilds.resolve(guildId);
+        if (config?.guildId) {
+            const testGuild = client.guilds.resolve(config.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.`);
+                throw new Error(
+                    `Provided test guild (${config.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);
@@ -247,14 +266,29 @@ export async function loadCommands(client: Client<true>, directory: string, guil
     return { commands: commandData, slashCommandHandlers, userCommandHandlers, messageCommandHandlers, setCommands: commandDataHasBeenUpdated };
 }
 
-export async function loadInteractions(client: Client, directory: string, argumentSeparator: string = ":") {
+export async function loadInteractions(
+    client: Client,
+    directory: string,
+    config?: {
+        argumentSeparator?: string;
+        wrappers?: {
+            modal?: Wrapper<Handler<ModalSubmitInteraction>>;
+            button?: Wrapper<Handler<ButtonInteraction>>;
+            stringSelectMenu?: Wrapper<Handler<StringSelectMenuInteraction>>;
+            userSelectMenu?: Wrapper<Handler<UserSelectMenuInteraction>>;
+            roleSelectMenu?: Wrapper<Handler<RoleSelectMenuInteraction>>;
+            mentionableSelectMenu?: Wrapper<Handler<MentionableSelectMenuInteraction>>;
+            channelSelectMenu?: Wrapper<Handler<ChannelSelectMenuInteraction>>;
+        };
+    },
+) {
     const modalHandlers = new Map<string, Handler<ModalSubmitInteraction>>();
     const buttonHandlers = new Map<string, Handler<ButtonInteraction>>();
-    const stringSelectHandlers = new Map<string, Handler<StringSelectMenuInteraction>>();
-    const userSelectHandlers = new Map<string, Handler<UserSelectMenuInteraction>>();
-    const roleSelectHandlers = new Map<string, Handler<RoleSelectMenuInteraction>>();
-    const mentionSelectHandlers = new Map<string, Handler<MentionableSelectMenuInteraction>>();
-    const channelSelectHandlers = new Map<string, Handler<ChannelSelectMenuInteraction>>();
+    const stringSelectMenuHandlers = new Map<string, Handler<StringSelectMenuInteraction>>();
+    const userSelectMenuHandlers = new Map<string, Handler<UserSelectMenuInteraction>>();
+    const roleSelectMenuHandlers = new Map<string, Handler<RoleSelectMenuInteraction>>();
+    const mentionableSelectMenuHandlers = new Map<string, Handler<MentionableSelectMenuInteraction>>();
+    const channelSelectMenuHandlers = new Map<string, Handler<ChannelSelectMenuInteraction>>();
 
     await importAll({ directory, recursive: true }, async ({ absolutePath, item }) => {
         const handlerKey = path
@@ -262,32 +296,43 @@ export async function loadInteractions(client: Client, directory: string, argume
             .replace(/\.[^/.]+$/, "")
             .replace(/\\/g, "/");
 
-        if (item instanceof ModalHandler) modalHandlers.set(handlerKey, item.handler);
-        else if (item instanceof ButtonHandler) buttonHandlers.set(handlerKey, item.handler);
-        else if (item instanceof StringSelectHandler) stringSelectHandlers.set(handlerKey, item.handler);
-        else if (item instanceof UserSelectHandler) userSelectHandlers.set(handlerKey, item.handler);
-        else if (item instanceof RoleSelectHandler) roleSelectHandlers.set(handlerKey, item.handler);
-        else if (item instanceof MentionSelectHandler) mentionSelectHandlers.set(handlerKey, item.handler);
-        else if (item instanceof ChannelSelectHandler) channelSelectHandlers.set(handlerKey, item.handler);
+        if (item instanceof ModalHandler) modalHandlers.set(handlerKey, (config?.wrappers?.modal ?? identity)(item.handler));
+        else if (item instanceof ButtonHandler) buttonHandlers.set(handlerKey, (config?.wrappers?.button ?? identity)(item.handler));
+        else if (item instanceof StringSelectMenuHandler)
+            stringSelectMenuHandlers.set(handlerKey, (config?.wrappers?.stringSelectMenu ?? identity)(item.handler));
+        else if (item instanceof UserSelectMenuHandler) userSelectMenuHandlers.set(handlerKey, (config?.wrappers?.userSelectMenu ?? identity)(item.handler));
+        else if (item instanceof RoleSelectMenuHandler) roleSelectMenuHandlers.set(handlerKey, (config?.wrappers?.roleSelectMenu ?? identity)(item.handler));
+        else if (item instanceof MentionableSelectMenuHandler)
+            mentionableSelectMenuHandlers.set(handlerKey, (config?.wrappers?.mentionableSelectMenu ?? identity)(item.handler));
+        else if (item instanceof ChannelSelectMenuHandler)
+            channelSelectMenuHandlers.set(handlerKey, (config?.wrappers?.channelSelectMenu ?? identity)(item.handler));
         else throw new Error(`Loading interactions failed: export from ${absolutePath} was not an instance of <InteractionType>Handler.`);
     });
 
     client.on(Events.InteractionCreate, (interaction) => {
         if (!interaction.isMessageComponent() && !interaction.isModalSubmit()) return;
 
-        const [, userId, path, ...args] = interaction.customId.split(argumentSeparator);
+        const [, userId, path, ...args] = interaction.customId.split(config?.argumentSeparator ?? ":");
         if (!path || (userId && interaction.user.id !== userId)) return;
 
         if (interaction.isModalSubmit()) modalHandlers.get(path)?.(interaction, ...args);
         else if (interaction.isButton()) buttonHandlers.get(path)?.(interaction, ...args);
-        else if (interaction.isStringSelectMenu()) stringSelectHandlers.get(path)?.(interaction, ...args);
-        else if (interaction.isUserSelectMenu()) userSelectHandlers.get(path)?.(interaction, ...args);
-        else if (interaction.isRoleSelectMenu()) roleSelectHandlers.get(path)?.(interaction, ...args);
-        else if (interaction.isMentionableSelectMenu()) mentionSelectHandlers.get(path)?.(interaction, ...args);
-        else if (interaction.isChannelSelectMenu()) channelSelectHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isStringSelectMenu()) stringSelectMenuHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isUserSelectMenu()) userSelectMenuHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isRoleSelectMenu()) roleSelectMenuHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isMentionableSelectMenu()) mentionableSelectMenuHandlers.get(path)?.(interaction, ...args);
+        else if (interaction.isChannelSelectMenu()) channelSelectMenuHandlers.get(path)?.(interaction, ...args);
     });
 
-    return { modalHandlers, buttonHandlers, stringSelectHandlers, userSelectHandlers, roleSelectHandlers, mentionSelectHandlers, channelSelectHandlers };
+    return {
+        modalHandlers,
+        buttonHandlers,
+        stringSelectHandlers: stringSelectMenuHandlers,
+        userSelectHandlers: userSelectMenuHandlers,
+        roleSelectHandlers: roleSelectMenuHandlers,
+        mentionSelectHandlers: mentionableSelectMenuHandlers,
+        channelSelectHandlers: channelSelectMenuHandlers,
+    };
 }
 
 export async function loadEvents(client: Client, directory: string, recursive: boolean = false) {

package/package.json

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