Enum Component

pub enum Component {
    String(String),
    Array(Vec<Component>),
    Object(Box<ComponentObject>),
}

Represents a Minecraft text component. Allows de/serialization using Serde with JSON.

Variants

String(String)

Simple string component (shorthand for {text: "value"})

Array(Vec<Component>)

Array of components (shorthand for first component with extras)

Object(Box<ComponentObject>)

Full component object with properties

Implementations

impl Component

pub fn text(text: impl AsRef<str>) -> Self

Creates a plain text component

Examples found in repository

src/lib.rs (line 567)

    pub fn append_newline(self) -> Self {
        self.append(Component::text("\n"))
    }

    /// Appends a space character
    pub fn append_space(self) -> Self {
        self.append(Component::text(" "))
    }

src/minimessage.rs (line 136)

    fn parse_text(&mut self) -> Result<(), MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            if self.starts_with('<') || (self.config.parse_legacy_colors && self.starts_with('&')) {
                break;
            }
            self.position += 1;
        }

        if start < self.position {
            let text = &self.input[start..self.position];
            let current_style = self.current_style();
            let mut comp = Component::text(text);
            comp = comp.color(current_style.color.clone());
            comp = comp.decorations(&self.collect_decorations());
            self.component_parts.push(comp);
        }
        Ok(())
    }

    fn parse_tag(&mut self) -> Result<(), MiniMessageError> {
        // Skip '<'
        self.position += 1;

        if self.starts_with('/') {
            // Closing tag
            self.position += 1;
            let tag_name = self.read_tag_name()?;
            self.handle_close_tag(&tag_name)?;
            self.expect('>')?;
        } else {
            // Opening tag
            let tag_name = self.read_tag_name()?;
            let mut args = Vec::new();
            let mut self_closing = false;

            while self.position < self.input.len() {
                // skip whitespace
                self.skip_whitespace();
                // skip colon separators
                while self.starts_with(':') {
                    self.position += 1;
                    self.skip_whitespace();
                }

                // if we’ve hit the end of the tag, stop
                if self.starts_with('>') || self.starts_with('/') {
                    break;
                }

                // read an argument
                let arg = self.read_argument()?;
                args.push(arg);
            }

            // Check for self-closing tag
            if self.starts_with('/') {
                self.position += 1;
                self_closing = true;
            }
            self.expect('>')?;

            self.handle_open_tag(&tag_name, args, self_closing)?;
        }

        Ok(())
    }

    fn read_tag_name(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if !c.is_ascii_alphanumeric() && c != '_' && c != '-' {
                break;
            }
            self.position += 1;
        }
        if start == self.position {
            return Err(MiniMessageError("Expected tag name".to_string()));
        }
        Ok(self.input[start..self.position].to_lowercase())
    }

    fn read_argument(&mut self) -> Result<String, MiniMessageError> {
        if self.starts_with('\'') || self.starts_with('"') {
            self.read_quoted_string()
        } else {
            self.read_unquoted_string()
        }
    }

    fn read_quoted_string(&mut self) -> Result<String, MiniMessageError> {
        let quote_char = self.current_char();
        self.position += 1;

        let mut escaped = false;
        let mut result = String::new();

        while self.position < self.input.len() {
            let c = self.current_char();
            if escaped {
                result.push(c);
                escaped = false;
            } else if c == '\\' {
                escaped = true;
            } else if c == quote_char {
                self.position += 1;
                return Ok(result);
            } else {
                result.push(c);
            }
            self.position += 1;
        }

        Err(MiniMessageError("Unterminated quoted string".to_string()))
    }

    fn read_unquoted_string(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if c == ':' || c == '>' || c == '/' || c.is_whitespace() {
                break;
            }
            self.position += 1;
        }
        // what?
        // if start == self.position {
        //     return Err(MiniMessageError("Expected argument".to_string()));
        // }
        Ok(self.input[start..self.position].to_string())
    }

    fn handle_open_tag(
        &mut self,
        tag: &str,
        args: Vec<String>,
        self_closing: bool,
    ) -> Result<(), MiniMessageError> {
        match tag {
            // Colors
            "black" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Black)))?,
            "dark_blue" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkBlue)))?
            }
            "dark_green" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGreen)))?
            }
            "dark_aqua" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkAqua)))?
            }
            "dark_red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkRed)))?,
            "dark_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkPurple)))?
            }
            "gold" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gold)))?,
            "gray" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gray)))?,
            "dark_gray" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGray)))?
            }
            "blue" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Blue)))?,
            "green" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Green)))?,
            "aqua" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Aqua)))?,
            "red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Red)))?,
            "light_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::LightPurple)))?
            }
            "yellow" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Yellow)))?,
            "white" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::White)))?,
            "color" | "colour" | "c" if !args.is_empty() => {
                if let Some(color) = args[0].parse::<Color>().ok() {
                    self.push_style(|s| s.color = Some(color))?
                }
            }

            // Decorations
            "bold" | "b" => self.push_style(|s| s.bold = Some(true))?,
            "italic" | "i" | "em" => self.push_style(|s| s.italic = Some(true))?,
            "underlined" | "u" => self.push_style(|s| s.underlined = Some(true))?,
            "strikethrough" | "st" => self.push_style(|s| s.strikethrough = Some(true))?,
            "obfuscated" | "obf" => self.push_style(|s| s.obfuscated = Some(true))?,

            // Reset tag
            "reset" => self.reset_style()?,

            // Click events
            "click" if args.len() >= 2 => {
                let action = args[0].as_str();
                let value = args[1].as_str();
                match action {
                    "run_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::RunCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "suggest_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::SuggestCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "open_url" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::OpenUrl {
                            url: value.to_string(),
                        })
                    })?,
                    "copy_to_clipboard" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::CopyToClipboard {
                            value: value.to_string(),
                        })
                    })?,
                    _ => {}
                }
            }

            // Hover events
            "hover" if !args.is_empty() => {
                let action = args[0].as_str();
                if action == "show_text" && args.len() >= 2 {
                    let mut nested_parser = Parser::new(&args[1], self.config);
                    let nested = nested_parser.parse()?;
                    self.push_style(|s| {
                        s.hover_event = Some(HoverEvent::ShowText { value: nested })
                    })?;
                }
            }

            // Newline
            "newline" | "br" => {
                self.component_parts.push(Component::text("\n"));
            }

            // Insertion
            "insert" | "insertion" if !args.is_empty() => {
                self.push_style(|s| s.insertion = Some(args[0].clone()))?
            }

            // Handle self-closing tags
            _ if self_closing => {
                // For self-closing tags, create an empty component with the style
                let current_style = self.current_style();
                let mut comp = Component::text("");
                comp = comp.color(current_style.color.clone());
                comp = comp.decorations(&self.collect_decorations());
                self.component_parts.push(comp);
            }

            // Unknown tags are treated as text
            _ => {
                let mut tag_text = format!("<{tag}");
                for arg in args {
                    tag_text.push(':');
                    tag_text.push_str(&arg);
                }
                if self_closing {
                    tag_text.push('/');
                }
                tag_text.push('>');
                self.component_parts
                    .push(Component::text(tag_text).apply_fallback_style(self.current_style()));
            }
        }

        Ok(())
    }

