gpui-ai 0.8.0

AI-native UI components for GPUI applications, built on gpui-component.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use gpui::{
    Element as _, IntoElement as _, Render, RenderOnce as _, Role, TestAppContext, Window,
    accesskit, canvas,
};
use gpui_ai::{image_generation::ImageGeneration, loading::LoadingState};
use std::sync::{Arc, Mutex};

struct CapturedNode {
    has_id: bool,
    role: Option<Role>,
    node: accesskit::Node,
}

#[derive(Clone, Copy)]
enum ProgressProbeKind {
    Loading,
    Image,
}

struct ProgressProbe {
    kind: ProgressProbeKind,
    captured: Arc<Mutex<Option<CapturedNode>>>,
}

impl Render for ProgressProbe {
    fn render(&mut self, _: &mut Window, _: &mut gpui::Context<Self>) -> impl gpui::IntoElement {
        let kind = self.kind;
        let captured = self.captured.clone();
        canvas(
            move |_, window, cx| {
                let mut node = accesskit::Node::new(Role::ProgressIndicator);
                let (has_id, role) = match kind {
                    ProgressProbeKind::Loading => {
                        let element = LoadingState::new()
                            .label("Reasoning about suppliers")
                            .render(window, cx)
                            .into_element();
                        let has_id = element.id().is_some();
                        let role = element.a11y_role();
                        element.write_a11y_info(&mut node);
                        (has_id, role)
                    }
                    ProgressProbeKind::Image => {
                        let element = ImageGeneration::new("image")
                            .label("Alpine meadow")
                            .progress(0.42)
                            .render(window, cx)
                            .into_element();
                        let has_id = element.id().is_some();
                        let role = element.a11y_role();
                        element.write_a11y_info(&mut node);
                        (has_id, role)
                    }
                };
                *captured.lock().expect("capture mutex should be available") =
                    Some(CapturedNode { has_id, role, node });
            },
            |_, _, _, _| {},
        )
    }
}

fn capture(kind: ProgressProbeKind, cx: &mut TestAppContext) -> CapturedNode {
    cx.update(gpui_ai::init);
    let captured = Arc::new(Mutex::new(None));
    let result = captured.clone();
    let (_, cx) = cx.add_window_view(move |_, _| ProgressProbe { kind, captured });
    cx.update(|window, cx| window.draw(cx).clear(cx));
    result
        .lock()
        .expect("capture mutex should be available")
        .take()
        .expect("progress node should be captured")
}

#[gpui::test]
fn loading_state_is_a_named_indeterminate_progress_indicator(cx: &mut TestAppContext) {
    let captured = capture(ProgressProbeKind::Loading, cx);

    assert!(captured.has_id);
    assert_eq!(captured.role, Some(Role::ProgressIndicator));
    assert_eq!(captured.node.label(), Some("Reasoning about suppliers"));
    assert_eq!(captured.node.numeric_value(), None);
}

#[gpui::test]
fn image_generation_exposes_its_percentage(cx: &mut TestAppContext) {
    let captured = capture(ProgressProbeKind::Image, cx);

    assert!(captured.has_id);
    assert_eq!(captured.role, Some(Role::ProgressIndicator));
    assert_eq!(captured.node.label(), Some("Alpine meadow"));
    assert_eq!(captured.node.numeric_value(), Some(42.0));
    assert_eq!(captured.node.min_numeric_value(), Some(0.0));
    assert_eq!(captured.node.max_numeric_value(), Some(100.0));
}