@minesa-org/mini-interaction 0.2.11 → 0.2.13

package/dist/clients/MiniInteraction.js

@@ -1267,7 +1267,7 @@ export class MiniInteraction {
                         canRespond: (id) => this.canRespond(id),
                         trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
                         onAck: (response) => ackResolver?.(response),
-                        sendFollowUp,
+                        sendFollowUp: (token, response, messageId) => this.sendFollowUp(token, response, messageId),
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =

package/dist/utils/CommandInteractionOptions.d.ts

@@ -46,23 +46,23 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     options: CommandInteractionOptionResolver;
     getResponse(): APIInteractionResponse | null;
     reply(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
-    followUp(data: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource>;
     edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
-    editReply(data?: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource | APIInteractionResponseUpdateMessage>;
+    followUp(data: InteractionMessageData): Promise<void>;
+    editReply(data?: InteractionMessageData): Promise<void>;
     deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
     showModal(data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
     }): APIModalInteractionResponse;
     withTimeoutProtection<T>(operation: () => Promise<T>, deferOptions?: DeferReplyOptions): Promise<T>;
     canRespond?(interactionId: string): boolean;
-    trackResponse?(interactionId: string, token: string, state: "responded" | "deferred"): void;
+    trackResponse?(interactionId: string, token: string, state: 'responded' | 'deferred'): void;
     onAck?(response: APIInteractionResponse): void;
     sendFollowUp?(token: string, response: APIInteractionResponse, messageId?: string): Promise<void>;
 }
 export declare const CommandInteraction: {};
 export declare function createCommandInteraction(interaction: APIChatInputApplicationCommandInteraction, helpers?: {
     canRespond?: (interactionId: string) => boolean;
-    trackResponse?: (interactionId: string, token: string, state: "responded" | "deferred") => void;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
     logTiming?: (interactionId: string, operation: string, startTime: number, success: boolean) => void;
     onAck?: (response: APIInteractionResponse) => void;
     sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;

package/dist/utils/CommandInteractionOptions.js

@@ -253,10 +253,10 @@ export function createCommandInteraction(interaction, helpers) {
         },
         reply(data) {
             if (this.canRespond && !this.canRespond(this.id)) {
-                throw new Error("Interaction cannot respond: already responded or expired");
+                throw new Error('Interaction cannot respond: already responded or expired');
             }
             const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
-            this.trackResponse?.(this.id, this.token, "responded");
+            this.trackResponse?.(this.id, this.token, 'responded');
             hasResponded = true;
             this.onAck?.(response);
             return response;
@@ -264,53 +264,45 @@ export function createCommandInteraction(interaction, helpers) {
         async followUp(data) {
             const normalisedData = normaliseInteractionMessageData(data);
             if (!normalisedData) {
-                throw new Error("[MiniInteraction] followUp requires data");
+                throw new Error('[MiniInteraction] followUp requires data');
             }
             const response = {
                 type: InteractionResponseType.ChannelMessageWithSource,
                 data: normalisedData,
             };
             if (this.sendFollowUp) {
-                await this.sendFollowUp(this.token, response, "");
+                await this.sendFollowUp(this.token, response, '');
             }
-            return response;
         },
         edit(data) {
             return createMessageResponse(InteractionResponseType.UpdateMessage, data);
         },
         async editReply(data) {
             if (this.canRespond && !this.canRespond(this.id)) {
-                throw new Error("Interaction cannot edit reply: expired");
+                throw new Error('Interaction cannot edit reply: expired');
             }
-            if (isDeferred) {
-                const normalisedData = normaliseInteractionMessageData(data);
-                if (!normalisedData) {
-                    throw new Error("[MiniInteraction] editReply requires data when deferred");
-                }
-                const response = {
-                    type: InteractionResponseType.ChannelMessageWithSource,
-                    data: normalisedData,
-                };
-                if (this.sendFollowUp) {
-                    await this.sendFollowUp(this.token, response, "@original");
-                }
-                this.trackResponse?.(this.id, this.token, "responded");
-                hasResponded = true;
-                return response;
+            const normalisedData = normaliseInteractionMessageData(data);
+            if (!normalisedData) {
+                throw new Error('[MiniInteraction] editReply requires data');
             }
-            const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
-            this.trackResponse?.(this.id, this.token, "responded");
+            const response = {
+                type: InteractionResponseType.ChannelMessageWithSource,
+                data: normalisedData,
+            };
+            if (this.sendFollowUp) {
+                await this.sendFollowUp(this.token, response, '@original');
+            }
+            this.trackResponse?.(this.id, this.token, 'responded');
             hasResponded = true;
-            return response;
         },
         deferReply(options) {
             if (this.canRespond && !this.canRespond(this.id)) {
-                throw new Error("Interaction cannot defer: already responded or expired");
+                throw new Error('Interaction cannot defer: already responded or expired');
             }
             const response = createDeferredResponse(options?.flags !== undefined
                 ? { flags: options.flags }
                 : undefined);
-            this.trackResponse?.(this.id, this.token, "deferred");
+            this.trackResponse?.(this.id, this.token, 'deferred');
             isDeferred = true;
             this.onAck?.(response);
             return response;

package/package.json

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