import { firstUpperCase } from "../utils";
|
|
/**
|
* 将模板字符串扁平化处理，转换为 Service 类型定义
|
* @param template - 包含 Service 类型定义的模板字符串
|
* @returns 处理后的 Service 类型定义字符串
|
* @throws {Error} 当模板中找不到 Service 类型定义时抛出错误
|
*/
|
export function flatten(template: string): string {
|
// 查找 Service 类型定义的起始位置
|
const startIndex = template.indexOf("export type Service = {");
|
|
// 保留 Service 类型定义前的内容
|
let header = template.substring(0, startIndex);
|
|
// 获取 Service 类型定义及其内容，去除换行和制表符
|
const serviceTemplateContent = template.substring(startIndex).replace(/\n|\t/g, "");
|
|
// 找到 Service 的内容部分
|
const serviceStartIndex = serviceTemplateContent.indexOf("{") + 1;
|
const serviceEndIndex = findClosingBrace(serviceTemplateContent, serviceStartIndex);
|
const serviceInnerContent = serviceTemplateContent
|
.substring(serviceStartIndex, serviceEndIndex)
|
.trim();
|
|
// 存储所有接口定义
|
const allInterfaces = new Map<string, string>();
|
|
// 处理 Service 内容，保持原有结构但替换嵌套对象为接口引用
|
const serviceContent = buildCurrentLevelContent(serviceInnerContent);
|
|
// 递归收集所有需要生成的接口
|
flattenContent(serviceInnerContent, allInterfaces, []);
|
|
// 生成所有接口定义
|
let interfaces = "";
|
allInterfaces.forEach((content, key) => {
|
interfaces += `\nexport interface ${firstUpperCase(key)}Interface { ${content} }\n`;
|
});
|
|
return `${header}${interfaces}\nexport type Service = { ${serviceContent} }`;
|
}
|
|
/**
|
* 查找匹配的右花括号位置
|
* @param str - 要搜索的字符串
|
* @param startIndex - 开始搜索的位置
|
* @returns 匹配的右花括号位置
|
* @throws {Error} 当找不到匹配的右花括号时抛出错误
|
*/
|
function findClosingBrace(str: string, startIndex: number): number {
|
let braceCount = 1;
|
let currentIndex = startIndex;
|
|
while (currentIndex < str.length && braceCount > 0) {
|
if (str[currentIndex] === "{") braceCount++;
|
if (str[currentIndex] === "}") braceCount--;
|
currentIndex++;
|
}
|
|
if (braceCount !== 0) {
|
throw new Error("Unmatched braces in the template");
|
}
|
|
return currentIndex - 1;
|
}
|
|
/**
|
* 递归收集所有需要生成的接口
|
* @param content - 要处理的内容
|
* @param allInterfaces - 存储所有接口定义的 Map
|
* @param parentFields - 父级字段数组（暂未使用）
|
*/
|
function flattenContent(
|
content: string,
|
allInterfaces: Map<string, string>,
|
parentFields: string[],
|
): void {
|
const interfacePattern = /(\w+)\s*:\s*\{/g;
|
let match: RegExpExecArray | null;
|
|
while ((match = interfacePattern.exec(content)) !== null) {
|
const key = match[1];
|
const startIndex = match.index + match[0].length;
|
const endIndex = findClosingBrace(content, startIndex);
|
|
if (endIndex > startIndex) {
|
const innerContent = content.substring(startIndex, endIndex).trim();
|
|
// 构建当前接口的内容，将嵌套对象替换为接口引用
|
const currentLevelContent = buildCurrentLevelContent(innerContent);
|
allInterfaces.set(key, currentLevelContent);
|
|
// 递归处理嵌套内容
|
flattenContent(innerContent, allInterfaces, []);
|
}
|
}
|
}
|
|
/**
|
* 构建当前级别的内容，将嵌套对象替换为接口引用
|
* @param content - 内容字符串
|
* @returns 处理后的内容
|
*/
|
function buildCurrentLevelContent(content: string): string {
|
const interfacePattern = /(\w+)\s*:\s*\{/g;
|
let result = content;
|
let match: RegExpExecArray | null;
|
|
// 重置正则表达式的 lastIndex
|
interfacePattern.lastIndex = 0;
|
|
while ((match = interfacePattern.exec(content)) !== null) {
|
const key = match[1];
|
const startIndex = match.index + match[0].length;
|
const endIndex = findClosingBrace(content, startIndex);
|
|
if (endIndex > startIndex) {
|
const fullMatch = content.substring(match.index, endIndex + 1);
|
const replacement = `${key}: ${firstUpperCase(key)}Interface;`;
|
result = result.replace(fullMatch, replacement);
|
}
|
}
|
|
// 清理多余的分号和空格
|
result = result.replace(/;+/g, ";").replace(/\s+/g, " ").trim();
|
|
return result;
|
}
|
