stylist 0.15.1

Stylist is a CSS-in-Rust styling solution for WebAssembly 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

use core::fmt;
use std::ops::DerefMut;
use std::sync::{Arc, Mutex};

use super::*;

/// The reader to read styles from a [`StyleManager`].
///
/// # Notes
///
/// You can only read styles from a style manager once. This is expected. You should never share
/// styles between renders.
#[derive(Debug)]
pub struct StaticReader {
    inner: Arc<Mutex<StyleData>>,
}

impl StaticReader {
    /// Reads [`StyleData`] from a [`StyleManager`].
    pub fn read_style_data(self) -> StyleData {
        self.inner
            .lock()
            .map(|m| m.clone())
            .unwrap_or_else(|_| StyleData::new())
    }
}

/// The writer to be passed to [`StyleManager`] to write styles.
#[derive(Debug)]
pub struct StaticWriter {
    inner: Arc<Mutex<StyleData>>,
}

/// Creates a [StaticWriter] - [StaticReader] pair.
pub fn render_static() -> (StaticWriter, StaticReader) {
    let inner = Arc::new(Mutex::new(StyleData::new()));

    (
        StaticWriter {
            inner: inner.clone(),
        },
        StaticReader { inner },
    )
}

impl StyleData {
    pub fn write_static_markup<W>(&self, w: &mut W) -> fmt::Result
    where
        W: fmt::Write,
    {
        for StyleDataContent { id, style_str, .. } in self.0.iter() {
            // We cannot guarantee a valid class name if the user choose to use a custom prefix.
            // If the default prefix is used, StyleId is guaranteed to be valid without
            // escaping.
            write!(w, r#"<style data-style="{}">"#, id)?;
            write!(w, "{}", html_escape::encode_style(&style_str))?;
            write!(w, "</style>")?;
        }

        Ok(())
    }
}

impl StyleManagerBuilder {
    /// Set the [StaticWriter] for current manager.
    ///
    /// # Note
    ///
    /// This also sets the StyleManager into the "static" mode. which it will stop rendering
    /// styles into any html element.
    pub fn writer(mut self, w: StaticWriter) -> Self {
        self.style_data = Some(w.inner);
        self
    }
}

impl StyleData {
    pub(crate) fn new() -> StyleData {
        StyleData(Arc::default())
    }
}

impl StyleManager {
    pub(crate) fn style_data(&self) -> Option<impl DerefMut<Target = StyleData> + '_> {
        self.inner
            .style_data
            .as_ref()
            .map(|m| m.lock().expect("failed to lock style data"))
    }
}

impl StyleData {
    pub(super) fn as_vec_mut(&mut self) -> &mut Vec<StyleDataContent> {
        Arc::make_mut(&mut self.0)
    }
}