//! 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> {
/// The text that is formatted, which texts that are part of it borrow from.
source: &'a str,
/// A buffer for the markers of tags.
buffer: Vec,
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(
source: &'a str,
tree: &'p Tree<'a>,
options: &'p Options<'p>,
docs: &'p mut Docs<'a>,
embed: &'p mut dyn Embed,
) -> Self {
Self { source, buffer: Vec::new(), 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 {
let start = (bytes.as_ptr() as usize).wrapping_sub(self.source.as_ptr() as usize);
if let Some(text) = self.source.get(start..start + bytes.len()) {
return self.docs.text(text);
}
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 = std::mem::take(&mut self.buffer);
out.clear();
write(self.tags(), &mut out);
let doc = match std::str::from_utf8(&out) {
Ok(text) => self.docs.owned(text),
Err(_) => self.docs.owned(&String::from_utf8_lossy(&out)),
};
self.buffer = out;
doc
}
/// `replaceEndOfLine(text, separator)`
pub(crate) fn lines(&mut self, text: &[u8], separator: Separator) -> Doc {
if !strings::contains_char(text, b'\n') {
return self.bytes(text);
}
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 `