@openrewrite/rewrite 8.53.0 → 8.53.1

package/src/javascript/print.ts

@@ -15,7 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {JS} from "./tree";
+import {JS, JSX} from "./tree";
 import {JavaScriptVisitor} from "./visitor";
 import {PrintOutputCapture, TreePrinters} from "../print";
 import {Cursor, isTree, Tree} from "../tree";
@@ -88,6 +88,71 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         return inferType;
     }
 
+    override async visitJsxTag(element: JSX.Tag, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(element, p);
+        await this.visitLeftPaddedLocal("<", element.openName, p);
+        await this.visitSpace(element.afterName, p);
+        await this.visitRightPaddedLocal(element.attributes, "", p);
+
+        if (element.selfClosing) {
+            await this.visitSpace(element.selfClosing, p);
+            p.append("/>");
+        } else {
+            p.append(">");
+            if (element.children) {
+                await this.visitRightPaddedLocal(element.children, "", p);
+                await this.visitLeftPaddedLocal("</", element.closingName, p);
+                await this.visitSpace(element.afterClosingName, p);
+                p.append(">");
+            }
+        }
+
+        await this.afterSyntax(element, p);
+        return element;
+    }
+
+    override async visitJsxAttribute(attribute: JSX.Attribute, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(attribute, p);
+        await this.visit(attribute.key, p);
+        if (attribute.value) {
+            p.append("=");
+            await this.visit(attribute.value.element, p);
+        }
+        await this.afterSyntax(attribute, p);
+        return attribute;
+    }
+
+    override async visitJsxSpreadAttribute(spread: JSX.SpreadAttribute, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(spread, p);
+        p.append("{");
+        await this.visitSpace(spread.dots, p);
+        p.append("...");
+        await this.visitRightPaddedLocal([spread.expression], "}", p);
+        p.append("}");
+        await this.afterSyntax(spread, p);
+        return spread;
+    }
+
+    override async visitJsxExpression(expr: JSX.EmbeddedExpression, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(expr, p);
+        p.append("{");
+        if (expr.expression) {
+            await this.visitRightPaddedLocal([expr.expression], "}", p);
+        }
+        p.append("}");
+        await this.afterSyntax(expr, p);
+        return expr;
+    }
+
+    override async visitJsxNamespacedName(ns: JSX.NamespacedName, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(ns, p);
+        await this.visit(ns.namespace, p);
+        p.append(":");
+        await this.visitLeftPadded(ns.name, p);
+        await this.afterSyntax(ns, p);
+        return ns;
+    }
+
     override async visitImportDeclaration(jsImport: JS.Import, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(jsImport, p);
         p.append("import");
@@ -196,7 +261,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         p.append("try");
         await this.visit(aTry.body, p);
         await this.visitNodes(aTry.catches, p);
-        aTry.finally && await this.visitJLeftPaddedLocal("finally", aTry.finally, p);
+        aTry.finally && await this.visitLeftPaddedLocal("finally", aTry.finally, p);
         await this.afterSyntax(aTry, p);
         return aTry;
     }
@@ -215,7 +280,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitArrayDimension(arrayDimension: J.ArrayDimension, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(arrayDimension, p);
         p.append("[");
-        await this.visitJRightPaddedLocalSingle(arrayDimension.index, "]", p);
+        await this.visitRightPaddedLocalSingle(arrayDimension.index, "]", p);
         await this.afterSyntax(arrayDimension, p);
         return arrayDimension;
     }
@@ -265,8 +330,8 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitTernary(ternary: J.Ternary, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(ternary, p);
         await this.visit(ternary.condition, p);
-        await this.visitJLeftPaddedLocal("?", ternary.truePart, p);
-        await this.visitJLeftPaddedLocal(":", ternary.falsePart, p);
+        await this.visitLeftPaddedLocal("?", ternary.truePart, p);
+        await this.visitLeftPaddedLocal(":", ternary.falsePart, p);
         await this.afterSyntax(ternary, p);
         return ternary;
     }
