gpui-cn 0.4.0

//! shadcn-style components for GPUI, built on `gpui-base`.
//!
//! gpui-cn depends on `gpui-kit` with the component layer off, so it adds
//! GPUI and `gpui-base` and nothing else.
//!
//! Initialize `gpui-base` first (through `gpui_kit::init`), then call
//! [`init`] once before opening windows. gpui-cn adds itself to every
//! window whose first level is gpui-base's `Root`, which
//! `gpui_kit::open_window` puts there:
//!
//! ```no_run
//! use gpui_kit::*;
//!
//! struct Hello;
//!
//! impl Render for Hello {
//!     fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
//!         div().p_4().child(
//!             gpui_cn::Button::new("save")
//!                 .primary()
//!                 .label("Save")
//!                 .on_click(|_, window, cx| {
//!                     let _ = window.prompt(PromptLevel::Info, "Saved", None, &["OK"], cx);
//!                 }),
//!         )
//!     }
//! }
//!
//! fn main() {
//!     gpui_kit::application().run(|cx| {
//!         gpui_kit::init(cx);
//!         gpui_cn::init(cx);
//!         gpui_kit::open_window(WindowOptions::default(), cx, |_, cx| cx.new(|_| Hello))
//!             .expect("failed to open window");
//!     });
//! }
//! ```

mod avatar;
mod badge;
mod button;
mod command;
mod icon;
mod input;
mod label;
mod looping;
mod menu;
mod nav;
mod popover;
mod progress;
mod root;
mod scroll_area;
mod select;
mod sidebar;
mod skeleton;
mod spinner;
mod switch;
mod tabs;
mod tag;
pub mod theme;
mod theme_mode_picker;
mod title_bar;
mod tooltip;
mod tooltip_host;
mod touch_selection;

pub use avatar::{Avatar, AvatarGroup, AvatarSize};
pub use badge::Badge;
pub use button::{Button, ButtonSize, ButtonVariant};
pub use command::{
    Command, CommandEntry, CommandEvent, CommandGroup, CommandItem, CommandRow,
    CommandSearchHandler, CommandState,
};
pub use gpui_kit;
pub use gpui_kit::base::input::{InputEvent, InputState, TextareaState};
pub use icon::{Icon, IconSource};
pub use input::{Field, Input, Textarea};
pub use label::Label;
pub use menu::{
    ContextMenu, DropdownMenu, MenuAnchor, MenuBar, MenuBarMenu, MenuBarState, MenuEntry,
    MenuEvent, MenuItem, MenuRowState, MenuState, MenuSubmenu,
};
pub use nav::{
    NavButtons, NavMotion, NavOperation, NavPage, NavStack, NavStackEvent, NavStackExt,
    NavStackState,
};
pub use popover::Popover;
pub use progress::Progress;
pub use scroll_area::ScrollArea;
pub use select::{
    SearchHandler, Select, SelectEntry, SelectEvent, SelectItem, SelectRow, SelectState,
    SelectValue,
};
pub use sidebar::{
    Sidebar, SidebarCollapsible, SidebarEvent, SidebarGroup, SidebarLayout, SidebarMenuButton,
    SidebarMenuSize, SidebarMenuSkeleton, SidebarMenuSub, SidebarSeparator, SidebarSide,
    SidebarState, SidebarTrigger,
};
pub use skeleton::Skeleton;
pub use spinner::Spinner;
pub use switch::Switch;
pub use tabs::{Tab, Tabs, TabsEvent, TabsState};
pub use tag::{Tag, TagVariant};
pub use theme::{
    ActiveTheme, MetricTokens, ReduceMotion, Theme, ThemeConfig, ThemeMode, ThemeTokens,
};
pub use theme_mode_picker::ThemeModePicker;
pub use title_bar::TitleBar;
pub use tooltip::{Tooltip, TooltipExt, TooltipTrigger};
pub use tooltip_host::TooltipHost;

use gpui_kit::{App, Global};

/// Everything an application normally imports from gpui-cn.
pub mod prelude {
    pub use crate::{
        ActiveTheme, Avatar, AvatarGroup, AvatarSize, Badge, Button, ButtonSize, ButtonVariant,
        Command, CommandEntry, CommandGroup, CommandItem, CommandState, ContextMenu, DropdownMenu,
        Field, Icon, Input, InputState, Label, MenuBar, MenuBarMenu, MenuBarState, MenuEntry,
        MenuItem, MenuState, MenuSubmenu, NavButtons, NavMotion, NavStack, NavStackExt,
        NavStackState, Popover, Progress, ReduceMotion, ScrollArea, Select, SelectEntry,
        SelectItem, SelectState, Sidebar, SidebarCollapsible, SidebarGroup, SidebarLayout,
        SidebarMenuButton, SidebarMenuSub, SidebarSeparator, SidebarSide, SidebarState,
        SidebarTrigger, Spinner, Switch, Tab, Tabs, TabsEvent, TabsState, Tag, TagVariant,
        Textarea, TextareaState, Theme, ThemeMode, ThemeModePicker, TitleBar, TooltipExt,
    };
    pub use gpui_kit::base::{Disableable, Placement, Selectable, StyledExt};
    pub use gpui_kit::prelude::FluentBuilder;
}

/// Marks that [`init`] ran, so a second call is a no-op.
struct Initialized;

impl Global for Initialized {}

/// Initializes gpui-cn. Call it once, after `gpui_base::init` (normally
/// through `gpui_kit::init`) and before opening windows.
///
/// Installs the built-in light and dark themes and projects them onto
/// `gpui_base::Theme`, as `gpui_component::init` does for its own theme.
/// With the `jetbrains-mono` feature it also registers JetBrains Mono
/// with the text system and makes it the code font. See
/// [`theme::fonts`].
/// Calling it twice changes nothing. In an application that also runs
/// `gpui_component::init`, the later of the two owns the base theme and
/// the other layer follows its colors.
///
/// # Panics
///
/// If `gpui_base::init` has not run. gpui-cn never initializes base itself:
/// the host owns that, as it does for every other layer on base.
pub fn init(cx: &mut App) {
    if cx.has_global::<Initialized>() {
        return;
    }
    assert!(
        base_initialized(cx),
        "gpui_cn::init needs gpui_base::init first; call gpui_kit::init(cx) before it"
    );
    theme::fonts::register(cx);
    Theme::init(cx);
    root::init(cx);
    select::init(cx);
    menu::init(cx);
    command::init(cx);
    cx.set_global(Initialized);
}

/// Whether `gpui_base::init` has run in this application.
///
/// `gpui_base::init` installs `GlobalState`, which nothing else creates, so
/// its presence is the signal.
fn base_initialized(cx: &App) -> bool {
    cx.has_global::<gpui_kit::base::GlobalState>()
}

#[cfg(test)]
mod tests {
    use gpui_kit::TestAppContext;

    #[gpui_kit::test]
    fn init_is_idempotent_and_skips_base_when_already_initialized(cx: &mut TestAppContext) {
        cx.update(|cx| {
            assert!(!super::base_initialized(cx));
            gpui_kit::init(cx);
            assert!(super::base_initialized(cx));
            super::init(cx);
            super::init(cx);
            assert!(cx.has_global::<super::Initialized>());
        });
    }

    #[gpui_kit::test]
    #[should_panic(expected = "needs gpui_base::init first")]
    fn init_refuses_to_run_before_base(cx: &mut TestAppContext) {
        cx.update(super::init);
    }
}