refakts/dist/commands/inline-variable-command.js

TypeScript refactoring tool built for AI coding agents to perform precise refactoring operations via command line instead of requiring complete code regeneration.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InlineVariableCommand = void 0;
const ts_morph_1 = require("ts-morph");
const ast_service_1 = require("../services/ast-service");
const variable_declaration_finder_1 = require("../services/variable-declaration-finder");
const expression_analyzer_1 = require("../services/expression-analyzer");
const variable_replacer_1 = require("../services/variable-replacer");
class InlineVariableCommand {
    constructor() {
        this.name = 'inline-variable';
        this.description = 'Replace variable usage with its value';
        this.complete = true;
        this.astService = new ast_service_1.ASTService();
        this.declarationFinder = new variable_declaration_finder_1.VariableDeclarationFinder();
        this.expressionAnalyzer = new expression_analyzer_1.ExpressionAnalyzer();
        this.variableReplacer = new variable_replacer_1.VariableReplacer();
    }
    async execute(file, options) {
        this.validateOptions(options);
        const sourceFile = this.astService.loadSourceFile(file);
        const node = this.findTargetNode(options);
        await this.performInlineVariable(node);
        await this.astService.saveSourceFile(sourceFile);
    }
    findTargetNode(options) {
        return this.astService.findNodeByLocation(options.location);
    }
    validateOptions(options) {
        if (!options.location) {
            throw new Error('Location format must be specified');
        }
    }
    getHelpText() {
        return '\nExamples:\n  refakts inline-variable "[src/file.ts 5:8-5:18]"';
    }
    async performInlineVariable(node) {
        this.validateIdentifierNode(node);
        const variableName = node.getText();
        const sourceFile = node.getSourceFile();
        const declaration = this.declarationFinder.findVariableDeclaration(sourceFile, variableName, node);
        const initializerText = this.getInitializerText(declaration, variableName);
        this.variableReplacer.replaceAllReferences(sourceFile, variableName, declaration, initializerText);
        this.variableReplacer.removeDeclaration(declaration);
    }
    validateIdentifierNode(node) {
        if (node.getKind() !== 80) {
            throw new Error(`Expected identifier, got ${node.getKindName()}`);
        }
    }
    getInitializerText(declaration, variableName, context) {
        const nameNode = declaration.getNameNode();
        if (ts_morph_1.Node.isObjectBindingPattern(nameNode) && variableName) {
            return this.getDestructuringInitializer(declaration, variableName);
        }
        return this.getRegularInitializer(declaration, context);
    }
    getDestructuringInitializer(declaration, variableName) {
        const initializer = declaration.getInitializer();
        if (!initializer) {
            throw new Error('Destructuring declaration has no initializer to inline');
        }
        const initializerText = initializer.getText();
        return `${initializerText}.${variableName}`;
    }
    getRegularInitializer(declaration, context) {
        const initializer = declaration.getInitializer();
        if (!initializer) {
            throw new Error('Variable has no initializer to inline');
        }
        return this.expressionAnalyzer.formatWithParentheses(initializer, context);
    }
}
exports.InlineVariableCommand = InlineVariableCommand;
//# sourceMappingURL=inline-variable-command.js.map