use crate::asset_paths::to_webp;
use crate::asset_snapshot::{AssetSnapshot, FALLBACK_HEIGHT, FALLBACK_WIDTH};
use crate::media::html_escape;
use std::collections::BTreeMap;
use std::path::PathBuf;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ImageContext<'a> {
MarkdownStandalone {
caption: Option<&'a str>,
width: Option<&'a str>,
align: Option<&'a str>,
class_names: &'a [String],
extra_attrs: &'a BTreeMap<String, String>,
},
MarkdownInline,
Hero,
FolderCardCover,
LinkPreview,
Favicon,
SiteLogo,
TrackingPixel,
EmailBody {
width: Option<u32>,
height: Option<u32>,
},
GalleryThumb,
HeroBare,
}
#[derive(Debug, Default, Clone)]
pub struct ImageRenderOptions<'a> {
pub eager: bool,
pub class: Option<&'a str>,
pub extra_attrs: Option<&'a str>,
}
pub fn synthesize_image_html(
src: &str,
alt: &str,
assets: &AssetSnapshot,
context: ImageContext<'_>,
options: &ImageRenderOptions<'_>,
) -> String {
if matches!(context, ImageContext::Favicon) {
let class_attr = options
.class
.map(|c| format!(r#" class="{}""#, html_escape(c)))
.unwrap_or_default();
return format!(
r#"<img{} src="{}" width="16" height="16" alt="{}">"#,
class_attr,
html_escape(src),
html_escape(alt),
);
}
if matches!(context, ImageContext::SiteLogo) {
return format!(
r#"<img class="site-logo" src="{}" alt="{}" aria-hidden="true">"#,
html_escape(src),
html_escape(alt),
);
}
if matches!(context, ImageContext::TrackingPixel) {
return format!(
r#"<img src="{}" alt="" width="1" height="1" />"#,
html_escape(src),
);
}
if matches!(context, ImageContext::HeroBare) {
let extra = options
.extra_attrs
.map(|s| format!(" {}", s))
.unwrap_or_default();
return format!(
r#"<img src="{}" alt="{}"{} />"#,
html_escape(src),
html_escape(alt),
extra,
);
}
if let ImageContext::EmailBody { width, height } = context {
let mut dims = String::new();
if let Some(w) = width {
dims.push_str(&format!(r#" width="{}""#, w));
}
if let Some(h) = height {
dims.push_str(&format!(r#" height="{}""#, h));
}
return format!(
r#"<img src="{}" alt="{}"{} style="display:block;max-width:100%;height:auto;" />"#,
html_escape(src),
html_escape(alt),
dims,
);
}
let inner = synthesize_inner(src, alt, assets, options);
match context {
ImageContext::MarkdownStandalone {
caption,
width,
align,
class_names,
extra_attrs,
} => wrap_in_figure_full(&inner, caption, width, align, class_names, extra_attrs),
_ => inner,
}
}
pub fn wrap_in_figure(
inner_html: &str,
caption: Option<&str>,
width: Option<&str>,
) -> String {
let empty_classes: &[String] = &[];
let empty_attrs: BTreeMap<String, String> = BTreeMap::new();
wrap_in_figure_full(inner_html, caption, width, None, empty_classes, &empty_attrs)
}
pub(super) fn wrap_in_figure_full(
inner_html: &str,
caption: Option<&str>,
width: Option<&str>,
align: Option<&str>,
class_names: &[String],
extra_attrs: &BTreeMap<String, String>,
) -> String {
let width_attr = width
.map(|w| format!(r#" data-width="{}""#, html_escape(w)))
.unwrap_or_default();
let mut class_value = String::from("moss-image");
if let Some(a) = align {
class_value.push(' ');
class_value.push_str(a);
}
for cn in class_names {
if cn.is_empty() {
continue;
}
class_value.push(' ');
class_value.push_str(cn);
}
let class_attr = format!(r#" class="{}""#, html_escape(&class_value));
let mut extra = String::new();
for (k, v) in extra_attrs {
extra.push(' ');
extra.push_str(k);
extra.push_str(r#"=""#);
extra.push_str(&html_escape(v));
extra.push('"');
}
match caption {
Some(text) => format!(
r#"<figure{class}{w}{extra}>{inner}<figcaption>{cap}</figcaption></figure>"#,
class = class_attr,
w = width_attr,
extra = extra,
inner = inner_html,
cap = html_escape(text),
),
None => format!(
r#"<figure{class}{w}{extra}>{inner}</figure>"#,
class = class_attr,
w = width_attr,
extra = extra,
inner = inner_html,
),
}
}
fn synthesize_inner(
src: &str,
alt: &str,
assets: &AssetSnapshot,
options: &ImageRenderOptions<'_>,
) -> String {
let img_tag = render_img_tag(src, alt, assets, options);
if is_raster_original(src) {
let srcset_path = to_webp(src);
format!(
r#"<picture><source srcset="{}" type="image/webp">{}</picture>"#,
html_escape(&srcset_path),
img_tag,
)
} else {
img_tag
}
}
fn is_raster_original(src: &str) -> bool {
let lower = src.to_ascii_lowercase();
lower.ends_with(".png") || lower.ends_with(".jpg") || lower.ends_with(".jpeg")
}
fn lookup_dims(assets: &AssetSnapshot, src: &str) -> Option<(u32, u32)> {
probe_paths(src, |p| assets.dims(&p))
}
fn lookup_lqip<'a>(assets: &'a AssetSnapshot, src: &str) -> Option<&'a str> {
probe_paths(src, |p| assets.lqip(&p))
}
fn lookup_color<'a>(assets: &'a AssetSnapshot, src: &str) -> Option<&'a String> {
probe_paths(src, |p| assets.dominant_color.get(&p))
}
fn probe_paths<T>(src: &str, mut probe: impl FnMut(PathBuf) -> Option<T>) -> Option<T> {
if let Some(v) = probe_normalized(src, &mut probe) {
return Some(v);
}
let decoded = percent_decode(src);
if decoded != src {
if let Some(v) = probe_normalized(&decoded, &mut probe) {
return Some(v);
}
}
None
}
fn probe_normalized<T>(src: &str, probe: &mut impl FnMut(PathBuf) -> Option<T>) -> Option<T> {
if let Some(v) = probe(PathBuf::from(src)) {
return Some(v);
}
let stripped = src.strip_prefix('/').unwrap_or(src);
if stripped != src {
if let Some(v) = probe(PathBuf::from(stripped)) {
return Some(v);
}
}
let mut s: &str = src;
while let Some(rest) = s.strip_prefix("./").or_else(|| s.strip_prefix("../")) {
s = rest;
}
if s != src {
if let Some(v) = probe(PathBuf::from(s)) {
return Some(v);
}
}
None
}
fn percent_decode(path: &str) -> String {
if !path.contains('%') {
return path.to_string();
}
let bytes = path.as_bytes();
let mut out = Vec::with_capacity(bytes.len());
let mut i = 0;
while i < bytes.len() {
if bytes[i] == b'%' && i + 2 < bytes.len() {
if let (Some(hi), Some(lo)) = (hex_val(bytes[i + 1]), hex_val(bytes[i + 2])) {
out.push((hi << 4) | lo);
i += 3;
continue;
}
}
out.push(bytes[i]);
i += 1;
}
String::from_utf8(out).unwrap_or_else(|_| path.to_string())
}
fn hex_val(b: u8) -> Option<u8> {
match b {
b'0'..=b'9' => Some(b - b'0'),
b'a'..=b'f' => Some(b - b'a' + 10),
b'A'..=b'F' => Some(b - b'A' + 10),
_ => None,
}
}
pub(crate) fn render_img_tag(
src: &str,
alt: &str,
assets: &AssetSnapshot,
options: &ImageRenderOptions<'_>,
) -> String {
let (width, height) = lookup_dims(assets, src).unwrap_or((FALLBACK_WIDTH, FALLBACK_HEIGHT));
let class_attr = options
.class
.map(|c| format!(r#" class="{}""#, html_escape(c)))
.unwrap_or_default();
let (loading_attr, fetchpriority_attr) = if options.eager {
(r#" loading="eager""#, r#" fetchpriority="high""#)
} else {
(r#" loading="lazy""#, "")
};
let extra_has_style = options
.extra_attrs
.map(|s| s.contains("style="))
.unwrap_or(false);
let style_attr = if extra_has_style {
String::new()
} else if let Some(lqip) = lookup_lqip(assets, src) {
format!(
r#" style="background-image:url({});background-size:cover""#,
lqip
)
} else if let Some(color) = lookup_color(assets, src) {
format!(r#" style="background-color:{}""#, color)
} else {
String::new()
};
let extra = options
.extra_attrs
.map(|s| format!(" {}", s))
.unwrap_or_default();
format!(
r#"<img{class_attr} src="{src_esc}" width="{w}" height="{h}"{loading}{fetch}{style} alt="{alt}"{extra} />"#,
class_attr = class_attr,
src_esc = html_escape(src),
w = width,
h = height,
loading = loading_attr,
fetch = fetchpriority_attr,
style = style_attr,
alt = html_escape(alt),
extra = extra,
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::asset_snapshot::VariantKindSet;
fn snapshot_with(
path: &str,
dims: Option<(u32, u32)>,
color: Option<&str>,
lqip: Option<&str>,
webp: bool,
) -> AssetSnapshot {
let mut s = AssetSnapshot::new();
let key = PathBuf::from(path);
if let Some(d) = dims {
s.dimensions.insert(key.clone(), d);
}
if let Some(c) = color {
s.dominant_color.insert(key.clone(), c.to_string());
}
if let Some(l) = lqip {
s.lqip.insert(key.clone(), l.to_string());
}
if webp {
let stem = crate::asset_snapshot::path_strip_extension(&key);
s.variants.insert(
stem,
VariantKindSet {
webp: true,
avif: false,
},
);
}
s
}
fn snapshot_dims(path: &str, w: u32, h: u32) -> AssetSnapshot {
snapshot_with(path, Some((w, h)), None, None, false)
}
#[test]
fn probe_paths_percent_decodes_src() {
let snap = snapshot_dims("assets/Europe - A Prophecy/e-006.jpg", 4515, 6158);
assert_eq!(
lookup_dims(&snap, "../../assets/Europe%20-%20A%20Prophecy/e-006.jpg"),
Some((4515, 6158))
);
}
#[test]
fn cover_slug_url_emits_real_dimensions_not_fallback() {
let mut snap = snapshot_dims("assets/Europe - A Prophecy/e-006.jpg", 4515, 6158);
snap.dimensions.insert(
PathBuf::from("assets/europe-a-prophecy/e-006.jpg"),
(4515, 6158),
);
let html = synthesize_image_html(
"/assets/europe-a-prophecy/e-006.jpg",
"cover",
&snap,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(
html.contains(r#"width="4515" height="6158""#),
"expected real dims, got: {html}"
);
assert!(
!html.contains(r#"width="800" height="600""#),
"800x600 fallback fired: {html}"
);
}
#[test]
fn picture_wrap_for_raster_original_no_lqip() {
let s = snapshot_dims("photo.jpg", 800, 600);
let html = synthesize_image_html(
"photo.jpg",
"A cat",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert_eq!(
html,
r#"<picture><source srcset="photo.webp" type="image/webp"><img src="photo.jpg" width="800" height="600" loading="lazy" alt="A cat" /></picture>"#
);
}
#[test]
fn picture_wrap_for_raster_original_with_lqip() {
let s = snapshot_with(
"photo.jpg",
Some((800, 600)),
None,
Some("data:image/jpeg;base64,abc"),
false,
);
let html = synthesize_image_html(
"photo.jpg",
"A cat",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert_eq!(
html,
r#"<picture><source srcset="photo.webp" type="image/webp"><img src="photo.jpg" width="800" height="600" loading="lazy" style="background-image:url(data:image/jpeg;base64,abc);background-size:cover" alt="A cat" /></picture>"#
);
}
#[test]
fn bare_img_with_dominant_color_no_lqip() {
let s = snapshot_with(
"photo.jpg",
Some((800, 600)),
Some("#aabbcc"),
None,
false,
);
let html = synthesize_image_html(
"photo.jpg",
"Cat",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(
html.contains(r#"style="background-color:#aabbcc""#),
"Got: {html}"
);
}
#[test]
fn picture_wrap_when_webp_exists() {
let s = snapshot_with("photo.jpg", Some((800, 600)), None, None, true);
let html = synthesize_image_html(
"photo.jpg",
"Cat",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(
html.starts_with(r#"<picture><source srcset="photo.webp" type="image/webp"><img"#),
"Got: {html}"
);
assert!(html.ends_with(r#"alt="Cat" /></picture>"#), "Got: {html}");
}
#[test]
fn picture_srcset_uses_to_webp_of_src_not_stored_variant() {
let s = snapshot_with("../assets/photo.jpg", Some((800, 600)), None, None, true);
let html = synthesize_image_html(
"../assets/photo.jpg",
"",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(
html.contains(r#"srcset="../assets/photo.webp""#),
"srcset should inherit src's prefix; got: {html}"
);
}
#[test]
fn eager_swaps_loading_attr_and_adds_fetchpriority() {
let s = snapshot_dims("photo.jpg", 1, 1);
let html = synthesize_image_html(
"photo.jpg",
"Hero",
&s,
ImageContext::Hero,
&ImageRenderOptions {
eager: true,
..Default::default()
},
);
assert!(
html.contains(r#"loading="eager" fetchpriority="high""#),
"Got: {html}"
);
assert!(!html.contains(r#"loading="lazy""#), "Got: {html}");
}
#[test]
fn favicon_is_bare_16x16_with_class() {
let s = AssetSnapshot::new();
let html = synthesize_image_html(
"https://example.com/favicon.ico",
"",
&s,
ImageContext::Favicon,
&ImageRenderOptions {
class: Some("link-preview-favicon"),
..Default::default()
},
);
assert_eq!(
html,
r#"<img class="link-preview-favicon" src="https://example.com/favicon.ico" width="16" height="16" alt="">"#
);
}
#[test]
fn synthesize_site_logo_basic_shape() {
let html = synthesize_image_html(
"assets/logo.png",
"",
&AssetSnapshot::new(),
ImageContext::SiteLogo,
&ImageRenderOptions::default(),
);
assert_eq!(
html,
r#"<img class="site-logo" src="assets/logo.png" alt="" aria-hidden="true">"#
);
}
#[test]
fn synthesize_site_logo_escapes_src() {
let html = synthesize_image_html(
r#"logo "with quotes".png"#,
"",
&AssetSnapshot::new(),
ImageContext::SiteLogo,
&ImageRenderOptions::default(),
);
assert!(
html.contains(r#"logo "with quotes".png"#),
"got: {html}"
);
}
#[test]
fn synthesize_site_logo_does_not_emit_picture_or_lqip() {
let mut snap = AssetSnapshot::new();
snap.lqip
.insert("logo.png".into(), "data:image/jpeg;base64,xxx".into());
let html = synthesize_image_html(
"logo.png",
"moss",
&snap,
ImageContext::SiteLogo,
&ImageRenderOptions::default(),
);
assert!(!html.contains("<picture"), "logo should not get picture wrap: {html}");
assert!(
!html.contains("background-image"),
"logo should not get LQIP: {html}"
);
assert!(
!html.contains("loading="),
"logo above-the-fold, no lazy-load: {html}"
);
}
#[test]
fn alt_with_quotes_is_escaped() {
let s = snapshot_dims("photo.jpg", 1, 1);
let html = synthesize_image_html(
"photo.jpg",
r#"Quote: "hi""#,
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(html.contains(r#"alt="Quote: "hi"""#), "Got: {html}");
}
#[test]
fn extra_attrs_passed_through_verbatim() {
let s = snapshot_dims("hero.jpg", 1920, 1080);
let html = synthesize_image_html(
"hero.jpg",
"",
&s,
ImageContext::Hero,
&ImageRenderOptions {
eager: true,
extra_attrs: Some(r#"data-cover-fit="cover""#),
..Default::default()
},
);
assert!(html.contains(r#"data-cover-fit="cover""#), "Got: {html}");
let alt_pos = html.find("alt=").unwrap();
let extra_pos = html.find("data-cover-fit=").unwrap();
assert!(extra_pos > alt_pos, "extra attrs should come after alt");
}
#[test]
fn lqip_style_suppressed_when_extra_attrs_has_style() {
let s = snapshot_with(
"hero.jpg",
Some((1920, 1080)),
None,
Some("data:image/jpeg;base64,abc"),
false,
);
let html = synthesize_image_html(
"hero.jpg",
"",
&s,
ImageContext::Hero,
&ImageRenderOptions {
eager: true,
extra_attrs: Some(r#"style="object-fit:cover;object-position:50% 50%""#),
..Default::default()
},
);
assert_eq!(
html.matches("style=").count(),
1,
"expected exactly one style= attribute; got: {html}"
);
assert!(
html.contains(r#"style="object-fit:cover"#),
"caller-supplied style must survive; got: {html}"
);
assert!(
!html.contains(r#"background-image:url(data:"#),
"LQIP must be suppressed when extra_attrs carries style=; got: {html}"
);
}
fn empty_extras() -> std::collections::BTreeMap<String, String> {
std::collections::BTreeMap::new()
}
#[test]
fn markdown_standalone_no_caption_wraps_in_figure() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"Alt text",
&s,
ImageContext::MarkdownStandalone {
caption: None,
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(html.starts_with(r#"<figure class="moss-image">"#));
assert!(html.ends_with("</figure>"));
assert!(!html.contains("<figcaption>"));
assert!(html.contains("<img"));
}
#[test]
fn markdown_standalone_with_caption_adds_figcaption() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"Alt text",
&s,
ImageContext::MarkdownStandalone {
caption: Some("A nice photo"),
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(html.starts_with(r#"<figure class="moss-image">"#));
assert!(html.contains("<figcaption>A nice photo</figcaption>"));
assert!(html.ends_with("</figure>"));
}
#[test]
fn markdown_standalone_caption_is_html_escaped() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"",
&s,
ImageContext::MarkdownStandalone {
caption: Some(r#"Q&A "best" of <em>2024</em>"#),
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(
html.contains("<figcaption>Q&A "best" of <em>2024</em></figcaption>"),
"caption text must be HTML-escaped at the boundary; got: {html}"
);
}
#[test]
fn markdown_standalone_wraps_picture_when_webp_present() {
let s = snapshot_with("photo.jpg", Some((1200, 800)), None, None, true);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"Alt",
&s,
ImageContext::MarkdownStandalone {
caption: Some("Cap"),
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
let fig_idx = html.find(r#"<figure class="moss-image">"#).expect("figure");
let pic_idx = html.find("<picture>").expect("picture");
let src_idx = html.find("<source").expect("source");
let img_idx = html.find("<img").expect("img");
let cap_idx = html.find("<figcaption>").expect("figcaption");
let fig_close = html.find("</figure>").expect("figure close");
assert!(fig_idx < pic_idx, "<picture> must be inside <figure>");
assert!(pic_idx < src_idx);
assert!(src_idx < img_idx);
assert!(img_idx < cap_idx, "<figcaption> follows <picture>");
assert!(cap_idx < fig_close);
}
#[test]
fn markdown_inline_does_not_wrap_in_figure() {
let s = snapshot_dims("photo.jpg", 800, 600);
let html = synthesize_image_html(
"photo.jpg",
"Alt",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(!html.contains("<figure"));
assert!(!html.contains("<figcaption>"));
}
#[test]
fn markdown_standalone_width_screen_emits_data_width_on_figure() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"",
&s,
ImageContext::MarkdownStandalone {
caption: None,
width: Some("screen"),
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(
html.starts_with(r#"<figure class="moss-image" data-width="screen">"#),
"data-width must sit on the figure wrapper; got: {html}"
);
assert!(
!html.contains(r#"<img"#) || !html[html.find("<img").unwrap()..].contains("data-width="),
"inner <img> must not carry data-width; got: {html}"
);
}
#[test]
fn markdown_standalone_width_wide_with_caption() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"Alt",
&s,
ImageContext::MarkdownStandalone {
caption: Some("A nice photo"),
width: Some("wide"),
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(html.contains(r#"data-width="wide""#), "got: {html}");
assert!(
html.contains("<figcaption>A nice photo</figcaption>"),
"got: {html}"
);
}
#[test]
fn markdown_standalone_width_none_omits_data_width() {
let s = snapshot_dims("photo.jpg", 800, 600);
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"",
&s,
ImageContext::MarkdownStandalone {
caption: None,
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(!html.contains("data-width="), "got: {html}");
}
#[test]
fn wrap_in_figure_width_emits_data_width_attribute() {
let html = wrap_in_figure(r#"<img src="x" />"#, None, Some("page"));
assert_eq!(
html,
r#"<figure class="moss-image" data-width="page"><img src="x" /></figure>"#
);
}
#[test]
fn wrap_in_figure_width_with_caption() {
let html = wrap_in_figure(r#"<img src="x" />"#, Some("hello"), Some("screen"));
assert_eq!(
html,
r#"<figure class="moss-image" data-width="screen"><img src="x" /><figcaption>hello</figcaption></figure>"#
);
}
#[test]
fn wrap_in_figure_no_width_no_attribute() {
let html = wrap_in_figure(r#"<img src="x" />"#, None, None);
assert_eq!(
html,
r#"<figure class="moss-image"><img src="x" /></figure>"#
);
}
#[test]
fn markdown_standalone_no_manifest_still_wraps_in_figure() {
let s = AssetSnapshot::new();
let extras = empty_extras();
let html = synthesize_image_html(
"photo.jpg",
"Alt",
&s,
ImageContext::MarkdownStandalone {
caption: Some("Cap"),
width: None,
align: None,
class_names: &[],
extra_attrs: &extras,
},
&ImageRenderOptions::default(),
);
assert!(html.starts_with(r#"<figure class="moss-image">"#));
assert!(html.contains("<img"));
assert!(html.contains("<figcaption>Cap</figcaption>"));
assert!(html.ends_with("</figure>"));
}
#[test]
fn missing_dimensions_fall_back_to_800x600() {
let s = AssetSnapshot::new();
let html = synthesize_image_html(
"ghost.jpg",
"",
&s,
ImageContext::MarkdownInline,
&ImageRenderOptions::default(),
);
assert!(html.contains(r#"width="800" height="600""#), "Got: {html}");
}
#[test]
fn synthesize_tracking_pixel_basic() {
let html = synthesize_image_html(
"https://api.mosspub.com/pixel.gif?u=abc",
"",
&AssetSnapshot::new(),
ImageContext::TrackingPixel,
&ImageRenderOptions::default(),
);
assert_eq!(
html,
r#"<img src="https://api.mosspub.com/pixel.gif?u=abc" alt="" width="1" height="1" />"#
);
}
#[test]
fn synthesize_tracking_pixel_escapes_url() {
let html = synthesize_image_html(
r#"x.gif?u=a&b="c""#,
"",
&AssetSnapshot::new(),
ImageContext::TrackingPixel,
&ImageRenderOptions::default(),
);
assert!(html.contains("&"), "& must be escaped");
assert!(html.contains("""), "\" must be escaped");
}
#[test]
fn synthesize_tracking_pixel_no_lazy_no_lqip() {
let mut snap = AssetSnapshot::new();
snap.lqip.insert(
"pixel.gif".into(),
"data:image/jpeg;base64,xxx".into(),
);
let html = synthesize_image_html(
"pixel.gif",
"",
&snap,
ImageContext::TrackingPixel,
&ImageRenderOptions::default(),
);
assert!(
!html.contains("loading=\"lazy\""),
"must NOT lazy-load (must fire on read)"
);
assert!(
!html.contains("background-image"),
"must NOT carry LQIP"
);
assert!(
!html.contains("<picture"),
"must NOT wrap in picture"
);
}
#[test]
fn synthesize_email_body_with_dims() {
let html = synthesize_image_html(
"https://media.example.com/photo.jpg",
"Cover",
&AssetSnapshot::new(),
ImageContext::EmailBody {
width: Some(600),
height: Some(400),
},
&ImageRenderOptions::default(),
);
assert!(html.contains(r#"width="600""#));
assert!(html.contains(r#"height="400""#));
assert!(html.contains(r#"style="display:block;max-width:100%;height:auto;""#));
}
#[test]
fn synthesize_email_body_without_dims() {
let html = synthesize_image_html(
"x.jpg",
"alt",
&AssetSnapshot::new(),
ImageContext::EmailBody {
width: None,
height: None,
},
&ImageRenderOptions::default(),
);
assert!(!html.contains("width="), "width should be omitted when None");
assert!(!html.contains("height="), "height should be omitted when None");
}
#[test]
fn synthesize_email_body_no_picture_no_data() {
let html = synthesize_image_html(
"photo.jpg",
"alt",
&AssetSnapshot::new(),
ImageContext::EmailBody {
width: None,
height: None,
},
&ImageRenderOptions::default(),
);
assert!(!html.contains("<picture"), "email images must not use <picture>");
assert!(!html.contains("<source"), "no <source>");
assert!(!html.contains("data-"), "no data-* (email clients strip)");
assert!(!html.contains("loading="), "email clients ignore loading attr");
assert!(
!html.contains("background-image"),
"email clients strip inline style URLs"
);
}
#[test]
fn synthesize_email_body_escapes() {
let html = synthesize_image_html(
r#"https://x.com/photo.jpg?a=1&b=2"#,
r#"alt with "quotes""#,
&AssetSnapshot::new(),
ImageContext::EmailBody {
width: None,
height: None,
},
&ImageRenderOptions::default(),
);
assert!(html.contains("&"), "& must be escaped");
assert!(html.contains("""), "\" must be escaped");
}
#[test]
fn synthesize_gallery_thumb_emits_picture_with_lazy() {
let p = ImageRenderOptions::default();
let mut snap = AssetSnapshot::new();
snap.dimensions
.insert(PathBuf::from("photo.jpg"), (1200, 800));
let out = synthesize_image_html(
"photo.jpg",
"alt",
&snap,
ImageContext::GalleryThumb,
&p,
);
assert!(out.contains("<picture"), "{out}");
assert!(out.contains(r#"srcset="photo.webp""#), "{out}");
assert!(out.contains(r#"loading="lazy""#), "{out}");
assert!(out.contains(r#"width="1200""#), "{out}");
assert!(out.contains(r#"height="800""#), "{out}");
assert!(out.contains(r#"alt="alt""#), "{out}");
}
#[test]
fn synthesize_gallery_thumb_non_raster_bare_img() {
let p = ImageRenderOptions::default();
let mut snap = AssetSnapshot::new();
snap.dimensions
.insert(PathBuf::from("icon.svg"), (64, 64));
let out = synthesize_image_html(
"icon.svg",
"",
&snap,
ImageContext::GalleryThumb,
&p,
);
assert!(!out.contains("<picture"), "{out}");
assert!(!out.contains("<source"), "{out}");
assert!(out.contains(r#"loading="lazy""#), "{out}");
assert!(out.contains(r#"width="64""#), "{out}");
}
#[test]
fn synthesize_gallery_thumb_threads_extra_attrs() {
let snap = snapshot_with(
"photo.jpg",
Some((1200, 800)),
None,
Some("data:image/jpeg;base64,abc"),
false,
);
let opts = ImageRenderOptions {
extra_attrs: Some(r#"style="object-position:50% 50%""#),
..Default::default()
};
let out = synthesize_image_html(
"photo.jpg",
"",
&snap,
ImageContext::GalleryThumb,
&opts,
);
assert_eq!(
out.matches("style=").count(),
1,
"expected exactly one style= attribute; got: {out}"
);
assert!(
out.contains(r#"style="object-position:50% 50%""#),
"caller-supplied style must survive; got: {out}"
);
}
#[test]
fn synthesize_hero_bare_basic_shape() {
let out = synthesize_image_html(
"cover.jpg",
"",
&AssetSnapshot::new(),
ImageContext::HeroBare,
&ImageRenderOptions::default(),
);
assert_eq!(out, r#"<img src="cover.jpg" alt="" />"#, "got: {}", out);
}
#[test]
fn synthesize_hero_bare_with_style_via_extra_attrs() {
let out = synthesize_image_html(
"cover.jpg",
"",
&AssetSnapshot::new(),
ImageContext::HeroBare,
&ImageRenderOptions {
extra_attrs: Some(r#"style="object-fit:cover;object-position:50% 50%""#),
..Default::default()
},
);
assert_eq!(
out,
r#"<img src="cover.jpg" alt="" style="object-fit:cover;object-position:50% 50%" />"#,
"got: {}",
out
);
}
#[test]
fn synthesize_hero_bare_with_lqip_in_snapshot_still_bare() {
let mut snap = AssetSnapshot::new();
snap.lqip
.insert("cover.jpg".into(), "data:image/jpeg;base64,xxx".into());
snap.dimensions.insert("cover.jpg".into(), (1920, 1080));
let out = synthesize_image_html(
"cover.jpg",
"",
&snap,
ImageContext::HeroBare,
&ImageRenderOptions::default(),
);
assert!(!out.contains("<picture"), "got: {}", out);
assert!(!out.contains("<source"), "got: {}", out);
assert!(!out.contains("background-image"), "got: {}", out);
assert!(!out.contains("width="), "got: {}", out);
assert!(!out.contains("height="), "got: {}", out);
assert!(!out.contains("loading="), "got: {}", out);
}
#[test]
fn synthesize_hero_bare_escapes_url() {
let out = synthesize_image_html(
r#"x.jpg?a=1&b="c""#,
"",
&AssetSnapshot::new(),
ImageContext::HeroBare,
&ImageRenderOptions::default(),
);
assert!(out.contains("&"), "& must be escaped; got: {}", out);
assert!(out.contains("""), "\" must be escaped; got: {}", out);
}
#[test]
fn synthesize_hero_bare_byte_shape_matches_legacy_fallback() {
let href = "covers/img.jpg";
let style_fragment = r#" style="object-fit:contain""#;
let legacy = format!(
"<img src=\"{}\" alt=\"\"{} />",
html_escape(href),
style_fragment,
);
let pr2 = synthesize_image_html(
href,
"",
&AssetSnapshot::new(),
ImageContext::HeroBare,
&ImageRenderOptions {
extra_attrs: Some(style_fragment.trim_start()),
..Default::default()
},
);
assert_eq!(pr2, legacy, "byte shape divergence: pr2={} legacy={}", pr2, legacy);
}
}