feat(html): implement formatter

Author: ematipico

AGENTS..md AGENTS.mdAGENTS..md renamed to AGENTS.md

@@ -20,6 +20,7 @@ mod cst;
 mod generated;
 mod html;
 pub(crate) mod prelude;
+pub(crate) mod separated;
 mod svelte;
 mod trivia;
 pub mod utils;

crates/biome_html_formatter/src/lib.rs

@@ -0,0 +1,141 @@
+use crate::FormatHtmlSyntaxToken;
+use crate::prelude::*;
+use biome_formatter::separated::{
+    FormatSeparatedElementRule, FormatSeparatedIter, TrailingSeparator,
+};
+use biome_formatter::{FormatRefWithRule, FormatRuleWithOptions};
+use biome_html_syntax::{HtmlLanguage, HtmlSyntaxToken, SvelteName};
+use biome_rowan::{AstNode, AstSeparatedList, AstSeparatedListElementsIterator};
+use std::marker::PhantomData;
+
+#[derive(Clone)]
+pub(crate) struct HtmlFormatSeparatedElementRule<N> {
+    node: PhantomData<N>,
+}
+
+impl<N> FormatSeparatedElementRule<N> for HtmlFormatSeparatedElementRule<N>
+where
+    N: AstNode<Language = HtmlLanguage> + AsFormat<HtmlFormatContext> + 'static,
+{
+    type Context = HtmlFormatContext;
+    type FormatNode<'a> = N::Format<'a>;
+    type FormatSeparator<'a> = FormatRefWithRule<'a, HtmlSyntaxToken, FormatHtmlSyntaxToken>;
+
+    fn format_node<'a>(&self, node: &'a N) -> Self::FormatNode<'a> {
+        node.format()
+    }
+
+    fn format_separator<'a>(&self, separator: &'a HtmlSyntaxToken) -> Self::FormatSeparator<'a> {
+        separator.format()
+    }
+}
+
+type HtmlFormatSeparatedIter<Node, C> = FormatSeparatedIter<
+    AstSeparatedListElementsIterator<HtmlLanguage, Node>,
+    Node,
+    HtmlFormatSeparatedElementRule<Node>,
+    C,
+>;
+
+/// AST Separated list formatting extension methods
+pub(crate) trait FormatAstSeparatedListExtension:
+    AstSeparatedList<Language = HtmlLanguage>
+{
+    /// Prints a separated list of nodes
+    ///
+    /// Trailing separators will be reused from the original list or created by
+    /// calling the `separator_factory` function. The last trailing separator
+    /// will not be printed by default. Use `with_trailing_separator` to add it
+    /// in where necessary.
+    fn format_separated(
+        &self,
+        separator: &'static str,
+    ) -> HtmlFormatSeparatedIter<Self::Node, HtmlFormatContext> {
+        HtmlFormatSeparatedIter::new(
+            self.elements(),
+            separator,
+            HtmlFormatSeparatedElementRule { node: PhantomData },
+            on_skipped,
+            on_removed,
+        )
+        .with_trailing_separator(TrailingSeparator::Disallowed)
+    }
+}
+
+impl<T> FormatAstSeparatedListExtension for T where T: AstSeparatedList<Language = HtmlLanguage> {}
+
+#[derive(Default, Debug, Clone, Copy)]
+pub(crate) struct HtmlFormatSeparatedElementRuleWithOptions<N, O> {
+    node: PhantomData<N>,
+    options: O,
+}
+
+impl<N, O> HtmlFormatSeparatedElementRuleWithOptions<N, O> {
+    pub(crate) fn new(options: O) -> Self {
+        Self {
+            node: PhantomData,
+            options,
+        }
+    }
+}
+
+impl<N, O, R> FormatSeparatedElementRule<N> for HtmlFormatSeparatedElementRuleWithOptions<N, O>
+where
+    O: Clone + Copy,
+    R: FormatNodeRule<N> + FormatRuleWithOptions<N, Context = HtmlFormatContext, Options = O>,
+    N: AstNode<Language = HtmlLanguage>
+        + for<'a> AsFormat<HtmlFormatContext, Format<'a> = FormatRefWithRule<'a, N, R>>
+        + 'static,
+{
+    type Context = HtmlFormatContext;
+    type FormatNode<'a> = FormatRefWithRule<'a, N, R>;
+    type FormatSeparator<'a> = FormatRefWithRule<'a, HtmlSyntaxToken, FormatHtmlSyntaxToken>;
+
+    fn format_node<'a>(&self, node: &'a N) -> Self::FormatNode<'a> {
+        node.format().with_options(self.options)
+    }
+
+    fn format_separator<'a>(&self, separator: &'a HtmlSyntaxToken) -> Self::FormatSeparator<'a> {
+        separator.format()
+    }
+}
+
+type HtmlFormatSeparatedIterWithOptions<Node, Options, C> = FormatSeparatedIter<
+    AstSeparatedListElementsIterator<HtmlLanguage, Node>,
+    Node,
+    HtmlFormatSeparatedElementRuleWithOptions<Node, Options>,
+    C,
+>;
+
+/// AST Separated list formatting extension methods with options
+#[expect(dead_code)]
+pub(crate) trait FormatAstSeparatedListWithOptionsExtension<O>:
+    AstSeparatedList<Language = HtmlLanguage>
+{
+    /// Prints a separated list of nodes with options
+    ///
+    /// Trailing separators will be reused from the original list or created by
+    /// calling the `separator_factory` function. The last trailing separator
+    /// will not be printed by default. Use `with_trailing_separator` to add it
+    /// in where necessary.
+    fn format_separated_with_options(
+        &self,
+        separator: &'static str,
+        options: O,
+    ) -> HtmlFormatSeparatedIterWithOptions<Self::Node, O, HtmlFormatContext> {
+        FormatSeparatedIter::new(
+            self.elements(),
+            separator,
+            HtmlFormatSeparatedElementRuleWithOptions::new(options),
+            on_skipped,
+            on_removed,
+        )
+        .with_trailing_separator(TrailingSeparator::Disallowed)
+    }
+}
+
+impl<T, O> FormatAstSeparatedListWithOptionsExtension<O> for T where
+    // TODO: probably it requires an update because it's tight to svelte grammar
+    T: AstSeparatedList<Language = HtmlLanguage, Node = SvelteName>
+{
+}

