@minesa-org/mini-interaction 0.0.4 → 0.0.6

package/dist/clients/MiniInteraction.js

@@ -7,6 +7,7 @@ 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";
+import { createModalSubmitInteraction, } from "../utils/ModalSubmitInteraction.js";
 /** File extensions that are treated as loadable modules when auto-loading. */
 const SUPPORTED_MODULE_EXTENSIONS = new Set([
     ".js",
@@ -29,6 +30,7 @@ export class MiniInteraction {
     componentsDirectory;
     commands = new Map();
     componentHandlers = new Map();
+    modalHandlers = new Map();
     commandsLoaded = false;
     loadCommandsPromise = null;
     componentsLoaded = false;
@@ -75,6 +77,18 @@ export class MiniInteraction {
             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) {
+                this.useComponent(component);
+            }
+        }
+        // Register modals exported with the command
+        if (command.modals && Array.isArray(command.modals)) {
+            for (const modal of command.modals) {
+                this.useModal(modal);
+            }
+        }
         return this;
     }
     /**
@@ -118,6 +132,36 @@ export class MiniInteraction {
         }
         return this;
     }
+    /**
+     * Registers a single modal handler mapped to a custom identifier.
+     *
+     * @param modal - The modal definition to register.
+     */
+    useModal(modal) {
+        const customId = modal?.customId;
+        if (!customId) {
+            throw new Error("[MiniInteraction] modal.customId is required");
+        }
+        if (typeof modal.handler !== "function") {
+            throw new Error("[MiniInteraction] modal.handler must be a function");
+        }
+        if (this.modalHandlers.has(customId)) {
+            console.warn(`[MiniInteraction] Modal "${customId}" already exists and will be overwritten.`);
+        }
+        this.modalHandlers.set(customId, modal.handler);
+        return this;
+    }
+    /**
+     * Registers multiple modal handlers in a single call.
+     *
+     * @param modals - The modal definitions to register.
+     */
+    useModals(modals) {
+        for (const modal of modals) {
+            this.useModal(modal);
+        }
+        return this;
+    }
     /**
      * Recursively loads components from the configured components directory.
      *
@@ -184,6 +228,18 @@ export class MiniInteraction {
                 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.commandsLoaded = true;
         return this;
@@ -302,6 +358,9 @@ export class MiniInteraction {
         if (interaction.type === InteractionType.MessageComponent) {
             return this.handleMessageComponent(interaction);
         }
+        if (interaction.type === InteractionType.ModalSubmit) {
+            return this.handleModalSubmit(interaction);
+        }
         return {
             status: 400,
             body: {
@@ -542,9 +601,10 @@ export class MiniInteraction {
             return;
         }
         if (!this.loadComponentsPromise) {
-            this.loadComponentsPromise = this.loadComponentsFromDirectory().then(() => {
-                this.loadComponentsPromise = null;
-            });
+            this.loadComponentsPromise =
+                this.loadComponentsFromDirectory().then(() => {
+                    this.loadComponentsPromise = null;
+                });
         }
         await this.loadComponentsPromise;
     }
@@ -583,7 +643,8 @@ export class MiniInteraction {
         const candidates = [];
         const isWithin = (parent, child) => {
             const relative = path.relative(parent, child);
-            return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+            return (relative === "" ||
+                (!relative.startsWith("..") && !path.isAbsolute(relative)));
         };
         const pushCandidate = (candidate) => {
             if (!candidates.includes(candidate)) {
@@ -681,6 +742,55 @@ export class MiniInteraction {
             };
         }
     }
+    /**
+     * Handles execution of a modal submit interaction.
+     */
+    async handleModalSubmit(interaction) {
+        const customId = interaction?.data?.custom_id;
+        if (!customId) {
+            return {
+                status: 400,
+                body: {
+                    error: "[MiniInteraction] Modal submit interaction is missing a custom_id",
+                },
+            };
+        }
+        const handler = this.modalHandlers.get(customId);
+        if (!handler) {
+            return {
+                status: 404,
+                body: {
+                    error: `[MiniInteraction] No handler registered for modal "${customId}"`,
+                },
+            };
+        }
+        try {
+            const interactionWithHelpers = createModalSubmitInteraction(interaction);
+            const response = await handler(interactionWithHelpers);
+            const resolvedResponse = response ?? interactionWithHelpers.getResponse();
+            if (!resolvedResponse) {
+                return {
+                    status: 500,
+                    body: {
+                        error: `[MiniInteraction] Modal "${customId}" did not return a response. ` +
+                            "Return an APIInteractionResponse to acknowledge the interaction.",
+                    },
+                };
+            }
+            return {
+                status: 200,
+                body: resolvedResponse,
+            };
+        }
+        catch (error) {
+            return {
+                status: 500,
+                body: {
+                    error: `[MiniInteraction] Modal "${customId}" failed: ${String(error)}`,
+                },
+            };
+        }
+    }
     /**
      * Handles execution of an application command interaction.
      */

package/dist/index.d.ts

@@ -7,10 +7,15 @@ export { CommandInteractionOptionResolver, createCommandInteraction, } from "./u
 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 { MiniInteractionComponent, MiniInteractionComponentHandler, } from "./clients/MiniInteraction.js";
+export type { MiniInteractionComponent, MiniInteractionComponentHandler, MiniInteractionModal, MiniInteractionModalHandler, } from "./clients/MiniInteraction.js";
+export type { MessageComponentInteraction } from "./utils/MessageComponentInteraction.js";
+export type { ModalSubmitInteraction } from "./utils/ModalSubmitInteraction.js";
 export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes.js";
 export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
+export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { TextInputStyle } from "discord-api-types/v10";
+export { MiniPermFlags } from "./types/PermissionFlags.js";
 export type { MiniComponentActionRow, MiniComponentMessageActionRow, } from "./types/ComponentTypes.js";
 export * from "./builders/index.js";

package/dist/index.js

@@ -6,4 +6,7 @@ export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes
 export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
+export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { TextInputStyle } from "discord-api-types/v10";
+export { MiniPermFlags } from "./types/PermissionFlags.js";
 export * from "./builders/index.js";

package/dist/types/Commands.d.ts

@@ -1,11 +1,22 @@
 import type { APIInteractionResponse, RESTPostAPIChatInputApplicationCommandsJSONBody } 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;
 /** Structure representing a slash command definition and its runtime handler. */
 export type MiniInteractionCommand = {
     data: RESTPostAPIChatInputApplicationCommandsJSONBody;
     handler: SlashCommandHandler;
+    /**
+     * 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.
+     * These will be automatically registered when the command is loaded.
+     */
+    modals?: MiniInteractionModal[];
 };
 /** Map of command names to their registered MiniInteraction command definitions. */
 export type MiniInteractionCommandsMap = Map<string, MiniInteractionCommand>;

package/dist/types/PermissionFlags.d.ts

@@ -0,0 +1,55 @@
+/** Convenience mapping of Discord permission bit flags for MiniInteraction usage. */
+export declare const MiniPermFlags: {
+    readonly CreateInstantInvite: bigint;
+    readonly KickMembers: bigint;
+    readonly BanMembers: bigint;
+    readonly Administrator: bigint;
+    readonly ManageChannels: bigint;
+    readonly ManageGuild: bigint;
+    readonly AddReactions: bigint;
+    readonly ViewAuditLog: bigint;
+    readonly PrioritySpeaker: bigint;
+    readonly Stream: bigint;
+    readonly ViewChannel: bigint;
+    readonly SendMessages: bigint;
+    readonly SendTTSMessages: bigint;
+    readonly ManageMessages: bigint;
+    readonly EmbedLinks: bigint;
+    readonly AttachFiles: bigint;
+    readonly ReadMessageHistory: bigint;
+    readonly MentionEveryone: bigint;
+    readonly UseExternalEmojis: bigint;
+    readonly ViewGuildInsights: bigint;
+    readonly Connect: bigint;
+    readonly Speak: bigint;
+    readonly MuteMembers: bigint;
+    readonly DeafenMembers: bigint;
+    readonly MoveMembers: bigint;
+    readonly UseVAD: bigint;
+    readonly ChangeNickname: bigint;
+    readonly ManageNicknames: bigint;
+    readonly ManageRoles: bigint;
+    readonly ManageWebhooks: bigint;
+    readonly ManageEmojisAndStickers: bigint;
+    readonly ManageGuildExpressions: bigint;
+    readonly UseApplicationCommands: bigint;
+    readonly RequestToSpeak: bigint;
+    readonly ManageEvents: bigint;
+    readonly ManageThreads: bigint;
+    readonly CreatePublicThreads: bigint;
+    readonly CreatePrivateThreads: bigint;
+    readonly UseExternalStickers: bigint;
+    readonly SendMessagesInThreads: bigint;
+    readonly UseEmbeddedActivities: bigint;
+    readonly ModerateMembers: bigint;
+    readonly ViewCreatorMonetizationAnalytics: bigint;
+    readonly UseSoundboard: bigint;
+    readonly CreateGuildExpressions: bigint;
+    readonly CreateEvents: bigint;
+    readonly UseExternalSounds: bigint;
+    readonly SendVoiceMessages: bigint;
+    readonly SendPolls: bigint;
+    readonly UseExternalApps: bigint;
+    readonly PinMessages: bigint;
+};
+export type MiniPermFlag = (typeof MiniPermFlags)[keyof typeof MiniPermFlags];

package/dist/types/PermissionFlags.js

@@ -0,0 +1,5 @@
+import { PermissionFlagsBits } from "discord-api-types/v10";
+/** Convenience mapping of Discord permission bit flags for MiniInteraction usage. */
+export const MiniPermFlags = {
+    ...PermissionFlagsBits,
+};

package/dist/types/SeparatorSpacingSize.d.ts

@@ -0,0 +1,2 @@
+/** Re-export of Discord separator spacing size identifiers for convenience in builders. */
+export { SeparatorSpacingSize } from "discord-api-types/v10";

package/dist/types/SeparatorSpacingSize.js

@@ -0,0 +1,2 @@
+/** Re-export of Discord separator spacing size identifiers for convenience in builders. */
+export { SeparatorSpacingSize } from "discord-api-types/v10";

package/dist/utils/CommandInteractionOptions.d.ts

@@ -132,7 +132,9 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     followUp(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
     edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
     deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
-    showModal(data: APIModalInteractionResponseCallbackData): APIModalInteractionResponse;
+    showModal(data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }): APIModalInteractionResponse;
 }
 /**
  * Wraps a raw application command interaction with helper methods and option resolvers.

package/dist/utils/CommandInteractionOptions.js

@@ -366,9 +366,14 @@ export function createCommandInteraction(interaction) {
                 : undefined);
         },
         showModal(data) {
+            const resolvedData = typeof data === "object" &&
+                "toJSON" in data &&
+                typeof data.toJSON === "function"
+                ? data.toJSON()
+                : data;
             return captureResponse({
                 type: InteractionResponseType.Modal,
-                data,
+                data: resolvedData,
             });
         },
     };

package/dist/utils/MessageComponentInteraction.d.ts

@@ -1,7 +1,10 @@
-import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseDeferredMessageUpdate, type APIInteractionResponseUpdateMessage, type APIMessageComponentInteraction } from "discord-api-types/v10";
+import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIInteractionResponseDeferredMessageUpdate, type APIInteractionResponseUpdateMessage, type APIMessageComponentInteraction, type APIModalInteractionResponse, type APIModalInteractionResponseCallbackData } from "discord-api-types/v10";
 import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
 /**
  * Represents a component interaction augmented with helper response methods.
+ *
+ * Note: The `values` property is available on select menu interactions (data.values).
+ * For button interactions, this property will be undefined.
  */
 export type MessageComponentInteraction = APIMessageComponentInteraction & {
     getResponse: () => APIInteractionResponse | null;
@@ -9,6 +12,15 @@ export type MessageComponentInteraction = APIMessageComponentInteraction & {
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
     update: (data?: InteractionMessageData) => APIInteractionResponseUpdateMessage;
     deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
+    /**
+     * The selected values from a select menu interaction.
+     * This property is only present for select menu interactions.
+     * For button interactions, this will be undefined.
+     */
+    values?: string[];
 };
 /**
  * Wraps a raw component interaction with helper methods mirroring Discord's expected responses.

package/dist/utils/MessageComponentInteraction.js

@@ -49,12 +49,27 @@ export function createMessageComponentInteraction(interaction) {
     const deferUpdate = () => captureResponse({
         type: InteractionResponseType.DeferredMessageUpdate,
     });
+    const showModal = (data) => {
+        const resolvedData = typeof data === "object" &&
+            "toJSON" in data &&
+            typeof data.toJSON === "function"
+            ? data.toJSON()
+            : data;
+        return captureResponse({
+            type: InteractionResponseType.Modal,
+            data: resolvedData,
+        });
+    };
     const getResponse = () => capturedResponse;
+    // Extract values from select menu interactions
+    const values = "values" in interaction.data ? interaction.data.values : undefined;
     return Object.assign(interaction, {
         reply,
         deferReply,
         update,
         deferUpdate,
+        showModal,
         getResponse,
+        values,
     });
 }

package/dist/utils/ModalSubmitInteraction.d.ts

@@ -0,0 +1,28 @@
+import { type APIInteractionResponse, type APIInteractionResponseChannelMessageWithSource, type APIInteractionResponseDeferredChannelMessageWithSource, type APIModalSubmitInteraction } from "discord-api-types/v10";
+import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageHelpers.js";
+/**
+ * Represents a modal submit interaction augmented with helper response methods.
+ */
+export type ModalSubmitInteraction = APIModalSubmitInteraction & {
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    /**
+     * Helper method to get the value of a text input component by custom_id.
+     * @param customId - The custom_id of the text input component
+     * @returns The value of the text input, or undefined if not found
+     */
+    getTextInputValue: (customId: string) => string | undefined;
+    /**
+     * Helper method to get all text input values as a map.
+     * @returns A map of custom_id to value for all text inputs
+     */
+    getTextInputValues: () => Map<string, string>;
+};
+/**
+ * Wraps a raw modal submit interaction with helper methods.
+ *
+ * @param interaction - The raw interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export declare function createModalSubmitInteraction(interaction: APIModalSubmitInteraction): ModalSubmitInteraction;

package/dist/utils/ModalSubmitInteraction.js

@@ -0,0 +1,74 @@
+import { InteractionResponseType, } from "discord-api-types/v10";
+import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./interactionMessageHelpers.js";
+/**
+ * Wraps a raw modal submit interaction with helper methods.
+ *
+ * @param interaction - The raw interaction payload from Discord.
+ * @returns A helper-augmented interaction object.
+ */
+export function createModalSubmitInteraction(interaction) {
+    let capturedResponse = null;
+    const captureResponse = (response) => {
+        capturedResponse = response;
+        return response;
+    };
+    const reply = (data) => {
+        const normalisedData = normaliseInteractionMessageData(data);
+        if (!normalisedData) {
+            throw new Error("[MiniInteraction] Modal submit replies require response data to be provided.");
+        }
+        return captureResponse({
+            type: InteractionResponseType.ChannelMessageWithSource,
+            data: normalisedData,
+        });
+    };
+    const deferReply = (options) => {
+        const flags = normaliseMessageFlags(options?.flags);
+        const response = flags !== undefined
+            ? {
+                type: InteractionResponseType.DeferredChannelMessageWithSource,
+                data: { flags },
+            }
+            : {
+                type: InteractionResponseType.DeferredChannelMessageWithSource,
+            };
+        return captureResponse(response);
+    };
+    const getResponse = () => capturedResponse;
+    // Helper to extract text input values from modal components
+    const extractTextInputs = () => {
+        const textInputs = new Map();
+        for (const component of interaction.data.components) {
+            // Handle action rows
+            if ("components" in component && Array.isArray(component.components)) {
+                for (const child of component.components) {
+                    if ("value" in child && "custom_id" in child) {
+                        textInputs.set(child.custom_id, child.value);
+                    }
+                }
+            }
+            // Handle labeled components
+            else if ("component" in component) {
+                const labeledComponent = component.component;
+                if ("value" in labeledComponent && "custom_id" in labeledComponent) {
+                    textInputs.set(labeledComponent.custom_id, labeledComponent.value);
+                }
+            }
+        }
+        return textInputs;
+    };
+    const textInputValues = extractTextInputs();
+    const getTextInputValue = (customId) => {
+        return textInputValues.get(customId);
+    };
+    const getTextInputValues = () => {
+        return new Map(textInputValues);
+    };
+    return Object.assign(interaction, {
+        reply,
+        deferReply,
+        getResponse,
+        getTextInputValue,
+        getTextInputValues,
+    });
+}

package/dist/utils/interactionMessageHelpers.d.ts

@@ -4,23 +4,23 @@ import type { InteractionFollowUpFlags, InteractionReplyFlags } from "../types/I
 export type MessageFlagLike = MessageFlags | InteractionReplyFlags | InteractionFollowUpFlags;
 /** Message payload accepted by helper reply/edit functions. */
 export type InteractionMessageData = Omit<APIInteractionResponseCallbackData, "flags"> & {
-    flags?: MessageFlagLike;
+    flags?: MessageFlagLike | MessageFlagLike[];
 };
 /** Deferred response payload recognised by helper methods. */
 export type DeferredResponseData = {
-    flags: MessageFlagLike;
+    flags: MessageFlagLike | MessageFlagLike[];
 };
 /** Options accepted when deferring a reply. */
 export type DeferReplyOptions = {
-    flags?: MessageFlagLike;
+    flags?: MessageFlagLike | MessageFlagLike[];
 };
 /**
  * Normalises helper flag enums into the raw Discord `MessageFlags` bitfield.
  *
- * @param flags - A flag from helper enums or raw Discord flags.
+ * @param flags - A flag or array of flags from helper enums or raw Discord flags.
  * @returns The value coerced to a `MessageFlags` compatible bitfield.
  */
-export declare function normaliseMessageFlags(flags: MessageFlagLike | undefined): MessageFlags | undefined;
+export declare function normaliseMessageFlags(flags: MessageFlagLike | MessageFlagLike[] | undefined): MessageFlags | undefined;
 /**
  * Ensures helper message payloads include correctly normalised message flags.
  *

package/dist/utils/interactionMessageHelpers.js

@@ -1,11 +1,31 @@
+import { ComponentType, MessageFlags as RawMessageFlags, } from "discord-api-types/v10";
+const COMPONENTS_V2_TYPES = new Set([
+    ComponentType.Container,
+    ComponentType.Section,
+    ComponentType.TextDisplay,
+    ComponentType.MediaGallery,
+    ComponentType.File,
+    ComponentType.Separator,
+    ComponentType.Thumbnail,
+]);
 /**
  * Normalises helper flag enums into the raw Discord `MessageFlags` bitfield.
  *
- * @param flags - A flag from helper enums or raw Discord flags.
+ * @param flags - A flag or array of flags from helper enums or raw Discord flags.
  * @returns The value coerced to a `MessageFlags` compatible bitfield.
  */
 export function normaliseMessageFlags(flags) {
-    return flags === undefined ? undefined : flags;
+    if (flags === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(flags)) {
+        if (flags.length === 0) {
+            return undefined;
+        }
+        // Combine multiple flags using bitwise OR
+        return flags.reduce((acc, flag) => (acc | flag), 0);
+    }
+    return flags;
 }
 /**
  * Ensures helper message payloads include correctly normalised message flags.
@@ -17,16 +37,66 @@ export function normaliseInteractionMessageData(data) {
     if (!data) {
         return undefined;
     }
-    if (data.flags === undefined) {
-        return data;
-    }
-    const { flags, ...rest } = data;
-    const normalisedFlags = normaliseMessageFlags(flags);
-    if (normalisedFlags === flags) {
+    // Auto-convert builders to JSON
+    const normalisedComponents = data.components
+        ? data.components.map((component) => resolveComponentLike(component))
+        : undefined;
+    const normalisedEmbeds = data.embeds
+        ? data.embeds.map((embed) => resolveComponentLike(embed))
+        : undefined;
+    const usesComponentsV2 = Array.isArray(normalisedComponents)
+        ? containsComponentsV2(normalisedComponents)
+        : false;
+    const normalisedFlags = normaliseMessageFlags(data.flags);
+    const finalFlags = usesComponentsV2
+        ? ((normalisedFlags ?? 0) |
+            RawMessageFlags.IsComponentsV2)
+        : normalisedFlags;
+    const needsNormalisation = finalFlags !== data.flags ||
+        normalisedComponents !== data.components ||
+        normalisedEmbeds !== data.embeds;
+    if (!needsNormalisation) {
         return data;
     }
+    const { flags: _flags, components: _components, embeds: _embeds, ...rest } = data;
     return {
         ...rest,
-        flags: normalisedFlags,
+        ...(normalisedComponents !== undefined
+            ? { components: normalisedComponents }
+            : {}),
+        ...(normalisedEmbeds !== undefined ? { embeds: normalisedEmbeds } : {}),
+        ...(finalFlags !== undefined ? { flags: finalFlags } : {}),
     };
 }
+function containsComponentsV2(components) {
+    return components.some((component) => componentUsesComponentsV2(component));
+}
+function componentUsesComponentsV2(component) {
+    const resolved = resolveComponentLike(component);
+    if (!resolved || typeof resolved !== "object") {
+        return false;
+    }
+    const type = resolved.type;
+    if (typeof type !== "number") {
+        return false;
+    }
+    if (COMPONENTS_V2_TYPES.has(type)) {
+        return true;
+    }
+    if (type === ComponentType.ActionRow) {
+        const rowComponents = resolved.components;
+        if (Array.isArray(rowComponents)) {
+            return containsComponentsV2(rowComponents);
+        }
+    }
+    return false;
+}
+function resolveComponentLike(component) {
+    if (component && typeof component === "object" && "toJSON" in component) {
+        const encoder = component;
+        if (typeof encoder.toJSON === "function") {
+            return encoder.toJSON();
+        }
+    }
+    return component;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minesa-org/mini-interaction",
-	"version": "0.0.4",
+	"version": "0.0.6",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",
@@ -14,6 +14,7 @@
 		"build": "tsc --project tsconfig.json",
 		"typecheck": "tsc --noEmit",
 		"prepare": "npm run build",
+		"patch": "npm version patch",
 		"publish:npm": "npm publish",
 		"publish:gh": "npm publish --registry=https://npm.pkg.github.com"
 	},