@openrewrite/rewrite 8.72.2 → 8.72.4

package/dist/javascript/recipes/change-import.js

@@ -20,15 +20,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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.ChangeImport = void 0;
 const recipe_1 = require("../../recipe");
@@ -72,550 +63,511 @@ class ChangeImport extends recipe_1.Recipe {
         this.displayName = "Change import";
         this.description = "Changes an import from one module/member to another, updating all type attributions.";
     }
-    editor() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const oldModule = this.oldModule;
-            const oldMember = this.oldMember;
-            const newModule = this.newModule;
-            const newMember = (_a = this.newMember) !== null && _a !== void 0 ? _a : oldMember;
-            const newAlias = this.newAlias;
-            // Build the old and new FQNs for type attribution updates
-            const oldFqn = oldMember === 'default' || oldMember === '*'
-                ? oldModule
-                : `${oldModule}.${oldMember}`;
-            const newFqn = newMember === 'default' || newMember === '*'
-                ? newModule
-                : `${newModule}.${newMember}`;
-            return new class extends index_1.JavaScriptVisitor {
-                constructor() {
-                    super(...arguments);
-                    this.hasOldImport = false;
-                    this.transformedImport = false;
-                }
-                visitJsCompilationUnit(cu, ctx) {
-                    const _super = Object.create(null, {
-                        visitJsCompilationUnit: { get: () => super.visitJsCompilationUnit }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        var _a;
-                        // Reset tracking for each file
-                        this.hasOldImport = false;
-                        this.oldAlias = undefined;
-                        this.transformedImport = false;
-                        // First pass: check if the old import exists and capture any alias
-                        for (const statement of cu.statements) {
-                            const stmt = (_a = statement.element) !== null && _a !== void 0 ? _a : statement;
-                            if (stmt.kind === index_1.JS.Kind.Import) {
-                                const jsImport = stmt;
-                                const aliasInfo = this.checkForOldImport(jsImport);
-                                if (aliasInfo.found) {
-                                    this.hasOldImport = true;
-                                    this.oldAlias = aliasInfo.alias;
-                                    break;
-                                }
-                            }
-                        }
-                        // Visit the compilation unit (this will transform imports via visitJsImport)
-                        let result = yield _super.visitJsCompilationUnit.call(this, cu, ctx);
-                        // If we transformed an import but need to add to existing import from new module,
-                        // or if we only removed a member from a multi-import, use maybeAddImport
-                        if (this.hasOldImport && !this.transformedImport) {
-                            const aliasToUse = newAlias !== null && newAlias !== void 0 ? newAlias : this.oldAlias;
-                            if (newMember === 'default') {
-                                (0, add_import_1.maybeAddImport)(this, {
-                                    module: newModule,
-                                    member: 'default',
-                                    alias: aliasToUse,
-                                    onlyIfReferenced: false
-                                });
-                            }
-                            else if (newMember === '*') {
-                                (0, add_import_1.maybeAddImport)(this, {
-                                    module: newModule,
-                                    member: '*',
-                                    alias: aliasToUse,
-                                    onlyIfReferenced: false
-                                });
-                            }
-                            else if (aliasToUse && aliasToUse !== newMember) {
-                                (0, add_import_1.maybeAddImport)(this, {
-                                    module: newModule,
-                                    member: newMember,
-                                    alias: aliasToUse,
-                                    onlyIfReferenced: false
-                                });
-                            }
-                            else {
-                                (0, add_import_1.maybeAddImport)(this, {
-                                    module: newModule,
-                                    member: newMember,
-                                    onlyIfReferenced: false
-                                });
-                            }
+    async editor() {
+        var _a;
+        const oldModule = this.oldModule;
+        const oldMember = this.oldMember;
+        const newModule = this.newModule;
+        const newMember = (_a = this.newMember) !== null && _a !== void 0 ? _a : oldMember;
+        const newAlias = this.newAlias;
+        // Build the old and new FQNs for type attribution updates
+        const oldFqn = oldMember === 'default' || oldMember === '*'
+            ? oldModule
+            : `${oldModule}.${oldMember}`;
+        const newFqn = newMember === 'default' || newMember === '*'
+            ? newModule
+            : `${newModule}.${newMember}`;
+        return new class extends index_1.JavaScriptVisitor {
+            constructor() {
+                super(...arguments);
+                this.hasOldImport = false;
+                this.transformedImport = false;
+            }
+            async visitJsCompilationUnit(cu, ctx) {
+                var _a;
+                // Reset tracking for each file
+                this.hasOldImport = false;
+                this.oldAlias = undefined;
+                this.transformedImport = false;
+                // First pass: check if the old import exists and capture any alias
+                for (const statement of cu.statements) {
+                    const stmt = (_a = statement.element) !== null && _a !== void 0 ? _a : statement;
+                    if (stmt.kind === index_1.JS.Kind.Import) {
+                        const jsImport = stmt;
+                        const aliasInfo = this.checkForOldImport(jsImport);
+                        if (aliasInfo.found) {
+                            this.hasOldImport = true;
+                            this.oldAlias = aliasInfo.alias;
+                            break;
                         }
-                        return result;
-                    });
+                    }
                 }
-                visitImportDeclaration(jsImport, ctx) {
-                    const _super = Object.create(null, {
-                        visitImportDeclaration: { get: () => super.visitImportDeclaration }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
+                // Visit the compilation unit (this will transform imports via visitJsImport)
+                let result = await super.visitJsCompilationUnit(cu, ctx);
+                // If we transformed an import but need to add to existing import from new module,
+                // or if we only removed a member from a multi-import, use maybeAddImport
+                if (this.hasOldImport && !this.transformedImport) {
+                    const aliasToUse = newAlias !== null && newAlias !== void 0 ? newAlias : this.oldAlias;
+                    if (newMember === 'default') {
+                        (0, add_import_1.maybeAddImport)(this, {
+                            module: newModule,
+                            member: 'default',
+                            alias: aliasToUse,
+                            onlyIfReferenced: false
+                        });
+                    }
+                    else if (newMember === '*') {
+                        (0, add_import_1.maybeAddImport)(this, {
+                            module: newModule,
+                            member: '*',
+                            alias: aliasToUse,
+                            onlyIfReferenced: false
+                        });
+                    }
+                    else if (aliasToUse && aliasToUse !== newMember) {
+                        (0, add_import_1.maybeAddImport)(this, {
+                            module: newModule,
+                            member: newMember,
+                            alias: aliasToUse,
+                            onlyIfReferenced: false
+                        });
+                    }
+                    else {
+                        (0, add_import_1.maybeAddImport)(this, {
+                            module: newModule,
+                            member: newMember,
+                            onlyIfReferenced: false
+                        });
+                    }
+                }
+                return result;
+            }
+            async visitImportDeclaration(jsImport, ctx) {
+                var _a;
+                let imp = await super.visitImportDeclaration(jsImport, ctx);
+                if (!this.hasOldImport) {
+                    return imp;
+                }
+                const aliasInfo = this.checkForOldImport(imp);
+                if (!aliasInfo.found) {
+                    return imp;
+                }
+                // Check if this is the only import from the old module
+                const namedImports = this.getNamedImports(imp);
+                const isOnlyImport = namedImports.length === 1 ||
+                    (oldMember === 'default' && !((_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings)) ||
+                    (oldMember === '*');
+                if (isOnlyImport) {
+                    // Transform the module specifier in place
+                    this.transformedImport = true;
+                    return (0, mutative_1.create)(imp, draft => {
                         var _a;
-                        let imp = yield _super.visitImportDeclaration.call(this, jsImport, ctx);
-                        if (!this.hasOldImport) {
-                            return imp;
-                        }
-                        const aliasInfo = this.checkForOldImport(imp);
-                        if (!aliasInfo.found) {
-                            return imp;
+                        if (draft.moduleSpecifier) {
+                            const literal = draft.moduleSpecifier.element;
+                            literal.value = newModule;
+                            // Update valueSource to preserve quote style
+                            const originalSource = literal.valueSource || `"${oldModule}"`;
+                            const quoteChar = originalSource.startsWith("'") ? "'" : '"';
+                            literal.valueSource = `${quoteChar}${newModule}${quoteChar}`;
                         }
-                        // Check if this is the only import from the old module
-                        const namedImports = this.getNamedImports(imp);
-                        const isOnlyImport = namedImports.length === 1 ||
-                            (oldMember === 'default' && !((_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings)) ||
-                            (oldMember === '*');
-                        if (isOnlyImport) {
-                            // Transform the module specifier in place
-                            this.transformedImport = true;
-                            return (0, mutative_1.create)(imp, draft => {
-                                var _a;
-                                if (draft.moduleSpecifier) {
-                                    const literal = draft.moduleSpecifier.element;
-                                    literal.value = newModule;
-                                    // Update valueSource to preserve quote style
-                                    const originalSource = literal.valueSource || `"${oldModule}"`;
-                                    const quoteChar = originalSource.startsWith("'") ? "'" : '"';
-                                    literal.valueSource = `${quoteChar}${newModule}${quoteChar}`;
-                                }
-                                // If we're also renaming the member, update the import specifier
-                                if (newMember !== oldMember && oldMember !== 'default' && oldMember !== '*') {
-                                    const importClause = draft.importClause;
-                                    if (((_a = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === index_1.JS.Kind.NamedImports) {
-                                        const namedImports = importClause.namedBindings;
-                                        for (const elem of namedImports.elements.elements) {
-                                            const specifier = elem.element;
-                                            if (specifier.specifier.kind === java_1.J.Kind.Identifier &&
-                                                specifier.specifier.simpleName === oldMember) {
-                                                specifier.specifier.simpleName = newMember;
-                                            }
-                                        }
+                        // If we're also renaming the member, update the import specifier
+                        if (newMember !== oldMember && oldMember !== 'default' && oldMember !== '*') {
+                            const importClause = draft.importClause;
+                            if (((_a = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === index_1.JS.Kind.NamedImports) {
+                                const namedImports = importClause.namedBindings;
+                                for (const elem of namedImports.elements.elements) {
+                                    const specifier = elem.element;
+                                    if (specifier.specifier.kind === java_1.J.Kind.Identifier &&
+                                        specifier.specifier.simpleName === oldMember) {
+                                        specifier.specifier.simpleName = newMember;
                                     }
                                 }
-                            });
-                        }
-                        else {
-                            // Remove just the specific member from the import
-                            // maybeAddImport will add the new import
-                            return this.removeNamedImportMember(imp, oldMember, ctx);
+                            }
                         }
                     });
                 }
-                removeNamedImportMember(imp, memberToRemove, _ctx) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (0, mutative_1.create)(imp, draft => {
-                            const importClause = draft.importClause;
-                            if (!(importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings))
-                                return;
-                            if (importClause.namedBindings.kind !== index_1.JS.Kind.NamedImports)
-                                return;
-                            const namedImports = importClause.namedBindings;
-                            const elements = namedImports.elements.elements;
-                            const filteredElements = elements.filter(elem => {
-                                const specifier = elem.element;
-                                const specifierNode = specifier.specifier;
-                                if (specifierNode.kind === java_1.J.Kind.Identifier) {
-                                    return specifierNode.simpleName !== memberToRemove;
-                                }
-                                if (specifierNode.kind === index_1.JS.Kind.Alias) {
-                                    const alias = specifierNode;
-                                    const propertyName = alias.propertyName.element;
-                                    if (propertyName.kind === java_1.J.Kind.Identifier) {
-                                        return propertyName.simpleName !== memberToRemove;
-                                    }
-                                }
-                                return true;
-                            });
-                            namedImports.elements.elements = filteredElements;
-                        });
-                    });
+                else {
+                    // Remove just the specific member from the import
+                    // maybeAddImport will add the new import
+                    return this.removeNamedImportMember(imp, oldMember, ctx);
                 }
-                getNamedImports(imp) {
-                    const imports = [];
-                    const importClause = imp.importClause;
-                    if (!importClause)
-                        return imports;
-                    const namedBindings = importClause.namedBindings;
-                    if (!namedBindings || namedBindings.kind !== index_1.JS.Kind.NamedImports)
-                        return imports;
-                    const namedImports = namedBindings;
-                    for (const elem of namedImports.elements.elements) {
+            }
+            async removeNamedImportMember(imp, memberToRemove, _ctx) {
+                return (0, mutative_1.create)(imp, draft => {
+                    const importClause = draft.importClause;
+                    if (!(importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings))
+                        return;
+                    if (importClause.namedBindings.kind !== index_1.JS.Kind.NamedImports)
+                        return;
+                    const namedImports = importClause.namedBindings;
+                    const elements = namedImports.elements.elements;
+                    const filteredElements = elements.filter(elem => {
                         const specifier = elem.element;
                         const specifierNode = specifier.specifier;
-                        if ((0, java_1.isIdentifier)(specifierNode)) {
-                            imports.push(specifierNode.simpleName);
+                        if (specifierNode.kind === java_1.J.Kind.Identifier) {
+                            return specifierNode.simpleName !== memberToRemove;
                         }
-                        else if (specifierNode.kind === index_1.JS.Kind.Alias) {
+                        if (specifierNode.kind === index_1.JS.Kind.Alias) {
                             const alias = specifierNode;
                             const propertyName = alias.propertyName.element;
-                            if ((0, java_1.isIdentifier)(propertyName)) {
-                                imports.push(propertyName.simpleName);
+                            if (propertyName.kind === java_1.J.Kind.Identifier) {
+                                return propertyName.simpleName !== memberToRemove;
                             }
                         }
-                    }
-                    return imports;
-                }
-                visitIdentifier(identifier, ctx) {
-                    const _super = Object.create(null, {
-                        visitIdentifier: { get: () => super.visitIdentifier }
+                        return true;
                     });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let ident = yield _super.visitIdentifier.call(this, identifier, ctx);
-                        if (!this.hasOldImport) {
-                            return ident;
+                    namedImports.elements.elements = filteredElements;
+                });
+            }
+            getNamedImports(imp) {
+                const imports = [];
+                const importClause = imp.importClause;
+                if (!importClause)
+                    return imports;
+                const namedBindings = importClause.namedBindings;
+                if (!namedBindings || namedBindings.kind !== index_1.JS.Kind.NamedImports)
+                    return imports;
+                const namedImports = namedBindings;
+                for (const elem of namedImports.elements.elements) {
+                    const specifier = elem.element;
+                    const specifierNode = specifier.specifier;
+                    if ((0, java_1.isIdentifier)(specifierNode)) {
+                        imports.push(specifierNode.simpleName);
+                    }
+                    else if (specifierNode.kind === index_1.JS.Kind.Alias) {
+                        const alias = specifierNode;
+                        const propertyName = alias.propertyName.element;
+                        if ((0, java_1.isIdentifier)(propertyName)) {
+                            imports.push(propertyName.simpleName);
                         }
-                        // Check and update type attribution
-                        let changed = false;
-                        // Update type if it references the old module
-                        const updatedType = this.updateType(ident.type);
+                    }
+                }
+                return imports;
+            }
+            async visitIdentifier(identifier, ctx) {
+                let ident = await super.visitIdentifier(identifier, ctx);
+                if (!this.hasOldImport) {
+                    return ident;
+                }
+                // Check and update type attribution
+                let changed = false;
+                // Update type if it references the old module
+                const updatedType = this.updateType(ident.type);
+                if (updatedType !== ident.type) {
+                    changed = true;
+                }
+                // Update fieldType if it references the old module
+                // fieldType is specifically Type.Variable, so we need to handle it specially
+                let updatedFieldType = ident.fieldType;
+                if (ident.fieldType) {
+                    const updated = this.updateVariableType(ident.fieldType);
+                    if (updated !== ident.fieldType) {
+                        updatedFieldType = updated;
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    return (0, mutative_1.create)(ident, draft => {
                         if (updatedType !== ident.type) {
-                            changed = true;
-                        }
-                        // Update fieldType if it references the old module
-                        // fieldType is specifically Type.Variable, so we need to handle it specially
-                        let updatedFieldType = ident.fieldType;
-                        if (ident.fieldType) {
-                            const updated = this.updateVariableType(ident.fieldType);
-                            if (updated !== ident.fieldType) {
-                                updatedFieldType = updated;
-                                changed = true;
-                            }
+                            draft.type = updatedType;
                         }
-                        if (changed) {
-                            return (0, mutative_1.create)(ident, draft => {
-                                if (updatedType !== ident.type) {
-                                    draft.type = updatedType;
-                                }
-                                if (updatedFieldType !== ident.fieldType) {
-                                    draft.fieldType = updatedFieldType;
-                                }
-                            });
+                        if (updatedFieldType !== ident.fieldType) {
+                            draft.fieldType = updatedFieldType;
                         }
-                        return ident;
                     });
                 }
-                visitMethodInvocation(method, ctx) {
-                    const _super = Object.create(null, {
-                        visitMethodInvocation: { get: () => super.visitMethodInvocation }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let m = yield _super.visitMethodInvocation.call(this, method, ctx);
-                        if (!this.hasOldImport) {
-                            return m;
-                        }
-                        // Update methodType if it references the old module
-                        const updatedMethodType = this.updateMethodType(m.methodType);
-                        if (updatedMethodType !== m.methodType) {
-                            return (0, mutative_1.create)(m, draft => {
-                                draft.methodType = updatedMethodType;
-                            });
-                        }
-                        return m;
-                    });
+                return ident;
+            }
+            async visitMethodInvocation(method, ctx) {
+                let m = await super.visitMethodInvocation(method, ctx);
+                if (!this.hasOldImport) {
+                    return m;
                 }
-                visitFieldAccess(fieldAccess, ctx) {
-                    const _super = Object.create(null, {
-                        visitFieldAccess: { get: () => super.visitFieldAccess }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let fa = yield _super.visitFieldAccess.call(this, fieldAccess, ctx);
-                        if (!this.hasOldImport) {
-                            return fa;
-                        }
-                        // Update type if it references the old module
-                        const updatedType = this.updateType(fa.type);
-                        if (updatedType !== fa.type) {
-                            return (0, mutative_1.create)(fa, draft => {
-                                draft.type = updatedType;
-                            });
-                        }
-                        return fa;
+                // Update methodType if it references the old module
+                const updatedMethodType = this.updateMethodType(m.methodType);
+                if (updatedMethodType !== m.methodType) {
+                    return (0, mutative_1.create)(m, draft => {
+                        draft.methodType = updatedMethodType;
                     });
                 }
-                visitFunctionCall(functionCall, ctx) {
-                    const _super = Object.create(null, {
-                        visitFunctionCall: { get: () => super.visitFunctionCall }
-                    });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let fc = yield _super.visitFunctionCall.call(this, functionCall, ctx);
-                        if (!this.hasOldImport) {
-                            return fc;
-                        }
-                        // Update methodType if it references the old module
-                        const updatedMethodType = this.updateMethodType(fc.methodType);
-                        if (updatedMethodType !== fc.methodType) {
-                            return (0, mutative_1.create)(fc, draft => {
-                                draft.methodType = updatedMethodType;
-                            });
-                        }
-                        return fc;
+                return m;
+            }
+            async visitFieldAccess(fieldAccess, ctx) {
+                let fa = await super.visitFieldAccess(fieldAccess, ctx);
+                if (!this.hasOldImport) {
+                    return fa;
+                }
+                // Update type if it references the old module
+                const updatedType = this.updateType(fa.type);
+                if (updatedType !== fa.type) {
+                    return (0, mutative_1.create)(fa, draft => {
+                        draft.type = updatedType;
                     });
                 }
-                visitNewClass(newClass, ctx) {
-                    const _super = Object.create(null, {
-                        visitNewClass: { get: () => super.visitNewClass }
+                return fa;
+            }
+            async visitFunctionCall(functionCall, ctx) {
+                let fc = await super.visitFunctionCall(functionCall, ctx);
+                if (!this.hasOldImport) {
+                    return fc;
+                }
+                // Update methodType if it references the old module
+                const updatedMethodType = this.updateMethodType(fc.methodType);
+                if (updatedMethodType !== fc.methodType) {
+                    return (0, mutative_1.create)(fc, draft => {
+                        draft.methodType = updatedMethodType;
                     });
-                    return __awaiter(this, void 0, void 0, function* () {
-                        let nc = yield _super.visitNewClass.call(this, newClass, ctx);
-                        if (!this.hasOldImport) {
-                            return nc;
-                        }
-                        let changed = false;
-                        // Update methodType if it references the old module
-                        const updatedMethodType = this.updateMethodType(nc.methodType);
+                }
+                return fc;
+            }
+            async visitNewClass(newClass, ctx) {
+                let nc = await super.visitNewClass(newClass, ctx);
+                if (!this.hasOldImport) {
+                    return nc;
+                }
+                let changed = false;
+                // Update methodType if it references the old module
+                const updatedMethodType = this.updateMethodType(nc.methodType);
+                if (updatedMethodType !== nc.methodType) {
+                    changed = true;
+                }
+                // Update constructorType if it references the old module
+                const updatedConstructorType = this.updateMethodType(nc.constructorType);
+                if (updatedConstructorType !== nc.constructorType) {
+                    changed = true;
+                }
+                // Update type if it references the old module
+                const updatedType = this.updateType(nc.type);
+                if (updatedType !== nc.type) {
+                    changed = true;
+                }
+                if (changed) {
+                    return (0, mutative_1.create)(nc, draft => {
                         if (updatedMethodType !== nc.methodType) {
-                            changed = true;
+                            draft.methodType = updatedMethodType;
                         }
-                        // Update constructorType if it references the old module
-                        const updatedConstructorType = this.updateMethodType(nc.constructorType);
                         if (updatedConstructorType !== nc.constructorType) {
-                            changed = true;
+                            draft.constructorType = updatedConstructorType;
                         }
-                        // Update type if it references the old module
-                        const updatedType = this.updateType(nc.type);
                         if (updatedType !== nc.type) {
-                            changed = true;
+                            draft.type = updatedType;
                         }
-                        if (changed) {
-                            return (0, mutative_1.create)(nc, draft => {
-                                if (updatedMethodType !== nc.methodType) {
-                                    draft.methodType = updatedMethodType;
-                                }
-                                if (updatedConstructorType !== nc.constructorType) {
-                                    draft.constructorType = updatedConstructorType;
-                                }
-                                if (updatedType !== nc.type) {
-                                    draft.type = updatedType;
-                                }
-                            });
-                        }
-                        return nc;
                     });
                 }
-                /**
-                 * Update a type if it references the old module
-                 */
-                updateType(type) {
-                    if (!type)
+                return nc;
+            }
+            /**
+             * Update a type if it references the old module
+             */
+            updateType(type) {
+                if (!type)
+                    return type;
+                switch (type.kind) {
+                    case java_1.Type.Kind.Class:
+                    case java_1.Type.Kind.ShallowClass:
+                        return this.updateClassType(type);
+                    case java_1.Type.Kind.Method:
+                        return this.updateMethodType(type);
+                    case java_1.Type.Kind.Variable:
+                        return this.updateVariableType(type);
+                    case java_1.Type.Kind.Parameterized:
+                        return this.updateParameterizedType(type);
+                    case java_1.Type.Kind.Array:
+                        return this.updateArrayType(type);
+                    default:
                         return type;
-                    switch (type.kind) {
-                        case java_1.Type.Kind.Class:
-                        case java_1.Type.Kind.ShallowClass:
-                            return this.updateClassType(type);
-                        case java_1.Type.Kind.Method:
-                            return this.updateMethodType(type);
-                        case java_1.Type.Kind.Variable:
-                            return this.updateVariableType(type);
-                        case java_1.Type.Kind.Parameterized:
-                            return this.updateParameterizedType(type);
-                        case java_1.Type.Kind.Array:
-                            return this.updateArrayType(type);
-                        default:
-                            return type;
-                    }
                 }
-                /**
-                 * Update a Class type if its FQN references the old module
-                 */
-                updateClassType(classType) {
-                    let changed = false;
-                    let newFullyQualifiedName = classType.fullyQualifiedName;
-                    let newOwningClass = classType.owningClass;
-                    // Check if the FQN matches or starts with the old module
-                    if (classType.fullyQualifiedName === oldFqn) {
-                        newFullyQualifiedName = newFqn;
-                        changed = true;
-                    }
-                    else if (classType.fullyQualifiedName === oldModule) {
-                        newFullyQualifiedName = newModule;
-                        changed = true;
-                    }
-                    else if (classType.fullyQualifiedName.startsWith(oldModule + '.')) {
-                        newFullyQualifiedName = newModule + classType.fullyQualifiedName.substring(oldModule.length);
+            }
+            /**
+             * Update a Class type if its FQN references the old module
+             */
+            updateClassType(classType) {
+                let changed = false;
+                let newFullyQualifiedName = classType.fullyQualifiedName;
+                let newOwningClass = classType.owningClass;
+                // Check if the FQN matches or starts with the old module
+                if (classType.fullyQualifiedName === oldFqn) {
+                    newFullyQualifiedName = newFqn;
+                    changed = true;
+                }
+                else if (classType.fullyQualifiedName === oldModule) {
+                    newFullyQualifiedName = newModule;
+                    changed = true;
+                }
+                else if (classType.fullyQualifiedName.startsWith(oldModule + '.')) {
+                    newFullyQualifiedName = newModule + classType.fullyQualifiedName.substring(oldModule.length);
+                    changed = true;
+                }
+                // Recursively update owningClass
+                if (classType.owningClass) {
+                    const updatedOwningClass = this.updateClassType(classType.owningClass);
+                    if (updatedOwningClass !== classType.owningClass) {
+                        newOwningClass = updatedOwningClass;
                         changed = true;
                     }
-                    // Recursively update owningClass
-                    if (classType.owningClass) {
-                        const updatedOwningClass = this.updateClassType(classType.owningClass);
-                        if (updatedOwningClass !== classType.owningClass) {
-                            newOwningClass = updatedOwningClass;
-                            changed = true;
-                        }
-                    }
-                    if (changed) {
+                }
+                if (changed) {
+                    // Type objects are marked as non-draftable, so we manually create new objects
+                    return Object.assign(Object.assign({}, classType), { fullyQualifiedName: newFullyQualifiedName, owningClass: newOwningClass });
+                }
+                return classType;
+            }
+            /**
+             * Update a Method type if its declaringType references the old module
+             */
+            updateMethodType(methodType) {
+                if (!methodType)
+                    return methodType;
+                // Update the declaring type
+                if (java_1.Type.isFullyQualified(methodType.declaringType)) {
+                    const declaringTypeFqn = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                    if (declaringTypeFqn === oldModule ||
+                        declaringTypeFqn === oldFqn ||
+                        declaringTypeFqn.startsWith(oldModule + '.')) {
+                        // Need to update the declaring type
+                        const updatedDeclaringType = this.updateType(methodType.declaringType);
+                        // Also update the method name if we're renaming the member
+                        const updatedName = (oldMember !== 'default' && oldMember !== '*' &&
+                            methodType.name === oldMember && newMember !== oldMember)
+                            ? newMember
+                            : methodType.name;
                         // Type objects are marked as non-draftable, so we manually create new objects
-                        return Object.assign(Object.assign({}, classType), { fullyQualifiedName: newFullyQualifiedName, owningClass: newOwningClass });
-                    }
-                    return classType;
-                }
-                /**
-                 * Update a Method type if its declaringType references the old module
-                 */
-                updateMethodType(methodType) {
-                    if (!methodType)
-                        return methodType;
-                    // Update the declaring type
-                    if (java_1.Type.isFullyQualified(methodType.declaringType)) {
-                        const declaringTypeFqn = java_1.Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
-                        if (declaringTypeFqn === oldModule ||
-                            declaringTypeFqn === oldFqn ||
-                            declaringTypeFqn.startsWith(oldModule + '.')) {
-                            // Need to update the declaring type
-                            const updatedDeclaringType = this.updateType(methodType.declaringType);
-                            // Also update the method name if we're renaming the member
-                            const updatedName = (oldMember !== 'default' && oldMember !== '*' &&
-                                methodType.name === oldMember && newMember !== oldMember)
-                                ? newMember
-                                : methodType.name;
-                            // Type objects are marked as non-draftable, so we manually create new objects
-                            return Object.assign(Object.assign({}, methodType), { declaringType: updatedDeclaringType, name: updatedName });
-                        }
+                        return Object.assign(Object.assign({}, methodType), { declaringType: updatedDeclaringType, name: updatedName });
                     }
-                    return methodType;
                 }
-                /**
-                 * Update a Variable type if its owner references the old module
-                 */
-                updateVariableType(variableType) {
-                    let changed = false;
-                    let newOwner = variableType.owner;
-                    let newInnerType = variableType.type;
-                    // Update owner if it references the old module
-                    if (variableType.owner) {
-                        const updatedOwner = this.updateType(variableType.owner);
-                        if (updatedOwner !== variableType.owner) {
-                            newOwner = updatedOwner;
-                            changed = true;
-                        }
-                    }
-                    // Update inner type if it references the old module
-                    const updatedInnerType = this.updateType(variableType.type);
-                    if (updatedInnerType !== variableType.type) {
-                        newInnerType = updatedInnerType;
+                return methodType;
+            }
+            /**
+             * Update a Variable type if its owner references the old module
+             */
+            updateVariableType(variableType) {
+                let changed = false;
+                let newOwner = variableType.owner;
+                let newInnerType = variableType.type;
+                // Update owner if it references the old module
+                if (variableType.owner) {
+                    const updatedOwner = this.updateType(variableType.owner);
+                    if (updatedOwner !== variableType.owner) {
+                        newOwner = updatedOwner;
                         changed = true;
                     }
-                    if (changed) {
-                        // Type objects are marked as non-draftable, so we manually create new objects
-                        return Object.assign(Object.assign({}, variableType), { owner: newOwner, type: newInnerType });
-                    }
-                    return variableType;
-                }
-                /**
-                 * Update a Parameterized type if its base type references the old module
-                 */
-                updateParameterizedType(paramType) {
-                    let changed = false;
-                    let newBaseType = paramType.type;
-                    let newTypeParams = paramType.typeParameters;
-                    // Update base type
-                    if (java_1.Type.isFullyQualified(paramType.type)) {
-                        const updatedType = this.updateType(paramType.type);
-                        if (updatedType !== paramType.type) {
-                            newBaseType = updatedType;
-                            changed = true;
-                        }
-                    }
-                    // Update type parameters
-                    const updatedParams = paramType.typeParameters.map(tp => this.updateType(tp));
-                    if (updatedParams.some((p, i) => p !== paramType.typeParameters[i])) {
-                        newTypeParams = updatedParams;
+                }
+                // Update inner type if it references the old module
+                const updatedInnerType = this.updateType(variableType.type);
+                if (updatedInnerType !== variableType.type) {
+                    newInnerType = updatedInnerType;
+                    changed = true;
+                }
+                if (changed) {
+                    // Type objects are marked as non-draftable, so we manually create new objects
+                    return Object.assign(Object.assign({}, variableType), { owner: newOwner, type: newInnerType });
+                }
+                return variableType;
+            }
+            /**
+             * Update a Parameterized type if its base type references the old module
+             */
+            updateParameterizedType(paramType) {
+                let changed = false;
+                let newBaseType = paramType.type;
+                let newTypeParams = paramType.typeParameters;
+                // Update base type
+                if (java_1.Type.isFullyQualified(paramType.type)) {
+                    const updatedType = this.updateType(paramType.type);
+                    if (updatedType !== paramType.type) {
+                        newBaseType = updatedType;
                         changed = true;
                     }
-                    if (changed) {
-                        // Type objects are marked as non-draftable, so we manually create new objects
-                        return Object.assign(Object.assign({}, paramType), { type: newBaseType, typeParameters: newTypeParams });
-                    }
-                    return paramType;
-                }
-                /**
-                 * Update an Array type if its element type references the old module
-                 */
-                updateArrayType(arrayType) {
-                    const updatedElemType = this.updateType(arrayType.elemType);
-                    if (updatedElemType !== arrayType.elemType) {
-                        // Type objects are marked as non-draftable, so we manually create new objects
-                        return Object.assign(Object.assign({}, arrayType), { elemType: updatedElemType });
-                    }
-                    return arrayType;
-                }
-                checkForOldImport(jsImport) {
-                    // Check if this import is from the old module
-                    const moduleSpecifier = jsImport.moduleSpecifier;
-                    if (!moduleSpecifier)
-                        return { found: false };
-                    const literal = moduleSpecifier.element;
-                    if (literal.kind !== java_1.J.Kind.Literal)
-                        return { found: false };
-                    const value = literal.value;
-                    if (value !== oldModule)
-                        return { found: false };
-                    const importClause = jsImport.importClause;
-                    if (!importClause) {
-                        // Side-effect import - not what we're looking for
-                        return { found: false };
+                }
+                // Update type parameters
+                const updatedParams = paramType.typeParameters.map(tp => this.updateType(tp));
+                if (updatedParams.some((p, i) => p !== paramType.typeParameters[i])) {
+                    newTypeParams = updatedParams;
+                    changed = true;
+                }
+                if (changed) {
+                    // Type objects are marked as non-draftable, so we manually create new objects
+                    return Object.assign(Object.assign({}, paramType), { type: newBaseType, typeParameters: newTypeParams });
+                }
+                return paramType;
+            }
+            /**
+             * Update an Array type if its element type references the old module
+             */
+            updateArrayType(arrayType) {
+                const updatedElemType = this.updateType(arrayType.elemType);
+                if (updatedElemType !== arrayType.elemType) {
+                    // Type objects are marked as non-draftable, so we manually create new objects
+                    return Object.assign(Object.assign({}, arrayType), { elemType: updatedElemType });
+                }
+                return arrayType;
+            }
+            checkForOldImport(jsImport) {
+                // Check if this import is from the old module
+                const moduleSpecifier = jsImport.moduleSpecifier;
+                if (!moduleSpecifier)
+                    return { found: false };
+                const literal = moduleSpecifier.element;
+                if (literal.kind !== java_1.J.Kind.Literal)
+                    return { found: false };
+                const value = literal.value;
+                if (value !== oldModule)
+                    return { found: false };
+                const importClause = jsImport.importClause;
+                if (!importClause) {
+                    // Side-effect import - not what we're looking for
+                    return { found: false };
+                }
+                // Check for default import
+                if (oldMember === 'default') {
+                    if (importClause.name) {
+                        const nameElem = importClause.name.element;
+                        if ((0, java_1.isIdentifier)(nameElem)) {
+                            return { found: true, alias: nameElem.simpleName };
+                        }
                     }
-                    // Check for default import
-                    if (oldMember === 'default') {
-                        if (importClause.name) {
-                            const nameElem = importClause.name.element;
-                            if ((0, java_1.isIdentifier)(nameElem)) {
-                                return { found: true, alias: nameElem.simpleName };
-                            }
+                    return { found: false };
+                }
+                // Check for namespace import
+                if (oldMember === '*') {
+                    const namedBindings = importClause.namedBindings;
+                    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === index_1.JS.Kind.Alias) {
+                        const alias = namedBindings;
+                        if ((0, java_1.isIdentifier)(alias.alias)) {
+                            return { found: true, alias: alias.alias.simpleName };
                         }
-                        return { found: false };
                     }
-                    // Check for namespace import
-                    if (oldMember === '*') {
-                        const namedBindings = importClause.namedBindings;
-                        if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === index_1.JS.Kind.Alias) {
-                            const alias = namedBindings;
+                    return { found: false };
+                }
+                // Check for named imports
+                const namedBindings = importClause.namedBindings;
+                if (!namedBindings)
+                    return { found: false };
+                if (namedBindings.kind !== index_1.JS.Kind.NamedImports)
+                    return { found: false };
+                const namedImports = namedBindings;
+                const elements = namedImports.elements.elements;
+                for (const elem of elements) {
+                    const specifier = elem.element;
+                    const specifierNode = specifier.specifier;
+                    // Handle direct import: import { act }
+                    if ((0, java_1.isIdentifier)(specifierNode) && specifierNode.simpleName === oldMember) {
+                        return { found: true };
+                    }
+                    // Handle aliased import: import { act as something }
+                    if (specifierNode.kind === index_1.JS.Kind.Alias) {
+                        const alias = specifierNode;
+                        const propertyName = alias.propertyName.element;
+                        if ((0, java_1.isIdentifier)(propertyName) && propertyName.simpleName === oldMember) {
                             if ((0, java_1.isIdentifier)(alias.alias)) {
                                 return { found: true, alias: alias.alias.simpleName };
                             }
                         }
-                        return { found: false };
                     }
-                    // Check for named imports
-                    const namedBindings = importClause.namedBindings;
-                    if (!namedBindings)
-                        return { found: false };
-                    if (namedBindings.kind !== index_1.JS.Kind.NamedImports)
-                        return { found: false };
-                    const namedImports = namedBindings;
-                    const elements = namedImports.elements.elements;
-                    for (const elem of elements) {
-                        const specifier = elem.element;
-                        const specifierNode = specifier.specifier;
-                        // Handle direct import: import { act }
-                        if ((0, java_1.isIdentifier)(specifierNode) && specifierNode.simpleName === oldMember) {
-                            return { found: true };
-                        }
-                        // Handle aliased import: import { act as something }
-                        if (specifierNode.kind === index_1.JS.Kind.Alias) {
-                            const alias = specifierNode;
-                            const propertyName = alias.propertyName.element;
-                            if ((0, java_1.isIdentifier)(propertyName) && propertyName.simpleName === oldMember) {
-                                if ((0, java_1.isIdentifier)(alias.alias)) {
-                                    return { found: true, alias: alias.alias.simpleName };
-                                }
-                            }
-                        }
-                    }
-                    return { found: false };
                 }
-            }();
-        });
+                return { found: false };
+            }
+        }();
     }
 }
 exports.ChangeImport = ChangeImport;