support Angular @let

dprint_plugin/tests/integration/angular.component.html

@@ -26,3 +26,5 @@
 }
 
 <div>{{ a ?. b ( ) }}</div>
+
+@let user = getUser (  1  );

dprint_plugin/tests/integration/biome/angular.component.html.snap

@@ -27,3 +27,5 @@ source: dprint_plugin/tests/integration.rs
 }
 
 <div>{{ a?.b() }}</div>
+
+@let user = getUser(1);

dprint_plugin/tests/integration/dprint_ts/angular.component.html.snap

@@ -26,3 +26,5 @@ source: dprint_plugin/tests/integration.rs
 }
 
 <div>{{ a?.b() }}</div>
+
+@let user = getUser(1);

markup_fmt/src/ast.rs

@@ -30,6 +30,11 @@ pub struct AngularInterpolation<'s> {
     pub expr: &'s str,
 }
 
+pub struct AngularLet<'s> {
+    pub name: &'s str,
+    pub expr: &'s str,
+}
+
 pub struct AngularSwitch<'s> {
     pub expr: &'s str,
     pub cases: Vec<AngularCase<'s>>,
@@ -109,6 +114,7 @@ pub enum Node<'s> {
     AngularFor(AngularFor<'s>),
     AngularIf(AngularIf<'s>),
     AngularInterpolation(AngularInterpolation<'s>),
+    AngularLet(AngularLet<'s>),
     AngularSwitch(AngularSwitch<'s>),
     AstroExpr(AstroExpr<'s>),
     Comment(Comment<'s>),

markup_fmt/src/error.rs

@@ -13,6 +13,7 @@ pub struct SyntaxError {
 pub enum SyntaxErrorKind {
     ExpectAngularFor,
     ExpectAngularIf,
+    ExpectAngularLet,
     ExpectAngularSwitch,
     ExpectAstroAttr,
     ExpectAstroExpr,
@@ -53,6 +54,7 @@ impl fmt::Display for SyntaxError {
         let reason: Cow<_> = match self.kind {
             SyntaxErrorKind::ExpectAngularFor => "expect Angular `@for`".into(),
             SyntaxErrorKind::ExpectAngularIf => "expect Angular `@if`".into(),
+            SyntaxErrorKind::ExpectAngularLet => "expect Angular `@let`".into(),
             SyntaxErrorKind::ExpectAngularSwitch => "expect Angular `@switch`".into(),
             SyntaxErrorKind::ExpectAstroAttr => "expect Astro attribute".into(),
             SyntaxErrorKind::ExpectAstroExpr => "expect Astro expression".into(),

markup_fmt/src/parser.rs

@@ -369,6 +369,38 @@ impl<'s> Parser<'s> {
         Ok(unsafe { self.source.get_unchecked(start..end) })
     }
 
+    fn parse_angular_let(&mut self) -> PResult<AngularLet<'s>> {
+        if self
+            .chars
+            .next_if(|(_, c)| *c == '@')
+            .and_then(|_| self.chars.next_if(|(_, c)| *c == 'l'))
+            .and_then(|_| self.chars.next_if(|(_, c)| *c == 'e'))
+            .and_then(|_| self.chars.next_if(|(_, c)| *c == 't'))
+            .is_none()
+        {
+            return Err(self.emit_error(SyntaxErrorKind::ExpectAngularLet));
+        }
+        self.skip_ws();
+
+        let name = self.parse_identifier()?;
+        self.skip_ws();
+        if self.chars.next_if(|(_, c)| *c == '=').is_none() {
+            return Err(self.emit_error(SyntaxErrorKind::ExpectChar('=')));
+        }
+        self.skip_ws();
+        let start = self
+            .chars
+            .peek()
+            .map(|(i, _)| *i)
+            .unwrap_or(self.source.len());
+        let expr = self.parse_angular_inline_script(start)?;
+        if self.chars.next_if(|(_, c)| *c == ';').is_none() {
+            return Err(self.emit_error(SyntaxErrorKind::ExpectChar(';')));
+        }
+
+        Ok(AngularLet { name, expr })
+    }
+
     fn parse_angular_switch(&mut self) -> PResult<AngularSwitch<'s>> {
         if self
             .chars
@@ -1290,6 +1322,7 @@ impl<'s> Parser<'s> {
                     Some((_, 'i')) => self.parse_angular_if().map(Node::AngularIf),
                     Some((_, 'f')) => self.parse_angular_for().map(Node::AngularFor),
                     Some((_, 's')) => self.parse_angular_switch().map(Node::AngularSwitch),
+                    Some((_, 'l')) => self.parse_angular_let().map(Node::AngularLet),
                     _ => self.parse_text_node().map(Node::Text),
                 }
             }

markup_fmt/src/printer.rs

@@ -151,6 +151,19 @@ impl<'s> DocGen<'s> for AngularInterpolation<'s> {
     }
 }
 
+impl<'s> DocGen<'s> for AngularLet<'s> {
+    fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, _: &State<'s>) -> Doc<'s>
+    where
+        F: for<'a> FnMut(&Path, &'a str, usize) -> Result<Cow<'a, str>, E>,
+    {
+        Doc::text("@let ")
+            .append(Doc::text(self.name))
+            .append(Doc::text(" = "))
+            .append(Doc::text(ctx.format_general_expr(self.expr)))
+            .append(Doc::text(";"))
+    }
+}
+
 impl<'s> DocGen<'s> for AngularSwitch<'s> {
     fn doc<E, F>(&self, ctx: &mut Ctx<'_, E, F>, state: &State<'s>) -> Doc<'s>
     where
@@ -878,6 +891,7 @@ impl<'s> DocGen<'s> for Node<'s> {
             Node::AngularInterpolation(angular_interpolation) => {
                 angular_interpolation.doc(ctx, state)
             }
+            Node::AngularLet(angular_let) => angular_let.doc(ctx, state),
             Node::AngularSwitch(angular_switch) => angular_switch.doc(ctx, state),
             Node::AstroExpr(astro_expr) => astro_expr.doc(ctx, state),
             Node::Comment(comment) => comment.doc(ctx, state),

markup_fmt/tests/fmt/angular/let/let.component.html

@@ -0,0 +1 @@
+@let   user   =   getUser();

markup_fmt/tests/fmt/angular/let/let.component.snap

@@ -0,0 +1,4 @@
+---
+source: markup_fmt/tests/fmt.rs
+---
+@let user = getUser();