@minesa-org/mini-interaction 0.0.3 → 0.0.4

package/dist/clients/MiniInteraction.d.ts

@@ -8,6 +8,7 @@ export type MiniInteractionOptions = {
     applicationId: string;
     publicKey: string;
     commandsDirectory?: string | false;
+    componentsDirectory?: string | false;
     fetchImplementation?: typeof fetch;
     verifyKeyImplementation?: VerifyKeyFunction;
 };
@@ -58,14 +59,17 @@ export declare class MiniInteraction {
     private readonly fetchImpl;
     private readonly verifyKeyImpl;
     private readonly commandsDirectory;
+    private readonly componentsDirectory;
     private readonly commands;
     private readonly componentHandlers;
     private commandsLoaded;
     private loadCommandsPromise;
+    private componentsLoaded;
+    private loadComponentsPromise;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
     /**
      * Registers a single command handler with the client.
      *
@@ -90,6 +94,12 @@ export declare class MiniInteraction {
      * @param components - The component definitions to register.
      */
     useComponents(components: MiniInteractionComponent[]): this;
+    /**
+     * Recursively loads components from the configured components directory.
+     *
+     * @param directory - Optional directory override for component discovery.
+     */
+    loadComponentsFromDirectory(directory?: string): Promise<this>;
     /**
      * Recursively loads commands from the configured commands directory.
      *
@@ -143,19 +153,27 @@ export declare class MiniInteraction {
     /**
      * Recursively collects all command module file paths from the target directory.
      */
-    private collectCommandFiles;
+    private collectModuleFiles;
     /**
      * Determines whether the provided file path matches a supported command file extension.
      */
-    private isSupportedCommandFile;
+    private isSupportedModuleFile;
     /**
      * Dynamically imports and validates a command module from disk.
      */
     private importCommandModule;
+    /**
+     * Dynamically imports and validates a component module from disk.
+     */
+    private importComponentModule;
     /**
      * Normalises the request body into a UTF-8 string for signature validation and parsing.
      */
     private normalizeBody;
+    /**
+     * Ensures components have been loaded from disk once before being accessed.
+     */
+    private ensureComponentsLoaded;
     /**
      * Ensures commands have been loaded from disk once before being accessed.
      */

package/dist/clients/MiniInteraction.js

@@ -7,8 +7,8 @@ import { verifyKey } from "discord-interactions";
 import { DISCORD_BASE_URL } from "../utils/constants.js";
 import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
 import { createMessageComponentInteraction, } from "../utils/MessageComponentInteraction.js";
-/** File extensions that are treated as command modules when auto-loading. */
-const SUPPORTED_COMMAND_EXTENSIONS = new Set([
+/** File extensions that are treated as loadable modules when auto-loading. */
+const SUPPORTED_MODULE_EXTENSIONS = new Set([
     ".js",
     ".mjs",
     ".cjs",
@@ -26,14 +26,17 @@ export class MiniInteraction {
     fetchImpl;
     verifyKeyImpl;
     commandsDirectory;
+    componentsDirectory;
     commands = new Map();
     componentHandlers = new Map();
     commandsLoaded = false;
     loadCommandsPromise = null;
+    componentsLoaded = false;
+    loadComponentsPromise = null;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, fetchImplementation, verifyKeyImplementation, }) {
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }) {
         if (!applicationId) {
             throw new Error("[MiniInteraction] applicationId is required");
         }
@@ -53,6 +56,10 @@ export class MiniInteraction {
             commandsDirectory === false
                 ? null
                 : this.resolveCommandsDirectory(commandsDirectory);
+        this.componentsDirectory =
+            componentsDirectory === false
+                ? null
+                : this.resolveComponentsDirectory(componentsDirectory);
     }
     /**
      * Registers a single command handler with the client.
@@ -111,6 +118,42 @@ export class MiniInteraction {
         }
         return this;
     }
+    /**
+     * Recursively loads components from the configured components directory.
+     *
+     * @param directory - Optional directory override for component discovery.
+     */
+    async loadComponentsFromDirectory(directory) {
+        const targetDirectory = directory !== undefined
+            ? this.resolveComponentsDirectory(directory)
+            : this.componentsDirectory;
+        if (!targetDirectory) {
+            throw new Error("[MiniInteraction] Components directory support disabled. Provide a directory path.");
+        }
+        const exists = await this.pathExists(targetDirectory);
+        if (!exists) {
+            this.componentsLoaded = true;
+            console.warn(`[MiniInteraction] Components directory "${targetDirectory}" does not exist. Skipping component auto-load.`);
+            return this;
+        }
+        const files = await this.collectModuleFiles(targetDirectory);
+        if (files.length === 0) {
+            this.componentsLoaded = true;
+            console.warn(`[MiniInteraction] No component files found under "${targetDirectory}".`);
+            return this;
+        }
+        for (const file of files) {
+            const components = await this.importComponentModule(file);
+            if (components.length === 0) {
+                continue;
+            }
+            for (const component of components) {
+                this.useComponent(component);
+            }
+        }
+        this.componentsLoaded = true;
+        return this;
+    }
     /**
      * Recursively loads commands from the configured commands directory.
      *
@@ -129,7 +172,7 @@ export class MiniInteraction {
             console.warn(`[MiniInteraction] Commands directory "${targetDirectory}" does not exist. Skipping command auto-load.`);
             return this;
         }
-        const files = await this.collectCommandFiles(targetDirectory);
+        const files = await this.collectModuleFiles(targetDirectory);
         if (files.length === 0) {
             this.commandsLoaded = true;
             console.warn(`[MiniInteraction] No command files found under "${targetDirectory}".`);
@@ -385,7 +428,7 @@ export class MiniInteraction {
     /**
      * Recursively collects all command module file paths from the target directory.
      */
-    async collectCommandFiles(directory) {
+    async collectModuleFiles(directory) {
         const entries = await readdir(directory, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
@@ -394,11 +437,11 @@ export class MiniInteraction {
             }
             const fullPath = path.join(directory, entry.name);
             if (entry.isDirectory()) {
-                const nestedFiles = await this.collectCommandFiles(fullPath);
+                const nestedFiles = await this.collectModuleFiles(fullPath);
                 files.push(...nestedFiles);
                 continue;
             }
-            if (entry.isFile() && this.isSupportedCommandFile(fullPath)) {
+            if (entry.isFile() && this.isSupportedModuleFile(fullPath)) {
                 files.push(fullPath);
             }
         }
@@ -407,8 +450,8 @@ export class MiniInteraction {
     /**
      * Determines whether the provided file path matches a supported command file extension.
      */
-    isSupportedCommandFile(filePath) {
-        return SUPPORTED_COMMAND_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+    isSupportedModuleFile(filePath) {
+        return SUPPORTED_MODULE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
     }
     /**
      * Dynamically imports and validates a command module from disk.
@@ -441,6 +484,47 @@ export class MiniInteraction {
             return null;
         }
     }
+    /**
+     * Dynamically imports and validates a component module from disk.
+     */
+    async importComponentModule(absolutePath) {
+        try {
+            const moduleUrl = pathToFileURL(absolutePath).href;
+            const imported = await import(moduleUrl);
+            const candidate = imported.default ??
+                imported.component ??
+                imported.components ??
+                imported.componentDefinition ??
+                imported;
+            const candidates = Array.isArray(candidate)
+                ? candidate
+                : [candidate];
+            const components = [];
+            for (const item of candidates) {
+                if (!item || typeof item !== "object") {
+                    continue;
+                }
+                const { customId, handler } = item;
+                if (typeof customId !== "string") {
+                    console.warn(`[MiniInteraction] Component module "${absolutePath}" is missing "customId". Skipping.`);
+                    continue;
+                }
+                if (typeof handler !== "function") {
+                    console.warn(`[MiniInteraction] Component module "${absolutePath}" is missing a "handler" function. Skipping.`);
+                    continue;
+                }
+                components.push({ customId, handler });
+            }
+            if (components.length === 0) {
+                console.warn(`[MiniInteraction] Component module "${absolutePath}" did not export any valid components. Skipping.`);
+            }
+            return components;
+        }
+        catch (error) {
+            console.error(`[MiniInteraction] Failed to load component module "${absolutePath}":`, error);
+            return [];
+        }
+    }
     /**
      * Normalises the request body into a UTF-8 string for signature validation and parsing.
      */
@@ -450,6 +534,20 @@ export class MiniInteraction {
         }
         return Buffer.from(body).toString("utf8");
     }
+    /**
+     * Ensures components have been loaded from disk once before being accessed.
+     */
+    async ensureComponentsLoaded() {
+        if (this.componentsLoaded || this.componentsDirectory === null) {
+            return;
+        }
+        if (!this.loadComponentsPromise) {
+            this.loadComponentsPromise = this.loadComponentsFromDirectory().then(() => {
+                this.loadComponentsPromise = null;
+            });
+        }
+        await this.loadComponentsPromise;
+    }
     /**
      * Ensures commands have been loaded from disk once before being accessed.
      */
@@ -546,6 +644,7 @@ export class MiniInteraction {
                 },
             };
         }
+        await this.ensureComponentsLoaded();
         const handler = this.componentHandlers.get(customId);
         if (!handler) {
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minesa-org/mini-interaction",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",