polished-css 0.1.0

Craft polished CSS in Rust following CSSWG standards. Achieve type-safety, modularity, atomicity, and ergonomic styling for front-end applications.
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

use std::{collections::HashMap, sync::RwLock};

use once_cell::sync::Lazy;

// Reference: https://refactoring.guru/design-patterns/observer/rust/example
#[derive(Debug)]
pub struct AtomicEventEmitter {
    observer: RwLock<AtomicObserver>,
}
impl AtomicEventEmitter {
    /// # Panics
    ///
    /// Panics if fails to read the `RwLock` on the `AtomicEventEmitter`'
    /// observer.
    pub fn build(&self, content: &crate::style::Content, layer: &str) {
        self.observer
            .read()
            .expect("Failed to read the RwLock on AtomicEventEmitter")
            .notify(&AtomicEvent::Build, content, layer);
    }

    /// # Panics
    ///
    /// Panics if event type is invalid - doesn't match any of `AtomicEvent`
    /// enum variants.
    pub fn subscribe(&self, event: &AtomicEvent, listener: AtomicSubscriber) {
        self.observer
            .write()
            .expect("Couldn't get a lock on atomic observer: poisoned")
            .entry(event.clone())
            .or_default();
        self.observer
            .write()
            .expect("Couldn't get a lock on atomic observer: poisoned")
            .get_mut(event)
            .expect("Invalid atomic styles event type variant")
            .push(listener);
    }

    /// # Panics
    ///
    /// Panics if event type is invalid - doesn't match any of `AtomicEvent`
    /// enum variants.
    pub fn unsubscribe(&self, event: &AtomicEvent, listener: AtomicSubscriber) {
        self.observer
            .write()
            .expect("Couldn't get a lock on atomic observer: poisoned")
            .get_mut(event)
            .expect("Invalid atomic styles event type variant")
            .retain(|&x| x != listener);
    }
}

// Reference: https://refactoring.guru/design-patterns/observer/rust/example
pub static ATOMIC: AtomicEventEmitter = AtomicEventEmitter {
    observer: RwLock::new(AtomicObserver(Lazy::new(HashMap::new))),
};

#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub enum AtomicEvent {
    Build,
}

pub type AtomicSubscriber = fn(content: &crate::style::Content, layer: &str);

// Reference: https://refactoring.guru/design-patterns/observer/rust/example
#[derive(Debug, polished_css_macros::Deref)]
pub struct AtomicObserver(Lazy<HashMap<AtomicEvent, Vec<AtomicSubscriber>>>);
impl AtomicObserver {
    pub fn notify(&self, event: &AtomicEvent, content: &crate::style::Content, layer: &str) {
        if let Some(listeners) = self.get(event) {
            for listener in listeners {
                listener(content, layer);
            }
        }
    }
}
impl std::ops::DerefMut for AtomicObserver {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

pub trait Atomic: crate::property::Property {
    fn atomic_name<'a>(&self) -> &'a str;

    fn style(&self) -> crate::style::Style;

    fn content(&self) -> crate::style::Content {
        self.style().content()
    }

    fn class_name(&self) -> String {
        use crate::selector::SelectorDisplay;
        self.style().selector.as_attribute_value()
    }

    fn atomic(&self) -> String {
        ATOMIC.build(&self.content(), "atomic");
        self.class_name()
    }

    fn atomic_to_layer(&self, layer: &str) -> String {
        ATOMIC.build(&self.content(), layer);
        self.class_name()
    }
}