@minesa-org/mini-interaction 0.0.2 → 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.
      */
@@ -169,7 +187,7 @@ export declare class MiniInteraction {
      */
     private resolveComponentsDirectory;
     /**
-     * Resolves a directory relative to the compiled file with optional overrides.
+     * Resolves a directory relative to the project "src" or "dist" folders with optional overrides.
      */
     private resolveDirectory;
     /**

package/dist/clients/MiniInteraction.js

@@ -1,13 +1,14 @@
+import { existsSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 import { InteractionResponseType, InteractionType, } from "discord-api-types/v10";
 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",
@@ -25,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");
         }
@@ -52,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.
@@ -110,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.
      *
@@ -128,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}".`);
@@ -384,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) {
@@ -393,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);
             }
         }
@@ -406,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.
@@ -440,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.
      */
@@ -449,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.
      */
@@ -467,27 +566,70 @@ export class MiniInteraction {
      * Resolves the absolute commands directory path from configuration.
      */
     resolveCommandsDirectory(commandsDirectory) {
-        return this.resolveDirectory("../commands", commandsDirectory);
+        return this.resolveDirectory("commands", commandsDirectory);
     }
     /**
      * Resolves the absolute components directory path from configuration.
      */
     resolveComponentsDirectory(componentsDirectory) {
-        return this.resolveDirectory("../components", componentsDirectory);
+        return this.resolveDirectory("components", componentsDirectory);
     }
     /**
-     * Resolves a directory relative to the compiled file with optional overrides.
+     * Resolves a directory relative to the project "src" or "dist" folders with optional overrides.
      */
-    resolveDirectory(defaultRelativePath, overrideDirectory) {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const defaultDir = path.resolve(__dirname, defaultRelativePath);
-        if (!overrideDirectory) {
-            return defaultDir;
-        }
-        return path.isAbsolute(overrideDirectory)
-            ? overrideDirectory
-            : path.resolve(process.cwd(), overrideDirectory);
+    resolveDirectory(defaultFolder, overrideDirectory) {
+        const projectRoot = process.cwd();
+        const allowedRoots = ["src", "dist"].map((folder) => path.resolve(projectRoot, folder));
+        const candidates = [];
+        const isWithin = (parent, child) => {
+            const relative = path.relative(parent, child);
+            return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+        };
+        const pushCandidate = (candidate) => {
+            if (!candidates.includes(candidate)) {
+                candidates.push(candidate);
+            }
+        };
+        const ensureWithinAllowedRoots = (absolutePath) => {
+            if (!allowedRoots.some((root) => isWithin(root, absolutePath))) {
+                throw new Error(`[MiniInteraction] Directory overrides must be located within "${path.join(projectRoot, "src")}" or "${path.join(projectRoot, "dist")}". Received: ${absolutePath}`);
+            }
+            pushCandidate(absolutePath);
+        };
+        const addOverrideCandidates = (overridePath) => {
+            const trimmed = overridePath.trim();
+            if (!trimmed) {
+                return;
+            }
+            if (path.isAbsolute(trimmed)) {
+                ensureWithinAllowedRoots(trimmed);
+                return;
+            }
+            const normalised = trimmed.replace(/^[./\\]+/, "");
+            if (!normalised) {
+                return;
+            }
+            if (normalised.startsWith("src") || normalised.startsWith("dist")) {
+                const absolutePath = path.resolve(projectRoot, normalised);
+                ensureWithinAllowedRoots(absolutePath);
+                return;
+            }
+            for (const root of allowedRoots) {
+                ensureWithinAllowedRoots(path.resolve(root, normalised));
+            }
+        };
+        if (overrideDirectory) {
+            addOverrideCandidates(overrideDirectory);
+        }
+        for (const root of allowedRoots) {
+            pushCandidate(path.resolve(root, defaultFolder));
+        }
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return candidates[0];
     }
     /**
      * Handles execution of a message component interaction.
@@ -502,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.2",
+	"version": "0.0.4",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",