← back to joeleaver__rinch

Function bodies 1,000 total

All specs Real LLM only Function bodies
fmt function · rust · L111-L122 (12 LOC)
crates/rinch-components/src/slider.rs
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Slider")
            .field("min", &self.min)
            .field("max", &self.max)
            .field("value", &self.value)
            .field(
                "value_signal",
                &self.value_signal.as_ref().map(|_| "Signal<f64>"),
            )
            .field("disabled", &self.disabled)
            .finish_non_exhaustive()
    }
class_string function · rust · L126-L157 (32 LOC)
crates/rinch-components/src/slider.rs
    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-slider"];

        let size: SliderSize = if self.size.is_empty() {
            SliderSize::default()
        } else {
            self.size.parse().unwrap_or_default()
        };
        classes.push(size.class_name());

        if !self.radius.is_empty() {
            let r = &self.radius;
            classes.push(match r.as_str() {
                "xs" => "rinch-slider--radius-xs",
                "sm" => "rinch-slider--radius-sm",
                "md" => "rinch-slider--radius-md",
                "lg" => "rinch-slider--radius-lg",
                "xl" => "rinch-slider--radius-xl",
                _ => "",
            });
        }

        if self.disabled {
            classes.push("rinch-slider--disabled");
        }

        if self.label_always_on {
            classes.push("rinch-slider--label-always-on");
        }

        classes.join(" ")
    }
render function · rust · L161-L304 (144 LOC)
crates/rinch-components/src/slider.rs
    fn render(&self, scope: &mut RenderScope, _children: &[NodeHandle]) -> NodeHandle {
        let class = self.class_string();

        let min = self.min.unwrap_or(0.0);
        let max = self.max.unwrap_or(100.0);
        let step = self.step;

        // Get initial value from signal if provided, otherwise from value prop
        let value = if let Some(ref sig) = self.value_signal {
            sig.get()
        } else {
            self.value.unwrap_or(min)
        };

        // Calculate percentage for styling
        let percentage = if max > min {
            ((value - min) / (max - min)) * 100.0
        } else {
            0.0
        };

        let mut style_parts = Vec::new();

        if !self.color.is_empty() {
            let c = &self.color;
            if c.starts_with('#') || c.starts_with("rgb") || c.starts_with("hsl") {
                style_parts.push(format!("--rinch-slider-color: {}", c));
            } else {
                style_parts.push(format!("--rinch
class_string function · rust · L19-L47 (29 LOC)
crates/rinch-components/src/space.rs
    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-space"];

        // Width
        if !self.w.is_empty() {
            match self.w.as_str() {
                "xs" => classes.push("rinch-space--w-xs"),
                "sm" => classes.push("rinch-space--w-sm"),
                "md" => classes.push("rinch-space--w-md"),
                "lg" => classes.push("rinch-space--w-lg"),
                "xl" => classes.push("rinch-space--w-xl"),
                _ => {}
            }
        }

        // Height
        if !self.h.is_empty() {
            match self.h.as_str() {
                "xs" => classes.push("rinch-space--h-xs"),
                "sm" => classes.push("rinch-space--h-sm"),
                "md" => classes.push("rinch-space--h-md"),
                "lg" => classes.push("rinch-space--h-lg"),
                "xl" => classes.push("rinch-space--h-xl"),
                _ => {}
            }
        }

        classes.join(" ")
    }
render function · rust · L51-L57 (7 LOC)
crates/rinch-components/src/space.rs
    fn render(&self, __scope: &mut RenderScope, _children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! {
            div { class: "rinch-space" }
        };
        container.set_attribute("class", &self.class_string());
        container
    }
class_name function · rust · L21-L29 (9 LOC)
crates/rinch-components/src/stack.rs
    pub fn class_name(&self) -> &'static str {
        match self {
            StackGap::Xs => "rinch-stack--gap-xs",
            StackGap::Sm => "rinch-stack--gap-sm",
            StackGap::Md => "rinch-stack--gap-md",
            StackGap::Lg => "rinch-stack--gap-lg",
            StackGap::Xl => "rinch-stack--gap-xl",
        }
    }
from_str function · rust · L34-L44 (11 LOC)
crates/rinch-components/src/stack.rs
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "xs" => Ok(StackGap::Xs),
            "sm" => Ok(StackGap::Sm),
            "md" => Ok(StackGap::Md),
            "lg" => Ok(StackGap::Lg),
            "xl" => Ok(StackGap::Xl),
            _ => Err(()),
        }
    }
Repobility (the analyzer behind this table) · https://repobility.com
class_name function · rust · L59-L66 (8 LOC)
crates/rinch-components/src/stack.rs
    pub fn class_name(&self) -> &'static str {
        match self {
            StackAlign::Stretch => "rinch-stack--align-stretch",
            StackAlign::Start => "rinch-stack--align-start",
            StackAlign::Center => "rinch-stack--align-center",
            StackAlign::End => "rinch-stack--align-end",
        }
    }
from_str function · rust · L71-L80 (10 LOC)
crates/rinch-components/src/stack.rs
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "stretch" => Ok(StackAlign::Stretch),
            "start" | "flex-start" => Ok(StackAlign::Start),
            "center" => Ok(StackAlign::Center),
            "end" | "flex-end" => Ok(StackAlign::End),
            _ => Err(()),
        }
    }
class_name function · rust · L96-L104 (9 LOC)
crates/rinch-components/src/stack.rs
    pub fn class_name(&self) -> &'static str {
        match self {
            StackJustify::Start => "rinch-stack--justify-start",
            StackJustify::Center => "rinch-stack--justify-center",
            StackJustify::End => "rinch-stack--justify-end",
            StackJustify::Between => "rinch-stack--justify-between",
            StackJustify::Around => "rinch-stack--justify-around",
        }
    }
