@openrewrite/rewrite 8.66.0-20251027-112229 → 8.66.0-20251027-133754

package/dist/javascript/add-import.js

@@ -0,0 +1,789 @@
+"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;
+const visitor_1 = require("./visitor");
+const java_1 = require("../java");
+const tree_1 = require("./tree");
+const uuid_1 = require("../uuid");
+const markers_1 = require("../markers");
+const execution_1 = require("../execution");
+var ImportStyle;
+(function (ImportStyle) {
+    ImportStyle[ImportStyle["ES6Named"] = 0] = "ES6Named";
+    ImportStyle[ImportStyle["ES6Namespace"] = 1] = "ES6Namespace";
+    ImportStyle[ImportStyle["ES6Default"] = 2] = "ES6Default";
+    ImportStyle[ImportStyle["CommonJS"] = 3] = "CommonJS"; // const x = require('module')
+})(ImportStyle || (exports.ImportStyle = ImportStyle = {}));
+/**
+ * Register an AddImport visitor to add an import statement to a JavaScript/TypeScript file
+ * @param visitor The visitor to add the import addition to
+ * @param options Configuration options for the import to add
+ */
+function maybeAddImport(visitor, options) {
+    for (const v of visitor.afterVisit || []) {
+        if (v instanceof AddImport &&
+            v.target === options.target &&
+            v.member === options.member &&
+            v.alias === options.alias) {
+            return;
+        }
+    }
+    visitor.afterVisit.push(new AddImport(options));
+}
+class AddImport extends visitor_1.JavaScriptVisitor {
+    constructor(options) {
+        var _a;
+        super();
+        this.target = options.target;
+        this.member = options.member;
+        this.alias = options.alias;
+        this.onlyIfReferenced = (_a = options.onlyIfReferenced) !== null && _a !== void 0 ? _a : true;
+        this.style = options.style;
+    }
+    /**
+     * Extract module name from a module specifier literal
+     */
+    getModuleName(moduleSpecifier) {
+        var _a;
+        if (moduleSpecifier.kind !== java_1.J.Kind.Literal) {
+            return undefined;
+        }
+        return (_a = moduleSpecifier.value) === null || _a === void 0 ? void 0 : _a.toString();
+    }
+    /**
+     * Check if a method invocation is a require() call
+     */
+    isRequireCall(methodInv) {
+        var _a;
+        return ((_a = methodInv.name) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
+            methodInv.name.simpleName === 'require';
+    }
+    /**
+     * Determine the appropriate import style based on file type and existing imports
+     */
+    determineImportStyle(compilationUnit) {
+        var _a;
+        // If style was explicitly provided, use it
+        if (this.style !== undefined) {
+            return this.style;
+        }
+        // Check the file extension from sourcePath
+        const sourcePath = compilationUnit.sourcePath;
+        const isTypeScript = sourcePath.endsWith('.ts') ||
+            sourcePath.endsWith('.tsx') ||
+            sourcePath.endsWith('.mts') ||
+            sourcePath.endsWith('.cts');
+        // Check for .cjs extension - must use CommonJS
+        if (sourcePath.endsWith('.cjs')) {
+            return ImportStyle.CommonJS;
+        }
+        // First, check if there's already an import from the same module
+        // and match that style
+        const existingStyleForModule = this.findExistingImportStyleForModule(compilationUnit);
+        if (existingStyleForModule !== null) {
+            return existingStyleForModule;
+        }
+        // For .mjs or TypeScript, prefer ES6
+        if (sourcePath.endsWith('.mjs') || isTypeScript) {
+            // If we're importing a member, use named imports
+            if (this.member !== undefined) {
+                return ImportStyle.ES6Named;
+            }
+            // Otherwise default import
+            return ImportStyle.ES6Default;
+        }
+        // For .js files, check what style is predominantly being used
+        let hasNamedImports = false;
+        let hasNamespaceImports = false;
+        let hasDefaultImports = false;
+        let hasCommonJSRequires = false;
+        for (const stmt of compilationUnit.statements) {
+            const statement = stmt.element;
+            // Check for ES6 imports
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                const jsImport = statement;
+                const importClause = jsImport.importClause;
+                if (importClause) {
+                    // Check for named bindings
+                    if (importClause.namedBindings) {
+                        if (importClause.namedBindings.kind === tree_1.JS.Kind.NamedImports) {
+                            hasNamedImports = true;
+                        }
+                        else if (importClause.namedBindings.kind === java_1.J.Kind.Identifier ||
+                            importClause.namedBindings.kind === tree_1.JS.Kind.Alias) {
+                            // import * as x from 'module'
+                            hasNamespaceImports = true;
+                        }
+                    }
+                    // Check for default import
+                    if (importClause.name) {
+                        hasDefaultImports = true;
+                    }
+                }
+            }
+            // Check for CommonJS requires
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
+                const varDecl = statement;
+                if (varDecl.variables.length === 1) {
+                    const namedVar = varDecl.variables[0].element;
+                    const initializer = (_a = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
+                    if ((initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation &&
+                        this.isRequireCall(initializer)) {
+                        hasCommonJSRequires = true;
+                    }
+                }
+            }
+        }
+        // Prefer matching the predominant style
+        // If file uses CommonJS, stick with it
+        if (hasCommonJSRequires && !hasNamedImports && !hasNamespaceImports && !hasDefaultImports) {
+            return ImportStyle.CommonJS;
+        }
+        // If importing a member, prefer named imports if they exist in the file
+        if (this.member !== undefined) {
+            if (hasNamedImports) {
+                return ImportStyle.ES6Named;
+            }
+            if (hasNamespaceImports) {
+                return ImportStyle.ES6Namespace;
+            }
+        }
+        // For default/whole module imports
+        if (this.member === undefined) {
+            if (hasNamespaceImports) {
+                return ImportStyle.ES6Namespace;
+            }
+            if (hasDefaultImports) {
+                return ImportStyle.ES6Default;
+            }
+        }
+        // Default to named imports for members, default imports for modules
+        return this.member !== undefined ? ImportStyle.ES6Named : ImportStyle.ES6Default;
+    }
+    /**
+     * Find the import style used for an existing import from the same module
+     */
+    findExistingImportStyleForModule(compilationUnit) {
+        var _a, _b;
+        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;
+                const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+                if (moduleSpecifier) {
+                    const moduleName = this.getModuleName(moduleSpecifier);
+                    if (moduleName === this.target) {
+                        const importClause = jsImport.importClause;
+                        if (importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) {
+                            if (importClause.namedBindings.kind === tree_1.JS.Kind.NamedImports) {
+                                return ImportStyle.ES6Named;
+                            }
+                            else {
+                                return ImportStyle.ES6Namespace;
+                            }
+                        }
+                        if (importClause === null || importClause === void 0 ? void 0 : importClause.name) {
+                            return ImportStyle.ES6Default;
+                        }
+                    }
+                }
+            }
+            // Check CommonJS requires
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
+                const varDecl = statement;
+                if (varDecl.variables.length === 1) {
+                    const namedVar = varDecl.variables[0].element;
+                    const initializer = (_b = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _b === void 0 ? void 0 : _b.element;
+                    if ((initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation &&
+                        this.isRequireCall(initializer)) {
+                        const moduleName = this.getModuleNameFromRequire(initializer);
+                        if (moduleName === this.target) {
+                            return ImportStyle.CommonJS;
+                        }
+                    }
+                }
+            }
+        }
+        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) {
+                return compilationUnit;
+            }
+            // If onlyIfReferenced is true, check if the identifier is actually used
+            if (this.onlyIfReferenced) {
+                const isReferenced = yield this.checkIdentifierReferenced(compilationUnit);
+                if (!isReferenced) {
+                    return compilationUnit;
+                }
+            }
+            // Determine the appropriate import style
+            const importStyle = this.determineImportStyle(compilationUnit);
+            // For ES6 named imports, check if we can merge into an existing import from the same module
+            if (importStyle === ImportStyle.ES6Named && this.member !== undefined) {
+                const mergedCu = yield 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 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 {
+                        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.target) {
+                        continue;
+                    }
+                    const importClause = jsImport.importClause;
+                    if (!importClause || !importClause.namedBindings) {
+                        continue;
+                    }
+                    // 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* () {
+                        const namedImports = importClause.namedBindings;
+                        // Create the new specifier with a space prefix (since it's not the first element)
+                        const newSpecifierBase = this.createImportSpecifier();
+                        const newSpecifier = Object.assign(Object.assign({}, newSpecifierBase), { prefix: java_1.singleSpace });
+                        // Add the new specifier to the elements
+                        const updatedNamedImports = yield this.produceJavaScript(namedImports, p, (namedDraft) => __awaiter(this, void 0, void 0, function* () {
+                            namedDraft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: [
+                                    ...namedImports.elements.elements,
+                                    (0, java_1.rightPadded)(newSpecifier, java_1.emptySpace)
+                                ] });
+                        }));
+                        // 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);
+                    }));
+                }
+            }
+            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;
+                    }
+                }
+                // 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;
+        });
+    }
+    /**
+     * Check if the import matches what we're trying to add
+     */
+    isMatchingImport(jsImport) {
+        var _a, _b;
+        // Check module specifier
+        const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+        if (!moduleSpecifier) {
+            return false;
+        }
+        const moduleName = this.getModuleName(moduleSpecifier);
+        if (moduleName !== this.target) {
+            return false;
+        }
+        const importClause = jsImport.importClause;
+        if (!importClause) {
+            return false;
+        }
+        // Check if the specific member or default import already exists
+        if (this.member === undefined) {
+            // We're adding a default import, check if one exists
+            return importClause.name !== undefined;
+        }
+        else {
+            // We're adding a named import, check if it exists
+            const namedBindings = importClause.namedBindings;
+            if (!namedBindings) {
+                return false;
+            }
+            if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
+                const namedImports = namedBindings;
+                for (const elem of namedImports.elements.elements) {
+                    if (((_b = elem.element) === null || _b === void 0 ? void 0 : _b.kind) === tree_1.JS.Kind.ImportSpecifier) {
+                        const specifier = elem.element;
+                        const importName = this.getImportName(specifier);
+                        const aliasName = this.getImportAlias(specifier);
+                        if (importName === this.member && aliasName === this.alias) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if this is a matching CommonJS require statement
+     */
+    isMatchingRequire(varDecl) {
+        var _a, _b, _c;
+        if (varDecl.variables.length !== 1) {
+            return false;
+        }
+        const namedVar = varDecl.variables[0].element;
+        if (!namedVar) {
+            return false;
+        }
+        const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
+        if (!initializer || initializer.kind !== java_1.J.Kind.MethodInvocation) {
+            return false;
+        }
+        const methodInv = initializer;
+        if (!this.isRequireCall(methodInv)) {
+            return false;
+        }
+        const moduleName = this.getModuleNameFromRequire(methodInv);
+        if (moduleName !== this.target) {
+            return false;
+        }
+        // Check if the variable name matches what we're trying to add
+        const pattern = namedVar.name;
+        if (this.member === undefined && (pattern === null || pattern === void 0 ? void 0 : pattern.kind) === java_1.J.Kind.Identifier) {
+            // Default import style: const fs = require('fs')
+            return true;
+        }
+        else if (this.member !== undefined && (pattern === null || pattern === void 0 ? void 0 : pattern.kind) === tree_1.JS.Kind.ObjectBindingPattern) {
+            // Destructured import: const { member } = require('module')
+            const objectPattern = pattern;
+            for (const elem of objectPattern.bindings.elements) {
+                if (((_b = elem.element) === null || _b === void 0 ? void 0 : _b.kind) === tree_1.JS.Kind.BindingElement) {
+                    const bindingElem = elem.element;
+                    const name = (_c = bindingElem.name) === null || _c === void 0 ? void 0 : _c.simpleName;
+                    if (name === (this.alias || this.member)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if the identifier is actually referenced in the file
+     */
+    checkIdentifierReferenced(compilationUnit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Use type attribution to detect if the identifier is referenced
+            // Map of module name -> Set of member names used from that module
+            const usedImports = new Map();
+            // Helper to record usage of a method from a module
+            const recordMethodUsage = (methodType) => {
+                const moduleName = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                if (moduleName) {
+                    if (!usedImports.has(moduleName)) {
+                        usedImports.set(moduleName, new Set());
+                    }
+                    usedImports.get(moduleName).add(methodType.name);
+                }
+            };
+            // Create a visitor to collect used identifiers with their type attribution
+            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* () {
+                        const type = identifier.type;
+                        if (type && java_1.Type.isMethod(type)) {
+                            recordMethodUsage(type);
+                        }
+                        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) {
+                            recordMethodUsage(methodInvocation.methodType);
+                        }
+                        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) {
+                            recordMethodUsage(functionCall.methodType);
+                        }
+                        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)) {
+                            recordMethodUsage(type);
+                        }
+                        return _super.visitFieldAccess.call(this, fieldAccess, p);
+                    });
+                }
+            };
+            yield collector.visit(compilationUnit, new execution_1.ExecutionContext());
+            // Check if our target import is used based on type attribution
+            const moduleMembers = usedImports.get(this.target);
+            if (!moduleMembers) {
+                return false;
+            }
+            // For specific members, check if that member is used; otherwise check if any member is used
+            return this.member ? moduleMembers.has(this.member) : moduleMembers.size > 0;
+        });
+    }
+    /**
+     * 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
+            const moduleSpecifier = {
+                id: (0, uuid_1.randomId)(),
+                kind: java_1.J.Kind.Literal,
+                prefix: java_1.singleSpace,
+                markers: markers_1.emptyMarkers,
+                value: `'${this.target}'`,
+                valueSource: `'${this.target}'`,
+                unicodeEscapes: [],
+                type: undefined
+            };
+            let importClause;
+            if (this.member === undefined) {
+                // Default import: import target from 'module'
+                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.target,
+                    type: undefined,
+                    fieldType: undefined
+                };
+                importClause = {
+                    id: (0, uuid_1.randomId)(),
+                    kind: tree_1.JS.Kind.ImportClause,
+                    prefix: java_1.emptySpace,
+                    markers: markers_1.emptyMarkers,
+                    typeOnly: false,
+                    name: (0, java_1.rightPadded)(defaultName, java_1.emptySpace),
+                    namedBindings: undefined
+                };
+            }
+            else {
+                // Named import: import { member } from 'module'
+                const importSpec = this.createImportSpecifier();
+                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)(importSpec, java_1.emptySpace)],
+                        markers: markers_1.emptyMarkers
+                    }
+                };
+                importClause = {
+                    id: (0, uuid_1.randomId)(),
+                    kind: tree_1.JS.Kind.ImportClause,
+                    prefix: java_1.emptySpace,
+                    markers: markers_1.emptyMarkers,
+                    typeOnly: false,
+                    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
+     */
+    createImportSpecifier() {
+        let specifier;
+        if (this.alias) {
+            // Aliased import: import { member 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: this.member,
+                type: undefined,
+                fieldType: undefined
+            };
+            const aliasName = {
+                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
+            };
+            specifier = {
+                id: (0, uuid_1.randomId)(),
+                kind: tree_1.JS.Kind.Alias,
+                prefix: java_1.emptySpace,
+                markers: markers_1.emptyMarkers,
+                propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
+                alias: aliasName
+            };
+        }
+        else {
+            // Regular import: import { member } from 'module'
+            specifier = {
+                id: (0, uuid_1.randomId)(),
+                kind: java_1.J.Kind.Identifier,
+                prefix: java_1.emptySpace,
+                markers: markers_1.emptyMarkers,
+                annotations: [],
+                simpleName: this.member,
+                type: undefined,
+                fieldType: undefined
+            };
+        }
+        return {
+            id: (0, uuid_1.randomId)(),
+            kind: tree_1.JS.Kind.ImportSpecifier,
+            prefix: java_1.emptySpace,
+            markers: markers_1.emptyMarkers,
+            importType: {
+                kind: java_1.J.Kind.LeftPadded,
+                before: java_1.emptySpace,
+                element: false,
+                markers: markers_1.emptyMarkers
+            },
+            specifier
+        };
+    }
+    /**
+     * Determine the appropriate spacing before the import statement
+     */
+    determineImportPrefix(compilationUnit, insertionIndex) {
+        var _a;
+        // If inserting at the beginning (index 0), use the prefix of the first statement
+        // but only the whitespace part (preserve comments on the original first statement)
+        if (insertionIndex === 0 && compilationUnit.statements.length > 0) {
+            const firstPrefix = (_a = compilationUnit.statements[0].element) === null || _a === void 0 ? void 0 : _a.prefix;
+            if (firstPrefix) {
+                // Keep only whitespace, not comments
+                return {
+                    kind: java_1.J.Kind.Space,
+                    comments: [],
+                    whitespace: firstPrefix.whitespace
+                };
+            }
+            return java_1.emptySpace;
+        }
+        // If inserting after other statements, ensure we have at least one newline
+        // to separate from the previous statement
+        return (0, java_1.space)("\n");
+    }
+    /**
+     * Find the index where the new import should be inserted
+     */
+    findImportInsertionIndex(compilationUnit) {
+        let lastImportIndex = -1;
+        for (let i = 0; i < compilationUnit.statements.length; i++) {
+            const statement = compilationUnit.statements[i].element;
+            if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                lastImportIndex = i;
+            }
+            else if (lastImportIndex >= 0) {
+                // We've found a non-import after imports, insert after the last import
+                return lastImportIndex + 1;
+            }
+        }
+        // If we found imports, insert after them
+        if (lastImportIndex >= 0) {
+            return lastImportIndex + 1;
+        }
+        // No imports found, insert at the beginning
+        return 0;
+    }
+    /**
+     * Get the module name from a require() call
+     */
+    getModuleNameFromRequire(methodInv) {
+        var _a, _b;
+        const args = (_a = methodInv.arguments) === null || _a === void 0 ? void 0 : _a.elements;
+        if (!args || args.length === 0) {
+            return undefined;
+        }
+        const firstArg = args[0].element;
+        if (!firstArg || firstArg.kind !== java_1.J.Kind.Literal || typeof firstArg.value !== 'string') {
+            return undefined;
+        }
+        return (_b = firstArg.value) === null || _b === void 0 ? void 0 : _b.toString();
+    }
+    /**
+     * Get the import name from an import specifier
+     */
+    getImportName(specifier) {
+        const spec = specifier.specifier;
+        if ((spec === null || spec === void 0 ? void 0 : spec.kind) === tree_1.JS.Kind.Alias) {
+            const alias = spec;
+            const propertyName = alias.propertyName.element;
+            if ((propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier) {
+                return propertyName.simpleName;
+            }
+        }
+        else if ((spec === null || spec === void 0 ? void 0 : spec.kind) === java_1.J.Kind.Identifier) {
+            return spec.simpleName;
+        }
+        return '';
+    }
+    /**
+     * Get the import alias from an import specifier
+     */
+    getImportAlias(specifier) {
+        var _a;
+        const spec = specifier.specifier;
+        if ((spec === null || spec === void 0 ? void 0 : spec.kind) === tree_1.JS.Kind.Alias) {
+            const alias = spec;
+            if (((_a = alias.alias) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
+                return alias.alias.simpleName;
+            }
+        }
+        return undefined;
+    }
+}
+exports.AddImport = AddImport;
+//# sourceMappingURL=add-import.js.map