refakts/dist/services/structural-analyzer.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";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.StructuralAnalyzer = void 0;
const path = __importStar(require("path"));
class StructuralAnalyzer {
    findStructuralMatches(sourceFile, options) {
        const { regex, fileName } = this.prepareMatchingContext(sourceFile, options);
        return this.collectAllMatches(sourceFile, regex, fileName, options);
    }
    prepareMatchingContext(sourceFile, options) {
        const pattern = options.regex;
        const fileName = path.basename(sourceFile.getFilePath());
        const regex = new RegExp(pattern);
        return { regex, fileName };
    }
    collectAllMatches(sourceFile, regex, fileName, options) {
        const results = [];
        this.addFieldMatches(sourceFile, regex, fileName, options, results);
        this.addMethodMatches(sourceFile, regex, fileName, options, results);
        return results;
    }
    addFieldMatches(sourceFile, regex, fileName, options, results) {
        if (this.shouldIncludeFields(options)) {
            results.push(...this.findASTFieldMatches(sourceFile, regex, fileName));
        }
    }
    addMethodMatches(sourceFile, regex, fileName, options, results) {
        if (this.shouldIncludeMethods(options)) {
            results.push(...this.findASTMethodMatches(sourceFile, regex, fileName));
        }
    }
    shouldIncludeFields(options) {
        return Boolean(options.includeFields || options['include-fields']);
    }
    shouldIncludeMethods(options) {
        return Boolean(options.includeMethods || options['include-methods']);
    }
    findASTFieldMatches(sourceFile, regex, fileName) {
        const classes = sourceFile.getClasses();
        return this.collectFieldsFromClasses(classes, regex, fileName);
    }
    collectFieldsFromClasses(classes, regex, fileName) {
        const results = [];
        for (const classDecl of classes) {
            const fieldMatches = this.getMatchingFields(classDecl, regex, fileName);
            results.push(...fieldMatches);
        }
        return results;
    }
    getMatchingFields(classDecl, regex, fileName) {
        const properties = classDecl.getProperties();
        return this.filterAndFormatProperties(properties, regex, fileName);
    }
    filterAndFormatProperties(properties, regex, fileName) {
        return this.processAllProperties(properties, regex, fileName);
    }
    processAllProperties(properties, regex, fileName) {
        const results = [];
        for (const prop of properties) {
            const result = this.processProperty(prop, regex, fileName);
            if (result)
                results.push(result);
        }
        return results;
    }
    processProperty(prop, regex, fileName) {
        return this.propertyMatches(prop, regex)
            ? this.formatFieldResult(prop, fileName)
            : null;
    }
    propertyMatches(prop, regex) {
        return regex.test(prop.getName());
    }
    formatFieldResult(prop, fileName) {
        const positions = this.getPropertyPositions(prop);
        return {
            location: `[${fileName} ${positions.startLine}:${positions.startColumn}-${positions.endLine}:${positions.endColumn}]`,
            content: prop.getName()
        };
    }
    getPropertyPositions(prop) {
        const nameNode = prop.getNameNode();
        const start = nameNode.getStart();
        const end = nameNode.getEnd();
        const sourceFile = prop.getSourceFile();
        const startPos = sourceFile.getLineAndColumnAtPos(start);
        const endPos = sourceFile.getLineAndColumnAtPos(end);
        return { startLine: startPos.line, startColumn: startPos.column, endLine: endPos.line, endColumn: endPos.column };
    }
    findASTMethodMatches(sourceFile, regex, fileName) {
        const classes = sourceFile.getClasses();
        return this.collectMethodsFromClasses(classes, regex, fileName);
    }
    collectMethodsFromClasses(classes, regex, fileName) {
        const results = [];
        for (const classDecl of classes) {
            const methodMatches = this.getMatchingMethods(classDecl, regex, fileName);
            results.push(...methodMatches);
        }
        return results;
    }
    getMatchingMethods(classDecl, regex, fileName) {
        const methods = classDecl.getMethods();
        return this.filterAndFormatMethods(methods, regex, fileName);
    }
    filterAndFormatMethods(methods, regex, fileName) {
        return this.processAllMethods(methods, regex, fileName);
    }
    processAllMethods(methods, regex, fileName) {
        const results = [];
        for (const method of methods) {
            const result = this.processMethod(method, regex, fileName);
            if (result)
                results.push(result);
        }
        return results;
    }
    processMethod(method, regex, fileName) {
        return this.methodMatches(method, regex)
            ? this.formatMethodResult(method, fileName)
            : null;
    }
    methodMatches(method, regex) {
        return regex.test(method.getName());
    }
    formatMethodResult(method, fileName) {
        const positions = this.getMethodPositions(method);
        return {
            location: `[${fileName} ${positions.startLine}:-${positions.endLine}:]`,
            content: method.getText()
        };
    }
    getMethodPositions(method) {
        const start = method.getStart();
        const end = method.getEnd();
        const sourceFile = method.getSourceFile();
        const startPos = sourceFile.getLineAndColumnAtPos(start);
        const endPos = sourceFile.getLineAndColumnAtPos(end);
        return { startLine: startPos.line, endLine: endPos.line };
    }
}
exports.StructuralAnalyzer = StructuralAnalyzer;
//# sourceMappingURL=structural-analyzer.js.map