from_str function · rust · L109-L119 (11 LOC)
crates/rinch-components/src/stack.rs
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "start" | "flex-start" => Ok(StackJustify::Start),
            "center" => Ok(StackJustify::Center),
            "end" | "flex-end" => Ok(StackJustify::End),
            "between" | "space-between" => Ok(StackJustify::Between),
            "around" | "space-around" => Ok(StackJustify::Around),
            _ => Err(()),
        }
    }
class_string function · rust · L135-L161 (27 LOC)
crates/rinch-components/src/stack.rs
    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-stack"];

        // Gap class
        let gap: StackGap = if self.gap.is_empty() {
            StackGap::default()
        } else {
            self.gap.parse().unwrap_or_default()
        };
        classes.push(gap.class_name());

        // Alignment class
        if !self.align.is_empty() {
            if let Ok(a) = self.align.parse::<StackAlign>() {
                classes.push(a.class_name());
            }
        }

        // Justification class
        if !self.justify.is_empty() {
            if let Ok(j) = self.justify.parse::<StackJustify>() {
                classes.push(j.class_name());
            }
        }

        classes.join(" ")
    }
render function · rust · L165-L175 (11 LOC)
crates/rinch-components/src/stack.rs
    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! {
            div { class: "rinch-stack" }
        };
        // Set computed class after rsx! to avoid effect overhead
        container.set_attribute("class", &self.class_string());
        for child in children {
            container.append_child(child);
        }
        container
    }
class_name function · rust · L21-L29 (9 LOC)
crates/rinch-components/src/stepper.rs
    pub fn class_name(&self) -> &'static str {
        match self {
            StepperSize::Xs => "rinch-stepper--xs",
            StepperSize::Sm => "rinch-stepper--sm",
            StepperSize::Md => "rinch-stepper--md",
            StepperSize::Lg => "rinch-stepper--lg",
            StepperSize::Xl => "rinch-stepper--xl",
        }
    }
from_str function · rust · L34-L43 (10 LOC)
crates/rinch-components/src/stepper.rs
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "xs" => Ok(StepperSize::Xs),
            "sm" => Ok(StepperSize::Sm),
            "md" => Ok(StepperSize::Md),
            "lg" => Ok(StepperSize::Lg),
            "xl" => Ok(StepperSize::Xl),
            _ => Err(()),
        }
    }
Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/
class_name function · rust · L55-L60 (6 LOC)
crates/rinch-components/src/stepper.rs
    pub fn class_name(&self) -> &'static str {
        match self {
            StepperOrientation::Horizontal => "rinch-stepper--horizontal",
            StepperOrientation::Vertical => "rinch-stepper--vertical",
        }
    }
from_str function · rust · L65-L71 (7 LOC)
crates/rinch-components/src/stepper.rs
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "horizontal" => Ok(StepperOrientation::Horizontal),
            "vertical" => Ok(StepperOrientation::Vertical),
            _ => Err(()),
        }
    }
