use std::sync::Arc; use gpui::Transformation;use gpui::{App, IntoElement, Rems, RenderOnce, Size, Styled, Window, svg};use serde::{Deserialize, Serialize};use strum::{EnumIter, EnumString, IntoStaticStr}; use crate::Color;use crate::prelude::*;use crate::traits::transformable::Transformable; #[derive(    Debug, PartialEq, Eq, Copy, Clone, EnumIter, EnumString, IntoStaticStr, Serialize, Deserialize,)]#[strum(serialize_all = "snake_case")]pub enum VectorName {    AcpGrid,    AcpLogo,    AcpLogoSerif,    AiGrid,    DebuggerGrid,    Grid,    ProTrialStamp,    ProUserStamp,    ZedLogo,    ZedXCopilot,} impl VectorName {    /// Returns the path to this vector image.    pub fn path(&self) -> Arc<str> {        let file_stem: &'static str = self.into();        format!("images/{file_stem}.svg").into()    }} /// A vector image, such as an SVG.////// A [`Vector`] is different from an [`crate::Icon`] in that it is intended/// to be displayed at a specific size, or series of sizes, rather/// than conforming to the standard size of an icon.#[derive(IntoElement, RegisterComponent)]pub struct Vector {    path: Arc<str>,    color: Color,    size: Size<Rems>,    transformation: Transformation,} impl Vector {    /// Creates a new [`Vector`] image with the given [`VectorName`] and size.    pub fn new(vector: VectorName, width: Rems, height: Rems) -> Self {        Self {            path: vector.path(),            color: Color::default(),            size: Size { width, height },            transformation: Transformation::default(),        }    }     /// Creates a new [`Vector`] image where the width and height are the same.    pub fn square(vector: VectorName, size: Rems) -> Self {        Self::new(vector, size, size)    }     /// Sets the vector color.    pub fn color(mut self, color: Color) -> Self {        self.color = color;        self    }     /// Sets the vector size.    pub fn size(mut self, size: impl Into<Size<Rems>>) -> Self {        let size = size.into();        self.size = size;        self    }} impl Transformable for Vector {    fn transform(mut self, transformation: Transformation) -> Self {        self.transformation = transformation;        self    }} impl RenderOnce for Vector {    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {        let width = self.size.width;        let height = self.size.height;         svg()            // By default, prevent the SVG from stretching            // to fill its container.            .flex_none()            .w(width)            .h(height)            .path(self.path)            .text_color(self.color.color(cx))            .with_transformation(self.transformation)    }} impl Component for Vector {    fn scope() -> ComponentScope {        ComponentScope::Images    }     fn name() -> &'static str {        "Vector"    }     fn description() -> Option<&'static str> {        Some("A vector image component that can be displayed at specific sizes.")    }     fn preview(_window: &mut Window, _cx: &mut App) -> Option<AnyElement> {        let size = rems_from_px(60.);         Some(            v_flex()                .gap_6()                .children(vec![                    example_group_with_title(                        "Basic Usage",                        vec![                            single_example(                                "Default",                                Vector::square(VectorName::ZedLogo, size).into_any_element(),                            ),                            single_example(                                "Custom Size",                                h_flex()                                    .h(rems_from_px(120.))                                    .justify_center()                                    .child(Vector::new(                                        VectorName::ZedLogo,                                        rems_from_px(120.),                                        rems_from_px(200.),                                    ))                                    .into_any_element(),                            ),                        ],                    ),                    example_group_with_title(                        "Colored",                        vec![                            single_example(                                "Accent Color",                                Vector::square(VectorName::ZedLogo, size)                                    .color(Color::Accent)                                    .into_any_element(),                            ),                            single_example(                                "Error Color",                                Vector::square(VectorName::ZedLogo, size)                                    .color(Color::Error)                                    .into_any_element(),                            ),                        ],                    ),                    example_group_with_title(                        "Different Vectors",                        vec![single_example(                            "Zed X Copilot",                            Vector::square(VectorName::ZedXCopilot, rems_from_px(100.))                                .into_any_element(),                        )],                    ),                ])                .into_any_element(),        )    }} #[cfg(test)]mod tests {    use super::*;     #[test]    fn vector_path() {        assert_eq!(VectorName::ZedLogo.path().as_ref(), "images/zed_logo.svg");    }}