pub fn append<C: Into<Component>>(self, component: C) -> Self

Appends a child component

Examples found in repository

src/lib.rs (line 567)

    pub fn append_newline(self) -> Self {
        self.append(Component::text("\n"))
    }

    /// Appends a space character
    pub fn append_space(self) -> Self {
        self.append(Component::text(" "))
    }

pub fn append_newline(self) -> Self

Appends a newline character

pub fn append_space(self) -> Self

Appends a space character

pub fn to_plain_text(&self) -> Cow<'_, str>

Returns the “plain text” representation of this component as a Cow<str>.

This is the closest equivalent to Kyori’s plain text serializer

Behavior by variant

• Component::String: Returns a borrowed &str of the string content.
• Component::Object:
  • If the object has text and no extra children, returns a borrowed &str.
  • If the object has extra children, returns an owned String concatenating the object’s text (if any) with the to_plain_text of each child.
• Component::Array: Returns an owned String concatenating the to_plain_text of each element in the array.

Notes

This method may allocate a new String if concatenation is needed.
Use Self::get_plain_text if you only need a cheap, O(1) borrowed string from a single component.

Examples found in repository

src/lib.rs (line 609)

    pub fn to_plain_text(&self) -> Cow<'_, str> {
        match self {
            Component::String(s) => Cow::Borrowed(s),
            Component::Object(obj) => {
                if obj.extra.is_none()
                    && let Some(text) = &obj.text
                {
                    return Cow::Borrowed(text);
                }

                let mut result = String::new();
                if let Some(text) = &obj.text {
                    result.push_str(text);
                }
                if let Some(children) = &obj.extra {
                    for child in children {
                        result.push_str(&child.to_plain_text());
                    }
                }
                Cow::Owned(result)
            }
            Component::Array(components) => {
                let mut result = String::new();
                for c in components {
                    result.push_str(&c.to_plain_text());
                }
                Cow::Owned(result)
            }
        }
    }

