use std::fmt;
use i18n_core::{Direction, LocaleTag, locale_tag};
use renderer_dom::escape_html;
use telar_project::{
ASSETS_META_NAME, FONT_FAMILY_ATTRIBUTE, FontDeclaration, PageRenderer, STATE_ELEMENT_ID,
};
use super::fonts::font_face;
use crate::runner::cli::WebRenderer;
pub(crate) const DEFAULT_TEMPLATE: &str = include_str!("default_page.html");
const MARKER_OPEN: &str = "%telar.";
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Marker {
Lang,
Dir,
Title,
Renderer,
Host,
Meta,
Fonts,
Bootstrap,
Prerendered,
State,
}
impl Marker {
pub(crate) const ALL: [Self; 10] = [
Self::Lang,
Self::Dir,
Self::Title,
Self::Renderer,
Self::Host,
Self::Meta,
Self::Fonts,
Self::Bootstrap,
Self::Prerendered,
Self::State,
];
pub(crate) fn name(self) -> &'static str {
match self {
Self::Lang => "lang",
Self::Dir => "dir",
Self::Title => "title",
Self::Renderer => "renderer",
Self::Host => "host",
Self::Meta => "meta",
Self::Fonts => "fonts",
Self::Bootstrap => "bootstrap",
Self::Prerendered => "prerendered",
Self::State => "state",
}
}
fn from_name(name: &str) -> Option<Self> {
Self::ALL.into_iter().find(|marker| marker.name() == name)
}
fn is_block(self) -> bool {
!matches!(
self,
Self::Lang | Self::Dir | Self::Title | Self::Renderer | Self::Host
)
}
fn appears_once(self) -> bool {
self.is_block() || self == Self::Host
}
}
impl fmt::Display for Marker {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{MARKER_OPEN}{}%", self.name())
}
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum TemplateError {
Unknown { name: String, line: usize },
Repeated(Marker),
Missing(Marker),
}
impl fmt::Display for TemplateError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Unknown { name, line } => {
let known: Vec<String> = Marker::ALL.iter().map(Marker::to_string).collect();
write!(
f,
"line {line}: `{MARKER_OPEN}{name}%` is not a marker; the markers are {}",
known.join(", ")
)
}
Self::Repeated(marker) => write!(f, "`{marker}` appears more than once"),
Self::Missing(Marker::Bootstrap) => write!(
f,
"`{}` is missing, so the page would never load the app; put it in `<head>` or before `</body>`",
Marker::Bootstrap
),
Self::Missing(marker) => write!(
f,
"`{marker}` is missing, and this build has content for it that would be dropped"
),
}
}
}
fn direction_str(direction: Direction) -> &'static str {
if direction.is_rtl() { "rtl" } else { "ltr" }
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct HeadTag {
element: &'static str,
attributes: Vec<(String, String)>,
}
impl HeadTag {
pub(crate) fn meta(name: impl Into<String>, content: impl Into<String>) -> Self {
Self::bare("meta")
.attr("name", name)
.attr("content", content)
}
pub(crate) fn link(rel: impl Into<String>, href: impl Into<String>) -> Self {
Self::bare("link").attr("rel", rel).attr("href", href)
}
pub(crate) fn property(property: impl Into<String>, content: impl Into<String>) -> Self {
Self::bare("meta")
.attr("property", property)
.attr("content", content)
}
pub(crate) fn base(href: impl Into<String>) -> Self {
Self::bare("base").attr("href", href)
}
pub(crate) fn font_preload(href: impl Into<String>, media_type: impl Into<String>) -> Self {
Self::link("preload", href)
.attr("as", "font")
.attr("type", media_type)
.attr("crossorigin", "")
}
pub(crate) fn attr(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.attributes.push((name.into(), value.into()));
self
}
fn bare(element: &'static str) -> Self {
Self {
element,
attributes: Vec::new(),
}
}
pub(super) fn html(&self) -> String {
let mut html = format!("<{}", self.element);
for (name, value) in &self.attributes {
html.push(' ');
html.push_str(&escape_html(name));
if !value.is_empty() {
html.push_str(&format!("=\"{}\"", escape_html(value)));
}
}
html.push_str(" />");
html
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct Bootstrap {
pub(crate) glue: String,
pub(crate) module: String,
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct PageFont {
pub(crate) declaration: FontDeclaration,
pub(crate) path: String,
pub(crate) preload: Option<String>,
}
#[derive(Clone, Debug)]
pub(crate) struct Page {
pub(crate) lang: LocaleTag,
pub(crate) dir: Direction,
pub(crate) title: String,
pub(crate) meta: Vec<HeadTag>,
pub(crate) head: Vec<String>,
pub(crate) fonts: Vec<PageFont>,
pub(crate) host: String,
pub(crate) bootstrap: Bootstrap,
pub(crate) renderer: WebRenderer,
pub(crate) prerendered: String,
pub(crate) state: Option<serde_json::Value>,
pub(crate) base: String,
}
impl Page {
pub(crate) fn new(title: impl Into<String>, bootstrap: Bootstrap) -> Self {
Self {
lang: locale_tag!("en"),
dir: Direction::default(),
title: title.into(),
meta: Vec::new(),
head: Vec::new(),
fonts: Vec::new(),
host: String::new(),
bootstrap,
renderer: WebRenderer::Dom,
prerendered: String::new(),
state: None,
base: "/".to_string(),
}
}
pub(crate) fn url(&self, path: &str) -> String {
format!("{}{path}", self.base)
}
pub(crate) fn render(&self, template: &str) -> Result<String, TemplateError> {
let found = markers_in(template)?;
self.check(&found)?;
let mut out = String::with_capacity(template.len() * 2);
let mut cursor = 0;
for (start, marker) in found {
out.push_str(&template[cursor..start]);
let after = start + marker.to_string().len();
cursor = after;
let expansion = self.expand(marker);
if !marker.is_block() {
out.push_str(&expansion);
continue;
}
let line_start = out.rfind('\n').map_or(0, |i| i + 1);
let indent = &out[line_start..];
let rest_of_line = template[after..].split('\n').next().unwrap_or_default();
let alone = indent.trim().is_empty() && rest_of_line.trim().is_empty();
if alone && expansion.is_empty() {
out.truncate(line_start);
cursor = (after + rest_of_line.len() + 1).min(template.len());
continue;
}
let indent = if indent.trim().is_empty() {
indent.to_string()
} else {
String::new()
};
out.push_str(&expansion.replace('\n', &format!("\n{indent}")));
}
out.push_str(&template[cursor..]);
Ok(out)
}
fn check(&self, found: &[(usize, Marker)]) -> Result<(), TemplateError> {
for marker in Marker::ALL {
let count = found.iter().filter(|(_, m)| *m == marker).count();
if marker.appears_once() && count > 1 {
return Err(TemplateError::Repeated(marker));
}
if count == 0 && self.must_appear(marker) {
return Err(TemplateError::Missing(marker));
}
}
Ok(())
}
fn must_appear(&self, marker: Marker) -> bool {
match marker {
Marker::Bootstrap => true,
Marker::Fonts => !self.fonts.is_empty(),
Marker::Host => !self.host.is_empty(),
Marker::Prerendered => !self.prerendered.is_empty(),
Marker::State => self.state.is_some(),
_ => false,
}
}
fn expand(&self, marker: Marker) -> String {
match marker {
Marker::Lang => escape_html(&self.lang.to_string()).into_owned(),
Marker::Dir => direction_str(self.dir).to_string(),
Marker::Title => escape_html(&self.title).into_owned(),
Marker::Renderer => PageRenderer::from(self.renderer).as_str().to_string(),
Marker::Host => self.host.clone(),
Marker::Meta => {
let mut parts = vec![lines(&self.meta)];
parts.extend(self.head.iter().cloned());
parts.retain(|part| !part.is_empty());
parts.join("\n")
}
Marker::Fonts => self.fonts(),
Marker::Bootstrap => self.bootstrap(),
Marker::Prerendered => self.prerendered.clone(),
Marker::State => self
.state
.as_ref()
.map(|state| {
format!(
"<script type=\"application/json\" id=\"{STATE_ELEMENT_ID}\">{}</script>",
script_json(state)
)
})
.unwrap_or_default(),
}
}
fn fonts(&self) -> String {
let preloads: Vec<HeadTag> = self
.fonts
.iter()
.filter_map(|font| {
let media_type = font.preload.as_ref()?;
Some(
HeadTag::font_preload(self.url(&font.path), media_type.clone())
.attr(FONT_FAMILY_ATTRIBUTE, font.declaration.family.clone()),
)
})
.collect();
let faces: String = self
.fonts
.iter()
.map(|font| font_face(&font.declaration, &self.url(&font.path)))
.collect();
let mut parts = vec![lines(&preloads)];
if !faces.is_empty() {
parts.push(format!("<style>\n{}\n</style>", faces.trim_end()));
}
parts.retain(|part| !part.is_empty());
parts.join("\n")
}
fn bootstrap(&self) -> String {
let glue = self.url(&self.bootstrap.glue);
let module = self.url(&self.bootstrap.module);
let preloads = lines(&[
HeadTag::meta(ASSETS_META_NAME, self.base.clone()),
HeadTag::link("modulepreload", glue.clone()),
HeadTag::link("preload", module)
.attr("as", "fetch")
.attr("type", "application/wasm")
.attr("crossorigin", ""),
]);
format!(
"{preloads}\n<script type=\"module\">\n import init from {};\n const wasm = await init();\n wasm.telar_start();\n</script>",
script_json(&serde_json::Value::String(glue))
)
}
}
fn markers_in(template: &str) -> Result<Vec<(usize, Marker)>, TemplateError> {
let mut found = Vec::new();
for (start, _) in template.match_indices(MARKER_OPEN) {
let rest = &template[start + MARKER_OPEN.len()..];
let name_len = rest
.find(|c: char| !(c.is_ascii_lowercase() || c == '_'))
.unwrap_or(rest.len());
if name_len == 0 || !rest[name_len..].starts_with('%') {
continue;
}
let name = &rest[..name_len];
let marker = Marker::from_name(name).ok_or_else(|| TemplateError::Unknown {
name: name.to_string(),
line: template[..start].matches('\n').count() + 1,
})?;
found.push((start, marker));
}
Ok(found)
}
fn lines(tags: &[HeadTag]) -> String {
tags.iter()
.map(HeadTag::html)
.collect::<Vec<_>>()
.join("\n")
}
pub(super) fn script_json(value: &serde_json::Value) -> String {
value.to_string().replace('<', "\\u003c")
}
#[cfg(test)]
#[path = "page.test.rs"]
mod tests;