refakts
Version:
TypeScript refactoring tool built for AI coding agents to perform precise refactoring operations via command line instead of requiring complete code regeneration.
162 lines • 6.61 kB
JavaScript
"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.RangeAnalyzer = void 0;
const path = __importStar(require("path"));
class RangeAnalyzer {
findRangeMatches(sourceFile, options) {
const regexOptions = this.extractRegexOptions(options);
const fileName = path.basename(sourceFile.getFilePath());
const ranges = this.findContentRanges(sourceFile, regexOptions.start, regexOptions.end);
return this.formatRangeResults(ranges, fileName);
}
extractRegexOptions(options) {
return {
start: (options.startRegex || options['start-regex']),
end: (options.endRegex || options['end-regex'])
};
}
formatRangeResults(ranges, fileName) {
if (ranges.length === 0)
return [{ location: 'No Matches' }];
return ranges.map(range => this.formatSingleRange(range, fileName));
}
formatSingleRange(range, fileName) {
const location = `\n[${fileName} ${range.startLine}:${range.startColumn}-${range.endLine}:${range.endColumn}]`;
return {
location,
content: `${range.content}\n[${fileName} ${range.startLine}:${range.startColumn}-${range.endLine}:${range.endColumn}]`
};
}
findContentRanges(sourceFile, startRegex, endRegex) {
const lines = sourceFile.getFullText().split('\n');
const patterns = this.createPatterns(startRegex, endRegex);
return this.processAllLines(sourceFile, lines, patterns);
}
processAllLines(sourceFile, lines, patterns) {
const ranges = [];
for (let i = 0; i < lines.length; i++) {
const result = this.processLine(sourceFile, lines, patterns, i);
i = this.handleLineResult(result, ranges, i);
}
return ranges;
}
handleLineResult(result, ranges, currentIndex) {
if (result.range) {
ranges.push(result.range);
return result.newIndex;
}
return currentIndex;
}
processLine(sourceFile, lines, patterns, i) {
if (this.shouldSkipLine(sourceFile, i + 1)) {
return this.createSkipResult(i);
}
return this.createRangeResult(sourceFile, lines, patterns, i);
}
createSkipResult(index) {
return { range: null, newIndex: index };
}
createRangeResult(sourceFile, lines, patterns, i) {
const range = this.findRangeFromStartLine(sourceFile, lines, patterns, i);
return {
range,
newIndex: range ? range.endLineIndex : i
};
}
createPatterns(startRegex, endRegex) {
return {
start: new RegExp(startRegex),
end: new RegExp(endRegex)
};
}
shouldSkipLine(sourceFile, lineNumber) {
return this.isCommentLine(sourceFile, lineNumber);
}
findRangeFromStartLine(sourceFile, lines, patterns, startIndex) {
const startMatch = patterns.start.exec(lines[startIndex]);
if (!startMatch)
return null;
const rangeStart = { line: startIndex + 1, column: startMatch.index + 1 };
const endResult = this.findEndMatch(sourceFile, lines, patterns.end, startIndex);
return endResult ? this.createRange(rangeStart, endResult.match, lines, startIndex, endResult.index) : null;
}
findEndMatch(sourceFile, lines, endPattern, startIndex) {
for (let j = startIndex; j < lines.length; j++) {
if (this.shouldSkipLine(sourceFile, j + 1))
continue;
const endMatch = endPattern.exec(lines[j]);
if (endMatch)
return { match: endMatch, index: j };
}
return null;
}
createRange(rangeStart, endMatch, lines, startIndex, endIndex) {
const rangeEnd = this.calculateRangeEnd(endMatch, endIndex);
const content = this.extractRangeContent(lines, startIndex, endIndex);
return this.buildRangeObject(rangeStart, rangeEnd, content, endIndex);
}
calculateRangeEnd(endMatch, endIndex) {
return { line: endIndex + 1, column: endMatch.index + endMatch[0].length + 1 };
}
extractRangeContent(lines, startIndex, endIndex) {
return lines.slice(startIndex, endIndex + 1).join('\n');
}
buildRangeObject(rangeStart, rangeEnd, content, endIndex) {
return {
startLine: rangeStart.line,
startColumn: rangeStart.column,
endLine: rangeEnd.line,
endColumn: rangeEnd.column,
content,
endLineIndex: endIndex
};
}
isCommentLine(sourceFile, lineNumber) {
const lines = sourceFile.getFullText().split('\n');
if (this.isInvalidLineNumber(lineNumber, lines.length))
return false;
const line = lines[lineNumber - 1];
return this.startsWithCommentMarker(line.trim());
}
isInvalidLineNumber(lineNumber, totalLines) {
return lineNumber <= 0 || lineNumber > totalLines;
}
startsWithCommentMarker(trimmedLine) {
return trimmedLine.startsWith('//') || trimmedLine.startsWith('*') || trimmedLine.startsWith('/*');
}
}
exports.RangeAnalyzer = RangeAnalyzer;
//# sourceMappingURL=range-analyzer.js.map