prest 0.5.1

Progressive RESTful framework
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use crate::*;

static DEFAULT_CSS: PreEscaped<&str> =
    PreEscaped(include_str!(concat!(env!("OUT_DIR"), "/default.css")));

/// Renders into a `<head>` tag with builder-like interface
pub struct Head<'a> {
    title: &'a str,
    styles: Option<Vec<PreEscaped<&'a str>>>,
    stylesheets: Option<Vec<&'a str>>,
    favicon: Option<&'a str>,
    webmanifest: Option<&'a str>,
    viewport: Option<&'a str>,
    theme_color: Option<&'a str>,
    other: Option<Markup>,
}

impl<'a> Head<'a> {
    /// Add custom markup to the [`Head`]
    pub fn with(mut self, other: Markup) -> Self {
        self.other = Some(other);
        self
    }
    /// Set title in the [`Head`]
    pub fn title(mut self, title: &'a str) -> Self {
        self.title = title;
        self
    }
    /// Add stylesheet link to the [`Head`]
    pub fn css(mut self, path: &'a str) -> Self {
        if let Some(stylesheets) = &mut self.stylesheets {
            stylesheets.push(path)
        } else {
            self.stylesheets = Some(vec![path]);
        }
        self
    }
    /// Add inline css to the [`Head`]
    pub fn style(mut self, style: PreEscaped<&'a str>) -> Self {
        if let Some(styles) = &mut self.styles {
            styles.push(style)
        } else {
            self.styles = Some(vec![style]);
        }
        self
    }
    /// Builds a default [`Head`] with provided title
    pub fn with_title(title: &'a str) -> Self {
        Self::default().title(title)
    }
}

impl<'a> Default for Head<'a> {
    fn default() -> Self {
        let webmanifest = match is_pwa() {
            true => Some("/.webmanifest"),
            false => None,
        };
        Self {
            title: "Prest app",
            viewport: Some("width=device-width, initial-scale=1.0"),
            webmanifest,
            styles: None,
            stylesheets: None,
            favicon: None,
            theme_color: None,
            other: None,
        }
    }
}

impl<'a> Render for Head<'a> {
    fn render(&self) -> Markup {
        html!(
            head {
                title {(self.title)}
                @if let Some(href) = self.favicon { link rel="icon" href=(href) {} }
                @if let Some(href) = self.webmanifest { link rel="manifest" href=(href) {} }
                @if let Some(viewport) = self.viewport { meta name="viewport" content=(viewport); }
                @if let Some(color) = self.theme_color { meta name="theme-color" content=(color); }
                @if let Some(stylesheets) = &self.stylesheets { @for stylesheet in stylesheets {link href={(stylesheet)} rel="stylesheet"{}}}
                style {(DEFAULT_CSS)}
                @if let Some(styles) = &self.styles { @for style in styles { style {(style)}}}
                @if let Some(markup) = &self.other {(markup)}
            }
        )
    }
}

/// Renders into a bunch of `<script>` tags with builder-like interface
pub struct Scripts<'a> {
    pub default_bundle: bool,
    pub others: Option<Vec<&'a str>>,
    pub inlines: Option<Vec<&'a str>>,
    pub stylesheets: Option<Vec<&'a str>>,
    pub hyperscripts: Option<Vec<&'a str>>,
}

impl<'a> Default for Scripts<'a> {
    fn default() -> Self {
        Self {
            default_bundle: true,
            others: None,
            inlines: None,
            // inlines: Some(vec![include_str!("./htmx_patch.js")]),
            stylesheets: None,
            hyperscripts: None,
        }
    }
}

impl<'a> Scripts<'a> {
    /// Add script src to the [`Scripts`]
    pub fn include(mut self, path: &'a str) -> Self {
        if let Some(srcs) = &mut self.others {
            srcs.push(path)
        } else {
            self.others = Some(vec![path])
        }
        self
    }
    /// Add inline js to the [`Scripts`]
    pub fn inline(mut self, script: &'a str) -> Self {
        if let Some(scripts) = &mut self.inlines {
            scripts.push(script)
        } else {
            self.inlines = Some(vec![script])
        }
        self
    }
    /// Add stylesheet link to the [`Scripts`]
    pub fn css(mut self, path: &'a str) -> Self {
        if let Some(stylesheets) = &mut self.stylesheets {
            stylesheets.push(path)
        } else {
            self.stylesheets = Some(vec![path]);
        }
        self
    }
    /// Add inline hyperscipt to the [`Scripts`]
    pub fn hyperscript(mut self, script: &'a str) -> Self {
        if let Some(scripts) = &mut self.hyperscripts {
            scripts.push(script)
        } else {
            self.hyperscripts = Some(vec![script])
        }
        self
    }
}

impl<'a> Render for Scripts<'a> {
    fn render(&self) -> Markup {
        html!(
            @if is_pwa() { script {(REGISTER_SW_SNIPPET)} }
            @if let Some(stylesheets) = &self.stylesheets { @for stylesheet in stylesheets {
                link rel="preload" href={(stylesheet)} as="style" onload="this.onload=null;this.rel='stylesheet'" {}
                noscript { link rel="stylesheet" href={(stylesheet)} {}}
            }}
            @if self.default_bundle {
                script src="/prest.js" {}
            }
            @if let Some(srcs) = &self.others { @for src in srcs {
                script src={(src)} crossorigin {}
            }}
            @if let Some(scripts) = &self.inlines { @for script in scripts {
                script {(PreEscaped(script))}
            }}
            @if let Some(scripts) = &self.hyperscripts { @for script in scripts {
                script type="text/hyperscript" {(PreEscaped(script))}
            }}
        )
    }
}