@minesa-org/mini-interaction 0.1.9 → 0.1.11

package/dist/clients/MiniInteraction.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody } from "discord-api-types/v10";
+import { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody } from "discord-api-types/v10";
 import type { MiniInteractionCommand } from "../types/Commands.js";
 import { RoleConnectionMetadataTypes } from "../types/RoleConnectionMetadataTypes.js";
 import { type MessageComponentInteraction, type ButtonInteraction, type StringSelectInteraction, type RoleSelectInteraction, type UserSelectInteraction, type ChannelSelectInteraction, type MentionableSelectInteraction } from "../utils/MessageComponentInteraction.js";
@@ -11,6 +11,7 @@ export type MiniInteractionOptions = {
     publicKey: string;
     commandsDirectory?: string | false;
     componentsDirectory?: string | false;
+    utilsDirectory?: string | false;
     fetchImplementation?: typeof fetch;
     verifyKeyImplementation?: VerifyKeyFunction;
 };
@@ -54,6 +55,7 @@ export type MiniInteractionComponentHandler = (interaction: MessageComponentInte
 export type MiniInteractionModalHandler = (interaction: ModalSubmitInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
 /** Unified handler signature that accepts any component or modal interaction. */
 export type MiniInteractionHandler = MiniInteractionButtonHandler | MiniInteractionStringSelectHandler | MiniInteractionRoleSelectHandler | MiniInteractionUserSelectHandler | MiniInteractionChannelSelectHandler | MiniInteractionMentionableSelectHandler | MiniInteractionComponentHandler | MiniInteractionModalHandler;
+type CommandDataPayload = RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody;
 /**
  * Structure describing a component or modal handler mapped to a custom id.
  * When auto-loading from the components directory:
@@ -144,6 +146,7 @@ export declare class MiniInteraction {
     private readonly verifyKeyImpl;
     private readonly commandsDirectory;
     private readonly componentsDirectory;
+    readonly utilsDirectory: string | null;
     private readonly commands;
     private readonly componentHandlers;
     private readonly modalHandlers;
@@ -152,10 +155,14 @@ export declare class MiniInteraction {
     private loadCommandsPromise;
     private componentsLoaded;
     private loadComponentsPromise;
+    private registerCommandsPromise;
+    private registerCommandsSignature;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, utilsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
+    private normalizeCommandData;
+    private registerCommand;
     /**
      * Registers a single command handler with the client.
      *
@@ -207,14 +214,14 @@ export declare class MiniInteraction {
     /**
      * Lists the raw command data payloads for registration with Discord.
      */
-    listCommandData(): (RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody)[];
+    listCommandData(): CommandDataPayload[];
     /**
      * 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 | RESTPostAPIContextMenuApplicationCommandsJSONBody)[]): Promise<unknown>;
+    registerCommands(botToken: string, commands?: CommandDataPayload[]): Promise<unknown>;
     /**
      * Registers role connection metadata with Discord's REST API.
      *
@@ -339,6 +346,10 @@ export declare class MiniInteraction {
      * Resolves the absolute components directory path from configuration.
      */
     private resolveComponentsDirectory;
+    /**
+     * Resolves the absolute utilities directory path from configuration.
+     */
+    private resolveUtilsDirectory;
     /**
      * Resolves a directory relative to the project "src" or "dist" folders with optional overrides.
      */

package/dist/clients/MiniInteraction.js

@@ -8,7 +8,7 @@ import { DISCORD_BASE_URL } from "../utils/constants.js";
 import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
 import { createMessageComponentInteraction, } from "../utils/MessageComponentInteraction.js";
 import { createModalSubmitInteraction, } from "../utils/ModalSubmitInteraction.js";
-import { createUserContextMenuInteraction, createMessageContextMenuInteraction, } from "../utils/ContextMenuInteraction.js";
+import { createUserContextMenuInteraction, createMessageContextMenuInteraction, createAppCommandInteraction, } from "../utils/ContextMenuInteraction.js";
 import { generateOAuthUrl, getOAuthTokens, getDiscordUser, } from "../oauth/DiscordOAuth.js";
 /** File extensions that are treated as loadable modules when auto-loading. */
 const SUPPORTED_MODULE_EXTENSIONS = new Set([
@@ -29,6 +29,7 @@ export class MiniInteraction {
     verifyKeyImpl;
     commandsDirectory;
     componentsDirectory;
+    utilsDirectory;
     commands = new Map();
     componentHandlers = new Map();
     modalHandlers = new Map();
@@ -37,10 +38,12 @@ export class MiniInteraction {
     loadCommandsPromise = null;
     componentsLoaded = false;
     loadComponentsPromise = null;
+    registerCommandsPromise = null;
+    registerCommandsSignature = null;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }) {
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, utilsDirectory, fetchImplementation, verifyKeyImplementation, }) {
         if (!applicationId) {
             throw new Error("[MiniInteraction] applicationId is required");
         }
@@ -63,33 +66,52 @@ export class MiniInteraction {
             componentsDirectory === false
                 ? null
                 : this.resolveComponentsDirectory(componentsDirectory);
+        this.utilsDirectory =
+            utilsDirectory === false
+                ? null
+                : this.resolveUtilsDirectory(utilsDirectory);
     }
-    /**
-     * Registers a single command handler with the client.
-     *
-     * @param command - The command definition to register.
-     */
-    useCommand(command) {
-        const commandName = command?.data?.name;
+    normalizeCommandData(data) {
+        if (typeof data === "object" && data !== null) {
+            const toJSON = data.toJSON;
+            if (typeof toJSON === "function") {
+                return toJSON.call(data);
+            }
+        }
+        return data;
+    }
+    registerCommand(command) {
+        const normalizedData = this.normalizeCommandData(command.data);
+        const commandName = normalizedData?.name;
         if (!commandName) {
             throw new Error("[MiniInteraction] command.data.name is required");
         }
         if (this.commands.has(commandName)) {
             console.warn(`[MiniInteraction] Command "${commandName}" already exists and will be overwritten.`);
         }
-        this.commands.set(commandName, command);
-        // Register components exported with the command
-        if (command.components && Array.isArray(command.components)) {
-            for (const component of command.components) {
+        const normalizedCommand = {
+            ...command,
+            data: normalizedData,
+        };
+        this.commands.set(commandName, normalizedCommand);
+        if (normalizedCommand.components && Array.isArray(normalizedCommand.components)) {
+            for (const component of normalizedCommand.components) {
                 this.useComponent(component);
             }
         }
-        // Register modals exported with the command
-        if (command.modals && Array.isArray(command.modals)) {
-            for (const modal of command.modals) {
+        if (normalizedCommand.modals && Array.isArray(normalizedCommand.modals)) {
+            for (const modal of normalizedCommand.modals) {
                 this.useModal(modal);
             }
         }
+    }
+    /**
+     * Registers a single command handler with the client.
+     *
+     * @param command - The command definition to register.
+     */
+    useCommand(command) {
+        this.registerCommand(command);
         return this;
     }
     /**
@@ -228,19 +250,7 @@ export class MiniInteraction {
             if (!command) {
                 continue;
             }
-            this.commands.set(command.data.name, command);
-            // Register components exported from the command file
-            if (command.components && Array.isArray(command.components)) {
-                for (const component of command.components) {
-                    this.useComponent(component);
-                }
-            }
-            // Register modals exported from the command file
-            if (command.modals && Array.isArray(command.modals)) {
-                for (const modal of command.modals) {
-                    this.useModal(modal);
-                }
-            }
+            this.registerCommand(command);
         }
         this.commandsLoaded = true;
         return this;
@@ -269,20 +279,46 @@ export class MiniInteraction {
         if (!Array.isArray(resolvedCommands) || resolvedCommands.length === 0) {
             throw new Error("[MiniInteraction] commands must be a non-empty array payload");
         }
+        const signature = JSON.stringify(resolvedCommands);
+        if (this.registerCommandsPromise) {
+            if (this.registerCommandsSignature === signature) {
+                console.warn("[MiniInteraction] Command registration already in progress. Reusing the in-flight request.");
+                return this.registerCommandsPromise;
+            }
+            console.warn("[MiniInteraction] Command registration already in progress. Waiting for it to finish before continuing.");
+            await this.registerCommandsPromise.catch(() => undefined);
+        }
         const url = `${DISCORD_BASE_URL}/applications/${this.applicationId}/commands`;
-        const response = await this.fetchImpl(url, {
-            method: "PUT",
-            headers: {
-                Authorization: `Bot ${botToken}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(resolvedCommands),
+        const requestPromise = (async () => {
+            try {
+                const response = await this.fetchImpl(url, {
+                    method: "PUT",
+                    headers: {
+                        Authorization: `Bot ${botToken}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify(resolvedCommands),
+                });
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    throw new Error(`[MiniInteraction] Failed to register commands: [${response.status}] ${errorBody}`);
+                }
+                return response.json();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (message.startsWith("[MiniInteraction]")) {
+                    throw error;
+                }
+                throw new Error(`[MiniInteraction] Failed to register commands: ${message}`);
+            }
+        })();
+        this.registerCommandsSignature = signature;
+        this.registerCommandsPromise = requestPromise.finally(() => {
+            this.registerCommandsPromise = null;
+            this.registerCommandsSignature = null;
         });
-        if (!response.ok) {
-            const errorBody = await response.text();
-            throw new Error(`[MiniInteraction] Failed to register commands: [${response.status}] ${errorBody}`);
-        }
-        return response.json();
+        return this.registerCommandsPromise;
     }
     /**
      * Registers role connection metadata with Discord's REST API.
@@ -775,8 +811,9 @@ export class MiniInteraction {
                 console.warn(`[MiniInteraction] Command module "${absolutePath}" does not export a command object. Skipping.`);
                 return null;
             }
-            const { data, handler } = candidate;
-            if (!data || typeof data.name !== "string") {
+            const { data, handler, components, modals } = candidate;
+            const normalizedData = this.normalizeCommandData(data);
+            if (!normalizedData || typeof normalizedData.name !== "string") {
                 console.warn(`[MiniInteraction] Command module "${absolutePath}" is missing "data.name". Skipping.`);
                 return null;
             }
@@ -784,7 +821,7 @@ export class MiniInteraction {
                 console.warn(`[MiniInteraction] Command module "${absolutePath}" is missing a "handler" function. Skipping.`);
                 return null;
             }
-            return { data, handler };
+            return { data: normalizedData, handler, components, modals };
         }
         catch (error) {
             console.error(`[MiniInteraction] Failed to load command module "${absolutePath}":`, error);
@@ -931,6 +968,12 @@ export class MiniInteraction {
     resolveComponentsDirectory(componentsDirectory) {
         return this.resolveDirectory("components", componentsDirectory);
     }
+    /**
+     * Resolves the absolute utilities directory path from configuration.
+     */
+    resolveUtilsDirectory(utilsDirectory) {
+        return this.resolveDirectory("utils", utilsDirectory);
+    }
     /**
      * Resolves a directory relative to the project "src" or "dist" folders with optional overrides.
      */
@@ -1131,6 +1174,13 @@ export class MiniInteraction {
                 resolvedResponse =
                     response ?? interactionWithHelpers.getResponse();
             }
+            else if (commandInteraction.data.type ===
+                ApplicationCommandType.PrimaryEntryPoint) {
+                const interactionWithHelpers = createAppCommandInteraction(commandInteraction);
+                response = await command.handler(interactionWithHelpers);
+                resolvedResponse =
+                    response ?? interactionWithHelpers.getResponse();
+            }
             else if (commandInteraction.data.type === ApplicationCommandType.Message) {
                 // Message context menu command
                 const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction);

package/dist/commands/ContextMenuCommandBuilder.d.ts

@@ -1,18 +1,23 @@
-import { ApplicationCommandType, type LocalizationMap, type Permissions, type RESTPostAPIContextMenuApplicationCommandsJSONBody } from "discord-api-types/v10";
+import { ApplicationCommandType, type LocalizationMap, type Permissions, type RESTPostAPIContextMenuApplicationCommandsJSONBody, type RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody } from "discord-api-types/v10";
 import { CommandContext, IntegrationType } from "./CommandBuilder.js";
 /**
- * Base data structure for context menu commands.
+ * Supported non-chat command types.
  */
-type ContextMenuCommandData = Partial<Omit<RESTPostAPIContextMenuApplicationCommandsJSONBody, "contexts" | "integration_types" | "type">> & {
-    type: ApplicationCommandType.User | ApplicationCommandType.Message;
+type NonChatCommandType = ApplicationCommandType.User | ApplicationCommandType.Message | ApplicationCommandType.PrimaryEntryPoint;
+type NonChatCommandPayload<T extends NonChatCommandType> = T extends ApplicationCommandType.PrimaryEntryPoint ? RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody : RESTPostAPIContextMenuApplicationCommandsJSONBody;
+/**
+ * Base data structure for context menu and primary entry point commands.
+ */
+type ContextMenuCommandData<T extends NonChatCommandType> = Partial<Omit<NonChatCommandPayload<T>, "contexts" | "integration_types" | "type">> & {
+    type: T;
     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;
+declare abstract class BaseContextMenuCommandBuilder<T extends NonChatCommandType> {
+    protected readonly data: ContextMenuCommandData<T>;
     constructor(type: T);
     /**
      * Sets the command name.
@@ -46,11 +51,11 @@ declare abstract class BaseContextMenuCommandBuilder<T extends ApplicationComman
     /**
      * Produces the final REST payload for the configured command.
      */
-    toJSON(): RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    toJSON(): NonChatCommandPayload<T>;
     /**
      * Allows the builder to be coerced into its JSON payload automatically.
      */
-    valueOf(): RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    valueOf(): NonChatCommandPayload<T>;
 }
 /**
  * Builder for User context menu commands.
@@ -80,4 +85,10 @@ export declare class UserCommandBuilder extends BaseContextMenuCommandBuilder<Ap
 export declare class MessageCommandBuilder extends BaseContextMenuCommandBuilder<ApplicationCommandType.Message> {
     constructor();
 }
+/**
+ * Builder for Primary Entry Point commands.
+ */
+export declare class AppCommandBuilder extends BaseContextMenuCommandBuilder<ApplicationCommandType.PrimaryEntryPoint> {
+    constructor();
+}
 export {};

package/dist/commands/ContextMenuCommandBuilder.js

@@ -135,3 +135,11 @@ export class MessageCommandBuilder extends BaseContextMenuCommandBuilder {
         super(ApplicationCommandType.Message);
     }
 }
+/**
+ * Builder for Primary Entry Point commands.
+ */
+export class AppCommandBuilder extends BaseContextMenuCommandBuilder {
+    constructor() {
+        super(ApplicationCommandType.PrimaryEntryPoint);
+    }
+}

package/dist/index.d.ts

@@ -2,13 +2,13 @@
 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 { UserCommandBuilder, MessageCommandBuilder, AppCommandBuilder, } 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 { UserContextMenuInteraction, MessageContextMenuInteraction, } from "./utils/ContextMenuInteraction.js";
+export type { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction, } from "./utils/ContextMenuInteraction.js";
 export type { MiniInteractionFetchHandler, MiniInteractionNodeHandler, MiniInteractionHandlerResult, MiniInteractionRequest, MiniInteractionOptions, DiscordOAuthAuthorizeContext, DiscordOAuthCallbackOptions, DiscordOAuthCallbackTemplates, DiscordOAuthErrorTemplateContext, DiscordOAuthServerErrorTemplateContext, DiscordOAuthStateTemplateContext, DiscordOAuthSuccessTemplateContext, DiscordOAuthVerificationPageOptions, } from "./clients/MiniInteraction.js";
-export type { MiniInteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, CommandHandler, } from "./types/Commands.js";
+export type { MiniInteractionCommand, SlashCommandHandler, UserCommandHandler, MessageCommandHandler, AppCommandHandler, CommandHandler, } from "./types/Commands.js";
 export type { MiniInteractionComponent, MiniInteractionButtonHandler, MiniInteractionStringSelectHandler, MiniInteractionRoleSelectHandler, MiniInteractionUserSelectHandler, MiniInteractionChannelSelectHandler, MiniInteractionMentionableSelectHandler, MiniInteractionComponentHandler, MiniInteractionModal, MiniInteractionModalHandler, MiniInteractionHandler, } from "./clients/MiniInteraction.js";
 export type { MessageComponentInteraction, ButtonInteraction, StringSelectInteraction, RoleSelectInteraction, UserSelectInteraction, ChannelSelectInteraction, MentionableSelectInteraction, ResolvedUserOption as ComponentResolvedUserOption, ResolvedMentionableOption as ComponentResolvedMentionableOption, } from "./utils/MessageComponentInteraction.js";
 export type { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";

package/dist/index.js

@@ -1,7 +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 { UserCommandBuilder, MessageCommandBuilder, AppCommandBuilder, } 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,23 +1,27 @@
-import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody } from "discord-api-types/v10";
+import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody, RESTPostAPIContextMenuApplicationCommandsJSONBody, RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody } from "discord-api-types/v10";
 import type { CommandInteraction } from "../utils/CommandInteractionOptions.js";
-import type { UserContextMenuInteraction, MessageContextMenuInteraction } from "../utils/ContextMenuInteraction.js";
+import type { UserContextMenuInteraction, MessageContextMenuInteraction, AppCommandInteraction } from "../utils/ContextMenuInteraction.js";
 import type { MiniInteractionComponent, MiniInteractionModal } from "../clients/MiniInteraction.js";
+import type { CommandBuilder } from "../commands/CommandBuilder.js";
+import type { MessageCommandBuilder, UserCommandBuilder, AppCommandBuilder } from "../commands/ContextMenuCommandBuilder.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: UserContextMenuInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
 /** Handler signature for message context menu command executions within MiniInteraction. */
 export type MessageCommandHandler = (interaction: MessageContextMenuInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
+/** Handler signature for primary entry point command executions within MiniInteraction. */
+export type AppCommandHandler = (interaction: AppCommandInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
 /** Union of all command handler types. */
-export type CommandHandler = SlashCommandHandler | UserCommandHandler | MessageCommandHandler;
+export type CommandHandler = SlashCommandHandler | UserCommandHandler | MessageCommandHandler | AppCommandHandler;
 /** Structure representing a slash command definition and its runtime handler. */
 export type MiniInteractionCommand = {
-    data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody;
+    data: RESTPostAPIChatInputApplicationCommandsJSONBody | RESTPostAPIContextMenuApplicationCommandsJSONBody | RESTPostAPIPrimaryEntryPointApplicationCommandJSONBody | CommandBuilder | UserCommandBuilder | MessageCommandBuilder | AppCommandBuilder;
     handler: CommandHandler;
     /**
      * Optional array of component handlers related to this command.
      * These will be automatically registered when the command is loaded.
-     */
+ */
     components?: MiniInteractionComponent[];
     /**
      * Optional array of modal handlers related to this command.

package/dist/utils/ContextMenuInteraction.d.ts

@@ -1,4 +1,4 @@
-import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIMessageApplicationCommandInteraction, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData, type APIUserApplicationCommandInteraction } from "discord-api-types/v10";
+import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseUpdateMessage, type APIMessage, type APIMessageApplicationCommandInteraction, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData, type APIPrimaryEntryPointCommandInteraction, type APIUser, type APIUserApplicationCommandInteraction } from "discord-api-types/v10";
 import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
 /**
  * Base helper methods for context menu interactions.
@@ -6,6 +6,8 @@ import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageH
 type ContextMenuInteractionHelpers = {
     getResponse: () => APIInteractionResponse | null;
     reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    followUp: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    editReply: (data?: InteractionMessageData) => APIInteractionResponseUpdateMessage;
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
     showModal: (data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
@@ -14,11 +16,21 @@ type ContextMenuInteractionHelpers = {
 /**
  * User context menu interaction with helper methods.
  */
-export type UserContextMenuInteraction = APIUserApplicationCommandInteraction & ContextMenuInteractionHelpers;
+export type UserContextMenuInteraction = APIUserApplicationCommandInteraction & ContextMenuInteractionHelpers & {
+    /** Resolved user targeted by this user context menu command. */
+    targetUser?: APIUser;
+};
 /**
  * Message context menu interaction with helper methods.
  */
-export type MessageContextMenuInteraction = APIMessageApplicationCommandInteraction & ContextMenuInteractionHelpers;
+export type MessageContextMenuInteraction = APIMessageApplicationCommandInteraction & ContextMenuInteractionHelpers & {
+    /** Resolved message targeted by this message context menu command. */
+    targetMessage?: APIMessage;
+};
+/**
+ * Primary entry point interaction with helper methods.
+ */
+export type AppCommandInteraction = APIPrimaryEntryPointCommandInteraction & ContextMenuInteractionHelpers;
 /**
  * Wraps a raw user context menu interaction with helper methods.
  *
@@ -33,4 +45,11 @@ export declare function createUserContextMenuInteraction(interaction: APIUserApp
  * @returns A helper-augmented interaction object.
  */
 export declare function createMessageContextMenuInteraction(interaction: APIMessageApplicationCommandInteraction): MessageContextMenuInteraction;
+/**
+ * Wraps a raw primary entry point interaction with helper methods.
+ *
+ * @param interaction - The raw primary entry point interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export declare function createAppCommandInteraction(interaction: APIPrimaryEntryPointCommandInteraction): AppCommandInteraction;
 export {};

package/dist/utils/ContextMenuInteraction.js

@@ -1,49 +1,63 @@
 import { InteractionResponseType, } from "discord-api-types/v10";
 import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./interactionMessageHelpers.js";
-/**
- * Wraps a raw user context menu interaction with helper methods.
- *
- * @param interaction - The raw user context menu interaction payload from Discord.
- * @returns A helper-augmented interaction object.
- */
-export function createUserContextMenuInteraction(interaction) {
+function createContextMenuInteractionHelpers() {
     let capturedResponse = null;
-    const reply = (data) => {
-        const normalised = normaliseInteractionMessageData(data);
-        if (!normalised) {
-            throw new Error("[MiniInteraction] Channel message responses require data to be provided.");
-        }
-        const response = {
-            type: InteractionResponseType.ChannelMessageWithSource,
-            data: normalised,
-        };
+    const captureResponse = (response) => {
         capturedResponse = response;
         return response;
     };
+    function createMessageResponse(type, data) {
+        const normalised = normaliseInteractionMessageData(data);
+        if (type === InteractionResponseType.ChannelMessageWithSource) {
+            if (!normalised) {
+                throw new Error("[MiniInteraction] Channel message responses require data to be provided.");
+            }
+            return captureResponse({
+                type,
+                data: normalised,
+            });
+        }
+        if (normalised) {
+            return captureResponse({ type, data: normalised });
+        }
+        return captureResponse({ type });
+    }
+    const reply = (data) => createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+    const followUp = (data) => createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+    const editReply = (data) => createMessageResponse(InteractionResponseType.UpdateMessage, data);
     const deferReply = (options = {}) => {
         const flags = normaliseMessageFlags(options.flags);
-        const response = {
+        return captureResponse({
             type: InteractionResponseType.DeferredChannelMessageWithSource,
             data: flags ? { flags } : undefined,
-        };
-        capturedResponse = response;
-        return response;
+        });
     };
     const showModal = (data) => {
         const modalData = typeof data === "object" && "toJSON" in data ? data.toJSON() : data;
-        const response = {
+        return captureResponse({
             type: InteractionResponseType.Modal,
             data: modalData,
-        };
-        capturedResponse = response;
-        return response;
+        });
     };
     const getResponse = () => capturedResponse;
-    return Object.assign(interaction, {
+    return {
+        getResponse,
         reply,
+        followUp,
+        editReply,
         deferReply,
         showModal,
-        getResponse,
+    };
+}
+/**
+ * Wraps a raw user context menu interaction with helper methods.
+ *
+ * @param interaction - The raw user context menu interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export function createUserContextMenuInteraction(interaction) {
+    return Object.assign(interaction, createContextMenuInteractionHelpers(), {
+        targetUser: resolveTargetUser(interaction),
     });
 }
 /**
@@ -53,42 +67,30 @@ export function createUserContextMenuInteraction(interaction) {
  * @returns A helper-augmented interaction object.
  */
 export function createMessageContextMenuInteraction(interaction) {
-    let capturedResponse = null;
-    const reply = (data) => {
-        const normalised = normaliseInteractionMessageData(data);
-        if (!normalised) {
-            throw new Error("[MiniInteraction] Channel message responses require data to be provided.");
-        }
-        const response = {
-            type: InteractionResponseType.ChannelMessageWithSource,
-            data: normalised,
-        };
-        capturedResponse = response;
-        return response;
-    };
-    const deferReply = (options = {}) => {
-        const flags = normaliseMessageFlags(options.flags);
-        const response = {
-            type: InteractionResponseType.DeferredChannelMessageWithSource,
-            data: flags ? { flags } : undefined,
-        };
-        capturedResponse = response;
-        return response;
-    };
-    const showModal = (data) => {
-        const modalData = typeof data === "object" && "toJSON" in data ? data.toJSON() : data;
-        const response = {
-            type: InteractionResponseType.Modal,
-            data: modalData,
-        };
-        capturedResponse = response;
-        return response;
-    };
-    const getResponse = () => capturedResponse;
-    return Object.assign(interaction, {
-        reply,
-        deferReply,
-        showModal,
-        getResponse,
+    return Object.assign(interaction, createContextMenuInteractionHelpers(), {
+        targetMessage: resolveTargetMessage(interaction),
     });
 }
+/**
+ * Wraps a raw primary entry point interaction with helper methods.
+ *
+ * @param interaction - The raw primary entry point interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export function createAppCommandInteraction(interaction) {
+    return Object.assign(interaction, createContextMenuInteractionHelpers());
+}
+function resolveTargetMessage(interaction) {
+    const targetId = interaction.data?.target_id;
+    if (!targetId) {
+        return undefined;
+    }
+    return interaction.data?.resolved?.messages?.[targetId];
+}
+function resolveTargetUser(interaction) {
+    const targetId = interaction.data?.target_id;
+    if (!targetId) {
+        return undefined;
+    }
+    return interaction.data?.resolved?.users?.[targetId];
+}

package/package.json

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