JavaScript: More formatter fixes

Author: knutwannheden

rewrite-javascript/rewrite/src/java/formatting-utils.ts

@@ -64,6 +64,56 @@ export function replaceIndentAfterLastNewline(ws: string, newIndent: string): st
     return ws.substring(0, lastNewline + 1) + newIndent;
 }
 
+/**
+ * Checks if a Space contains any newlines (in whitespace or comment suffixes).
+ */
+export function spaceContainsNewline(space: J.Space | undefined): boolean {
+    if (!space) return false;
+    if (space.whitespace.includes("\n")) return true;
+    return space.comments.some(c => c.suffix.includes("\n"));
+}
+
+/**
+ * Normalizes indentation in an entire Space, including both whitespace and comment suffixes.
+ * Each newline followed by whitespace gets its indentation normalized to the target indent.
+ *
+ * @param space The Space to normalize
+ * @param targetIndent The indentation to use after newlines
+ * @returns The normalized Space, or the original if unchanged
+ */
+export function normalizeSpaceIndent(space: J.Space, targetIndent: string): J.Space {
+    let changed = false;
+
+    // Normalize whitespace
+    let newWhitespace = space.whitespace;
+    if (space.whitespace.includes("\n")) {
+        newWhitespace = replaceIndentAfterLastNewline(space.whitespace, targetIndent);
+        changed = changed || newWhitespace !== space.whitespace;
+    }
+
+    // Normalize comment suffixes
+    const newComments = space.comments.map(comment => {
+        if (comment.suffix.includes("\n")) {
+            const newSuffix = replaceIndentAfterLastNewline(comment.suffix, targetIndent);
+            if (newSuffix !== comment.suffix) {
+                changed = true;
+                return {...comment, suffix: newSuffix};
+            }
+        }
+        return comment;
+    });
+
+    if (!changed) {
+        return space;
+    }
+
+    return {
+        ...space,
+        whitespace: newWhitespace,
+        comments: newComments
+    };
+}
+
 /**
  * Handles element removal from lists while preserving LST formatting.
  * Automatically applies prefixes from removed elements to the next kept element,

rewrite-javascript/rewrite/src/javascript/format.ts

@@ -311,11 +311,17 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         const ret = await super.visitImportDeclaration(jsImport, p) as JS.Import;
         return produce(ret, draft => {
             if (draft.importClause) {
-                draft.importClause.prefix.whitespace = draft.importClause.namedBindings && !draft.importClause.typeOnly ? "" : " ";
+                // Space after 'import' keyword:
+                // - If there's a default import (name), space goes in importClause.prefix
+                // - If typeOnly (import type ...), space goes in importClause.prefix (before 'type')
+                // - If only namedBindings (no default, no type), space goes in namedBindings.prefix (importClause.prefix is empty)
+                const hasDefaultImport = !!draft.importClause.name;
+                draft.importClause.prefix.whitespace = (hasDefaultImport || draft.importClause.typeOnly) ? " " : "";
                 if (draft.importClause.name) {
                     draft.importClause.name.after.whitespace = "";
                 }
                 if (draft.importClause.namedBindings) {
+                    // Space before namedBindings - always needed
                     draft.importClause.namedBindings.prefix.whitespace = " ";
                     if (draft.importClause.namedBindings.kind == JS.Kind.NamedImports) {
                         const ni = draft.importClause.namedBindings as Draft<JS.NamedImports>;

rewrite-javascript/rewrite/src/javascript/parser.ts

@@ -3474,7 +3474,7 @@ export class JavaScriptParserVisitor {
             statements: node.clauses.map(clause =>
                 this.rightPadded(
                     this.visit(clause),
-                    this.suffix(clause)
+                    emptySpace
                 )),
             end: end
         }