crates/biome_html_formatter/src/separated.rs

@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use biome_formatter::write;
 use biome_html_syntax::{SvelteDebugBlock, SvelteDebugBlockFields};
+use biome_rowan::AstSeparatedList;
 
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatSvelteDebugBlock;
@@ -15,7 +16,11 @@ impl FormatNodeRule<SvelteDebugBlock> for FormatSvelteDebugBlock {
 
         write!(f, [sv_curly_at_token.format(), debug_token.format(),])?;
 
-        write!(f, [space(), bindings.format()])?;
+        if !bindings.is_empty() {
+            write!(f, [space()])?;
+        }
+
+        write!(f, [bindings.format()])?;
 
         write!(f, [r_curly_token.format()])
     }

crates/biome_html_formatter/src/svelte/auxiliary/debug_block.rs

@@ -1,10 +1,12 @@
 use crate::prelude::*;
-use biome_html_syntax::SvelteName;
-use biome_rowan::AstNode;
+use biome_formatter::write;
+use biome_html_syntax::{SvelteName, SvelteNameFields};
+
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatSvelteName;
 impl FormatNodeRule<SvelteName> for FormatSvelteName {
     fn fmt_fields(&self, node: &SvelteName, f: &mut HtmlFormatter) -> FormatResult<()> {
-        format_html_verbatim_node(node.syntax()).fmt(f)
+        let SvelteNameFields { svelte_ident_token } = node.as_fields();
+        write!(f, [svelte_ident_token.format()])
     }
 }

crates/biome_html_formatter/src/svelte/auxiliary/name.rs

@@ -1,10 +1,19 @@
 use crate::prelude::*;
+use crate::separated::FormatAstSeparatedListExtension;
 use biome_html_syntax::SvelteBindingList;
+
 #[derive(Debug, Clone, Default)]
 pub(crate) struct FormatSvelteBindingList;
 impl FormatRule<SvelteBindingList> for FormatSvelteBindingList {
     type Context = HtmlFormatContext;
     fn fmt(&self, node: &SvelteBindingList, f: &mut HtmlFormatter) -> FormatResult<()> {
-        format_html_verbatim_node(node.syntax()).fmt(f)
+        let separator = space();
+        let mut joiner = f.join_with(&separator);
+
+        for formatted in node.format_separated(",") {
+            joiner.entry(&formatted);
+        }
+
+        joiner.finish()
     }
 }

crates/biome_html_formatter/src/svelte/lists/binding_list.rs

@@ -1,5 +1,5 @@
-use crate::FormatHtmlSyntaxToken;
 use crate::prelude::HtmlFormatContext;
+use crate::{FormatHtmlSyntaxToken, HtmlFormatter};
 use biome_formatter::formatter::Formatter;
 use biome_formatter::trivia::FormatToken;
 use biome_formatter::{Argument, Format, FormatResult};
@@ -39,3 +39,11 @@ impl<'a> Format<HtmlFormatContext> for FormatReplaced<'a> {
         FormatHtmlSyntaxToken.format_replaced(self.token, &self.content, f)
     }
 }
+
+pub(crate) fn on_skipped(token: &HtmlSyntaxToken, f: &mut HtmlFormatter) -> FormatResult<()> {
+    FormatHtmlSyntaxToken.format_skipped_token_trivia(token, f)
+}
+
+pub(crate) fn on_removed(token: &HtmlSyntaxToken, f: &mut HtmlFormatter) -> FormatResult<()> {
+    FormatHtmlSyntaxToken.format_removed(token, f)
+}

crates/biome_html_formatter/src/trivia.rs

@@ -0,0 +1,6 @@
+{@debug}
+
+{@debug foo}
+
+
+{@debug foo, bar}{@debug foo, bar,      baz}

crates/biome_html_formatter/tests/specs/html/astro/debug.svelte

@@ -0,0 +1,43 @@
+---
+source: crates/biome_formatter_test/src/snapshot_builder.rs
+info: astro/debug.svelte
+---
+# Input
+
+```svelte
+{@debug}
+
+{@debug foo}
+
+
+{@debug foo, bar}{@debug foo, bar,      baz}
+
+```
+
+
+=============================
+
+# Outputs
+
+## Output 1
+
+-----
+Indent style: Tab
+Indent width: 2
+Line ending: LF
+Line width: 80
+Attribute Position: Auto
+Bracket same line: false
+Whitespace sensitivity: css
+Indent script and style: false
+Self close void elements: never
+-----
+
+```svelte
+{@debug}
+
+{@debug foo}
+
+{@debug foo, bar}
+{@debug foo, bar, baz}
+```