Skip to main content

fc_ui/capabilities/data/
timeline.rs

1use crate::capabilities::foundation::theme::use_theme;
2use crate::capabilities::primitives::icon::Icon;
3use crate::capabilities::primitives::icon_source::IconSource;
4use gpui::{prelude::FluentBuilder as _, *};
5
6#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
7pub enum TimelineItemVariant {
8    #[default]
9    Default,
10    Success,
11    Warning,
12    Error,
13    Info,
14}
15
16impl TimelineItemVariant {
17    fn default_icon(&self) -> &'static str {
18        match self {
19            TimelineItemVariant::Default => "circle",
20            TimelineItemVariant::Success => "circle-check",
21            TimelineItemVariant::Warning => "triangle-alert",
22            TimelineItemVariant::Error => "circle-alert",
23            TimelineItemVariant::Info => "info",
24        }
25    }
26}
27
28#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
29pub enum TimelineOrientation {
30    #[default]
31    Vertical,
32    Horizontal,
33}
34
35#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
36pub enum TimelineSize {
37    Sm,
38    #[default]
39    Md,
40    Lg,
41}
42
43#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
44pub enum TimelineLayout {
45    #[default]
46    Left,
47    Right,
48    Center,
49}
50
51#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
52pub enum TimelineConnectorStyle {
53    #[default]
54    Solid,
55    Dashed,
56    None,
57}
58
59#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
60pub enum TimelineIndicatorStyle {
61    #[default]
62    Dot,
63    Icon,
64    Number,
65}
66
67#[derive(Copy, Clone, Debug, PartialEq, Eq)]
68pub enum TimelineItemPosition {
69    Left,
70    Right,
71}
72
73impl TimelineSize {
74    fn icon_size(&self) -> Pixels {
75        match self {
76            TimelineSize::Sm => px(14.0),
77            TimelineSize::Md => px(18.0),
78            TimelineSize::Lg => px(22.0),
79        }
80    }
81
82    fn dot_size(&self) -> Pixels {
83        match self {
84            TimelineSize::Sm => px(10.0),
85            TimelineSize::Md => px(14.0),
86            TimelineSize::Lg => px(18.0),
87        }
88    }
89
90    fn number_size(&self) -> Pixels {
91        match self {
92            TimelineSize::Sm => px(20.0),
93            TimelineSize::Md => px(26.0),
94            TimelineSize::Lg => px(32.0),
95        }
96    }
97
98    fn connector_width(&self) -> Pixels {
99        match self {
100            TimelineSize::Sm => px(2.0),
101            TimelineSize::Md => px(2.0),
102            TimelineSize::Lg => px(3.0),
103        }
104    }
105
106    fn title_size(&self) -> f32 {
107        match self {
108            TimelineSize::Sm => 13.0,
109            TimelineSize::Md => 14.0,
110            TimelineSize::Lg => 16.0,
111        }
112    }
113
114    fn description_size(&self) -> f32 {
115        match self {
116            TimelineSize::Sm => 12.0,
117            TimelineSize::Md => 13.0,
118            TimelineSize::Lg => 14.0,
119        }
120    }
121
122    fn spacing(&self) -> Pixels {
123        match self {
124            TimelineSize::Sm => px(12.0),
125            TimelineSize::Md => px(16.0),
126            TimelineSize::Lg => px(20.0),
127        }
128    }
129
130    fn item_gap(&self) -> Pixels {
131        match self {
132            TimelineSize::Sm => px(20.0),
133            TimelineSize::Md => px(28.0),
134            TimelineSize::Lg => px(36.0),
135        }
136    }
137}
138
139#[derive(Clone)]
140pub struct TimelineItem {
141    pub title: SharedString,
142    pub description: Option<SharedString>,
143    pub timestamp: Option<SharedString>,
144    pub icon: Option<IconSource>,
145    pub variant: TimelineItemVariant,
146    pub position: Option<TimelineItemPosition>,
147}
148
149impl TimelineItem {
150    pub fn new(title: impl Into<SharedString>) -> Self {
151        Self {
152            title: title.into(),
153            description: None,
154            timestamp: None,
155            icon: None,
156            variant: TimelineItemVariant::default(),
157            position: None,
158        }
159    }
160
161    pub fn description(mut self, desc: impl Into<SharedString>) -> Self {
162        self.description = Some(desc.into());
163        self
164    }
165
166    pub fn timestamp(mut self, ts: impl Into<SharedString>) -> Self {
167        self.timestamp = Some(ts.into());
168        self
169    }
170
171    pub fn icon(mut self, icon: impl Into<IconSource>) -> Self {
172        self.icon = Some(icon.into());
173        self
174    }
175
176    pub fn variant(mut self, variant: TimelineItemVariant) -> Self {
177        self.variant = variant;
178        self
179    }
180
181    pub fn success(mut self) -> Self {
182        self.variant = TimelineItemVariant::Success;
183        self
184    }
185
186    pub fn warning(mut self) -> Self {
187        self.variant = TimelineItemVariant::Warning;
188        self
189    }
190
191    pub fn error(mut self) -> Self {
192        self.variant = TimelineItemVariant::Error;
193        self
194    }
195
196    pub fn info(mut self) -> Self {
197        self.variant = TimelineItemVariant::Info;
198        self
199    }
200
201    pub fn position(mut self, position: TimelineItemPosition) -> Self {
202        self.position = Some(position);
203        self
204    }
205
206    pub fn left(mut self) -> Self {
207        self.position = Some(TimelineItemPosition::Left);
208        self
209    }
210
211    pub fn right(mut self) -> Self {
212        self.position = Some(TimelineItemPosition::Right);
213        self
214    }
215
216    fn get_color(&self, theme: &crate::capabilities::foundation::theme::Theme) -> Hsla {
217        match self.variant {
218            TimelineItemVariant::Default => theme.tokens.muted_foreground,
219            TimelineItemVariant::Success => rgb(0x22c55e).into(),
220            TimelineItemVariant::Warning => rgb(0xf59e0b).into(),
221            TimelineItemVariant::Error => theme.tokens.destructive,
222            TimelineItemVariant::Info => theme.tokens.primary,
223        }
224    }
225}
226
227#[derive(IntoElement)]
228pub struct Timeline {
229    items: Vec<TimelineItem>,
230    orientation: TimelineOrientation,
231    size: TimelineSize,
232    layout: TimelineLayout,
233    alternating: bool,
234    indicator_style: TimelineIndicatorStyle,
235    connector_style: TimelineConnectorStyle,
236    connector_color: Option<Hsla>,
237    content_width: Option<Pixels>,
238    style: StyleRefinement,
239}
240
241impl Timeline {
242    pub fn new(items: Vec<TimelineItem>) -> Self {
243        Self {
244            items,
245            orientation: TimelineOrientation::default(),
246            size: TimelineSize::default(),
247            layout: TimelineLayout::default(),
248            alternating: false,
249            indicator_style: TimelineIndicatorStyle::default(),
250            connector_style: TimelineConnectorStyle::default(),
251            connector_color: None,
252            content_width: None,
253            style: StyleRefinement::default(),
254        }
255    }
256
257    pub fn vertical(items: Vec<TimelineItem>) -> Self {
258        Self::new(items).orientation(TimelineOrientation::Vertical)
259    }
260
261    pub fn horizontal(items: Vec<TimelineItem>) -> Self {
262        Self::new(items).orientation(TimelineOrientation::Horizontal)
263    }
264
265    pub fn orientation(mut self, orientation: TimelineOrientation) -> Self {
266        self.orientation = orientation;
267        self
268    }
269
270    pub fn size(mut self, size: TimelineSize) -> Self {
271        self.size = size;
272        self
273    }
274
275    pub fn sm(mut self) -> Self {
276        self.size = TimelineSize::Sm;
277        self
278    }
279
280    pub fn md(mut self) -> Self {
281        self.size = TimelineSize::Md;
282        self
283    }
284
285    pub fn lg(mut self) -> Self {
286        self.size = TimelineSize::Lg;
287        self
288    }
289
290    pub fn layout(mut self, layout: TimelineLayout) -> Self {
291        self.layout = layout;
292        self
293    }
294
295    pub fn left_layout(mut self) -> Self {
296        self.layout = TimelineLayout::Left;
297        self
298    }
299
300    pub fn right_layout(mut self) -> Self {
301        self.layout = TimelineLayout::Right;
302        self
303    }
304
305    pub fn center_layout(mut self) -> Self {
306        self.layout = TimelineLayout::Center;
307        self
308    }
309
310    pub fn alternating(mut self, alternating: bool) -> Self {
311        self.alternating = alternating;
312        if alternating {
313            self.layout = TimelineLayout::Center;
314        }
315        self
316    }
317
318    pub fn indicator_style(mut self, style: TimelineIndicatorStyle) -> Self {
319        self.indicator_style = style;
320        self
321    }
322
323    pub fn dot_indicators(mut self) -> Self {
324        self.indicator_style = TimelineIndicatorStyle::Dot;
325        self
326    }
327
328    pub fn icon_indicators(mut self) -> Self {
329        self.indicator_style = TimelineIndicatorStyle::Icon;
330        self
331    }
332
333    pub fn number_indicators(mut self) -> Self {
334        self.indicator_style = TimelineIndicatorStyle::Number;
335        self
336    }
337
338    pub fn connector_style(mut self, style: TimelineConnectorStyle) -> Self {
339        self.connector_style = style;
340        self
341    }
342
343    pub fn solid_connector(mut self) -> Self {
344        self.connector_style = TimelineConnectorStyle::Solid;
345        self
346    }
347
348    pub fn dashed_connector(mut self) -> Self {
349        self.connector_style = TimelineConnectorStyle::Dashed;
350        self
351    }
352
353    pub fn no_connector(mut self) -> Self {
354        self.connector_style = TimelineConnectorStyle::None;
355        self
356    }
357
358    pub fn connector_color(mut self, color: Hsla) -> Self {
359        self.connector_color = Some(color);
360        self
361    }
362
363    pub fn content_width(mut self, width: Pixels) -> Self {
364        self.content_width = Some(width);
365        self
366    }
367
368    #[deprecated(note = "Use indicator_style(TimelineIndicatorStyle::Icon) instead")]
369    pub fn show_icons(mut self, show: bool) -> Self {
370        if show {
371            self.indicator_style = TimelineIndicatorStyle::Icon;
372        }
373        self
374    }
375}
376
377impl Timeline {
378    fn render_indicator(
379        &self,
380        item: &TimelineItem,
381        index: usize,
382        theme: &crate::capabilities::foundation::theme::Theme,
383    ) -> AnyElement {
384        let item_color = item.get_color(theme);
385        let size = self.size;
386
387        match self.indicator_style {
388            TimelineIndicatorStyle::Dot => div()
389                .size(size.dot_size())
390                .rounded_full()
391                .bg(item_color)
392                .flex_shrink_0()
393                .into_any_element(),
394
395            TimelineIndicatorStyle::Icon => {
396                let icon_source = item
397                    .icon
398                    .clone()
399                    .unwrap_or_else(|| IconSource::Named(item.variant.default_icon().into()));
400                div()
401                    .flex()
402                    .items_center()
403                    .justify_center()
404                    .size(size.icon_size() + px(10.0))
405                    .rounded_full()
406                    .bg(item_color.opacity(0.15))
407                    .border_2()
408                    .border_color(item_color)
409                    .flex_shrink_0()
410                    .child(
411                        Icon::new(icon_source)
412                            .size(size.icon_size())
413                            .color(item_color),
414                    )
415                    .into_any_element()
416            }
417
418            TimelineIndicatorStyle::Number => div()
419                .flex()
420                .items_center()
421                .justify_center()
422                .size(size.number_size())
423                .rounded_full()
424                .bg(item_color)
425                .flex_shrink_0()
426                .text_size(px(size.title_size() - 2.0))
427                .font_weight(FontWeight::SEMIBOLD)
428                .text_color(theme.tokens.background)
429                .child(format!("{}", index + 1))
430                .into_any_element(),
431        }
432    }
433
434    fn render_connector(
435        &self,
436        theme: &crate::capabilities::foundation::theme::Theme,
437        length: Pixels,
438    ) -> Option<AnyElement> {
439        if self.connector_style == TimelineConnectorStyle::None {
440            return None;
441        }
442
443        let color = self.connector_color.unwrap_or(theme.tokens.border);
444        let width = self.size.connector_width();
445
446        let connector = match self.connector_style {
447            TimelineConnectorStyle::Solid => div().w(width).h(length).bg(color).into_any_element(),
448            TimelineConnectorStyle::Dashed => {
449                let num_dashes = ((length / px(8.0)) as usize).max(1);
450                div()
451                    .w(width)
452                    .h(length)
453                    .flex()
454                    .flex_col()
455                    .gap(px(4.0))
456                    .overflow_hidden()
457                    .children(
458                        (0..num_dashes)
459                            .map(|_| div().w(width).h(px(4.0)).bg(color).into_any_element()),
460                    )
461                    .into_any_element()
462            }
463            TimelineConnectorStyle::None => return None,
464        };
465
466        Some(connector)
467    }
468
469    fn render_content(
470        &self,
471        item: &TimelineItem,
472        theme: &crate::capabilities::foundation::theme::Theme,
473        align_right: bool,
474    ) -> AnyElement {
475        let size = self.size;
476
477        div()
478            .flex()
479            .flex_col()
480            .gap(px(4.0))
481            .when(align_right, |d| d.items_end())
482            .when_some(self.content_width, |d, w| d.w(w))
483            .child(
484                div()
485                    .flex()
486                    .flex_col()
487                    .gap(px(2.0))
488                    .when(align_right, |d| d.items_end())
489                    .child(
490                        div()
491                            .text_size(px(size.title_size()))
492                            .font_weight(FontWeight::MEDIUM)
493                            .text_color(theme.tokens.foreground)
494                            .when(align_right, |d| d.text_align(TextAlign::Right))
495                            .child(item.title.clone()),
496                    )
497                    .when_some(item.timestamp.clone(), |d, ts| {
498                        d.child(
499                            div()
500                                .text_size(px(size.description_size() - 1.0))
501                                .text_color(theme.tokens.muted_foreground)
502                                .when(align_right, |d| d.text_align(TextAlign::Right))
503                                .child(ts),
504                        )
505                    }),
506            )
507            .when_some(item.description.clone(), |d, desc| {
508                d.child(
509                    div()
510                        .text_size(px(size.description_size()))
511                        .text_color(theme.tokens.muted_foreground)
512                        .when(align_right, |d| d.text_align(TextAlign::Right))
513                        .child(desc),
514                )
515            })
516            .into_any_element()
517    }
518
519    fn render_vertical_left_item(
520        &self,
521        item: &TimelineItem,
522        index: usize,
523        is_last: bool,
524        theme: &crate::capabilities::foundation::theme::Theme,
525    ) -> AnyElement {
526        let indicator = self.render_indicator(item, index, theme);
527        let connector = if !is_last {
528            self.render_connector(theme, self.size.item_gap())
529        } else {
530            None
531        };
532        let content = self.render_content(item, theme, false);
533
534        div()
535            .flex()
536            .gap(self.size.spacing())
537            .child(
538                div()
539                    .flex()
540                    .flex_col()
541                    .items_center()
542                    .child(indicator)
543                    .when_some(connector, |d, c| d.child(c)),
544            )
545            .child(
546                div()
547                    .flex_1()
548                    .pb(if is_last {
549                        px(0.0)
550                    } else {
551                        self.size.item_gap()
552                    })
553                    .child(content),
554            )
555            .into_any_element()
556    }
557
558    fn render_vertical_right_item(
559        &self,
560        item: &TimelineItem,
561        index: usize,
562        is_last: bool,
563        theme: &crate::capabilities::foundation::theme::Theme,
564    ) -> AnyElement {
565        let indicator = self.render_indicator(item, index, theme);
566        let connector = if !is_last {
567            self.render_connector(theme, self.size.item_gap())
568        } else {
569            None
570        };
571        let content = self.render_content(item, theme, true);
572
573        div()
574            .flex()
575            .flex_row_reverse()
576            .gap(self.size.spacing())
577            .child(
578                div()
579                    .flex()
580                    .flex_col()
581                    .items_center()
582                    .child(indicator)
583                    .when_some(connector, |d, c| d.child(c)),
584            )
585            .child(
586                div()
587                    .flex_1()
588                    .pb(if is_last {
589                        px(0.0)
590                    } else {
591                        self.size.item_gap()
592                    })
593                    .child(content),
594            )
595            .into_any_element()
596    }
597
598    fn render_vertical_center_item(
599        &self,
600        item: &TimelineItem,
601        index: usize,
602        is_last: bool,
603        theme: &crate::capabilities::foundation::theme::Theme,
604        on_left: bool,
605    ) -> AnyElement {
606        let indicator = self.render_indicator(item, index, theme);
607        let connector = if !is_last {
608            self.render_connector(theme, self.size.item_gap())
609        } else {
610            None
611        };
612        let left_content = if on_left {
613            Some(self.render_content(item, theme, true))
614        } else {
615            None
616        };
617
618        let right_content = if on_left {
619            None
620        } else {
621            Some(self.render_content(item, theme, false))
622        };
623
624        div()
625            .flex()
626            .w_full()
627            .child(
628                div()
629                    .flex_1()
630                    .flex()
631                    .justify_end()
632                    .pr(self.size.spacing())
633                    .when_some(left_content, |d, c| d.child(c)),
634            )
635            .child(
636                div()
637                    .flex()
638                    .flex_col()
639                    .items_center()
640                    .child(indicator)
641                    .when_some(connector, |d, c| d.child(c)),
642            )
643            .child(
644                div()
645                    .flex_1()
646                    .pl(self.size.spacing())
647                    .pb(if is_last {
648                        px(0.0)
649                    } else {
650                        self.size.item_gap()
651                    })
652                    .when_some(right_content, |d, c| d.child(c)),
653            )
654            .into_any_element()
655    }
656
657    fn render_horizontal_item(
658        &self,
659        item: &TimelineItem,
660        index: usize,
661        is_last: bool,
662        theme: &crate::capabilities::foundation::theme::Theme,
663    ) -> AnyElement {
664        let indicator = self.render_indicator(item, index, theme);
665        let content = div()
666            .flex()
667            .flex_col()
668            .items_center()
669            .gap(px(4.0))
670            .max_w(px(120.0))
671            .child(
672                div()
673                    .text_size(px(self.size.title_size()))
674                    .font_weight(FontWeight::MEDIUM)
675                    .text_color(theme.tokens.foreground)
676                    .text_center()
677                    .child(item.title.clone()),
678            )
679            .when_some(item.timestamp.clone(), |d, ts| {
680                d.child(
681                    div()
682                        .text_size(px(self.size.description_size() - 1.0))
683                        .text_color(theme.tokens.muted_foreground)
684                        .text_center()
685                        .child(ts),
686                )
687            })
688            .when_some(item.description.clone(), |d, desc| {
689                d.child(
690                    div()
691                        .text_size(px(self.size.description_size()))
692                        .text_color(theme.tokens.muted_foreground)
693                        .text_center()
694                        .child(desc),
695                )
696            });
697
698        let connector = if !is_last {
699            self.render_connector(theme, self.size.item_gap()).map(|_| {
700                div()
701                    .h(self.size.connector_width())
702                    .w(self.size.item_gap())
703                    .bg(self.connector_color.unwrap_or(theme.tokens.border))
704                    .into_any_element()
705            })
706        } else {
707            None
708        };
709
710        div()
711            .flex()
712            .flex_col()
713            .items_center()
714            .gap(self.size.spacing())
715            .child(content)
716            .child(
717                div()
718                    .flex()
719                    .items_center()
720                    .child(indicator)
721                    .when_some(connector, |d, c| d.child(c)),
722            )
723            .into_any_element()
724    }
725}
726
727impl Styled for Timeline {
728    fn style(&mut self) -> &mut StyleRefinement {
729        &mut self.style
730    }
731}
732
733impl RenderOnce for Timeline {
734    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
735        let theme = use_theme(cx);
736        let items = self.items.clone();
737        let items_len = items.len();
738        let user_style = self.style.clone();
739
740        let container = match self.orientation {
741            TimelineOrientation::Vertical => div().flex().flex_col().w_full(),
742            TimelineOrientation::Horizontal => div().flex().flex_row().items_start(),
743        };
744
745        container
746            .children(items.iter().enumerate().map(|(i, item)| {
747                let is_last = i == items_len - 1;
748
749                match self.orientation {
750                    TimelineOrientation::Vertical => {
751                        let item_position = item.position.unwrap_or({
752                            if self.alternating {
753                                if i % 2 == 0 {
754                                    TimelineItemPosition::Left
755                                } else {
756                                    TimelineItemPosition::Right
757                                }
758                            } else {
759                                TimelineItemPosition::Left
760                            }
761                        });
762
763                        match self.layout {
764                            TimelineLayout::Left => {
765                                self.render_vertical_left_item(item, i, is_last, &theme)
766                            }
767                            TimelineLayout::Right => {
768                                self.render_vertical_right_item(item, i, is_last, &theme)
769                            }
770                            TimelineLayout::Center => {
771                                let on_left = item_position == TimelineItemPosition::Left;
772                                self.render_vertical_center_item(item, i, is_last, &theme, on_left)
773                            }
774                        }
775                    }
776                    TimelineOrientation::Horizontal => {
777                        self.render_horizontal_item(item, i, is_last, &theme)
778                    }
779                }
780            }))
781            .map(|this| {
782                let mut div = this;
783                div.style().refine(&user_style);
784                div
785            })
786    }
787}
788
789pub fn timeline(items: Vec<TimelineItem>) -> Timeline {
790    Timeline::new(items)
791}