@minesa-org/mini-interaction 0.2.15 → 0.2.17

package/dist/clients/MiniInteraction.js

@@ -1584,9 +1584,21 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
                 reject(new Error(`Handler timeout: ${handlerName} exceeded ${timeoutMs}ms limit`));
             }, timeoutMs);
         });
+        // Create the handler promise and handle its potential background errors
+        const handlerPromise = (async () => {
+            try {
+                return await handler(...args);
+            }
+            catch (error) {
+                // If this error happens AFTER an ACK was already sent (via ackPromise)
+                // or after a timeout, we MUST still log it because nobody else will catch it.
+                console.error(`[MiniInteraction] ${handlerName} background error:`, error);
+                throw error;
+            }
+        })();
         try {
             const promises = [
-                Promise.resolve(handler(...args)),
+                handlerPromise,
                 timeoutPromise,
             ];
             if (ackPromise) {
@@ -1606,12 +1618,13 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
-            // Re-throw the error with additional context
+            // Background errors are already logged above
             if (error instanceof Error &&
                 error.message.includes("Handler timeout")) {
                 throw error;
             }
-            console.error(`[MiniInteraction] ${handlerName} failed:`, error);
+            // Only log here if it wasn't a background error (which we already caught)
+            // But since we catch all in handlerPromise, this is mostly for the timeout/race itself.
             throw error;
         }
     };

package/dist/utils/CommandInteractionOptions.d.ts

@@ -45,10 +45,10 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     };
     options: CommandInteractionOptionResolver;
     getResponse(): APIInteractionResponse | null;
-    reply(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
+    reply(data: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource>;
     edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
     followUp(data: InteractionMessageData): Promise<void>;
-    editReply(data?: InteractionMessageData): Promise<void>;
+    editReply(data?: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource | APIInteractionResponseUpdateMessage>;
     deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
     showModal(data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;

package/dist/utils/CommandInteractionOptions.js

@@ -251,13 +251,13 @@ export function createCommandInteraction(interaction, helpers) {
         getResponse() {
             return capturedResponse;
         },
-        reply(data) {
+        async reply(data) {
             if (this.canRespond && !this.canRespond(this.id)) {
                 throw new Error('Interaction cannot respond: already responded or expired');
             }
             const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
             if (isDeferred && this.sendFollowUp) {
-                this.sendFollowUp(this.token, response, '@original');
+                await this.sendFollowUp(this.token, response, '@original');
             }
             else {
                 this.onAck?.(response);
@@ -305,6 +305,7 @@ export function createCommandInteraction(interaction, helpers) {
             }
             this.trackResponse?.(this.id, this.token, 'responded');
             hasResponded = true;
+            return response;
         },
         deferReply(options) {
             if (this.canRespond && !this.canRespond(this.id)) {

package/dist/utils/ContextMenuInteraction.d.ts

@@ -5,7 +5,7 @@ import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageH
  */
 export type ContextMenuInteractionHelpers = {
     getResponse: () => APIInteractionResponse | null;
-    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
     followUp: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
     editReply: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;

package/dist/utils/ContextMenuInteraction.js

@@ -27,13 +27,13 @@ function createContextMenuInteractionHelpers(interaction, helpers) {
         }
         return captureResponse({ type });
     }
-    const reply = (data) => {
+    const reply = async (data) => {
         if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
             throw new Error("[MiniInteraction] Interaction cannot respond: already responded or expired");
         }
         const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
         if (isDeferred && helpers?.sendFollowUp) {
-            helpers.sendFollowUp(interaction.token, response, '@original');
+            await helpers.sendFollowUp(interaction.token, response, '@original');
         }
         else {
             helpers?.onAck?.(response);

package/dist/utils/MessageComponentInteraction.d.ts

@@ -153,6 +153,10 @@ export type MessageComponentInteraction = APIMessageComponentInteraction & {
     showModal: (data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
     }) => APIModalInteractionResponse;
+    /**
+     * Edit the initial interaction response.
+     */
+    editReply: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage | APIInteractionResponseChannelMessageWithSource>;
     /**
      * Finalise the interaction response via a webhook follow-up.
      * This is automatically called by reply() and update() if the interaction is deferred.

package/dist/utils/MessageComponentInteraction.js

@@ -108,6 +108,29 @@ export function createMessageComponentInteraction(interaction, helpers) {
             data: resolvedData,
         });
     };
+    const editReply = async (data) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot edit reply: expired");
+        }
+        const normalisedData = normaliseInteractionMessageData(data);
+        const response = captureResponse(normalisedData
+            ? {
+                type: InteractionResponseType.ChannelMessageWithSource,
+                data: normalisedData,
+            }
+            : {
+                type: InteractionResponseType.ChannelMessageWithSource,
+                data: { content: "" }
+            });
+        if (helpers?.sendFollowUp) {
+            await helpers.sendFollowUp(interaction.token, response, "@original");
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
+        helpers?.trackResponse?.(interaction.id, interaction.token, "responded");
+        return response;
+    };
     const getResponse = () => capturedResponse;
     // Extract values from select menu interactions
     const values = "values" in interaction.data ? interaction.data.values : undefined;
@@ -210,6 +233,7 @@ export function createMessageComponentInteraction(interaction, helpers) {
         update,
         deferUpdate,
         showModal,
+        editReply,
         getResponse,
         values,
         getStringValues,

package/dist/utils/ModalSubmitInteraction.d.ts

@@ -21,6 +21,10 @@ export type ModalSubmitInteraction = APIModalSubmitInteraction & {
      */
     canRespond?: (interactionId: string) => boolean;
     trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
+    /**
+     * Edit the initial interaction response.
+     */
+    editReply: (data?: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
 };
 export declare const ModalSubmitInteraction: {};
 /**

package/dist/utils/ModalSubmitInteraction.js

@@ -25,7 +25,21 @@ export function createModalSubmitInteraction(interaction, helpers) {
             data: normalisedData,
         });
         if (isDeferred && helpers?.sendFollowUp) {
-            await helpers.sendFollowUp(interaction.token, response, '');
+            await helpers.sendFollowUp(interaction.token, response, '@original');
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
+        return response;
+    };
+    const editReply = async (data) => {
+        const normalisedData = normaliseInteractionMessageData(data);
+        const response = captureResponse({
+            type: InteractionResponseType.ChannelMessageWithSource,
+            data: normalisedData ?? { content: "" },
+        });
+        if (helpers?.sendFollowUp) {
+            await helpers.sendFollowUp(interaction.token, response, '@original');
         }
         else {
             helpers?.onAck?.(response);
@@ -64,6 +78,7 @@ export function createModalSubmitInteraction(interaction, helpers) {
     return Object.assign(interaction, {
         reply,
         deferReply,
+        editReply,
         getResponse,
         getTextFieldValue,
         sendFollowUp: helpers?.sendFollowUp,

package/package.json

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