@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/add-import.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AddImport = exports.ImportStyle = void 0;
 exports.maybeAddImport = maybeAddImport;
@@ -267,260 +258,254 @@ class AddImport extends visitor_1.JavaScriptVisitor {
         }
         return null;
     }
-    visitJsCompilationUnit(compilationUnit, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // First, check if the import already exists
-            const hasImport = yield this.checkImportExists(compilationUnit);
-            if (hasImport) {
+    async visitJsCompilationUnit(compilationUnit, p) {
+        // First, check if the import already exists
+        const hasImport = await this.checkImportExists(compilationUnit);
+        if (hasImport) {
+            return compilationUnit;
+        }
+        // If onlyIfReferenced is true, check if the identifier is actually used
+        // Skip this check for side-effect imports
+        if (!this.sideEffectOnly && this.onlyIfReferenced) {
+            const isReferenced = await this.checkIdentifierReferenced(compilationUnit);
+            if (!isReferenced) {
                 return compilationUnit;
             }
-            // If onlyIfReferenced is true, check if the identifier is actually used
-            // Skip this check for side-effect imports
-            if (!this.sideEffectOnly && this.onlyIfReferenced) {
-                const isReferenced = yield this.checkIdentifierReferenced(compilationUnit);
-                if (!isReferenced) {
-                    return compilationUnit;
-                }
-            }
-            // Determine the appropriate import style
-            const importStyle = this.determineImportStyle(compilationUnit);
-            // For named imports, check if we can merge into an existing import from the same module
-            // This handles both:
-            // - Case 1: Existing import has named bindings - merge into them
-            // - Case 2: Default import without named bindings - add named bindings
-            // Don't try to merge default imports (member === 'default'), side-effect imports, or namespace imports (member === '*')
-            if (!this.sideEffectOnly && this.member !== undefined && this.member !== 'default' && this.member !== '*') {
-                const mergedCu = yield this.tryMergeIntoExistingImport(compilationUnit, p);
-                if (mergedCu !== compilationUnit) {
-                    return mergedCu;
-                }
+        }
+        // Determine the appropriate import style
+        const importStyle = this.determineImportStyle(compilationUnit);
+        // For named imports, check if we can merge into an existing import from the same module
+        // This handles both:
+        // - Case 1: Existing import has named bindings - merge into them
+        // - Case 2: Default import without named bindings - add named bindings
+        // Don't try to merge default imports (member === 'default'), side-effect imports, or namespace imports (member === '*')
+        if (!this.sideEffectOnly && this.member !== undefined && this.member !== 'default' && this.member !== '*') {
+            const mergedCu = await this.tryMergeIntoExistingImport(compilationUnit, p);
+            if (mergedCu !== compilationUnit) {
+                return mergedCu;
             }
-            // Add the import using the appropriate style
-            if (importStyle === ImportStyle.CommonJS) {
-                // TODO: Implement CommonJS require creation
-                // For now, fall back to ES6 imports
-                // return this.addCommonJSRequire(compilationUnit, p);
+        }
+        // Add the import using the appropriate style
+        if (importStyle === ImportStyle.CommonJS) {
+            // TODO: Implement CommonJS require creation
+            // For now, fall back to ES6 imports
+            // return this.addCommonJSRequire(compilationUnit, p);
+        }
+        // Add ES6 import (handles ES6Named, ES6Namespace, ES6Default)
+        return this.produceJavaScript(compilationUnit, p, async (draft) => {
+            // Find the position to insert the import
+            const insertionIndex = this.findImportInsertionIndex(compilationUnit);
+            const newImport = await this.createImportStatement(compilationUnit, insertionIndex, p);
+            // Insert the import at the appropriate position
+            // Create semicolon marker for the import statement
+            const semicolonMarkers = (0, markers_1.markers)({
+                kind: java_1.J.Markers.Semicolon,
+                id: (0, uuid_1.randomId)()
+            });
+            if (insertionIndex === 0) {
+                // Insert at the beginning
+                // The `after` space should be empty since semicolon is printed after it
+                // The spacing comes from updating the next statement's prefix
+                const updatedStatements = compilationUnit.statements.length > 0
+                    ? [
+                        (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
+                        Object.assign(Object.assign({}, compilationUnit.statements[0]), { element: compilationUnit.statements[0].element
+                                ? Object.assign(Object.assign({}, compilationUnit.statements[0].element), { prefix: (0, java_1.space)("\n\n") }) : undefined }),
+                        ...compilationUnit.statements.slice(1)
+                    ]
+                    : [(0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers)];
+                draft.statements = updatedStatements;
             }
-            // Add ES6 import (handles ES6Named, ES6Namespace, ES6Default)
-            return this.produceJavaScript(compilationUnit, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                // Find the position to insert the import
-                const insertionIndex = this.findImportInsertionIndex(compilationUnit);
-                const newImport = yield this.createImportStatement(compilationUnit, insertionIndex, p);
-                // Insert the import at the appropriate position
-                // Create semicolon marker for the import statement
-                const semicolonMarkers = (0, markers_1.markers)({
-                    kind: java_1.J.Markers.Semicolon,
-                    id: (0, uuid_1.randomId)()
-                });
-                if (insertionIndex === 0) {
-                    // Insert at the beginning
-                    // The `after` space should be empty since semicolon is printed after it
-                    // The spacing comes from updating the next statement's prefix
-                    const updatedStatements = compilationUnit.statements.length > 0
-                        ? [
-                            (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
-                            Object.assign(Object.assign({}, compilationUnit.statements[0]), { element: compilationUnit.statements[0].element
-                                    ? Object.assign(Object.assign({}, compilationUnit.statements[0].element), { prefix: (0, java_1.space)("\n\n") }) : undefined }),
-                            ...compilationUnit.statements.slice(1)
-                        ]
-                        : [(0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers)];
-                    draft.statements = updatedStatements;
+            else {
+                // Insert after existing imports
+                const before = compilationUnit.statements.slice(0, insertionIndex);
+                const after = compilationUnit.statements.slice(insertionIndex);
+                //The `after` space is empty, spacing comes from next statement's prefix
+                // Ensure the next statement has at least one newline in its prefix
+                if (after.length > 0 && after[0].element) {
+                    const currentPrefix = after[0].element.prefix;
+                    const needsNewline = !currentPrefix.whitespace.includes('\n');
+                    const updatedNextStatement = needsNewline ? Object.assign(Object.assign({}, after[0]), { element: Object.assign(Object.assign({}, after[0].element), { prefix: (0, java_1.space)("\n" + currentPrefix.whitespace) }) }) : after[0];
+                    draft.statements = [
+                        ...before,
+                        (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
+                        updatedNextStatement,
+                        ...after.slice(1)
+                    ];
                 }
                 else {
-                    // Insert after existing imports
-                    const before = compilationUnit.statements.slice(0, insertionIndex);
-                    const after = compilationUnit.statements.slice(insertionIndex);
-                    //The `after` space is empty, spacing comes from next statement's prefix
-                    // Ensure the next statement has at least one newline in its prefix
-                    if (after.length > 0 && after[0].element) {
-                        const currentPrefix = after[0].element.prefix;
-                        const needsNewline = !currentPrefix.whitespace.includes('\n');
-                        const updatedNextStatement = needsNewline ? Object.assign(Object.assign({}, after[0]), { element: Object.assign(Object.assign({}, after[0].element), { prefix: (0, java_1.space)("\n" + currentPrefix.whitespace) }) }) : after[0];
-                        draft.statements = [
-                            ...before,
-                            (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
-                            updatedNextStatement,
-                            ...after.slice(1)
-                        ];
-                    }
-                    else {
-                        draft.statements = [
-                            ...before,
-                            (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
-                            ...after
-                        ];
-                    }
+                    draft.statements = [
+                        ...before,
+                        (0, java_1.rightPadded)(newImport, java_1.emptySpace, semicolonMarkers),
+                        ...after
+                    ];
                 }
-            }));
+            }
         });
     }
     /**
      * Try to merge the new member into an existing import from the same module
      */
-    tryMergeIntoExistingImport(compilationUnit, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            for (let i = 0; i < compilationUnit.statements.length; i++) {
-                const stmt = compilationUnit.statements[i];
-                const statement = stmt.element;
-                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
-                    const jsImport = statement;
-                    const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
-                    if (!moduleSpecifier) {
-                        continue;
-                    }
-                    const moduleName = this.getModuleName(moduleSpecifier);
-                    // Check if this is an import from our target module
-                    if (moduleName !== this.module) {
-                        continue;
-                    }
-                    const importClause = jsImport.importClause;
-                    if (!importClause) {
-                        continue;
-                    }
-                    // Only merge into imports with matching typeOnly - don't mix type and value imports
-                    if (importClause.typeOnly !== this.typeOnly) {
+    async tryMergeIntoExistingImport(compilationUnit, p) {
+        var _a;
+        for (let i = 0; i < compilationUnit.statements.length; i++) {
+            const stmt = compilationUnit.statements[i];
+            const statement = stmt.element;
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                const jsImport = statement;
+                const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+                if (!moduleSpecifier) {
+                    continue;
+                }
+                const moduleName = this.getModuleName(moduleSpecifier);
+                // Check if this is an import from our target module
+                if (moduleName !== this.module) {
+                    continue;
+                }
+                const importClause = jsImport.importClause;
+                if (!importClause) {
+                    continue;
+                }
+                // Only merge into imports with matching typeOnly - don't mix type and value imports
+                if (importClause.typeOnly !== this.typeOnly) {
+                    continue;
+                }
+                // Case 1: Existing import has named bindings - merge into them
+                if (importClause.namedBindings) {
+                    // Only merge into NamedImports, not namespace imports
+                    if (importClause.namedBindings.kind !== tree_1.JS.Kind.NamedImports) {
                         continue;
                     }
-                    // Case 1: Existing import has named bindings - merge into them
-                    if (importClause.namedBindings) {
-                        // Only merge into NamedImports, not namespace imports
-                        if (importClause.namedBindings.kind !== tree_1.JS.Kind.NamedImports) {
-                            continue;
-                        }
-                        // We found a matching import with named bindings - merge into it
-                        return this.produceJavaScript(compilationUnit, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                            var _a, _b, _c;
-                            const namedImports = importClause.namedBindings;
-                            const existingElements = namedImports.elements.elements;
-                            // Find the correct insertion position (alphabetical, case-insensitive)
-                            const newName = (this.alias || this.member).toLowerCase();
-                            let insertIndex = existingElements.findIndex(elem => {
-                                var _a;
-                                if (((_a = elem.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.ImportSpecifier) {
-                                    const name = this.getImportAlias(elem.element) || this.getImportName(elem.element);
-                                    return newName.localeCompare(name.toLowerCase()) < 0;
+                    // We found a matching import with named bindings - merge into it
+                    return this.produceJavaScript(compilationUnit, p, async (draft) => {
+                        var _a, _b, _c;
+                        const namedImports = importClause.namedBindings;
+                        const existingElements = namedImports.elements.elements;
+                        // Find the correct insertion position (alphabetical, case-insensitive)
+                        const newName = (this.alias || this.member).toLowerCase();
+                        let insertIndex = existingElements.findIndex(elem => {
+                            var _a;
+                            if (((_a = elem.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.ImportSpecifier) {
+                                const name = this.getImportAlias(elem.element) || this.getImportName(elem.element);
+                                return newName.localeCompare(name.toLowerCase()) < 0;
+                            }
+                            return false;
+                        });
+                        if (insertIndex === -1)
+                            insertIndex = existingElements.length;
+                        // Detect spacing style from existing elements:
+                        // - firstElementPrefix: space after { (from first element's prefix)
+                        // - trailingSpace: space before } (from last element's after)
+                        const firstElementPrefix = (_c = (_b = (_a = existingElements[0]) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.prefix) !== null && _c !== void 0 ? _c : java_1.emptySpace;
+                        const lastIndex = existingElements.length - 1;
+                        const trailingSpace = existingElements[lastIndex].after;
+                        // Build the new elements array with proper spacing
+                        const updatedNamedImports = await this.produceJavaScript(namedImports, p, async (namedDraft) => {
+                            const newSpecifier = this.createImportSpecifier();
+                            const newElements = existingElements.flatMap((elem, j) => {
+                                const results = [];
+                                if (j === insertIndex) {
+                                    // Insert new element here
+                                    // First element gets the same prefix as the original first element
+                                    // Other positions get a single space (separator after comma)
+                                    const prefix = j === 0 ? firstElementPrefix : java_1.singleSpace;
+                                    results.push((0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix }), java_1.emptySpace));
                                 }
-                                return false;
-                            });
-                            if (insertIndex === -1)
-                                insertIndex = existingElements.length;
-                            // Detect spacing style from existing elements:
-                            // - firstElementPrefix: space after { (from first element's prefix)
-                            // - trailingSpace: space before } (from last element's after)
-                            const firstElementPrefix = (_c = (_b = (_a = existingElements[0]) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.prefix) !== null && _c !== void 0 ? _c : java_1.emptySpace;
-                            const lastIndex = existingElements.length - 1;
-                            const trailingSpace = existingElements[lastIndex].after;
-                            // Build the new elements array with proper spacing
-                            const updatedNamedImports = yield this.produceJavaScript(namedImports, p, (namedDraft) => __awaiter(this, void 0, void 0, function* () {
-                                const newSpecifier = this.createImportSpecifier();
-                                const newElements = existingElements.flatMap((elem, j) => {
-                                    const results = [];
-                                    if (j === insertIndex) {
-                                        // Insert new element here
-                                        // First element gets the same prefix as the original first element
-                                        // Other positions get a single space (separator after comma)
-                                        const prefix = j === 0 ? firstElementPrefix : java_1.singleSpace;
-                                        results.push((0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix }), java_1.emptySpace));
-                                    }
-                                    // Adjust existing element: if inserting before first, give it space prefix
-                                    let adjusted = elem;
-                                    if (j === 0 && insertIndex === 0 && elem.element) {
-                                        adjusted = Object.assign(Object.assign({}, elem), { element: Object.assign(Object.assign({}, elem.element), { prefix: java_1.singleSpace }) });
-                                    }
-                                    // Last element before a new trailing element loses its trailing space
-                                    if (j === lastIndex && insertIndex > lastIndex) {
-                                        adjusted = Object.assign(Object.assign({}, adjusted), { after: java_1.emptySpace });
-                                    }
-                                    results.push(adjusted);
-                                    return results;
-                                });
-                                // Append at end if inserting after all existing elements
-                                if (insertIndex > lastIndex) {
-                                    newElements.push((0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix: java_1.singleSpace }), trailingSpace));
+                                // Adjust existing element: if inserting before first, give it space prefix
+                                let adjusted = elem;
+                                if (j === 0 && insertIndex === 0 && elem.element) {
+                                    adjusted = Object.assign(Object.assign({}, elem), { element: Object.assign(Object.assign({}, elem.element), { prefix: java_1.singleSpace }) });
                                 }
-                                namedDraft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: newElements });
-                            }));
-                            // Update the import with the new named imports
-                            const updatedImport = yield this.produceJavaScript(jsImport, p, (importDraft) => __awaiter(this, void 0, void 0, function* () {
-                                importDraft.importClause = yield this.produceJavaScript(importClause, p, (clauseDraft) => __awaiter(this, void 0, void 0, function* () {
-                                    clauseDraft.namedBindings = updatedNamedImports;
-                                }));
-                            }));
-                            // Replace the statement in the compilation unit
-                            draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
-                        }));
-                    }
-                    // Case 2: Default import without named bindings - add named bindings
-                    // Transform: import React from 'react' -> import React, { useState } from 'react'
-                    if (importClause.name && !importClause.namedBindings) {
-                        return this.produceJavaScript(compilationUnit, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                            const newSpecifier = this.createImportSpecifier();
-                            // Get the spaces style for brace spacing
-                            const spacesStyle = (0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, compilationUnit);
-                            const braceSpace = spacesStyle.within.es6ImportExportBraces ? java_1.singleSpace : java_1.emptySpace;
-                            // Create new NamedImports with a single element
-                            // Apply brace spacing: space after { is in specifier's prefix, space before } is in after
-                            const namedImports = {
-                                id: (0, uuid_1.randomId)(),
-                                kind: tree_1.JS.Kind.NamedImports,
-                                prefix: java_1.singleSpace,
-                                markers: markers_1.emptyMarkers,
-                                elements: {
-                                    kind: java_1.J.Kind.Container,
-                                    before: java_1.emptySpace,
-                                    elements: [(0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix: braceSpace }), braceSpace)],
-                                    markers: markers_1.emptyMarkers
+                                // Last element before a new trailing element loses its trailing space
+                                if (j === lastIndex && insertIndex > lastIndex) {
+                                    adjusted = Object.assign(Object.assign({}, adjusted), { after: java_1.emptySpace });
                                 }
-                            };
-                            // Update the import clause to include named bindings
-                            // Also update name.after to emptySpace since the comma goes right after the name
-                            const updatedImport = yield this.produceJavaScript(jsImport, p, (importDraft) => __awaiter(this, void 0, void 0, function* () {
-                                importDraft.importClause = yield this.produceJavaScript(importClause, p, (clauseDraft) => __awaiter(this, void 0, void 0, function* () {
-                                    // Remove space after default name (comma goes right after)
-                                    if (clauseDraft.name) {
-                                        clauseDraft.name = Object.assign(Object.assign({}, clauseDraft.name), { after: java_1.emptySpace });
-                                    }
-                                    clauseDraft.namedBindings = namedImports;
-                                }));
-                                // Ensure moduleSpecifier has proper space before 'from'
-                                if (importDraft.moduleSpecifier) {
-                                    importDraft.moduleSpecifier = Object.assign(Object.assign({}, importDraft.moduleSpecifier), { before: java_1.singleSpace });
+                                results.push(adjusted);
+                                return results;
+                            });
+                            // Append at end if inserting after all existing elements
+                            if (insertIndex > lastIndex) {
+                                newElements.push((0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix: java_1.singleSpace }), trailingSpace));
+                            }
+                            namedDraft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: newElements });
+                        });
+                        // Update the import with the new named imports
+                        const updatedImport = await this.produceJavaScript(jsImport, p, async (importDraft) => {
+                            importDraft.importClause = await this.produceJavaScript(importClause, p, async (clauseDraft) => {
+                                clauseDraft.namedBindings = updatedNamedImports;
+                            });
+                        });
+                        // Replace the statement in the compilation unit
+                        draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
+                    });
+                }
+                // Case 2: Default import without named bindings - add named bindings
+                // Transform: import React from 'react' -> import React, { useState } from 'react'
+                if (importClause.name && !importClause.namedBindings) {
+                    return this.produceJavaScript(compilationUnit, p, async (draft) => {
+                        const newSpecifier = this.createImportSpecifier();
+                        // Get the spaces style for brace spacing
+                        const spacesStyle = (0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, compilationUnit);
+                        const braceSpace = spacesStyle.within.es6ImportExportBraces ? java_1.singleSpace : java_1.emptySpace;
+                        // Create new NamedImports with a single element
+                        // Apply brace spacing: space after { is in specifier's prefix, space before } is in after
+                        const namedImports = {
+                            id: (0, uuid_1.randomId)(),
+                            kind: tree_1.JS.Kind.NamedImports,
+                            prefix: java_1.singleSpace,
+                            markers: markers_1.emptyMarkers,
+                            elements: {
+                                kind: java_1.J.Kind.Container,
+                                before: java_1.emptySpace,
+                                elements: [(0, java_1.rightPadded)(Object.assign(Object.assign({}, newSpecifier), { prefix: braceSpace }), braceSpace)],
+                                markers: markers_1.emptyMarkers
+                            }
+                        };
+                        // Update the import clause to include named bindings
+                        // Also update name.after to emptySpace since the comma goes right after the name
+                        const updatedImport = await this.produceJavaScript(jsImport, p, async (importDraft) => {
+                            importDraft.importClause = await this.produceJavaScript(importClause, p, async (clauseDraft) => {
+                                // Remove space after default name (comma goes right after)
+                                if (clauseDraft.name) {
+                                    clauseDraft.name = Object.assign(Object.assign({}, clauseDraft.name), { after: java_1.emptySpace });
                                 }
-                            }));
-                            // Replace the statement in the compilation unit
-                            draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
-                        }));
-                    }
+                                clauseDraft.namedBindings = namedImports;
+                            });
+                            // Ensure moduleSpecifier has proper space before 'from'
+                            if (importDraft.moduleSpecifier) {
+                                importDraft.moduleSpecifier = Object.assign(Object.assign({}, importDraft.moduleSpecifier), { before: java_1.singleSpace });
+                            }
+                        });
+                        // Replace the statement in the compilation unit
+                        draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
+                    });
                 }
             }
-            return compilationUnit;
-        });
+        }
+        return compilationUnit;
     }
     /**
      * Check if the import already exists in the compilation unit
      */