pub fn get_plain_text(&self) -> Option<&str>

Returns the raw text field if this component is a string or an object with a text field.

Does not traverse children or consider other fields. Cheap, O(1) operation alternative to Self::to_plain_text.

pub fn apply_fallback_style(self, fallback: &Style) -> Self

Applies fallback styles to unset properties

Examples found in repository

src/lib.rs (line 649)

    pub fn apply_fallback_style(self, fallback: &Style) -> Self {
        match self {
            Component::String(s) => {
                let mut obj = ComponentObject {
                    content_type: Some(ContentType::Text),
                    text: Some(s),
                    ..Default::default()
                };
                obj.merge_style(fallback);
                Component::Object(Box::new(obj))
            }
            Component::Array(vec) => Component::Array(
                vec.into_iter()
                    .map(|c| c.apply_fallback_style(fallback))
                    .collect(),
            ),
            Component::Object(mut obj) => {
                obj.merge_style(fallback);
                if let Some(extras) = obj.extra {
                    obj.extra = Some(
                        extras
                            .into_iter()
                            .map(|c| c.apply_fallback_style(fallback))
                            .collect(),
                    );
                }
                Component::Object(obj)
            }
        }
    }

src/minimessage.rs (line 382)

    fn handle_open_tag(
        &mut self,
        tag: &str,
        args: Vec<String>,
        self_closing: bool,
    ) -> Result<(), MiniMessageError> {
        match tag {
            // Colors
            "black" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Black)))?,
            "dark_blue" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkBlue)))?
            }
            "dark_green" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGreen)))?
            }
            "dark_aqua" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkAqua)))?
            }
            "dark_red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkRed)))?,
            "dark_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkPurple)))?
            }
            "gold" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gold)))?,
            "gray" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gray)))?,
            "dark_gray" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGray)))?
            }
            "blue" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Blue)))?,
            "green" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Green)))?,
            "aqua" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Aqua)))?,
            "red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Red)))?,
            "light_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::LightPurple)))?
            }
            "yellow" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Yellow)))?,
            "white" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::White)))?,
            "color" | "colour" | "c" if !args.is_empty() => {
                if let Some(color) = args[0].parse::<Color>().ok() {
                    self.push_style(|s| s.color = Some(color))?
                }
            }

            // Decorations
            "bold" | "b" => self.push_style(|s| s.bold = Some(true))?,
            "italic" | "i" | "em" => self.push_style(|s| s.italic = Some(true))?,
            "underlined" | "u" => self.push_style(|s| s.underlined = Some(true))?,
            "strikethrough" | "st" => self.push_style(|s| s.strikethrough = Some(true))?,
            "obfuscated" | "obf" => self.push_style(|s| s.obfuscated = Some(true))?,

            // Reset tag
            "reset" => self.reset_style()?,

            // Click events
            "click" if args.len() >= 2 => {
                let action = args[0].as_str();
                let value = args[1].as_str();
                match action {
                    "run_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::RunCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "suggest_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::SuggestCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "open_url" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::OpenUrl {
                            url: value.to_string(),
                        })
                    })?,
                    "copy_to_clipboard" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::CopyToClipboard {
                            value: value.to_string(),
                        })
                    })?,
                    _ => {}
                }
            }

            // Hover events
            "hover" if !args.is_empty() => {
                let action = args[0].as_str();
                if action == "show_text" && args.len() >= 2 {
                    let mut nested_parser = Parser::new(&args[1], self.config);
                    let nested = nested_parser.parse()?;
                    self.push_style(|s| {
                        s.hover_event = Some(HoverEvent::ShowText { value: nested })
                    })?;
                }
            }

            // Newline
            "newline" | "br" => {
                self.component_parts.push(Component::text("\n"));
            }

            // Insertion
            "insert" | "insertion" if !args.is_empty() => {
                self.push_style(|s| s.insertion = Some(args[0].clone()))?
            }

            // Handle self-closing tags
            _ if self_closing => {
                // For self-closing tags, create an empty component with the style
                let current_style = self.current_style();
                let mut comp = Component::text("");
                comp = comp.color(current_style.color.clone());
                comp = comp.decorations(&self.collect_decorations());
                self.component_parts.push(comp);
            }

            // Unknown tags are treated as text
            _ => {
                let mut tag_text = format!("<{tag}");
                for arg in args {
                    tag_text.push(':');
                    tag_text.push_str(&arg);
                }
                if self_closing {
                    tag_text.push('/');
                }
                tag_text.push('>');
                self.component_parts
                    .push(Component::text(tag_text).apply_fallback_style(self.current_style()));
            }
        }

        Ok(())
    }

