@openrewrite/rewrite 8.53.0 → 8.53.1

package/src/javascript/visitor.ts

@@ -18,7 +18,7 @@
 import {mapAsync, SourceFile, ValidImmerRecipeReturnType} from "../";
 import {Expression, J, JavaType, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
 import {createDraft, Draft, finishDraft} from "immer";
-import {isJavaScript, JS} from "./tree";
+import {isJavaScript, JS, JSX} from "./tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
 
 export class JavaScriptVisitor<P> extends JavaVisitor<P> {
@@ -116,6 +116,45 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         });
     }
 
+    protected async visitJsxTag(element: JSX.Tag, p: P): Promise<J | undefined> {
+        return this.produceJavaScript<JSX.Tag>(element, p, async draft => {
+            draft.openName = await this.visitLeftPadded(element.openName, p);
+            draft.afterName = await this.visitSpace(element.afterName, p);
+            draft.attributes = await mapAsync(element.attributes, attr => this.visitRightPadded(attr, p));
+            draft.selfClosing = element.selfClosing && await this.visitSpace(element.selfClosing, p);
+            draft.children = element.children && await mapAsync(element.children, child => this.visitRightPadded(child, p));
+            draft.closingName = element.closingName && await this.visitLeftPadded(element.closingName, p);
+            draft.afterClosingName = element.afterClosingName && await this.visitSpace(element.afterClosingName, p);
+        });
+    }
+
+    protected async visitJsxAttribute(attribute: JSX.Attribute, p: P): Promise<J | undefined> {
+        return this.produceJavaScript<JSX.Attribute>(attribute, p, async draft => {
+            draft.key = await this.visitDefined<J.Identifier | JSX.NamespacedName>(attribute.key, p);
+            draft.value = attribute.value && await this.visitLeftPadded(attribute.value, p);
+        });
+    }
+
+    protected async visitJsxSpreadAttribute(spread: JSX.SpreadAttribute, p: P): Promise<J | undefined> {
+        return this.produceJavaScript<JSX.SpreadAttribute>(spread, p, async draft => {
+            draft.dots = await this.visitSpace(spread.dots, p);
+            draft.expression = await this.visitRightPadded(spread.expression, p);
+        });
+    }
+
+    protected async visitJsxExpression(expr: JSX.EmbeddedExpression, p: P): Promise<J | undefined> {
+        return this.produceJavaScript<JSX.EmbeddedExpression>(expr, p, async draft => {
+            draft.expression = await this.visitRightPadded(expr.expression, p);
+        });
+    }
+
+    protected async visitJsxNamespacedName(ns: JSX.NamespacedName, p: P): Promise<J | undefined> {
+        return this.produceJavaScript<JSX.NamespacedName>(ns, p, async draft => {
+            draft.namespace = await this.visitDefined<J.Identifier>(ns.namespace, p);
+            draft.name = await this.visitLeftPadded(ns.name, p);
+        });
+    }
+
     protected async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, p: P): Promise<J | undefined> {
         return this.produceJavaScript<JS.CompilationUnit>(compilationUnit, p, async draft => {
             draft.statements = await mapAsync(compilationUnit.statements, stmt => this.visitRightPadded(stmt, p));
@@ -232,6 +271,12 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     protected async visitImportDeclaration(jsImport: JS.Import, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(jsImport, p);
+        if (!statement?.kind || statement.kind !== JS.Kind.Import) {
+            return statement;
+        }
+        jsImport = statement as JS.Import;
+
         return this.produceJavaScript<JS.Import>(jsImport, p, async draft => {
             draft.importClause = jsImport.importClause && await this.visitDefined<JS.ImportClause>(jsImport.importClause, p);
             draft.moduleSpecifier = await this.visitLeftPadded(jsImport.moduleSpecifier, p);
@@ -872,6 +917,16 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
                     return this.visitImportTypeAttributes(tree as unknown as JS.ImportTypeAttributes, p);
                 case JS.Kind.ImportAttribute:
                     return this.visitImportAttribute(tree as unknown as JS.ImportAttribute, p);
+                case JS.Kind.JsxAttribute:
+                    return this.visitJsxAttribute(tree as unknown as JSX.Attribute, p);
+                case JS.Kind.JsxSpreadAttribute:
+                    return this.visitJsxSpreadAttribute(tree as unknown as JSX.SpreadAttribute, p);
+                case JS.Kind.JsxEmbeddedExpression:
+                    return this.visitJsxExpression(tree as unknown as JSX.EmbeddedExpression, p);
+                case JS.Kind.JsxNamespacedName:
+                    return this.visitJsxNamespacedName(tree as unknown as JSX.NamespacedName, p);
+                case JS.Kind.JsxTag:
+                    return this.visitJsxTag(tree as unknown as JSX.Tag, p);
                 case JS.Kind.Binary:
                     return this.visitBinaryExtensions(tree as unknown as JS.Binary, p);
                 case JS.Kind.LiteralType:

package/src/tree.ts

@@ -56,6 +56,11 @@ export class Cursor {
         return this._messages;
     }
 
+    getNearestMessage<T>(key: string): any {
+        const t = this._messages == undefined ? undefined : this._messages.get(key);
+        return t == null && this.parent != null ? this.parent.getNearestMessage<T>(key) : t;
+    }
+
     asArray(): any[] {
         const path: any[] = [];
         let current: Cursor | undefined = this;