-    checkImportExists(compilationUnit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const stmt of compilationUnit.statements) {
-                const statement = stmt.element;
-                // Check ES6 imports
-                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
-                    const jsImport = statement;
-                    if (this.isMatchingImport(jsImport)) {
-                        return true;
-                    }
+    async checkImportExists(compilationUnit) {
+        for (const stmt of compilationUnit.statements) {
+            const statement = stmt.element;
+            // Check ES6 imports
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                const jsImport = statement;
+                if (this.isMatchingImport(jsImport)) {
+                    return true;
                 }
-                // Check CommonJS require statements
-                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
-                    const varDecl = statement;
-                    if (this.isMatchingRequire(varDecl)) {
-                        return true;
-                    }
+            }
+            // Check CommonJS require statements
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
+                const varDecl = statement;
+                if (this.isMatchingRequire(varDecl)) {
+                    return true;
                 }
             }
-            return false;
-        });
+        }
+        return false;
     }
     /**
      * Check if the import matches what we're trying to add
@@ -714,335 +699,311 @@ class AddImport extends visitor_1.JavaScriptVisitor {
     /**
      * Check if the identifier is actually referenced in the file
      */
-    checkIdentifierReferenced(compilationUnit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            // For namespace imports, we cannot use type attribution to detect usage
-            // because the namespace itself is used as an identifier, not individual members.
-            // For simplicity, we skip the onlyIfReferenced check for namespace imports.
-            if (this.member === '*') {
-                // TODO: Implement proper namespace usage detection by checking if alias identifier is used
-                return true;
-            }
-            // Step 1: Find the expected declaring type by examining existing imports from the same module
-            let expectedDeclaringType;
-            for (const stmt of compilationUnit.statements) {
-                const statement = stmt.element;
-                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
-                    const jsImport = statement;
-                    const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
-                    if (!moduleSpecifier) {
-                        continue;
-                    }
-                    const moduleName = this.getModuleName(moduleSpecifier);
-                    if (moduleName !== this.module) {
-                        continue; // Not the module we're interested in
-                    }
-                    // Found an existing import from our target module
-                    // Extract the declaring type from any imported member with type attribution
-                    const importClause = jsImport.importClause;
-                    if (((_b = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _b === void 0 ? void 0 : _b.kind) === tree_1.JS.Kind.NamedImports) {
-                        const namedImports = importClause.namedBindings;
-                        for (const elem of namedImports.elements.elements) {
-                            const specifier = elem.element;
-                            if ((specifier === null || specifier === void 0 ? void 0 : specifier.kind) === tree_1.JS.Kind.ImportSpecifier) {
-                                const importSpec = specifier;
-                                let identifier;
-                                if (((_c = importSpec.specifier) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Identifier) {
-                                    identifier = importSpec.specifier;
-                                }
-                                else if (((_d = importSpec.specifier) === null || _d === void 0 ? void 0 : _d.kind) === tree_1.JS.Kind.Alias) {
-                                    const aliasSpec = importSpec.specifier;
-                                    if (((_e = aliasSpec.alias) === null || _e === void 0 ? void 0 : _e.kind) === java_1.J.Kind.Identifier) {
-                                        identifier = aliasSpec.alias;
-                                    }
-                                }
-                                expectedDeclaringType = this.getModuleFromType(identifier === null || identifier === void 0 ? void 0 : identifier.type, identifier === null || identifier === void 0 ? void 0 : identifier.fieldType);
-                                if (expectedDeclaringType) {
-                                    break; // Found it!
+    async checkIdentifierReferenced(compilationUnit) {
+        var _a, _b, _c, _d, _e;
+        // For namespace imports, we cannot use type attribution to detect usage
+        // because the namespace itself is used as an identifier, not individual members.
+        // For simplicity, we skip the onlyIfReferenced check for namespace imports.
+        if (this.member === '*') {
+            // TODO: Implement proper namespace usage detection by checking if alias identifier is used
+            return true;
+        }
+        // Step 1: Find the expected declaring type by examining existing imports from the same module
+        let expectedDeclaringType;
+        for (const stmt of compilationUnit.statements) {
+            const statement = stmt.element;
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                const jsImport = statement;
+                const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+                if (!moduleSpecifier) {
+                    continue;
+                }
+                const moduleName = this.getModuleName(moduleSpecifier);
+                if (moduleName !== this.module) {
+                    continue; // Not the module we're interested in
+                }
+                // Found an existing import from our target module
+                // Extract the declaring type from any imported member with type attribution
+                const importClause = jsImport.importClause;
+                if (((_b = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _b === void 0 ? void 0 : _b.kind) === tree_1.JS.Kind.NamedImports) {
+                    const namedImports = importClause.namedBindings;
+                    for (const elem of namedImports.elements.elements) {
+                        const specifier = elem.element;
+                        if ((specifier === null || specifier === void 0 ? void 0 : specifier.kind) === tree_1.JS.Kind.ImportSpecifier) {
+                            const importSpec = specifier;
+                            let identifier;
+                            if (((_c = importSpec.specifier) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Identifier) {
+                                identifier = importSpec.specifier;
+                            }
+                            else if (((_d = importSpec.specifier) === null || _d === void 0 ? void 0 : _d.kind) === tree_1.JS.Kind.Alias) {
+                                const aliasSpec = importSpec.specifier;
+                                if (((_e = aliasSpec.alias) === null || _e === void 0 ? void 0 : _e.kind) === java_1.J.Kind.Identifier) {
+                                    identifier = aliasSpec.alias;
                                 }
                             }
+                            expectedDeclaringType = this.getModuleFromType(identifier === null || identifier === void 0 ? void 0 : identifier.type, identifier === null || identifier === void 0 ? void 0 : identifier.fieldType);
+                            if (expectedDeclaringType) {
+                                break; // Found it!
+                            }
                         }
                     }
-                    if (expectedDeclaringType) {
-                        break; // No need to scan more imports
-                    }
+                }
+                if (expectedDeclaringType) {
+                    break; // No need to scan more imports
                 }
             }
-            // Step 2: Look for references that match
-            const targetName = this.alias || this.member;
-            const targetModule = this.module;
-            let found = false;
-            const self = this;
-            // If no existing imports from this module, look for unresolved references
-            // If there ARE existing imports, look for references with the expected declaring type
-            const collector = new class extends visitor_1.JavaScriptVisitor {
-                visitIdentifier(identifier, p) {
-                    const _super = Object.create(null, {
-                        visitIdentifier: { get: () => super.visitIdentifier }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        if (identifier.simpleName === targetName) {
-                            const type = identifier.type;
-                            const fieldType = identifier.fieldType;
-                            if (expectedDeclaringType) {
-                                // We have an expected declaring type - check for exact match
-                                if (type && java_1.Type.isMethod(type)) {
-                                    const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(type.declaringType);
-                                    if (declaringTypeName === expectedDeclaringType) {
-                                        found = true;
-                                    }
-                                }
-                                else if (type && java_1.Type.isClass(type)) {
-                                    if (self.classTypeMatchesModule(type, expectedDeclaringType)) {
-                                        found = true;
-                                    }
-                                }
-                                else if ((fieldType === null || fieldType === void 0 ? void 0 : fieldType.kind) === java_1.Type.Kind.Variable) {
-                                    const ownerTypeName = fieldType.owner
-                                        ? java_1.Type.FullyQualified.getFullyQualifiedName(fieldType.owner)
-                                        : undefined;
-                                    if (ownerTypeName === expectedDeclaringType) {
-                                        found = true;
-                                    }
+        }
+        // Step 2: Look for references that match
+        const targetName = this.alias || this.member;
+        const targetModule = this.module;
+        let found = false;
+        const self = this;
+        // If no existing imports from this module, look for unresolved references
+        // If there ARE existing imports, look for references with the expected declaring type
+        const collector = new class extends visitor_1.JavaScriptVisitor {
+            async visitIdentifier(identifier, p) {
+                if (identifier.simpleName === targetName) {
+                    const type = identifier.type;
+                    const fieldType = identifier.fieldType;
+                    if (expectedDeclaringType) {
+                        // We have an expected declaring type - check for exact match
+                        if (type && java_1.Type.isMethod(type)) {
+                            const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(type.declaringType);
+                            if (declaringTypeName === expectedDeclaringType) {
+                                found = true;
+                            }
+                        }
+                        else if (type && java_1.Type.isClass(type)) {
+                            if (self.classTypeMatchesModule(type, expectedDeclaringType)) {
+                                found = true;
+                            }
+                        }
+                        else if ((fieldType === null || fieldType === void 0 ? void 0 : fieldType.kind) === java_1.Type.Kind.Variable) {
+                            const ownerTypeName = fieldType.owner
+                                ? java_1.Type.FullyQualified.getFullyQualifiedName(fieldType.owner)
+                                : undefined;
+                            if (ownerTypeName === expectedDeclaringType) {
+                                found = true;
+                            }
+                        }
+                        // Also check for unresolved references (member isn't imported yet)
+                        else if (!type && !fieldType) {
+                            found = true;
+                        }
+                    }
+                    else {
+                        // No existing imports from this module - look for references that match
+                        // 1. Unresolved references (no type/unknown type and no fieldType)
+                        const isUnknownType = !type || type.kind === java_1.Type.Kind.Unknown;
+                        if (isUnknownType && !fieldType) {
+                            found = true;
+                        }
+                        // 2. References with fieldType matching the target module
+                        else if ((fieldType === null || fieldType === void 0 ? void 0 : fieldType.kind) === java_1.Type.Kind.Variable) {
+                            const variableType = fieldType;
+                            if (variableType.owner && java_1.Type.isClass(variableType.owner)) {
+                                // Traverse owningClass chain to find the root module (handles nested namespaces)
+                                // For example: React.forwardRef -> owner is "React" namespace -> owningClass is "react" module
+                                let current = variableType.owner;
+                                // Walk up the owningClass chain until we reach the root
+                                while (current.owningClass && java_1.Type.isClass(current.owningClass)) {
+                                    current = current.owningClass;
                                 }
-                                // Also check for unresolved references (member isn't imported yet)
-                                else if (!type && !fieldType) {
+                                const moduleName = java_1.Type.FullyQualified.getFullyQualifiedName(current);
+                                if (moduleName === targetModule) {
                                     found = true;
                                 }
                             }
-                            else {
-                                // No existing imports from this module - look for references that match
-                                // 1. Unresolved references (no type/unknown type and no fieldType)
-                                const isUnknownType = !type || type.kind === java_1.Type.Kind.Unknown;
-                                if (isUnknownType && !fieldType) {
-                                    found = true;
-                                }
-                                // 2. References with fieldType matching the target module
-                                else if ((fieldType === null || fieldType === void 0 ? void 0 : fieldType.kind) === java_1.Type.Kind.Variable) {
-                                    const variableType = fieldType;
-                                    if (variableType.owner && java_1.Type.isClass(variableType.owner)) {
-                                        // Traverse owningClass chain to find the root module (handles nested namespaces)
-                                        // For example: React.forwardRef -> owner is "React" namespace -> owningClass is "react" module
-                                        let current = variableType.owner;
-                                        // Walk up the owningClass chain until we reach the root
-                                        while (current.owningClass && java_1.Type.isClass(current.owningClass)) {
-                                            current = current.owningClass;
-                                        }
-                                        const moduleName = java_1.Type.FullyQualified.getFullyQualifiedName(current);
-                                        if (moduleName === targetModule) {
-                                            found = true;
-                                        }
-                                    }
-                                }
-                                // 3. References with method type matching the target module
-                                else if (type && java_1.Type.isMethod(type)) {
-                                    const methodType = type;
-                                    const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
-                                    if (declaringTypeName === targetModule) {
-                                        found = true;
-                                    }
-                                }
+                        }
+                        // 3. References with method type matching the target module
+                        else if (type && java_1.Type.isMethod(type)) {
+                            const methodType = type;
+                            const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                            if (declaringTypeName === targetModule) {
+                                found = true;
                             }
                         }
-                        return _super.visitIdentifier.call(this, identifier, p);
-                    });
+                    }
                 }
-                visitMethodInvocation(methodInvocation, p) {
-                    const _super = Object.create(null, {
-                        visitMethodInvocation: { get: () => super.visitMethodInvocation }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        if (methodInvocation.methodType && methodInvocation.methodType.name === targetName) {
-                            if (expectedDeclaringType) {
-                                const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType);
-                                if (declaringTypeName === expectedDeclaringType) {
-                                    found = true;
-                                }
-                            }
+                return super.visitIdentifier(identifier, p);
+            }
+            async visitMethodInvocation(methodInvocation, p) {
+                if (methodInvocation.methodType && methodInvocation.methodType.name === targetName) {
+                    if (expectedDeclaringType) {
+                        const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType);
+                        if (declaringTypeName === expectedDeclaringType) {
+                            found = true;
                         }
-                        return _super.visitMethodInvocation.call(this, methodInvocation, p);
-                    });
+                    }
                 }
-                visitFunctionCall(functionCall, p) {
-                    const _super = Object.create(null, {
-                        visitFunctionCall: { get: () => super.visitFunctionCall }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        if (functionCall.methodType && functionCall.methodType.name === targetName) {
-                            if (expectedDeclaringType) {
-                                const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType);
-                                if (declaringTypeName === expectedDeclaringType) {
-                                    found = true;
-                                }
-                            }
+                return super.visitMethodInvocation(methodInvocation, p);
+            }
+            async visitFunctionCall(functionCall, p) {
+                if (functionCall.methodType && functionCall.methodType.name === targetName) {
+                    if (expectedDeclaringType) {
+                        const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType);
+                        if (declaringTypeName === expectedDeclaringType) {
+                            found = true;
                         }
-                        return _super.visitFunctionCall.call(this, functionCall, p);
-                    });
+                    }
                 }
-                visitFieldAccess(fieldAccess, p) {
-                    const _super = Object.create(null, {
-                        visitFieldAccess: { get: () => super.visitFieldAccess }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const type = fieldAccess.type;
-                        if (type && java_1.Type.isMethod(type)) {
-                            const methodType = type;
-                            if (methodType.name === targetName) {
-                                if (expectedDeclaringType) {
-                                    const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
-                                    if (declaringTypeName === expectedDeclaringType) {
-                                        found = true;
-                                    }
-                                }
+                return super.visitFunctionCall(functionCall, p);
+            }
+            async visitFieldAccess(fieldAccess, p) {
+                const type = fieldAccess.type;
+                if (type && java_1.Type.isMethod(type)) {
+                    const methodType = type;
+                    if (methodType.name === targetName) {
+                        if (expectedDeclaringType) {
+                            const declaringTypeName = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                            if (declaringTypeName === expectedDeclaringType) {
+                                found = true;
                             }
                         }
-                        return _super.visitFieldAccess.call(this, fieldAccess, p);
-                    });
+                    }
                 }
-            };
-            yield collector.visit(compilationUnit, undefined);
-            return found;
-        });
+                return super.visitFieldAccess(fieldAccess, p);
+            }
+        };
+        await collector.visit(compilationUnit, undefined);
+        return found;
     }
     /**
      * Create a new import statement
      */
-    createImportStatement(compilationUnit, insertionIndex, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Determine the appropriate prefix (spacing before the import)
-            const prefix = this.determineImportPrefix(compilationUnit, insertionIndex);
-            // Create the module specifier
-            // For side-effect imports, use emptySpace since space comes from LeftPadded.before
-            // For regular imports with import clause, use emptySpace since space comes from LeftPadded.before
-            // However, the printer expects the space after 'from' in the literal's prefix
-            // Note: value contains the unquoted string, valueSource contains the quoted version for printing
-            const moduleSpecifier = {
+    async createImportStatement(compilationUnit, insertionIndex, p) {
+        // Determine the appropriate prefix (spacing before the import)
+        const prefix = this.determineImportPrefix(compilationUnit, insertionIndex);
+        // Create the module specifier
+        // For side-effect imports, use emptySpace since space comes from LeftPadded.before
+        // For regular imports with import clause, use emptySpace since space comes from LeftPadded.before
+        // However, the printer expects the space after 'from' in the literal's prefix
+        // Note: value contains the unquoted string, valueSource contains the quoted version for printing
+        const moduleSpecifier = {
+            id: (0, uuid_1.randomId)(),
+            kind: java_1.J.Kind.Literal,
+            prefix: this.sideEffectOnly ? java_1.emptySpace : java_1.singleSpace,
+            markers: markers_1.emptyMarkers,
+            value: this.module,
+            valueSource: `'${this.module}'`,
+            unicodeEscapes: [],
+            type: undefined
+        };
+        let importClause;
+        if (this.sideEffectOnly) {
+            // Side-effect import: import 'module'
+            importClause = undefined;
+        }
+        else if (this.member === '*') {
+            // Namespace import: import * as alias from 'module'
+            const propertyName = {
                 id: (0, uuid_1.randomId)(),
-                kind: java_1.J.Kind.Literal,
-                prefix: this.sideEffectOnly ? java_1.emptySpace : java_1.singleSpace,
+                kind: java_1.J.Kind.Identifier,
+                prefix: java_1.emptySpace,
                 markers: markers_1.emptyMarkers,
-                value: this.module,
-                valueSource: `'${this.module}'`,
-                unicodeEscapes: [],
-                type: undefined
+                annotations: [],
+                simpleName: '*',
+                type: undefined,
+                fieldType: undefined
             };
-            let importClause;
-            if (this.sideEffectOnly) {
-                // Side-effect import: import 'module'
-                importClause = undefined;
-            }
-            else if (this.member === '*') {
-                // Namespace import: import * as alias from 'module'
-                const propertyName = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: java_1.J.Kind.Identifier,
-                    prefix: java_1.emptySpace,
-                    markers: markers_1.emptyMarkers,
-                    annotations: [],
-                    simpleName: '*',
-                    type: undefined,
-                    fieldType: undefined
-                };
-                const aliasIdentifier = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: java_1.J.Kind.Identifier,
-                    prefix: java_1.singleSpace,
-                    markers: markers_1.emptyMarkers,
-                    annotations: [],
-                    simpleName: this.alias,
-                    type: undefined,
-                    fieldType: undefined
-                };
-                const namespaceBinding = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: tree_1.JS.Kind.Alias,
-                    prefix: java_1.singleSpace,
-                    markers: markers_1.emptyMarkers,
-                    propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
-                    alias: aliasIdentifier
-                };
-                importClause = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: tree_1.JS.Kind.ImportClause,
-                    prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
-                    markers: markers_1.emptyMarkers,
-                    typeOnly: this.typeOnly,
-                    name: undefined,
-                    namedBindings: namespaceBinding
-                };
-            }
-            else if (this.member === undefined || this.member === 'default') {
-                // Default import: import target from 'module'
-                // or: import alias from 'module' (when member === 'default')
-                const defaultName = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: java_1.J.Kind.Identifier,
-                    prefix: java_1.singleSpace,
-                    markers: markers_1.emptyMarkers,
-                    annotations: [],
-                    simpleName: this.alias || this.module,
-                    type: undefined,
-                    fieldType: undefined
-                };
-                importClause = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: tree_1.JS.Kind.ImportClause,
-                    prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
-                    markers: markers_1.emptyMarkers,
-                    typeOnly: this.typeOnly,
-                    name: (0, java_1.rightPadded)(defaultName, java_1.emptySpace),
-                    namedBindings: undefined
-                };
-            }
-            else {
-                // Named import: import { member } from 'module'
-                // Get the spaces style for brace spacing
-                const spacesStyle = (0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, compilationUnit);
-                const braceSpace = spacesStyle.within.es6ImportExportBraces ? java_1.singleSpace : java_1.emptySpace;
-                const importSpec = this.createImportSpecifier();
-                // Apply brace spacing: the space after { is in the specifier's prefix,
-                // and the space before } is in the rightPadded's after
-                const importSpecWithSpacing = Object.assign(Object.assign({}, importSpec), { prefix: braceSpace });
-                const namedImports = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: tree_1.JS.Kind.NamedImports,
-                    prefix: java_1.singleSpace,
-                    markers: markers_1.emptyMarkers,
-                    elements: {
-                        kind: java_1.J.Kind.Container,
-                        before: java_1.emptySpace,
-                        elements: [(0, java_1.rightPadded)(importSpecWithSpacing, braceSpace)],
-                        markers: markers_1.emptyMarkers
-                    }
-                };
-                importClause = {
-                    id: (0, uuid_1.randomId)(),
-                    kind: tree_1.JS.Kind.ImportClause,
-                    prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
-                    markers: markers_1.emptyMarkers,
-                    typeOnly: this.typeOnly,
-                    name: undefined,
-                    namedBindings: namedImports
-                };
-            }
-            const jsImport = {
+            const aliasIdentifier = {
+                id: (0, uuid_1.randomId)(),
+                kind: java_1.J.Kind.Identifier,
+                prefix: java_1.singleSpace,
+                markers: markers_1.emptyMarkers,
+                annotations: [],
+                simpleName: this.alias,
+                type: undefined,
+                fieldType: undefined
+            };
+            const namespaceBinding = {
+                id: (0, uuid_1.randomId)(),
+                kind: tree_1.JS.Kind.Alias,
+                prefix: java_1.singleSpace,
+                markers: markers_1.emptyMarkers,
+                propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
+                alias: aliasIdentifier
+            };
+            importClause = {
                 id: (0, uuid_1.randomId)(),
-                kind: tree_1.JS.Kind.Import,
-                prefix,
+                kind: tree_1.JS.Kind.ImportClause,
+                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
                 markers: markers_1.emptyMarkers,
-                modifiers: [],
-                importClause,
-                moduleSpecifier: {
-                    kind: java_1.J.Kind.LeftPadded,
-                    before: java_1.singleSpace,
-                    element: moduleSpecifier,
+                typeOnly: this.typeOnly,
+                name: undefined,
+                namedBindings: namespaceBinding
+            };
+        }
+        else if (this.member === undefined || this.member === 'default') {
+            // Default import: import target from 'module'
+            // or: import alias from 'module' (when member === 'default')
+            const defaultName = {
+                id: (0, uuid_1.randomId)(),
+                kind: java_1.J.Kind.Identifier,
+                prefix: java_1.singleSpace,
+                markers: markers_1.emptyMarkers,
+                annotations: [],
+                simpleName: this.alias || this.module,
+                type: undefined,
+                fieldType: undefined
+            };
+            importClause = {
+                id: (0, uuid_1.randomId)(),
+                kind: tree_1.JS.Kind.ImportClause,
+                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
+                markers: markers_1.emptyMarkers,
+                typeOnly: this.typeOnly,
+                name: (0, java_1.rightPadded)(defaultName, java_1.emptySpace),
+                namedBindings: undefined
+            };
+        }
+        else {
+            // Named import: import { member } from 'module'
+            // Get the spaces style for brace spacing
+            const spacesStyle = (0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, compilationUnit);
+            const braceSpace = spacesStyle.within.es6ImportExportBraces ? java_1.singleSpace : java_1.emptySpace;
+            const importSpec = this.createImportSpecifier();
+            // Apply brace spacing: the space after { is in the specifier's prefix,
+            // and the space before } is in the rightPadded's after
+            const importSpecWithSpacing = Object.assign(Object.assign({}, importSpec), { prefix: braceSpace });
+            const namedImports = {
+                id: (0, uuid_1.randomId)(),
+                kind: tree_1.JS.Kind.NamedImports,
+                prefix: java_1.singleSpace,
+                markers: markers_1.emptyMarkers,
+                elements: {
+                    kind: java_1.J.Kind.Container,
+                    before: java_1.emptySpace,
+                    elements: [(0, java_1.rightPadded)(importSpecWithSpacing, braceSpace)],
                     markers: markers_1.emptyMarkers
-                },
-                initializer: undefined
+                }
             };
-            return jsImport;
-        });
+            importClause = {
+                id: (0, uuid_1.randomId)(),
+                kind: tree_1.JS.Kind.ImportClause,
+                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
+                markers: markers_1.emptyMarkers,
+                typeOnly: this.typeOnly,
+                name: undefined,
+                namedBindings: namedImports
+            };
+        }
+        const jsImport = {
+            id: (0, uuid_1.randomId)(),
+            kind: tree_1.JS.Kind.Import,
+            prefix,
+            markers: markers_1.emptyMarkers,
+            modifiers: [],
+            importClause,
+            moduleSpecifier: {
+                kind: java_1.J.Kind.LeftPadded,
+                before: java_1.singleSpace,
+                element: moduleSpecifier,
+                markers: markers_1.emptyMarkers
+            },
+            initializer: undefined
+        };
+        return jsImport;
     }
     /**
      * Create an import specifier for a named import