pub fn color(self, color: Option<Color>) -> Self

Sets text color

Examples found in repository

src/minimessage.rs (line 137)

    fn parse_text(&mut self) -> Result<(), MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            if self.starts_with('<') || (self.config.parse_legacy_colors && self.starts_with('&')) {
                break;
            }
            self.position += 1;
        }

        if start < self.position {
            let text = &self.input[start..self.position];
            let current_style = self.current_style();
            let mut comp = Component::text(text);
            comp = comp.color(current_style.color.clone());
            comp = comp.decorations(&self.collect_decorations());
            self.component_parts.push(comp);
        }
        Ok(())
    }

    fn parse_tag(&mut self) -> Result<(), MiniMessageError> {
        // Skip '<'
        self.position += 1;

        if self.starts_with('/') {
            // Closing tag
            self.position += 1;
            let tag_name = self.read_tag_name()?;
            self.handle_close_tag(&tag_name)?;
            self.expect('>')?;
        } else {
            // Opening tag
            let tag_name = self.read_tag_name()?;
            let mut args = Vec::new();
            let mut self_closing = false;

            while self.position < self.input.len() {
                // skip whitespace
                self.skip_whitespace();
                // skip colon separators
                while self.starts_with(':') {
                    self.position += 1;
                    self.skip_whitespace();
                }

                // if we’ve hit the end of the tag, stop
                if self.starts_with('>') || self.starts_with('/') {
                    break;
                }

                // read an argument
                let arg = self.read_argument()?;
                args.push(arg);
            }

            // Check for self-closing tag
            if self.starts_with('/') {
                self.position += 1;
                self_closing = true;
            }
            self.expect('>')?;

            self.handle_open_tag(&tag_name, args, self_closing)?;
        }

        Ok(())
    }

    fn read_tag_name(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if !c.is_ascii_alphanumeric() && c != '_' && c != '-' {
                break;
            }
            self.position += 1;
        }
        if start == self.position {
            return Err(MiniMessageError("Expected tag name".to_string()));
        }
        Ok(self.input[start..self.position].to_lowercase())
    }

    fn read_argument(&mut self) -> Result<String, MiniMessageError> {
        if self.starts_with('\'') || self.starts_with('"') {
            self.read_quoted_string()
        } else {
            self.read_unquoted_string()
        }
    }

    fn read_quoted_string(&mut self) -> Result<String, MiniMessageError> {
        let quote_char = self.current_char();
        self.position += 1;

        let mut escaped = false;
        let mut result = String::new();

        while self.position < self.input.len() {
            let c = self.current_char();
            if escaped {
                result.push(c);
                escaped = false;
            } else if c == '\\' {
                escaped = true;
            } else if c == quote_char {
                self.position += 1;
                return Ok(result);
            } else {
                result.push(c);
            }
            self.position += 1;
        }

        Err(MiniMessageError("Unterminated quoted string".to_string()))
    }

    fn read_unquoted_string(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if c == ':' || c == '>' || c == '/' || c.is_whitespace() {
                break;
            }
            self.position += 1;
        }
        // what?
        // if start == self.position {
        //     return Err(MiniMessageError("Expected argument".to_string()));
        // }
        Ok(self.input[start..self.position].to_string())
    }

    fn handle_open_tag(
        &mut self,
        tag: &str,
        args: Vec<String>,
        self_closing: bool,
    ) -> Result<(), MiniMessageError> {
        match tag {
            // Colors
            "black" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Black)))?,
            "dark_blue" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkBlue)))?
            }
            "dark_green" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGreen)))?
            }
            "dark_aqua" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkAqua)))?
            }
            "dark_red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkRed)))?,
            "dark_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkPurple)))?
            }
            "gold" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gold)))?,
            "gray" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gray)))?,
            "dark_gray" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGray)))?
            }
            "blue" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Blue)))?,
            "green" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Green)))?,
            "aqua" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Aqua)))?,
            "red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Red)))?,
            "light_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::LightPurple)))?
            }
            "yellow" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Yellow)))?,
            "white" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::White)))?,
            "color" | "colour" | "c" if !args.is_empty() => {
                if let Some(color) = args[0].parse::<Color>().ok() {
                    self.push_style(|s| s.color = Some(color))?
                }
            }

            // Decorations
            "bold" | "b" => self.push_style(|s| s.bold = Some(true))?,
            "italic" | "i" | "em" => self.push_style(|s| s.italic = Some(true))?,
            "underlined" | "u" => self.push_style(|s| s.underlined = Some(true))?,
            "strikethrough" | "st" => self.push_style(|s| s.strikethrough = Some(true))?,
            "obfuscated" | "obf" => self.push_style(|s| s.obfuscated = Some(true))?,

            // Reset tag
            "reset" => self.reset_style()?,

            // Click events
            "click" if args.len() >= 2 => {
                let action = args[0].as_str();
                let value = args[1].as_str();
                match action {
                    "run_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::RunCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "suggest_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::SuggestCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "open_url" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::OpenUrl {
                            url: value.to_string(),
                        })
                    })?,
                    "copy_to_clipboard" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::CopyToClipboard {
                            value: value.to_string(),
                        })
                    })?,
                    _ => {}
                }
            }

            // Hover events
            "hover" if !args.is_empty() => {
                let action = args[0].as_str();
                if action == "show_text" && args.len() >= 2 {
                    let mut nested_parser = Parser::new(&args[1], self.config);
                    let nested = nested_parser.parse()?;
                    self.push_style(|s| {
                        s.hover_event = Some(HoverEvent::ShowText { value: nested })
                    })?;
                }
            }

            // Newline
            "newline" | "br" => {
                self.component_parts.push(Component::text("\n"));
            }

            // Insertion
            "insert" | "insertion" if !args.is_empty() => {
                self.push_style(|s| s.insertion = Some(args[0].clone()))?
            }

            // Handle self-closing tags
            _ if self_closing => {
                // For self-closing tags, create an empty component with the style
                let current_style = self.current_style();
                let mut comp = Component::text("");
                comp = comp.color(current_style.color.clone());
                comp = comp.decorations(&self.collect_decorations());
                self.component_parts.push(comp);
            }

            // Unknown tags are treated as text
            _ => {
                let mut tag_text = format!("<{tag}");
                for arg in args {
                    tag_text.push(':');
                    tag_text.push_str(&arg);
                }
                if self_closing {
                    tag_text.push('/');
                }
                tag_text.push('>');
                self.component_parts
                    .push(Component::text(tag_text).apply_fallback_style(self.current_style()));
            }
        }

        Ok(())
    }

