@openrewrite/rewrite 8.69.0-20251207-184829 → 8.69.0-20251207-214914

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

@@ -0,0 +1,658 @@
+"use strict";
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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");
+const index_1 = require("../index");
+const add_import_1 = require("../add-import");
+const java_1 = require("../../java");
+const immer_1 = require("immer");
+/**
+ * Changes an import from one module to another, updating all type attributions.
+ *
+ * This recipe is useful for:
+ * - Library migrations (e.g., moving `act` from `react-dom/test-utils` to `react`)
+ * - Module restructuring (e.g., split packages)
+ * - Renaming exported members
+ *
+ * @example
+ * // Migrate act import from react-dom/test-utils to react
+ * const recipe = new ChangeImport({
+ *     oldModule: "react-dom/test-utils",
+ *     oldMember: "act",
+ *     newModule: "react"
+ * });
+ * // Before: import { act } from 'react-dom/test-utils';
+ * // After:  import { act } from 'react';
+ *
+ * @example
+ * // Change a named import to a different name
+ * const recipe = new ChangeImport({
+ *     oldModule: "lodash",
+ *     oldMember: "extend",
+ *     newModule: "lodash",
+ *     newMember: "assign"
+ * });
+ * // Before: import { extend } from 'lodash';
+ * // After:  import { assign } from 'lodash';
+ */
+class ChangeImport extends recipe_1.Recipe {
+    constructor(options) {
+        super(options);
+        this.name = "org.openrewrite.javascript.change-import";
+        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
+                                });
+                            }
+                        }
+                        return result;
+                    });
+                }
+                visitImportDeclaration(jsImport, ctx) {
+                    const _super = Object.create(null, {
+                        visitImportDeclaration: { get: () => super.visitImportDeclaration }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        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;
+                        }
+                        // 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, immer_1.produce)(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;
+                                            }
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                        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, immer_1.produce)(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;
+                        });
+                    });
+                }
+                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);
+                            }
+                        }
+                    }
+                    return imports;
+                }
+                visitIdentifier(identifier, ctx) {
+                    const _super = Object.create(null, {
+                        visitIdentifier: { get: () => super.visitIdentifier }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        let ident = yield _super.visitIdentifier.call(this, 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, immer_1.produce)(ident, draft => {
+                                if (updatedType !== ident.type) {
+                                    draft.type = updatedType;
+                                }
+                                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, immer_1.produce)(m, draft => {
+                                draft.methodType = updatedMethodType;
+                            });
+                        }
+                        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, immer_1.produce)(fa, draft => {
+                                draft.type = updatedType;
+                            });
+                        }
+                        return fa;
+                    });
+                }
+                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, immer_1.produce)(fc, draft => {
+                                draft.methodType = updatedMethodType;
+                            });
+                        }
+                        return fc;
+                    });
+                }
+                visitNewClass(newClass, ctx) {
+                    const _super = Object.create(null, {
+                        visitNewClass: { get: () => super.visitNewClass }
+                    });
+                    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);
+                        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, immer_1.produce)(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 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);
+                        changed = true;
+                    }
+                    // Recursively update owningClass
+                    if (classType.owningClass) {
+                        const updatedOwningClass = this.updateClassType(classType.owningClass);
+                        if (updatedOwningClass !== classType.owningClass) {
+                            newOwningClass = updatedOwningClass;
+                            changed = true;
+                        }
+                    }
+                    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({}, 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;
+                        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;
+                        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 };
+                            }
+                        }
+                        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 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 };
+                }
+            }();
+        });
+    }
+}
+exports.ChangeImport = ChangeImport;
+__decorate([
+    (0, recipe_1.Option)({
+        displayName: "Old module",
+        description: "The module to change imports from",
+        example: "react-dom/test-utils"
+    })
+], ChangeImport.prototype, "oldModule", void 0);
+__decorate([
+    (0, recipe_1.Option)({
+        displayName: "Old member",
+        description: "The member to change (or 'default' for default imports, '*' for namespace imports)",
+        example: "act"
+    })
+], ChangeImport.prototype, "oldMember", void 0);
+__decorate([
+    (0, recipe_1.Option)({
+        displayName: "New module",
+        description: "The module to change imports to",
+        example: "react"
+    })
+], ChangeImport.prototype, "newModule", void 0);
+__decorate([
+    (0, recipe_1.Option)({
+        displayName: "New member",
+        description: "The new member name. If not specified, keeps the same member name.",
+        example: "act",
+        required: false
+    })
+], ChangeImport.prototype, "newMember", void 0);
+__decorate([
+    (0, recipe_1.Option)({
+        displayName: "New alias",
+        description: "Optional alias for the new import. Required when newMember is 'default' or '*'.",
+        required: false
+    })
+], ChangeImport.prototype, "newAlias", void 0);
+//# sourceMappingURL=change-import.js.map