@minesa-org/mini-interaction 0.0.9 → 0.0.11

package/dist/clients/MiniInteraction.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody } from "discord-api-types/v10";
+import { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody } from "discord-api-types/v10";
 import type { MiniInteractionCommand } from "../types/Commands.js";
 import { RoleConnectionMetadataTypes } from "../types/RoleConnectionMetadataTypes.js";
 import { type MessageComponentInteraction } from "../utils/MessageComponentInteraction.js";
@@ -138,14 +138,14 @@ export declare class MiniInteraction {
     /**
      * Lists the raw command data payloads for registration with Discord.
      */
-    listCommandData(): RESTPostAPIChatInputApplicationCommandsJSONBody[];
+    listCommandData(): (RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody)[];
     /**
-     * Registers slash commands with Discord's REST API.
+     * Registers commands with Discord's REST API.
      *
      * @param botToken - The bot token authorising the registration request.
      * @param commands - Optional command list to register instead of auto-loaded commands.
      */
-    registerCommands(botToken: string, commands?: RESTPostAPIChatInputApplicationCommandsJSONBody[]): Promise<unknown>;
+    registerCommands(botToken: string, commands?: (RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody)[]): Promise<unknown>;
     /**
      * Registers role connection metadata with Discord's REST API.
      *

package/dist/clients/MiniInteraction.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { InteractionResponseType, InteractionType, } from "discord-api-types/v10";
+import { ApplicationCommandType, 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";
@@ -251,7 +251,7 @@ export class MiniInteraction {
         return Array.from(this.commands.values(), (command) => command.data);
     }
     /**
-     * Registers slash commands with Discord's REST API.
+     * Registers commands with Discord's REST API.
      *
      * @param botToken - The bot token authorising the registration request.
      * @param commands - Optional command list to register instead of auto-loaded commands.
@@ -831,10 +831,22 @@ export class MiniInteraction {
                 },
             };
         }
-        const interactionWithHelpers = createCommandInteraction(commandInteraction);
         try {
-            const response = await command.handler(interactionWithHelpers);
-            const resolvedResponse = response ?? interactionWithHelpers.getResponse();
+            let response;
+            let resolvedResponse = null;
+            // Check if it's a chat input (slash) command
+            if (commandInteraction.data.type ===
+                ApplicationCommandType.ChatInput) {
+                const interactionWithHelpers = createCommandInteraction(commandInteraction);
+                response = await command.handler(interactionWithHelpers);
+                resolvedResponse =
+                    response ?? interactionWithHelpers.getResponse();
+            }
+            else {
+                // Context menu commands (User or Message) - pass raw interaction
+                response = await command.handler(commandInteraction);
+                resolvedResponse = response ?? null;
+            }
             if (!resolvedResponse) {
                 return {
                     status: 500,

package/dist/commands/ContextMenuCommandBuilder.d.ts

@@ -0,0 +1,83 @@
+import { ApplicationCommandType, type LocalizationMap, type Permissions, type RESTPostAPIContextMenuApplicationCommandsJSONBody } from "discord-api-types/v10";
+import { CommandContext, IntegrationType } from "./CommandBuilder.js";
+/**
+ * Base data structure for context menu commands.
+ */
+type ContextMenuCommandData = Partial<Omit<RESTPostAPIContextMenuApplicationCommandsJSONBody, "contexts" | "integration_types" | "type">> & {
+    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+    contexts?: CommandContext[] | null;
+    integration_types?: IntegrationType[];
+};
+/**
+ * Base builder for context menu commands (User and Message commands).
+ */
+declare abstract class BaseContextMenuCommandBuilder<T extends ApplicationCommandType.User | ApplicationCommandType.Message> {
+    protected readonly data: ContextMenuCommandData;
+    constructor(type: T);
+    /**
+     * Sets the command name.
+     * Context menu command names can be up to 32 characters and are displayed in the UI.
+     */
+    setName(name: string): this;
+    /**
+     * Sets the localized names for the command.
+     */
+    setNameLocalizations(nameLocalizations: LocalizationMap | null): this;
+    /**
+     * Sets the default member permissions required to use this command.
+     */
+    setDefaultMemberPermissions(permissions: Permissions | null): this;
+    /**
+     * Sets whether the command is available in direct messages.
+     */
+    setDMPermission(dmPermission: boolean): this;
+    /**
+     * Marks the command as not safe for work.
+     */
+    setNSFW(nsfw: boolean): this;
+    /**
+     * Limits the contexts in which the command can appear.
+     */
+    setContexts(contexts: CommandContext[] | null): this;
+    /**
+     * Specifies the integration types supported by the command.
+     */
+    setIntegrationTypes(integrationTypes: IntegrationType[]): this;
+    /**
+     * Produces the final REST payload for the configured command.
+     */
+    toJSON(): RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    /**
+     * Allows the builder to be coerced into its JSON payload automatically.
+     */
+    valueOf(): RESTPostAPIContextMenuApplicationCommandsJSONBody;
+}
+/**
+ * Builder for User context menu commands.
+ * These commands appear when right-clicking on a user.
+ *
+ * @example
+ * ```typescript
+ * const userCommand = new UserCommandBuilder()
+ *   .setName('User Info')
+ *   .toJSON();
+ * ```
+ */
+export declare class UserCommandBuilder extends BaseContextMenuCommandBuilder<ApplicationCommandType.User> {
+    constructor();
+}
+/**
+ * Builder for Message context menu commands.
+ * These commands appear when right-clicking on a message.
+ *
+ * @example
+ * ```typescript
+ * const messageCommand = new MessageCommandBuilder()
+ *   .setName('Report Message')
+ *   .toJSON();
+ * ```
+ */
+export declare class MessageCommandBuilder extends BaseContextMenuCommandBuilder<ApplicationCommandType.Message> {
+    constructor();
+}
+export {};

package/dist/commands/ContextMenuCommandBuilder.js

@@ -0,0 +1,137 @@
+import { ApplicationCommandType, } from "discord-api-types/v10";
+/**
+ * Base builder for context menu commands (User and Message commands).
+ */
+class BaseContextMenuCommandBuilder {
+    data;
+    constructor(type) {
+        this.data = {
+            type,
+        };
+    }
+    /**
+     * Sets the command name.
+     * Context menu command names can be up to 32 characters and are displayed in the UI.
+     */
+    setName(name) {
+        if (!name || name.length === 0) {
+            throw new Error("Context menu command name cannot be empty");
+        }
+        if (name.length > 32) {
+            throw new RangeError("Context menu command name cannot exceed 32 characters");
+        }
+        this.data.name = name;
+        return this;
+    }
+    /**
+     * Sets the localized names for the command.
+     */
+    setNameLocalizations(nameLocalizations) {
+        this.data.name_localizations = nameLocalizations ?? undefined;
+        return this;
+    }
+    /**
+     * Sets the default member permissions required to use this command.
+     */
+    setDefaultMemberPermissions(permissions) {
+        this.data.default_member_permissions =
+            permissions === null ? null : String(permissions);
+        return this;
+    }
+    /**
+     * Sets whether the command is available in direct messages.
+     */
+    setDMPermission(dmPermission) {
+        this.data.dm_permission = dmPermission;
+        return this;
+    }
+    /**
+     * Marks the command as not safe for work.
+     */
+    setNSFW(nsfw) {
+        this.data.nsfw = nsfw;
+        return this;
+    }
+    /**
+     * Limits the contexts in which the command can appear.
+     */
+    setContexts(contexts) {
+        this.data.contexts = contexts ? [...contexts] : null;
+        return this;
+    }
+    /**
+     * Specifies the integration types supported by the command.
+     */
+    setIntegrationTypes(integrationTypes) {
+        this.data.integration_types = [...integrationTypes];
+        return this;
+    }
+    /**
+     * Produces the final REST payload for the configured command.
+     */
+    toJSON() {
+        const { name, type } = this.data;
+        if (!name) {
+            throw new Error("Context menu command name has not been set");
+        }
+        const contexts = this.data.contexts;
+        const integrationTypes = this.data.integration_types;
+        return {
+            ...this.data,
+            name,
+            type,
+            contexts: contexts === null
+                ? null
+                : Array.isArray(contexts)
+                    ? [...contexts]
+                    : undefined,
+            integration_types: Array.isArray(integrationTypes)
+                ? [...integrationTypes]
+                : integrationTypes ?? undefined,
+        };
+    }
+    /**
+     * Allows the builder to be coerced into its JSON payload automatically.
+     */
+    valueOf() {
+        return this.toJSON();
+    }
+    /**
+     * Formats the command as JSON when inspected in Node.js runtimes.
+     */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toJSON();
+    }
+}
+/**
+ * Builder for User context menu commands.
+ * These commands appear when right-clicking on a user.
+ *
+ * @example
+ * ```typescript
+ * const userCommand = new UserCommandBuilder()
+ *   .setName('User Info')
+ *   .toJSON();
+ * ```
+ */
+export class UserCommandBuilder extends BaseContextMenuCommandBuilder {
+    constructor() {
+        super(ApplicationCommandType.User);
+    }
+}
+/**
+ * Builder for Message context menu commands.
+ * These commands appear when right-clicking on a message.
+ *
+ * @example
+ * ```typescript
+ * const messageCommand = new MessageCommandBuilder()
+ *   .setName('Report Message')
+ *   .toJSON();
+ * ```
+ */
+export class MessageCommandBuilder extends BaseContextMenuCommandBuilder {
+    constructor() {
+        super(ApplicationCommandType.Message);
+    }
+}

