fc-ui 0.9.7

A comprehensive, professional UI component library for GPUI inspired by shadcn/ui. 85+ polished components for building beautiful desktop applications.
Documentation
use crate::capabilities::data::palette::default_color;
use crate::capabilities::data::pie_chart::PieChartSegment;
use crate::capabilities::foundation::theme::Theme;
use gpui::{div, hsla, prelude::FluentBuilder as _, px, Div, Hsla, ParentElement, Styled};

const START_ANGLE: f32 = -std::f32::consts::FRAC_PI_2;

#[derive(Clone, Copy)]
pub(crate) struct SegmentGeometry {
    pub(crate) start_angle: f32,
    pub(crate) sweep_angle: f32,
    pub(crate) color: Hsla,
}

pub(crate) fn positive_finite_total(segments: &[PieChartSegment]) -> f64 {
    segments
        .iter()
        .map(|segment| segment.value)
        .filter(|value| value.is_finite() && *value > 0.0)
        .sum()
}

pub(crate) fn segment_geometry(segments: &[PieChartSegment], total: f64) -> Vec<SegmentGeometry> {
    if !total.is_finite() || total <= 0.0 {
        return Vec::new();
    }

    let mut current_angle = START_ANGLE;
    let mut geometry = Vec::new();

    for (index, segment) in segments.iter().enumerate() {
        if !segment.value.is_finite() || segment.value <= 0.0 {
            continue;
        }

        let sweep_angle = (segment.value / total) as f32 * std::f32::consts::TAU;
        let color = segment.color.unwrap_or_else(|| default_color(index));
        geometry.push(SegmentGeometry {
            start_angle: current_angle,
            sweep_angle,
            color,
        });
        current_angle += sweep_angle;
    }

    geometry
}

pub(crate) fn color_at_angle(angle: f32, geometry: &[SegmentGeometry]) -> Hsla {
    let normalized_angle = if angle < START_ANGLE {
        angle + std::f32::consts::TAU
    } else {
        angle
    };

    for segment in geometry {
        let end_angle = segment.start_angle + segment.sweep_angle;
        if normalized_angle >= segment.start_angle && normalized_angle < end_angle {
            return segment.color;
        }
    }

    geometry
        .last()
        .map(|segment| segment.color)
        .unwrap_or(hsla(0.0, 0.0, 0.5, 1.0))
}

pub(crate) fn render_legend(
    segments: &[PieChartSegment],
    total: f64,
    show_percentages: bool,
    theme: &Theme,
) -> Div {
    let visible_count = segments
        .iter()
        .filter(|s| s.value.is_finite() && s.value > 0.0)
        .count();
    let mut displayed_total = 0u32;
    let mut visible_index = 0usize;

    div()
        .flex()
        .flex_col()
        .gap(px(8.0))
        .children(segments.iter().enumerate().filter_map(|(index, segment)| {
            if !segment.value.is_finite() || segment.value <= 0.0 {
                return None;
            }

            visible_index += 1;
            let color = segment.color.unwrap_or_else(|| default_color(index));
            let percentage = if total > 0.0 {
                if visible_index == visible_count {
                    100u32.saturating_sub(displayed_total)
                } else {
                    let pct = (segment.value / total * 100.0) as u32;
                    displayed_total += pct;
                    pct
                }
            } else {
                0
            };

            Some(
                div()
                    .flex()
                    .items_center()
                    .gap(px(8.0))
                    .child(div().size(px(12.0)).rounded(px(2.0)).bg(color))
                    .child(
                        div()
                            .flex()
                            .flex_1()
                            .items_center()
                            .justify_between()
                            .gap(px(12.0))
                            .child(
                                div()
                                    .text_sm()
                                    .text_color(theme.tokens.foreground)
                                    .child(segment.label.clone()),
                            )
                            .when(show_percentages, |this| {
                                this.child(
                                    div()
                                        .text_sm()
                                        .text_color(theme.tokens.muted_foreground)
                                        .child(format!("{}%", percentage)),
                                )
                            }),
                    ),
            )
        }))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn segment(label: &str, value: f64) -> PieChartSegment {
        PieChartSegment {
            label: label.into(),
            value,
            color: None,
        }
    }

    #[test]
    fn geometry_uses_only_positive_finite_segments() {
        let segments = vec![
            segment("first", 2.0),
            segment("invalid", f64::NAN),
            segment("zero", 0.0),
            segment("second", 1.0),
        ];
        let total = positive_finite_total(&segments);
        let geometry = segment_geometry(&segments, total);

        assert_eq!(total, 3.0);
        assert_eq!(geometry.len(), 2);
        assert_eq!(geometry[0].start_angle, START_ANGLE);
        assert!((geometry[0].sweep_angle - std::f32::consts::TAU * 2.0 / 3.0).abs() < f32::EPSILON);
        assert!(
            (geometry[1].start_angle - (START_ANGLE + geometry[0].sweep_angle)).abs()
                < f32::EPSILON
        );
    }

    #[test]
    fn color_lookup_wraps_and_uses_the_last_segment_as_a_boundary_fallback() {
        let geometry = segment_geometry(&[segment("first", 1.0), segment("second", 1.0)], 2.0);

        assert_eq!(
            color_at_angle(START_ANGLE + std::f32::consts::TAU + 0.1, &geometry),
            geometry[1].color
        );
        assert_eq!(
            color_at_angle(START_ANGLE - 0.1, &geometry),
            geometry[1].color
        );
    }
}