orbital-base-components 0.1.1

Headless base primitives for Orbital — structure, semantics, and accessibility
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::ops::Deref;

use leptos::prelude::*;

use crate::form::{format_datetime, DatetimeFormat, OrbitalDateTime};

use super::{FieldValidationState, Rule};

#[derive(Debug, Default, PartialEq, Clone, Copy)]
pub enum DatePickerRuleTrigger {
    #[default]
    Blur,
    Change,
    Select,
}

pub struct DatePickerRule(Rule<Option<OrbitalDateTime>, DatePickerRuleTrigger>);

impl DatePickerRule {
    pub fn required(required: Signal<bool>) -> Self {
        Self::validator(move |value, name| {
            if required.get_untracked() && value.is_none() {
                let message = name.get_untracked().map_or_else(
                    || String::from("Please select date!"),
                    |name| format!("Please select {name}!"),
                );
                Err(FieldValidationState::Error(message))
            } else {
                Ok(())
            }
        })
    }

    pub fn required_with_message(required: Signal<bool>, message: Signal<String>) -> Self {
        Self::validator(move |value, _| {
            if required.get_untracked() && value.is_none() {
                Err(FieldValidationState::Error(message.get_untracked()))
            } else {
                Ok(())
            }
        })
    }

    pub fn min_date(min: Signal<Option<OrbitalDateTime>>) -> Self {
        Self::validator(move |value, _| {
            let Some(value) = value else {
                return Ok(());
            };
            let Some(min) = min.get_untracked() else {
                return Ok(());
            };
            if value.start_of_day() < min.start_of_day() {
                let bound = format_datetime(min.start_of_day(), DatetimeFormat::IsoDate);
                Err(FieldValidationState::Error(format!(
                    "Date must be on or after {bound}"
                )))
            } else {
                Ok(())
            }
        })
    }

    pub fn min_date_with_message(
        min: Signal<Option<OrbitalDateTime>>,
        message: Signal<String>,
    ) -> Self {
        Self::validator(move |value, _| {
            let Some(value) = value else {
                return Ok(());
            };
            let Some(min) = min.get_untracked() else {
                return Ok(());
            };
            if value.start_of_day() < min.start_of_day() {
                Err(FieldValidationState::Error(message.get_untracked()))
            } else {
                Ok(())
            }
        })
    }

    pub fn max_date(max: Signal<Option<OrbitalDateTime>>) -> Self {
        Self::validator(move |value, _| {
            let Some(value) = value else {
                return Ok(());
            };
            let Some(max) = max.get_untracked() else {
                return Ok(());
            };
            if value.start_of_day() > max.start_of_day() {
                let bound = format_datetime(max.start_of_day(), DatetimeFormat::IsoDate);
                Err(FieldValidationState::Error(format!(
                    "Date must be on or before {bound}"
                )))
            } else {
                Ok(())
            }
        })
    }

    pub fn max_date_with_message(
        max: Signal<Option<OrbitalDateTime>>,
        message: Signal<String>,
    ) -> Self {
        Self::validator(move |value, _| {
            let Some(value) = value else {
                return Ok(());
            };
            let Some(max) = max.get_untracked() else {
                return Ok(());
            };
            if value.start_of_day() > max.start_of_day() {
                Err(FieldValidationState::Error(message.get_untracked()))
            } else {
                Ok(())
            }
        })
    }

    pub fn validator(
        f: impl Fn(&Option<OrbitalDateTime>, Signal<Option<String>>) -> Result<(), FieldValidationState>
            + Send
            + Sync
            + 'static,
    ) -> Self {
        Self(Rule::validator(f))
    }

    pub fn with_trigger(self, trigger: DatePickerRuleTrigger) -> Self {
        Self(Rule::with_trigger(self.0, trigger))
    }
}

impl Deref for DatePickerRule {
    type Target = Rule<Option<OrbitalDateTime>, DatePickerRuleTrigger>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}