use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CssTextScalar {
DocumentSpace,
Tab,
SegmentBreak,
CarriageReturn,
MandatoryLineBreak(char),
VisibleControl(VisibleControlCharacter),
Text(char),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct VisibleControlCharacter(pub(super) char);
impl VisibleControlCharacter {
pub(crate) const fn synthesized_glyph(self) -> char {
'\u{25a0}'
}
}
pub(crate) fn classify_css_text_scalar(character: char) -> CssTextScalar {
match character {
' ' => CssTextScalar::DocumentSpace,
'\t' => CssTextScalar::Tab,
'\n' => CssTextScalar::SegmentBreak,
'\r' => CssTextScalar::CarriageReturn,
character if character_is_mandatory_line_break(character) => {
CssTextScalar::MandatoryLineBreak(character)
}
character if character_is_unicode_control(character) => {
CssTextScalar::VisibleControl(VisibleControlCharacter(character))
}
character => CssTextScalar::Text(character),
}
}
pub(crate) fn css_text_rendering_text(text: &str) -> String {
text.chars()
.map(|character| match classify_css_text_scalar(character) {
CssTextScalar::CarriageReturn => ' ',
CssTextScalar::MandatoryLineBreak(character) => character,
CssTextScalar::VisibleControl(control) => control.synthesized_glyph(),
CssTextScalar::DocumentSpace => ' ',
CssTextScalar::Tab => '\t',
CssTextScalar::SegmentBreak => '\n',
CssTextScalar::Text(character) => character,
})
.collect()
}
pub(crate) fn is_css_collapsible_whitespace(character: char) -> bool {
matches!(character, ' ' | '\t' | '\n' | '\r')
}
pub(crate) fn is_css_preserved_document_space(character: char) -> bool {
matches!(character, ' ' | '\t')
}
pub(crate) fn text_is_css_collapsible_whitespace(text: &str) -> bool {
text.chars().all(is_css_collapsible_whitespace)
}
pub(crate) fn trim_css_collapsible_whitespace(text: &str) -> &str {
text.trim_matches(is_css_collapsible_whitespace)
}
pub(crate) fn trim_start_css_collapsible_whitespace(text: &str) -> &str {
text.trim_start_matches(is_css_collapsible_whitespace)
}
pub(crate) fn trim_end_css_collapsible_whitespace(text: &str) -> &str {
text.trim_end_matches(is_css_collapsible_whitespace)
}
#[cfg(test)]
pub(crate) fn collapse_css_collapsible_whitespace(text: &str) -> String {
let text = trim_css_collapsible_whitespace(text);
let mut output = String::with_capacity(text.len());
let mut in_whitespace = false;
for character in text.chars() {
if is_css_collapsible_whitespace(character) {
if !in_whitespace {
output.push(' ');
}
in_whitespace = true;
} else {
output.push(character);
in_whitespace = false;
}
}
output
}
#[cfg(test)]
pub(crate) fn trim_trailing_css_hanging_space_separators<'a>(
text: &'a str,
style: &ComputedStyle,
) -> &'a str {
if !style.white_space.hangs_trailing_space_separators() {
return text;
}
let end = text
.char_indices()
.rev()
.find_map(|(offset, character)| {
(!character_is_css_other_space_separator(character))
.then_some(offset + character.len_utf8())
})
.unwrap_or(0);
&text[..end]
}
#[cfg(test)]
pub(crate) fn line_end_letter_spacing_width(text: &str, style: &ComputedStyle) -> LayoutLength {
let letter_spacing = style.used_letter_spacing().points();
if letter_spacing == 0.0
|| text.is_empty()
|| text.chars().any(|character| {
character_has_cursive_shaping_behavior(character)
&& !character_is_join_control(character)
})
{
return layout_pt(0.0);
}
let boundaries = GraphemeClusterSegmenter::new()
.segment_str(text)
.collect::<Vec<_>>();
if boundaries.windows(2).any(|window| {
text[window[0]..window[1]]
.chars()
.any(|character| !character_is_bidi_format_control(character))
}) {
layout_pt(letter_spacing)
} else {
layout_pt(0.0)
}
}