@hyperneutrino/djs-lite 1.4.0 → 1.4.2

package/index.ts

@@ -29,8 +29,6 @@ import type { Dirent } from "node:fs";
 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 | MessageComponentInteraction | ModalSubmitInteraction> = (
@@ -124,7 +122,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);
 
@@ -133,7 +131,7 @@ async function importAll(
     );
 }
 
-export async function loadSubcommands(directory: string): Promise<{
+async function loadSubcommands(directory: string): Promise<{
     options: ApplicationCommandSubCommandData[];
     handlers: Map<string, Handler<ChatInputCommandInteraction>>;
 }> {
@@ -155,11 +153,11 @@ export async function loadSubcommands(directory: string): Promise<{
     return { options, handlers };
 }
 
-export async function loadSubcommandsAndGroups(directory: string): Promise<{
+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>>();
@@ -188,8 +186,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>>();
@@ -198,37 +194,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) {
-                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.data.name !== file.name.replace(/.[^/.]+$/, ""))
-                throw new Error(`Code style enforcement: name exported from ${relativePath} does not match the filename`);
-        }),
-    );
+        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);
@@ -248,8 +235,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>>();
@@ -258,26 +243,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 ({ 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;
@@ -296,25 +273,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.4.0",
+    "version": "1.4.2",
     "module": "index.ts",
     "type": "module",
     "devDependencies": {