tidos 0.7.6

Tidos is a component framework that can be served by any web 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

use std::collections::HashSet;
#[cfg(feature = "i18n")]
use unic_langid::LanguageIdentifier;
#[cfg(feature = "i18n")]
use unic_langid::LanguageIdentifierError;

#[cfg(feature = "rocket")]
mod rocket_impl;

#[cfg(feature = "axum")]
mod axum_impl;

#[cfg(feature = "actix-web")]
mod actix_web_impl;

#[cfg(feature = "warp")]
mod warp_impl;

/// A fully rendered page ready to be returned from a route handler.
///
/// `Page` accumulates the rendered HTML body and any `<head>` elements (such
/// as `<style>` blocks from [`scoped_css!`](macro@crate::scoped_css) or custom
/// tags from [`head!`](macro@crate::head)). When the `rocket` feature is
/// enabled, `Page` implements Rocket's `Responder` and produces a complete
/// `<!doctype html>` document.
///
/// You rarely construct `Page` directly — the
/// [`page!`](macro@crate::page) macro creates one for you and returns it
/// from the route handler.
#[cfg(not(feature = "i18n"))]
pub struct Page {
	/// Tracks which `<head>` element IDs have already been injected, to avoid
	/// duplicates (e.g. when a component is rendered in a loop).
	pub head_ids: HashSet<&'static str>,
	/// Accumulated HTML content for the `<head>` element.
	pub head: String,
	/// Accumulated HTML content for the `<body>` element.
	pub template: String,
}

/// A fully rendered page ready to be returned from a route handler.
///
/// `Page` accumulates the rendered HTML body and any `<head>` elements (such
/// as `<style>` blocks from [`scoped_css!`](macro@crate::scoped_css) or custom
/// tags from [`head!`](macro@crate::head)). When a web framework feature is
/// enabled, `Page` implements that framework's response trait and produces a
/// complete `<!doctype html>` document with the correct `lang` attribute set
/// from the negotiated locale.
///
/// You rarely construct `Page` directly — the
/// [`page!`](macro@crate::page) macro creates one for you and returns it
/// from the route handler.
#[cfg(feature = "i18n")]
pub struct Page {
	/// Tracks which `<head>` element IDs have already been injected, to avoid
	/// duplicates (e.g. when a component is rendered in a loop).
	pub head_ids: HashSet<&'static str>,
	/// The negotiated locale for this page, used in the `<html lang="…">` attribute.
	pub lang: LanguageIdentifier,
	/// Accumulated HTML content for the `<head>` element.
	pub head: String,
	/// Accumulated HTML content for the `<body>` element.
	pub template: String,
}

impl Page {
	/// Creates a new, empty [`Page`].
	///
	/// Called internally by the [`page!`](macro@crate::page) macro.
	#[cfg(not(feature = "i18n"))]
	#[allow(clippy::new_without_default)]
	pub fn new() -> Page {
		Page {
			head_ids: HashSet::new(),
			head: String::new(),
			template: String::new(),
		}
	}

	/// Creates a new, empty [`Page`] for the given locale.
	///
	/// Called internally by the [`page!`](macro@crate::page) macro when the
	/// `i18n` feature is enabled. The `lang` value is extracted from the route
	/// parameter by [`Lang`].
	#[cfg(feature = "i18n")]
	pub fn new(lang: LanguageIdentifier) -> Page {
		Page {
			head_ids: HashSet::new(),
			lang,
			head: String::new(),
			template: String::new(),
		}
	}

	/// Injects `element` into the page `<head>`, keyed by `id`.
	///
	/// If `id` has already been inserted the element is silently ignored,
	/// which makes it safe to call this method from components rendered inside
	/// a loop (e.g. via [`scoped_css!`](macro@crate::scoped_css)).
	pub fn add_elements_to_head(&mut self, id: &'static str, element: String) {
		if self.head_ids.insert(id) {
			self.head += &element;
		}
	}
}

/// A request guard / extractor that parses a locale from a URL path segment.
///
/// Available whenever the `i18n` feature is enabled. Framework-specific
/// extractor implementations are provided by the `rocket`, `axum`, and
/// `actix-web` features. For `warp`, `Lang` implements [`std::str::FromStr`]
/// so it works directly with `warp::path::param::<Lang>()` and
/// `warp::header::<Lang>("accept-language")`.
///
/// The locale string (e.g. `"en-US"`, `"nl-NL"`) is parsed into a
/// [`LanguageIdentifier`] and made available on the [`Page`] so that
/// [`i18n!`](crate::i18n::i18n) can resolve translations.
///
/// **Rocket** — use as a `FromParam` route parameter: `#[get("/<lang>")]`.
///
/// **Axum** — use as a `FromRequestParts` extractor; route must have a
/// `:lang` path segment (e.g. `"/:lang"`).
///
/// **Actix Web** — use as a `FromRequest` extractor; route must have a
/// `{lang}` path segment (e.g. `"/{lang}"`).
///
/// **Warp** — use `warp::path::param::<Lang>()` or
/// `warp::header::<Lang>("accept-language")`.
#[cfg(feature = "i18n")]
pub struct Lang(pub LanguageIdentifier);

#[cfg(feature = "i18n")]
impl std::str::FromStr for Lang {
	type Err = LanguageIdentifierError;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		s.parse::<LanguageIdentifier>().map(Lang)
	}
}

#[cfg(all(feature = "rocket", feature = "i18n"))]
impl<'a> ::rocket::request::FromParam<'a> for Lang {
	type Error = LanguageIdentifierError;

	fn from_param(param: &'a str) -> Result<Self, Self::Error> {
		match LanguageIdentifier::from_bytes(param.as_bytes()) {
			Ok(id) => Ok(Self(id)),
			Err(error) => Err(error),
		}
	}
}