@openrewrite/rewrite 8.91.3 → 8.91.5

package/dist/javascript/remove-import.js

@@ -80,12 +80,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         });
     }
     async visitJsCompilationUnit(compilationUnit, p) {
-        // First, collect all used identifiers in the file
-        const usedIdentifiers = new Set();
-        const usedTypes = new Set();
-        // Traverse the AST to collect used identifiers
-        await this.collectUsedIdentifiers(compilationUnit, usedIdentifiers, usedTypes);
-        // Now process imports with knowledge of what's used
+        const usedNames = collectUsedNames(compilationUnit);
         return this.produceJavaScript(compilationUnit, p, async (draft) => {
             const formatter = new java_2.ElementRemovalFormatter(true); // Preserve file headers from first import
             const newStatements = await (0, util_1.mapAsync)(compilationUnit.statements, async (stmt) => {
@@ -93,7 +88,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                 // Handle ES6 imports
                 if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
                     const jsImport = statement;
-                    const result = await this.processImport(jsImport, usedIdentifiers, usedTypes, p);
+                    const result = await this.processImport(jsImport, usedNames, p);
                     if (result === undefined) {
                         formatter.markRemoved(statement);
                         return undefined;
@@ -106,7 +101,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                 // Multi-variable declarations might come as JS.ScopedVariableDeclarations
                 if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
                     const varDecl = statement;
-                    const result = await this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                    const result = await this.processRequireFromVarDecls(varDecl, usedNames, p);
                     if (result === undefined) {
                         formatter.markRemoved(statement);
                         return undefined;
@@ -124,7 +119,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                     for (const v of scopedVarDecl.variables) {
                         const varDecl = v.element;
                         if ((varDecl === null || varDecl === void 0 ? void 0 : varDecl.kind) === java_1.J.Kind.VariableDeclarations) {
-                            const result = await this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                            const result = await this.processRequireFromVarDecls(varDecl, usedNames, p);
                             if (result === undefined) {
                                 hasChanges = true;
                                 varFormatter.markRemoved(varDecl);
@@ -160,10 +155,10 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             draft.eof = await this.visitSpace(compilationUnit.eof, p);
         });
     }
-    async processImport(jsImport, usedIdentifiers, usedTypes, p) {
+    async processImport(jsImport, usedNames, p) {
         // Handle import-equals-require syntax: import util = require("util");
         if (jsImport.initializer) {
-            return this.processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p);
+            return this.processImportEqualsRequire(jsImport, usedNames, p);
         }
         // Check if this import is from the target module
         if (!this.isTargetModule(jsImport)) {
@@ -187,11 +182,11 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                 let shouldRemove;
                 if (this.member === 'default') {
                     // Special case: member 'default' means remove any default import from the target module if unused
-                    shouldRemove = !usedIdentifiers.has(name) && !usedTypes.has(name);
+                    shouldRemove = !usedNames.has(name);
                 }
                 else {
                     // Regular case: check if the import name matches the removal criteria
-                    shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes, name);
+                    shouldRemove = this.shouldRemoveImport(name, usedNames, name);
                 }
                 if (shouldRemove) {
                     // If there are no named imports, remove the entire import
@@ -230,7 +225,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                 if (this.member !== undefined) {
                     // We're trying to remove a specific member from this namespace
                     // Check if the namespace itself is used
-                    if (!usedIdentifiers.has(name) && !usedTypes.has(name)) {
+                    if (!usedNames.has(name)) {
                         // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
@@ -241,7 +236,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                     }
                     // Namespace is used, we can't remove individual members from it
                 }
-                else if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes, name)) {
+                else if (this.shouldRemoveImport(name, usedNames, name)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -261,7 +256,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                 if (this.member !== undefined) {
                     // We're trying to remove a specific member from this namespace
                     // Check if the namespace itself is used
-                    if (!usedIdentifiers.has(aliasName) && !usedTypes.has(aliasName)) {
+                    if (!usedNames.has(aliasName)) {
                         // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
@@ -272,7 +267,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                     }
                     // Namespace is used, we can't remove individual members from it
                 }
-                else if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes, aliasName)) {
+                else if (this.shouldRemoveImport(aliasName, usedNames, aliasName)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -286,7 +281,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             // Handle named imports: import { a, b } from 'module'
             if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
                 const namedImports = namedBindings;
-                const updatedImports = await this.processNamedImports(namedImports, usedIdentifiers, usedTypes, p);
+                const updatedImports = await this.processNamedImports(namedImports, usedNames, p);
                 if (updatedImports === undefined) {
                     // All named imports were removed
                     if (!importClause.name) {
@@ -312,10 +307,10 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
      * Process TypeScript import-equals-require syntax: import util = require("util");
      * This is represented as a JS.Import with an initializer containing the require() call.
      */
-    async processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p) {
+    async processImportEqualsRequire(jsImport, usedNames, p) {
         var _a;
         const initializer = (_a = jsImport.initializer) === null || _a === void 0 ? void 0 : _a.element;
-        if (!initializer || !this.isRequireCall(initializer)) {
+        if (!initializer || !isRequireCall(initializer)) {
             return jsImport;
         }
         const methodInv = initializer;
@@ -332,23 +327,11 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         const importedName = importClause.name.element.simpleName;
         // For import-equals-require, we can only remove the entire import since
         // it imports the whole module as a single identifier
-        if (this.shouldRemoveIdentifier(importedName, usedIdentifiers, usedTypes)) {
+        if (this.shouldRemoveIdentifier(importedName, usedNames)) {
             return undefined;
         }
         return jsImport;
     }
-    /**
-     * Check if a node is a require() method invocation
-     */
-    isRequireCall(node) {
-        var _a;
-        if (node.kind !== java_1.J.Kind.MethodInvocation) {
-            return false;
-        }
-        const methodInv = node;
-        return ((_a = methodInv.name) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
-            methodInv.name.simpleName === 'require';
-    }
     /**
      * Check if the module name matches the target module
      */
@@ -358,13 +341,13 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
     /**
      * Check if an identifier should be removed based on usage
      */
-    shouldRemoveIdentifier(name, usedIdentifiers, usedTypes) {
+    shouldRemoveIdentifier(name, usedNames) {
         // For CommonJS and import-equals-require, we're removing the entire import
         // if the identifier is not used (member is typically undefined for these cases,
         // or we're checking if a specific binding is used)
-        return !usedIdentifiers.has(name) && !usedTypes.has(name);
+        return !usedNames.has(name);
     }
-    async processNamedImports(namedImports, usedIdentifiers, usedTypes, p) {
+    async processNamedImports(namedImports, usedNames, p) {
         const { filtered, allRemoved } = await this.filterElementsWithPrefixPreservation(namedImports.elements.elements, (elem) => {
             if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
                 const specifier = elem;
@@ -378,13 +361,13 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
                     // We're removing a specific member - check if this matches
                     if (this.member === importName) {
                         // This is the member we want to remove - check if it's used
-                        return usedIdentifiers.has(nameToCheck) || usedTypes.has(nameToCheck);
+                        return usedNames.has(nameToCheck);
                     }
                     return true; // Keep imports that don't match the member
                 }
                 else {
                     // We're removing based on the import name itself
-                    return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes, importName);
+                    return !this.shouldRemoveImport(importName, usedNames, importName);
                 }
             }
             return true; // Keep non-ImportSpecifier elements
@@ -407,7 +390,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             draft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: filtered });
         });
     }
-    async processRequireFromVarDecls(varDecls, usedIdentifiers, p) {
+    async processRequireFromVarDecls(varDecls, usedNames, p) {
         var _a;
         // Check if this is a require() call
         if (varDecls.variables.length !== 1) {
@@ -418,7 +401,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             return varDecls;
         }
         const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
-        if (!initializer || !this.isRequireCall(initializer)) {
+        if (!initializer || !isRequireCall(initializer)) {
             return varDecls;
         }
         const methodInv = initializer;
@@ -432,14 +415,14 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             const varName = pattern.simpleName;
             // For require() statements, check the module name from the require call
             const moduleName = this.getModuleNameFromRequire(methodInv);
-            if (moduleName && this.matchesTargetModule(moduleName) && !usedIdentifiers.has(varName)) {
+            if (moduleName && this.matchesTargetModule(moduleName) && !usedNames.has(varName)) {
                 return undefined; // Remove the entire require statement
             }
         }
         // Handle: const { readFile } = require('fs')
         if (pattern.kind === tree_1.JS.Kind.ObjectBindingPattern && this.member !== undefined) {
             const objectPattern = pattern;
-            const updatedPattern = await this.processObjectBindingPattern(objectPattern, usedIdentifiers, p);
+            const updatedPattern = await this.processObjectBindingPattern(objectPattern, usedNames, p);
             if (updatedPattern === undefined) {
                 return undefined; // Remove entire require
             }
@@ -470,12 +453,12 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         }
         return (_b = firstArg.value) === null || _b === void 0 ? void 0 : _b.toString();
     }
-    async processObjectBindingPattern(pattern, usedIdentifiers, p) {
+    async processObjectBindingPattern(pattern, usedNames, p) {
         const { filtered, allRemoved } = await this.filterElementsWithPrefixPreservation(pattern.bindings.elements, (elem) => {
             const bound = this.boundByPatternElement(elem);
             // An element whose names cannot be read is left alone.
             return bound.length === 0 ||
-                bound.some(b => !this.shouldRemoveImport(b.name, usedIdentifiers, new Set(), b.member));
+                bound.some(b => !this.shouldRemoveImport(b.name, usedNames, b.member));
         }, async (elem, prefix) => {
             if (elem.kind === java_1.J.Kind.Identifier) {
                 return this.produceJava(elem, p, async (draft) => {
@@ -537,7 +520,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
             ? [{ name: elem.simpleName, member: elem.simpleName }]
             : (0, scope_1.bindingNames)(elem);
     }
-    shouldRemoveImport(name, usedIdentifiers, usedTypes, member) {
+    shouldRemoveImport(name, usedNames, member) {
         // If member is specified, we're removing a specific member from the module
         if (this.member !== undefined) {
             // A name bound under an alias reads one member and is referenced by another, and a name
@@ -549,7 +532,7 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         // If no member specified, we're removing all unused imports from the module
         // So we check if this particular import is unused
         // Check if it's used
-        return !(usedIdentifiers.has(name) || usedTypes.has(name));
+        return !usedNames.has(name);
     }
     isTargetModule(jsImport) {
         var _a, _b;
@@ -563,399 +546,28 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         // Match the module name
         return moduleName === this.module;
     }
-    /**
-     * Helper to traverse parameters from various node types
-     */
-    async traverseParameters(params, usedIdentifiers, usedTypes) {
-        if (!params || typeof params !== 'object')
-            return;
-        if (Array.isArray(params)) {
-            for (const p of params) {
-                // Array elements might be RightPadded, so unwrap them
-                const elem = p.element || p;
-                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (params.elements) {
-            for (const p of params.elements) {
-                if (p.element) {
-                    await this.collectUsedIdentifiers(p.element, usedIdentifiers, usedTypes);
-                }
-            }
-        }
-        else if (params.parameters) {
-            for (const p of params.parameters) {
-                const elem = p.element || p;
-                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-            }
-        }
-    }
-    /**
-     * Helper to traverse statements from various node types
-     */
-    async traverseStatements(statements, usedIdentifiers, usedTypes) {
-        if (!statements)
-            return;
-        if (Array.isArray(statements)) {
-            for (const stmt of statements) {
-                const element = stmt.element || stmt;
-                if (element) {
-                    await this.collectUsedIdentifiers(element, usedIdentifiers, usedTypes);
-                }
-            }
-        }
-    }
-    /**
-     * Helper to check for type expressions and collect type usage
-     */
-    async checkTypeExpression(node, usedTypes) {
-        if (node.typeExpression) {
-            await this.collectTypeUsage(node.typeExpression, usedTypes);
-        }
-    }
-    async collectUsedIdentifiers(node, usedIdentifiers, usedTypes) {
-        // This is a simplified version - in a real implementation,
-        // we'd need to traverse the entire AST and collect all identifier usages
-        // For now, we'll implement a basic traversal
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _q, _r;
-        if (node.kind === java_1.J.Kind.Identifier) {
-            const identifier = node;
-            usedIdentifiers.add(identifier.simpleName);
-        }
-        else if (node.kind === java_1.J.Kind.VariableDeclarations) {
-            const varDecls = node;
-            // Check the type expression on the VariableDeclarations itself
-            await this.checkTypeExpression(varDecls, usedTypes);
-            for (const v of varDecls.variables) {
-                // Check the initializer
-                if ((_a = v.element.initializer) === null || _a === void 0 ? void 0 : _a.element) {
-                    await this.collectUsedIdentifiers(v.element.initializer.element, usedIdentifiers, usedTypes);
-                }
-            }
-        }
-        else if (node.kind === java_1.J.Kind.MethodInvocation) {
-            const methodInv = node;
-            // Check if this is a member access pattern like fs.readFileSync
-            if (((_c = (_b = methodInv.select) === null || _b === void 0 ? void 0 : _b.element) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.FieldAccess) {
-                const fieldAccess = methodInv.select.element;
-                if (((_d = fieldAccess.target) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Identifier) {
-                    usedIdentifiers.add(fieldAccess.target.simpleName);
-                }
-            }
-            else if (((_f = (_e = methodInv.select) === null || _e === void 0 ? void 0 : _e.element) === null || _f === void 0 ? void 0 : _f.kind) === java_1.J.Kind.Identifier) {
-                // Direct identifier like fs in fs.method() - though this is rare
-                usedIdentifiers.add(methodInv.select.element.simpleName);
-            }
-            else if (!methodInv.select) {
-                // No select means this is a direct function call like isArray()
-                // Only in this case should we add the method name as a used identifier
-                if (methodInv.name && methodInv.name.kind === java_1.J.Kind.Identifier) {
-                    usedIdentifiers.add(methodInv.name.simpleName);
-                }
-            }
-            // Note: We don't add method names for calls like Array.isArray() or obj.method()
-            // because those are methods on objects, not standalone imported functions
-            // Recursively check arguments
-            if (methodInv.arguments) {
-                for (const arg of methodInv.arguments.elements) {
-                    if (arg.element) {
-                        await this.collectUsedIdentifiers(arg.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check select (object being called on)
-            if ((_g = methodInv.select) === null || _g === void 0 ? void 0 : _g.element) {
-                await this.collectUsedIdentifiers(methodInv.select.element, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === java_1.J.Kind.MemberReference) {
-            const memberRef = node;
-            if (memberRef.containing && ((_h = memberRef.containing.element) === null || _h === void 0 ? void 0 : _h.kind) === java_1.J.Kind.Identifier) {
-                usedIdentifiers.add(memberRef.containing.element.simpleName);
-            }
-        }
-        else if (node.kind === java_1.J.Kind.FieldAccess) {
-            // Handle field access like fs.readFileSync
-            const fieldAccess = node;
-            if (((_j = fieldAccess.target) === null || _j === void 0 ? void 0 : _j.kind) === java_1.J.Kind.Identifier) {
-                usedIdentifiers.add(fieldAccess.target.simpleName);
-            }
-            // Recursively check the target
-            if (fieldAccess.target) {
-                await this.collectUsedIdentifiers(fieldAccess.target, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.CompilationUnit) {
-            const cu = node;
-            for (const stmt of cu.statements) {
-                if (stmt.element && stmt.element.kind !== tree_1.JS.Kind.Import) {
-                    // Skip require() statements at the top level
-                    if (stmt.element.kind === java_1.J.Kind.VariableDeclarations) {
-                        const varDecls = stmt.element;
-                        // Check if this is a require() statement
-                        let isRequire = false;
-                        for (const v of varDecls.variables) {
-                            const namedVar = v.element;
-                            if (((_l = (_k = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _k === void 0 ? void 0 : _k.element) === null || _l === void 0 ? void 0 : _l.kind) === java_1.J.Kind.MethodInvocation) {
-                                const methodInv = namedVar.initializer.element;
-                                if (((_m = methodInv.name) === null || _m === void 0 ? void 0 : _m.kind) === java_1.J.Kind.Identifier &&
-                                    methodInv.name.simpleName === 'require') {
-                                    isRequire = true;
-                                    break;
-                                }
-                            }
-                        }
-                        if (!isRequire) {
-                            // Not a require statement, process normally
-                            await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                        }
-                    }
-                    else if (stmt.element.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
-                        // Process other non-import, non-require statements normally
-                        await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-        }
-        else if (node.kind === java_1.J.Kind.Return) {
-            // Handle return statements
-            const returnStmt = node;
-            if (returnStmt.expression) {
-                await this.collectUsedIdentifiers(returnStmt.expression, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === java_1.J.Kind.Block) {
-            const block = node;
-            for (const stmt of block.statements) {
-                if (stmt.element) {
-                    await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                }
-            }
-        }
-        else if (node.kind === java_1.J.Kind.MethodDeclaration) {
-            const method = node;
-            // Check parameters for type usage
-            if (method.parameters) {
-                for (const param of method.parameters.elements) {
-                    // Parameters can be various types, handle them recursively
-                    if (param.element) {
-                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check body
-            if (method.body) {
-                await this.collectUsedIdentifiers(method.body, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.TypeOf) {
-            // Handle typeof expressions like: typeof util
-            const typeOf = node;
-            if (typeOf.expression) {
-                await this.collectUsedIdentifiers(typeOf.expression, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.TypeQuery) {
-            // Handle typeof type queries like: const x: typeof util
-            const typeQuery = node;
-            if (typeQuery.typeExpression) {
-                await this.collectUsedIdentifiers(typeQuery.typeExpression, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.typeExpression) {
-            // Handle nodes with type expressions (parameters, variables, etc.)
-            await this.checkTypeExpression(node, usedTypes);
-            // Continue traversing other parts
-            if (node.name) {
-                await this.collectUsedIdentifiers(node.name, usedIdentifiers, usedTypes);
-            }
-            if (node.initializer) {
-                await this.collectUsedIdentifiers(node.initializer, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.ArrowFunction || node.kind === java_1.J.Kind.Lambda) {
-            // Handle arrow functions and lambdas
-            const func = node;
-            if (func.parameters) {
-                await this.collectUsedIdentifiers(func.parameters, usedIdentifiers, usedTypes);
-            }
-            if (func.lambda) {
-                await this.collectUsedIdentifiers(func.lambda, usedIdentifiers, usedTypes);
-            }
-            if (func.body) {
-                await this.collectUsedIdentifiers(func.body, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === java_1.J.Kind.Lambda) {
-            const lambda = node;
-            if ((_o = lambda.parameters) === null || _o === void 0 ? void 0 : _o.parameters) {
-                for (const param of lambda.parameters.parameters) {
-                    if (param.element) {
-                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            if (lambda.body) {
-                await this.collectUsedIdentifiers(lambda.body, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.JsxTag) {
-            // Handle JSX tags like <div>content</div>
-            const jsxTag = node;
-            // Check attributes
-            if (jsxTag.attributes) {
-                for (const attr of jsxTag.attributes) {
-                    if (attr.element) {
-                        await this.collectUsedIdentifiers(attr.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check children
-            if (jsxTag.children) {
-                for (const child of jsxTag.children) {
-                    if (child) {
-                        await this.collectUsedIdentifiers(child, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.JsxEmbeddedExpression) {
-            // Handle JSX embedded expressions like {React.version}
-            const embedded = node;
-            // The expression is wrapped in RightPadded, so unwrap it
-            const expr = ((_q = embedded.expression) === null || _q === void 0 ? void 0 : _q.element) || embedded.expression;
-            if (expr) {
-                await this.collectUsedIdentifiers(expr, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.JsxAttribute) {
-            // Handle JSX attributes like onClick={handler}
-            const jsxAttr = node;
-            if (jsxAttr.value) {
-                await this.collectUsedIdentifiers(jsxAttr.value, usedIdentifiers, usedTypes);
-            }
-        }
-        else if (node.kind === tree_1.JS.Kind.TypeDeclaration) {
-            // Handle type alias declarations like: type Props = { children: React.ReactNode }
-            const typeDecl = node;
-            // The initializer contains the type expression (the right side of the =)
-            if ((_r = typeDecl.initializer) === null || _r === void 0 ? void 0 : _r.element) {
-                await this.collectTypeUsage(typeDecl.initializer.element, usedTypes);
-            }
-        }
-        else if (node.statements) {
-            // Generic handler for nodes with statements
-            await this.traverseStatements(node.statements, usedIdentifiers, usedTypes);
-        }
-        else if (node.body) {
-            // Generic handler for nodes with body
-            await this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
-        }
-        else if (node.parameters) {
-            // Handle anything with parameters (functions, methods, etc.)
-            await this.traverseParameters(node.parameters, usedIdentifiers, usedTypes);
-            // Continue with the body if it exists
-            if (node.body) {
-                await this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
-            }
-        }
+}
+exports.RemoveImport = RemoveImport;
+/**
+ * The names the file references, less its own imports: a specifier names what it binds, so counting
+ * one would read an import as a use of itself.
+ */
+function collectUsedNames(cu) {
+    const used = new Set();
+    for (const statement of cu.statements) {
+        const element = statement.element;
+        if (!element || element.kind === tree_1.JS.Kind.Import) {
+            continue;
+        }
+        (0, scope_1.namesReferencedWithin)(element).forEach(name => used.add(name));
     }
-    async collectTypeUsage(typeExpr, usedTypes) {
-        var _a;
-        if (typeExpr.kind === java_1.J.Kind.Identifier) {
-            usedTypes.add(typeExpr.simpleName);
-        }
-        else if (typeExpr.kind === java_1.J.Kind.ParameterizedType) {
-            const paramType = typeExpr;
-            // First, collect usage from the base type (e.g., React.Ref from React.Ref<T>)
-            if (paramType.class) {
-                await this.collectTypeUsage(paramType.class, usedTypes);
-            }
-            // Then collect usage from type parameters (e.g., HTMLButtonElement from React.Ref<HTMLButtonElement>)
-            if (paramType.typeParameters) {
-                for (const typeParam of paramType.typeParameters.elements) {
-                    if (typeParam.element) {
-                        await this.collectTypeUsage(typeParam.element, usedTypes);
-                    }
-                }
-            }
-        }
-        else if (typeExpr.kind === java_1.J.Kind.FieldAccess) {
-            // Handle qualified names in type positions like React.Ref
-            const fieldAccess = typeExpr;
-            if (((_a = fieldAccess.target) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
-                usedTypes.add(fieldAccess.target.simpleName);
-            }
-            else if (fieldAccess.target) {
-                // Recursively handle nested field accesses
-                await this.collectTypeUsage(fieldAccess.target, usedTypes);
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.Intersection) {
-            // Handle intersection types like ButtonProps & { ref?: React.Ref<HTMLButtonElement> }
-            const intersection = typeExpr;
-            for (const typeElem of intersection.types) {
-                if (typeElem.element) {
-                    await this.collectTypeUsage(typeElem.element, usedTypes);
-                }
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.TypeLiteral) {
-            // Handle type literals like { ref?: React.Ref<HTMLButtonElement> }
-            const typeLiteral = typeExpr;
-            // TypeLiteral members are in a Block, which contains statements
-            for (const stmt of typeLiteral.members.statements) {
-                if (stmt.element) {
-                    // Each statement is typically a VariableDeclarations representing a property
-                    await this.collectUsedIdentifiers(stmt.element, new Set(), usedTypes);
-                }
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.TypeQuery) {
-            // Handle typeof type queries like: const x: typeof util
-            const typeQuery = typeExpr;
-            if (typeQuery.typeExpression) {
-                await this.collectTypeUsage(typeQuery.typeExpression, usedTypes);
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.TypeOf) {
-            // Handle typeof expressions in types
-            const typeOf = typeExpr;
-            if (typeOf.expression) {
-                // For typeof expressions, the expression contains the identifier
-                // Add it to usedTypes since it's used in a type context
-                if (typeOf.expression.kind === java_1.J.Kind.Identifier) {
-                    usedTypes.add(typeOf.expression.simpleName);
-                }
-                else {
-                    await this.collectTypeUsage(typeOf.expression, usedTypes);
-                }
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.TypeTreeExpression) {
-            // Handle TypeTreeExpression which wraps type identifiers
-            const typeTree = typeExpr;
-            if (typeTree.expression) {
-                await this.collectTypeUsage(typeTree.expression, usedTypes);
-            }
-        }
-        else if (typeExpr.kind === tree_1.JS.Kind.TypeInfo) {
-            // Handle TypeInfo which contains type identifiers
-            const typeInfo = typeExpr;
-            if (typeInfo.typeIdentifier) {
-                await this.collectTypeUsage(typeInfo.typeIdentifier, usedTypes);
-            }
-        }
-        else if (typeExpr.expression) {
-            // Generic handler for nodes with expression property
-            await this.collectTypeUsage(typeExpr.expression, usedTypes);
-        }
-        else if (typeExpr.typeIdentifier) {
-            // Generic handler for nodes with typeIdentifier property
-            await this.collectTypeUsage(typeExpr.typeIdentifier, usedTypes);
-        }
-        // Add more type expression handlers as needed
+    return used;
+}
+function isRequireCall(node) {
+    if (node.kind !== java_1.J.Kind.MethodInvocation) {
+        return false;
     }
+    const name = node.name;
+    return (name === null || name === void 0 ? void 0 : name.kind) === java_1.J.Kind.Identifier && name.simpleName === 'require';
 }
-exports.RemoveImport = RemoveImport;
 //# sourceMappingURL=remove-import.js.map