@@ -301,7 +366,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.beforeSyntax(doWhileLoop, p);
         p.append("do");
         await this.visitStatementLocal(doWhileLoop.body, p);
-        await this.visitJLeftPaddedLocal("while", doWhileLoop.whileCondition, p);
+        await this.visitLeftPaddedLocal("while", doWhileLoop.whileCondition, p);
         await this.afterSyntax(doWhileLoop, p);
         return doWhileLoop;
     }
@@ -317,7 +382,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     override async visitInstanceOf(instanceOf: J.InstanceOf, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(instanceOf, p);
-        await this.visitJRightPaddedLocalSingle(instanceOf.expression, "instanceof", p);
+        await this.visitRightPaddedLocalSingle(instanceOf.expression, "instanceof", p);
         await this.visit(instanceOf.class, p);
         instanceOf.pattern && await this.visit(instanceOf.pattern, p);
         await this.afterSyntax(instanceOf, p);
@@ -423,7 +488,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
             }
 
             if (variable.element.initializer) {
-                await this.visitJLeftPaddedLocal("=", variable.element.initializer, p);
+                await this.visitLeftPaddedLocal("=", variable.element.initializer, p);
             }
 
             await this.afterSyntax(variable.element, p);
@@ -443,7 +508,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.beforeSyntax(variable, p);
         await this.visit(variable.name, p);
 
-        variable.initializer && await this.visitJLeftPaddedLocal("=", variable.initializer, p);
+        variable.initializer && await this.visitLeftPaddedLocal("=", variable.initializer, p);
 
         await this.afterSyntax(variable, p);
         return variable;
@@ -608,7 +673,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.visit(classDecl.name, p);
         classDecl.typeParameters && await this.visitJContainerLocal("<", classDecl.typeParameters, ",", ">", p);
         classDecl.primaryConstructor && await this.visitJContainerLocal("(", classDecl.primaryConstructor, ",", ")", p);
-        classDecl.extends && await this.visitJLeftPaddedLocal("extends", classDecl.extends, p);
+        classDecl.extends && await this.visitLeftPaddedLocal("extends", classDecl.extends, p);
         classDecl.implements && await this.visitJContainerLocal(classDecl.classKind.type === J.ClassDeclaration.Kind.Type.Interface ? "extends" : "implements",
             classDecl.implements, ",", null, p);
         await this.visit(classDecl.body, p);
@@ -696,7 +761,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         if (method.name.toString().length === 0) {
             method.select && await this.visitRightPadded(method.select, p);
         } else {
-            method.select && await this.visitJRightPaddedLocalSingle(method.select, "", p);
+            method.select && await this.visitRightPaddedLocalSingle(method.select, "", p);
             await this.visit(method.name, p);
         }
 
@@ -1099,7 +1164,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     protected async visitComputedPropertyName(computedPropertyName: JS.ComputedPropertyName, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(computedPropertyName, p);
         p.append("[");
-        await this.visitJRightPaddedLocalSingle(computedPropertyName.expression, "]", p);
+        await this.visitRightPaddedLocalSingle(computedPropertyName.expression, "]", p);
         await this.afterSyntax(computedPropertyName, p);
         return computedPropertyName;
     }