package/dist/index.d.ts

@@ -2,13 +2,14 @@
 export { MiniInteraction } from "./clients/MiniInteraction.js";
 export type { RoleConnectionMetadataField } from "./clients/MiniInteraction.js";
 export { CommandBuilder, CommandContext, IntegrationType, } from "./commands/CommandBuilder.js";
+export { UserCommandBuilder, MessageCommandBuilder, } from "./commands/ContextMenuCommandBuilder.js";
 export type { AttachmentOptionBuilder, ChannelOptionBuilder, MentionableOptionBuilder, NumberOptionBuilder, RoleOptionBuilder, StringOptionBuilder, SubcommandBuilder, SubcommandGroupBuilder, UserOptionBuilder, } from "./commands/CommandBuilder.js";
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
 export type { CommandInteraction, MentionableOption, ResolvedUserOption, } from "./utils/CommandInteractionOptions.js";
 export type { MiniInteractionFetchHandler, MiniInteractionNodeHandler, MiniInteractionHandlerResult, MiniInteractionRequest, MiniInteractionOptions, } from "./clients/MiniInteraction.js";
-export type { MiniInteractionCommand, SlashCommandHandler, } from "./types/Commands.js";
+export type { MiniInteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, CommandHandler, } from "./types/Commands.js";
 export type { MiniInteractionComponent, MiniInteractionComponentHandler, MiniInteractionModal, MiniInteractionModalHandler, MiniInteractionHandler, } from "./clients/MiniInteraction.js";
