biome_js_formatter 0.0.2

Biome's JavaScript formatter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::jsx::attribute::expression_attribute_value::should_inline_jsx_expression;
use crate::prelude::*;
use crate::prelude::{format_args, write};

use crate::utils::AnyJsBinaryLikeExpression;
use biome_formatter::{CstFormatContext, FormatResult};
use biome_js_syntax::{AnyJsExpression, JsxExpressionChild, JsxExpressionChildFields};

#[derive(Debug, Clone, Default)]
pub struct FormatJsxExpressionChild;

impl FormatNodeRule<JsxExpressionChild> for FormatJsxExpressionChild {
    fn fmt_fields(&self, node: &JsxExpressionChild, f: &mut JsFormatter) -> FormatResult<()> {
        let JsxExpressionChildFields {
            l_curly_token,
            expression,
            r_curly_token,
        } = node.as_fields();

        match expression {
            Some(expression) => {
                let comments = f.context().comments();
                let is_conditional_or_binary =
                    matches!(expression, AnyJsExpression::JsConditionalExpression(_))
                        || AnyJsBinaryLikeExpression::can_cast(expression.syntax().kind());

                let should_inline = !comments.has_comments(expression.syntax())
                    && (is_conditional_or_binary
                        || should_inline_jsx_expression(&expression, comments));

                if should_inline {
                    write!(
                        f,
                        [
                            l_curly_token.format(),
                            expression.format(),
                            line_suffix_boundary(),
                            r_curly_token.format()
                        ]
                    )
                } else {
                    write!(
                        f,
                        [group(&format_args![
                            l_curly_token.format(),
                            soft_block_indent(&expression.format()),
                            line_suffix_boundary(),
                            r_curly_token.format()
                        ])]
                    )
                }
            }
            None => {
                let has_line_comment = f
                    .comments()
                    .leading_dangling_trailing_comments(node.syntax())
                    .any(|comment| comment.kind().is_line());

                write!(f, [l_curly_token.format()])?;

                if has_line_comment {
                    write!(
                        f,
                        [
                            format_dangling_comments(node.syntax()).with_block_indent(),
                            hard_line_break()
                        ]
                    )?;
                } else {
                    write!(f, [format_dangling_comments(node.syntax())])?;
                }

                write!(f, [r_curly_token.format()])
            }
        }
    }

    fn fmt_dangling_comments(
        &self,
        _: &JsxExpressionChild,
        _: &mut JsFormatter,
    ) -> FormatResult<()> {
        // Formatted inside of `fmt_fields`
        Ok(())
    }
}