Add support for label components

Author: mkrasnitski

src/builder/create_components.rs

@@ -21,8 +21,6 @@ impl<const VAL: u8> Serialize for StaticU8<VAL> {
 pub enum CreateActionRow<'a> {
     Buttons(Cow<'a, [CreateButton<'a>]>),
     SelectMenu(CreateSelectMenu<'a>),
-    /// Only valid in modals!
-    InputText(CreateInputText<'a>),
 }
 
 impl<'a> CreateActionRow<'a> {
@@ -33,10 +31,6 @@ impl<'a> CreateActionRow<'a> {
     pub fn select_menu(select_menu: impl Into<CreateSelectMenu<'a>>) -> Self {
         Self::SelectMenu(select_menu.into())
     }
-
-    pub fn input_text(input_text: impl Into<CreateInputText<'a>>) -> Self {
-        Self::InputText(input_text.into())
-    }
 }
 
 impl serde::Serialize for CreateActionRow<'_> {
@@ -49,7 +43,6 @@ impl serde::Serialize for CreateActionRow<'_> {
         match self {
             CreateActionRow::Buttons(buttons) => map.serialize_entry("components", &buttons)?,
             CreateActionRow::SelectMenu(select) => map.serialize_entry("components", &[select])?,
-            CreateActionRow::InputText(input) => map.serialize_entry("components", &[input])?,
         }
 
         map.end()
@@ -105,6 +98,10 @@ pub enum CreateComponent<'a> {
     ///
     /// A container is a flexible component that can hold multiple nested components.
     Container(CreateContainer<'a>),
+    /// Represents a label component (V2).
+    ///
+    /// A label is used to hold other components in a modal.
+    Label(CreateLabel<'a>),
 }
 
 /// A builder to create a section component, supports up to a max of **3** components with an
@@ -501,6 +498,54 @@ impl<'a> CreateContainer<'a> {
     }
 }
 
+/// A builder for creating a label that can hold an [`InputText`] or [`SelectMenu`].
+#[derive(Clone, Debug, Serialize)]
+#[must_use]
+pub struct CreateLabel<'a> {
+    #[serde(rename = "type")]
+    kind: StaticU8<18>,
+    label: Cow<'a, str>,
+    description: Option<Cow<'a, str>>,
+    component: CreateLabelComponent<'a>,
+}
+
+impl<'a> CreateLabel<'a> {
+    /// Create a select menu with a specific label.
+    pub fn select_menu(label: impl Into<Cow<'a, str>>, select_menu: CreateSelectMenu<'a>) -> Self {
+        Self {
+            kind: StaticU8::<18>,
+            label: label.into(),
+            description: None,
+            component: CreateLabelComponent::SelectMenu(select_menu),
+        }
+    }
+
+    /// Create a text input with a specific label.
+    pub fn input_text(label: impl Into<Cow<'a, str>>, input_text: CreateInputText<'a>) -> Self {
+        Self {
+            kind: StaticU8::<18>,
+            label: label.into(),
+            description: None,
+            component: CreateLabelComponent::InputText(input_text),
+        }
+    }
+
+    /// Sets the description of this component, which will display underneath the label text.
+    pub fn description(mut self, description: impl Into<Cow<'a, str>>) -> Self {
+        self.description = Some(description.into());
+        self
+    }
+}
+
+/// An enum of all valid label components.
+#[derive(Clone, Debug, Serialize)]
+#[must_use]
+#[serde(untagged)]
+enum CreateLabelComponent<'a> {
+    SelectMenu(CreateSelectMenu<'a>),
+    InputText(CreateInputText<'a>),
+}
+
 enum_number! {
     #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Deserialize, Serialize)]
     #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
@@ -893,7 +938,6 @@ pub struct CreateInputText<'a> {
     kind: ComponentType,
     custom_id: Cow<'a, str>,
     style: InputTextStyle,
-    label: Option<Cow<'a, str>>,
     min_length: Option<u16>,
     max_length: Option<u16>,
     required: bool,
@@ -906,14 +950,9 @@ pub struct CreateInputText<'a> {
 impl<'a> CreateInputText<'a> {
     /// Creates a text input with the given style, label, and custom id (a developer-defined
     /// identifier), leaving all other fields empty.
-    pub fn new(
-        style: InputTextStyle,
-        label: impl Into<Cow<'a, str>>,
-        custom_id: impl Into<Cow<'a, str>>,
-    ) -> Self {
+    pub fn new(style: InputTextStyle, custom_id: impl Into<Cow<'a, str>>) -> Self {
         Self {
             style,
-            label: Some(label.into()),
             custom_id: custom_id.into(),
 
             placeholder: None,
@@ -932,12 +971,6 @@ impl<'a> CreateInputText<'a> {
         self
     }
 
-    /// Sets the label of this input text. Replaces the current value as set in [`Self::new`].
-    pub fn label(mut self, label: impl Into<Cow<'a, str>>) -> Self {
-        self.label = Some(label.into());
-        self
-    }
-
     /// Sets the custom id of the input text, a developer-defined identifier. Replaces the current
     /// value as set in [`Self::new`].
     pub fn custom_id(mut self, id: impl Into<Cow<'a, str>>) -> Self {

src/builder/create_interaction_response.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 
 use super::create_poll::Ready;
 use super::{
-    CreateActionRow,
     CreateAllowedMentions,
     CreateAttachment,
     CreateComponent,
@@ -424,7 +423,7 @@ impl<'a> CreateAutocompleteResponse<'a> {
 #[derive(Clone, Debug, Default, Serialize)]
 #[must_use]
 pub struct CreateModal<'a> {
-    components: Cow<'a, [CreateActionRow<'a>]>,
+    components: Cow<'a, [CreateComponent<'a>]>,
     custom_id: Cow<'a, str>,
     title: Cow<'a, str>,
 }
@@ -442,7 +441,7 @@ impl<'a> CreateModal<'a> {
     /// Sets the components of this message.
     ///
     /// Overwrites existing components.
-    pub fn components(mut self, components: impl Into<Cow<'a, [CreateActionRow<'a>]>>) -> Self {
+    pub fn components(mut self, components: impl Into<Cow<'a, [CreateComponent<'a>]>>) -> Self {
         self.components = components.into();
         self
     }

src/collector/quick_modal.rs

@@ -1,6 +1,13 @@
 use std::borrow::Cow;
 
-use crate::builder::{CreateActionRow, CreateInputText, CreateInteractionResponse, CreateModal};
+use crate::builder::{
+    CreateComponent,
+    CreateInputText,
+    CreateInteractionResponse,
+    CreateLabel,
+    CreateModal,
+    CreateTextDisplay,
+};
 use crate::collector::ModalInteractionCollector;
 use crate::gateway::client::Context;
 use crate::internal::prelude::*;
@@ -31,15 +38,15 @@ pub struct QuickModalResponse {
 pub struct CreateQuickModal<'a> {
     title: Cow<'a, str>,
     timeout: Option<std::time::Duration>,
-    input_texts: Vec<CreateInputText<'a>>,
+    components: Vec<CreateComponent<'a>>,
 }
 
 impl<'a> CreateQuickModal<'a> {
     pub fn new(title: impl Into<Cow<'a, str>>) -> Self {
         Self {
             title: title.into(),
             timeout: None,
-            input_texts: Vec::new(),
+            components: Vec::new(),
         }
     }
 
@@ -52,27 +59,40 @@ impl<'a> CreateQuickModal<'a> {
         self
     }
 
+    /// Adds a text display field.
+    pub fn text(mut self, content: impl Into<Cow<'a, str>>) -> Self {
+        self.components.push(CreateComponent::TextDisplay(CreateTextDisplay::new(content)));
+        self
+    }
+
     /// Adds an input text field.
-    ///
-    /// As the `custom_id` field of [`CreateInputText`], just supply an empty string. All custom
-    /// IDs are overwritten by [`CreateQuickModal`] when sending the modal.
-    pub fn field(mut self, input_text: CreateInputText<'a>) -> Self {
-        self.input_texts.push(input_text);
+    pub fn field(
+        mut self,
+        label: impl Into<Cow<'a, str>>,
+        input_text: CreateInputText<'a>,
+    ) -> Self {
+        self.components.push(CreateComponent::Label(
+            CreateLabel::input_text(label, input_text).description("test"),
+        ));
         self
     }
 
     /// Convenience method to add a single-line input text field.
     ///
     /// Wraps [`Self::field`].
     pub fn short_field(self, label: impl Into<Cow<'a, str>>) -> Self {
-        self.field(CreateInputText::new(InputTextStyle::Short, label, ""))
+        let input_text =
+            CreateInputText::new(InputTextStyle::Short, self.components.len().to_string());
+        self.field(label, input_text)
     }
 
     /// Convenience method to add a multi-line input text field.
     ///
     /// Wraps [`Self::field`].
     pub fn paragraph_field(self, label: impl Into<Cow<'a, str>>) -> Self {
-        self.field(CreateInputText::new(InputTextStyle::Paragraph, label, ""))
+        let input_text =
+            CreateInputText::new(InputTextStyle::Paragraph, self.components.len().to_string());
+        self.field(label, input_text)
     }
 
     /// # Errors
@@ -84,22 +104,13 @@ impl<'a> CreateQuickModal<'a> {
         interaction_id: InteractionId,
         token: &str,
     ) -> Result<Option<QuickModalResponse>, crate::Error> {
-        let modal_custom_id = interaction_id.to_arraystring();
         let builder = CreateInteractionResponse::Modal(
-            CreateModal::new(modal_custom_id.as_str(), self.title).components(
-                self.input_texts
-                    .into_iter()
-                    .enumerate()
-                    .map(|(i, input_text)| {
-                        CreateActionRow::InputText(input_text.custom_id(i.to_string()))
-                    })
-                    .collect::<Vec<_>>(),
-            ),
+            CreateModal::new(interaction_id.to_string(), self.title).components(self.components),
         );
         builder.execute(&ctx.http, interaction_id, token).await?;
 
         let collector = ModalInteractionCollector::new(ctx)
-            .custom_ids(vec![FixedString::from_str_trunc(&modal_custom_id)]);
+            .custom_ids(vec![FixedString::from_str_trunc(&interaction_id.to_string())]);
 
         let collector = match self.timeout {
             Some(timeout) => collector.timeout(timeout),
@@ -114,23 +125,22 @@ impl<'a> CreateQuickModal<'a> {
             .data
             .components
             .iter()
-            .filter_map(|row| match row.components.first() {
-                Some(ActionRowComponent::InputText(text)) => {
+            .filter_map(|component| {
+                if let Component::Label(label) = component
+                    && let LabelComponent::InputText(text) = &label.component
+                {
                     if let Some(value) = &text.value {
                         Some(value.clone())
                     } else {
                         tracing::warn!("input text value was empty in modal response");
                         None
                     }
-                },
-                Some(other) => {
-                    tracing::warn!("expected input text in modal response, got {:?}", other);
-                    None
-                },
-                None => {
-                    tracing::warn!("empty action row");
+                } else {
+                    if !matches!(component, Component::TextDisplay(_)) {
+                        tracing::warn!("expected input text in modal response, got {component:?}");
+                    }
                     None
-                },
+                }
             })
             .collect();