-export type { MessageComponentInteraction } from "./utils/MessageComponentInteraction.js";
+export type { MessageComponentInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
 export type { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 /** Entry point re-exporting MiniInteraction helpers, builders, and shared types. */
 export { MiniInteraction } from "./clients/MiniInteraction.js";
 export { CommandBuilder, CommandContext, IntegrationType, } from "./commands/CommandBuilder.js";
+export { UserCommandBuilder, MessageCommandBuilder, } from "./commands/ContextMenuCommandBuilder.js";
 export { CommandInteractionOptionResolver, createCommandInteraction, } from "./utils/CommandInteractionOptions.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";

package/dist/types/Commands.d.ts

@@ -1,12 +1,18 @@
-import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody } from "discord-api-types/v10";
+import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, APIUserApplicationCommandInteraction, APIMessageApplicationCommandInteraction } from "discord-api-types/v10";
 import type { CommandInteraction } from "../utils/CommandInteractionOptions.js";
 import type { MiniInteractionComponent, MiniInteractionModal } from "../clients/MiniInteraction.js";
 /** Handler signature for slash command executions within MiniInteraction. */
 export type SlashCommandHandler = (interaction: CommandInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+/** Handler signature for user context menu command executions within MiniInteraction. */
+export type UserCommandHandler = (interaction: APIUserApplicationCommandInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+/** Handler signature for message context menu command executions within MiniInteraction. */
+export type MessageCommandHandler = (interaction: APIMessageApplicationCommandInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+/** Union of all command handler types. */
+export type CommandHandler = SlashCommandHandler | UserCommandHandler | MessageCommandHandler;
 /** Structure representing a slash command definition and its runtime handler. */
 export type MiniInteractionCommand = {
-    data: RESTPostAPIChatInputApplicationCommandsJSONBody;
-    handler: SlashCommandHandler;
+    data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    handler: CommandHandler;
     /**
      * Optional array of component handlers related to this command.
      * These will be automatically registered when the command is loaded.

package/dist/utils/CommandInteractionOptions.d.ts

@@ -47,12 +47,25 @@ export declare class CommandInteractionOptionResolver {
      */
     getString(name: string, required?: boolean): string | null;
     /**
-     * Looks up a numeric option by name.
+     * Looks up an integer option by name.
      *
      * @param name - The option name to resolve.
      * @param required - Whether to throw when the option is missing.
      */
+    getInteger(name: string, required?: boolean): number | null;
+    /**
+     * Looks up a numeric option by name.
+     *
+     * @param name - The option name to resolve.
+     */
     getNumber(name: string, required?: boolean): number | null;
+    /**
+     * Looks up a boolean option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getBoolean(name: string, required?: boolean): boolean | null;
     /**
      * Resolves a user option, including any guild member payload.
      *

package/dist/utils/CommandInteractionOptions.js

@@ -131,15 +131,34 @@ export class CommandInteractionOptionResolver {
         return option ? option.value : null;
     }
     /**
-     * Looks up a numeric option by name.
+     * Looks up an integer option by name.
      *
      * @param name - The option name to resolve.
      * @param required - Whether to throw when the option is missing.
      */
+    getInteger(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Integer, required);
+        return option ? option.value : null;
+    }
+    /**
+     * Looks up a numeric option by name.
+     *
+     * @param name - The option name to resolve.
+     */
     getNumber(name, required = false) {
         const option = this.extractOption(name, ApplicationCommandOptionType.Number, required);
         return option ? option.value : null;
     }
+    /**
+     * Looks up a boolean option by name.
+     *
+     * @param name - The option name to resolve.
+     * @param required - Whether to throw when the option is missing.
+     */
+    getBoolean(name, required = false) {
+        const option = this.extractOption(name, ApplicationCommandOptionType.Boolean, required);
+        return option ? option.value : null;
+    }
     /**
      * Resolves a user option, including any guild member payload.
      *

package/dist/utils/MessageComponentInteraction.d.ts

@@ -1,5 +1,18 @@
-import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseDeferredMessageUpdate, type APIInteractionResponseUpdateMessage, type APIMessageComponentInteraction, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData } from "discord-api-types/v10";
+import { type APIInteractionDataResolvedChannel, type APIInteractionDataResolvedGuildMember, type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseDeferredMessageUpdate, type APIInteractionResponseUpdateMessage, type APIMessageComponentInteraction, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData, type APIRole, type APIUser } from "discord-api-types/v10";
 import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
+/** Resolved user option including optional guild member data. */
+export type ResolvedUserOption = {
+    user: APIUser;
+    member?: APIInteractionDataResolvedGuildMember;
+};
+/** Resolved mentionable option (either a user or role). */
+export type ResolvedMentionableOption = {
+    type: "user";
+    value: ResolvedUserOption;
+} | {
+    type: "role";
+    value: APIRole;
+};
 /**
  * Represents a component interaction augmented with helper response methods.
  *
@@ -21,6 +34,31 @@ export type MessageComponentInteraction = APIMessageComponentInteraction & {
      * For button interactions, this will be undefined.
      */
     values?: string[];
+    /**
+     * Helper method to get selected string values from a string select menu.
+     * @returns Array of selected string values, or empty array if not a string select menu
+     */
+    getStringValues: () => string[];
+    /**
+     * Helper method to get selected roles from a role select menu.
+     * @returns Array of resolved role objects, or empty array if not a role select menu
+     */
+    getRoles: () => APIRole[];
+    /**
+     * Helper method to get selected channels from a channel select menu.
+     * @returns Array of resolved channel objects, or empty array if not a channel select menu
+     */
+    getChannels: () => APIInteractionDataResolvedChannel[];
+    /**
+     * Helper method to get selected users from a user select menu.
+     * @returns Array of resolved user objects (with optional member data), or empty array if not a user select menu
+     */
+    getUsers: () => ResolvedUserOption[];
+    /**
+     * Helper method to get selected mentionables from a mentionable select menu.
+     * @returns Array of resolved mentionable objects (users or roles), or empty array if not a mentionable select menu
+     */
+    getMentionables: () => ResolvedMentionableOption[];
 };
 /**
  * Wraps a raw component interaction with helper methods mirroring Discord's expected responses.

package/dist/utils/MessageComponentInteraction.js

@@ -63,6 +63,99 @@ export function createMessageComponentInteraction(interaction) {
     const getResponse = () => capturedResponse;
     // Extract values from select menu interactions
     const values = "values" in interaction.data ? interaction.data.values : undefined;
+    // Helper methods for select menu interactions
+    const getStringValues = () => {
+        return values ?? [];
+    };
+    const getRoles = () => {
+        if (!values) {
+            return [];
+        }
+        // Type guard: check if resolved data exists
+        const resolved = "resolved" in interaction.data
+            ? interaction.data.resolved
+            : undefined;
+        if (!resolved?.roles) {
+            return [];
+        }
+        const roles = [];
+        for (const roleId of values) {
+            const role = resolved.roles[roleId];
+            if (role) {
+                roles.push(role);
+            }
+        }
+        return roles;
+    };
+    const getChannels = () => {
+        if (!values) {
+            return [];
+        }
+        // Type guard: check if resolved data exists
+        const resolved = "resolved" in interaction.data
+            ? interaction.data.resolved
+            : undefined;
+        if (!resolved?.channels) {
+            return [];
+        }
+        const channels = [];
+        for (const channelId of values) {
+            const channel = resolved.channels[channelId];
+            if (channel) {
+                channels.push(channel);
+            }
+        }
+        return channels;
+    };
+    const getUsers = () => {
+        if (!values) {
+            return [];
+        }
+        // Type guard: check if resolved data exists
+        const resolved = "resolved" in interaction.data
+            ? interaction.data.resolved
+            : undefined;
+        if (!resolved?.users) {
+            return [];
+        }
+        const users = [];
+        for (const userId of values) {
+            const user = resolved.users[userId];
+            if (user) {
+                const member = resolved.members?.[userId];
+                users.push({ user, member });
+            }
+        }
+        return users;
+    };
+    const getMentionables = () => {
+        if (!values) {
+            return [];
+        }
+        // Type guard: check if resolved data exists
+        const resolved = "resolved" in interaction.data
+            ? interaction.data.resolved
+            : undefined;
+        if (!resolved) {
+            return [];
+        }
+        const mentionables = [];
+        for (const id of values) {
+            // Check if it's a role
+            const role = resolved.roles?.[id];
+            if (role) {
+                mentionables.push({ type: "role", value: role });
+                continue;
+            }
+            // Check if it's a user
+            const user = resolved.users?.[id];
+            if (user) {
+                const member = resolved.members?.[id];
+                mentionables.push({ type: "user", value: { user, member } });
+            }
+        }
+        return mentionables;
+    };
     return Object.assign(interaction, {
         reply,
         deferReply,
@@ -71,5 +164,10 @@ export function createMessageComponentInteraction(interaction) {
         showModal,
         getResponse,
         values,
+        getStringValues,
+        getRoles,
+        getChannels,
+        getUsers,
+        getMentionables,
     });
 }

package/package.json

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