Skip to main content

prime_steps/
state.rs

1//! Pure Steps logic: classes, disabled state, `tabindex`, `aria-disabled`, click and key outcome (after PrimeNG `steps.ts`).
2
3use prime_rs_core::ClassNames;
4use std::borrow::Cow;
5
6/// Root classes: `p-steps p-component`, `p-readonly`, the user class.
7pub fn root_classes(readonly: bool, extra: Option<&str>) -> Cow<'static, str> {
8    let mut cn = ClassNames::new();
9    cn.add("p-steps p-component").add_if(readonly, "p-readonly").add_user(extra);
10    cn.finish_cow()
11}
12
13/// Item classes: `p-steps-item`, `p-steps-item-active`, `p-disabled`.
14pub fn item_classes(active: bool, disabled: bool) -> Cow<'static, str> {
15    let mut cn = ClassNames::new();
16    cn.add("p-steps-item").add_if(active, "p-steps-item-active").add_if(disabled, "p-disabled");
17    cn.finish_cow()
18}
19
20/// The item is disabled: it has `disabled`, or readonly is on and the item is not active (`isItemDisabled`).
21pub fn is_item_disabled(item_disabled: bool, index: usize, active: usize, readonly: bool) -> bool {
22    item_disabled || (readonly && index != active)
23}
24
25/// Link `tabindex` without moving focus: `-1` for a disabled one, its own (or `0`) for the active one, its own
26/// (or `-1`) for the rest (`getItemTabIndex`).
27pub fn link_tabindex(item_disabled: bool, item_tabindex: Option<i32>, index: usize, active: usize) -> i32 {
28    if item_disabled {
29        -1
30    } else if index == active {
31        item_tabindex.filter(|t| *t != 0).unwrap_or(0)
32    } else {
33        item_tabindex.unwrap_or(-1)
34    }
35}
36
37/// Link `aria-disabled`: the item's `disabled` or readonly on an inactive item.
38pub fn aria_disabled(item_disabled: bool, index: usize, active: usize, readonly: bool) -> bool {
39    item_disabled || (readonly && index != active)
40}
41
42/// What a click does.
43#[derive(Clone, Copy, Debug, PartialEq, Eq)]
44pub enum Click {
45    /// Only cancel the link navigation.
46    Ignore,
47    /// Select the item and call the command; `prevent_default` — whether to cancel navigation (the item has no `url`).
48    Activate {
49        /// Whether to cancel the link navigation.
50        prevent_default: bool,
51    },
52}
53
54/// Click outcome (`onItemClick`): readonly or a disabled item — ignored.
55pub fn click_outcome(item_disabled: bool, readonly: bool, has_url: bool) -> Click {
56    if readonly || item_disabled { Click::Ignore } else { Click::Activate { prevent_default: !has_url } }
57}
58
59/// The item that focus moves to on a key; at the bounds it stays the same. `None` — the key does not move focus.
60pub fn key_target(code: &str, index: usize, count: usize) -> Option<usize> {
61    let last = count.checked_sub(1)?;
62    match code {
63        "ArrowRight" => Some((index + 1).min(last)),
64        "ArrowLeft" => Some(index.saturating_sub(1)),
65        "Home" => Some(0),
66        "End" => Some(last),
67        _ => None,
68    }
69}
70
71/// `Enter` and `Space` act as a click.
72pub fn is_activation_key(code: &str) -> bool {
73    matches!(code, "Enter" | "Space")
74}
75
76#[cfg(test)]
77mod tests {
78    use super::*;
79
80    #[test]
81    fn root_and_item_classes() {
82        assert_eq!(root_classes(false, None), "p-steps p-component");
83        assert_eq!(root_classes(true, Some("mine")), "p-steps p-component p-readonly mine");
84        assert_eq!(item_classes(false, false), "p-steps-item");
85        assert_eq!(item_classes(true, false), "p-steps-item p-steps-item-active");
86        assert_eq!(item_classes(false, true), "p-steps-item p-disabled");
87        assert_eq!(item_classes(true, true), "p-steps-item p-steps-item-active p-disabled");
88    }
89
90    #[test]
91    fn disabled_table() {
92        // (disabled, index, active, readonly) → disabled
93        for (dis, i, a, ro, want) in [
94            (false, 1, 1, true, false),
95            (false, 0, 1, true, true),
96            (false, 0, 1, false, false),
97            (true, 1, 1, false, true),
98            (true, 1, 1, true, true),
99        ] {
100            assert_eq!(is_item_disabled(dis, i, a, ro), want, "{dis} {i} {a} {ro}");
101            assert_eq!(aria_disabled(dis, i, a, ro), want, "{dis} {i} {a} {ro}");
102        }
103    }
104
105    #[test]
106    fn tabindex_table() {
107        assert_eq!(link_tabindex(true, Some(5), 1, 1), -1, "disabled");
108        assert_eq!(link_tabindex(false, None, 1, 1), 0, "active");
109        assert_eq!(link_tabindex(false, Some(3), 1, 1), 3, "active with its own");
110        assert_eq!(link_tabindex(false, Some(0), 1, 1), 0);
111        assert_eq!(link_tabindex(false, None, 0, 1), -1, "the rest");
112        assert_eq!(link_tabindex(false, Some(2), 0, 1), 2);
113    }
114
115    #[test]
116    fn click_table() {
117        assert_eq!(click_outcome(false, true, false), Click::Ignore);
118        assert_eq!(click_outcome(true, false, false), Click::Ignore);
119        assert_eq!(click_outcome(false, false, false), Click::Activate { prevent_default: true });
120        assert_eq!(click_outcome(false, false, true), Click::Activate { prevent_default: false });
121    }
122
123    #[test]
124    fn key_targets_stay_inside() {
125        assert_eq!(key_target("ArrowRight", 0, 4), Some(1));
126        assert_eq!(key_target("ArrowRight", 3, 4), Some(3));
127        assert_eq!(key_target("ArrowLeft", 2, 4), Some(1));
128        assert_eq!(key_target("ArrowLeft", 0, 4), Some(0));
129        assert_eq!(key_target("Home", 2, 4), Some(0));
130        assert_eq!(key_target("End", 1, 4), Some(3));
131        assert_eq!(key_target("Tab", 1, 4), None);
132        assert_eq!(key_target("End", 0, 0), None);
133        assert!(is_activation_key("Enter") && is_activation_key("Space") && !is_activation_key("KeyA"));
134    }
135}