{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "composer",
  "type": "registry:item",
  "title": "Composer",
  "description": "A chat message box with autocomplete for mentions, channels and emoji.",
  "files": [
    {
      "path": "registry/theme/locale.rs",
      "type": "registry:file",
      "target": "~/src/ui/locale.rs",
      "content": "//! Layout direction and the built-in strings components draw.\n//!\n//! Components read the [`Direction`] from [`UiTheme::direction`] and mirror\n//! rows, insets, chevrons, popup sides and arrow keys in right-to-left\n//! layouts. Change it with [`set_direction`], which also keeps it across\n//! theme swaps.\n//!\n//! Every word a component draws or announces on its own, such as \"Close\" or\n//! \"Search emoji\", is a [`UiText`]. [`set_strings`] installs the\n//! application's translations; anything it leaves out stays English. Text the\n//! application passes in, such as a button label, is never translated here.\n\nuse std::rc::Rc;\n\nuse gpui_kit::{App, Global, SharedString, Styled, TextAlign, px};\n\nuse super::UiTheme;\n\n/// The order in which a layout reads: left to right or right to left.\n#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]\npub enum Direction {\n    /// Left to right, as in English.\n    #[default]\n    Ltr,\n    /// Right to left, as in Arabic, Hebrew, Persian and Urdu.\n    Rtl,\n}\n\nimpl Direction {\n    /// Whether this is right to left.\n    pub fn is_rtl(self) -> bool {\n        self == Self::Rtl\n    }\n\n    /// The text alignment of the reading start edge.\n    pub fn start_align(self) -> TextAlign {\n        match self {\n            Self::Ltr => TextAlign::Left,\n            Self::Rtl => TextAlign::Right,\n        }\n    }\n\n    /// The keystroke key with `left` and `right` swapped in right-to-left\n    /// layouts, so a handler written for left to right moves toward the\n    /// reading start on the start-side arrow. Other keys pass through.\n    pub fn logical_key(self, key: &str) -> &str {\n        match (self, key) {\n            (Self::Rtl, \"left\") => \"right\",\n            (Self::Rtl, \"right\") => \"left\",\n            _ => key,\n        }\n    }\n\n    /// The Kit placement mirrored for this direction: Left and Right swap in\n    /// right-to-left layouts, Top and Bottom stay.\n    pub fn placement(self, placement: gpui_kit::base::Placement) -> gpui_kit::base::Placement {\n        use gpui_kit::base::Placement;\n        match (self, placement) {\n            (Self::Rtl, Placement::Left) => Placement::Right,\n            (Self::Rtl, Placement::Right) => Placement::Left,\n            _ => placement,\n        }\n    }\n\n    /// The Kit alignment mirrored for this direction along a horizontal edge:\n    /// Start and End swap in right-to-left layouts.\n    pub fn align(self, align: gpui_kit::base::Align) -> gpui_kit::base::Align {\n        use gpui_kit::base::Align;\n        match (self, align) {\n            (Self::Rtl, Align::Start) => Align::End,\n            (Self::Rtl, Align::End) => Align::Start,\n            _ => align,\n        }\n    }\n\n    /// The popup corner mirrored for this direction: left and right corners\n    /// swap in right-to-left layouts.\n    pub fn anchor(self, anchor: gpui_kit::Anchor) -> gpui_kit::Anchor {\n        use gpui_kit::Anchor;\n        if !self.is_rtl() {\n            return anchor;\n        }\n        match anchor {\n            Anchor::TopLeft => Anchor::TopRight,\n            Anchor::TopRight => Anchor::TopLeft,\n            Anchor::BottomLeft => Anchor::BottomRight,\n            Anchor::BottomRight => Anchor::BottomLeft,\n            Anchor::LeftCenter => Anchor::RightCenter,\n            Anchor::RightCenter => Anchor::LeftCenter,\n            other => other,\n        }\n    }\n\n    /// The chevron or arrow pointing toward the reading end (`forward`) or\n    /// start, from the left-to-right `right` icon and `left` icon.\n    pub fn icon<T>(self, forward: bool, left: T, right: T) -> T {\n        if forward == self.is_rtl() {\n            left\n        } else {\n            right\n        }\n    }\n}\n\n/// The key context a right-to-left text input adds around Kit's `Input`, so\n/// the arrow keys move toward the visual side they point to.\n#[doc(hidden)]\npub const RTL_INPUT_CONTEXT: &str = \"GpuicnRtl\";\n\n/// Binds the mirrored arrow keys of right-to-left text inputs.\n#[doc(hidden)]\npub fn bind_keys(cx: &mut App) {\n    use gpui_kit::KeyBinding;\n    use gpui_kit::base::actions::{SelectLeft, SelectRight};\n    use gpui_kit::base::input::{\n        MoveLeft, MoveRight, MoveToNextWord, MoveToPreviousWord, SelectToNextWordEnd,\n        SelectToPreviousWordStart,\n    };\n    let context = Some(\"GpuicnRtl > Input\");\n    // Word movement uses Alt on macOS and Ctrl elsewhere, as in Kit.\n    let words = if cfg!(target_os = \"macos\") {\n        [\"alt-left\", \"alt-right\", \"alt-shift-left\", \"alt-shift-right\"]\n    } else {\n        [\n            \"ctrl-left\",\n            \"ctrl-right\",\n            \"ctrl-shift-left\",\n            \"ctrl-shift-right\",\n        ]\n    };\n    cx.bind_keys([\n        KeyBinding::new(\"left\", MoveRight, context),\n        KeyBinding::new(\"right\", MoveLeft, context),\n        KeyBinding::new(\"shift-left\", SelectRight, context),\n        KeyBinding::new(\"shift-right\", SelectLeft, context),\n        KeyBinding::new(words[0], MoveToNextWord, context),\n        KeyBinding::new(words[1], MoveToPreviousWord, context),\n        KeyBinding::new(words[2], SelectToNextWordEnd, context),\n        KeyBinding::new(words[3], SelectToPreviousWordStart, context),\n    ]);\n}\n\n#[derive(Clone, Copy, Default)]\nstruct DirectionState(Direction);\nimpl Global for DirectionState {}\n\n/// Sets the layout direction for every window and redraws them.\npub fn set_direction(cx: &mut App, direction: Direction) {\n    cx.set_global(DirectionState(direction));\n    if cx.has_global::<UiTheme>() {\n        let mut theme = UiTheme::read(cx).clone();\n        theme.direction = direction;\n        UiTheme::set(cx, theme);\n    }\n}\n\n/// The layout direction, left to right until [`set_direction`] says otherwise.\npub fn direction(cx: &App) -> Direction {\n    cx.try_global::<DirectionState>()\n        .map(|state| state.0)\n        .unwrap_or_default()\n}\n\n/// Wraps text the application supplies, such as a person's name, in Unicode\n/// first-strong isolates, so a right-to-left name does not reorder the\n/// punctuation and words around it, and a left-to-right name inside\n/// right-to-left text keeps its own order.\npub fn isolate(text: impl AsRef<str>) -> SharedString {\n    let text = text.as_ref();\n    if text.is_empty() || text.starts_with('\\u{2068}') {\n        return SharedString::from(text.to_owned());\n    }\n    format!(\"\\u{2068}{text}\\u{2069}\").into()\n}\n\n/// Logical inline-direction styles: start and end are left and right in\n/// left-to-right layouts and swap in right-to-left ones.\npub trait DirectionalStyled: Styled + Sized {\n    /// A flex row whose first child sits at the reading start.\n    fn flex_row_in(self, direction: Direction) -> Self {\n        let element = self.flex();\n        match direction {\n            Direction::Ltr => element.flex_row(),\n            Direction::Rtl => element.flex_row_reverse(),\n        }\n    }\n\n    /// Reverses an existing flex row in right-to-left layouts.\n    fn mirror_row(self, direction: Direction) -> Self {\n        if direction.is_rtl() {\n            self.flex_row_reverse()\n        } else {\n            self\n        }\n    }\n\n    /// Padding on the reading start edge.\n    fn padding_start(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let padding = &mut self.style().padding;\n        match direction {\n            Direction::Ltr => padding.left = Some(value.into()),\n            Direction::Rtl => padding.right = Some(value.into()),\n        }\n        self\n    }\n\n    /// Padding on the reading end edge.\n    fn padding_end(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let padding = &mut self.style().padding;\n        match direction {\n            Direction::Ltr => padding.right = Some(value.into()),\n            Direction::Rtl => padding.left = Some(value.into()),\n        }\n        self\n    }\n\n    /// Margin on the reading start edge.\n    fn margin_start(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let margin = &mut self.style().margin;\n        match direction {\n            Direction::Ltr => margin.left = Some(value.into()),\n            Direction::Rtl => margin.right = Some(value.into()),\n        }\n        self\n    }\n\n    /// Margin on the reading end edge.\n    fn margin_end(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let margin = &mut self.style().margin;\n        match direction {\n            Direction::Ltr => margin.right = Some(value.into()),\n            Direction::Rtl => margin.left = Some(value.into()),\n        }\n        self\n    }\n\n    /// Distance of a positioned element from the reading start edge.\n    fn inset_start(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let inset = &mut self.style().inset;\n        match direction {\n            Direction::Ltr => inset.left = Some(value.into()),\n            Direction::Rtl => inset.right = Some(value.into()),\n        }\n        self\n    }\n\n    /// Distance of a positioned element from the reading end edge.\n    fn inset_end(mut self, direction: Direction, value: gpui_kit::Pixels) -> Self {\n        let inset = &mut self.style().inset;\n        match direction {\n            Direction::Ltr => inset.right = Some(value.into()),\n            Direction::Rtl => inset.left = Some(value.into()),\n        }\n        self\n    }\n\n    /// A one-pixel border on the reading start edge.\n    fn border_start_1(mut self, direction: Direction) -> Self {\n        let border = &mut self.style().border_widths;\n        match direction {\n            Direction::Ltr => border.left = Some(px(1.).into()),\n            Direction::Rtl => border.right = Some(px(1.).into()),\n        }\n        self\n    }\n\n    /// A one-pixel border on the reading end edge.\n    fn border_end_1(mut self, direction: Direction) -> Self {\n        let border = &mut self.style().border_widths;\n        match direction {\n            Direction::Ltr => border.right = Some(px(1.).into()),\n            Direction::Rtl => border.left = Some(px(1.).into()),\n        }\n        self\n    }\n\n    /// Rounds the two corners on the reading start edge.\n    fn rounded_start(mut self, direction: Direction, radius: gpui_kit::Pixels) -> Self {\n        let corners = &mut self.style().corner_radii;\n        let radius = Some(radius.into());\n        match direction {\n            Direction::Ltr => (corners.top_left, corners.bottom_left) = (radius, radius),\n            Direction::Rtl => (corners.top_right, corners.bottom_right) = (radius, radius),\n        }\n        self\n    }\n\n    /// Rounds the two corners on the reading end edge.\n    fn rounded_end(mut self, direction: Direction, radius: gpui_kit::Pixels) -> Self {\n        let corners = &mut self.style().corner_radii;\n        let radius = Some(radius.into());\n        match direction {\n            Direction::Ltr => (corners.top_right, corners.bottom_right) = (radius, radius),\n            Direction::Rtl => (corners.top_left, corners.bottom_left) = (radius, radius),\n        }\n        self\n    }\n\n    /// A two-pixel border on the reading start edge, as on a highlighted row.\n    fn border_start_2(mut self, direction: Direction) -> Self {\n        let border = &mut self.style().border_widths;\n        match direction {\n            Direction::Ltr => border.left = Some(px(2.).into()),\n            Direction::Rtl => border.right = Some(px(2.).into()),\n        }\n        self\n    }\n\n    /// Removes the border on the reading start edge.\n    fn border_start_0(mut self, direction: Direction) -> Self {\n        let border = &mut self.style().border_widths;\n        match direction {\n            Direction::Ltr => border.left = Some(px(0.).into()),\n            Direction::Rtl => border.right = Some(px(0.).into()),\n        }\n        self\n    }\n\n    /// Text aligned to the reading start edge.\n    fn text_start(self, direction: Direction) -> Self {\n        self.text_align(direction.start_align())\n    }\n}\n\nimpl<T: Styled> DirectionalStyled for T {}\n\n/// A word or sentence a component draws or announces on its own.\n///\n/// Match on it in [`set_strings`] to translate; [`UiText::key`] gives a stable\n/// identifier for message catalogs such as Fluent, and the values a variant\n/// carries are the arguments to place.\n#[derive(Clone, Debug, Eq, Hash, PartialEq)]\n#[non_exhaustive]\npub enum UiText {\n    /// \"Close\", on dialogs, drawers, lightboxes and window controls.\n    Close,\n    /// \"Close notification\", on toasts.\n    CloseNotification,\n    /// \"Loading\", the spinner's accessible name.\n    Loading,\n    /// \"Read only\", announced on read-only fields.\n    ReadOnly,\n    /// \"{label} (required)\", a required field's accessible name.\n    Required(SharedString),\n    /// \"One-time code\", the OTP field's default accessible name.\n    OneTimeCode,\n    /// \"Invalid value\", announced on invalid inputs.\n    InvalidValue,\n    /// \"Unavailable\", announced on disabled list rows and commands.\n    Unavailable,\n    /// \"No results found.\", the command palette's empty state.\n    NoResults,\n    /// \"No items\", the virtual list's empty state.\n    NoItems,\n    /// \"Use arrow keys to navigate and Enter to activate.\", the virtual list's hint.\n    ListInstructions,\n    /// The multi-select virtual list's hint.\n    MultiSelectInstructions,\n    /// \"Selection\", a select's default accessible name.\n    Selection,\n    /// \"Select…\", a select's default placeholder.\n    SelectPlaceholder,\n    /// \"{label} (invalid value)\", an invalid select's accessible name.\n    InvalidSelection(SharedString),\n    /// \"Navigation\", the sidebar's accessible name.\n    Navigation,\n    /// \"Toggle sidebar\".\n    ToggleSidebar,\n    /// \"current destination\", read after the selected sidebar item.\n    CurrentDestination,\n    /// \"expanded\", read after an open disclosure.\n    Expanded,\n    /// \"collapsed\", read after a closed disclosure.\n    Collapsed,\n    /// \"Cut\", in the text context menu.\n    Cut,\n    /// \"Copy\", in the text context menu.\n    Copy,\n    /// \"Paste\", in the text context menu.\n    Paste,\n    /// \"Select All\", in the text context menu.\n    SelectAll,\n    /// \"Decrease value\", on number fields.\n    DecreaseValue,\n    /// \"Increase value\", on number fields.\n    IncreaseValue,\n    /// \"Minimize\", a title bar window control.\n    Minimize,\n    /// \"Maximize\", a title bar window control.\n    Maximize,\n    /// \"Restore\", a title bar window control.\n    Restore,\n    /// \"Uploading… {percent}%\", an attachment's progress.\n    Uploading(u32),\n    /// \"Upload failed\".\n    UploadFailed,\n    /// \"Remove {name}\", on attachments and tags.\n    Remove(SharedString),\n    /// \"Retry uploading {name}\".\n    RetryUpload(SharedString),\n    /// \"Previous month\", on calendars.\n    PreviousMonth,\n    /// \"Next month\", on calendars.\n    NextMonth,\n    /// A weekday name, 0 for \"Sunday\" through 6 for \"Saturday\".\n    Weekday(u8),\n    /// A two-letter weekday heading, 0 for \"Su\" through 6 for \"Sa\".\n    WeekdayShort(u8),\n    /// A month name, 1 for \"January\" through 12 for \"December\".\n    Month(u8),\n    /// A calendar's heading, such as \"March 2026\".\n    MonthYear {\n        /// 1 to 12.\n        month: u8,\n        /// The year.\n        year: i32,\n    },\n    /// A date read aloud, such as \"Saturday, March 14, 2026\".\n    LongDate {\n        /// 0 for Sunday through 6 for Saturday.\n        weekday: u8,\n        /// 1 to 12.\n        month: u8,\n        /// 1 to 31.\n        day: u8,\n        /// The year.\n        year: i32,\n    },\n    /// A compact date, such as \"Mar 14, 2026\".\n    ShortDate {\n        /// 1 to 12.\n        month: u8,\n        /// 1 to 31.\n        day: u8,\n        /// The year.\n        year: i32,\n    },\n    /// \"today\", appended to today's date in a calendar.\n    Today,\n    /// \"Pick a date\", the date picker's placeholder.\n    PickDate,\n    /// \"Pick a date and time\", the date and time picker's placeholder.\n    PickDateTime,\n    /// \"Time, {time}\", the time field's accessible name.\n    TimeField(SharedString),\n    /// \"Hour\".\n    Hour,\n    /// \"AM\", before noon on a 12-hour clock.\n    Am,\n    /// \"PM\", after noon on a 12-hour clock.\n    Pm,\n    /// \"AM or PM\", the time field's period segment.\n    DayPeriod,\n    /// \"Minute\".\n    Minute,\n    /// \"Done\", closing the date and time picker.\n    Done,\n    /// \"Carousel\", the carousel's default accessible name.\n    Carousel,\n    /// \"Previous slide\".\n    PreviousSlide,\n    /// \"Next slide\".\n    NextSlide,\n    /// \"Search commands\", the command palette's input.\n    SearchCommands,\n    /// \"Commands\", the command list and the composer's slash suggestions.\n    Commands,\n    /// \"Command palette\".\n    CommandPalette,\n    /// \"Message\", the composer's accessible name.\n    Message,\n    /// \"People\", the composer's @ suggestions.\n    People,\n    /// \"Channels\", the composer's ~ suggestions.\n    Channels,\n    /// \"Emoji\", the composer's : suggestions and the emoji grid.\n    Emoji,\n    /// \"Suggestions\", the composer's other suggestions.\n    Suggestions,\n    /// \"Load image\", on image placeholders.\n    LoadImage,\n    /// \"Load image from {host}\".\n    LoadImageFrom(SharedString),\n    /// \"Show image preview\", on link embeds.\n    ExpandPreview,\n    /// \"Hide image preview\", on link embeds.\n    CollapsePreview,\n    /// \"Remove preview\", on link embeds.\n    RemovePreview,\n    /// \"Attachment\", an untitled attachment embed.\n    Attachment,\n    /// \"Jump\", on quoted messages.\n    Jump,\n    /// \"Jump to the message from {author}\".\n    JumpToMessageFrom(SharedString),\n    /// \"Originally posted in {channel}\".\n    OriginallyPostedIn(SharedString),\n    /// \"Show more\", expanding long quotes.\n    ShowMore,\n    /// \"Show less\", collapsing long quotes.\n    ShowLess,\n    /// \"Copy code\", on a code block's copy button.\n    CopyCode,\n    /// \"Copied\", after a copy button copied.\n    Copied,\n    /// \"Quoted message from {author}\".\n    QuotedMessageFrom(SharedString),\n    /// \"Search emoji\", the emoji picker's placeholder and input name.\n    SearchEmoji,\n    /// \"Search results\", the emoji picker's results heading.\n    SearchResults,\n    /// \"Frequently used\", an emoji picker heading.\n    FrequentlyUsed,\n    /// \"Recently used\", an emoji picker heading.\n    RecentlyUsed,\n    /// \"Custom\", the emoji picker's custom emoji heading.\n    CustomEmoji,\n    /// \"Emoji categories\", the emoji picker's tab list.\n    EmojiCategories,\n    /// \"No emoji found.\", the emoji picker's empty state.\n    NoEmoji,\n    /// \"Skin tone\", the emoji picker's skin tone menu.\n    SkinTone,\n    /// A skin tone name, 0 for \"Default skin tone\" through 5 for \"Dark skin tone\".\n    SkinToneName(u8),\n    /// \"Previous image\", in the lightbox.\n    PreviousImage,\n    /// \"Next image\", in the lightbox.\n    NextImage,\n    /// \"Image\", an untitled image.\n    Image,\n    /// \"Zoom out\", in the lightbox.\n    ZoomOut,\n    /// \"Zoom in\", in the lightbox.\n    ZoomIn,\n    /// \"Image viewer: {name}\", the lightbox's accessible name.\n    ImageViewer(SharedString),\n    /// \"{index} of {count}\", the lightbox's position, counting from 1.\n    Position {\n        /// The current item, from 1.\n        index: usize,\n        /// How many there are.\n        count: usize,\n    },\n    /// \"Zoom {percent}%\", the lightbox's zoom status.\n    Zoom(u32),\n    /// \"Message failed to send.\".\n    MessageFailed,\n    /// \"Retry\", resending a failed message.\n    Retry,\n    /// \"Delete\", discarding a failed message.\n    Delete,\n    /// \"Add reaction\".\n    AddReaction,\n    /// \"Jump to latest\", the message list's default jump label.\n    JumpToLatest,\n    /// \"1 new message\" or \"{count} new messages\", the message list's jump\n    /// label while messages arrived out of view.\n    NewMessages(usize),\n    /// \"online\", an avatar status.\n    StatusOnline,\n    /// \"away\", an avatar status.\n    StatusAway,\n    /// \"do not disturb\", an avatar status.\n    StatusDnd,\n    /// \"offline\", an avatar status.\n    StatusOffline,\n    /// A list of names, such as \"Ana, Ben and Chen\", for avatar stacks.\n    Names(Vec<SharedString>),\n    /// \"Clear selection\", on a searchable select.\n    ClearSelection,\n    /// \"Show options\", on a searchable select.\n    ShowOptions,\n    /// \"Hue\", the Color Picker's hue slider.\n    ColorHue,\n    /// \"Chroma\", the Color Picker's colorfulness slider.\n    ColorChroma,\n    /// \"Lightness\", the Color Picker's lightness slider.\n    ColorLightness,\n    /// How to move a sortable row with the keyboard; the keys are already\n    /// in reading order.\n    SortInstructions {\n        /// The key that moves toward the start, such as \"Up\".\n        previous: SharedString,\n        /// The key that moves toward the end, such as \"Down\".\n        next: SharedString,\n    },\n    /// A sortable group header's label with its move keys.\n    SortGroup {\n        /// The group's name.\n        label: SharedString,\n        /// The key that moves toward the start.\n        previous: SharedString,\n        /// The key that moves toward the end.\n        next: SharedString,\n    },\n    /// The announcement after a keyboard move in a sortable list.\n    Moved {\n        /// The moved row or group.\n        label: SharedString,\n        /// The new place, counted from 1.\n        position: usize,\n        /// How many places there are.\n        count: usize,\n        /// The group the row moved into, if rows are grouped.\n        group: Option<SharedString>,\n    },\n}\n\nconst WEEKDAYS: [&str; 7] = [\n    \"Sunday\",\n    \"Monday\",\n    \"Tuesday\",\n    \"Wednesday\",\n    \"Thursday\",\n    \"Friday\",\n    \"Saturday\",\n];\nconst MONTHS: [&str; 12] = [\n    \"January\",\n    \"February\",\n    \"March\",\n    \"April\",\n    \"May\",\n    \"June\",\n    \"July\",\n    \"August\",\n    \"September\",\n    \"October\",\n    \"November\",\n    \"December\",\n];\nconst SKIN_TONES: [&str; 6] = [\n    \"Default skin tone\",\n    \"Light skin tone\",\n    \"Medium-light skin tone\",\n    \"Medium skin tone\",\n    \"Medium-dark skin tone\",\n    \"Dark skin tone\",\n];\n\nfn month_english(month: u8) -> &'static str {\n    MONTHS[usize::from(month.clamp(1, 12) - 1)]\n}\n\nimpl UiText {\n    /// A stable kebab-case identifier, such as `close` or `emoji-search`,\n    /// for looking the string up in a message catalog.\n    pub fn key(&self) -> &'static str {\n        match self {\n            Self::Close => \"close\",\n            Self::CloseNotification => \"close-notification\",\n            Self::Loading => \"loading\",\n            Self::ReadOnly => \"read-only\",\n            Self::Required(_) => \"required\",\n            Self::OneTimeCode => \"one-time-code\",\n            Self::InvalidValue => \"invalid-value\",\n            Self::Unavailable => \"unavailable\",\n            Self::NoResults => \"no-results\",\n            Self::NoItems => \"no-items\",\n            Self::ListInstructions => \"list-instructions\",\n            Self::MultiSelectInstructions => \"multi-select-instructions\",\n            Self::Selection => \"selection\",\n            Self::SelectPlaceholder => \"select-placeholder\",\n            Self::InvalidSelection(_) => \"invalid-selection\",\n            Self::Navigation => \"navigation\",\n            Self::ToggleSidebar => \"toggle-sidebar\",\n            Self::CurrentDestination => \"current-destination\",\n            Self::Expanded => \"expanded\",\n            Self::Collapsed => \"collapsed\",\n            Self::Cut => \"cut\",\n            Self::Copy => \"copy\",\n            Self::Paste => \"paste\",\n            Self::SelectAll => \"select-all\",\n            Self::DecreaseValue => \"decrease-value\",\n            Self::IncreaseValue => \"increase-value\",\n            Self::Minimize => \"minimize\",\n            Self::Maximize => \"maximize\",\n            Self::Restore => \"restore\",\n            Self::Uploading(_) => \"uploading\",\n            Self::UploadFailed => \"upload-failed\",\n            Self::Remove(_) => \"remove\",\n            Self::RetryUpload(_) => \"retry-upload\",\n            Self::PreviousMonth => \"previous-month\",\n            Self::NextMonth => \"next-month\",\n            Self::Weekday(_) => \"weekday\",\n            Self::WeekdayShort(_) => \"weekday-short\",\n            Self::Month(_) => \"month\",\n            Self::MonthYear { .. } => \"month-year\",\n            Self::LongDate { .. } => \"long-date\",\n            Self::ShortDate { .. } => \"short-date\",\n            Self::Today => \"today\",\n            Self::PickDate => \"pick-date\",\n            Self::PickDateTime => \"pick-date-time\",\n            Self::TimeField(_) => \"time-field\",\n            Self::Hour => \"hour\",\n            Self::Am => \"am\",\n            Self::Pm => \"pm\",\n            Self::DayPeriod => \"day-period\",\n            Self::Minute => \"minute\",\n            Self::Done => \"done\",\n            Self::Carousel => \"carousel\",\n            Self::PreviousSlide => \"previous-slide\",\n            Self::NextSlide => \"next-slide\",\n            Self::SearchCommands => \"search-commands\",\n            Self::Commands => \"commands\",\n            Self::CommandPalette => \"command-palette\",\n            Self::Message => \"message\",\n            Self::People => \"people\",\n            Self::Channels => \"channels\",\n            Self::Emoji => \"emoji\",\n            Self::Suggestions => \"suggestions\",\n            Self::LoadImage => \"load-image\",\n            Self::LoadImageFrom(_) => \"load-image-from\",\n            Self::ExpandPreview => \"expand-preview\",\n            Self::CollapsePreview => \"collapse-preview\",\n            Self::RemovePreview => \"remove-preview\",\n            Self::Attachment => \"attachment\",\n            Self::Jump => \"jump\",\n            Self::JumpToMessageFrom(_) => \"jump-to-message-from\",\n            Self::OriginallyPostedIn(_) => \"originally-posted-in\",\n            Self::ShowMore => \"show-more\",\n            Self::ShowLess => \"show-less\",\n            Self::CopyCode => \"copy-code\",\n            Self::Copied => \"copied\",\n            Self::QuotedMessageFrom(_) => \"quoted-message-from\",\n            Self::SearchEmoji => \"emoji-search\",\n            Self::SearchResults => \"emoji-search-results\",\n            Self::FrequentlyUsed => \"emoji-frequently-used\",\n            Self::RecentlyUsed => \"emoji-recently-used\",\n            Self::CustomEmoji => \"emoji-custom\",\n            Self::EmojiCategories => \"emoji-categories\",\n            Self::NoEmoji => \"emoji-none\",\n            Self::SkinTone => \"emoji-skin-tone\",\n            Self::SkinToneName(_) => \"emoji-skin-tone-name\",\n            Self::PreviousImage => \"previous-image\",\n            Self::NextImage => \"next-image\",\n            Self::Image => \"image\",\n            Self::ZoomOut => \"zoom-out\",\n            Self::ZoomIn => \"zoom-in\",\n            Self::ImageViewer(_) => \"image-viewer\",\n            Self::Position { .. } => \"position\",\n            Self::Zoom(_) => \"zoom\",\n            Self::MessageFailed => \"message-failed\",\n            Self::Retry => \"retry\",\n            Self::Delete => \"delete\",\n            Self::AddReaction => \"add-reaction\",\n            Self::JumpToLatest => \"jump-to-latest\",\n            Self::NewMessages(_) => \"new-messages\",\n            Self::StatusOnline => \"status-online\",\n            Self::StatusAway => \"status-away\",\n            Self::StatusDnd => \"status-dnd\",\n            Self::StatusOffline => \"status-offline\",\n            Self::Names(_) => \"names\",\n            Self::ClearSelection => \"clear-selection\",\n            Self::ShowOptions => \"show-options\",\n            Self::ColorHue => \"color-hue\",\n            Self::ColorChroma => \"color-chroma\",\n            Self::ColorLightness => \"color-lightness\",\n            Self::SortInstructions { .. } => \"sort-instructions\",\n            Self::SortGroup { .. } => \"sort-group\",\n            Self::Moved { .. } => \"moved\",\n        }\n    }\n\n    /// The English text, which components show when no translation is set.\n    pub fn english(&self) -> SharedString {\n        let text: &'static str = match self {\n            Self::Uploading(percent) => return format!(\"Uploading… {percent}%\").into(),\n            Self::NewMessages(1) => \"1 new message\",\n            Self::NewMessages(count) => return format!(\"{count} new messages\").into(),\n            Self::Required(label) => return format!(\"{label} (required)\").into(),\n            Self::InvalidSelection(label) => return format!(\"{label} (invalid value)\").into(),\n            Self::Remove(name) => return format!(\"Remove {name}\").into(),\n            Self::RetryUpload(name) => return format!(\"Retry uploading {name}\").into(),\n            Self::Weekday(day) => WEEKDAYS[usize::from(*day) % 7],\n            Self::WeekdayShort(day) => &WEEKDAYS[usize::from(*day) % 7][..2],\n            Self::Month(month) => month_english(*month),\n            Self::TimeField(time) => return format!(\"Time, {time}\").into(),\n            Self::MonthYear { month, year } => {\n                return format!(\"{} {year}\", month_english(*month)).into();\n            }\n            Self::LongDate {\n                weekday,\n                month,\n                day,\n                year,\n            } => {\n                let weekday = WEEKDAYS[usize::from(*weekday) % 7];\n                return format!(\"{weekday}, {} {day}, {year}\", month_english(*month)).into();\n            }\n            Self::ShortDate { month, day, year } => {\n                return format!(\"{} {day}, {year}\", &month_english(*month)[..3]).into();\n            }\n            Self::Today => \"today\",\n            Self::LoadImageFrom(host) => return format!(\"Load image from {host}\").into(),\n            Self::JumpToMessageFrom(author) => {\n                return format!(\"Jump to the message from {author}\").into();\n            }\n            Self::OriginallyPostedIn(channel) => {\n                return format!(\"Originally posted in {channel}\").into();\n            }\n            Self::QuotedMessageFrom(author) => {\n                return format!(\"Quoted message from {author}\").into();\n            }\n            Self::ImageViewer(name) => return format!(\"Image viewer: {name}\").into(),\n            Self::Names(names) => {\n                return match names.as_slice() {\n                    [] => SharedString::default(),\n                    [only] => only.clone(),\n                    [rest @ .., last] => format!(\n                        \"{} and {last}\",\n                        rest.iter()\n                            .map(SharedString::as_ref)\n                            .collect::<Vec<_>>()\n                            .join(\", \")\n                    )\n                    .into(),\n                };\n            }\n            Self::Position { index, count } => return format!(\"{index} of {count}\").into(),\n            Self::SortInstructions { previous, next } => {\n                return format!(\n                    \"Press Alt+Shift+{previous} or Alt+Shift+{next} to move the focused row.\"\n                )\n                .into();\n            }\n            Self::SortGroup {\n                label,\n                previous,\n                next,\n            } => return format!(\"{label}, move with Alt+Shift+{previous} or {next}\").into(),\n            Self::Moved {\n                label,\n                position,\n                count,\n                group,\n            } => {\n                return match group {\n                    Some(group) => {\n                        format!(\"{label} moved to position {position} of {count} in {group}\")\n                    }\n                    None => format!(\"{label} moved to position {position} of {count}\"),\n                }\n                .into();\n            }\n            Self::ClearSelection => \"Clear selection\",\n            Self::ShowOptions => \"Show options\",\n            Self::ColorHue => \"Hue\",\n            Self::ColorChroma => \"Chroma\",\n            Self::ColorLightness => \"Lightness\",\n            Self::Zoom(percent) => return format!(\"Zoom {percent}%\").into(),\n            Self::SkinToneName(tone) => SKIN_TONES[usize::from(*tone).min(SKIN_TONES.len() - 1)],\n            Self::Close => \"Close\",\n            Self::CloseNotification => \"Close notification\",\n            Self::Loading => \"Loading\",\n            Self::ReadOnly => \"Read only\",\n            Self::OneTimeCode => \"One-time code\",\n            Self::InvalidValue => \"Invalid value\",\n            Self::Unavailable => \"Unavailable\",\n            Self::NoResults => \"No results found.\",\n            Self::NoItems => \"No items\",\n            Self::ListInstructions => \"Use arrow keys to navigate and Enter to activate.\",\n            Self::MultiSelectInstructions => {\n                \"Multi-select list. Use arrows to navigate, Shift for a range, Command or Control to toggle.\"\n            }\n            Self::Selection => \"Selection\",\n            Self::SelectPlaceholder => \"Select…\",\n            Self::Navigation => \"Navigation\",\n            Self::ToggleSidebar => \"Toggle sidebar\",\n            Self::CurrentDestination => \"current destination\",\n            Self::Expanded => \"expanded\",\n            Self::Collapsed => \"collapsed\",\n            Self::Cut => \"Cut\",\n            Self::Copy => \"Copy\",\n            Self::Paste => \"Paste\",\n            Self::SelectAll => \"Select All\",\n            Self::DecreaseValue => \"Decrease value\",\n            Self::IncreaseValue => \"Increase value\",\n            Self::Minimize => \"Minimize\",\n            Self::Maximize => \"Maximize\",\n            Self::Restore => \"Restore\",\n            Self::UploadFailed => \"Upload failed\",\n            Self::PreviousMonth => \"Previous month\",\n            Self::NextMonth => \"Next month\",\n            Self::PickDate => \"Pick a date\",\n            Self::PickDateTime => \"Pick a date and time\",\n            Self::Hour => \"Hour\",\n            Self::Am => \"AM\",\n            Self::Pm => \"PM\",\n            Self::DayPeriod => \"AM or PM\",\n            Self::Minute => \"Minute\",\n            Self::Done => \"Done\",\n            Self::Carousel => \"Carousel\",\n            Self::PreviousSlide => \"Previous slide\",\n            Self::NextSlide => \"Next slide\",\n            Self::SearchCommands => \"Search commands\",\n            Self::Commands => \"Commands\",\n            Self::CommandPalette => \"Command palette\",\n            Self::Message => \"Message\",\n            Self::People => \"People\",\n            Self::Channels => \"Channels\",\n            Self::Emoji => \"Emoji\",\n            Self::Suggestions => \"Suggestions\",\n            Self::LoadImage => \"Load image\",\n            Self::ExpandPreview => \"Show image preview\",\n            Self::CollapsePreview => \"Hide image preview\",\n            Self::RemovePreview => \"Remove preview\",\n            Self::Attachment => \"Attachment\",\n            Self::Jump => \"Jump\",\n            Self::ShowMore => \"Show more\",\n            Self::ShowLess => \"Show less\",\n            Self::CopyCode => \"Copy code\",\n            Self::Copied => \"Copied\",\n            Self::SearchEmoji => \"Search emoji\",\n            Self::SearchResults => \"Search results\",\n            Self::FrequentlyUsed => \"Frequently used\",\n            Self::RecentlyUsed => \"Recently used\",\n            Self::CustomEmoji => \"Custom\",\n            Self::EmojiCategories => \"Emoji categories\",\n            Self::NoEmoji => \"No emoji found.\",\n            Self::SkinTone => \"Skin tone\",\n            Self::PreviousImage => \"Previous image\",\n            Self::NextImage => \"Next image\",\n            Self::Image => \"Image\",\n            Self::ZoomOut => \"Zoom out\",\n            Self::ZoomIn => \"Zoom in\",\n            Self::MessageFailed => \"Message failed to send.\",\n            Self::Retry => \"Retry\",\n            Self::Delete => \"Delete\",\n            Self::AddReaction => \"Add reaction\",\n            Self::JumpToLatest => \"Jump to latest\",\n            Self::StatusOnline => \"online\",\n            Self::StatusAway => \"away\",\n            Self::StatusDnd => \"do not disturb\",\n            Self::StatusOffline => \"offline\",\n        };\n        SharedString::new_static(text)\n    }\n}\n\ntype Translate = Rc<dyn Fn(&UiText) -> Option<SharedString>>;\n\n#[derive(Clone)]\nstruct Strings(Translate);\nimpl Global for Strings {}\n\n/// Installs the application's translations of the built-in strings and\n/// redraws every window. Return `None` for a string to keep its English.\n///\n/// ```ignore\n/// locale::set_strings(cx, move |text| match text {\n///     UiText::Close => Some(\"إغلاق\".into()),\n///     UiText::Remove(name) => Some(format!(\"إزالة {name}\").into()),\n///     _ => None,\n/// });\n/// ```\npub fn set_strings(cx: &mut App, translate: impl Fn(&UiText) -> Option<SharedString> + 'static) {\n    cx.set_global(Strings(Rc::new(translate)));\n    cx.refresh_windows();\n}\n\n/// Removes the application's translations, so every built-in string is English.\npub fn clear_strings(cx: &mut App) {\n    if cx.has_global::<Strings>() {\n        cx.remove_global::<Strings>();\n        cx.refresh_windows();\n    }\n}\n\n/// The application's translation of a built-in string, or its English.\npub fn text(cx: &App, text: UiText) -> SharedString {\n    cx.try_global::<Strings>()\n        .and_then(|strings| (strings.0)(&text))\n        .unwrap_or_else(|| text.english())\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn english_covers_arguments_and_tables() {\n        assert_eq!(UiText::Remove(\"a.png\".into()).english(), \"Remove a.png\");\n        assert_eq!(UiText::Month(1).english(), \"January\");\n        assert_eq!(UiText::Month(12).english(), \"December\");\n        assert_eq!(UiText::WeekdayShort(0).english(), \"Su\");\n        assert_eq!(UiText::SkinToneName(5).english(), \"Dark skin tone\");\n        assert_eq!(UiText::Uploading(40).english(), \"Uploading… 40%\");\n        assert_eq!(UiText::NewMessages(1).english(), \"1 new message\");\n        assert_eq!(UiText::NewMessages(3).english(), \"3 new messages\");\n        let date = UiText::LongDate {\n            weekday: 6,\n            month: 3,\n            day: 14,\n            year: 2026,\n        };\n        assert_eq!(date.english(), \"Saturday, March 14, 2026\");\n        let date = UiText::ShortDate {\n            month: 3,\n            day: 14,\n            year: 2026,\n        };\n        assert_eq!(date.english(), \"Mar 14, 2026\");\n    }\n\n    #[test]\n    fn logical_keys_swap_only_in_rtl() {\n        assert_eq!(Direction::Ltr.logical_key(\"left\"), \"left\");\n        assert_eq!(Direction::Rtl.logical_key(\"left\"), \"right\");\n        assert_eq!(Direction::Rtl.logical_key(\"right\"), \"left\");\n        assert_eq!(Direction::Rtl.logical_key(\"up\"), \"up\");\n    }\n\n    #[test]\n    fn isolate_wraps_once() {\n        let name = isolate(\"سارة\");\n        assert_eq!(name.as_ref(), \"\\u{2068}سارة\\u{2069}\");\n        assert_eq!(isolate(&name), name);\n        assert_eq!(isolate(\"\"), \"\");\n    }\n\n    #[gpui_kit::test]\n    fn translations_replace_english_and_fall_back(cx: &mut gpui_kit::TestAppContext) {\n        cx.update(|cx| {\n            assert_eq!(text(cx, UiText::Close), \"Close\");\n            set_strings(cx, |text| match text {\n                UiText::Close => Some(\"إغلاق\".into()),\n                UiText::Remove(name) => Some(format!(\"إزالة {name}\").into()),\n                _ => None,\n            });\n            assert_eq!(text(cx, UiText::Close), \"إغلاق\");\n            assert_eq!(text(cx, UiText::Remove(\"a\".into())), \"إزالة a\");\n            assert_eq!(text(cx, UiText::Done), \"Done\");\n            clear_strings(cx);\n            assert_eq!(text(cx, UiText::Close), \"Close\");\n        });\n    }\n\n    #[gpui_kit::test]\n    fn direction_survives_theme_swaps(cx: &mut gpui_kit::TestAppContext) {\n        cx.update(|cx| {\n            super::super::init(cx);\n            set_direction(cx, Direction::Rtl);\n            assert_eq!(UiTheme::read(cx).direction, Direction::Rtl);\n            UiTheme::switch(cx, super::super::ThemeMode::Dark);\n            assert_eq!(UiTheme::read(cx).direction, Direction::Rtl);\n            UiTheme::set(cx, UiTheme::neutral_light());\n            assert_eq!(direction(cx), Direction::Rtl);\n            assert_eq!(UiTheme::read(cx).direction, Direction::Rtl);\n        });\n    }\n}\n"
    },
    {
      "path": "registry/theme/primitives.rs",
      "type": "registry:file",
      "target": "~/src/ui/primitives.rs",
      "content": "//! Shared visual recipes between the theme tokens and the components.\n//!\n//! shadcn expresses these as Tailwind class strings; here each one is a function\n//! that applies the same styles to any GPUI element, so every component draws\n//! surfaces, controls, focus, text and images the same way, and a change to a\n//! recipe reaches the whole catalog. The registry lint fails components that\n//! rewrite one of these by hand. Everything takes `&UiTheme` so it works in\n//! `RenderOnce` and `Render` alike without re-reading the global.\n\nuse gpui_icons::{LucideIcon, lucide};\nuse gpui_kit::{\n    AnyElement, Axis, BoxShadow, Div, FontWeight, ImageSource, Img, InteractiveElement,\n    IntoElement, MouseButton, ObjectFit, ParentElement, Pixels, Rgba, SharedString,\n    StatefulInteractiveElement, StyleRefinement, Styled, StyledImage as _, Window, div, img, px,\n};\n\nuse super::{UiTextStyle, UiTheme};\n\n/// Text sizes from the type scale, each with its line height and the body font.\npub mod text {\n    use super::*;\n\n    /// Applies one step of the type scale and the body font.\n    pub fn style<T: Styled>(element: T, theme: &UiTheme, style: UiTextStyle) -> T {\n        let style = theme.text_style(style);\n        element\n            .font_family(theme.fonts.body.clone())\n            .text_size(style.size)\n            .line_height(style.line_height)\n    }\n    /// Captions, key caps and timestamps.\n    pub fn xs<T: Styled>(element: T, theme: &UiTheme) -> T {\n        style(element, theme, theme.typography.xs)\n    }\n    /// Controls and body copy; the Nova default.\n    pub fn sm<T: Styled>(element: T, theme: &UiTheme) -> T {\n        style(element, theme, theme.typography.sm)\n    }\n    /// Prose and dialog titles.\n    pub fn base<T: Styled>(element: T, theme: &UiTheme) -> T {\n        style(element, theme, theme.typography.base)\n    }\n    /// Section headings.\n    pub fn lg<T: Styled>(element: T, theme: &UiTheme) -> T {\n        style(element, theme, theme.typography.lg)\n    }\n    /// Page headings.\n    pub fn xl<T: Styled>(element: T, theme: &UiTheme) -> T {\n        style(element, theme, theme.typography.xl)\n    }\n    /// A medium-weight heading in the heading font at the given step.\n    pub fn heading<T: Styled>(element: T, theme: &UiTheme, size: UiTextStyle) -> T {\n        style(element, theme, size)\n            .font_family(theme.fonts.heading.clone())\n            .font_weight(FontWeight::MEDIUM)\n    }\n    /// Switches to the monospace font, keeping the current size.\n    pub fn mono<T: Styled>(element: T, theme: &UiTheme) -> T {\n        element.font_family(theme.fonts.mono.clone())\n    }\n    /// Muted supporting text at the small size.\n    pub fn muted<T: Styled>(element: T, theme: &UiTheme) -> T {\n        sm(element, theme).text_color(theme.colors.muted_foreground)\n    }\n\n    /// How tall a line box has to be, as a multiple of the font size, for\n    /// a glyph to fit inside it: Geist and IBM Plex Sans both reach 1.3em\n    /// from the top of an accent to the bottom of a g. A shorter box is fine\n    /// until something clips it; `truncate()` and `overflow_hidden()` clip\n    /// to the box and cut the bottoms off g, p and y.\n    pub const INK: f32 = 1.3;\n\n    /// The line height for text drawn at `size` (already scaled): the type\n    /// scale's own when `size` is one of its steps, otherwise 1.4 times the\n    /// size rounded up to a whole pixel. Never shorter than [`INK`].\n    pub fn line_height(theme: &UiTheme, size: Pixels) -> Pixels {\n        let t = &theme.typography;\n        [t.xs, t.sm, t.base, t.lg, t.xl]\n            .into_iter()\n            .map(|step| theme.text_style(step))\n            .find(|step| (step.size - size).abs() < px(0.01))\n            .map(|step| step.line_height)\n            .unwrap_or_else(|| px((f32::from(size) * 1.4).ceil()))\n            .max(size * INK)\n    }\n\n    /// Sets a control's text size and a line box its glyphs fit in.\n    ///\n    /// GPUI Kit's base `Button`, `Toggle` and `Tab` set\n    /// `line_height(relative(1.))`, a box exactly the font size, so a\n    /// truncated label inside one loses its descenders. Every gpuicn control\n    /// built on one of them sets its text here instead of `text_size`.\n    pub fn control<T: Styled>(element: T, theme: &UiTheme, size: Pixels) -> T {\n        element\n            .text_size(size)\n            .line_height(line_height(theme, size))\n    }\n}\n\n/// Icon sizes in spacing units, so icons scale with control density.\npub mod icon {\n    use super::*;\n\n    /// 12px: inside badges and tags.\n    pub fn xs(theme: &UiTheme) -> Pixels {\n        theme.space(3.)\n    }\n    /// 14px: inside small buttons and chips.\n    pub fn sm(theme: &UiTheme) -> Pixels {\n        theme.space(3.5)\n    }\n    /// 16px: the default inside controls and menu items.\n    pub fn md(theme: &UiTheme) -> Pixels {\n        theme.space(4.)\n    }\n    /// 20px: list leading icons.\n    pub fn lg(theme: &UiTheme) -> Pixels {\n        theme.space(5.)\n    }\n    /// 24px: empty states and headers.\n    pub fn xl(theme: &UiTheme) -> Pixels {\n        theme.space(6.)\n    }\n}\n\n/// Keyboard focus treatment: shadcn Nova's `ring-3 ring-ring/50` outside the\n/// border, with the border taking the ring color. Apply through\n/// `focus_visible` so pointer presses leave it alone.\npub mod focus {\n    use super::*;\n\n    /// The ring as a box shadow, for elements that draw their own border.\n    pub fn shadow(color: Rgba) -> Vec<BoxShadow> {\n        vec![BoxShadow::new(px(0.), px(0.), color.into()).spread_radius(px(3.))]\n    }\n    /// The focus ring for an ordinary control.\n    pub fn ring(style: StyleRefinement, theme: &UiTheme) -> StyleRefinement {\n        let control = theme.control();\n        style\n            .border_color(theme.colors.ring)\n            .shadow(shadow(control.ring))\n    }\n    /// The focus ring for an invalid control, in the destructive color.\n    pub fn invalid_ring(style: StyleRefinement, theme: &UiTheme) -> StyleRefinement {\n        let control = theme.control();\n        style\n            .border_color(theme.colors.destructive)\n            .shadow(shadow(control.invalid_ring))\n    }\n    /// Picks the valid or invalid ring.\n    pub fn ring_for(style: StyleRefinement, theme: &UiTheme, invalid: bool) -> StyleRefinement {\n        if invalid {\n            invalid_ring(style, theme)\n        } else {\n            ring(style, theme)\n        }\n    }\n    /// Draws the ring on `element` while `focused`, for controls whose focus is\n    /// tracked on a parent (a grouped checkbox or radio draws it on its box).\n    pub fn shown<T: Styled>(element: T, theme: &UiTheme, focused: bool) -> T {\n        shown_for(element, theme, focused, false)\n    }\n    /// [`shown`] with the invalid ring when `invalid`.\n    pub fn shown_for<T: Styled>(element: T, theme: &UiTheme, focused: bool, invalid: bool) -> T {\n        if focused {\n            super::super::apply_style(\n                element,\n                &ring_for(StyleRefinement::default(), theme, invalid),\n            )\n        } else {\n            element\n        }\n    }\n}\n\n/// Disabled and interactive cursor treatment.\npub mod disabled {\n    use super::*;\n\n    /// Nova's `disabled:opacity-50` plus the blocked cursor.\n    pub fn style<T: Styled>(element: T) -> T {\n        element.opacity(0.5).cursor_not_allowed()\n    }\n    /// A pointer cursor when enabled, the disabled treatment otherwise.\n    pub fn interactive<T: Styled>(element: T, disabled: bool) -> T {\n        if disabled {\n            style(element)\n        } else {\n            element.cursor_pointer()\n        }\n    }\n    /// Half opacity while `dimmed`, for content that is unavailable rather than\n    /// a control that is disabled: uploading pictures, disabled list rows.\n    pub fn dim<T: Styled>(element: T, dimmed: bool) -> T {\n        if dimmed {\n            element.opacity(0.5)\n        } else {\n            element\n        }\n    }\n}\n\n/// Elevated surfaces. One rule per kind, so every popover, menu, dialog, card\n/// and tooltip in the catalog shares border, radius, shadow and text defaults.\npub mod surface {\n    use super::*;\n\n    /// Starts text at the reading edge. Floating surfaces paint outside\n    /// their trigger's tree, so they cannot inherit the window's alignment.\n    fn reading_start<T: Styled>(element: T, theme: &UiTheme) -> T {\n        if theme.direction.is_rtl() {\n            element.text_align(gpui_kit::TextAlign::Right)\n        } else {\n            element\n        }\n    }\n    fn popover_base<T: Styled>(element: T, theme: &UiTheme) -> T {\n        reading_start(text::sm(element, theme), theme)\n            .border_1()\n            .border_color(theme.control().surface_border)\n            .bg(theme.colors.popover)\n            .text_color(theme.colors.popover_foreground)\n    }\n    /// Popovers, hover cards, select and combobox lists: `rounded-lg shadow-md`.\n    pub fn popover<T: Styled>(element: T, theme: &UiTheme) -> T {\n        popover_base(element, theme)\n            .rounded(theme.radius.lg)\n            .shadow(theme.shadows.md.to_vec())\n    }\n    /// Menus and context menus: a popover with Nova's 4px inset.\n    pub fn menu<T: Styled>(element: T, theme: &UiTheme) -> T {\n        popover(element, theme).p(theme.space(1.))\n    }\n    /// Dialogs and command palettes: `rounded-xl shadow-lg`.\n    pub fn modal<T: Styled>(element: T, theme: &UiTheme) -> T {\n        popover_base(element, theme)\n            .rounded(theme.radius.xl)\n            .shadow(theme.shadows.lg.to_vec())\n    }\n    /// A sheet or drawer panel: the modal surface without a radius, which the\n    /// caller rounds on the open edge.\n    pub fn sheet<T: Styled>(element: T, theme: &UiTheme) -> T {\n        popover_base(element, theme).border_color(theme.colors.border)\n    }\n    /// Toasts: `rounded-2xl` on the popover surface with the plain border.\n    pub fn toast<T: Styled>(element: T, theme: &UiTheme) -> T {\n        popover_base(element, theme)\n            .rounded(theme.radius.two_xl)\n            .border_color(theme.colors.border)\n            .shadow(theme.shadows.lg.to_vec())\n    }\n    /// Cards and empty states: `rounded-xl border shadow-sm` on the card color.\n    pub fn card<T: Styled>(element: T, theme: &UiTheme) -> T {\n        reading_start(text::sm(element, theme), theme)\n            .rounded(theme.radius.xl)\n            .border_1()\n            .border_color(theme.colors.border)\n            .bg(theme.colors.card)\n            .text_color(theme.colors.card_foreground)\n            .shadow(theme.shadows.sm.to_vec())\n    }\n    /// A floating action bar over content, as on a hovered message.\n    pub fn floating<T: Styled>(element: T, theme: &UiTheme) -> T {\n        element\n            .rounded(theme.radius.lg)\n            .border_1()\n            .border_color(theme.colors.border)\n            .bg(theme.colors.background)\n            .shadow(theme.shadows.sm.to_vec())\n    }\n    /// Tooltips: the popover surface (so they follow light and dark mode)\n    /// at the medium radius and caption size.\n    pub fn tooltip<T: Styled>(element: T, theme: &UiTheme) -> T {\n        reading_start(text::xs(element, theme), theme)\n            .rounded(theme.radius.md)\n            .px(theme.space(3.))\n            .py(theme.space(1.5))\n            .border_1()\n            .border_color(theme.control().surface_border)\n            .bg(theme.colors.popover)\n            .text_color(theme.colors.popover_foreground)\n            .shadow(theme.shadows.md.to_vec())\n    }\n    /// A one-pixel rule in the border color, across or down.\n    pub fn divider<T: Styled>(element: T, theme: &UiTheme, axis: Axis) -> T {\n        let element = match axis {\n            Axis::Horizontal => element.w_full().h(px(1.)),\n            Axis::Vertical => element.h_full().w(px(1.)),\n        };\n        element.bg(theme.colors.border)\n    }\n}\n\n/// Form control pieces shared by single controls and their grouped variants.\npub mod control {\n    use super::*;\n\n    /// Corner radius of a 16px check box: Nova's `rounded-[4px]` at the default radius.\n    pub fn box_radius(theme: &UiTheme) -> Pixels {\n        theme.radius.sm * (2. / 3.)\n    }\n\n    /// The frame every text-like control shares: inputs, textareas, selects,\n    /// number and OTP cells. Large radius, input border and fill, small text.\n    /// Callers set the size: `h(theme.space(8.))` and `px(theme.space(2.5))`\n    /// for a single-line control.\n    pub fn frame<T: Styled>(element: T, theme: &UiTheme, invalid: bool) -> T {\n        let control = theme.control();\n        text::sm(element, theme)\n            .rounded(theme.radius.lg)\n            .border_1()\n            .border_color(if invalid {\n                theme.colors.destructive\n            } else {\n                control.border\n            })\n            .bg(control.background)\n            .text_color(theme.colors.foreground)\n    }\n\n    /// Styles `element` as the 16px check box with its mark, for checkboxes and\n    /// grouped checkboxes. The element is the interactive root of the control.\n    pub fn checkbox_box<T: Styled + ParentElement>(\n        element: T,\n        theme: &UiTheme,\n        checked: bool,\n        indeterminate: bool,\n    ) -> T {\n        let colors = theme.colors;\n        let control = theme.control();\n        let selected = checked || indeterminate;\n        let element = element\n            .flex()\n            .flex_shrink_0()\n            .items_center()\n            .justify_center()\n            .size(theme.space(4.))\n            .rounded(box_radius(theme))\n            .border_1()\n            .border_color(if selected {\n                colors.primary\n            } else {\n                control.border\n            })\n            .bg(if selected {\n                colors.primary\n            } else {\n                control.background\n            });\n        if selected {\n            element.child(\n                lucide(if indeterminate {\n                    LucideIcon::Minus\n                } else {\n                    LucideIcon::Check\n                })\n                .size(icon::sm(theme))\n                .text_color(colors.primary_foreground),\n            )\n        } else {\n            element\n        }\n    }\n\n    /// Styles `element` as the 16px radio circle with its dot.\n    pub fn radio_dot<T: Styled + ParentElement>(element: T, theme: &UiTheme, checked: bool) -> T {\n        let colors = theme.colors;\n        let control = theme.control();\n        let element = element\n            .flex()\n            .flex_shrink_0()\n            .items_center()\n            .justify_center()\n            .size(theme.space(4.))\n            .rounded_full()\n            .border_1()\n            .border_color(if checked {\n                colors.primary\n            } else {\n                control.border\n            })\n            .bg(if checked {\n                colors.primary\n            } else {\n                control.background\n            });\n        if checked {\n            element.child(\n                div()\n                    .size(theme.space(2.))\n                    .rounded_full()\n                    .bg(colors.primary_foreground),\n            )\n        } else {\n            element\n        }\n    }\n\n    /// The toggle look shared by Toggle and Toggle Group items: transparent at\n    /// rest, muted when hovered or pressed, an input border when outlined.\n    pub fn toggle<T: Styled>(\n        element: T,\n        theme: &UiTheme,\n        pressed: bool,\n        disabled: bool,\n        outline: bool,\n    ) -> T {\n        let colors = theme.colors;\n        let control = theme.control();\n        let element = text::sm(element, theme)\n            .border_1()\n            .border_color(if outline {\n                control.border\n            } else {\n                colors.background.opacity(0.)\n            })\n            .text_color(colors.foreground)\n            .bg(if pressed {\n                control.pressed\n            } else {\n                colors.background.opacity(0.)\n            });\n        disabled::interactive(element, disabled)\n    }\n}\n\n/// The switch track and thumb colors for a checked or unchecked switch.\npub fn switch_colors(theme: &UiTheme, checked: bool) -> (Rgba, Rgba) {\n    let control = theme.control();\n    if checked {\n        (theme.colors.primary, control.thumb_checked)\n    } else {\n        (control.track, control.thumb)\n    }\n}\n\n/// A GPUI `img` that plays animated GIFs and WebPs.\n///\n/// GPUI only advances an image's frames when the element has an id, so this\n/// names the picture after its source: two pictures of the same file share a\n/// frame clock, and a new source starts from the first frame. Animation stops\n/// while [`App::reduce_motion`](gpui_kit::App) is on, as for any `img`. Use it\n/// wherever a component draws a caller's picture.\npub fn image(source: impl Into<ImageSource>) -> Img {\n    let source = source.into();\n    let id = image_id(&source);\n    let mut image = img(source);\n    image.interactivity().element_id = Some(id);\n    image\n}\n\n/// The element id [`image`] gives a picture of `source`.\npub fn image_id(source: &ImageSource) -> gpui_kit::ElementId {\n    use std::hash::{Hash as _, Hasher as _};\n    let mut hasher = std::collections::hash_map::DefaultHasher::new();\n    match source {\n        ImageSource::Resource(resource) => resource.hash(&mut hasher),\n        ImageSource::Render(render) => (1u8, render.id.0).hash(&mut hasher),\n        ImageSource::Image(image) => (2u8, image.id).hash(&mut hasher),\n        ImageSource::Custom(load) => {\n            (3u8, std::sync::Arc::as_ptr(load) as *const () as usize).hash(&mut hasher)\n        }\n    }\n    gpui_kit::ElementId::NamedInteger(\"gpuicn-image\".into(), hasher.finish())\n}\n\n/// An image inside a rounded frame. GPUI clips children to rectangles, so the\n/// frame rounds itself and the image rounds to the frame's inner radius; the\n/// image fills the frame's box and never sizes the frame from its aspect ratio.\n/// Animated pictures play, through [`image`].\npub fn clipped_image(\n    source: impl Into<ImageSource>,\n    radius: Pixels,\n    fit: ObjectFit,\n    theme: &UiTheme,\n) -> Div {\n    clipped_image_with(source, radius, fit, theme, |image| image)\n}\n\n/// [`clipped_image`] with access to the picture, for loading and fallback views.\npub fn clipped_image_with(\n    source: impl Into<ImageSource>,\n    radius: Pixels,\n    fit: ObjectFit,\n    theme: &UiTheme,\n    configure: impl FnOnce(Img) -> Img,\n) -> Div {\n    div()\n        .relative()\n        .flex_shrink_0()\n        .overflow_hidden()\n        .rounded(radius)\n        .bg(theme.colors.muted)\n        .child(configure(\n            image(source)\n                .absolute()\n                .inset_0()\n                .size_full()\n                .rounded(radius)\n                .object_fit(fit),\n        ))\n}\n\n/// A circular image, as in avatars.\npub fn round_image(source: impl Into<ImageSource>, size: Pixels, theme: &UiTheme) -> Div {\n    clipped_image(source, size / 2., ObjectFit::Cover, theme).size(size)\n}\n\n/// Dismisses an overlay from a press outside it or the Escape key.\npub mod dismiss {\n    use super::*;\n\n    /// Runs `handler` when Escape is pressed while focus is inside `element`.\n    /// `handler` returns whether it handled the key; when it did not, Escape\n    /// goes on to the overlay or shortcut around it.\n    ///\n    /// Escape arrives as the `Dismiss` action in its own key context, so it\n    /// wins over an application's Escape binding (bindings run before key\n    /// listeners, and a deeper context wins). The element takes that key\n    /// context, so don't use this on an element with a key context of its\n    /// own.\n    pub fn on_escape<E: InteractiveElement>(\n        element: E,\n        handler: impl Fn(&mut Window, &mut gpui_kit::App) -> bool + 'static,\n    ) -> E {\n        element\n            .key_context(super::super::DISMISS_CONTEXT)\n            .on_action(move |_: &super::super::Dismiss, window, cx| {\n                if !handler(window, cx) {\n                    cx.propagate();\n                }\n            })\n    }\n\n    /// Runs `handler` when the pointer presses outside `element` or Escape is\n    /// pressed while focus is inside it.\n    pub fn on_outside<E: StatefulInteractiveElement>(\n        element: E,\n        handler: impl Fn(&mut Window, &mut gpui_kit::App) + 'static,\n    ) -> E {\n        let handler = std::rc::Rc::new(handler);\n        let on_press = handler.clone();\n        on_escape(\n            element.on_mouse_down_out(move |event, window, cx| {\n                if event.button == MouseButton::Left {\n                    on_press(window, cx)\n                }\n            }),\n            move |window, cx| {\n                handler(window, cx);\n                true\n            },\n        )\n    }\n}\n\n/// Hover-revealed content that never changes layout: the element keeps its\n/// size and only its opacity follows `visible`.\npub fn hover_reveal<T: Styled>(element: T, visible: bool) -> T {\n    element.opacity(if visible { 1. } else { 0. })\n}\n\n/// Content shown while the pointer is over the enclosing `.group(name)`\n/// element, with no state and no re-render: opacity 0 at rest, 1 on hover.\n/// Pass `pinned` to keep it visible, as for a selected row's actions.\npub fn hover_reveal_in_group<T: Styled + InteractiveElement>(\n    element: T,\n    group: impl Into<SharedString>,\n    pinned: bool,\n) -> T {\n    if pinned {\n        element\n    } else {\n        element\n            .opacity(0.)\n            .group_hover(group, |style| style.opacity(1.))\n    }\n}\n\n/// Erases an element's type after styling, for callers that store children.\npub fn erase(element: impl IntoElement) -> AnyElement {\n    element.into_any_element()\n}\n\n/// A press that belongs to a control. GPUI runs a parent's click handler\n/// after its child's unless the child stops propagation, and the window's\n/// text selection starts from any press; a control that claims its press\n/// keeps both from happening, so a click on a button inside a clickable row\n/// is the button's alone and pressing it never starts a selection.\npub mod press {\n    use gpui_kit::{App, InteractiveElement, MouseButton, base::GlobalState};\n\n    /// Claims every left press on `element` for it.\n    pub fn claim<T: InteractiveElement>(element: T) -> T {\n        element.on_mouse_down(MouseButton::Left, |_, _, cx| claim_now(cx))\n    }\n\n    /// Claims the current press, from inside a mouse-down handler.\n    pub fn claim_now(cx: &mut App) {\n        GlobalState::init(cx);\n        GlobalState::suppress_text_selection(cx);\n    }\n\n    /// Whether a control claimed the current press. A clickable container\n    /// checks this in its click handler and leaves the click to the control.\n    pub fn claimed(cx: &App) -> bool {\n        cx.has_global::<GlobalState>() && GlobalState::is_text_selection_suppressed(cx)\n    }\n\n    /// Forgets the last press's claim. Call it in the capture phase of a\n    /// container's mouse down, so a claim never outlives its press in a\n    /// window without a selection root (which does this itself).\n    pub fn reset(cx: &mut App) {\n        if cx.has_global::<GlobalState>() {\n            GlobalState::reset_text_selection_suppression(cx);\n        }\n    }\n}\n"
    },
    {
      "path": "registry/theme/theme.rs",
      "type": "registry:file",
      "target": "~/src/ui/theme.rs",
      "content": "//! The app-owned shadcn Neutral theme for gpuicn.\n//!\n//! Source: shadcn/ui 4.19.0 at\n//! `1773ecfeeb4a04366978d353e69b5c7ded78dcb2`, Nova style.\n\nuse std::{sync::Arc, time::Duration};\n\nuse gpui_kit::{\n    App, BoxShadow, ElementId, Global, Pixels, Rgba, SharedString, Styled, Subscription, Window,\n    WindowAppearance, black, px,\n};\n\n#[path = \"locale.rs\"]\npub mod locale;\n#[path = \"primitives.rs\"]\npub mod primitives;\n\npub use locale::{Direction, UiText};\n\ngpui_kit::actions!(\n    gpuicn,\n    [\n        /// Move to the next keyboard tab stop.\n        FocusNext,\n        /// Move to the previous keyboard tab stop.\n        FocusPrevious,\n        /// Close the innermost dismissable overlay (Escape).\n        Dismiss\n    ]\n);\n\nstruct Initialized;\nimpl Global for Initialized {}\n\n/// The key context of an overlay that closes on Escape: dialogs, popovers\n/// and the lightbox. Its Escape binding is deeper than any application\n/// context around the overlay, so an app's own Escape shortcut (such as\n/// \"mark read\") never swallows the key while an overlay has focus.\npub const DISMISS_CONTEXT: &str = \"GpuicnDismiss\";\n\n/// The key context of a one-time-code field, which binds the paste shortcut.\n#[doc(hidden)]\npub const OTP_CONTEXT: &str = \"GpuicnOtp\";\n\n/// Installs component actions, keyboard traversal and the default theme once.\n/// Call this from application startup for both copied source and crate usage.\npub fn init(cx: &mut App) {\n    if cx.has_global::<Initialized>() {\n        return;\n    }\n    seed_component_fonts(cx);\n    gpui_kit::init(cx);\n    cx.set_global(Initialized);\n    if !cx.has_global::<UiTheme>() {\n        UiTheme::set(cx, UiTheme::neutral_light());\n    } else {\n        let theme = UiTheme::read(cx).clone();\n        sync_component_theme(cx, theme);\n    }\n    cx.bind_keys([\n        gpui_kit::KeyBinding::new(\"tab\", FocusNext, None),\n        gpui_kit::KeyBinding::new(\"shift-tab\", FocusPrevious, None),\n        gpui_kit::KeyBinding::new(\"escape\", Dismiss, Some(DISMISS_CONTEXT)),\n    ]);\n    locale::bind_keys(cx);\n    {\n        use gpui_kit::{KeyBinding, base::input::Paste};\n        let context = Some(OTP_CONTEXT);\n        #[cfg(any(target_os = \"macos\", target_family = \"wasm\"))]\n        cx.bind_keys([KeyBinding::new(\"cmd-v\", Paste, context)]);\n        #[cfg(not(target_os = \"macos\"))]\n        cx.bind_keys([KeyBinding::new(\"ctrl-v\", Paste, context)]);\n    }\n    cx.on_action(|_: &FocusNext, cx| advance_focus(false, cx));\n    cx.on_action(|_: &FocusPrevious, cx| advance_focus(true, cx));\n    // Scoped component bindings take precedence over these window-wide defaults.\n    #[cfg(target_family = \"wasm\")]\n    {\n        // Browser previews also accept macOS editing shortcuts.\n        use gpui_kit::KeyBinding;\n        use gpui_kit::base::input::{\n            Copy, Cut, MoveEnd, MoveHome, MoveToNextWord, MoveToPreviousWord, Paste, Redo,\n            SelectAll, SelectToNextWordEnd, SelectToPreviousWordStart, Undo,\n        };\n        cx.bind_keys([\n            KeyBinding::new(\"cmd-a\", SelectAll, Some(\"Input\")),\n            KeyBinding::new(\"cmd-c\", Copy, Some(\"Input\")),\n            KeyBinding::new(\"cmd-v\", Paste, Some(\"Input\")),\n            KeyBinding::new(\"cmd-x\", Cut, Some(\"Input\")),\n            KeyBinding::new(\"cmd-left\", MoveHome, Some(\"Input\")),\n            KeyBinding::new(\"cmd-right\", MoveEnd, Some(\"Input\")),\n            KeyBinding::new(\"cmd-z\", Undo, Some(\"Input\")),\n            KeyBinding::new(\"cmd-shift-z\", Redo, Some(\"Input\")),\n            KeyBinding::new(\"alt-left\", MoveToPreviousWord, Some(\"Input\")),\n            KeyBinding::new(\"alt-right\", MoveToNextWord, Some(\"Input\")),\n            KeyBinding::new(\"alt-shift-left\", SelectToPreviousWordStart, Some(\"Input\")),\n            KeyBinding::new(\"alt-shift-right\", SelectToNextWordEnd, Some(\"Input\")),\n        ]);\n    }\n}\n\nfn seed_component_fonts(cx: &mut App) {\n    use gpui_kit::component::Theme;\n\n    if cx.has_global::<Theme>() {\n        return;\n    }\n    let fonts = if cx.has_global::<UiTheme>() {\n        UiTheme::read(cx).fonts.clone()\n    } else {\n        UiTheme::neutral_light().fonts\n    };\n    let mut component = Theme::default();\n    component.font_family = fonts.body;\n    component.mono_font_family = fonts.mono;\n    cx.set_global(component);\n}\n\nfn advance_focus(reverse: bool, cx: &mut App) {\n    let Some(handle) = cx.active_window() else {\n        return;\n    };\n    // Action dispatch still holds the window borrow until this callback returns.\n    cx.defer(move |cx| {\n        let _ = handle.update(cx, |_, window, cx| {\n            if reverse {\n                window.focus_prev(cx);\n            } else {\n                window.focus_next(cx);\n            }\n        });\n    });\n}\n\n/// The active color mode.\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum ThemeMode {\n    /// The Neutral light palette.\n    Light,\n    /// The Neutral dark palette.\n    Dark,\n}\n\n/// Which of an application's two palettes is shown.\n#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]\npub enum Appearance {\n    /// Always the light palette.\n    Light,\n    /// Always the dark palette.\n    Dark,\n    /// The palette matching the operating system's window appearance.\n    #[default]\n    System,\n}\n\nimpl Appearance {\n    /// The mode this appearance shows under the given system appearance.\n    pub fn resolve(self, system: WindowAppearance) -> ThemeMode {\n        match self {\n            Appearance::Light => ThemeMode::Light,\n            Appearance::Dark => ThemeMode::Dark,\n            Appearance::System => match system {\n                WindowAppearance::Dark | WindowAppearance::VibrantDark => ThemeMode::Dark,\n                WindowAppearance::Light | WindowAppearance::VibrantLight => ThemeMode::Light,\n            },\n        }\n    }\n}\n\n/// The application's light and dark themes and which one it shows.\n#[derive(Clone)]\nstruct ThemePair {\n    light: UiTheme,\n    dark: UiTheme,\n    appearance: Appearance,\n}\nimpl Global for ThemePair {}\n\n/// Swaps palettes when the operating system's appearance changes while the\n/// application follows it. Call it for each window the application opens and\n/// keep the subscription; `app::run` does this for the first window.\npub fn follow_system(window: &mut Window, cx: &mut App) -> Subscription {\n    UiTheme::apply_appearance(cx);\n    window.observe_window_appearance(|_, cx| UiTheme::apply_appearance(cx))\n}\n\n/// Semantic colors consumed by installed components.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiColors {\n    /// App background.\n    pub background: Rgba,\n    /// Default foreground.\n    pub foreground: Rgba,\n    /// Card background.\n    pub card: Rgba,\n    /// Card foreground.\n    pub card_foreground: Rgba,\n    /// Popover background.\n    pub popover: Rgba,\n    /// Popover foreground.\n    pub popover_foreground: Rgba,\n    /// Primary control background.\n    pub primary: Rgba,\n    /// Primary control foreground.\n    pub primary_foreground: Rgba,\n    /// Secondary control background.\n    pub secondary: Rgba,\n    /// Secondary control foreground.\n    pub secondary_foreground: Rgba,\n    /// Muted background.\n    pub muted: Rgba,\n    /// Muted foreground.\n    pub muted_foreground: Rgba,\n    /// Accent background.\n    pub accent: Rgba,\n    /// Accent foreground.\n    pub accent_foreground: Rgba,\n    /// Destructive action color.\n    pub destructive: Rgba,\n    /// Text on a solid `destructive` surface.\n    pub destructive_foreground: Rgba,\n    /// Positive status, such as a completed upload or an online presence dot.\n    pub success: Rgba,\n    /// Text on a `success` fill.\n    pub success_foreground: Rgba,\n    /// Cautionary status, such as a permalink highlight or a pending state.\n    pub warning: Rgba,\n    /// Text on a `warning` fill.\n    pub warning_foreground: Rgba,\n    /// Informational status.\n    pub info: Rgba,\n    /// Text on an `info` fill.\n    pub info_foreground: Rgba,\n    /// Default border.\n    pub border: Rgba,\n    /// Input border.\n    pub input: Rgba,\n    /// Focus ring.\n    pub ring: Rgba,\n    /// First chart color.\n    pub chart_1: Rgba,\n    /// Second chart color.\n    pub chart_2: Rgba,\n    /// Third chart color.\n    pub chart_3: Rgba,\n    /// Fourth chart color.\n    pub chart_4: Rgba,\n    /// Fifth chart color.\n    pub chart_5: Rgba,\n    /// Sidebar background.\n    pub sidebar: Rgba,\n    /// Sidebar foreground.\n    pub sidebar_foreground: Rgba,\n    /// Sidebar primary background.\n    pub sidebar_primary: Rgba,\n    /// Sidebar primary foreground.\n    pub sidebar_primary_foreground: Rgba,\n    /// Sidebar accent background.\n    pub sidebar_accent: Rgba,\n    /// Sidebar accent foreground.\n    pub sidebar_accent_foreground: Rgba,\n    /// Sidebar border.\n    pub sidebar_border: Rgba,\n    /// Sidebar focus border color.\n    pub sidebar_ring: Rgba,\n    /// Scrim behind modal surfaces.\n    pub overlay: Rgba,\n    /// Markdown link text. `None` follows `primary`; read it with `link()`.\n    pub link: Option<Rgba>,\n    /// Fill behind a mention of the reader, and the tint of a mention row.\n    /// `None` follows `primary`; read it with `mention_highlight()`.\n    pub mention_highlight: Option<Rgba>,\n    /// Text on `mention_highlight`. `None` follows `primary_foreground`.\n    pub mention_highlight_foreground: Option<Rgba>,\n    /// The rule and label marking where new messages start. `None` follows\n    /// `destructive`; read it with `new_messages()`.\n    pub new_messages: Option<Rgba>,\n    /// Quiet sidebar text: read rows, icons and section labels. `None`\n    /// follows `sidebar_foreground` at 70%.\n    pub sidebar_muted_foreground: Option<Rgba>,\n    /// Sidebar mention badges. `None` follows `sidebar_primary`.\n    pub sidebar_badge: Option<Rgba>,\n    /// Text on `sidebar_badge`. `None` follows `sidebar_primary_foreground`.\n    pub sidebar_badge_foreground: Option<Rgba>,\n}\n\nimpl UiColors {\n    /// Markdown link text: `link`, or `primary`.\n    pub fn link(&self) -> Rgba {\n        self.link.unwrap_or(self.primary)\n    }\n    /// Mention fill: `mention_highlight`, or `primary`.\n    pub fn mention_highlight(&self) -> Rgba {\n        self.mention_highlight.unwrap_or(self.primary)\n    }\n    /// Text on the mention fill: `mention_highlight_foreground`, or `primary_foreground`.\n    pub fn mention_highlight_foreground(&self) -> Rgba {\n        self.mention_highlight_foreground\n            .unwrap_or(self.primary_foreground)\n    }\n    /// The new-messages rule: `new_messages`, or `destructive`.\n    pub fn new_messages(&self) -> Rgba {\n        self.new_messages.unwrap_or(self.destructive)\n    }\n    /// Quiet sidebar text: `sidebar_muted_foreground`, or `sidebar_foreground` at 70%.\n    pub fn sidebar_muted_foreground(&self) -> Rgba {\n        self.sidebar_muted_foreground\n            .unwrap_or(self.sidebar_foreground.opacity(0.7))\n    }\n    /// Sidebar mention badge fill: `sidebar_badge`, or `sidebar_primary`.\n    pub fn sidebar_badge(&self) -> Rgba {\n        self.sidebar_badge.unwrap_or(self.sidebar_primary)\n    }\n    /// Text on a sidebar mention badge: `sidebar_badge_foreground`, or\n    /// `sidebar_primary_foreground`.\n    pub fn sidebar_badge_foreground(&self) -> Rgba {\n        self.sidebar_badge_foreground\n            .unwrap_or(self.sidebar_primary_foreground)\n    }\n}\n\n/// Theme font family names. Applications own font loading.\n#[derive(Clone, Debug, PartialEq)]\npub struct UiFonts {\n    /// Default body family.\n    pub body: SharedString,\n    /// Default heading family.\n    pub heading: SharedString,\n    /// Default monospace family.\n    pub mono: SharedString,\n}\n\n/// Corner radii derived from shadcn's 10px base radius.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiRadius {\n    /// Backward-compatible alias for [`Self::lg`].\n    pub base: Pixels,\n    /// Six pixels (`radius * 0.6`).\n    pub sm: Pixels,\n    /// Eight pixels (`radius * 0.8`).\n    pub md: Pixels,\n    /// Ten pixels (the configured base radius).\n    pub lg: Pixels,\n    /// Fourteen pixels (`radius * 1.4`).\n    pub xl: Pixels,\n    /// Eighteen pixels (`radius * 1.8`).\n    pub two_xl: Pixels,\n    /// Twenty-two pixels (`radius * 2.2`).\n    pub three_xl: Pixels,\n    /// Twenty-six pixels (`radius * 2.6`).\n    pub four_xl: Pixels,\n}\n\nimpl UiRadius {\n    /// Derives the complete Nova radius scale from one nonnegative base radius.\n    pub fn new(base: Pixels) -> Self {\n        assert!(f32::from(base).is_finite() && base >= px(0.));\n        Self {\n            base,\n            sm: base * 0.6,\n            md: base * 0.8,\n            lg: base,\n            xl: base * 1.4,\n            two_xl: base * 1.8,\n            three_xl: base * 2.2,\n            four_xl: base * 2.6,\n        }\n    }\n}\n\n/// Shared UI transition durations. Honor these alongside `App::reduce_motion()`.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiMotion {\n    /// Thumb and small-state transitions (150ms by default).\n    pub fast: Duration,\n    /// Panel/layout transitions (200ms by default).\n    pub normal: Duration,\n    /// Application preference; true removes movement without removing state feedback.\n    pub reduced: bool,\n    /// Shared easing for reversible state transitions.\n    pub easing: UiEasing,\n}\nimpl Default for UiMotion {\n    fn default() -> Self {\n        Self {\n            fast: Duration::from_millis(150),\n            normal: Duration::from_millis(200),\n            reduced: false,\n            easing: UiEasing::EaseInOut,\n        }\n    }\n}\n\n/// Curves supported by the shared native transition helper.\n#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]\npub enum UiEasing {\n    /// Constant-speed motion, as used by shadcn sidebar layout transitions.\n    Linear,\n    /// Fast response followed by a smooth stop.\n    EaseOut,\n    /// Smooth acceleration and deceleration for changes within a layout.\n    #[default]\n    EaseInOut,\n    /// Quick start and a long settle (`cubic-bezier(0.22, 1, 0.36, 1)`), for\n    /// surfaces that slide in from an edge, such as drawers and sheets.\n    Emphasized,\n}\nimpl UiEasing {\n    fn sample(self, progress: f32) -> f32 {\n        match self {\n            Self::Linear => progress,\n            Self::EaseOut => gpui_kit::ease_out_quint()(progress),\n            Self::EaseInOut => gpui_kit::ease_in_out(progress),\n            Self::Emphasized => gpui_kit::base::motion::Easing::CubicBezier {\n                x1: 0.22,\n                y1: 1.,\n                x2: 0.36,\n                y2: 1.,\n            }\n            .sample(progress),\n        }\n    }\n}\n\n/// Steps per second of a looping indicator, such as a spinner or a skeleton's pulse.\n/// A loop drawn every frame redraws its view 60 or 120 times a second for as long\n/// as it shows, which can be minutes for a connection banner; a dozen steps read\n/// as the same motion.\npub const LOOP_STEPS_PER_SECOND: u32 = 12;\n\n/// Where a looping indicator is in its cycle of `period`, from 0 to 1. The value\n/// moves in [`LOOP_STEPS_PER_SECOND`] steps on one clock shared by every loop, and\n/// the view that draws it is asked to redraw once at the next step, however many\n/// loops it holds, and only while its window is active: a loop in a background\n/// window costs nothing until the window comes forward (activation redraws it).\npub fn loop_phase(period: Duration, window: &mut Window, cx: &mut App) -> f32 {\n    thread_local! {\n        static EPOCH: std::cell::OnceCell<web_time::Instant> = const { std::cell::OnceCell::new() };\n        static WAITING: std::cell::RefCell<std::collections::HashSet<gpui_kit::EntityId>> =\n            Default::default();\n    }\n    let step = Duration::from_secs(1) / LOOP_STEPS_PER_SECOND;\n    // The executor's clock, so the steps follow simulated time in tests.\n    let now = cx.background_executor().now();\n    let elapsed = EPOCH.with(|epoch| now.duration_since(*epoch.get_or_init(|| now)));\n    let steps = (period.as_secs_f64() / step.as_secs_f64()).round().max(1.);\n    let at = (elapsed.as_secs_f64() / step.as_secs_f64()).floor();\n    let phase = ((at % steps) / steps) as f32;\n    let view = window.current_view();\n    if window.is_window_active() && WAITING.with(|waiting| waiting.borrow_mut().insert(view)) {\n        let next = step.mul_f64(at + 1.);\n        let wait = next.saturating_sub(elapsed);\n        cx.spawn(async move |cx| {\n            cx.background_executor().timer(wait).await;\n            WAITING.with(|waiting| waiting.borrow_mut().remove(&view));\n            cx.update(|cx| cx.notify(view));\n        })\n        .detach();\n    }\n    phase\n}\n\n/// Returns a smoothly retargetable value for one stable, caller-named property.\n/// Starts at the target on mount; rapid reversals continue from the current value.\n/// Honors theme and GPUI reduced-motion settings and schedules no idle frames.\n/// Use for state changes, never for pointer-drag coordinates or keyboard navigation.\n/// Native layout transitions perform layout work; retain expensive child entities.\npub fn transition_value(\n    id: impl Into<ElementId>,\n    target: f32,\n    duration: Duration,\n    window: &mut Window,\n    cx: &mut App,\n) -> f32 {\n    let easing = UiTheme::read(cx).motion.easing;\n    transition_with(id, target, duration, easing, window, cx)\n}\n\n/// [`transition_value`] with an explicit curve, for the few surfaces whose motion\n/// differs from the theme default (drawers slide with [`UiEasing::Emphasized`]).\npub fn transition_with(\n    id: impl Into<ElementId>,\n    target: f32,\n    duration: Duration,\n    easing: UiEasing,\n    window: &mut Window,\n    cx: &mut App,\n) -> f32 {\n    assert!(target.is_finite(), \"transition targets must be finite\");\n    gpui_kit::base::motion::transition(\n        id.into(),\n        target,\n        motion_policy(duration, easing, cx),\n        window,\n        cx,\n    )\n}\n\n/// Shares the theme's disclosure and notification timing with Kit's presence lifecycle.\n/// Returns a sample whose `progress` runs 0→1 while entering and 1→0 while leaving, so\n/// a surface fades or scales with it; `should_render()` keeps the element mounted\n/// until the exit transition has finished.\n#[doc(hidden)]\npub fn presence(\n    id: impl Into<ElementId>,\n    present: bool,\n    window: &mut Window,\n    cx: &mut App,\n) -> gpui_kit::base::motion::PresenceSample {\n    let motion = UiTheme::read(cx).motion;\n    presence_with(id, present, motion.fast, motion.easing, window, cx)\n}\n\n/// [`presence`] with explicit timing and curve, for panels that take the theme's\n/// `normal` duration or a different easing.\n#[doc(hidden)]\npub fn presence_with(\n    id: impl Into<ElementId>,\n    present: bool,\n    duration: Duration,\n    easing: UiEasing,\n    window: &mut Window,\n    cx: &mut App,\n) -> gpui_kit::base::motion::PresenceSample {\n    gpui_kit::base::motion::Presence::new(id.into(), present)\n        .transition(motion_policy(duration, easing, cx))\n        .sample(window, cx)\n}\n\n/// The one place motion honors the theme and platform reduced-motion settings.\nfn motion_policy(\n    duration: Duration,\n    easing: UiEasing,\n    cx: &App,\n) -> gpui_kit::base::motion::Transition {\n    let duration = if UiTheme::read(cx).motion.reduced || cx.reduce_motion() {\n        Duration::ZERO\n    } else {\n        duration\n    };\n    gpui_kit::base::motion::Transition::new(duration).ease(move |progress| easing.sample(progress))\n}\n\n/// Shared shadcn elevation tokens. Each level is shared, so cloning a theme\n/// every render costs no allocation; `to_vec()` the level you apply.\n#[derive(Clone, Debug, PartialEq)]\npub struct UiShadows {\n    /// Tailwind `shadow-sm`.\n    pub sm: Arc<[BoxShadow]>,\n    /// Tailwind `shadow-md`.\n    pub md: Arc<[BoxShadow]>,\n    /// Tailwind `shadow-lg`.\n    pub lg: Arc<[BoxShadow]>,\n}\n\n/// One step of the type scale: a text size and the line height that goes with it.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiTextStyle {\n    /// Font size before `text_scale`.\n    pub size: Pixels,\n    /// Line height before `text_scale`.\n    pub line_height: Pixels,\n}\n\n/// The type scale, Tailwind's by default. Components read sizes from here through\n/// `primitives::text`, so `text_scale` and a custom scale reach every label.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiTypography {\n    /// Captions and key caps (12/16).\n    pub xs: UiTextStyle,\n    /// Controls and body copy in dense desktop layouts (14/20); the Nova default.\n    pub sm: UiTextStyle,\n    /// Prose and dialog titles (16/24).\n    pub base: UiTextStyle,\n    /// Section headings (18/28).\n    pub lg: UiTextStyle,\n    /// Page headings (20/28).\n    pub xl: UiTextStyle,\n}\n\nimpl Default for UiTypography {\n    fn default() -> Self {\n        let style = |size: f32, line_height: f32| UiTextStyle {\n            size: px(size),\n            line_height: px(line_height),\n        };\n        Self {\n            xs: style(12., 16.),\n            sm: style(14., 20.),\n            base: style(16., 24.),\n            lg: style(18., 28.),\n            xl: style(20., 28.),\n        }\n    }\n}\n\n/// Window widths at which layouts change shape.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiBreakpoints {\n    /// Below this width, sidebars become sheets and drawers fill the window (768px).\n    pub mobile: Pixels,\n    /// Below this width, side drawers take three quarters of the window (640px).\n    pub compact: Pixels,\n}\n\nimpl Default for UiBreakpoints {\n    fn default() -> Self {\n        Self {\n            mobile: px(768.),\n            compact: px(640.),\n        }\n    }\n}\n\n/// Colors every form control shares, derived once from the palette and mode so\n/// no component chooses its own dark-mode alpha. These follow shadcn Nova's\n/// `dark:bg-input/30`, `dark:hover:bg-input/50` and `dark:border-input` rules.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct ControlColors {\n    /// Resting fill of inputs, checkboxes, radios and outline buttons.\n    pub background: Rgba,\n    /// Resting border of the same controls.\n    pub border: Rgba,\n    /// Hover fill of outline, ghost and toggle controls.\n    pub hover: Rgba,\n    /// Hover fill of ghost buttons and plain icon buttons.\n    pub ghost_hover: Rgba,\n    /// Fill of a pressed toggle or selected tab.\n    pub pressed: Rgba,\n    /// Fill of the pressed option of a segmented toggle group, raised on\n    /// the group's muted track.\n    pub segment: Rgba,\n    /// Unchecked switch track.\n    pub track: Rgba,\n    /// Switch thumb on the unchecked track.\n    pub thumb: Rgba,\n    /// Switch thumb on the checked (`primary`) track.\n    pub thumb_checked: Rgba,\n    /// Tinted destructive fill, for destructive buttons, badges and tags.\n    pub destructive_background: Rgba,\n    /// Hover of the tinted destructive fill.\n    pub destructive_hover: Rgba,\n    /// Hairline around tinted destructive chips.\n    pub destructive_border: Rgba,\n    /// Focus ring color at Nova's 50% opacity.\n    pub ring: Rgba,\n    /// Focus ring of an invalid control.\n    pub invalid_ring: Rgba,\n    /// Hairline around popovers and dialogs (`ring-foreground/10`).\n    pub surface_border: Rgba,\n}\n\n/// Base spacing unit from the pinned Nova style.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub struct UiSpacing {\n    /// Four pixels.\n    pub unit: Pixels,\n}\n\n/// The application-owned theme stored in GPUI global state.\n#[derive(Clone, Debug, PartialEq)]\npub struct UiTheme {\n    /// Active color mode.\n    pub mode: ThemeMode,\n    /// Active semantic colors.\n    pub colors: UiColors,\n    /// Font family names.\n    pub fonts: UiFonts,\n    /// Base corner radius.\n    pub radius: UiRadius,\n    /// Base spacing unit.\n    pub spacing: UiSpacing,\n    /// Shared elevation tokens.\n    pub shadows: UiShadows,\n    /// Shared motion durations and reduced-motion preference.\n    pub motion: UiMotion,\n    /// Typography scale, independent of control density (1 by default).\n    pub text_scale: f32,\n    /// Text sizes and line heights, multiplied by `text_scale` when applied.\n    pub typography: UiTypography,\n    /// Window widths at which layouts change shape.\n    pub breakpoints: UiBreakpoints,\n    /// Syntax colors and surface of Markdown code blocks.\n    pub code_theme: CodeTheme,\n    /// Layout direction. [`locale::set_direction`] sets it and keeps it\n    /// across theme swaps; [`UiTheme::set`] overwrites it with that setting.\n    pub direction: Direction,\n}\n\n/// The syntax theme of Markdown code blocks, as in Mattermost's `codeTheme`.\n///\n/// `Default` follows the light or dark mode on the theme's muted code\n/// surface. The named themes bring their own background and text color, so\n/// a dark code theme stays readable in a light window.\n#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]\npub enum CodeTheme {\n    /// GPUI Kit's light or dark syntax colors, by mode.\n    #[default]\n    Default,\n    /// GitHub's light syntax colors.\n    GitHub,\n    /// Monokai: bright syntax on a dark olive surface.\n    Monokai,\n    /// Solarized, dark variant.\n    SolarizedDark,\n    /// Solarized, light variant.\n    SolarizedLight,\n}\n\nimpl CodeTheme {\n    /// Every code theme, for a settings picker.\n    pub const ALL: [CodeTheme; 5] = [\n        CodeTheme::Default,\n        CodeTheme::GitHub,\n        CodeTheme::Monokai,\n        CodeTheme::SolarizedDark,\n        CodeTheme::SolarizedLight,\n    ];\n\n    /// Reads Mattermost's names: `github`, `monokai`, `solarized-dark`,\n    /// `solarized-light`, and `default`.\n    pub fn from_name(name: &str) -> Option<Self> {\n        Some(match name.trim().to_ascii_lowercase().as_str() {\n            \"default\" | \"\" => Self::Default,\n            \"github\" => Self::GitHub,\n            \"monokai\" => Self::Monokai,\n            \"solarized-dark\" | \"solarized_dark\" => Self::SolarizedDark,\n            \"solarized-light\" | \"solarized_light\" => Self::SolarizedLight,\n            _ => return None,\n        })\n    }\n\n    /// The name `from_name` reads.\n    pub fn name(self) -> &'static str {\n        match self {\n            Self::Default => \"default\",\n            Self::GitHub => \"github\",\n            Self::Monokai => \"monokai\",\n            Self::SolarizedDark => \"solarized-dark\",\n            Self::SolarizedLight => \"solarized-light\",\n        }\n    }\n\n    /// The code block's own background and text color, or `None` for the\n    /// theme's muted surface.\n    pub fn surface(self) -> Option<(Rgba, Rgba)> {\n        let hex = |value: u32| gpui_kit::rgb(value);\n        match self {\n            Self::Default => None,\n            Self::GitHub => Some((hex(0xf6f8fa), hex(0x24292e))),\n            Self::Monokai => Some((hex(0x272822), hex(0xf8f8f2))),\n            Self::SolarizedDark => Some((hex(0x002b36), hex(0x839496))),\n            Self::SolarizedLight => Some((hex(0xfdf6e3), hex(0x657b83))),\n        }\n    }\n\n    /// The Kit highlight theme for this code theme in `mode`, built once.\n    #[doc(hidden)]\n    pub fn highlight_theme(\n        self,\n        mode: ThemeMode,\n    ) -> Arc<gpui_kit::component::highlighter::HighlightTheme> {\n        use gpui_kit::component::highlighter::HighlightTheme;\n        use std::sync::OnceLock;\n        static BUILT: [OnceLock<Arc<HighlightTheme>>; 4] = [const { OnceLock::new() }; 4];\n        // (keyword, string, comment, function, number, type, tag, attribute,\n        //  property, operator, variable)\n        let (index, palette, dark) = match self {\n            Self::Default => {\n                return match mode {\n                    ThemeMode::Light => HighlightTheme::default_light(),\n                    ThemeMode::Dark => HighlightTheme::default_dark(),\n                };\n            }\n            Self::GitHub => (\n                0,\n                [\n                    \"#d73a49\", \"#032f62\", \"#6a737d\", \"#6f42c1\", \"#005cc5\", \"#e36209\", \"#22863a\",\n                    \"#6f42c1\", \"#005cc5\", \"#d73a49\", \"#24292e\",\n                ],\n                false,\n            ),\n            Self::Monokai => (\n                1,\n                [\n                    \"#f92672\", \"#e6db74\", \"#75715e\", \"#a6e22e\", \"#ae81ff\", \"#66d9ef\", \"#f92672\",\n                    \"#a6e22e\", \"#fd971f\", \"#f92672\", \"#f8f8f2\",\n                ],\n                true,\n            ),\n            Self::SolarizedDark => (\n                2,\n                [\n                    \"#859900\", \"#2aa198\", \"#586e75\", \"#268bd2\", \"#d33682\", \"#b58900\", \"#268bd2\",\n                    \"#93a1a1\", \"#268bd2\", \"#859900\", \"#839496\",\n                ],\n                true,\n            ),\n            Self::SolarizedLight => (\n                3,\n                [\n                    \"#859900\", \"#2aa198\", \"#93a1a1\", \"#268bd2\", \"#d33682\", \"#b58900\", \"#268bd2\",\n                    \"#586e75\", \"#268bd2\", \"#859900\", \"#657b83\",\n                ],\n                false,\n            ),\n        };\n        BUILT[index]\n            .get_or_init(|| {\n                let [\n                    keyword,\n                    string,\n                    comment,\n                    function,\n                    number,\n                    kind,\n                    tag,\n                    attribute,\n                    property,\n                    operator,\n                    variable,\n                ] = palette;\n                let color = |value: &str| gpui_kit::private::serde_json::json!({ \"color\": value });\n                let json = gpui_kit::private::serde_json::json!({\n                    \"name\": self.name(),\n                    \"appearance\": if dark { \"dark\" } else { \"light\" },\n                    \"style\": {\n                        \"syntax\": {\n                            \"keyword\": color(keyword),\n                            \"string\": color(string),\n                            \"string.escape\": color(number),\n                            \"comment\": { \"color\": comment, \"font_style\": \"italic\" },\n                            \"comment.doc\": { \"color\": comment, \"font_style\": \"italic\" },\n                            \"function\": color(function),\n                            \"constructor\": color(function),\n                            \"number\": color(number),\n                            \"boolean\": color(number),\n                            \"constant\": color(number),\n                            \"type\": color(kind),\n                            \"enum\": color(kind),\n                            \"tag\": color(tag),\n                            \"attribute\": color(attribute),\n                            \"property\": color(property),\n                            \"operator\": color(operator),\n                            \"variable\": color(variable),\n                            \"punctuation\": color(variable),\n                            \"title\": { \"color\": function, \"font_weight\": 700 },\n                            \"link_uri\": color(string),\n                            \"link_text\": color(function),\n                        }\n                    }\n                });\n                Arc::new(\n                    gpui_kit::private::serde_json::from_value::<HighlightTheme>(json)\n                        .expect(\"the code theme palettes are valid\"),\n                )\n            })\n            .clone()\n    }\n}\n\nimpl Global for UiTheme {}\n\nimpl Default for UiTheme {\n    fn default() -> Self {\n        Self::neutral_light()\n    }\n}\n\nimpl UiTheme {\n    /// Creates the pinned Neutral light theme.\n    pub fn neutral_light() -> Self {\n        Self::new(ThemeMode::Light, neutral_light_colors())\n    }\n\n    /// Creates the pinned Neutral dark theme.\n    pub fn neutral_dark() -> Self {\n        Self::new(ThemeMode::Dark, neutral_dark_colors())\n    }\n\n    /// Installs light and dark themes together and shows the one the current\n    /// [`Appearance`] selects (System until [`UiTheme::set_appearance`] says\n    /// otherwise). [`follow_system`] keeps the pair in step with the OS.\n    pub fn set_pair(cx: &mut App, light: Self, dark: Self) {\n        let appearance = cx\n            .try_global::<ThemePair>()\n            .map_or(Appearance::System, |pair| pair.appearance);\n        cx.set_global(ThemePair {\n            light,\n            dark,\n            appearance,\n        });\n        Self::apply_appearance(cx);\n    }\n\n    /// Chooses which of the installed pair to show. Without a pair, the\n    /// pinned Neutral palettes stand in.\n    pub fn set_appearance(cx: &mut App, appearance: Appearance) {\n        match cx.try_global::<ThemePair>() {\n            Some(_) => cx.global_mut::<ThemePair>().appearance = appearance,\n            None => cx.set_global(ThemePair {\n                light: Self::neutral_light(),\n                dark: Self::neutral_dark(),\n                appearance,\n            }),\n        }\n        Self::apply_appearance(cx);\n    }\n\n    /// The appearance the application asked for, System when none was set.\n    pub fn appearance(cx: &App) -> Appearance {\n        cx.try_global::<ThemePair>()\n            .map_or(Appearance::System, |pair| pair.appearance)\n    }\n\n    /// Installs the pair member the appearance selects, if a pair is installed.\n    fn apply_appearance(cx: &mut App) {\n        let Some(pair) = cx.try_global::<ThemePair>().cloned() else {\n            return;\n        };\n        let theme = match pair.appearance.resolve(cx.window_appearance()) {\n            ThemeMode::Light => pair.light,\n            ThemeMode::Dark => pair.dark,\n        };\n        let current = cx.try_global::<Self>();\n        if current\n            .is_some_and(|current| current.mode == theme.mode && current.colors == theme.colors)\n        {\n            return;\n        }\n        Self::set(cx, theme);\n    }\n\n    /// Installs a theme into the application.\n    pub fn set(cx: &mut App, mut theme: Self) {\n        theme.direction = locale::direction(cx);\n        assert!(f32::from(theme.spacing.unit).is_finite() && theme.spacing.unit > px(0.));\n        assert!(theme.text_scale.is_finite() && theme.text_scale > 0.);\n        sync_component_theme(cx, theme.clone());\n        cx.set_global(theme);\n        cx.refresh_windows();\n    }\n\n    /// Reads the installed theme.\n    ///\n    /// Panics when the application has not installed a theme.\n    #[track_caller]\n    pub fn read(cx: &App) -> &Self {\n        cx.try_global::<Self>().expect(\n            \"gpuicn theme is not installed: call `ui::theme::init(cx)` once at application startup\",\n        )\n    }\n\n    /// Builds a theme from shadcn theme CSS, such as the output of the shadcn\n    /// theme picker or tweakcn.\n    ///\n    /// Light reads `:root`; dark reads `:root` and then `.dark`, like the\n    /// browser cascade. Recognized `--background`, `--primary`, `--sidebar-*`,\n    /// `--chart-*` and `--radius` declarations replace the Neutral defaults;\n    /// other declarations are ignored. Colors may use `oklch()`, `hsl()`,\n    /// bare HSL triplets, `rgb()` or hex. Build both modes and call\n    /// [`UiTheme::set`] to switch; [`UiTheme::switch`] restores Neutral colors.\n    pub fn from_shadcn_css(css: &str, mode: ThemeMode) -> Result<Self, ThemeCssError> {\n        let blocks = css_blocks(css);\n        let mut theme = match mode {\n            ThemeMode::Light => Self::neutral_light(),\n            ThemeMode::Dark => Self::neutral_dark(),\n        };\n        let mut selectors = vec![\":root\"];\n        if mode == ThemeMode::Dark {\n            selectors.push(\".dark\");\n        }\n        for selector in selectors {\n            let declarations = blocks\n                .iter()\n                .filter(|(name, _)| name.split(',').any(|part| part.trim() == selector))\n                .flat_map(|(_, body)| body.split(';'))\n                .collect::<Vec<_>>();\n            if declarations.is_empty() {\n                return Err(ThemeCssError(format!(\"no `{selector}` block found\")));\n            }\n            for declaration in declarations {\n                let Some((name, value)) = declaration.split_once(':') else {\n                    continue;\n                };\n                let (name, value) = (name.trim(), value.trim());\n                let Some(name) = name.strip_prefix(\"--\") else {\n                    continue;\n                };\n                if name == \"radius\" {\n                    theme.radius = UiRadius::new(css_length(value).ok_or_else(|| {\n                        ThemeCssError(format!(\"unsupported length `--radius: {value}`\"))\n                    })?);\n                } else if let Some(slot) = theme.colors.slot(name) {\n                    *slot = css_color(value).ok_or_else(|| {\n                        ThemeCssError(format!(\"unsupported color `--{name}: {value}`\"))\n                    })?;\n                } else if let Some(slot) = theme.colors.optional_slot(name) {\n                    *slot = Some(css_color(value).ok_or_else(|| {\n                        ThemeCssError(format!(\"unsupported color `--{name}: {value}`\"))\n                    })?);\n                }\n            }\n        }\n        Ok(theme)\n    }\n\n    /// Selects the pinned palette, preserving non-color tokens or initializing defaults.\n    pub fn switch(cx: &mut App, mode: ThemeMode) {\n        let mut theme = cx\n            .try_global::<Self>()\n            .cloned()\n            .unwrap_or_else(Self::neutral_light);\n        theme.mode = mode;\n        theme.colors = match mode {\n            ThemeMode::Light => neutral_light_colors(),\n            ThemeMode::Dark => neutral_dark_colors(),\n        };\n        Self::set(cx, theme);\n    }\n\n    /// Returns a multiple of the configured spacing unit (2 means 8px by default).\n    pub fn space(&self, units: f32) -> Pixels {\n        self.spacing.unit * units\n    }\n\n    /// Scales typography independently of spacing; sizes use Nova's default pixels.\n    pub fn text(&self, size: f32) -> Pixels {\n        px(size * self.text_scale)\n    }\n\n    fn new(mode: ThemeMode, colors: UiColors) -> Self {\n        Self {\n            mode,\n            colors,\n            fonts: UiFonts {\n                body: \"Geist\".into(),\n                heading: \"Geist\".into(),\n                mono: \"Geist Mono\".into(),\n            },\n            radius: UiRadius::new(px(10.)),\n            motion: UiMotion::default(),\n            text_scale: 1.,\n            typography: UiTypography::default(),\n            breakpoints: UiBreakpoints::default(),\n            code_theme: CodeTheme::Default,\n            direction: Direction::Ltr,\n            spacing: UiSpacing { unit: px(4.) },\n            shadows: UiShadows {\n                sm: Arc::from([\n                    BoxShadow::new(px(0.), px(1.), black().alpha(0.10)).blur_radius(px(3.)),\n                    BoxShadow::new(px(0.), px(1.), black().alpha(0.10))\n                        .blur_radius(px(2.))\n                        .spread_radius(px(-1.)),\n                ]),\n                md: Arc::from([\n                    BoxShadow::new(px(0.), px(4.), black().alpha(0.10))\n                        .blur_radius(px(6.))\n                        .spread_radius(px(-1.)),\n                    BoxShadow::new(px(0.), px(2.), black().alpha(0.10))\n                        .blur_radius(px(4.))\n                        .spread_radius(px(-2.)),\n                ]),\n                lg: Arc::from([\n                    BoxShadow::new(px(0.), px(10.), black().alpha(0.10))\n                        .blur_radius(px(15.))\n                        .spread_radius(px(-3.)),\n                    BoxShadow::new(px(0.), px(4.), black().alpha(0.10))\n                        .blur_radius(px(6.))\n                        .spread_radius(px(-4.)),\n                ]),\n            },\n        }\n    }\n\n    /// The shared form-control colors for the active mode. See [`ControlColors`].\n    pub fn control(&self) -> ControlColors {\n        let colors = self.colors;\n        let dark = self.mode == ThemeMode::Dark;\n        ControlColors {\n            background: if dark {\n                colors.input.opacity(0.30)\n            } else {\n                colors.background.opacity(0.)\n            },\n            border: colors.input,\n            hover: if dark {\n                colors.input.opacity(0.50)\n            } else {\n                colors.muted\n            },\n            ghost_hover: if dark {\n                colors.muted.opacity(0.50)\n            } else {\n                colors.muted\n            },\n            pressed: colors.muted,\n            segment: if dark {\n                colors.secondary\n            } else {\n                colors.background\n            },\n            track: if dark {\n                colors.input.opacity(0.80)\n            } else {\n                colors.input\n            },\n            thumb: if dark {\n                colors.foreground\n            } else {\n                colors.background\n            },\n            thumb_checked: if dark {\n                colors.primary_foreground\n            } else {\n                colors.background\n            },\n            destructive_background: colors.destructive.opacity(if dark { 0.20 } else { 0.10 }),\n            destructive_hover: colors.destructive.opacity(if dark { 0.30 } else { 0.20 }),\n            destructive_border: colors.destructive.opacity(0.20),\n            ring: colors.ring.opacity(0.50),\n            invalid_ring: colors.destructive.opacity(0.20),\n            surface_border: colors.foreground.opacity(0.10),\n        }\n    }\n\n    /// `color` composited over the `background` token: the same color with\n    /// no transparency. A translucent fill lets a focus ring's shadow, which\n    /// GPUI paints under the whole box, show through it; this one does not.\n    pub fn opaque(&self, color: Rgba) -> Rgba {\n        let under = self.colors.background;\n        let alpha = color.a.clamp(0., 1.);\n        let mix = |top: f32, bottom: f32| top * alpha + bottom * (1. - alpha);\n        Rgba {\n            r: mix(color.r, under.r),\n            g: mix(color.g, under.g),\n            b: mix(color.b, under.b),\n            a: 1.,\n        }\n    }\n\n    /// A step of the type scale multiplied by `text_scale`.\n    pub fn text_style(&self, style: UiTextStyle) -> UiTextStyle {\n        UiTextStyle {\n            size: style.size * self.text_scale,\n            line_height: style.line_height * self.text_scale,\n        }\n    }\n}\n\nfn sync_component_theme(cx: &mut App, theme: UiTheme) {\n    use gpui_kit::component::{Theme, ThemeTokens};\n\n    if !cx.has_global::<Theme>() {\n        return;\n    }\n\n    let colors = theme.colors;\n    let component = Theme::global_mut(cx);\n    component.mode = match theme.mode {\n        ThemeMode::Light => gpui_kit::component::ThemeMode::Light,\n        ThemeMode::Dark => gpui_kit::component::ThemeMode::Dark,\n    };\n    // Start from Kit's palette for this mode, so colors gpuicn doesn't set\n    // below, such as scrollbar tracks, never keep the other mode's values.\n    component.colors = *match theme.mode {\n        ThemeMode::Light => gpui_kit::component::ThemeColor::light(),\n        ThemeMode::Dark => gpui_kit::component::ThemeColor::dark(),\n    };\n    component.font_family = theme.fonts.body;\n    component.mono_font_family = theme.fonts.mono;\n    component.radius = theme.radius.md;\n    component.radius_lg = theme.radius.lg;\n    component.background = colors.background.into();\n    component.foreground = colors.foreground.into();\n    component.popover = colors.popover.into();\n    component.popover_foreground = colors.popover_foreground.into();\n    component.primary = colors.primary.into();\n    component.primary_foreground = colors.primary_foreground.into();\n    component.secondary = colors.secondary.into();\n    component.secondary_foreground = colors.secondary_foreground.into();\n    component.muted = colors.muted.into();\n    component.muted_foreground = colors.muted_foreground.into();\n    component.accent = colors.accent.into();\n    component.accent_foreground = colors.accent_foreground.into();\n    component.primary_hover = colors.primary.opacity(0.9).into();\n    component.primary_active = colors.primary.opacity(0.8).into();\n    component.secondary_hover = colors.secondary.opacity(0.8).into();\n    component.secondary_active = colors.secondary.opacity(0.7).into();\n    component.border = colors.border.into();\n    component.input = colors.input.into();\n    component.ring = colors.ring.into();\n    component.overlay = colors.overlay.into();\n    component.caret = colors.foreground.into();\n    component.window_border = colors.border.into();\n    component.danger = colors.destructive.into();\n    component.danger_foreground = colors.destructive_foreground.into();\n    component.danger_hover = colors.destructive.opacity(0.9).into();\n    component.danger_active = colors.destructive.opacity(0.8).into();\n    component.success = colors.success.into();\n    component.success_foreground = colors.success_foreground.into();\n    component.success_hover = colors.success.opacity(0.9).into();\n    component.success_active = colors.success.opacity(0.8).into();\n    component.warning = colors.warning.into();\n    component.warning_foreground = colors.warning_foreground.into();\n    component.warning_hover = colors.warning.opacity(0.9).into();\n    component.warning_active = colors.warning.opacity(0.8).into();\n    component.info = colors.info.into();\n    component.info_foreground = colors.info_foreground.into();\n    component.info_hover = colors.info.opacity(0.9).into();\n    component.info_active = colors.info.opacity(0.8).into();\n    component.chart_1 = colors.chart_1.into();\n    component.chart_2 = colors.chart_2.into();\n    component.chart_3 = colors.chart_3.into();\n    component.chart_4 = colors.chart_4.into();\n    component.chart_5 = colors.chart_5.into();\n    component.chart_bullish = colors.success.into();\n    component.chart_bearish = colors.destructive.into();\n    component.chart_grid = colors.border.opacity(0.6).into();\n    // Buttons: Kit's plain button is shadcn `outline`; the variants follow their token.\n    component.button = colors.background.into();\n    component.button_foreground = colors.foreground.into();\n    component.button_hover = colors.accent.into();\n    component.button_active = colors.muted.into();\n    component.button_primary = component.primary;\n    component.button_primary_foreground = component.primary_foreground;\n    component.button_primary_hover = component.primary_hover;\n    component.button_primary_active = component.primary_active;\n    component.button_secondary = component.secondary;\n    component.button_secondary_foreground = component.secondary_foreground;\n    component.button_secondary_hover = component.secondary_hover;\n    component.button_secondary_active = component.secondary_active;\n    component.button_danger = component.danger;\n    component.button_danger_foreground = component.danger_foreground;\n    component.button_danger_hover = component.danger_hover;\n    component.button_danger_active = component.danger_active;\n    component.button_success = component.success;\n    component.button_success_foreground = component.success_foreground;\n    component.button_success_hover = component.success_hover;\n    component.button_success_active = component.success_active;\n    component.button_warning = component.warning;\n    component.button_warning_foreground = component.warning_foreground;\n    component.button_warning_hover = component.warning_hover;\n    component.button_warning_active = component.warning_active;\n    component.button_info = component.info;\n    component.button_info_foreground = component.info_foreground;\n    component.button_info_hover = component.info_hover;\n    component.button_info_active = component.info_active;\n    // Nova scrollbars float over content with no track.\n    component.scrollbar = gpui_kit::transparent_black();\n    component.scrollbar_thumb = colors.border.into();\n    component.scrollbar_thumb_hover = colors.muted_foreground.opacity(0.72).into();\n    component.sidebar = colors.sidebar.into();\n    component.sidebar_foreground = colors.sidebar_foreground.into();\n    component.sidebar_border = colors.sidebar_border.into();\n    component.sidebar_accent = colors.sidebar_accent.into();\n    component.sidebar_accent_foreground = colors.sidebar_accent_foreground.into();\n    component.sidebar_primary = colors.sidebar_primary.into();\n    component.sidebar_primary_foreground = colors.sidebar_primary_foreground.into();\n    component.title_bar = colors.sidebar.into();\n    component.title_bar_border = colors.border.into();\n    component.status_bar = colors.sidebar.into();\n    component.status_bar_border = colors.border.into();\n    // Rich text: links, selection, table headings and code highlighting.\n    component.link = colors.link().into();\n    component.link_hover = colors.link().opacity(0.9).into();\n    component.link_active = colors.link().opacity(0.8).into();\n    component.selection = colors.ring.opacity(0.3).into();\n    component.description_list_label = colors.muted.into();\n    component.description_list_label_foreground = colors.muted_foreground.into();\n    component.group_box = colors.card.into();\n    component.group_box_foreground = colors.card_foreground.into();\n    component.accordion = colors.card.into();\n    // Lists and tables share the `muted` zebra and the `accent` hover of menus.\n    component.colors.list = colors.background.into();\n    component.list_even = colors.muted.opacity(0.5).into();\n    component.list_head = colors.muted.into();\n    component.list_hover = colors.accent.into();\n    // Kit draws query matches in Select, Combobox and Command with this.\n    component.list_highlight_foreground = colors.primary.into();\n    component.list_active = colors.accent.into();\n    component.list_active_border = colors.ring.into();\n    component.table = colors.background.into();\n    component.table_even = colors.muted.opacity(0.5).into();\n    component.table_hover = colors.muted.opacity(0.5).into();\n    component.table_active = colors.accent.into();\n    component.table_active_border = colors.ring.into();\n    component.table_row_border = colors.border.into();\n    component.table_head = colors.muted.into();\n    component.table_head_foreground = colors.foreground.into();\n    component.table_foot = colors.muted.opacity(0.5).into();\n    component.table_foot_foreground = colors.foreground.into();\n    // Controls: shadcn tracks are `input`, thumbs and active tabs are `background`.\n    component.switch = colors.input.into();\n    component.switch_thumb = colors.background.into();\n    component.slider_bar = colors.primary.into();\n    component.slider_thumb = colors.background.into();\n    component.progress_bar = colors.primary.into();\n    component.skeleton = colors.accent.into();\n    component.tab_bar = colors.muted.into();\n    component.tab_bar_segmented = colors.muted.into();\n    component.tab_foreground = colors.muted_foreground.into();\n    component.tab_active = colors.background.into();\n    component.tab_active_foreground = colors.foreground.into();\n    component.drag_border = colors.ring.into();\n    component.drop_target = colors.ring.opacity(0.15).into();\n    component.highlight_theme = theme.code_theme.highlight_theme(theme.mode);\n    component.tokens = ThemeTokens::from(&component.colors);\n\n    Theme::sync_base(cx);\n}\n\n/// Why [`UiTheme::from_shadcn_css`] could not read a theme.\n#[derive(Clone, Debug, PartialEq)]\npub struct ThemeCssError(pub String);\n\nimpl std::fmt::Display for ThemeCssError {\n    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n        write!(formatter, \"shadcn theme CSS: {}\", self.0)\n    }\n}\n\nimpl std::error::Error for ThemeCssError {}\n\nimpl UiColors {\n    #[doc(hidden)]\n    pub fn slot(&mut self, variable: &str) -> Option<&mut Rgba> {\n        Some(match variable {\n            \"background\" => &mut self.background,\n            \"foreground\" => &mut self.foreground,\n            \"card\" => &mut self.card,\n            \"card-foreground\" => &mut self.card_foreground,\n            \"popover\" => &mut self.popover,\n            \"popover-foreground\" => &mut self.popover_foreground,\n            \"primary\" => &mut self.primary,\n            \"primary-foreground\" => &mut self.primary_foreground,\n            \"secondary\" => &mut self.secondary,\n            \"secondary-foreground\" => &mut self.secondary_foreground,\n            \"muted\" => &mut self.muted,\n            \"muted-foreground\" => &mut self.muted_foreground,\n            \"accent\" => &mut self.accent,\n            \"accent-foreground\" => &mut self.accent_foreground,\n            \"destructive\" => &mut self.destructive,\n            \"destructive-foreground\" => &mut self.destructive_foreground,\n            \"success\" => &mut self.success,\n            \"success-foreground\" => &mut self.success_foreground,\n            \"warning\" => &mut self.warning,\n            \"warning-foreground\" => &mut self.warning_foreground,\n            \"info\" => &mut self.info,\n            \"info-foreground\" => &mut self.info_foreground,\n            \"border\" => &mut self.border,\n            \"input\" => &mut self.input,\n            \"ring\" => &mut self.ring,\n            \"chart-1\" => &mut self.chart_1,\n            \"chart-2\" => &mut self.chart_2,\n            \"chart-3\" => &mut self.chart_3,\n            \"chart-4\" => &mut self.chart_4,\n            \"chart-5\" => &mut self.chart_5,\n            \"sidebar\" | \"sidebar-background\" => &mut self.sidebar,\n            \"sidebar-foreground\" => &mut self.sidebar_foreground,\n            \"sidebar-primary\" => &mut self.sidebar_primary,\n            \"sidebar-primary-foreground\" => &mut self.sidebar_primary_foreground,\n            \"sidebar-accent\" => &mut self.sidebar_accent,\n            \"sidebar-accent-foreground\" => &mut self.sidebar_accent_foreground,\n            \"sidebar-border\" => &mut self.sidebar_border,\n            \"sidebar-ring\" => &mut self.sidebar_ring,\n            _ => return None,\n        })\n    }\n\n    /// The optional tokens that follow another one until set.\n    #[doc(hidden)]\n    pub fn optional_slot(&mut self, variable: &str) -> Option<&mut Option<Rgba>> {\n        Some(match variable {\n            \"link\" => &mut self.link,\n            \"mention-highlight\" => &mut self.mention_highlight,\n            \"mention-highlight-foreground\" => &mut self.mention_highlight_foreground,\n            \"new-messages\" => &mut self.new_messages,\n            \"sidebar-muted-foreground\" => &mut self.sidebar_muted_foreground,\n            \"sidebar-badge\" => &mut self.sidebar_badge,\n            \"sidebar-badge-foreground\" => &mut self.sidebar_badge_foreground,\n            _ => return None,\n        })\n    }\n}\n\n/// Innermost `selector { body }` pairs with comments removed.\nfn css_blocks(css: &str) -> Vec<(String, String)> {\n    let mut text = String::with_capacity(css.len());\n    let mut rest = css;\n    while let Some(start) = rest.find(\"/*\") {\n        text.push_str(&rest[..start]);\n        rest = rest[start + 2..]\n            .split_once(\"*/\")\n            .map_or(\"\", |(_, after)| after);\n    }\n    text.push_str(rest);\n    let mut blocks = Vec::new();\n    let mut selector_start = 0;\n    let mut open = None;\n    for (index, character) in text.char_indices() {\n        match character {\n            '{' => {\n                open = Some((text[selector_start..index].trim().to_owned(), index + 1));\n                selector_start = index + 1;\n            }\n            '}' => {\n                if let Some((selector, body)) = open.take() {\n                    blocks.push((selector, text[body..index].to_owned()));\n                }\n                selector_start = index + 1;\n            }\n            ';' if open.is_none() => selector_start = index + 1,\n            _ => {}\n        }\n    }\n    blocks\n}\n\nfn css_length(value: &str) -> Option<Pixels> {\n    let value = value.trim();\n    let pixels = if let Some(rem) = value.strip_suffix(\"rem\") {\n        rem.trim().parse::<f32>().ok()? * 16.\n    } else if let Some(pixels) = value.strip_suffix(\"px\") {\n        pixels.trim().parse::<f32>().ok()?\n    } else {\n        value.parse::<f32>().ok().filter(|value| *value == 0.)?\n    };\n    (pixels.is_finite() && pixels >= 0.).then(|| px(pixels))\n}\n\n/// A CSS number or percentage; `percent` is the value of `100%`.\nfn css_number(value: &str, percent: f64) -> Option<f64> {\n    let value = value.trim();\n    let number = match value.strip_suffix('%') {\n        Some(value) => value.trim().parse::<f64>().ok()? / 100. * percent,\n        None => value\n            .strip_suffix(\"deg\")\n            .unwrap_or(value)\n            .parse::<f64>()\n            .ok()?,\n    };\n    number.is_finite().then_some(number)\n}\n\nfn css_color(value: &str) -> Option<Rgba> {\n    let value = value.trim().trim_end_matches(\"!important\").trim();\n    if let Some(hex) = value.strip_prefix('#') {\n        return css_hex(hex);\n    }\n    let (function, arguments) = match value.split_once('(') {\n        Some((function, arguments)) => (\n            function.trim().to_ascii_lowercase(),\n            arguments.strip_suffix(')')?,\n        ),\n        // shadcn v3 themes store bare HSL triplets such as `0 0% 100%`.\n        None => (\"hsl\".to_owned(), value),\n    };\n    let (channels, alpha) = match arguments.split_once('/') {\n        Some((channels, alpha)) => (channels, css_number(alpha, 1.)?),\n        None => (arguments, 1.),\n    };\n    let channels: Vec<_> = channels\n        .split(|character: char| character == ',' || character.is_whitespace())\n        .filter(|part| !part.is_empty())\n        .collect();\n    let (channels, alpha) = match channels.len() {\n        3 => (channels, alpha),\n        4 => (channels[..3].to_vec(), css_number(channels[3], 1.)?),\n        _ => return None,\n    };\n    let color = match function.as_str() {\n        \"oklch\" => oklch(\n            css_number(channels[0], 1.)?,\n            css_number(channels[1], 0.4)?,\n            css_number(channels[2], 1.)?,\n        ),\n        \"hsl\" | \"hsla\" => hsl(\n            css_number(channels[0], 1.)?,\n            css_number(channels[1], 1.)?,\n            css_number(channels[2], 1.)?,\n        ),\n        \"rgb\" | \"rgba\" => [\n            css_number(channels[0], 255.)? / 255.,\n            css_number(channels[1], 255.)? / 255.,\n            css_number(channels[2], 255.)? / 255.,\n        ],\n        _ => return None,\n    };\n    Some(Rgba {\n        r: color[0].clamp(0., 1.) as f32,\n        g: color[1].clamp(0., 1.) as f32,\n        b: color[2].clamp(0., 1.) as f32,\n        a: alpha.clamp(0., 1.) as f32,\n    })\n}\n\nfn css_hex(hex: &str) -> Option<Rgba> {\n    if !hex.bytes().all(|byte| byte.is_ascii_hexdigit()) {\n        return None;\n    }\n    let digits: Vec<u8> = match hex.len() {\n        3 | 4 => hex\n            .chars()\n            .map(|digit| u8::from_str_radix(&format!(\"{digit}{digit}\"), 16).ok())\n            .collect::<Option<_>>()?,\n        6 | 8 => (0..hex.len())\n            .step_by(2)\n            .map(|index| u8::from_str_radix(&hex[index..index + 2], 16).ok())\n            .collect::<Option<_>>()?,\n        _ => return None,\n    };\n    Some(Rgba {\n        r: digits[0] as f32 / 255.,\n        g: digits[1] as f32 / 255.,\n        b: digits[2] as f32 / 255.,\n        a: digits.get(3).map_or(1., |alpha| *alpha as f32 / 255.),\n    })\n}\n\n/// OKLCH to gamma-encoded sRGB, matching the pinned Neutral conversion when chroma is 0.\nfn oklch(lightness: f64, chroma: f64, hue: f64) -> [f64; 3] {\n    let (a, b) = (\n        chroma * hue.to_radians().cos(),\n        chroma * hue.to_radians().sin(),\n    );\n    let l = (lightness + 0.396_337_777_4 * a + 0.215_803_757_3 * b).powi(3);\n    let m = (lightness - 0.105_561_345_8 * a - 0.063_854_172_8 * b).powi(3);\n    let s = (lightness - 0.089_484_177_5 * a - 1.291_485_548 * b).powi(3);\n    [\n        4.076_741_662_1 * l - 3.307_711_591_3 * m + 0.230_969_929_2 * s,\n        -1.268_438_004_6 * l + 2.609_757_401_1 * m - 0.341_319_396_5 * s,\n        -0.004_196_086_3 * l - 0.703_418_614_7 * m + 1.707_614_701 * s,\n    ]\n    .map(srgb_channel)\n}\n\nfn hsl(hue: f64, saturation: f64, lightness: f64) -> [f64; 3] {\n    let hue = hue.rem_euclid(360.) / 60.;\n    let chroma = (1. - (2. * lightness - 1.).abs()) * saturation;\n    let x = chroma * (1. - (hue % 2. - 1.).abs());\n    let (r, g, b) = match hue as u32 {\n        0 => (chroma, x, 0.),\n        1 => (x, chroma, 0.),\n        2 => (0., chroma, x),\n        3 => (0., x, chroma),\n        4 => (x, 0., chroma),\n        _ => (chroma, 0., x),\n    };\n    let base = lightness - chroma / 2.;\n    [r + base, g + base, b + base]\n}\n\nfn neutral_light_colors() -> UiColors {\n    UiColors {\n        background: neutral(1.0),\n        foreground: neutral(0.145),\n        card: neutral(1.0),\n        card_foreground: neutral(0.145),\n        popover: neutral(1.0),\n        popover_foreground: neutral(0.145),\n        primary: neutral(0.205),\n        primary_foreground: neutral(0.985),\n        secondary: neutral(0.97),\n        secondary_foreground: neutral(0.205),\n        muted: neutral(0.97),\n        muted_foreground: neutral(0.556),\n        accent: neutral(0.97),\n        accent_foreground: neutral(0.205),\n        destructive: srgb(0xdc, 0x26, 0x26),\n        destructive_foreground: neutral(0.985),\n        success: srgb(0x16, 0xa3, 0x4a),\n        success_foreground: neutral(0.985),\n        warning: srgb(0xd9, 0x77, 0x06),\n        warning_foreground: neutral(0.985),\n        info: srgb(0x25, 0x63, 0xeb),\n        info_foreground: neutral(0.985),\n        border: neutral(0.922),\n        input: neutral(0.922),\n        ring: neutral(0.708),\n        chart_1: neutral(0.87),\n        chart_2: neutral(0.556),\n        chart_3: neutral(0.439),\n        chart_4: neutral(0.371),\n        chart_5: neutral(0.269),\n        sidebar: neutral(0.985),\n        sidebar_foreground: neutral(0.145),\n        sidebar_primary: neutral(0.205),\n        sidebar_primary_foreground: neutral(0.985),\n        sidebar_accent: neutral(0.97),\n        sidebar_accent_foreground: neutral(0.205),\n        sidebar_border: neutral(0.922),\n        sidebar_ring: neutral(0.708),\n        overlay: black().alpha(0.10).into(),\n        link: None,\n        mention_highlight: None,\n        mention_highlight_foreground: None,\n        new_messages: None,\n        sidebar_muted_foreground: None,\n        sidebar_badge: None,\n        sidebar_badge_foreground: None,\n    }\n}\n\nfn neutral_dark_colors() -> UiColors {\n    UiColors {\n        background: neutral(0.145),\n        foreground: neutral(0.985),\n        card: neutral(0.205),\n        card_foreground: neutral(0.985),\n        popover: neutral(0.205),\n        popover_foreground: neutral(0.985),\n        primary: neutral(0.922),\n        primary_foreground: neutral(0.205),\n        secondary: neutral(0.269),\n        secondary_foreground: neutral(0.985),\n        muted: neutral(0.269),\n        muted_foreground: neutral(0.708),\n        accent: neutral(0.269),\n        accent_foreground: neutral(0.985),\n        destructive: srgb(0xff, 0x64, 0x67),\n        destructive_foreground: neutral(0.985),\n        success: srgb(0x4a, 0xde, 0x80),\n        success_foreground: neutral(0.145),\n        warning: srgb(0xfb, 0xbf, 0x24),\n        warning_foreground: neutral(0.145),\n        info: srgb(0x60, 0xa5, 0xfa),\n        info_foreground: neutral(0.145),\n        border: neutral_alpha(1.0, 0.10),\n        input: neutral_alpha(1.0, 0.15),\n        ring: neutral(0.556),\n        chart_1: neutral(0.87),\n        chart_2: neutral(0.556),\n        chart_3: neutral(0.439),\n        chart_4: neutral(0.371),\n        chart_5: neutral(0.269),\n        sidebar: neutral(0.205),\n        sidebar_foreground: neutral(0.985),\n        sidebar_primary: srgb(0x14, 0x47, 0xe6),\n        sidebar_primary_foreground: neutral(0.985),\n        sidebar_accent: neutral(0.269),\n        sidebar_accent_foreground: neutral(0.985),\n        sidebar_border: neutral_alpha(1.0, 0.10),\n        sidebar_ring: neutral(0.556),\n        // shadcn pairs black/10 with a backdrop blur GPUI lacks; without it a\n        // 10% scrim disappears on a near-black page.\n        overlay: black().alpha(0.50).into(),\n        link: None,\n        mention_highlight: None,\n        mention_highlight_foreground: None,\n        new_messages: None,\n        sidebar_muted_foreground: None,\n        sidebar_badge: None,\n        sidebar_badge_foreground: None,\n    }\n}\n\n#[doc(hidden)]\npub fn neutral(l: f64) -> Rgba {\n    neutral_alpha(l, 1.0)\n}\n\nfn neutral_alpha(l: f64, alpha: f64) -> Rgba {\n    let channel = srgb_channel(l * l * l) as f32;\n\n    Rgba {\n        r: channel,\n        g: channel,\n        b: channel,\n        a: alpha.clamp(0.0, 1.0) as f32,\n    }\n}\n\nconst fn srgb(red: u8, green: u8, blue: u8) -> Rgba {\n    Rgba {\n        r: red as f32 / 255.0,\n        g: green as f32 / 255.0,\n        b: blue as f32 / 255.0,\n        a: 1.0,\n    }\n}\n\nfn srgb_channel(channel: f64) -> f64 {\n    if channel >= 0.003_130_8 {\n        (1.055 * channel.powf(1.0 / 2.4) - 0.055).clamp(0.0, 1.0)\n    } else {\n        (12.92 * channel).clamp(0.0, 1.0)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn code_themes_build_with_their_own_surface() {\n        for theme in CodeTheme::ALL {\n            assert_eq!(CodeTheme::from_name(theme.name()), Some(theme));\n            let built = theme.highlight_theme(ThemeMode::Light);\n            // Built once: the Kit shares one highlighter per theme instance.\n            assert!(Arc::ptr_eq(\n                &built,\n                &theme.highlight_theme(ThemeMode::Light)\n            ));\n            if theme.surface().is_some() {\n                assert_eq!(built.name, theme.name());\n                assert!(built.keyword.is_some());\n            }\n        }\n        assert_eq!(\n            CodeTheme::from_name(\"Solarized-Dark\"),\n            Some(CodeTheme::SolarizedDark)\n        );\n        assert_eq!(CodeTheme::from_name(\"dracula\"), None);\n    }\n\n    #[test]\n    fn optional_tokens_follow_their_base_until_set() {\n        let mut theme = UiTheme::neutral_light();\n        theme.colors.primary = gpui_kit::rgb(0x1c58d9);\n        assert_eq!(theme.colors.link(), theme.colors.primary);\n        assert_eq!(theme.colors.mention_highlight(), theme.colors.primary);\n        assert_eq!(theme.colors.new_messages(), theme.colors.destructive);\n        assert_eq!(theme.colors.sidebar_badge(), theme.colors.sidebar_primary);\n        theme.colors.link = Some(gpui_kit::rgb(0x2389d7));\n        assert_eq!(theme.colors.link(), gpui_kit::rgb(0x2389d7));\n        let css = \":root { --primary: #111111; --link: #2389d7; --sidebar-badge: #ff0000; }\";\n        let parsed = UiTheme::from_shadcn_css(css, ThemeMode::Light).unwrap();\n        assert_eq!(parsed.colors.link(), gpui_kit::rgb(0x2389d7));\n        assert_eq!(parsed.colors.sidebar_badge(), gpui_kit::rgb(0xff0000));\n        assert_eq!(parsed.colors.mention_highlight(), gpui_kit::rgb(0x111111));\n    }\n\n    #[test]\n    fn converts_pinned_neutral_tokens() {\n        assert_eq!(\n            neutral(1.0),\n            Rgba {\n                r: 1.0,\n                g: 1.0,\n                b: 1.0,\n                a: 1.0,\n            }\n        );\n        assert_eq!(\n            neutral(0.0),\n            Rgba {\n                r: 0.0,\n                g: 0.0,\n                b: 0.0,\n                a: 1.0,\n            }\n        );\n\n        assert_eq!(neutral_light_colors().destructive, srgb(0xdc, 0x26, 0x26));\n        assert_eq!(neutral_dark_colors().destructive, srgb(0xff, 0x64, 0x67));\n        assert_eq!(\n            neutral_dark_colors().sidebar_primary,\n            srgb(0x14, 0x47, 0xe6)\n        );\n    }\n\n    fn close(left: Rgba, right: Rgba) -> bool {\n        [\n            (left.r, right.r),\n            (left.g, right.g),\n            (left.b, right.b),\n            (left.a, right.a),\n        ]\n        .iter()\n        .all(|(left, right)| (left - right).abs() < 1.5 / 255.)\n    }\n\n    #[test]\n    fn imports_shadcn_theme_css() {\n        let css = r#\"\n            @layer base {\n              :root {\n                --radius: 0.5rem; /* 8px */\n                --background: oklch(1 0 0);\n                --foreground: oklch(0.145 0 0);\n                --primary: #2563eb;\n                --ring: rgb(37 99 235 / 50%);\n                --sidebar-background: 0 0% 98%;\n                --font-sans: Inter, sans-serif;\n              }\n              .dark {\n                --background: oklch(0.145 0 0);\n                --border: oklch(1 0 0 / 10%);\n                --sidebar-primary: oklch(0.488 0.243 264.376);\n                --chart-1: hsl(220 70% 50%);\n              }\n            }\n        \"#;\n        let light = UiTheme::from_shadcn_css(css, ThemeMode::Light).unwrap();\n        assert_eq!(light.mode, ThemeMode::Light);\n        assert_eq!(light.radius.lg, px(8.));\n        assert!(close(light.colors.background, neutral(1.0)));\n        assert!(close(light.colors.foreground, neutral(0.145)));\n        assert_eq!(light.colors.primary, srgb(0x25, 0x63, 0xeb));\n        assert!(close(\n            light.colors.ring,\n            Rgba {\n                a: 0.5,\n                ..srgb(37, 99, 235)\n            }\n        ));\n        assert!(close(light.colors.sidebar, neutral(0.985)));\n        // Variables the CSS leaves out keep the Neutral defaults.\n        assert_eq!(light.colors.muted, neutral_light_colors().muted);\n\n        let dark = UiTheme::from_shadcn_css(css, ThemeMode::Dark).unwrap();\n        assert_eq!(dark.mode, ThemeMode::Dark);\n        assert!(close(dark.colors.background, neutral(0.145)));\n        // `.dark` inherits `:root` values it does not override.\n        assert_eq!(dark.colors.primary, srgb(0x25, 0x63, 0xeb));\n        assert!(close(dark.colors.border, neutral_alpha(1.0, 0.10)));\n        assert!(close(dark.colors.sidebar_primary, srgb(0x14, 0x47, 0xe6)));\n        assert!(close(dark.colors.chart_1, srgb(0x26, 0x63, 0xd9)));\n\n        assert!(UiTheme::from_shadcn_css(\":root { --primary: blue; }\", ThemeMode::Light).is_err());\n        assert!(UiTheme::from_shadcn_css(\":root { --radius: 1em; }\", ThemeMode::Light).is_err());\n        assert!(UiTheme::from_shadcn_css(\":root { }\", ThemeMode::Dark).is_err());\n        assert_eq!(\n            css_hex(\"fff8\"),\n            Some(Rgba {\n                r: 1.,\n                g: 1.,\n                b: 1.,\n                a: 0x88 as f32 / 255.\n            })\n        );\n    }\n\n    #[test]\n    fn preserves_pinned_alpha_tokens() {\n        let dark = neutral_dark_colors();\n        assert_eq!(dark.border.a, 0.10);\n        assert_eq!(dark.input.a, 0.15);\n        assert_eq!(dark.sidebar_border.a, 0.10);\n        assert!((dark.input.opacity(0.30).a - 0.045).abs() < f32::EPSILON);\n    }\n\n    #[test]\n    fn derives_the_shadcn_radius_and_shadow_scales() {\n        let theme = UiTheme::neutral_light();\n        assert_eq!(theme.radius.sm, px(6.));\n        assert_eq!(theme.radius.md, px(8.));\n        assert_eq!(theme.radius.lg, px(10.));\n        assert_eq!(theme.radius.xl, px(14.));\n        assert_eq!(theme.shadows.sm.len(), 2);\n        assert_eq!(theme.shadows.md.len(), 2);\n        assert_eq!(theme.shadows.lg.len(), 2);\n    }\n\n    #[gpui_kit::test]\n    fn keeps_component_state_tokens_in_sync_with_ui_theme(cx: &mut gpui_kit::TestAppContext) {\n        cx.update(|cx| {\n            init(cx);\n            let component = gpui_kit::component::Theme::global(cx);\n            assert_eq!(component.mode, gpui_kit::component::ThemeMode::Light);\n            assert_eq!(\n                component.button_hover,\n                UiTheme::read(cx).colors.accent.into()\n            );\n\n            UiTheme::switch(cx, ThemeMode::Dark);\n            let component = gpui_kit::component::Theme::global(cx);\n            assert_eq!(component.mode, gpui_kit::component::ThemeMode::Dark);\n            assert_eq!(component.ring, UiTheme::read(cx).colors.ring.into());\n\n            let mut custom = UiTheme::read(cx).clone();\n            custom.colors.accent = srgb(0x22, 0x66, 0xaa);\n            custom.fonts.body = \"Custom Sans\".into();\n            custom.radius = UiRadius::new(px(12.));\n            let expected_accent = custom.colors.accent;\n            UiTheme::set(cx, custom);\n\n            let component = gpui_kit::component::Theme::global(cx);\n            assert_eq!(component.button_hover, expected_accent.into());\n            assert_eq!(component.font_family, \"Custom Sans\");\n            assert_eq!(component.radius, px(9.6));\n            assert_eq!(\n                component.tokens.button_hover.background,\n                expected_accent.into()\n            );\n\n            init(cx);\n            assert_eq!(\n                gpui_kit::component::Theme::global(cx).button_hover,\n                expected_accent.into()\n            );\n        });\n    }\n}\n\n// Refine the actual control after default styling; no extra layout or focus node.\n#[doc(hidden)]\npub fn apply_style<T: Styled>(mut element: T, style: &gpui_kit::StyleRefinement) -> T {\n    use gpui_kit::Refineable as _;\n    element.style().refine(style);\n    element\n}\n\n#[derive(gpui_kit::IntoElement)]\n#[doc(hidden)]\npub struct DisclosureIcon {\n    icon: gpui_kit::Svg,\n    open: bool,\n}\n#[doc(hidden)]\npub fn disclosure_icon(icon: gpui_kit::Svg, open: bool) -> DisclosureIcon {\n    DisclosureIcon { icon, open }\n}\nimpl gpui_kit::RenderOnce for DisclosureIcon {\n    fn render(self, window: &mut Window, cx: &mut App) -> impl gpui_kit::IntoElement {\n        let duration = UiTheme::read(cx).motion.fast;\n        let value = transition_value(\n            \"disclosure-rotation\",\n            if self.open { 1. } else { 0. },\n            duration,\n            window,\n            cx,\n        );\n        self.icon\n            .with_transformation(gpui_kit::Transformation::rotate(gpui_kit::radians(\n                value * std::f32::consts::PI,\n            )))\n    }\n}\n\n#[cfg(test)]\nmod motion_tests {\n    use super::*;\n    use gpui_kit::{\n        AppContext as _, Context, IntoElement, Render, TestAppContext, VisualTestContext, div,\n    };\n\n    struct View {\n        target: f32,\n        sampled: f32,\n    }\n    impl Render for View {\n        fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {\n            self.sampled = transition_value(\n                \"test-motion\",\n                self.target,\n                Duration::from_millis(200),\n                window,\n                cx,\n            );\n            div()\n        }\n    }\n\n    #[gpui_kit::test]\n    fn theme_reduced_motion_snaps_an_active_upstream_transition(cx: &mut TestAppContext) {\n        cx.update(init);\n        let window = cx.add_window(|_, _| View {\n            target: 0.,\n            sampled: 0.,\n        });\n        let mut visual = VisualTestContext::from_window(window.into(), cx);\n        visual.update(|window, cx| window.draw(cx).clear(cx));\n        window\n            .update(cx, |view, _, cx| {\n                view.target = 1.;\n                cx.notify();\n            })\n            .unwrap();\n        visual.update(|window, cx| window.draw(cx).clear(cx));\n        assert_eq!(\n            cx.read_window(&window, |view, cx| view.read(cx).sampled)\n                .unwrap(),\n            0.\n        );\n        cx.update(|cx| {\n            let mut theme = UiTheme::read(cx).clone();\n            theme.motion.reduced = true;\n            UiTheme::set(cx, theme);\n        });\n        visual.update(|window, cx| window.draw(cx).clear(cx));\n        assert_eq!(\n            cx.read_window(&window, |view, cx| view.read(cx).sampled)\n                .unwrap(),\n            1.\n        );\n    }\n}\n\n/// Shared focus traversal for the tab, radio and toggle collections.\n#[doc(hidden)]\npub struct RovingFocus {\n    pub handles: Vec<Option<gpui_kit::FocusHandle>>,\n    active: gpui_kit::Entity<Option<gpui_kit::FocusHandle>>,\n}\nimpl RovingFocus {\n    pub fn new(\n        id: gpui_kit::ElementId,\n        items: &[(gpui_kit::ElementId, bool)],\n        selected: Option<usize>,\n        window: &mut gpui_kit::Window,\n        cx: &mut App,\n    ) -> Self {\n        let active =\n            window.use_keyed_state((id, \"active\"), cx, |_, _| None::<gpui_kit::FocusHandle>);\n        let mut handles: Vec<_> = items\n            .iter()\n            .map(|(id, disabled)| {\n                let handle = window\n                    .use_keyed_state((id.clone(), \"focus\"), cx, |_, cx| cx.focus_handle())\n                    .read(cx)\n                    .clone();\n                handle.clone().tab_stop(false);\n                (!disabled).then_some(handle)\n            })\n            .collect();\n        let index = handles\n            .iter()\n            .position(|h| h.as_ref().is_some_and(|h| h.is_focused(window)))\n            .or(selected.filter(|&i| handles.get(i).is_some_and(Option::is_some)))\n            .or_else(|| {\n                handles\n                    .iter()\n                    .position(|h| h.is_some() && h.as_ref() == active.read(cx).as_ref())\n            })\n            .or_else(|| handles.iter().position(Option::is_some));\n        if let Some(index) = index {\n            let handle = handles[index].as_ref().unwrap().clone().tab_stop(true);\n            handles[index] = Some(handle.clone());\n            active.update(cx, |value, _| *value = Some(handle));\n        }\n        Self { handles, active }\n    }\n    pub fn key(\n        &self,\n        event: &gpui_kit::KeyDownEvent,\n        axis: Option<gpui_kit::Axis>,\n        window: &mut gpui_kit::Window,\n        cx: &mut App,\n    ) -> Option<usize> {\n        if event.keystroke.modifiers.modified() {\n            return None;\n        }\n        let enabled: Vec<_> = self\n            .handles\n            .iter()\n            .enumerate()\n            .filter_map(|(i, h)| h.as_ref().map(|h| (i, h)))\n            .collect();\n        let current = enabled.iter().position(|(_, h)| h.is_focused(window))?;\n        let direction = UiTheme::read(cx).direction;\n        let next = match direction.logical_key(event.keystroke.key.as_str()) {\n            \"home\" => 0,\n            \"end\" => enabled.len() - 1,\n            \"left\" if axis != Some(gpui_kit::Axis::Vertical) => {\n                (current + enabled.len() - 1) % enabled.len()\n            }\n            \"right\" if axis != Some(gpui_kit::Axis::Vertical) => (current + 1) % enabled.len(),\n            \"up\" if axis != Some(gpui_kit::Axis::Horizontal) => {\n                (current + enabled.len() - 1) % enabled.len()\n            }\n            \"down\" if axis != Some(gpui_kit::Axis::Horizontal) => (current + 1) % enabled.len(),\n            _ => return None,\n        };\n        enabled[current].1.clone().tab_stop(false);\n        let handle = enabled[next].1.clone().tab_stop(true);\n        handle.focus(window, cx);\n        self.active.update(cx, |value, _| *value = Some(handle));\n        window.refresh();\n        cx.stop_propagation();\n        Some(enabled[next].0)\n    }\n}\n"
    },
    {
      "path": "registry/input/input.rs",
      "type": "registry:file",
      "target": "~/src/ui/input.rs",
      "content": "//! Nova presentation for GPUI Kit's single-line and multi-line editing states.\n\nuse std::ops::Range;\nuse std::rc::Rc;\n\nuse super::theme::{\n    UiText, UiTheme, locale,\n    primitives::{control, disabled, focus},\n};\npub use gpui_kit::base::input::{InputEvent, InputState, TextareaState};\nuse gpui_kit::base::{\n    InputBase,\n    input::{InputBaseState, InputEditorStyle, InputModeKind},\n};\nuse gpui_kit::component::native_menu::NativeMenu;\nuse gpui_kit::{\n    AccessibleAction, App, ClipboardItem, ContentMask, Context, ElementId, Entity,\n    EntityInputHandler as _, EventEmitter, FocusHandle, Focusable as _, InteractiveElement as _,\n    IntoElement, MouseButton, ParentElement as _, RenderOnce, SharedString,\n    StatefulInteractiveElement as _, Styled, Subscription, UnderlineStyle, Window, canvas, point,\n    prelude::FluentBuilder as _, px,\n};\n\ntype PasteHandler = Rc<dyn Fn(&ClipboardItem, &mut Window, &mut App) -> bool>;\n\n/// The caller owns the editing state, focus and event subscriptions.\n#[derive(IntoElement)]\npub struct Input {\n    state: Entity<InputState>,\n    style: gpui_kit::StyleRefinement,\n    label: Option<SharedString>,\n    disabled: bool,\n    read_only: bool,\n    invalid: bool,\n    bordered: bool,\n    paste_handler: Option<PasteHandler>,\n}\n\n/// Nova presentation for GPUI Kit's ordinary multi-line editing state.\n#[derive(IntoElement)]\npub struct Textarea {\n    state: Entity<TextareaState>,\n    style: gpui_kit::StyleRefinement,\n    label: Option<SharedString>,\n    disabled: bool,\n    read_only: bool,\n    invalid: bool,\n    bordered: bool,\n    paste_handler: Option<PasteHandler>,\n    misspellings: Option<Entity<Misspellings>>,\n}\n\n/// Replaces a misspelled range with a suggestion in one undoable edit.\n///\n/// `SpellingMenu::suggestion` adds menu items that dispatch it; a textarea\n/// showing `Misspellings` handles it.\n#[derive(Clone, PartialEq, Debug, gpui_kit::Action)]\n#[action(namespace = gpuicn, no_json)]\npub struct ReplaceMisspelling {\n    /// The byte range to replace.\n    pub range: Range<usize>,\n    /// The replacement text.\n    pub text: SharedString,\n}\n\ntype SpellingMenuHandler = Rc<dyn Fn(&mut SpellingMenu, &mut Window, &mut App)>;\n\n/// Misspelled byte ranges in a textarea, drawn as wavy underlines.\n///\n/// The application checks the spelling itself, with the platform's checker,\n/// and passes the ranges to `set` a moment after typing stops. Edits shift\n/// the ranges after them and drop the ones they touch, so no underline sits\n/// on the wrong text before fresh ranges arrive. Attach it with\n/// `Textarea::misspellings`; `ComposerState` has one built in.\npub struct Misspellings {\n    input: Entity<TextareaState>,\n    ranges: Vec<Range<usize>>,\n    text: SharedString,\n    menu: Option<SpellingMenuHandler>,\n    _subscription: Subscription,\n}\n\n/// Notifications from `Misspellings`.\n#[derive(Clone, Debug, PartialEq)]\npub enum MisspellingsEvent {\n    /// A suggestion replaced a misspelled range.\n    Replaced {\n        /// The range that was replaced, in the text before the edit.\n        range: Range<usize>,\n        /// The text that replaced it.\n        text: SharedString,\n    },\n}\n\nimpl EventEmitter<MisspellingsEvent> for Misspellings {}\n\nimpl Misspellings {\n    /// Tracks misspellings for `input`.\n    pub fn new(input: &Entity<TextareaState>, cx: &mut Context<Self>) -> Self {\n        let subscription = cx.subscribe(input, |this, input, event, cx| {\n            if let InputEvent::Change = event {\n                let text = input.read(cx).value();\n                this.follow_edit(&text);\n                this.text = text;\n                cx.notify();\n            }\n        });\n        Self {\n            text: input.read(cx).value(),\n            input: input.clone(),\n            ranges: Vec::new(),\n            menu: None,\n            _subscription: subscription,\n        }\n    }\n\n    /// Replaces the misspelled ranges: byte offsets into the current value.\n    /// Ranges outside the text or off character boundaries are dropped.\n    pub fn set(&mut self, ranges: impl IntoIterator<Item = Range<usize>>, cx: &mut Context<Self>) {\n        let text = self.input.read(cx).value();\n        let mut ranges: Vec<_> = ranges\n            .into_iter()\n            .filter(|range| {\n                range.start < range.end\n                    && text.is_char_boundary(range.start)\n                    && text.is_char_boundary(range.end)\n            })\n            .collect();\n        ranges.sort_by_key(|range| range.start);\n        self.ranges = ranges;\n        self.text = text;\n        cx.notify();\n    }\n\n    /// The current misspelled ranges, in order.\n    pub fn ranges(&self) -> &[Range<usize>] {\n        &self.ranges\n    }\n\n    /// The misspelled range at byte `offset`, its ends included.\n    pub fn range_at(&self, offset: usize) -> Option<Range<usize>> {\n        self.ranges\n            .iter()\n            .find(|range| range.start <= offset && offset <= range.end)\n            .cloned()\n    }\n\n    /// Builds the menu for a right-click inside a misspelled range. Its items\n    /// go above Cut, Copy, Paste and Select All; a right-click elsewhere shows\n    /// only those.\n    pub fn on_menu(\n        &mut self,\n        handler: impl Fn(&mut SpellingMenu, &mut Window, &mut App) + 'static,\n    ) {\n        self.menu = Some(Rc::new(handler));\n    }\n\n    /// Replaces `range` with `text` as one undoable edit and selects nothing,\n    /// leaving the caret after it.\n    pub fn replace(\n        &mut self,\n        range: Range<usize>,\n        text: impl Into<SharedString>,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) {\n        let text = text.into();\n        let value = self.input.read(cx).value();\n        if range.end > value.len()\n            || !value.is_char_boundary(range.start)\n            || !value.is_char_boundary(range.end)\n        {\n            return;\n        }\n        let replacement = text.clone();\n        self.input.update(cx, |input, cx| {\n            input.set_selected_range(range.clone(), cx);\n            input.replace(replacement, window, cx);\n        });\n        cx.emit(MisspellingsEvent::Replaced { range, text });\n    }\n\n    /// Moves the ranges after an edit and drops the ranges it touched.\n    fn follow_edit(&mut self, new: &str) {\n        let old = self.text.as_ref();\n        if old == new || self.ranges.is_empty() {\n            return;\n        }\n        let prefix = old\n            .char_indices()\n            .zip(new.chars())\n            .find(|((_, a), b)| a != b)\n            .map_or(old.len().min(new.len()), |((index, _), _)| index);\n        let suffix = old[prefix..]\n            .chars()\n            .rev()\n            .zip(new[prefix..].chars().rev())\n            .take_while(|(a, b)| a == b)\n            .map(|(a, _)| a.len_utf8())\n            .sum::<usize>();\n        let removed = prefix..old.len() - suffix;\n        let inserted = new.len() - suffix - prefix;\n        self.ranges.retain_mut(|range| {\n            if range.end < removed.start || (range.end == removed.start && inserted == 0) {\n                true\n            } else if range.start > removed.end\n                || (range.start == removed.end && removed.end > removed.start)\n            {\n                range.start = range.start - removed.len() + inserted;\n                range.end = range.end - removed.len() + inserted;\n                true\n            } else {\n                false\n            }\n        });\n    }\n}\n\n/// The items a right-click on a misspelled word adds above Cut, Copy and\n/// Paste: suggestions, then the application's own actions such as\n/// \"Ignore\" or \"Add to dictionary\".\npub struct SpellingMenu {\n    range: Range<usize>,\n    word: SharedString,\n    menu: NativeMenu,\n}\n\nimpl SpellingMenu {\n    /// The misspelled byte range under the pointer.\n    pub fn range(&self) -> Range<usize> {\n        self.range.clone()\n    }\n    /// The misspelled word.\n    pub fn word(&self) -> &SharedString {\n        &self.word\n    }\n    /// Adds a suggestion; choosing it replaces the word in one undoable edit.\n    pub fn suggestion(&mut self, text: impl Into<SharedString>) -> &mut Self {\n        let text = text.into();\n        let action = ReplaceMisspelling {\n            range: self.range.clone(),\n            text: text.clone(),\n        };\n        self.push(|menu| menu.menu(text, Box::new(action)));\n        self\n    }\n    /// Adds an item that dispatches the application's own action.\n    pub fn item(\n        &mut self,\n        label: impl Into<SharedString>,\n        action: Box<dyn gpui_kit::Action>,\n    ) -> &mut Self {\n        let label = label.into();\n        self.push(|menu| menu.menu(label, action));\n        self\n    }\n    /// Adds a separator line.\n    pub fn separator(&mut self) -> &mut Self {\n        self.push(NativeMenu::separator);\n        self\n    }\n    fn push(&mut self, add: impl FnOnce(NativeMenu) -> NativeMenu) {\n        self.menu = add(std::mem::take(&mut self.menu));\n    }\n}\n\n/// Cut, Copy, Paste and Select All, after `menu`'s own items.\nfn edit_menu(menu: NativeMenu, copyable: bool, editable: bool, cx: &App) -> NativeMenu {\n    let menu = if menu.is_empty() {\n        menu\n    } else {\n        menu.separator()\n    };\n    menu.menu_with_disabled(\n        locale::text(cx, UiText::Cut),\n        !(editable && copyable),\n        Box::new(gpui_kit::base::input::Cut),\n    )\n    .menu_with_disabled(\n        locale::text(cx, UiText::Copy),\n        !copyable,\n        Box::new(gpui_kit::base::input::Copy),\n    )\n    .menu_with_disabled(\n        locale::text(cx, UiText::Paste),\n        !editable,\n        Box::new(gpui_kit::base::input::Paste),\n    )\n    .separator()\n    .menu(\n        locale::text(cx, UiText::SelectAll),\n        Box::new(gpui_kit::base::input::SelectAll),\n    )\n}\n\n/// Paints a 1px wavy underline under each misspelled range that is laid out.\nfn misspelling_underlines(\n    input: Entity<TextareaState>,\n    misspellings: Entity<Misspellings>,\n    theme: &UiTheme,\n) -> impl IntoElement {\n    let color = theme.colors.destructive;\n    canvas(\n        |_, _, _| {},\n        move |bounds, _, window, cx| {\n            let input = input.read(cx);\n            let style = UnderlineStyle {\n                thickness: px(1.),\n                color: Some(color.into()),\n                wavy: true,\n            };\n            window.with_content_mask(Some(ContentMask { bounds }), |window| {\n                for range in misspellings.read(cx).ranges() {\n                    let Some(word) = input.range_to_bounds(range) else {\n                        continue;\n                    };\n                    let line = input.line_height().unwrap_or(px(20.));\n                    // A word that wraps onto the next line has no single box.\n                    if word.size.height > line * 1.5 || word.size.width <= px(0.) {\n                        continue;\n                    }\n                    let origin = point(word.left(), word.bottom() - px(3.));\n                    window.paint_underline(origin, word.size.width, &style);\n                }\n            });\n        },\n    )\n    .absolute()\n    .inset_0()\n}\n\nimpl Textarea {\n    /// Creates a Nova textarea using the caller's retained Kit editing state.\n    pub fn new(state: &Entity<TextareaState>) -> Self {\n        Self {\n            state: state.clone(),\n            style: Default::default(),\n            label: None,\n            disabled: false,\n            read_only: false,\n            invalid: false,\n            bordered: true,\n            paste_handler: None,\n            misspellings: None,\n        }\n    }\n    /// Underlines the ranges in `misspellings` with a wavy destructive line\n    /// and adds its spelling items, then Cut, Copy, Paste and Select All, to\n    /// the right-click menu.\n    pub fn misspellings(mut self, misspellings: &Entity<Misspellings>) -> Self {\n        self.misspellings = Some(misspellings.clone());\n        self\n    }\n    /// Sets the accessible name of the control.\n    pub fn aria_label(mut self, label: impl Into<SharedString>) -> Self {\n        self.label = Some(label.into());\n        self\n    }\n    /// Disables interaction and applies the disabled appearance.\n    pub fn disabled(mut self, value: bool) -> Self {\n        self.disabled = value;\n        self\n    }\n    /// Prevents user changes while preserving focus and reading.\n    pub fn read_only(mut self, value: bool) -> Self {\n        self.read_only = value;\n        self\n    }\n    /// Applies validation error colors and an invalid accessibility description.\n    pub fn invalid(mut self, value: bool) -> Self {\n        self.invalid = value;\n        self\n    }\n    /// Controls the Nova textarea border and background.\n    pub fn bordered(mut self, value: bool) -> Self {\n        self.bordered = value;\n        self\n    }\n    /// Intercepts native clipboard payloads before the default text insertion.\n    /// Returning `true` consumes the paste; `false` keeps normal text paste.\n    /// Browser image/file paste needs async clipboard permission and is not\n    /// available through this synchronous hook.\n    pub fn on_paste(\n        mut self,\n        handler: impl Fn(&ClipboardItem, &mut Window, &mut App) -> bool + 'static,\n    ) -> Self {\n        self.paste_handler = Some(Rc::new(handler));\n        self\n    }\n    #[doc(hidden)]\n    pub fn is_disabled(&self) -> bool {\n        self.disabled\n    }\n    #[doc(hidden)]\n    pub fn is_read_only(&self) -> bool {\n        self.read_only\n    }\n    #[doc(hidden)]\n    pub fn is_invalid(&self) -> bool {\n        self.invalid\n    }\n    #[doc(hidden)]\n    pub fn field_focus_handle(&self, cx: &App) -> FocusHandle {\n        self.state.read(cx).focus_handle(cx)\n    }\n}\n\nimpl Styled for Textarea {\n    fn style(&mut self) -> &mut gpui_kit::StyleRefinement {\n        &mut self.style\n    }\n}\nimpl Input {\n    /// Creates a Nova input using the caller's retained Kit editing state.\n    pub fn new(state: &Entity<InputState>) -> Self {\n        Self {\n            state: state.clone(),\n            style: Default::default(),\n            label: None,\n            disabled: false,\n            read_only: false,\n            invalid: false,\n            bordered: true,\n            paste_handler: None,\n        }\n    }\n    /// Sets the accessible name of the control.\n    pub fn aria_label(mut self, label: impl Into<SharedString>) -> Self {\n        self.label = Some(label.into());\n        self\n    }\n    /// Disables interaction and applies the disabled appearance.\n    pub fn disabled(mut self, value: bool) -> Self {\n        self.disabled = value;\n        self\n    }\n    /// Prevents user changes while preserving focus and reading.\n    pub fn read_only(mut self, value: bool) -> Self {\n        self.read_only = value;\n        self\n    }\n    /// Applies validation error colors and an invalid accessibility description.\n    pub fn invalid(mut self, value: bool) -> Self {\n        self.invalid = value;\n        self\n    }\n    /// Controls the Nova input border and background.\n    pub fn bordered(mut self, value: bool) -> Self {\n        self.bordered = value;\n        self\n    }\n    /// Intercepts native clipboard payloads before the default text insertion.\n    /// Returning `true` consumes the paste; `false` keeps normal text paste.\n    /// Browser image/file paste needs async clipboard permission and is not\n    /// available through this synchronous hook.\n    pub fn on_paste(\n        mut self,\n        handler: impl Fn(&ClipboardItem, &mut Window, &mut App) -> bool + 'static,\n    ) -> Self {\n        self.paste_handler = Some(Rc::new(handler));\n        self\n    }\n    #[doc(hidden)]\n    pub fn is_disabled(&self) -> bool {\n        self.disabled\n    }\n    #[doc(hidden)]\n    pub fn is_read_only(&self) -> bool {\n        self.read_only\n    }\n    #[doc(hidden)]\n    pub fn is_invalid(&self) -> bool {\n        self.invalid\n    }\n    #[doc(hidden)]\n    pub fn field_focus_handle(&self, cx: &App) -> FocusHandle {\n        self.state.read(cx).focus_handle(cx)\n    }\n}\nimpl Styled for Input {\n    fn style(&mut self) -> &mut gpui_kit::StyleRefinement {\n        &mut self.style\n    }\n}\nimpl RenderOnce for Input {\n    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {\n        let theme = UiTheme::read(cx).clone();\n        let core = InputCore {\n            label: self.label,\n            disabled: self.disabled,\n            read_only: self.read_only,\n            invalid: self.invalid,\n            bordered: self.bordered,\n            paste_handler: self.paste_handler,\n        };\n        let root = core\n            .render(\"input\", self.state, &theme, window, cx)\n            .h(theme.space(8.))\n            .items_center();\n        super::theme::apply_style(root, &self.style)\n    }\n}\n\nimpl RenderOnce for Textarea {\n    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {\n        let theme = UiTheme::read(cx).clone();\n        let core = InputCore {\n            label: self.label,\n            disabled: self.disabled,\n            read_only: self.read_only,\n            invalid: self.invalid,\n            bordered: self.bordered,\n            paste_handler: self.paste_handler,\n        };\n        let input = self.state.clone();\n        let root = core\n            .render(\"textarea\", self.state, &theme, window, cx)\n            .min_h(theme.space(16.))\n            .items_start()\n            .py(theme.space(2.));\n        let editable = !self.disabled && !self.read_only;\n        let root = match self.misspellings {\n            Some(misspellings) => {\n                install_spelling_menu(&input, &misspellings, editable, cx);\n                let replacer = misspellings.clone();\n                root.relative()\n                    .when(editable, |root| {\n                        root.on_action(move |action: &ReplaceMisspelling, window, cx| {\n                            replacer.update(cx, |misspellings, cx| {\n                                misspellings.replace(\n                                    action.range.clone(),\n                                    action.text.clone(),\n                                    window,\n                                    cx,\n                                )\n                            });\n                        })\n                    })\n                    .child(misspelling_underlines(input, misspellings, &theme))\n            }\n            None => root,\n        };\n        super::theme::apply_style(root, &self.style)\n    }\n}\n\n/// Shows the spelling items and the edit items on a right-click.\nfn install_spelling_menu(\n    input: &Entity<TextareaState>,\n    misspellings: &Entity<Misspellings>,\n    editable: bool,\n    cx: &mut App,\n) {\n    let misspellings = misspellings.downgrade();\n    let weak_input = input.downgrade();\n    input.update(cx, |state, _| {\n        state.on_context_menu(Rc::new(move |_, capabilities, position, window, cx| {\n            let (Some(input), Some(misspellings)) = (weak_input.upgrade(), misspellings.upgrade())\n            else {\n                return;\n            };\n            // The right-click has already moved the caret to the word.\n            let (cursor, value) = {\n                let input = input.read(cx);\n                (input.cursor(), input.value())\n            };\n            let found = misspellings.read(cx).range_at(cursor);\n            let handler = misspellings.read(cx).menu.clone();\n            let mut menu = NativeMenu::new();\n            if let (Some(range), Some(handler), true) = (found, handler, editable) {\n                let mut spelling = SpellingMenu {\n                    word: value\n                        .get(range.clone())\n                        .unwrap_or_default()\n                        .to_string()\n                        .into(),\n                    range,\n                    menu,\n                };\n                handler(&mut spelling, window, cx);\n                menu = spelling.menu;\n            }\n            edit_menu(\n                menu,\n                capabilities.is_copyable(),\n                editable && !capabilities.is_readonly(),\n                cx,\n            )\n            .show(position, window, cx);\n        }));\n    });\n}\n\n/// The Nova editing frame around any Kit input state. `Input` and `Textarea`\n/// differ only in their size, so both build on this.\n#[doc(hidden)]\npub struct InputCore {\n    pub label: Option<SharedString>,\n    pub disabled: bool,\n    pub read_only: bool,\n    pub invalid: bool,\n    pub bordered: bool,\n    pub paste_handler: Option<PasteHandler>,\n}\n\nimpl InputCore {\n    /// The editor colors every Kit input in a gpuicn app uses.\n    pub fn editor_style(theme: &UiTheme) -> InputEditorStyle {\n        let colors = theme.colors;\n        InputEditorStyle {\n            foreground: colors.foreground.into(),\n            muted_foreground: colors.muted_foreground.into(),\n            background: colors.background.into(),\n            border: colors.input.into(),\n            selection: colors.ring.opacity(0.3).into(),\n            caret: colors.foreground.into(),\n            ..Default::default()\n        }\n    }\n\n    #[doc(hidden)]\n    pub fn render<M: InputModeKind>(\n        self,\n        kind: &'static str,\n        state: Entity<InputBaseState<M>>,\n        theme: &UiTheme,\n        window: &mut Window,\n        cx: &mut App,\n    ) -> InputBase {\n        let editor_style = Self::editor_style(theme);\n        let direction = theme.direction;\n        state.update(cx, |state, cx| {\n            state.set_disabled(self.disabled, cx);\n            state.set_readonly(self.read_only, cx);\n            state.set_editor_style(editor_style);\n            // Single-line inputs start at the reading edge; Kit leaves\n            // multi-line alignment to the text itself.\n            state.set_text_align(direction.start_align(), cx);\n        });\n        let read_only_text = locale::text(cx, UiText::ReadOnly);\n        let invalid_text = locale::text(cx, UiText::InvalidValue);\n        let read = state.read(cx);\n        let focus_handle = read.focus_handle(cx);\n        let focused = focus_handle.is_focused(window) && !self.disabled;\n        let value = read.value();\n        let placeholder = read.presentation().placeholder().clone();\n        let action_state = state.clone();\n        let click_state = state.clone();\n        let a11y_focus = state.clone();\n        let paste_handler = self\n            .paste_handler\n            .filter(|_| !self.disabled && !self.read_only);\n        let root = InputBase::new(ElementId::from((kind, state.entity_id())))\n            .focused(focused)\n            .disabled(self.disabled)\n            .when_some(self.label, |root, label| root.accessibility_label(label))\n            .aria_value(value)\n            .aria_placeholder(placeholder)\n            .when(self.read_only, |root| root.aria_description(read_only_text))\n            .when(self.invalid, |root| root.aria_description(invalid_text))\n            .when(direction.is_rtl(), |root| {\n                root.key_context(locale::RTL_INPUT_CONTEXT)\n            })\n            .when(!self.disabled, |root| {\n                root.on_a11y_action(AccessibleAction::Focus, move |_, window, cx| {\n                    a11y_focus.update(cx, |state, cx| state.focus(window, cx));\n                })\n            })\n            .when(!self.disabled, |root| {\n                root.on_mouse_down(MouseButton::Left, move |_, window, cx| {\n                    click_state.update(cx, |state, cx| state.focus(window, cx));\n                })\n            })\n            .when(!self.disabled && !self.read_only, |root| {\n                root.on_a11y_action(AccessibleAction::SetValue, move |data, window, cx| {\n                    if let Some(gpui_kit::accesskit::ActionData::Value(value)) = data {\n                        action_state.update(cx, |state, cx| {\n                            let end = state.value().encode_utf16().count();\n                            state.replace_text_in_range(Some(0..end), value, window, cx);\n                        });\n                    }\n                })\n            })\n            .flex()\n            .w_full()\n            .min_w_0()\n            .px(theme.space(2.5))\n            .text_color(theme.colors.foreground);\n        let root = if self.bordered {\n            focus::shown_for(\n                control::frame(root, theme, self.invalid),\n                theme,\n                focused,\n                self.invalid,\n            )\n            // The ring is a shadow painted under the whole box; a translucent\n            // fill would show it across a tall textarea.\n            .when_some(\n                focused.then(|| theme.opaque(theme.control().background)),\n                |root, fill| root.bg(fill),\n            )\n        } else {\n            super::theme::primitives::text::sm(root, theme)\n        };\n        root.when(self.disabled, disabled::style)\n            .when_some(paste_handler, |root, handler| {\n                root.capture_action(move |_: &gpui_kit::base::input::Paste, window, cx| {\n                    if let Some(clipboard) = cx.read_from_clipboard()\n                        && handler(&clipboard, window, cx)\n                    {\n                        cx.stop_propagation();\n                    }\n                })\n            })\n            .child(state)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use gpui_kit::{AppContext as _, Context, Render, TestAppContext, VisualTestContext};\n    use std::{cell::Cell, rc::Rc};\n\n    struct PasteProbe {\n        input: Entity<InputState>,\n        textarea: Entity<TextareaState>,\n        multiline: bool,\n        disabled: bool,\n        read_only: bool,\n        hits: Rc<Cell<usize>>,\n    }\n\n    impl Render for PasteProbe {\n        fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {\n            let hits = self.hits.clone();\n            let handler = move |item: &ClipboardItem, _: &mut Window, _: &mut App| {\n                hits.set(hits.get() + 1);\n                item.text().as_deref() == Some(\"asset\")\n            };\n            if self.multiline {\n                Textarea::new(&self.textarea)\n                    .disabled(self.disabled)\n                    .read_only(self.read_only)\n                    .on_paste(handler)\n                    .into_any_element()\n            } else {\n                Input::new(&self.input)\n                    .disabled(self.disabled)\n                    .read_only(self.read_only)\n                    .on_paste(handler)\n                    .into_any_element()\n            }\n        }\n    }\n\n    #[gpui_kit::test]\n    fn paste_hooks_consume_payloads_and_respect_editability(cx: &mut TestAppContext) {\n        cx.update(super::super::theme::init);\n        for multiline in [false, true] {\n            let hits = Rc::new(Cell::new(0));\n            let (probe, visual) = cx.add_window_view({\n                let hits = hits.clone();\n                move |window, cx| PasteProbe {\n                    input: cx.new(|cx| InputState::new(window, cx)),\n                    textarea: cx.new(|cx| TextareaState::new(window, cx)),\n                    multiline,\n                    disabled: false,\n                    read_only: false,\n                    hits,\n                }\n            });\n            let draw = |visual: &mut VisualTestContext| {\n                visual.update(|window, cx| window.draw(cx).clear(cx));\n            };\n            let dispatch = |visual: &mut VisualTestContext, text: &str| {\n                visual.update(|window, cx| {\n                    if multiline {\n                        let textarea = probe.read(cx).textarea.clone();\n                        textarea.update(cx, |state, cx| state.focus(window, cx));\n                    } else {\n                        let input = probe.read(cx).input.clone();\n                        input.update(cx, |state, cx| state.focus(window, cx));\n                    }\n                    cx.write_to_clipboard(ClipboardItem::new_string(text.into()));\n                    window.dispatch_action(Box::new(gpui_kit::base::input::Paste), cx);\n                });\n            };\n            let value = |visual: &mut VisualTestContext| {\n                visual.update(|_, cx| {\n                    let probe = probe.read(cx);\n                    if multiline {\n                        probe.textarea.read(cx).value().to_string()\n                    } else {\n                        probe.input.read(cx).value().to_string()\n                    }\n                })\n            };\n\n            draw(visual);\n            dispatch(visual, \"asset\");\n            assert_eq!(hits.get(), 1);\n            assert_eq!(value(visual), \"\");\n\n            dispatch(visual, \"text\");\n            assert_eq!(hits.get(), 2);\n            assert_eq!(value(visual), \"text\");\n\n            for (disabled, read_only) in [(true, false), (false, true)] {\n                probe.update(visual, |probe, cx| {\n                    probe.disabled = disabled;\n                    probe.read_only = read_only;\n                    cx.notify();\n                });\n                draw(visual);\n                dispatch(visual, \"asset\");\n                assert_eq!(hits.get(), 2);\n                assert_eq!(value(visual), \"text\");\n            }\n        }\n    }\n}\n\n#[cfg(test)]\nmod spelling_tests {\n    use super::*;\n    use gpui_kit::{AppContext as _, Render, TestAppContext, VisualTestContext};\n\n    struct Notes {\n        input: Entity<TextareaState>,\n        misspellings: Entity<Misspellings>,\n    }\n\n    impl Render for Notes {\n        fn render(&mut self, _: &mut Window, _: &mut gpui_kit::Context<Self>) -> impl IntoElement {\n            gpui_kit::div().w(px(400.)).child(\n                Textarea::new(&self.input)\n                    .aria_label(\"Notes\")\n                    .misspellings(&self.misspellings),\n            )\n        }\n    }\n\n    fn notes(text: &'static str, cx: &mut TestAppContext) -> (Entity<Notes>, VisualTestContext) {\n        cx.update(super::super::theme::init);\n        let window = cx.add_window(move |window, cx| {\n            let input = cx.new(|cx| TextareaState::new(window, cx));\n            input.update(cx, |input, cx| input.set_value(text, window, cx));\n            let misspellings = cx.new(|cx| Misspellings::new(&input, cx));\n            Notes {\n                input,\n                misspellings,\n            }\n        });\n        let view = window.root(cx).unwrap();\n        let mut cx = VisualTestContext::from_window(window.into(), cx);\n        cx.update(|window, cx| {\n            window.activate_window();\n            let input = view.read(cx).input.clone();\n            input.update(cx, |input, cx| input.focus(window, cx));\n            window.draw(cx).clear(cx);\n        });\n        (view, cx)\n    }\n\n    #[gpui_kit::test]\n    fn edits_move_later_ranges_and_drop_touched_ones(cx: &mut TestAppContext) {\n        let (view, mut cx) = notes(\"teh cat sat on teh mat\", cx);\n        let (input, misspellings) = cx.update(|_, cx| {\n            let view = view.read(cx);\n            (view.input.clone(), view.misspellings.clone())\n        });\n        cx.update(|_, cx| misspellings.update(cx, |m, cx| m.set([0..3, 15..18, 30..40], cx)));\n        cx.update(|_, cx| {\n            assert_eq!(\n                misspellings.read(cx).ranges(),\n                [0..3, 15..18],\n                \"out of range dropped\"\n            )\n        });\n        // Typing before the second word moves it.\n        cx.update(|window, cx| {\n            input.update(cx, |input, cx| {\n                input.set_selected_range(4..4, cx);\n                input.replace(\"big \", window, cx);\n            })\n        });\n        cx.run_until_parked();\n        cx.update(|_, cx| assert_eq!(misspellings.read(cx).ranges(), [0..3, 19..22]));\n        // Typing inside the first word drops it.\n        cx.update(|window, cx| {\n            input.update(cx, |input, cx| {\n                input.set_selected_range(1..1, cx);\n                input.replace(\"x\", window, cx);\n            })\n        });\n        cx.run_until_parked();\n        cx.update(|_, cx| {\n            let misspellings = misspellings.read(cx);\n            assert_eq!(misspellings.ranges(), vec![20..23]);\n            assert_eq!(misspellings.range_at(21), Some(20..23));\n            assert_eq!(misspellings.range_at(5), None);\n        });\n    }\n\n    #[gpui_kit::test]\n    fn a_suggestion_replaces_the_word_in_one_undoable_edit(cx: &mut TestAppContext) {\n        let (view, mut cx) = notes(\"see teh cat\", cx);\n        let input = cx.update(|_, cx| view.read(cx).input.clone());\n        cx.update(|_, cx| {\n            view.read(cx)\n                .misspellings\n                .clone()\n                .update(cx, |m, cx| m.set(std::iter::once(4..7), cx));\n        });\n        cx.dispatch_action(ReplaceMisspelling {\n            range: 4..7,\n            text: \"the\".into(),\n        });\n        cx.update(|_, cx| assert_eq!(input.read(cx).value(), \"see the cat\"));\n        cx.simulate_keystrokes(\"secondary-z\");\n        cx.update(|_, cx| assert_eq!(input.read(cx).value(), \"see teh cat\"));\n    }\n\n    #[gpui_kit::test]\n    fn the_spelling_menu_puts_suggestions_above_the_edit_items(cx: &mut TestAppContext) {\n        let mut menu = SpellingMenu {\n            range: 0..3,\n            word: \"teh\".into(),\n            menu: NativeMenu::new(),\n        };\n        menu.suggestion(\"the\").suggestion(\"ten\");\n        let menu = cx.update(|cx| edit_menu(menu.menu, false, true, cx));\n        assert!(!menu.is_empty());\n    }\n}\n"
    },
    {
      "path": "registry/textarea/textarea.rs",
      "type": "registry:file",
      "target": "~/src/ui/textarea.rs",
      "content": "//! Discoverable Nova textarea built on the shared Kit-backed input source.\n\npub use super::input::{Textarea, TextareaState};\nuse gpui_kit::Entity;\n\n/// Creates a textarea using the caller's retained editing state.\npub fn textarea(state: &Entity<TextareaState>) -> Textarea {\n    Textarea::new(state)\n}\n"
    },
    {
      "path": "registry/composer/composer.rs",
      "type": "registry:file",
      "target": "~/src/ui/composer.rs",
      "content": "//! Nova chat composer: a growing textarea with caret control, paste and key\n//! hooks, Enter to send, and an autocomplete popup for `@`, `~`, `:` and `/`.\n//!\n//! The application owns what the triggers mean. It listens for\n//! `ComposerEvent::Autocomplete`, looks up suggestions (synchronously or not)\n//! and passes them to `set_suggestions`; accepting one replaces the trigger\n//! and query with the suggestion's text.\n\nuse std::ops::Range;\nuse std::rc::Rc;\n\nuse gpui_icons::{LucideIcon, lucide};\nuse gpui_kit::base::TestSupportExt as _;\nuse gpui_kit::{\n    Anchor, AnchoredPositionMode, AnyElement, App, AppContext as _, Bounds, ClipboardItem, Context,\n    ElementId, Entity, EntityInputHandler as _, EventEmitter, FocusHandle, Focusable, FontWeight,\n    InteractiveElement as _, IntoElement, Keystroke, ParentElement, Pixels, Point, Render,\n    RenderOnce, Role, SharedString, StatefulInteractiveElement as _, StyleRefinement, Styled,\n    Subscription, Window, anchored, deferred, div, point, prelude::FluentBuilder as _, px,\n};\n\nuse super::input::{InputEvent, Misspellings, SpellingMenu, Textarea, TextareaState};\nuse super::theme::{\n    UiText, UiTheme, apply_style,\n    locale::{self, DirectionalStyled as _},\n    primitives::surface,\n};\n\ntype KeyHandler = Rc<dyn Fn(&Keystroke, &mut Window, &mut App) -> bool + 'static>;\ntype PasteHandler = Rc<dyn Fn(&ClipboardItem, &mut Window, &mut App) -> bool + 'static>;\ntype SuggestionSlot =\n    Rc<dyn Fn(&ComposerSuggestion, &mut Window, &mut App) -> Option<AnyElement> + 'static>;\n\n/// One autocomplete entry.\n#[derive(Clone, Debug, PartialEq)]\npub struct ComposerSuggestion {\n    /// The text that replaces the trigger and query, such as `\"@arya\"`.\n    pub value: SharedString,\n    /// The visible name, such as \"Arya Jha\".\n    pub label: SharedString,\n    /// Secondary text, such as \"@arya\" or a channel purpose.\n    pub description: Option<SharedString>,\n    /// A leading Lucide icon, such as `Hash` for channels.\n    pub icon: Option<LucideIcon>,\n}\n\nimpl ComposerSuggestion {\n    /// Creates a suggestion that inserts `value` and shows `label`.\n    pub fn new(value: impl Into<SharedString>, label: impl Into<SharedString>) -> Self {\n        Self {\n            value: value.into(),\n            label: label.into(),\n            description: None,\n            icon: None,\n        }\n    }\n    /// Adds secondary text after the label.\n    pub fn description(mut self, description: impl Into<SharedString>) -> Self {\n        self.description = Some(description.into());\n        self\n    }\n    /// Adds a leading Lucide icon.\n    pub fn icon(mut self, icon: LucideIcon) -> Self {\n        self.icon = Some(icon);\n        self\n    }\n}\n\n/// Notifications from a composer.\n#[derive(Clone, Debug, PartialEq)]\npub enum ComposerEvent {\n    /// The text changed.\n    Change,\n    /// Enter was pressed outside autocomplete and IME composition. The\n    /// application sends the text and clears the composer with `set_value`.\n    Submit(SharedString),\n    /// The caret is in a trigger such as `@ar`: look up suggestions for\n    /// `query` and pass them to `set_suggestions`.\n    Autocomplete {\n        /// The trigger character, such as `'@'`.\n        trigger: char,\n        /// The text typed after the trigger.\n        query: SharedString,\n    },\n    /// The caret left the trigger, or the reader dismissed the popup.\n    AutocompleteClosed,\n    /// A suggestion replaced the trigger and query.\n    Accept {\n        /// The trigger character.\n        trigger: char,\n        /// The accepted suggestion's value.\n        value: SharedString,\n    },\n    /// A suggestion opened with `open_suggestions` replaced its range.\n    AcceptRange {\n        /// The byte range that was replaced, in the text before the edit.\n        range: Range<usize>,\n        /// The accepted suggestion's value.\n        value: SharedString,\n    },\n}\n\n#[derive(Clone, Debug, PartialEq)]\nstruct ActiveTrigger {\n    trigger: char,\n    start: usize,\n    query: SharedString,\n}\n\n/// Finds the trigger the caret is in: a trigger character at the start of the\n/// text or after whitespace, followed by non-whitespace up to the caret.\n/// `/` only counts at the very start, as a command. Returns the trigger, its\n/// byte offset and the query after it.\n///\n/// A trigger inside Markdown code, an unclosed backtick span on its line or\n/// an open ``` fence, does not count, so `` `npm i @types/node` `` opens no\n/// popup. Use [`active_trigger_with`] to count those too.\npub fn active_trigger<'a>(\n    text: &'a str,\n    cursor: usize,\n    triggers: &[char],\n) -> Option<(char, usize, &'a str)> {\n    active_trigger_with(text, cursor, triggers, true)\n}\n\n/// [`active_trigger`], with `ignore_code` choosing whether triggers inside\n/// Markdown code spans and fences are skipped.\npub fn active_trigger_with<'a>(\n    text: &'a str,\n    cursor: usize,\n    triggers: &[char],\n    ignore_code: bool,\n) -> Option<(char, usize, &'a str)> {\n    let found = find_trigger(text, cursor, triggers)?;\n    if ignore_code && in_code(text, found.1) {\n        return None;\n    }\n    Some(found)\n}\n\n/// Whether byte `offset` of `text` is inside Markdown code: an open fenced\n/// block (``` or ~~~) or an unclosed backtick span earlier on its line.\npub fn in_code(text: &str, offset: usize) -> bool {\n    let Some(before) = text.get(..offset) else {\n        return false;\n    };\n    let line_start = before.rfind('\\n').map_or(0, |index| index + 1);\n    let mut fence: Option<(char, usize)> = None;\n    for line in before[..line_start].lines() {\n        let trimmed = line.trim_start();\n        let marker = trimmed.chars().next().filter(|c| *c == '`' || *c == '~');\n        let Some(marker) = marker else {\n            continue;\n        };\n        let run = trimmed.chars().take_while(|c| *c == marker).count();\n        if run < 3 {\n            continue;\n        }\n        fence = match fence {\n            None => Some((marker, run)),\n            Some((open, length)) if open == marker && run >= length => None,\n            open => open,\n        };\n    }\n    let line = &before[line_start..];\n    let trimmed = line.trim_start();\n    if fence.is_some() || trimmed.starts_with(\"```\") || trimmed.starts_with(\"~~~\") {\n        return true;\n    }\n    // A span opens with a run of backticks and closes with a run as long.\n    let mut open: Option<usize> = None;\n    let mut chars = line.chars().peekable();\n    while let Some(c) = chars.next() {\n        if c != '`' {\n            continue;\n        }\n        let mut run = 1;\n        while chars.peek() == Some(&'`') {\n            chars.next();\n            run += 1;\n        }\n        open = match open {\n            None => Some(run),\n            Some(length) if length == run => None,\n            open => open,\n        };\n    }\n    open.is_some()\n}\n\nfn find_trigger<'a>(\n    text: &'a str,\n    cursor: usize,\n    triggers: &[char],\n) -> Option<(char, usize, &'a str)> {\n    let before = text.get(..cursor)?;\n    let (start, trigger) = before\n        .char_indices()\n        .rev()\n        .take_while(|(_, c)| !c.is_whitespace())\n        .filter(|(_, c)| triggers.contains(c))\n        .last()?;\n    let preceded_by_space = before[..start]\n        .chars()\n        .next_back()\n        .is_none_or(char::is_whitespace);\n    if !preceded_by_space || (trigger == '/' && start != 0) {\n        return None;\n    }\n    Some((trigger, start, &before[start + trigger.len_utf8()..]))\n}\n\n/// Retained composer state: the editor, triggers and autocomplete.\npub struct ComposerState {\n    input: Entity<TextareaState>,\n    misspellings: Entity<Misspellings>,\n    triggers: Vec<char>,\n    ignore_code: bool,\n    active: Option<ActiveTrigger>,\n    /// A range the application opened suggestions for; it wins over triggers.\n    custom: Option<Range<usize>>,\n    dismissed: Option<usize>,\n    suggestions: Vec<ComposerSuggestion>,\n    highlighted: usize,\n    submit_on_enter: bool,\n    on_key: Option<KeyHandler>,\n    on_paste: Option<PasteHandler>,\n    leading: Option<SuggestionSlot>,\n    max_rows: usize,\n    _subscriptions: Vec<Subscription>,\n}\n\nimpl EventEmitter<ComposerEvent> for ComposerState {}\n\nimpl Focusable for ComposerState {\n    fn focus_handle(&self, cx: &App) -> FocusHandle {\n        self.input.read(cx).focus_handle(cx)\n    }\n}\n\nimpl ComposerState {\n    /// Creates a composer that grows from one to `max_rows` lines.\n    pub fn new(max_rows: usize, window: &mut Window, cx: &mut Context<Self>) -> Self {\n        let max_rows = max_rows.max(1);\n        let input = cx.new(|cx| {\n            TextareaState::new(window, cx)\n                .auto_grow(1, max_rows)\n                .placeholder(\"Write a message…\")\n        });\n        let window_handle = window.window_handle();\n        let weak = cx.weak_entity();\n        let subscriptions = vec![\n            cx.subscribe(&input, |this, _, event, cx| {\n                if let InputEvent::Change = event {\n                    cx.emit(ComposerEvent::Change);\n                }\n                this.refresh_trigger(cx);\n            }),\n            // Cursor moves notify without a change event.\n            cx.observe(&input, |this, _, cx| this.refresh_trigger(cx)),\n            // Keystrokes reach interceptors before the editor's own bindings,\n            // so autocomplete keys, the caller's hook and Enter win over them.\n            cx.intercept_keystrokes(move |event, window, cx| {\n                if window.window_handle() != window_handle {\n                    return;\n                }\n                let Some(state) = weak.upgrade() else {\n                    return;\n                };\n                let focus = state.read(cx).focus_handle(cx);\n                if !focus.is_focused(window) {\n                    return;\n                }\n                if state.update(cx, |state, cx| {\n                    state.handle_key(&event.keystroke, window, cx)\n                }) {\n                    cx.stop_propagation();\n                }\n            }),\n        ];\n        let misspellings = cx.new(|cx| Misspellings::new(&input, cx));\n        Self {\n            input,\n            misspellings,\n            triggers: vec!['@', '~', ':', '/'],\n            ignore_code: true,\n            active: None,\n            custom: None,\n            dismissed: None,\n            suggestions: Vec::new(),\n            highlighted: 0,\n            submit_on_enter: true,\n            on_key: None,\n            on_paste: None,\n            leading: None,\n            max_rows,\n            _subscriptions: subscriptions,\n        }\n    }\n\n    /// The editing state, for anything not covered here.\n    pub fn input(&self) -> &Entity<TextareaState> {\n        &self.input\n    }\n\n    /// The misspelled ranges the composer underlines.\n    pub fn misspellings(&self) -> &Entity<Misspellings> {\n        &self.misspellings\n    }\n\n    /// Underlines misspelled byte ranges of the current text with a wavy\n    /// line. Pass fresh ranges a moment after typing stops; edits move or\n    /// drop the old ones meanwhile.\n    pub fn set_misspellings(\n        &mut self,\n        ranges: impl IntoIterator<Item = Range<usize>>,\n        cx: &mut Context<Self>,\n    ) {\n        self.misspellings\n            .update(cx, |misspellings, cx| misspellings.set(ranges, cx));\n    }\n\n    /// Builds the right-click menu for a misspelled word: suggestions, which\n    /// replace it in one undoable edit, and app items such as \"Ignore\". They\n    /// go above Cut, Copy, Paste and Select All.\n    pub fn set_on_misspelling_menu(\n        &mut self,\n        handler: impl Fn(&mut SpellingMenu, &mut Window, &mut App) + 'static,\n        cx: &mut Context<Self>,\n    ) {\n        self.misspellings\n            .update(cx, |misspellings, _| misspellings.on_menu(handler));\n    }\n\n    /// The number of lines the editor grows to before it scrolls.\n    pub fn max_rows(&self) -> usize {\n        self.max_rows\n    }\n\n    /// Changes the number of lines the editor grows to before it scrolls,\n    /// keeping the draft, selection and history. `Composer::max_height`\n    /// calls it on each render to follow a cap in pixels.\n    pub fn set_max_rows(&mut self, max_rows: usize, cx: &mut Context<Self>) {\n        let max_rows = max_rows.max(1);\n        if max_rows == self.max_rows {\n            return;\n        }\n        self.max_rows = max_rows;\n        self.input\n            .update(cx, |input, cx| input.set_auto_grow(1, max_rows, cx));\n        cx.notify();\n    }\n\n    /// Sets the placeholder.\n    pub fn set_placeholder(\n        &mut self,\n        placeholder: impl Into<SharedString>,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) {\n        let placeholder = placeholder.into();\n        self.input.update(cx, |input, cx| {\n            input.set_placeholder(placeholder, window, cx)\n        });\n    }\n\n    /// Sets the characters that open autocomplete. Defaults to `@ ~ : /`.\n    pub fn set_triggers(\n        &mut self,\n        triggers: impl IntoIterator<Item = char>,\n        cx: &mut Context<Self>,\n    ) {\n        self.triggers = triggers.into_iter().collect();\n        self.refresh_trigger(cx);\n    }\n\n    /// Whether triggers inside Markdown code spans and fences are ignored, as\n    /// in the Mattermost web app. On by default.\n    pub fn set_ignore_triggers_in_code(&mut self, ignore: bool, cx: &mut Context<Self>) {\n        self.ignore_code = ignore;\n        self.refresh_trigger(cx);\n    }\n\n    /// Whether Enter sends (Shift+Enter adds a line). On by default.\n    pub fn set_submit_on_enter(&mut self, submit: bool) {\n        self.submit_on_enter = submit;\n    }\n\n    /// Sees each key press before the composer and the editor, while the\n    /// composer has focus and autocomplete is closed. Return `true` to claim\n    /// it, for example Up in an empty composer to edit the last message.\n    pub fn set_on_key(\n        &mut self,\n        handler: impl Fn(&Keystroke, &mut Window, &mut App) -> bool + 'static,\n    ) {\n        self.on_key = Some(Rc::new(handler));\n    }\n\n    /// Sees a paste first. Return `true` to claim it, for example when the\n    /// clipboard holds an image or files to upload.\n    pub fn set_on_paste(\n        &mut self,\n        handler: impl Fn(&ClipboardItem, &mut Window, &mut App) -> bool + 'static,\n    ) {\n        self.on_paste = Some(Rc::new(handler));\n    }\n\n    /// Renders the leading element of each suggestion, such as an avatar or\n    /// emoji image. Return `None` to fall back to the suggestion's icon.\n    pub fn set_suggestion_leading(\n        &mut self,\n        slot: impl Fn(&ComposerSuggestion, &mut Window, &mut App) -> Option<AnyElement> + 'static,\n    ) {\n        self.leading = Some(Rc::new(slot));\n    }\n\n    /// The text.\n    pub fn value(&self, cx: &App) -> SharedString {\n        self.input.read(cx).value()\n    }\n\n    /// Replaces the text, for example with an empty string after sending.\n    pub fn set_value(\n        &mut self,\n        value: impl Into<SharedString>,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) {\n        let value: SharedString = value.into();\n        let end = value.len();\n        self.input.update(cx, |input, cx| {\n            input.set_value(value, window, cx);\n            input.set_selected_range(end..end, cx);\n        });\n        self.refresh_trigger(cx);\n    }\n\n    /// The selected byte range; empty at the caret.\n    pub fn selection(&self, cx: &App) -> Range<usize> {\n        self.input.read(cx).selected_range()\n    }\n\n    /// Selects a byte range, or places the caret with an empty range.\n    pub fn set_selection(&mut self, range: Range<usize>, cx: &mut Context<Self>) {\n        self.input\n            .update(cx, |input, cx| input.set_selected_range(range, cx));\n    }\n\n    /// Replaces the selection (or inserts at the caret) and leaves the caret after it.\n    pub fn insert(\n        &mut self,\n        text: impl Into<SharedString>,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) {\n        let text = text.into();\n        self.input\n            .update(cx, |input, cx| input.replace(text, window, cx));\n    }\n\n    /// Wraps the selection in `before` and `after`, such as `**` for bold,\n    /// keeping the original text selected. With no selection the caret ends\n    /// between them.\n    pub fn wrap_selection(\n        &mut self,\n        before: &str,\n        after: &str,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) {\n        let range = self.selection(cx);\n        let value = self.value(cx);\n        let selected = value.get(range.clone()).unwrap_or_default();\n        let wrapped = format!(\"{before}{selected}{after}\");\n        let inner = range.start + before.len()..range.start + before.len() + selected.len();\n        self.input.update(cx, |input, cx| {\n            input.replace(wrapped, window, cx);\n            input.set_selected_range(inner, cx);\n        });\n    }\n\n    /// The caret's rectangle in window coordinates, from the last layout.\n    pub fn caret_bounds(&self, cx: &App) -> Option<Bounds<Pixels>> {\n        let input = self.input.read(cx);\n        let cursor = input.cursor();\n        input.range_to_bounds(&(cursor..cursor))\n    }\n\n    /// Whether an input method is composing text, such as CJK or a dead key.\n    /// Keys during composition belong to the input method.\n    pub fn is_composing(&self, window: &mut Window, cx: &mut App) -> bool {\n        self.input.update(cx, |input, cx| {\n            input.marked_text_range(window, cx).is_some()\n        })\n    }\n\n    /// Focuses the editor.\n    pub fn focus(&self, window: &mut Window, cx: &mut App) {\n        self.input.update(cx, |input, cx| input.focus(window, cx));\n    }\n\n    /// Shows suggestions for the current trigger; an empty list hides the popup.\n    pub fn set_suggestions(\n        &mut self,\n        suggestions: impl IntoIterator<Item = ComposerSuggestion>,\n        cx: &mut Context<Self>,\n    ) {\n        self.suggestions = suggestions.into_iter().collect();\n        self.highlighted = 0;\n        cx.notify();\n    }\n\n    /// Opens the suggestion popup for a byte range the application chose,\n    /// such as the argument after `/jira create `, anchored at its start.\n    ///\n    /// Accepting a suggestion replaces the range with its value and a space\n    /// and emits `ComposerEvent::AcceptRange`. Keys work as for a trigger.\n    /// Call it again with a new range or list as the text changes (an empty\n    /// list hides the popup), and `close_suggestions` when it no longer\n    /// applies. While it is open, trigger characters do not open their own.\n    pub fn open_suggestions(\n        &mut self,\n        range: Range<usize>,\n        suggestions: impl IntoIterator<Item = ComposerSuggestion>,\n        cx: &mut Context<Self>,\n    ) {\n        let len = self.value(cx).len();\n        let start = range.start.min(len);\n        let range = start..range.end.clamp(start, len);\n        let same_range = self.custom.as_ref() == Some(&range);\n        let previous = self.highlighted_suggestion().map(|item| item.value.clone());\n        self.active = None;\n        self.custom = Some(range);\n        self.suggestions = suggestions.into_iter().collect();\n        // Updating the list for the same range keeps the highlighted entry.\n        self.highlighted = previous\n            .filter(|_| same_range)\n            .and_then(|value| self.suggestions.iter().position(|item| item.value == value))\n            .unwrap_or(0);\n        cx.notify();\n    }\n\n    /// Closes suggestions opened with `open_suggestions`.\n    pub fn close_suggestions(&mut self, cx: &mut Context<Self>) {\n        if self.custom.take().is_some() {\n            self.suggestions.clear();\n            cx.notify();\n            self.refresh_trigger(cx);\n        }\n    }\n\n    /// The range suggestions were opened for with `open_suggestions`.\n    pub fn suggestion_range(&self) -> Option<Range<usize>> {\n        self.custom.clone()\n    }\n\n    /// Whether the autocomplete popup is showing.\n    pub fn is_autocomplete_open(&self) -> bool {\n        (self.active.is_some() || self.custom.is_some()) && !self.suggestions.is_empty()\n    }\n\n    /// The highlighted suggestion while the popup is open.\n    pub fn highlighted_suggestion(&self) -> Option<&ComposerSuggestion> {\n        self.is_autocomplete_open()\n            .then(|| self.suggestions.get(self.highlighted))\n            .flatten()\n    }\n\n    /// Replaces the trigger and query with suggestion `index` and a space.\n    pub fn accept(&mut self, index: usize, window: &mut Window, cx: &mut Context<Self>) {\n        if let Some(range) = self.custom.clone() {\n            let Some(suggestion) = self.suggestions.get(index).cloned() else {\n                return;\n            };\n            let text = format!(\"{} \", suggestion.value);\n            self.custom = None;\n            self.suggestions.clear();\n            self.input.update(cx, |input, cx| {\n                input.set_selected_range(range.clone(), cx);\n                input.replace(text, window, cx);\n            });\n            cx.emit(ComposerEvent::AcceptRange {\n                range,\n                value: suggestion.value,\n            });\n            cx.notify();\n            return;\n        }\n        let (Some(active), Some(suggestion)) =\n            (self.active.clone(), self.suggestions.get(index).cloned())\n        else {\n            return;\n        };\n        let end = active.start + active.trigger.len_utf8() + active.query.len();\n        let text = format!(\"{} \", suggestion.value);\n        self.input.update(cx, |input, cx| {\n            input.set_selected_range(active.start..end, cx);\n            input.replace(text, window, cx);\n        });\n        self.active = None;\n        self.suggestions.clear();\n        cx.emit(ComposerEvent::Accept {\n            trigger: active.trigger,\n            value: suggestion.value,\n        });\n        cx.notify();\n    }\n\n    fn close_autocomplete(&mut self, cx: &mut Context<Self>) {\n        if self.custom.take().is_some() {\n            self.suggestions.clear();\n            cx.emit(ComposerEvent::AutocompleteClosed);\n            cx.notify();\n            return;\n        }\n        if self.active.take().is_some() {\n            self.suggestions.clear();\n            cx.emit(ComposerEvent::AutocompleteClosed);\n            cx.notify();\n        }\n    }\n\n    fn refresh_trigger(&mut self, cx: &mut Context<Self>) {\n        if self.custom.is_some() {\n            return;\n        }\n        let input = self.input.read(cx);\n        let value = input.value();\n        let range = input.selected_range();\n        let found = (range.is_empty())\n            .then(|| active_trigger_with(&value, range.end, &self.triggers, self.ignore_code))\n            .flatten()\n            .map(|(trigger, start, query)| ActiveTrigger {\n                trigger,\n                start,\n                query: query.to_string().into(),\n            });\n        if self.dismissed.is_some() && found.as_ref().map(|found| found.start) != self.dismissed {\n            self.dismissed = None;\n        }\n        let found = found.filter(|found| Some(found.start) != self.dismissed);\n        if found == self.active {\n            return;\n        }\n        match found {\n            Some(found) => {\n                cx.emit(ComposerEvent::Autocomplete {\n                    trigger: found.trigger,\n                    query: found.query.clone(),\n                });\n                self.active = Some(found);\n            }\n            None => self.close_autocomplete(cx),\n        }\n        cx.notify();\n    }\n\n    fn handle_key(\n        &mut self,\n        keystroke: &Keystroke,\n        window: &mut Window,\n        cx: &mut Context<Self>,\n    ) -> bool {\n        if self.is_composing(window, cx) {\n            return false;\n        }\n        let modifiers = keystroke.modifiers;\n        let plain = !(modifiers.control || modifiers.alt || modifiers.platform || modifiers.shift);\n        if self.is_autocomplete_open() && plain {\n            let count = self.suggestions.len();\n            match keystroke.key.as_str() {\n                \"up\" => self.highlighted = (self.highlighted + count - 1) % count,\n                \"down\" => self.highlighted = (self.highlighted + 1) % count,\n                \"enter\" | \"tab\" => {\n                    self.accept(self.highlighted, window, cx);\n                    return true;\n                }\n                \"escape\" => {\n                    self.dismissed = self.active.as_ref().map(|active| active.start);\n                    self.close_autocomplete(cx);\n                    return true;\n                }\n                _ => return false,\n            }\n            cx.notify();\n            return true;\n        }\n        if let Some(handler) = self.on_key.clone()\n            && handler(keystroke, window, cx)\n        {\n            return true;\n        }\n        if self.submit_on_enter && keystroke.key == \"enter\" && plain {\n            cx.emit(ComposerEvent::Submit(self.value(cx)));\n            return true;\n        }\n        false\n    }\n}\n\nimpl Render for ComposerState {\n    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {\n        let theme = UiTheme::read(cx).clone();\n        let colors = theme.colors;\n        let id = ElementId::from((\"composer\", cx.entity_id()));\n        let on_paste = self.on_paste.clone();\n        let dir = theme.direction;\n        let textarea = Textarea::new(&self.input)\n            .misspellings(&self.misspellings)\n            .aria_label(locale::text(cx, UiText::Message))\n            .bordered(false)\n            .min_h(px(0.))\n            .px(text_inset(&theme).x)\n            .py(text_inset(&theme).y)\n            .when_some(on_paste, |textarea, handler| {\n                textarea.on_paste(move |item, window, cx| handler(item, window, cx))\n            });\n\n        let open = match (&self.custom, &self.active) {\n            (Some(range), _) => Some((None, range.start)),\n            (None, Some(active)) => Some((Some(active.trigger), active.start)),\n            (None, None) => None,\n        };\n        let popup = open\n            .filter(|_| !self.suggestions.is_empty())\n            .and_then(|(trigger, start)| {\n                // Both rectangles come from the editor's last layout, so their\n                // difference stays right even if the page moved since then.\n                let input = self.input.read(cx);\n                let active = trigger;\n                let trigger = input.range_to_bounds(&(start..start));\n                let (Some(trigger), Some(text)) = (trigger, input.text_bounds()) else {\n                    // The caret has no position until the editor's first layout.\n                    window.request_animation_frame();\n                    return None;\n                };\n                let anchor = trigger.origin - text.origin + text_inset(&theme);\n                Some((active, anchor))\n            })\n            .map(|(active, anchor)| {\n                let leading = self.leading.clone();\n                let rows: Vec<AnyElement> = self\n                    .suggestions\n                    .clone()\n                    .into_iter()\n                    .enumerate()\n                    .map(|(index, suggestion)| {\n                        let selected = index == self.highlighted;\n                        let leading = leading\n                            .as_ref()\n                            .and_then(|slot| slot(&suggestion, window, cx));\n                        div()\n                            .id((\n                                id.clone(),\n                                SharedString::from(format!(\"suggestion-{index}\")),\n                            ))\n                            .test_support()\n                            .role(Role::ListBoxOption)\n                            .aria_label(suggestion.label.clone())\n                            .aria_selected(selected)\n                            .when(selected, |row| row.aria_active_descendant())\n                            .flex_row_in(dir)\n                            .items_center()\n                            .gap(theme.space(2.))\n                            .h(theme.space(8.))\n                            .px(theme.space(2.))\n                            .rounded(theme.radius.md)\n                            .cursor_pointer()\n                            .when(selected, |row| row.bg(colors.muted))\n                            .on_hover(cx.listener(move |this, hovered, _, cx| {\n                                if *hovered && this.highlighted != index {\n                                    this.highlighted = index;\n                                    cx.notify();\n                                }\n                            }))\n                            .on_click(cx.listener(move |this, _, window, cx| {\n                                this.accept(index, window, cx);\n                                this.focus(window, cx);\n                            }))\n                            .map(|row| match (leading, suggestion.icon) {\n                                (Some(leading), _) => row.child(\n                                    div().flex_shrink_0().flex().items_center().child(leading),\n                                ),\n                                (None, Some(icon)) => row.child(\n                                    lucide(icon)\n                                        .size(theme.space(4.))\n                                        .flex_shrink_0()\n                                        .text_color(colors.muted_foreground),\n                                ),\n                                (None, None) => row,\n                            })\n                            .child(\n                                div()\n                                    .flex_shrink_0()\n                                    .font_weight(FontWeight::MEDIUM)\n                                    .child(suggestion.label.clone()),\n                            )\n                            .children(suggestion.description.clone().map(|description| {\n                                div()\n                                    .min_w_0()\n                                    .overflow_hidden()\n                                    .text_ellipsis()\n                                    .whitespace_nowrap()\n                                    .text_color(colors.muted_foreground)\n                                    .child(description)\n                            }))\n                            .into_any_element()\n                    })\n                    .collect();\n                let list_label = locale::text(\n                    cx,\n                    match active {\n                        Some('@') => UiText::People,\n                        Some('~') => UiText::Channels,\n                        Some(':') => UiText::Emoji,\n                        Some('/') => UiText::Commands,\n                        _ => UiText::Suggestions,\n                    },\n                );\n                // The list hangs from the trigger toward the reading end.\n                let x = if dir.is_rtl() {\n                    anchor.x + theme.space(2.)\n                } else {\n                    anchor.x - theme.space(2.)\n                };\n                deferred(\n                    anchored()\n                        .position_mode(AnchoredPositionMode::Local)\n                        .position(point(x, anchor.y - px(4.)))\n                        .anchor(dir.anchor(Anchor::BottomLeft))\n                        .snap_to_window_with_margin(theme.space(2.))\n                        .child(\n                            div()\n                                .id((id.clone(), \"suggestions\"))\n                                .role(Role::ListBox)\n                                .aria_label(list_label)\n                                .occlude()\n                                .w(theme.space(72.))\n                                .max_h(theme.space(72.))\n                                .overflow_y_scroll()\n                                .map(|list| surface::menu(list, &theme))\n                                .children(rows),\n                        ),\n                )\n                .with_priority(1)\n            });\n\n        div()\n            .id(id)\n            .key_context(\"Composer\")\n            .relative()\n            .w_full()\n            .child(textarea)\n            .children(popup.map(|popup| div().absolute().top_0().left_0().child(popup)))\n    }\n}\n\n/// The editor's text origin inside the textarea: its padding.\nfn text_inset(theme: &UiTheme) -> Point<Pixels> {\n    point(theme.space(3.), theme.space(2.))\n}\n\n/// A composer bound to retained `ComposerState`, with an optional toolbar.\n///\n/// Children render in a row under the text, such as attach, emoji and send\n/// buttons; the composer draws the border and focus ring around both.\n#[derive(IntoElement)]\npub struct Composer {\n    state: Entity<ComposerState>,\n    max_height: Option<Pixels>,\n    toolbar: Vec<AnyElement>,\n    style: StyleRefinement,\n}\n\nimpl Composer {\n    /// Creates a composer for retained state.\n    pub fn new(state: &Entity<ComposerState>) -> Self {\n        Self {\n            state: state.clone(),\n            max_height: None,\n            toolbar: Vec::new(),\n            style: StyleRefinement::default(),\n        }\n    }\n\n    /// Caps the text box at a height, such as 40% of the window, without\n    /// rebuilding the state: the editor grows line by line until the box\n    /// reaches it, then scrolls. The toolbar is not counted. Pass a value\n    /// derived from `window.viewport_size()` on every render to follow resizes.\n    pub fn max_height(mut self, height: impl Into<Pixels>) -> Self {\n        self.max_height = Some(height.into());\n        self\n    }\n}\n\n/// How many editor lines fit in a text box `height` tall.\nfn rows_within(height: Pixels, line_height: Pixels, inset: Pixels) -> usize {\n    if line_height <= px(0.) {\n        return 1;\n    }\n    (((height - inset * 2.) / line_height).floor() as usize).max(1)\n}\n\nimpl ParentElement for Composer {\n    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {\n        self.toolbar.extend(elements);\n    }\n}\n\nimpl Styled for Composer {\n    fn style(&mut self) -> &mut StyleRefinement {\n        &mut self.style\n    }\n}\n\nimpl RenderOnce for Composer {\n    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {\n        let theme = UiTheme::read(cx).clone();\n        let colors = theme.colors;\n        let focused = self.state.read(cx).focus_handle(cx).is_focused(window);\n        if let Some(height) = self.max_height {\n            // Before the editor's first layout, the type scale gives the line height.\n            let line_height = self\n                .state\n                .read(cx)\n                .input\n                .read(cx)\n                .line_height()\n                .unwrap_or_else(|| theme.text_style(theme.typography.sm).line_height);\n            let rows = rows_within(height, line_height, text_inset(&theme).y);\n            if rows != self.state.read(cx).max_rows {\n                self.state\n                    .update(cx, |state, cx| state.set_max_rows(rows, cx));\n            }\n        }\n        let root = div()\n            .w_full()\n            .flex()\n            .flex_col()\n            .rounded(theme.radius.lg)\n            .border_1()\n            .border_color(if focused { colors.ring } else { colors.input })\n            .bg(colors.background)\n            .child(self.state.clone())\n            .when(!self.toolbar.is_empty(), |root| {\n                root.child(\n                    div()\n                        .flex_row_in(theme.direction)\n                        .items_center()\n                        .gap(theme.space(1.))\n                        .px(theme.space(2.))\n                        .pb(theme.space(2.))\n                        .children(self.toolbar),\n                )\n            });\n        apply_style(root, &self.style)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::{active_trigger, active_trigger_with, rows_within};\n    use gpui_kit::px;\n\n    #[test]\n    fn a_pixel_cap_becomes_whole_lines() {\n        // 8px inset above and below, 20px lines.\n        assert_eq!(rows_within(px(216.), px(20.), px(8.)), 10);\n        assert_eq!(rows_within(px(215.), px(20.), px(8.)), 9);\n        // Never less than one line, even in a tiny window.\n        assert_eq!(rows_within(px(10.), px(20.), px(8.)), 1);\n        assert_eq!(rows_within(px(100.), px(0.), px(8.)), 1);\n    }\n\n    const TRIGGERS: [char; 4] = ['@', '~', ':', '/'];\n\n    #[test]\n    fn triggers_start_after_whitespace_and_end_at_the_caret() {\n        assert_eq!(active_trigger(\"hi @ar\", 6, &TRIGGERS), Some(('@', 3, \"ar\")));\n        assert_eq!(active_trigger(\"@\", 1, &TRIGGERS), Some(('@', 0, \"\")));\n        assert_eq!(\n            active_trigger(\"see ~gen\", 8, &TRIGGERS),\n            Some(('~', 4, \"gen\"))\n        );\n        assert_eq!(\n            active_trigger(\"nice :ta\", 8, &TRIGGERS),\n            Some((':', 5, \"ta\"))\n        );\n        assert_eq!(\n            active_trigger(\"/away\", 5, &TRIGGERS),\n            Some(('/', 0, \"away\"))\n        );\n        // Inside a word, after a space, or a slash mid-message: no trigger.\n        assert_eq!(active_trigger(\"mail@host\", 9, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"@arya done\", 10, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"a/b\", 3, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"x /cmd\", 6, &TRIGGERS), None);\n        // The caret, not the end of the text, ends the query.\n        assert_eq!(active_trigger(\"@arya\", 3, &TRIGGERS), Some(('@', 0, \"ar\")));\n    }\n\n    #[test]\n    fn triggers_inside_code_do_not_count() {\n        assert_eq!(active_trigger(\"run `@x\", 7, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"`npm i @types\", 13, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"`:wq\", 4, &TRIGGERS), None);\n        assert_eq!(active_trigger(\"```\\n@x\", 6, &TRIGGERS), None);\n        assert_eq!(\n            active_trigger(\"~~~ rust\\nlet a = 1;\\n :ta\", 23, &TRIGGERS),\n            None\n        );\n        // A closed span or fence ends the code.\n        assert_eq!(\n            active_trigger(\"`code` @ar\", 10, &TRIGGERS),\n            Some(('@', 7, \"ar\"))\n        );\n        assert_eq!(\n            active_trigger(\"```\\nx\\n```\\n@ar\", 13, &TRIGGERS),\n            Some(('@', 10, \"ar\"))\n        );\n        assert_eq!(\n            active_trigger(\"``a ` b`` @ar\", 13, &TRIGGERS),\n            Some(('@', 10, \"ar\"))\n        );\n        // The span is per line.\n        assert_eq!(\n            active_trigger(\"`open\\n@ar\", 9, &TRIGGERS),\n            Some(('@', 6, \"ar\"))\n        );\n        // The option turns it off.\n        assert_eq!(\n            active_trigger_with(\"`npm i @types\", 13, &TRIGGERS, false),\n            Some(('@', 7, \"types\"))\n        );\n    }\n}\n"
    }
  ],
  "meta": {
    "since": "0.7.0",
    "category": "chat"
  }
}
