@hyperneutrino/djs-lite 1.0.0 → 1.0.2

package/index.ts

@@ -1,5 +1,6 @@
 import {
     ApplicationCommandType,
+    AutocompleteInteraction,
     Client,
     CommandInteraction,
     Events,
@@ -7,6 +8,7 @@ import {
     type BaseApplicationCommandData,
     type ChatInputApplicationCommandData,
     type ChatInputCommandInteraction,
+    type ClientEvents,
     type MessageApplicationCommandData,
     type MessageContextMenuCommandInteraction,
     type UserApplicationCommandData,
@@ -17,22 +19,41 @@ import path from "node:path";
 
 process.on("uncaughtException", (err) => console.error(err));
 
-type Handler<T extends CommandInteraction> = (interaction: T) => Awaitable<unknown>;
+type Handler<T extends CommandInteraction | AutocompleteInteraction> = (interaction: T) => Awaitable<unknown>;
 
-class Command<T extends BaseApplicationCommandData, U extends CommandInteraction> {
+class Command<T extends BaseApplicationCommandData, U extends CommandInteraction, Z extends boolean = false> {
     data: T;
     handler: Handler<U>;
+    autocomplete: Handler<AutocompleteInteraction> | null;
+
+    constructor({ handler, ...data }: T & { handler: Handler<U> } & (Z extends true ? { autocomplete?: Handler<AutocompleteInteraction> } : {})) {
+        if ("autocomplete" in data) {
+            const { autocomplete, ...rest } = data;
+            this.autocomplete = autocomplete as Handler<AutocompleteInteraction>;
+            this.data = rest as unknown as T;
+        } else {
+            this.autocomplete = null;
+            this.data = data as unknown as T;
+        }
 
-    constructor({ handler, ...data }: T & { handler: Handler<U> }) {
-        this.data = data as unknown as T;
         this.handler = handler;
     }
 }
 
-export class SlashCommand extends Command<ChatInputApplicationCommandData & { type: ApplicationCommandType.ChatInput }, ChatInputCommandInteraction> {}
+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 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) {
     const files = await fs.readdir(path.resolve(directory), { recursive: false, withFileTypes: true });
 
@@ -42,6 +63,8 @@ export async function loadCommands(client: Client<true>, directory: string) {
     const userCommandHandlers = new Map<string, Handler<UserContextMenuCommandInteraction>>();
     const messageCommandHandlers = new Map<string, Handler<MessageContextMenuCommandInteraction>>();
 
+    const slashCommandAutocompletes = new Map<string, Handler<AutocompleteInteraction>>();
+
     await Promise.all(
         files.map(async (file) => {
             const { default: item } = await import(path.resolve(file.parentPath, file.name));
@@ -49,6 +72,7 @@ export async function loadCommands(client: Client<true>, directory: string) {
             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);
@@ -67,6 +91,7 @@ export async function loadCommands(client: Client<true>, directory: string) {
         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);
     });
 }
 
@@ -97,3 +122,18 @@ export async function loadInteractions(client: Client<true>, directory: string,
         handlers.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 { default: item } = await import(path.resolve(file.parentPath, file.name));
+            if (item instanceof EventHandler) (handlers[item.event as keyof ClientEvents] ??= []).push(item.handler);
+        }),
+    );
+
+    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.0",
+    "version": "1.0.2",
     "module": "index.ts",
     "type": "module",
     "devDependencies": {