@openrewrite/rewrite 8.69.0-20251207-184829 → 8.69.0-20251207-220615

package/src/index.ts

@@ -35,16 +35,16 @@ export * from "./run";
 
 // register all recipes in this package
 export async function activate(registry: RecipeRegistry): Promise<void> {
-    const {OrderImports} = await import("./recipe/index.js");
     const {ModernizeOctalEscapeSequences, ModernizeOctalLiterals, RemoveDuplicateObjectKeys} = await import("./javascript/migrate/es6/index.js");
     const {ExportAssignmentToExportDefault} = await import("./javascript/migrate/typescript/index.js");
     const {UseObjectPropertyShorthand, PreferOptionalChain, AddParseIntRadix} = await import("./javascript/cleanup/index.js");
-    const {AsyncCallbackInSyncArrayMethod, UpgradeDependencyVersion} = await import("./javascript/recipes/index.js");
+    const {AsyncCallbackInSyncArrayMethod, AutoFormat, UpgradeDependencyVersion, OrderImports, ChangeImport} = await import("./javascript/recipes/index.js");
     const {FindDependency} = await import("./javascript/search/index.js");
 
     registry.register(ExportAssignmentToExportDefault);
     registry.register(FindDependency);
     registry.register(OrderImports);
+    registry.register(ChangeImport);
     registry.register(ModernizeOctalEscapeSequences);
     registry.register(ModernizeOctalLiterals);
     registry.register(RemoveDuplicateObjectKeys);
@@ -52,6 +52,7 @@ export async function activate(registry: RecipeRegistry): Promise<void> {
     registry.register(PreferOptionalChain);
     registry.register(AddParseIntRadix);
     registry.register(AsyncCallbackInSyncArrayMethod);
+    registry.register(AutoFormat);
     registry.register(UpgradeDependencyVersion);
 }
 

package/src/javascript/parser.ts

@@ -367,11 +367,14 @@ export class JavaScriptParserVisitor {
         }
 
         let shebangStatement: J.RightPadded<JS.Shebang> | undefined;
+        let shebangTrailingSpace: J.Space | undefined;
         if (prefix.whitespace?.startsWith('#!')) {
             const newlineIndex = prefix.whitespace.indexOf('\n');
             const shebangText = newlineIndex === -1 ? prefix.whitespace : prefix.whitespace.slice(0, newlineIndex);
-            // Include all whitespace after shebang (including blank lines) in the shebang's after space
-            const afterShebang = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex);
+            // Shebang's after only contains the newline that terminates the shebang line
+            // The remaining whitespace and comments go into the first statement's prefix
+            const afterShebangNewline = newlineIndex === -1 ? '' : '\n';
+            const remainingWhitespace = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex + 1);
 
             shebangStatement = this.rightPadded<JS.Shebang>({
                 kind: JS.Kind.Shebang,
@@ -379,14 +382,38 @@ export class JavaScriptParserVisitor {
                 prefix: emptySpace,
                 markers: emptyMarkers,
                 text: shebangText
-            }, {kind: J.Kind.Space, whitespace: afterShebang, comments: []}, emptyMarkers);
+            }, {kind: J.Kind.Space, whitespace: afterShebangNewline, comments: []}, emptyMarkers);
+
+            // Store the trailing whitespace and comments to prepend to first statement
+            if (remainingWhitespace || prefix.comments.length > 0) {
+                shebangTrailingSpace = {kind: J.Kind.Space, whitespace: remainingWhitespace, comments: prefix.comments};
+            }
 
             // CU prefix should be empty when there's a shebang
             prefix = produce(prefix, draft => {
                 draft.whitespace = '';
+                draft.comments = [];
             });
         }
 
+        let statements = this.semicolonPaddedStatementList(node.statements);
+
+        // If there's trailing whitespace/comments after the shebang, prepend to first statement's prefix
+        if (shebangTrailingSpace && statements.length > 0) {
+            const firstStmt = statements[0];
+            statements = [
+                produce(firstStmt, draft => {
+                    const existingPrefix = draft.element.prefix;
+                    draft.element.prefix = {
+                        kind: J.Kind.Space,
+                        whitespace: shebangTrailingSpace!.whitespace + existingPrefix.whitespace,
+                        comments: [...shebangTrailingSpace!.comments, ...existingPrefix.comments]
+                    };
+                }),
+                ...statements.slice(1)
+            ];
+        }
+
         return {
             kind: JS.Kind.CompilationUnit,
             id: randomId(),
@@ -396,8 +423,8 @@ export class JavaScriptParserVisitor {
             charsetName: bomAndTextEncoding.encoding,
             charsetBomMarked: bomAndTextEncoding.hasBom,
             statements: shebangStatement
-                ? [shebangStatement, ...this.semicolonPaddedStatementList(node.statements)]
-                : this.semicolonPaddedStatementList(node.statements),
+                ? [shebangStatement, ...statements]
+                : statements,
             eof: this.prefix(node.endOfFileToken)
         };
     }
@@ -3788,15 +3815,29 @@ export class JavaScriptParserVisitor {
     }
 
     visitJsxExpression(node: ts.JsxExpression): JSX.EmbeddedExpression {
+        let expr: Expression;
+        if (node.expression) {
+            if (node.dotDotDotToken) {
+                expr = produce(this.convert<Expression>(node.expression), draft => {
+                    draft.markers.markers.push({
+                        kind: JS.Markers.Spread,
+                        id: randomId(),
+                        prefix: this.prefix(node.dotDotDotToken!)
+                    } satisfies Spread as Spread);
+                });
+            } else {
+                expr = this.convert<Expression>(node.expression);
+            }
+        } else {
+            expr = this.newEmpty();
+        }
         return {
             kind: JS.Kind.JsxEmbeddedExpression,
             id: randomId(),
             prefix: this.prefix(node),
             markers: emptyMarkers,
             expression: this.rightPadded(
-                node.expression ?
-                    this.convert<Expression>(node.expression) :
-                    this.newEmpty(),
+                expr,
                 this.prefix(this.findChildNode(node, ts.SyntaxKind.CloseBraceToken)!)
             )
         };

package/src/javascript/recipes/auto-format.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Recipe} from "../../recipe";
+import {TreeVisitor} from "../../visitor";
+import {ExecutionContext} from "../../execution";
+import {AutoformatVisitor} from "../format";
+
+/**
+ * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
+ *
+ * This recipe applies the following formatting:
+ * - Normalizes whitespace
+ * - Ensures minimum viable spacing
+ * - Applies blank line rules
+ * - Applies wrapping and braces rules
+ * - Applies spacing rules
+ * - Applies tabs and indentation rules
+ *
+ * The formatting rules are determined by the style settings attached to the source file,
+ * or defaults to IntelliJ IDEA style if no custom style is specified.
+ */
+export class AutoFormat extends Recipe {
+    readonly name = "org.openrewrite.javascript.format.auto-format";
+    readonly displayName = "Auto-format JavaScript/TypeScript code";
+    readonly description = "Format JavaScript and TypeScript code using a comprehensive set of formatting rules based on the project's style settings.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new AutoformatVisitor();
+    }
+}