//! Prettier's `printer-html.js`, `print/children.js`, `print/element.js` and `print/tag.js`, building a [`Doc`]. use std::borrow::Cow; use super::ast::{Flags, Id, Kind, Tree}; use super::embed::{self, Embedded}; use super::strings; use super::tag::Tags; use super::utilities::{ dedent_string, html_split, html_trim_preserve_indentation, is_pre_like, is_script_like_tag, is_text_like, should_unquote_attribute_value, unescape_quote_entities, }; use super::{Options, Parser}; use crate::doc::{Align, Doc, Docs}; use crate::embed::Embed; pub(crate) struct Printer<'p, 'a> { pub(crate) tree: &'p Tree<'a>, pub(crate) options: &'p Options<'p>, pub(crate) docs: &'p mut Docs<'a>, pub(crate) embed: &'p mut dyn Embed, /// The number of `indent`s around what is printed now. pub(crate) indents: usize, /// `path.ancestors.length` of the node printed now. ancestors: usize, } /// What `printBetweenLine` returns. #[derive(Clone, Copy, PartialEq, Eq)] enum Between { None, Hard, Line, Soft, } impl<'p, 'a> Printer<'p, 'a> { pub(crate) fn new( tree: &'p Tree<'a>, options: &'p Options<'p>, docs: &'p mut Docs<'a>, embed: &'p mut dyn Embed, ) -> Self { Self { tree, options, docs, embed, indents: 0, ancestors: 0 } } fn tags(&self) -> Tags<'p, 'a, 'p> { Tags { tree: self.tree, options: self.options } } /// A text that the arena keeps. pub(crate) fn bytes(&mut self, bytes: &[u8]) -> Doc { match std::str::from_utf8(bytes) { Ok(text) => self.docs.owned(text), Err(_) => self.docs.owned(&String::from_utf8_lossy(bytes)), } } /// A string that `write` builds from the tag markers. fn marker(&mut self, write: impl FnOnce(Tags<'p, 'a, 'p>, &mut Vec)) -> Doc { let mut out = Vec::new(); write(self.tags(), &mut out); self.bytes(&out) } /// `replaceEndOfLine(text, separator)` pub(crate) fn lines(&mut self, text: &[u8], separator: Separator) -> Doc { let parts = self.line_parts(text, separator); self.docs.concat(&parts) } fn line_parts(&mut self, text: &[u8], separator: Separator) -> Vec { let mut parts = Vec::new(); for (index, line) in strings::split(text, b"\n").enumerate() { if index > 0 { let separator = match separator { Separator::Literal => self.docs.literalline(), Separator::Hard => self.docs.hardline(), }; parts.push(separator); } parts.push(self.bytes(line)); } parts } // ───────────────────────────── `genericPrint` ───────────────────────────── pub(crate) fn print_root(&mut self) -> Doc { let root = self.tree.root; self.ancestors = 0; let children = self.print_children(root); let group = self.docs.group(children); let hardline = self.docs.hardline(); self.docs.concat(&[group, hardline]) } /// `path.call(print)` for `id`: the embedded printer first, then `genericPrint`. fn print(&mut self, id: Id) -> Doc { if let Some(doc) = self.print_embedded(id) { return doc; } let node = &self.tree[id]; match node.kind { Kind::Element | Kind::IeConditionalComment => self.print_element(id), Kind::IeConditionalStartComment | Kind::IeConditionalEndComment => { let start = self.marker(|tags, out| tags.opening_tag_start(id, out)); let end = self.marker(|tags, out| tags.closing_tag_end(id, out)); self.docs.concat(&[start, end]) } Kind::Interpolation => { let mut parts = vec![self.marker(|tags, out| tags.opening_tag_start(id, out))]; let mut next = self.tree.first_child(id); while let Some(child) = next { next = self.tree.next(child); parts.push(self.print_nested(child)); } parts.push(self.marker(|tags, out| tags.closing_tag_end(id, out))); self.docs.concat(&parts) } Kind::Text => self.print_text(id), Kind::DocType => { let start = self.marker(|tags, out| tags.opening_tag_start(id, out)); let space = self.docs.text(" "); let value = doc_type_value(&node.value); let value = self.bytes(&value); let inner = self.docs.concat(&[start, space, value]); let group = self.docs.group(inner); let end = self.marker(|tags, out| tags.closing_tag_end(id, out)); self.docs.concat(&[group, end]) } Kind::Comment => { let prefix = self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let span = node.span; let text = &self.options.original_text[span.start as usize..span.end as usize]; let value = self.lines(text, Separator::Literal); let suffix = self.marker(|tags, out| tags.closing_tag_suffix(id, out)); self.docs.concat(&[prefix, value, suffix]) } Kind::FrontMatter => { let span = node.span; let raw = &self.options.original_text[span.start as usize..span.end as usize]; self.print_front_matter(raw) } _ => Docs::EMPTY, } } /// Prints a child, one level deeper. fn print_nested(&mut self, id: Id) -> Doc { self.ancestors += 1; let doc = self.print(id); self.ancestors -= 1; doc } fn print_text(&mut self, id: Id) -> Doc { let node = &self.tree[id]; let parent = self.tree.parent(id).map(|parent| &self.tree[parent]); if parent.is_some_and(|parent| parent.kind == Kind::Interpolation) { let value = &node.value[..]; let trailing = trailing_newline(value); let value = trailing.map_or(value, |at| &value[..at]); let printed = self.lines(value, Separator::Literal); let end = if trailing.is_some() { self.docs.hardline() } else { Docs::EMPTY }; return self.docs.concat(&[printed, end]); } let prefix = self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let mut parts = self.text_value_parts(id, &self.tree[id].value); let suffix = self.marker(|tags, out| tags.closing_tag_suffix(id, out)); parts[0] = self.docs.concat(&[prefix, parts[0]]); let last = parts.len() - 1; parts[last] = self.docs.concat(&[parts[last], suffix]); self.docs.fill(&parts) } /// `getTextValueParts`, as the parts of a fill. fn text_value_parts(&mut self, id: Id, value: &[u8]) -> Vec { let parent = self.tree.parent(id).map_or(self.tree.root, |parent| parent); let parent = &self.tree[parent]; if parent.has(Flags::IS_WHITESPACE_SENSITIVE) { if parent.has(Flags::IS_INDENTATION_SENSITIVE) { return self.line_parts(value, Separator::Literal); } let dedented = dedent_string(html_trim_preserve_indentation(value)); return self.line_parts(&dedented, Separator::Hard); } let words: Vec<&[u8]> = html_split(value).collect(); let mut parts = Vec::with_capacity(words.len() * 2); for (index, word) in words.into_iter().enumerate() { if index > 0 { parts.push(self.docs.line()); } parts.push(self.bytes(word)); } parts } fn print_front_matter(&mut self, raw: &[u8]) -> Doc { if let Some(doc) = embed::front_matter(self, raw) { return doc; } self.lines(raw, Separator::Literal) } // ───────────────────────────── `print/children.js` ───────────────────────────── /// `getEndLocation` fn end_location(&self, id: Id) -> u32 { let node = &self.tree[id]; let end = node.span.end; if node.kind == Kind::Element && node.end_span().is_none() { if let Some(last) = self.tree.last_child(id) { return end.max(self.end_location(last)); } } end } fn print_child(&mut self, id: Id) -> Doc { if !self.tree.has_prettier_ignore(id) { return self.print_nested(id); } let tags = self.tags(); let node = &self.tree[id]; let mut start = node.span.start as usize; if self .tree .prev(id) .is_some_and(|prev| tags.needs_to_borrow_next_opening_tag_start_marker(prev)) { start += tags.len_of(|tags, out| tags.opening_tag_start_marker(id, out)); } let mut end = self.end_location(id) as usize; if self.tree.next(id).is_some_and(|next| tags.needs_to_borrow_prev_closing_tag_end_marker(next)) { end -= tags.len_of(|tags, out| tags.closing_tag_end_marker(id, out)); } let text = self.options.original_text.get(start..end).unwrap_or_default(); let text = strings::trim_html_whitespace_end(text); let prefix = self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let value = self.lines(text, Separator::Literal); let suffix = self.marker(|tags, out| tags.closing_tag_suffix(id, out)); self.docs.concat(&[prefix, value, suffix]) } fn between(&self, prev: Id, next: Id) -> Between { let tags = self.tags(); let (before, after) = (&self.tree[prev], &self.tree[next]); let hard_leading = self.tree.prefer_hardline_as_leading_spaces(next, self.options); if is_text_like(before) && is_text_like(after) { if before.has(Flags::IS_TRAILING_SPACE_SENSITIVE) { if before.has(Flags::HAS_TRAILING_SPACES) { return if hard_leading { Between::Hard } else { Between::Line }; } return Between::None; } return if hard_leading { Between::Hard } else { Between::Soft }; } if (tags.needs_to_borrow_next_opening_tag_start_marker(prev) && (self.tree.has_prettier_ignore(next) || self.tree.first_child(next).is_some() || after.has(Flags::IS_SELF_CLOSING) || (after.kind == Kind::Element && after.has_attrs()))) || (before.kind == Kind::Element && before.has(Flags::IS_SELF_CLOSING) && tags.needs_to_borrow_prev_closing_tag_end_marker(next)) { return Between::None; } if after.kind == Kind::Comment && after.has(Flags::IS_LEADING_SPACE_SENSITIVE) && !after.has(Flags::HAS_LEADING_SPACES) { return Between::Soft; } let borrows_deep = || { tags.needs_to_borrow_prev_closing_tag_end_marker(next) && self.tree.last_child(prev).is_some_and(|last| { tags.needs_to_borrow_parent_closing_tag_start_marker(last) && self .tree .last_child(last) .is_some_and(|deep| tags.needs_to_borrow_parent_closing_tag_start_marker(deep)) }) }; if !after.has(Flags::IS_LEADING_SPACE_SENSITIVE) || hard_leading || borrows_deep() { return Between::Hard; } if after.has(Flags::HAS_LEADING_SPACES) { Between::Line } else { Between::Soft } } fn between_doc(&mut self, between: Between) -> Doc { match between { Between::None => Docs::EMPTY, Between::Hard => self.docs.hardline(), Between::Line => self.docs.line(), Between::Soft => self.docs.softline(), } } fn print_children(&mut self, id: Id) -> Doc { let children: Vec = self.tree.children(id).collect(); if self.tree.force_break_children(id) { let mut parts = vec![self.docs.break_parent()]; for &child in &children { let between = self.tree.prev(child).map_or(Between::None, |prev| self.between(prev, child)); if between != Between::None { let line = self.between_doc(between); let prev = self.tree.prev(child).unwrap(); let extra = if self.tree.force_next_empty_line(prev, self.options) { self.docs.hardline() } else { Docs::EMPTY }; parts.push(line); parts.push(extra); } parts.push(self.print_child(child)); } return self.docs.concat(&parts); } let ids: Vec<_> = children.iter().map(|_| self.docs.group_id()).collect(); let mut parts = Vec::with_capacity(children.len()); for (index, &child) in children.iter().enumerate() { let node = &self.tree[child]; let prev = self.tree.prev(child); if is_text_like(node) { if let Some(prev) = prev.filter(|&prev| is_text_like(&self.tree[prev])) { let between = self.between(prev, child); if between != Between::None { if self.tree.force_next_empty_line(prev, self.options) { let hard = self.docs.hardline(); let again = self.docs.hardline(); let printed = self.print_child(child); parts.push(self.docs.concat(&[hard, again, printed])); } else { let line = self.between_doc(between); let printed = self.print_child(child); parts.push(self.docs.concat(&[line, printed])); } continue; } } parts.push(self.print_child(child)); continue; } let mut prev_parts = Vec::new(); let mut leading = Vec::new(); let mut trailing = Vec::new(); let mut next_parts = Vec::new(); let prev_between = prev.map_or(Between::None, |prev| self.between(prev, child)); let next = self.tree.next(child); let next_between = next.map_or(Between::None, |next| self.between(child, next)); if prev_between != Between::None { let prev = prev.unwrap(); if self.tree.force_next_empty_line(prev, self.options) { prev_parts.push(self.docs.hardline()); prev_parts.push(self.docs.hardline()); } else if prev_between == Between::Hard { prev_parts.push(self.docs.hardline()); } else if is_text_like(&self.tree[prev]) { leading.push(self.between_doc(prev_between)); } else { let soft = self.docs.softline(); leading.push(self.docs.if_break(Docs::EMPTY, soft, Some(ids[index - 1]))); } } if next_between != Between::None { let next = next.unwrap(); let next_is_text = is_text_like(&self.tree[next]); if self.tree.force_next_empty_line(child, self.options) { if next_is_text { next_parts.push(self.docs.hardline()); next_parts.push(self.docs.hardline()); } } else if next_between == Between::Hard { if next_is_text { next_parts.push(self.docs.hardline()); } } else { trailing.push(self.between_doc(next_between)); } } let printed = self.print_child(child); let mut inner = vec![printed]; inner.extend(trailing); let inner = self.docs.concat(&inner); let inner = self.docs.group_with(inner, Some(ids[index]), false); leading.push(inner); let outer = self.docs.concat(&leading); let outer = self.docs.group(outer); prev_parts.push(outer); prev_parts.extend(next_parts); parts.push(self.docs.concat(&prev_parts)); } self.docs.concat(&parts) } // ───────────────────────────── `print/element.js` ───────────────────────────── fn print_element(&mut self, id: Id) -> Doc { let tags = self.tags(); let node = &self.tree[id]; if node.has(Flags::PRESERVES_CONTENT) { let prefix = self.marker(|tags, out| tags.opening_tag_prefix(id, out)); let opening = self.print_opening_tag(id); let opening = self.docs.group(opening); let content = tags.node_content(id); let content = self.lines(content, Separator::Literal); let closing = self.print_closing_tag(id); let suffix = self.marker(|tags, out| tags.closing_tag_suffix(id, out)); return self.docs.concat(&[prefix, opening, content, closing, suffix]); } let first = self.tree.first_child(id); let last = self.tree.last_child(id); let hug = match (first, last) { (Some(first), Some(last)) if first == last => { let child = &self.tree[first]; child.kind == Kind::Interpolation && child.flags & (Flags::IS_LEADING_SPACE_SENSITIVE | Flags::HAS_LEADING_SPACES) == Flags::IS_LEADING_SPACE_SENSITIVE && child.flags & (Flags::IS_TRAILING_SPACE_SENSITIVE | Flags::HAS_TRAILING_SPACES) == Flags::IS_TRAILING_SPACE_SENSITIVE } _ => false, }; let attr_group = self.docs.group_id(); let (Some(first), Some(last)) = (first, last) else { let contents = if node.flags.contains(Flags::HAS_DANGLING_SPACES | Flags::IS_DANGLING_SPACE_SENSITIVE) { self.docs.line() } else { Docs::EMPTY }; return self.print_tag(id, attr_group, contents); }; let first_node = &self.tree[first]; let line_before = if hug { let soft = self.docs.softline(); self.docs.if_break(soft, Docs::EMPTY, Some(attr_group)) } else if first_node .flags .contains(Flags::HAS_LEADING_SPACES | Flags::IS_LEADING_SPACE_SENSITIVE) { self.docs.line() } else if first_node.kind == Kind::Text && node.flags.contains(Flags::IS_WHITESPACE_SENSITIVE | Flags::IS_INDENTATION_SENSITIVE) { let soft = self.docs.softline(); self.docs.align(Align::Root, soft) } else { self.docs.softline() }; let indented = !hug && !self.is_unindented_vue_block(id); if indented { self.indents += 1; } let children = self.print_children(id); if indented { self.indents -= 1; } let children = self.docs.concat(&[line_before, children]); let children = if hug { self.docs.indent_if_break(children, attr_group, false) } else if indented { self.docs.indent(children) } else { children }; let line_after = self.line_after_children(id, last, hug, attr_group); let force = if self.tree.force_break_content(id, self.options) { self.docs.break_parent() } else { Docs::EMPTY }; let contents = self.docs.concat(&[force, children, line_after]); self.print_tag(id, attr_group, contents) } /// A Vue root `