class_string function · rust · L110-L139 (30 LOC)
crates/rinch-components/src/stepper.rs
    pub fn class_string(&self) -> String {
        let mut classes = vec!["rinch-stepper"];

        if !self.size.is_empty()
            && let Ok(size) = self.size.parse::<StepperSize>()
        {
            classes.push(size.class_name());
        }

        if !self.orientation.is_empty() {
            if let Ok(orientation) = self.orientation.parse::<StepperOrientation>() {
                classes.push(orientation.class_name());
            }
        } else {
            classes.push(StepperOrientation::Horizontal.class_name());
        }

        if !self.radius.is_empty() {
            match self.radius.as_str() {
                "xs" => classes.push("rinch-stepper--radius-xs"),
                "sm" => classes.push("rinch-stepper--radius-sm"),
                "md" => classes.push("rinch-stepper--radius-md"),
                "lg" => classes.push("rinch-stepper--radius-lg"),
                "xl" => classes.push("rinch-stepper--radius-xl"),
                _ => {}
            }
render function · rust · L143-L174 (32 LOC)
crates/rinch-components/src/stepper.rs
    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let mut style_parts = Vec::new();
        if !self.color.is_empty() {
            let c = &self.color;
            if c.starts_with('#') || c.starts_with("rgb") || c.starts_with("hsl") {
                style_parts.push(format!("--rinch-stepper-color: {}", c));
            } else {
                style_parts.push(format!("--rinch-stepper-color: var(--rinch-color-{}-6)", c));
            }
        }
        if !self.icon_size.is_empty() {
            style_parts.push(format!("--rinch-stepper-icon-size: {}", self.icon_size));
        }

        let container = rinch_macros::rsx! { div { class: "rinch-stepper" } };
        container.set_attribute("class", &self.class_string());
        container.set_attribute("data-active", &self.active.to_string());

        if !style_parts.is_empty() {
            container.set_attribute("style", &style_parts.join("; "));
        }

        let steps_contai
render function · rust · L204-L304 (101 LOC)
crates/rinch-components/src/stepper.rs
    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        // State classes
        let state = if self.state.is_empty() {
            "inactive"
        } else {
            &self.state
        };
        let state_class = match state {
            "completed" => "rinch-stepper__step--completed",
            "progress" => "rinch-stepper__step--progress",
            _ => "rinch-stepper__step--inactive",
        };

        let loading_class = if self.loading {
            " rinch-stepper__step--loading"
        } else {
            ""
        };

        let clickable = if self.allow_step_click || self.allow_step_select {
            " rinch-stepper__step--clickable"
        } else {
            ""
        };

        let class = format!(
            "rinch-stepper__step {} {}{}",
            state_class, loading_class, clickable
        );

        let step_el = rinch_macros::rsx! { div { class: "rinch-stepper__step" } };
        step_el.set_attr
render function · rust · L312-L320 (9 LOC)
crates/rinch-components/src/stepper.rs
    fn render(&self, __scope: &mut RenderScope, children: &[NodeHandle]) -> NodeHandle {
        let container = rinch_macros::rsx! { div { class: "rinch-stepper__completed" } };

        for child in children {
            container.append_child(child);
        }

        container
    }
styles function · rust · L1-L149 (149 LOC)
crates/rinch-components/src/styles/accordion.rs
pub fn styles() -> String {
    r#"
/* Accordion base */
.rinch-accordion {
    display: flex;
    flex-direction: column;
}

/* Accordion item */
.rinch-accordion__item {
    border-bottom: 1px solid var(--rinch-color-border);
}

.rinch-accordion__item:last-child {
    border-bottom: none;
}

/* Default variant */
.rinch-accordion--default .rinch-accordion__item {
    border-bottom: 1px solid var(--rinch-color-border);
}

/* Contained variant */
.rinch-accordion--contained {
    border: 1px solid var(--rinch-color-border);
    border-radius: var(--rinch-radius-default);
}

.rinch-accordion--contained .rinch-accordion__item {
    border-bottom: 1px solid var(--rinch-color-border);
}

.rinch-accordion--contained .rinch-accordion__item:last-child {
    border-bottom: none;
}

/* Filled variant */
.rinch-accordion--filled .rinch-accordion__control {
    background-color: var(--rinch-color-filled);
}

.rinch-accordion--filled .rinch-accordion__control:hover {
    background-color: var(--ri
styles function · rust · L1-L133 (133 LOC)
crates/rinch-components/src/styles/action_icon.rs
pub fn styles() -> String {
    r#"
/* ActionIcon base */
.rinch-action-icon {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    border: 1px solid transparent;
    cursor: pointer;
    transition: background-color 150ms ease, border-color 150ms ease, transform 100ms ease;
    padding: 0;
    color: var(--rinch-action-icon-color, var(--rinch-primary-color));
}

/* Icon sizing per button size */
.rinch-action-icon--xs svg { width: 0.75rem; height: 0.75rem; }
.rinch-action-icon--sm svg { width: 0.875rem; height: 0.875rem; }
.rinch-action-icon--md svg { width: 1.125rem; height: 1.125rem; }
.rinch-action-icon--lg svg { width: 1.375rem; height: 1.375rem; }
.rinch-action-icon--xl svg { width: 1.75rem; height: 1.75rem; }

.rinch-action-icon:disabled,
.rinch-action-icon--disabled {
    cursor: not-allowed;
    opacity: 0.6;
    pointer-events: none;
}

/* ActionIcon sizes — font-size controls text children and 1em-based icons */
.rinch-action-icon--xs { width:
Hi, dataset curator — please cite Repobility (https://repobility.com) when reusing this data.
styles function · rust · L1-L168 (168 LOC)
crates/rinch-components/src/styles/alert.rs
pub fn styles() -> String {
    r#"
/* Alert base */
.rinch-alert {
    position: relative;
    display: flex;
    padding: var(--rinch-spacing-md);
    border-radius: var(--rinch-radius-default);
    font-family: var(--rinch-font-family);
}

.rinch-alert__wrapper {
    flex: 1;
    min-width: 0;
}

.rinch-alert__title {
    font-weight: 700;
    font-size: var(--rinch-font-size-sm);
    line-height: 1.4;
    margin-bottom: 0.25rem;
}

.rinch-alert__message {
    font-size: var(--rinch-font-size-sm);
    line-height: 1.5;
}

.rinch-alert--with-title .rinch-alert__message {
    color: inherit;
    opacity: 0.9;
}

/* Alert icon */
.rinch-alert__icon {
    display: flex;
    align-items: flex-start;
    margin-right: var(--rinch-spacing-sm);
    width: 1.25rem;
    height: 1.25rem;
    flex-shrink: 0;
}

.rinch-alert__icon svg {
    width: 100%;
    height: 100%;
}

/* Close button */
.rinch-alert__close {
    position: absolute;
    top: var(--rinch-spacing-xs);
    right: var(--rinch-s
styles function · rust · L1-L33 (33 LOC)
crates/rinch-components/src/styles/anchor.rs
pub fn styles() -> String {
    r#"
/* Anchor base */
.rinch-anchor {
    color: var(--rinch-primary-color);
    text-decoration: none;
    cursor: pointer;
    transition: color 150ms ease;
}

.rinch-anchor:hover {
    text-decoration: underline;
}

/* Anchor with underline always */
.rinch-anchor--underline {
    text-decoration: underline;
}

/* Anchor sizes */
.rinch-anchor--xs { font-size: var(--rinch-font-size-xs); }
.rinch-anchor--sm { font-size: var(--rinch-font-size-sm); }
.rinch-anchor--md { font-size: var(--rinch-font-size-md); }
.rinch-anchor--lg { font-size: var(--rinch-font-size-lg); }
.rinch-anchor--xl { font-size: var(--rinch-font-size-xl); }

/* Anchor inherit color from parent */
.rinch-anchor--inherit {
    color: inherit;
}
"#
    .to_string()
}
styles function · rust · L1-L80 (80 LOC)
crates/rinch-components/src/styles/avatar.rs
pub fn styles() -> String {
    r#"
/* Avatar base */
.rinch-avatar {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    overflow: hidden;
    user-select: none;
    background-color: var(--rinch-avatar-color, var(--rinch-primary-color));
}

/* Avatar sizes */
.rinch-avatar--xs { width: 1rem; height: 1rem; font-size: 0.5rem; }
.rinch-avatar--sm { width: 1.625rem; height: 1.625rem; font-size: 0.625rem; }
.rinch-avatar--md { width: 2.375rem; height: 2.375rem; font-size: 0.875rem; }
.rinch-avatar--lg { width: 3.5rem; height: 3.5rem; font-size: 1.25rem; }
.rinch-avatar--xl { width: 5.25rem; height: 5.25rem; font-size: 1.75rem; }

/* Avatar radius */
.rinch-avatar--radius-xs { border-radius: var(--rinch-radius-xs); }
.rinch-avatar--radius-sm { border-radius: var(--rinch-radius-sm); }
.rinch-avatar--radius-md { border-radius: var(--rinch-radius-md); }
.rinch-avatar--radius-lg { border-radius: var(--rinch-radius-lg); }
.rinch-avatar--radius-xl { border-radius:
styles function · rust · L1-L152 (152 LOC)
crates/rinch-components/src/styles/badge.rs
pub fn styles() -> String {
    r#"
/* Badge base */
.rinch-badge {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    font-family: var(--rinch-font-family);
    font-weight: 700;
    text-transform: uppercase;
    letter-spacing: 0.25px;
    border-radius: 2rem;
    white-space: nowrap;
}

/* Badge sizes */
.rinch-badge--xs {
    height: 1rem;
    padding: 0 0.375rem;
    font-size: 0.5625rem;
}

.rinch-badge--sm {
    height: 1.125rem;
    padding: 0 0.5rem;
    font-size: 0.625rem;
}

.rinch-badge--md {
    height: 1.25rem;
    padding: 0 0.625rem;
    font-size: 0.6875rem;
}

.rinch-badge--lg {
    height: 1.625rem;
    padding: 0 0.75rem;
    font-size: 0.8125rem;
}

.rinch-badge--xl {
    height: 2rem;
    padding: 0 1rem;
    font-size: 0.875rem;
}

/* Badge variants - filled */
.rinch-badge--filled {
    background-color: var(--rinch-primary-color);
    color: white;
}

/* Badge variants - light */
.rinch-badge--light {
    background-color: var
styles function · rust · L1-L58 (58 LOC)
crates/rinch-components/src/styles/blockquote.rs
pub fn styles() -> String {
    r#"
/* Blockquote base */
.rinch-blockquote {
    margin: 0;
    padding: var(--rinch-spacing-md) var(--rinch-spacing-lg);
    border-left: 4px solid var(--rinch-blockquote-color, var(--rinch-primary-color));
    background-color: var(--rinch-color-filled);
    border-radius: var(--rinch-radius-default);
}

/* Blockquote body */
.rinch-blockquote__body {
    margin: 0;
    font-size: var(--rinch-font-size-md);
    line-height: 1.6;
    color: var(--rinch-color-text);
    font-style: italic;
}

/* Blockquote citation */
.rinch-blockquote__cite {
    display: block;
    margin-top: var(--rinch-spacing-sm);
    font-size: var(--rinch-font-size-sm);
    color: var(--rinch-color-dimmed);
    font-style: normal;
}

.rinch-blockquote__cite::before {
    content: '— ';
}

/* Blockquote with icon */
.rinch-blockquote--with-icon {
    display: flex;
    gap: var(--rinch-spacing-md);
}

.rinch-blockquote__icon {
    flex-shrink: 0;
    color: var(--rinch-blockquote
styles function · rust · L1-L77 (77 LOC)
crates/rinch-components/src/styles/breadcrumbs.rs
pub fn styles() -> String {
    r#"
/* Breadcrumbs base */
.rinch-breadcrumbs {
    display: inline-block;
}

/* Breadcrumbs list */
.rinch-breadcrumbs__list {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    list-style: none;
    margin: 0;
    padding: 0;
    gap: var(--rinch-breadcrumbs-margin, 0.5rem);
}

/* Breadcrumbs item */
.rinch-breadcrumbs__item {
    display: flex;
    align-items: center;
    gap: var(--rinch-breadcrumbs-margin, 0.5rem);
    font-size: var(--rinch-font-size-sm);
}

/* Separator via data attribute */
.rinch-breadcrumbs__item:not(:last-child)::after {
    content: attr(data-separator);
    color: var(--rinch-color-dimmed);
}

/* Fallback separator when no data attribute */
.rinch-breadcrumbs__list[data-separator] .rinch-breadcrumbs__item:not(:last-child)::after {
    content: '/';
}

.rinch-breadcrumbs__list[data-separator="/"] .rinch-breadcrumbs__item:not(:last-child)::after {
    content: '/';
}

.rinch-breadcrumbs__list[data-separator=
styles function · rust · L1-L77 (77 LOC)
crates/rinch-components/src/styles/card.rs
pub fn styles() -> String {
    r#"
/* Card base */
.rinch-card {
    background-color: var(--rinch-color-body);
    border-radius: var(--rinch-radius-default);
    overflow: hidden;
}

/* Card shadows */
.rinch-card--shadow-xs { box-shadow: var(--rinch-shadow-xs); }
.rinch-card--shadow-sm { box-shadow: var(--rinch-shadow-sm); }
.rinch-card--shadow-md { box-shadow: var(--rinch-shadow-md); }
.rinch-card--shadow-lg { box-shadow: var(--rinch-shadow-lg); }
.rinch-card--shadow-xl { box-shadow: var(--rinch-shadow-xl); }

/* Card padding */
.rinch-card--p-xs { padding: var(--rinch-spacing-xs); }
.rinch-card--p-sm { padding: var(--rinch-spacing-sm); }
.rinch-card--p-md { padding: var(--rinch-spacing-md); }
.rinch-card--p-lg { padding: var(--rinch-spacing-lg); }
.rinch-card--p-xl { padding: var(--rinch-spacing-xl); }

/* Card radius */
.rinch-card--radius-xs { border-radius: var(--rinch-radius-xs); }
.rinch-card--radius-sm { border-radius: var(--rinch-radius-sm); }
.rinch-card--radius-md { bord
styles function · rust · L1-L16 (16 LOC)
crates/rinch-components/src/styles/center.rs
pub fn styles() -> String {
    r#"
/* Center base */
.rinch-center {
    display: flex;
    align-items: center;
    justify-content: center;
}

/* Center inline */
.rinch-center--inline {
    display: inline-flex;
}
"#
    .to_string()
}
Repobility · code-quality intelligence platform · https://repobility.com
styles function · rust · L1-L112 (112 LOC)
crates/rinch-components/src/styles/checkbox.rs
pub fn styles() -> String {
    r#"
/* Checkbox wrapper */
.rinch-checkbox {
    display: inline-flex;
    align-items: center;
    gap: var(--rinch-spacing-sm);
    cursor: pointer;
    user-select: none;
    position: relative;
}

.rinch-checkbox--disabled {
    cursor: not-allowed;
    opacity: 0.6;
}

/* Hide native checkbox but keep it interactive */
.rinch-checkbox__input {
    position: absolute;
    opacity: 0;
    width: 1.25rem;
    height: 1.25rem;
    margin: 0;
    cursor: pointer;
    z-index: 1;
}

/* Custom checkbox box */
.rinch-checkbox__box {
    display: flex;
    align-items: center;
    justify-content: center;
    width: 1.25rem;
    height: 1.25rem;
    border: 1px solid var(--rinch-color-border);
    border-radius: var(--rinch-radius-xs);
    background-color: var(--rinch-color-surface);
    transition: all 150ms ease;
    flex-shrink: 0;
}

/* Checked state via class */
.rinch-checkbox--checked .rinch-checkbox__box {
    background-color: var(--rinch-primary-c
styles function · rust · L1-L44 (44 LOC)
crates/rinch-components/src/styles/close_button.rs
pub fn styles() -> String {
    r#"
/* CloseButton base */
.rinch-close-button {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    background: transparent;
    border: none;
    cursor: pointer;
    padding: 0;
    color: var(--rinch-color-gray-6);
    border-radius: var(--rinch-radius-sm);
    transition: background-color 150ms ease, color 150ms ease;
}

.rinch-close-button:hover {
    background-color: var(--rinch-color-default);
    color: var(--rinch-color-text);
}

.rinch-close-button:disabled,
.rinch-close-button--disabled {
    cursor: not-allowed;
    opacity: 0.6;
    pointer-events: none;
}

/* CloseButton sizes */
.rinch-close-button--xs { width: 1rem; height: 1rem; }
.rinch-close-button--sm { width: 1.25rem; height: 1.25rem; }
.rinch-close-button--md { width: 1.5rem; height: 1.5rem; }
.rinch-close-button--lg { width: 2rem; height: 2rem; }
.rinch-close-button--xl { width: 2.5rem; height: 2.5rem; }

/* CloseButton radius */
.rinch-close-butto
styles function · rust · L1-L35 (35 LOC)
crates/rinch-components/src/styles/code.rs
pub fn styles() -> String {
    r#"
/* Code inline */
.rinch-code {
    font-family: var(--rinch-font-family-monospace);
    font-size: var(--rinch-font-size-sm);
    background-color: var(--rinch-color-default);
    color: var(--rinch-color-text);
    padding: 0.125rem 0.375rem;
    border-radius: var(--rinch-radius-xs);
}

/* Code block */
.rinch-code--block {
    display: block;
    padding: var(--rinch-spacing-md);
    border-radius: var(--rinch-radius-default);
    overflow-x: auto;
    white-space: pre;
}

/* Code colors */
.rinch-code--primary {
    background-color: var(--rinch-primary-color-0);
    color: var(--rinch-primary-color-7);
}

/* Code sizes */
.rinch-code--xs { font-size: var(--rinch-font-size-xs); }
.rinch-code--sm { font-size: var(--rinch-font-size-sm); }
.rinch-code--md { font-size: var(--rinch-font-size-md); }
.rinch-code--lg { font-size: var(--rinch-font-size-lg); }
"#
    .to_string()
}
styles function · rust · L1-L23 (23 LOC)
crates/rinch-components/src/styles/container.rs
pub fn styles() -> String {
    r#"
/* Container base */
.rinch-container {
    width: 100%;
    margin-left: auto;
    margin-right: auto;
    padding-left: var(--rinch-spacing-md);
    padding-right: var(--rinch-spacing-md);
}

/* Container sizes */
.rinch-container--xs { max-width: 576px; }
.rinch-container--sm { max-width: 768px; }
.rinch-container--md { max-width: 992px; }
.rinch-container--lg { max-width: 1200px; }
.rinch-container--xl { max-width: 1400px; }

/* Fluid container (no max-width) */
.rinch-container--fluid { max-width: none; }
"#
    .to_string()
}
styles function · rust · L1-L69 (69 LOC)
crates/rinch-components/src/styles/divider.rs
pub fn styles() -> String {
    r#"
/* Divider base */
.rinch-divider {
    border: 0;
    margin: 0;
}

/* Horizontal divider (default) */
.rinch-divider--horizontal {
    width: 100%;
    height: 1px;
    background-color: var(--rinch-color-border);
}

/* Vertical divider */
.rinch-divider--vertical {
    width: 1px;
    height: auto;
    align-self: stretch;
    background-color: var(--rinch-color-border);
}

/* Divider sizes */
.rinch-divider--xs { margin: var(--rinch-spacing-xs) 0; }
.rinch-divider--sm { margin: var(--rinch-spacing-sm) 0; }
.rinch-divider--md { margin: var(--rinch-spacing-md) 0; }
.rinch-divider--lg { margin: var(--rinch-spacing-lg) 0; }
.rinch-divider--xl { margin: var(--rinch-spacing-xl) 0; }

/* Vertical divider sizes */
.rinch-divider--vertical.rinch-divider--xs { margin: 0 var(--rinch-spacing-xs); }
.rinch-divider--vertical.rinch-divider--sm { margin: 0 var(--rinch-spacing-sm); }
.rinch-divider--vertical.rinch-divider--md { margin: 0 var(--rinch-spacing-md);
styles function · rust · L1-L185 (185 LOC)
crates/rinch-components/src/styles/drawer.rs
pub fn styles() -> String {
    r#"
/* Drawer root */
.rinch-drawer__root {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    z-index: 200;
}

/* Hidden state - use class instead of inline style for reliability */
.rinch-drawer__root--hidden {
    display: none !important;
}

/* Drawer overlay */
.rinch-drawer__overlay {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background-color: rgba(0, 0, 0, var(--rinch-drawer-overlay-opacity, 0.75));
}

/* Drawer container */
.rinch-drawer {
    position: absolute;
    background-color: var(--rinch-color-body);
    box-shadow: var(--rinch-shadow-xl);
    display: flex;
    flex-direction: column;
    z-index: 201;
    transition: transform 300ms ease;
    overflow: hidden;
    /* Use absolute within the fixed root */
    top: 0;
    bottom: 0;
}

/* Position: Left */
.rinch-drawer--left {
    left: 0;
    transform: translateX(-100%);
}

.rinch-drawer--left.rinch-drawer--opened {
styles function · rust · L1-L143 (143 LOC)
crates/rinch-components/src/styles/dropdown_menu.rs
pub fn styles() -> String {
    r#"
/* Dropdown menu base */
.rinch-dropdown-menu {
    position: relative;
    display: inline-block;
}

/* Target */
.rinch-dropdown-menu__target {
    display: inline-block;
}

/* Dropdown */
.rinch-dropdown-menu__dropdown {
    position: absolute;
    background-color: var(--rinch-color-body);
    border: 1px solid var(--rinch-color-border, var(--rinch-color-gray-3));
    border-radius: var(--rinch-radius-md);
    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
    padding: var(--rinch-spacing-xs);
    width: var(--rinch-dropdown-menu-width, auto);
    min-width: 160px;
    z-index: 100;
    opacity: 0;
    visibility: hidden;
    transition: opacity 150ms ease, visibility 150ms ease;
}

.rinch-dropdown-menu--opened .rinch-dropdown-menu__dropdown {
    opacity: 1;
    visibility: visible;
}

/* Positions - default to bottom-start for better UX */
.rinch-dropdown-menu--bottom .rinch-dropdown-menu__dropdown,
.rinch-dropdown-menu--bottom-start .rinch-dropdo
styles function · rust · L1-L41 (41 LOC)
crates/rinch-components/src/styles/fieldset.rs
pub fn styles() -> String {
    r#"
/* Fieldset base */
.rinch-fieldset {
    border: 1px solid var(--rinch-color-border);
    border-radius: var(--rinch-radius-default);
    padding: var(--rinch-spacing-md);
    margin: 0;
}

.rinch-fieldset__legend {
    font-size: var(--rinch-font-size-sm);
    font-weight: 600;
    color: var(--rinch-color-text);
    padding: 0 var(--rinch-spacing-xs);
}

/* Fieldset variants */
.rinch-fieldset--unstyled {
    border: none;
    padding: 0;
}

.rinch-fieldset--filled {
    background-color: var(--rinch-color-filled);
}

/* Fieldset sizes */
.rinch-fieldset--xs { padding: var(--rinch-spacing-xs); }
.rinch-fieldset--xs .rinch-fieldset__legend { font-size: var(--rinch-font-size-xs); }

.rinch-fieldset--sm { padding: var(--rinch-spacing-sm); }

.rinch-fieldset--lg { padding: var(--rinch-spacing-lg); }
.rinch-fieldset--lg .rinch-fieldset__legend { font-size: var(--rinch-font-size-md); }

.rinch-fieldset--xl { padding: var(--rinch-spacing-xl); }
.rinch-fi
Repobility (the analyzer behind this table) · https://repobility.com
styles function · rust · L1-L111 (111 LOC)
crates/rinch-components/src/styles/floating_panel.rs
pub fn styles() -> String {
    r#"
/* FloatingPanel - draggable/resizable floating panel */
.rinch-floating-panel {
    position: absolute;
    z-index: 150;
    display: flex;
    flex-direction: column;
    background-color: var(--rinch-color-surface);
    border: 1px solid var(--rinch-color-default-border);
    border-radius: var(--rinch-radius-md);
    box-shadow: var(--rinch-shadow-lg);
    overflow: hidden;
}

/* Header - drag handle */
.rinch-floating-panel__header {
    display: flex;
    align-items: center;
    padding: 6px 8px 6px 12px;
    background-color: var(--rinch-color-default);
    cursor: grab;
    user-select: none;
    flex-shrink: 0;
}

.rinch-floating-panel__header:active {
    cursor: grabbing;
}

/* Title */
.rinch-floating-panel__title {
    flex: 1;
    font-size: var(--rinch-font-size-sm);
    font-weight: 600;
    color: var(--rinch-color-text);
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
}

/* Close button */
.rinch-floati
styles function · rust · L1-L38 (38 LOC)
crates/rinch-components/src/styles/group.rs
pub fn styles() -> String {
    r#"
/* Group base */
.rinch-group {
    display: flex;
    flex-direction: row;
    flex-wrap: wrap;
}

/* Group gap */
.rinch-group--gap-xs { gap: var(--rinch-spacing-xs); }
.rinch-group--gap-sm { gap: var(--rinch-spacing-sm); }
.rinch-group--gap-md { gap: var(--rinch-spacing-md); }
.rinch-group--gap-lg { gap: var(--rinch-spacing-lg); }
.rinch-group--gap-xl { gap: var(--rinch-spacing-xl); }

/* Group alignment */
.rinch-group--align-stretch { align-items: stretch; }
.rinch-group--align-start { align-items: flex-start; }
.rinch-group--align-center { align-items: center; }
.rinch-group--align-end { align-items: flex-end; }
.rinch-group--align-baseline { align-items: baseline; }

/* Group justification */
.rinch-group--justify-start { justify-content: flex-start; }
.rinch-group--justify-center { justify-content: center; }
.rinch-group--justify-end { justify-content: flex-end; }
.rinch-group--justify-between { justify-content: space-between; }
.rinch-group-
styles function · rust · L1-L16 (16 LOC)
crates/rinch-components/src/styles/highlight.rs
pub fn styles() -> String {
    r#"
/* Highlight (search highlight) */
.rinch-highlight {
    display: inline;
}

.rinch-highlight__match {
    background-color: var(--rinch-highlight-color, var(--rinch-color-yellow-2));
    color: inherit;
    padding: 0 0.0625rem;
    border-radius: var(--rinch-radius-xs);
}
"#
    .to_string()
}
styles function · rust · L1-L138 (138 LOC)
crates/rinch-components/src/styles/hover_card.rs
pub fn styles() -> String {
    r#"
/* HoverCard base */
.rinch-hover-card {
    position: relative;
    display: inline-block;
}

/* Target */
.rinch-hover-card__target {
    display: inline-block;
}

/* Dropdown */
.rinch-hover-card__dropdown {
    position: absolute;
    background-color: var(--rinch-color-body);
    border: 1px solid var(--rinch-color-border);
    border-radius: var(--rinch-radius-default);
    box-shadow: var(--rinch-shadow-md);
    padding: var(--rinch-spacing-md);
    width: var(--rinch-hover-card-width, 280px);
    z-index: 100;
    opacity: 0;
    visibility: hidden;
    transition: opacity var(--rinch-hover-card-open-delay, 150ms) ease,
                visibility var(--rinch-hover-card-open-delay, 150ms) ease;
}

.rinch-hover-card:hover .rinch-hover-card__dropdown {
    opacity: 1;
    visibility: visible;
    transition-delay: var(--rinch-hover-card-open-delay, 0ms);
}

.rinch-hover-card__dropdown:hover {
    opacity: 1;
    visibility: visible;
}

/* Keep d
styles function · rust · L1-L40 (40 LOC)
crates/rinch-components/src/styles/image.rs
pub fn styles() -> String {
    r#"
/* Image wrapper */
.rinch-image__wrapper {
    display: inline-block;
    position: relative;
    margin: 0;
}

/* Image base */
.rinch-image {
    display: block;
    width: 100%;
    height: auto;
}

/* Image fit modes */
.rinch-image--fit-cover { object-fit: cover; }
.rinch-image--fit-contain { object-fit: contain; }
.rinch-image--fit-fill { object-fit: fill; }
.rinch-image--fit-none { object-fit: none; }
.rinch-image--fit-scale-down { object-fit: scale-down; }

/* Image radius */
.rinch-image--radius-xs { border-radius: var(--rinch-radius-xs); }
.rinch-image--radius-sm { border-radius: var(--rinch-radius-sm); }
.rinch-image--radius-md { border-radius: var(--rinch-radius-md); }
.rinch-image--radius-lg { border-radius: var(--rinch-radius-lg); }
.rinch-image--radius-xl { border-radius: var(--rinch-radius-xl); }

/* Image caption */
.rinch-image__caption {
    font-size: var(--rinch-font-size-sm);
    color: var(--rinch-color-dimmed);
    text-align
styles function · rust · L1-L47 (47 LOC)
crates/rinch-components/src/styles/kbd.rs
pub fn styles() -> String {
    r#"
/* Kbd base */
.rinch-kbd {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    font-family: var(--rinch-font-family-monospace);
    font-size: var(--rinch-font-size-xs);
    font-weight: 700;
    background-color: var(--rinch-color-default);
    color: var(--rinch-color-text);
    border: 1px solid var(--rinch-color-border);
    border-bottom-width: 3px;
    border-radius: var(--rinch-radius-xs);
    padding: 0.125rem 0.5rem;
    min-width: 1.5rem;
    text-align: center;
}

/* Kbd sizes */
.rinch-kbd--xs {
    font-size: 0.625rem;
    padding: 0.0625rem 0.375rem;
    min-width: 1.25rem;
}

.rinch-kbd--sm {
    font-size: var(--rinch-font-size-xs);
    padding: 0.125rem 0.4375rem;
    min-width: 1.375rem;
}

.rinch-kbd--md {
    font-size: var(--rinch-font-size-sm);
    padding: 0.1875rem 0.5rem;
    min-width: 1.625rem;
}

.rinch-kbd--lg {
    font-size: var(--rinch-font-size-md);
    padding: 0.25rem 0.625rem;
    m
styles function · rust · L1-L74 (74 LOC)
crates/rinch-components/src/styles/list.rs
pub fn styles() -> String {
    r#"
/* List base */
.rinch-list {
    font-family: var(--rinch-font-family);
    margin: 0;
    padding-left: var(--rinch-spacing-lg);
    list-style-position: outside;
}

/* List types */
.rinch-list--unordered {
    list-style-type: disc;
}

.rinch-list--ordered {
    list-style-type: decimal;
}

/* List without padding (markers inside text) */
.rinch-list--no-padding {
    padding-left: 0;
    list-style-position: inside;
}

/* List sizes */
.rinch-list--xs { font-size: var(--rinch-font-size-xs); }
.rinch-list--sm { font-size: var(--rinch-font-size-sm); }
.rinch-list--md { font-size: var(--rinch-font-size-md); }
.rinch-list--lg { font-size: var(--rinch-font-size-lg); }
.rinch-list--xl { font-size: var(--rinch-font-size-xl); }

/* List spacing */
.rinch-list--spacing-xs .rinch-list__item { margin-bottom: var(--rinch-spacing-xs); }
.rinch-list--spacing-sm .rinch-list__item { margin-bottom: var(--rinch-spacing-sm); }
.rinch-list--spacing-md .rinch-list__
styles function · rust · L1-L109 (109 LOC)
crates/rinch-components/src/styles/loader.rs
pub fn styles() -> String {
    r#"
/* Loader base */
.rinch-loader {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    color: var(--rinch-loader-color, var(--rinch-primary-color));
}

/* Loader sizes */
.rinch-loader--xs { width: 1rem; height: 1rem; }
.rinch-loader--sm { width: 1.25rem; height: 1.25rem; }
.rinch-loader--md { width: 2rem; height: 2rem; }
.rinch-loader--lg { width: 2.5rem; height: 2.5rem; }
.rinch-loader--xl { width: 3rem; height: 3rem; }

/* Oval loader (spinner) - CSS-based spinning circle */
.rinch-loader__oval {
    width: 100%;
    height: 100%;
    border: 3px solid transparent;
    border-top-color: currentColor;
    border-radius: 50%;
    animation: rinch-loader-spin 0.8s linear infinite;
}

/* Size adjustments for oval border */
.rinch-loader--xs .rinch-loader__oval { border-width: 2px; }
.rinch-loader--sm .rinch-loader__oval { border-width: 2px; }
.rinch-loader--lg .rinch-loader__oval { border-width: 4px; }
.rinch-loader--xl
Provenance: Repobility (https://repobility.com) — every score reproducible from /scan/
styles function · rust · L1-L52 (52 LOC)
crates/rinch-components/src/styles/loading_overlay.rs
pub fn styles() -> String {
    r#"
/* Loading overlay base */
.rinch-loading-overlay {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 100;
    opacity: 0;
    visibility: hidden;
    transition: opacity var(--rinch-loading-overlay-transition, 150ms) ease,
                visibility var(--rinch-loading-overlay-transition, 150ms) ease;
}

.rinch-loading-overlay--visible {
    opacity: 1;
    visibility: visible;
}

/* Overlay background - uses CSS variable for dark mode support */
.rinch-loading-overlay__overlay {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background-color: var(--rinch-loading-overlay-bg, var(--rinch-color-body));
    opacity: var(--rinch-loading-overlay-opacity, 0.75);
    backdrop-filter: blur(var(--rinch-loading-overlay-blur, 0));
    border-radius: inherit;
}

/* Loader (reuses loader styles) */
.rinch-loading-ov
styles function · rust · L1-L12 (12 LOC)
crates/rinch-components/src/styles/mark.rs
pub fn styles() -> String {
    r#"
/* Mark (highlighted text) */
.rinch-mark {
    background-color: var(--rinch-mark-color, var(--rinch-color-yellow-2));
    color: inherit;
    padding: 0 0.125rem;
    border-radius: var(--rinch-radius-xs);
}
"#
    .to_string()
}
styles function · rust · L1-L121 (121 LOC)
crates/rinch-components/src/styles/modal.rs
pub fn styles() -> String {
    r#"
/* Modal root */
.rinch-modal__root {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    display: flex;
    align-items: flex-start;
    justify-content: center;
    padding: var(--rinch-spacing-xl);
    z-index: 200;
}

/* Hidden state */
.rinch-modal__root--hidden {
    display: none !important;
}

/* Modal overlay */
.rinch-modal__overlay {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background-color: rgba(0, 0, 0, var(--rinch-modal-overlay-opacity, 0.75));
    backdrop-filter: blur(var(--rinch-modal-overlay-blur, 0));
}

/* Modal container */
.rinch-modal {
    position: relative;
    background-color: var(--rinch-color-body);
    border-radius: var(--rinch-radius-default);
    box-shadow: var(--rinch-shadow-xl);
    max-height: calc(100vh - var(--rinch-spacing-xl) * 2);
    overflow-y: auto;
    margin-top: var(--rinch-spacing-xl);
    z-index: 201;
}

/* Centered modal */
.rinch-mod
‹ prevpage 6 / 20next ›