pub fn font(self, font: Option<String>) -> Self

Sets font

pub fn decoration(self, decoration: TextDecoration, state: Option<bool>) -> Self

Sets text decoration state

pub fn decorations( self, decorations: &HashMap<TextDecoration, Option<bool>>, ) -> Self

Sets multiple decorations at once

Examples found in repository

src/minimessage.rs (line 138)

    fn parse_text(&mut self) -> Result<(), MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            if self.starts_with('<') || (self.config.parse_legacy_colors && self.starts_with('&')) {
                break;
            }
            self.position += 1;
        }

        if start < self.position {
            let text = &self.input[start..self.position];
            let current_style = self.current_style();
            let mut comp = Component::text(text);
            comp = comp.color(current_style.color.clone());
            comp = comp.decorations(&self.collect_decorations());
            self.component_parts.push(comp);
        }
        Ok(())
    }

    fn parse_tag(&mut self) -> Result<(), MiniMessageError> {
        // Skip '<'
        self.position += 1;

        if self.starts_with('/') {
            // Closing tag
            self.position += 1;
            let tag_name = self.read_tag_name()?;
            self.handle_close_tag(&tag_name)?;
            self.expect('>')?;
        } else {
            // Opening tag
            let tag_name = self.read_tag_name()?;
            let mut args = Vec::new();
            let mut self_closing = false;

            while self.position < self.input.len() {
                // skip whitespace
                self.skip_whitespace();
                // skip colon separators
                while self.starts_with(':') {
                    self.position += 1;
                    self.skip_whitespace();
                }

                // if we’ve hit the end of the tag, stop
                if self.starts_with('>') || self.starts_with('/') {
                    break;
                }

                // read an argument
                let arg = self.read_argument()?;
                args.push(arg);
            }

            // Check for self-closing tag
            if self.starts_with('/') {
                self.position += 1;
                self_closing = true;
            }
            self.expect('>')?;

            self.handle_open_tag(&tag_name, args, self_closing)?;
        }

        Ok(())
    }

    fn read_tag_name(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if !c.is_ascii_alphanumeric() && c != '_' && c != '-' {
                break;
            }
            self.position += 1;
        }
        if start == self.position {
            return Err(MiniMessageError("Expected tag name".to_string()));
        }
        Ok(self.input[start..self.position].to_lowercase())
    }

    fn read_argument(&mut self) -> Result<String, MiniMessageError> {
        if self.starts_with('\'') || self.starts_with('"') {
            self.read_quoted_string()
        } else {
            self.read_unquoted_string()
        }
    }

    fn read_quoted_string(&mut self) -> Result<String, MiniMessageError> {
        let quote_char = self.current_char();
        self.position += 1;

        let mut escaped = false;
        let mut result = String::new();

        while self.position < self.input.len() {
            let c = self.current_char();
            if escaped {
                result.push(c);
                escaped = false;
            } else if c == '\\' {
                escaped = true;
            } else if c == quote_char {
                self.position += 1;
                return Ok(result);
            } else {
                result.push(c);
            }
            self.position += 1;
        }

        Err(MiniMessageError("Unterminated quoted string".to_string()))
    }

    fn read_unquoted_string(&mut self) -> Result<String, MiniMessageError> {
        let start = self.position;
        while self.position < self.input.len() {
            let c = self.current_char();
            if c == ':' || c == '>' || c == '/' || c.is_whitespace() {
                break;
            }
            self.position += 1;
        }
        // what?
        // if start == self.position {
        //     return Err(MiniMessageError("Expected argument".to_string()));
        // }
        Ok(self.input[start..self.position].to_string())
    }

    fn handle_open_tag(
        &mut self,
        tag: &str,
        args: Vec<String>,
        self_closing: bool,
    ) -> Result<(), MiniMessageError> {
        match tag {
            // Colors
            "black" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Black)))?,
            "dark_blue" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkBlue)))?
            }
            "dark_green" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGreen)))?
            }
            "dark_aqua" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkAqua)))?
            }
            "dark_red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkRed)))?,
            "dark_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkPurple)))?
            }
            "gold" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gold)))?,
            "gray" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Gray)))?,
            "dark_gray" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::DarkGray)))?
            }
            "blue" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Blue)))?,
            "green" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Green)))?,
            "aqua" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Aqua)))?,
            "red" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Red)))?,
            "light_purple" => {
                self.push_style(|s| s.color = Some(Color::Named(NamedColor::LightPurple)))?
            }
            "yellow" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::Yellow)))?,
            "white" => self.push_style(|s| s.color = Some(Color::Named(NamedColor::White)))?,
            "color" | "colour" | "c" if !args.is_empty() => {
                if let Some(color) = args[0].parse::<Color>().ok() {
                    self.push_style(|s| s.color = Some(color))?
                }
            }

            // Decorations
            "bold" | "b" => self.push_style(|s| s.bold = Some(true))?,
            "italic" | "i" | "em" => self.push_style(|s| s.italic = Some(true))?,
            "underlined" | "u" => self.push_style(|s| s.underlined = Some(true))?,
            "strikethrough" | "st" => self.push_style(|s| s.strikethrough = Some(true))?,
            "obfuscated" | "obf" => self.push_style(|s| s.obfuscated = Some(true))?,

            // Reset tag
            "reset" => self.reset_style()?,

            // Click events
            "click" if args.len() >= 2 => {
                let action = args[0].as_str();
                let value = args[1].as_str();
                match action {
                    "run_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::RunCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "suggest_command" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::SuggestCommand {
                            command: value.to_string(),
                        })
                    })?,
                    "open_url" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::OpenUrl {
                            url: value.to_string(),
                        })
                    })?,
                    "copy_to_clipboard" => self.push_style(|s| {
                        s.click_event = Some(ClickEvent::CopyToClipboard {
                            value: value.to_string(),
                        })
                    })?,
                    _ => {}
                }
            }

            // Hover events
            "hover" if !args.is_empty() => {
                let action = args[0].as_str();
                if action == "show_text" && args.len() >= 2 {
                    let mut nested_parser = Parser::new(&args[1], self.config);
                    let nested = nested_parser.parse()?;
                    self.push_style(|s| {
                        s.hover_event = Some(HoverEvent::ShowText { value: nested })
                    })?;
                }
            }

            // Newline
            "newline" | "br" => {
                self.component_parts.push(Component::text("\n"));
            }

            // Insertion
            "insert" | "insertion" if !args.is_empty() => {
                self.push_style(|s| s.insertion = Some(args[0].clone()))?
            }

            // Handle self-closing tags
            _ if self_closing => {
                // For self-closing tags, create an empty component with the style
                let current_style = self.current_style();
                let mut comp = Component::text("");
                comp = comp.color(current_style.color.clone());
                comp = comp.decorations(&self.collect_decorations());
                self.component_parts.push(comp);
            }

            // Unknown tags are treated as text
            _ => {
                let mut tag_text = format!("<{tag}");
                for arg in args {
                    tag_text.push(':');
                    tag_text.push_str(&arg);
                }
                if self_closing {
                    tag_text.push('/');
                }
                tag_text.push('>');
                self.component_parts
                    .push(Component::text(tag_text).apply_fallback_style(self.current_style()));
            }
        }

        Ok(())
    }

pub fn click_event(self, event: Option<ClickEvent>) -> Self

Sets click event

pub fn hover_event(self, event: Option<HoverEvent>) -> Self

Sets hover event

pub fn insertion(self, insertion: Option<String>) -> Self

Sets insertion text

pub fn has_decoration(&self, decoration: TextDecoration) -> bool

Checks if a decoration is enabled

pub fn has_styling(&self) -> bool

Checks if any styling is present

pub fn set_children(self, children: Vec<Component>) -> Self

Sets child components

pub fn get_children(&self) -> &[Component]

Gets child components

Trait Implementations

impl Clone for Component

fn clone(&self) -> Component

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Component

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Component

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: AsRef<str>> From<T> for Component

fn from(value: T) -> Component

Converts to this type from the input type.

impl PartialEq for Component

fn eq(&self, other: &Component) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Component

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Component