@hyperneutrino/djs-lite 1.3.0 → 1.4.1

package/index.ts

@@ -1,4 +1,5 @@
 import {
+    ApplicationCommandOptionType,
     ApplicationCommandType,
     AutocompleteInteraction,
     ButtonInteraction,
@@ -56,12 +57,12 @@ abstract class Command<T extends BaseApplicationCommandData, U extends CommandIn
     }
 }
 
-export class SlashCommand extends Command<ChatInputApplicationCommandData & { type: ApplicationCommandType.ChatInput }, ChatInputCommandInteraction, true> {}
-export class UserCommand extends Command<UserApplicationCommandData, UserContextMenuCommandInteraction> {}
-export class MessageCommand extends Command<MessageApplicationCommandData, MessageContextMenuCommandInteraction> {}
+export class SlashCommand extends Command<Omit<ChatInputApplicationCommandData, "type">, ChatInputCommandInteraction, true> {}
+export class UserCommand extends Command<Omit<UserApplicationCommandData, "type">, UserContextMenuCommandInteraction> {}
+export class MessageCommand extends Command<Omit<MessageApplicationCommandData, "type">, MessageContextMenuCommandInteraction> {}
 
 export class SlashCommandWithSubcommands {
-    data: Omit<ChatInputApplicationCommandData, "options"> & { type: ApplicationCommandType.ChatInput };
+    data: Omit<ChatInputApplicationCommandData, "options" | "type">;
 
     constructor(data: typeof this.data) {
         this.data = data;
@@ -69,7 +70,7 @@ export class SlashCommandWithSubcommands {
 }
 
 export class SubcommandGroup {
-    data: Omit<ApplicationCommandSubGroupData, "options">;
+    data: Omit<ApplicationCommandSubGroupData, "options" | "type">;
 
     constructor(data: typeof this.data) {
         this.data = data;
@@ -77,7 +78,7 @@ export class SubcommandGroup {
 }
 
 export class Subcommand {
-    data: ApplicationCommandSubCommandData;
+    data: Omit<ApplicationCommandSubCommandData, "type">;
     handler: Handler<ChatInputCommandInteraction>;
 
     constructor({ handler, ...data }: typeof this.data & { handler: Subcommand["handler"] }) {
@@ -123,7 +124,7 @@ async function importAll(
             if (file.isDirectory()) return;
 
             const absolutePath = path.resolve(file.parentPath, file.name);
-            const relativePath = path.relative(path.resolve(directory), absolutePath);
+            const relativePath = path.join(directory, path.relative(path.resolve(directory), absolutePath));
 
             const { default: item } = await import(absolutePath);
 
@@ -143,7 +144,7 @@ export async function loadSubcommands(directory: string): Promise<{
 
     await importAll({ directory, recursive: false }, async ({ file, relativePath, item }) => {
         if (item instanceof Subcommand) {
-            options.push(item.data);
+            options.push({ ...item.data, type: ApplicationCommandOptionType.Subcommand });
             handlers.set(item.data.name, item.handler);
         } else throw new Error(`Loading commands failed: export from ${relativePath} (third-level in commands folder) was not an instance of Subcommand.`);
 
@@ -158,18 +159,18 @@ export async function loadSubcommandsAndGroups(directory: string): Promise<{
     options: (ApplicationCommandSubGroupData | ApplicationCommandSubCommandData)[];
     handler: Handler<ChatInputCommandInteraction>;
 }> {
-    if (!(await fs.exists(directory))) throw new Error(`Loading subcomands/groups failed: ${directory} is required but could not be found.`);
+    if (!(await fs.exists(directory))) throw new Error(`Loading subcommands/groups failed: ${directory} is required but could not be found.`);
 
     const options: (ApplicationCommandSubGroupData | ApplicationCommandSubCommandData)[] = [];
     const handlers = new Map<string, Handler<ChatInputCommandInteraction>>();
 
     await importAll({ directory, recursive: false }, async ({ file, relativePath, item }) => {
         if (item instanceof Subcommand) {
-            options.push(item.data);
+            options.push({ ...item.data, type: ApplicationCommandOptionType.Subcommand });
             handlers.set(`/${item.data.name}`, item.handler);
         } else if (item instanceof SubcommandGroup) {
             const subcommands = await loadSubcommands(relativePath.replace(/\.[^/.]+$/, ""));
-            options.push({ ...item.data, options: subcommands.options });
+            options.push({ ...item.data, type: ApplicationCommandOptionType.SubcommandGroup, options: subcommands.options });
             subcommands.handlers.entries().forEach(([key, handler]) => handlers.set(`${item.data.name}/${key}`, handler));
         } else
             throw new Error(
@@ -187,8 +188,6 @@ export async function loadSubcommandsAndGroups(directory: string): Promise<{
 }
 
 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)[] = [];
 
     const slashCommandHandlers = new Map<string, Handler<ChatInputCommandInteraction>>();
@@ -197,36 +196,28 @@ export async function loadCommands(client: Client<true>, directory: string, guil
 
     const slashCommandAutocompletes = new Map<string, Handler<AutocompleteInteraction>>();
 
-    await Promise.all(
-        files.map(async (file) => {
-            if (file.isDirectory()) return;
-
-            const absolutePath = path.resolve(file.parentPath, file.name);
-            const relativePath = path.relative(path.resolve(directory), absolutePath);
-
-            const { default: item } = await import(absolutePath);
+    await importAll({ directory, recursive: false }, async ({ file, 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);
+        } else if (item instanceof UserCommand) {
+            commandData.push({ ...item.data, type: ApplicationCommandType.User });
+            userCommandHandlers.set(item.data.name, item.handler);
+        } else if (item instanceof MessageCommand) {
+            commandData.push({ ...item.data, type: ApplicationCommandType.Message });
+            messageCommandHandlers.set(item.data.name, 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);
+        } else {
+            throw new Error(`Loading commands failed: export from ${relativePath} was not an instance of <Type>Command.`);
+        }
 
-            if (item instanceof SlashCommand) {
-                slashCommandHandlers.set(item.data.name, item.handler);
-                if (item.autocomplete) slashCommandAutocompletes.set(item.data.name, item.autocomplete);
-            } else if (item instanceof UserCommand) {
-                userCommandHandlers.set(item.data.name, item.handler);
-            } else if (item instanceof MessageCommand) {
-                messageCommandHandlers.set(item.data.name, 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);
-            } else {
-                throw new Error(`Loading commands failed: export from ${relativePath} was not an instance of <Type>Command.`);
-            }
-
-            if (item.data.name !== file.name.replace(/.[^/.]+$/, ""))
-                throw new Error(`Code style enforcement: name exported from ${relativePath} does not match the filename`);
-
-            commandData.push(item.data);
-        }),
-    );
+        if (item.data.name !== file.name.replace(/.[^/.]+$/, ""))
+            throw new Error(`Code style enforcement: name exported from ${relativePath} does not match the filename`);
+    });
 
     client.on(Events.InteractionCreate, (interaction) => {
         if (interaction.isChatInputCommand()) slashCommandHandlers.get(interaction.commandName)?.(interaction);
@@ -246,8 +237,6 @@ export async function loadCommands(client: Client<true>, directory: string, guil
 }
 
 export async function loadInteractions(client: Client, directory: string, argumentSeparator: string = ":") {
-    const files = await fs.readdir(path.resolve(directory), { recursive: true, withFileTypes: true });
-
     const modalHandlers = new Map<string, Handler<ModalSubmitInteraction>>();
     const buttonHandlers = new Map<string, Handler<ButtonInteraction>>();
     const stringHandlers = new Map<string, Handler<StringSelectMenuInteraction>>();
@@ -256,26 +245,18 @@ export async function loadInteractions(client: Client, directory: string, argume
     const mentionHandlers = new Map<string, Handler<MentionableSelectMenuInteraction>>();
     const channelHandlers = new Map<string, Handler<ChannelSelectMenuInteraction>>();
 
-    await Promise.all(
-        files.map(async (file) => {
-            if (file.isDirectory()) return;
-
-            const absolutePath = path.resolve(file.parentPath, file.name);
-            const relativePath = path.relative(path.resolve(directory), absolutePath);
-            const handlerKey = relativePath.replace(/\.[^/.]+$/, "").replace(/\\/g, "/");
-
-            const { default: item } = await import(absolutePath).catch(() => null);
-
-            if (item instanceof ModalHandler) modalHandlers.set(handlerKey, item.handler);
-            else if (item instanceof ButtonHandler) buttonHandlers.set(handlerKey, item.handler);
-            else if (item instanceof StringSelectHandler) stringHandlers.set(handlerKey, item.handler);
-            else if (item instanceof UserSelectHandler) userHandlers.set(handlerKey, item.handler);
-            else if (item instanceof RoleSelectHandler) roleHandlers.set(handlerKey, item.handler);
-            else if (item instanceof MentionSelectHandler) mentionHandlers.set(handlerKey, item.handler);
-            else if (item instanceof ChannelSelectHandler) channelHandlers.set(handlerKey, item.handler);
-            else throw new Error(`Loading interactions failed: export from ${relativePath} was not an instance of <InteractionType>Handler.`);
-        }),
-    );
+    await importAll({ directory, recursive: true }, async ({ file, relativePath, item }) => {
+        const handlerKey = relativePath.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) stringHandlers.set(handlerKey, item.handler);
+        else if (item instanceof UserSelectHandler) userHandlers.set(handlerKey, item.handler);
+        else if (item instanceof RoleSelectHandler) roleHandlers.set(handlerKey, item.handler);
+        else if (item instanceof MentionSelectHandler) mentionHandlers.set(handlerKey, item.handler);
+        else if (item instanceof ChannelSelectHandler) channelHandlers.set(handlerKey, item.handler);
+        else throw new Error(`Loading interactions failed: export from ${relativePath} was not an instance of <InteractionType>Handler.`);
+    });
 
     client.on(Events.InteractionCreate, (interaction) => {
         if (!interaction.isMessageComponent() && !interaction.isModalSubmit()) return;
@@ -294,25 +275,14 @@ export async function loadInteractions(client: Client, directory: string, argume
 }
 
 export async function loadEvents(client: Client, 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>.`,
-                );
-            }
-        }),
-    );
+    await importAll({ directory, recursive }, async ({ relativePath, item }) => {
+        if (item instanceof EventHandler) (handlers[item.event as keyof ClientEvents] ??= []).push(item.handler);
+        else {
+            throw new Error(`Loading events failed: export from ${relativePath} 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.3.0",
+    "version": "1.4.1",
     "module": "index.ts",
     "type": "module",
     "devDependencies": {