@@ -1173,7 +1238,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     override async visitNewClass(newClass: J.NewClass, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(newClass, p);
-        newClass.enclosing && await this.visitJRightPaddedLocalSingle(newClass.enclosing, ".", p);
+        newClass.enclosing && await this.visitRightPaddedLocalSingle(newClass.enclosing, ".", p);
         await this.visitSpace(newClass.new, p);
 
         if (newClass.class) {
@@ -1220,7 +1285,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     override async visitLabel(label: J.Label, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(label, p);
-        await this.visitJRightPaddedLocalSingle(label.label, ":", p);
+        await this.visitRightPaddedLocalSingle(label.label, ":", p);
         await this.visit(label.statement, p);
         await this.afterSyntax(label, p);
         return label;
@@ -1246,7 +1311,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.beforeSyntax(fieldAccess, p);
         await this.visit(fieldAccess.target, p);
 
-        await this.visitJLeftPaddedLocal(".", fieldAccess.name, p);
+        await this.visitLeftPaddedLocal(".", fieldAccess.name, p);
         await this.afterSyntax(fieldAccess, p);
         return fieldAccess;
     }
@@ -1263,7 +1328,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitParentheses<T extends J>(parens: J.Parentheses<T>, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(parens, p);
         p.append('(');
-        await this.visitJRightPaddedLocalSingle(parens.tree, ")", p);
+        await this.visitRightPaddedLocalSingle(parens.tree, ")", p);
         await this.afterSyntax(parens, p);
         return parens;
     }
@@ -1279,7 +1344,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitAssignment(assignment: J.Assignment, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(assignment, p);
         await this.visit(assignment.variable, p);
-        await this.visitJLeftPaddedLocal("=", assignment.assignment, p);
+        await this.visitLeftPaddedLocal("=", assignment.assignment, p);
         await this.afterSyntax(assignment, p);
         return assignment;
     }
@@ -1588,7 +1653,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         p.append('(');
         await this.visitJRightPaddedLocal(ctrl.init, ",", p);
         p.append(';');
-        ctrl.condition && await this.visitJRightPaddedLocalSingle(ctrl.condition, ";", p);
+        ctrl.condition && await this.visitRightPaddedLocalSingle(ctrl.condition, ";", p);
         await this.visitJRightPaddedLocal(ctrl.update, ",", p);
         p.append(')');
         await this.visitStatementLocal(forLoop.body, p);
@@ -1735,7 +1800,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         return right;
     }
 
-    private async visitJRightPaddedLocalSingle(node: J.RightPadded<J> | undefined, suffix: string, p: PrintOutputCapture) {
+    private async visitRightPaddedLocalSingle(node: J.RightPadded<J> | undefined, suffix: string, p: PrintOutputCapture) {
         if (node) {
             await this.visit(node.element, p);
 
@@ -1761,23 +1826,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         }
     }
 
-    private async visitJLeftPaddedLocal(prefix: string | null, leftPadded: J.LeftPadded<J> | J.LeftPadded<boolean> | undefined, p: PrintOutputCapture) {
-        if (leftPadded) {
-            await this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, p);
-
-            if (prefix) {
-                p.append(prefix);
-            }
-
-            if (typeof leftPadded.element !== 'boolean') {
-                await this.visit(leftPadded.element, p);
-            }
-
-            await this.afterSyntaxMarkers(leftPadded.markers, p);
-        }
-    }
-
-    private async visitLeftPaddedLocal(prefix: string | undefined, leftPadded: J.LeftPadded<J> | J.LeftPadded<boolean> | undefined, p: PrintOutputCapture) {
+    private async visitLeftPaddedLocal(prefix: string | undefined, leftPadded: J.LeftPadded<J> | J.LeftPadded<boolean> | J.LeftPadded<string> | undefined, p: PrintOutputCapture) {
         if (leftPadded) {
             await this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, p);
 
@@ -1785,7 +1834,9 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
                 p.append(prefix);
             }
 
-            if (typeof leftPadded.element !== 'boolean') {
+            if (typeof leftPadded.element === 'string') {
+                p.append(leftPadded.element);
+            } else if (typeof leftPadded.element !== 'boolean') {
                 await this.visit(leftPadded.element, p);
             }
 
@@ -1888,10 +1939,10 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
         if (this.getParentCursor(1)?.value.kind === J.Kind.TypeCast) {
             p.append('<');
-            await this.visitJRightPaddedLocalSingle(controlParens.tree, ">", p);
+            await this.visitRightPaddedLocalSingle(controlParens.tree, ">", p);
         } else {
             p.append('(');
-            await this.visitJRightPaddedLocalSingle(controlParens.tree, ")", p);
+            await this.visitRightPaddedLocalSingle(controlParens.tree, ")", p);
         }
 
         await this.afterSyntax(controlParens, p);

package/src/javascript/rpc.ts

@@ -15,7 +15,7 @@
  */
 import {JavaScriptVisitor} from "./visitor";
 import {asRef, RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {isJavaScript, JS} from "./tree";
+import {isJavaScript, JS, JSX} from "./tree";
 import {Expression, J, JavaType, Statement, TypedTree, TypeTree} from "../java";
 import {createDraft, finishDraft} from "immer";
 import {JavaReceiver, JavaSender} from "../java/rpc";
@@ -371,6 +371,42 @@ class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
         return withStatement;
     }
 
+    override async visitJsxTag(tag: JSX.Tag, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(tag, el => el.openName, el => this.visitLeftPadded(el, q));
+        await q.getAndSend(tag, el => el.afterName, space => this.visitSpace(space, q));
+        await q.getAndSendList(tag, el => el.attributes, attr => attr.element.id, attr => this.visitRightPadded(attr, q));
+
+        await q.getAndSend(tag, el => el.selfClosing, space => this.visitSpace(space, q));
+        await q.getAndSendList(tag, el => el.children!, child => child.element.id, child => this.visitRightPadded(child, q));
+        await q.getAndSend(tag, el => el.closingName, el => this.visitLeftPadded(el, q));
+        await q.getAndSend(tag, el => el.afterClosingName, el => this.visitSpace(el, q));
+
+        return tag;
+    }
+
+    override async visitJsxAttribute(attribute: JSX.Attribute, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(attribute, el => el.key, el => this.visit(el, q));
+        await q.getAndSend(attribute, el => el.value, el => this.visitLeftPadded(el, q));
+        return attribute;
+    }
+
+    override async visitJsxSpreadAttribute(spreadAttribute: JSX.SpreadAttribute, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(spreadAttribute, el => el.dots, space => this.visitSpace(space, q));
+        await q.getAndSend(spreadAttribute, el => el.expression, el => this.visitRightPadded(el, q));
+        return spreadAttribute;
+    }
+
+    override async visitJsxExpression(embeddedExpression: JSX.EmbeddedExpression, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(embeddedExpression, el => el.expression, el => this.visitRightPadded(el, q));
+        return embeddedExpression;
+    }
+
+    override async visitJsxNamespacedName(namespacedName: JSX.NamespacedName, q: RpcSendQueue): Promise<J | undefined> {
+        await q.getAndSend(namespacedName, el => el.namespace, el => this.visit(el, q));
+        await q.getAndSend(namespacedName, el => el.name, el => this.visitLeftPadded(el, q));
+        return namespacedName;
+    }
+
     override async visitIndexSignatureDeclaration(indexSignatureDeclaration: JS.IndexSignatureDeclaration, q: RpcSendQueue): Promise<J | undefined> {
         await q.getAndSendList(indexSignatureDeclaration, el => el.modifiers, el => el.id, el => this.visit(el, q));
         await q.getAndSend(indexSignatureDeclaration, el => el.parameters, el => this.visitContainer(el, q));
@@ -900,6 +936,47 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         return finishDraft(draft);
     }
 
+    override async visitJsxTag(tag: JSX.Tag, q: RpcReceiveQueue): Promise<J | undefined> {
+        const draft = createDraft(tag);
+        draft.openName = await q.receive(draft.openName, el => this.visitLeftPadded(el, q));
+        draft.afterName = await q.receive(draft.afterName, space => this.visitSpace(space, q));
+        draft.attributes = await q.receiveListDefined(draft.attributes, attr => this.visitRightPadded(attr, q));
+
+        draft.selfClosing = await q.receive(draft.selfClosing, space => this.visitSpace(space, q));
+        draft.children = await q.receiveListDefined(draft.children, child => this.visitRightPadded(child, q));
+        draft.closingName = await q.receive(draft.closingName, el => this.visitLeftPadded(el, q));
+        draft.afterClosingName = await q.receive(draft.afterClosingName, el => this.visitSpace(el, q));
+
+        return finishDraft(draft);
+    }
+
+    override async visitJsxAttribute(attribute: JSX.Attribute, q: RpcReceiveQueue): Promise<J | undefined> {
+        const draft = createDraft(attribute);
+        draft.key = await q.receive(draft.key, el => this.visitDefined<J.Identifier | JSX.NamespacedName>(el, q));
+        draft.value = await q.receive(draft.value, el => this.visitLeftPadded(el, q));
+        return finishDraft(draft);
+    }
+
+    override async visitJsxSpreadAttribute(spreadAttribute: JSX.SpreadAttribute, q: RpcReceiveQueue): Promise<J | undefined> {
+        const draft = createDraft(spreadAttribute);
+        draft.dots = await q.receive(draft.dots, space => this.visitSpace(space, q));
+        draft.expression = await q.receive(draft.expression, el => this.visitRightPadded(el, q));
+        return finishDraft(draft);
+    }
+
+    override async visitJsxExpression(embeddedExpression: JSX.EmbeddedExpression, q: RpcReceiveQueue): Promise<J | undefined> {
+        const draft = createDraft(embeddedExpression);
+        draft.expression = await q.receive(draft.expression, el => this.visitRightPadded(el, q));
+        return finishDraft(draft);
+    }
+
+    override async visitJsxNamespacedName(namespacedName: JSX.NamespacedName, q: RpcReceiveQueue): Promise<J | undefined> {
+        const draft = createDraft(namespacedName);
+        draft.namespace = await q.receive(draft.namespace, el => this.visitDefined<J.Identifier>(el, q));
+        draft.name = await q.receive(draft.name, el => this.visitLeftPadded(el, q));
+        return finishDraft(draft);
+    }
+
     override async visitIndexSignatureDeclaration(indexSignatureDeclaration: JS.IndexSignatureDeclaration, q: RpcReceiveQueue): Promise<J | undefined> {
         const draft = createDraft(indexSignatureDeclaration);
         draft.modifiers = await q.receiveListDefined(draft.modifiers, el => this.visitDefined<J.Modifier>(el, q));

package/src/javascript/style.ts

@@ -25,8 +25,9 @@ export const JavaScriptStyles = {
 
 export const StyleKind = {
     SpacesStyle: "org.openrewrite.javascript.style.SpacesStyle",
-    WrappingAndBracesStyle: "org.openrewrite.java.style.WrappingAndBracesStyle",
-    BlankLinesStyle: "org.openrewrite.javascript.style.BlankLinesStyle"
+    WrappingAndBracesStyle: "org.openrewrite.javascript.style.WrappingAndBracesStyle",
+    BlankLinesStyle: "org.openrewrite.javascript.style.BlankLinesStyle",
+    TabsAndIndentsStyle: "org.openrewrite.javascript.style.TabsAndIndentsStyle"
 } as const;
 
 export const SpacesStyleDetailKind = {
@@ -156,6 +157,13 @@ export interface WrappingAndBracesStyle extends Style {
     readonly ifStatement: WrappingAndBracesStyle.IfStatement;
 }
 
+export namespace WrappingAndBracesStyle {
+    export interface IfStatement {
+        readonly kind: typeof WrappingAndBracesStyleDetailKind.WrappingAndBracesStyleIfStatement;
+        readonly elseOnNewLine: boolean;
+    }
+}
+
 export interface BlankLinesStyle extends Style {
     readonly kind: "org.openrewrite.javascript.style.BlankLinesStyle";
     readonly keepMaximum: BlankLinesStyle.KeepMaximum;
@@ -178,11 +186,15 @@ export namespace BlankLinesStyle {
     }
 }
 
-export namespace WrappingAndBracesStyle {
-    export interface IfStatement {
-        readonly kind: typeof WrappingAndBracesStyleDetailKind.WrappingAndBracesStyleIfStatement;
-        readonly elseOnNewLine: boolean;
-    }
+export interface TabsAndIndentsStyle extends Style {
+    readonly kind: typeof StyleKind.TabsAndIndentsStyle;
+    readonly useTabCharacter: boolean;
+    readonly tabSize: number;
+    readonly indentSize: number;
+    readonly continuationIndent: number;
+    readonly keepIndentsOnEmptyLines: boolean;
+    readonly indentChainedMethods: boolean;
+    readonly indentAllChainedCallsInAGroup: boolean;
 }
 
 export namespace IntelliJ {
@@ -194,7 +206,7 @@ export namespace IntelliJ {
             displayName: "IntelliJ IDEA",
             description: "Default IntelliJ IDEA code style.",
             tags: [],
-            styles: [spaces(), wrappingAndBraces(), blankLines()],
+            styles: [spaces(), wrappingAndBraces(), blankLines(), tabsAndIndents()],
         }
 
         export function spaces(): SpacesStyle {
@@ -315,6 +327,19 @@ export namespace IntelliJ {
                 }
             };
         }
+
+        export function tabsAndIndents(): TabsAndIndentsStyle {
+            return {
+                kind: StyleKind.TabsAndIndentsStyle,
+                useTabCharacter: false,
+                tabSize: 4,
+                indentSize: 4,
+                continuationIndent: 4,
+                keepIndentsOnEmptyLines: false,
+                indentChainedMethods: true,
+                indentAllChainedCallsInAGroup: false
+            };
+        }
     }
 
     export namespace TypeScript {
@@ -325,7 +350,7 @@ export namespace IntelliJ {
             displayName: "IntelliJ IDEA",
             description: "Default IntelliJ IDEA code style.",
             tags: [],
-            styles: [spaces(), wrappingAndBraces(), blankLines()],
+            styles: [spaces(), wrappingAndBraces(), blankLines(), tabsAndIndents()],
         }
 
         export function spaces(): SpacesStyle {
@@ -448,6 +473,19 @@ export namespace IntelliJ {
                 }
             };
         }
+
+        export function tabsAndIndents(): TabsAndIndentsStyle {
+            return {
+                kind: StyleKind.TabsAndIndentsStyle,
+                useTabCharacter: false,
+                tabSize: 4,
+                indentSize: 4,
+                continuationIndent: 4,
+                keepIndentsOnEmptyLines: false,
+                indentChainedMethods: true,
+                indentAllChainedCallsInAGroup: false
+            };
+        }
     }
 }
 

package/src/javascript/tree.ts

@@ -17,7 +17,7 @@
  */
 
 import {SourceFile, TreeKind} from "../";
-import {Expression, J, JavaType, Statement, TypedTree, TypeTree, VariableDeclarator,} from "../java";
+import {Expression, J, JavaType, NameTree, Statement, TypedTree, TypeTree, VariableDeclarator,} from "../java";
 import getType = TypedTree.getType;
 import FunctionType = JS.FunctionType;
 
@@ -30,9 +30,12 @@ export namespace JS {
         Alias: "org.openrewrite.javascript.tree.JS$Alias",
         ArrayBindingPattern: "org.openrewrite.javascript.tree.JS$ArrayBindingPattern",
         ArrowFunction: "org.openrewrite.javascript.tree.JS$ArrowFunction",
+        AssignmentOperation: "org.openrewrite.javascript.tree.JS$AssignmentOperation",
         Await: "org.openrewrite.javascript.tree.JS$Await",
+        Binary: "org.openrewrite.javascript.tree.JS$Binary",
         BindingElement: "org.openrewrite.javascript.tree.JS$BindingElement",
         CompilationUnit: "org.openrewrite.javascript.tree.JS$CompilationUnit",
+        ComputedPropertyMethodDeclaration: "org.openrewrite.javascript.tree.JS$ComputedPropertyMethodDeclaration",
         ComputedPropertyName: "org.openrewrite.javascript.tree.JS$ComputedPropertyName",
         ConditionalType: "org.openrewrite.javascript.tree.JS$ConditionalType",
         Delete: "org.openrewrite.javascript.tree.JS$Delete",
@@ -55,9 +58,11 @@ export namespace JS {
         Intersection: "org.openrewrite.javascript.tree.JS$Intersection",
         ForInLoop: "org.openrewrite.javascript.tree.JS$ForInLoop",
         ForOfLoop: "org.openrewrite.javascript.tree.JS$ForOfLoop",
-        ComputedPropertyMethodDeclaration: "org.openrewrite.javascript.tree.JS$ComputedPropertyMethodDeclaration",
-        AssignmentOperation: "org.openrewrite.javascript.tree.JS$AssignmentOperation",
-        Binary: "org.openrewrite.javascript.tree.JS$Binary",
+        JsxEmbeddedExpression: "org.openrewrite.javascript.tree.JSX$EmbeddedExpression",
+        JsxSpreadAttribute: "org.openrewrite.javascript.tree.JSX$SpreadAttribute",
+        JsxNamespacedName: "org.openrewrite.javascript.tree.JSX$NamespacedName",
+        JsxTag: "org.openrewrite.javascript.tree.JSX$Tag",
+        JsxAttribute: "org.openrewrite.javascript.tree.JSX$Attribute",
         Import: "org.openrewrite.javascript.tree.JS$Import",
         ImportClause: "org.openrewrite.javascript.tree.JS$ImportClause",
         ImportSpecifier: "org.openrewrite.javascript.tree.JS$ImportSpecifier",
@@ -822,6 +827,72 @@ export namespace JS {
     }
 }
 
+export namespace JSX {
+    /**
+     * Represents a JSX tag. Note that `selfClosing` and `children` are mutually exclusive.
+     * @example <div>{child}</div>
+     */
+    export type Tag =
+        (BaseTag & {
+            readonly selfClosing: J.Space;
+            readonly children?: undefined;
+            readonly closingName?: undefined;
+            readonly afterClosingName?: undefined;
+        }) |
+        (BaseTag & {
+            readonly selfClosing?: undefined;
+            readonly children: J.RightPadded<EmbeddedExpression | Tag | J.Identifier | J.Literal | J.Empty>[];
+            readonly closingName: J.LeftPadded<J.Identifier | J.FieldAccess | NamespacedName | J.Empty>;
+            readonly afterClosingName: J.Space;
+        });
+
+    interface BaseTag extends JS, Expression {
+        readonly kind: typeof JS.Kind.JsxTag;
+        readonly openName: J.LeftPadded<J.Identifier | J.FieldAccess | NamespacedName | J.Empty>;
+        readonly afterName: J.Space;
+        readonly attributes: J.RightPadded<Attribute | SpreadAttribute>[];
+    }
+
+    /**
+     * Represents a single JSX attribute.
+     * @example prop="value"
+     */
+    export interface Attribute extends JS {
+        readonly kind: typeof JS.Kind.JsxAttribute;
+        readonly key: J.Identifier | NamespacedName;
+        readonly value?: J.LeftPadded<Expression>;
+    }
+
+    /**
+     * Represents a spread attribute in JSX.
+     * @example {...props}
+     */
+    export interface SpreadAttribute extends JS {
+        readonly kind: typeof JS.Kind.JsxSpreadAttribute;
+        readonly dots: J.Space
+        readonly expression: J.RightPadded<Expression>;
+    }
+
+    /**
+     * Represents a JSX expression container.
+     * @example {expression}
+     */
+    export interface EmbeddedExpression extends JS, Expression {
+        readonly kind: typeof JS.Kind.JsxEmbeddedExpression;
+        readonly expression: J.RightPadded<Expression>;
+    }
+
+    /**
+     * Represents a namespaced JSX name.
+     * @example namespace:Name
+     */
+    export interface NamespacedName extends JS, NameTree {
+        readonly kind: typeof JS.Kind.JsxNamespacedName;
+        readonly namespace: J.Identifier;
+        readonly name: J.LeftPadded<J.Identifier>;
+    }
+}
+
 const KindValues = new Set(Object.values(JS.Kind));
 
 export function isJavaScript(tree: any): tree is JS {