|
|
import { resolve } from 'path' |
|
|
import fs from 'fs' |
|
|
import * as parser from '@babel/parser' |
|
|
import traverse from '@babel/traverse' |
|
|
import { parse } from '@vue/compiler-sfc' |
|
|
|
|
|
// 路由映射插件 - 真正利用AST解析和Vite编译时关系 |
|
|
export function routeMappingPlugin() { |
|
|
return { |
|
|
name: 'route-mapping', |
|
|
|
|
|
// 在构建开始时执行 |
|
|
buildStart() { |
|
|
console.log('🔧 开始分析AST和Vite编译时关系...') |
|
|
this.analyzeASTAndViteRelations() |
|
|
}, |
|
|
|
|
|
// 在开发模式下也执行 |
|
|
configureServer(server) { |
|
|
console.log('🔧 开发模式下分析AST和Vite编译时关系...') |
|
|
this.analyzeASTAndViteRelations() |
|
|
}, |
|
|
|
|
|
// 利用AST和Vite编译时API分析关系 |
|
|
analyzeASTAndViteRelations() { |
|
|
try { |
|
|
// 1. 分析路由配置的AST |
|
|
const routerAST = this.analyzeRouterAST() |
|
|
|
|
|
// 2. 分析组件文件的AST |
|
|
const componentASTs = this.analyzeComponentASTs() |
|
|
|
|
|
// 3. 分析服务文件的AST |
|
|
const serviceASTs = this.analyzeServiceASTs() |
|
|
|
|
|
// 4. 建立真实的调用关系 |
|
|
const callRelations = this.buildCallRelations(routerAST, componentASTs, serviceASTs) |
|
|
|
|
|
// 5. 生成真实的路由映射 |
|
|
const routeMappings = this.generateRealRouteMappings(callRelations) |
|
|
|
|
|
// 6. 生成映射文件 |
|
|
this.generateRouteMappingFile(routeMappings) |
|
|
|
|
|
console.log('✅ AST和Vite编译时关系分析完成') |
|
|
} catch (error) { |
|
|
console.error('❌ AST和Vite编译时关系分析失败:', error) |
|
|
// 回退到简单分析 |
|
|
this.fallbackToSimpleAnalysis() |
|
|
} |
|
|
}, |
|
|
|
|
|
// 分析路由AST |
|
|
analyzeRouterAST() { |
|
|
const routerPath = resolve(__dirname, '../src/renderer/router/index.js') |
|
|
if (!fs.existsSync(routerPath)) { |
|
|
throw new Error('Router file not found') |
|
|
} |
|
|
|
|
|
const routerContent = fs.readFileSync(routerPath, 'utf-8') |
|
|
const ast = parser.parse(routerContent, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const routes = [] |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找路由配置对象 |
|
|
ObjectExpression(path) { |
|
|
const properties = path.node.properties |
|
|
let route = {} |
|
|
|
|
|
properties.forEach(prop => { |
|
|
if (prop.key && prop.key.name === 'path' && prop.value && prop.value.value) { |
|
|
route.path = prop.value.value |
|
|
} |
|
|
if (prop.key && prop.key.name === 'name' && prop.value && prop.value.value) { |
|
|
route.name = prop.value.value |
|
|
} |
|
|
if (prop.key && prop.key.name === 'component' && prop.value) { |
|
|
route.component = this.extractComponentName(prop.value) |
|
|
} |
|
|
}) |
|
|
|
|
|
if (route.path) { |
|
|
route.module = this.extractModuleFromPath(route.path) |
|
|
routes.push(route) |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return { routes, ast } |
|
|
}, |
|
|
|
|
|
// 分析组件AST |
|
|
analyzeComponentASTs() { |
|
|
const componentASTs = new Map() |
|
|
const componentFiles = this.findComponentFiles() |
|
|
|
|
|
componentFiles.forEach(componentFile => { |
|
|
try { |
|
|
const content = fs.readFileSync(componentFile.path, 'utf-8') |
|
|
|
|
|
if (componentFile.path.endsWith('.vue')) { |
|
|
// 解析Vue文件 |
|
|
const { descriptor } = parse(content) |
|
|
const scriptContent = descriptor.script?.content || '' |
|
|
|
|
|
if (scriptContent) { |
|
|
const scriptAST = parser.parse(scriptContent, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeVueComponentAST(scriptAST, componentFile.name) |
|
|
componentASTs.set(componentFile.name, { |
|
|
...analysis, |
|
|
file: componentFile, |
|
|
template: descriptor.template?.content || '' |
|
|
}) |
|
|
} |
|
|
} else { |
|
|
// 解析JS文件 |
|
|
const ast = parser.parse(content, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeJavaScriptComponentAST(ast, componentFile.name) |
|
|
componentASTs.set(componentFile.name, { |
|
|
...analysis, |
|
|
file: componentFile |
|
|
}) |
|
|
} |
|
|
} catch (error) { |
|
|
console.warn(`⚠️ 解析组件文件失败: ${componentFile.path}`, error.message) |
|
|
} |
|
|
}) |
|
|
|
|
|
return componentASTs |
|
|
}, |
|
|
|
|
|
// 分析服务AST |
|
|
analyzeServiceASTs() { |
|
|
const serviceASTs = new Map() |
|
|
const serviceFiles = this.findServiceFiles() |
|
|
|
|
|
serviceFiles.forEach(serviceFile => { |
|
|
try { |
|
|
const content = fs.readFileSync(serviceFile.path, 'utf-8') |
|
|
const ast = parser.parse(content, { |
|
|
sourceType: 'module', |
|
|
plugins: ['jsx'] |
|
|
}) |
|
|
|
|
|
const analysis = this.analyzeServiceAST(ast, serviceFile.name) |
|
|
serviceASTs.set(serviceFile.name, { |
|
|
...analysis, |
|
|
file: serviceFile |
|
|
}) |
|
|
} catch (error) { |
|
|
console.warn(`⚠️ 解析服务文件失败: ${serviceFile.path}`, error.message) |
|
|
} |
|
|
}) |
|
|
|
|
|
return serviceASTs |
|
|
}, |
|
|
|
|
|
// 分析Vue组件AST |
|
|
analyzeVueComponentAST(ast, componentName) { |
|
|
const analysis = { |
|
|
imports: [], |
|
|
exports: [], |
|
|
methods: [], |
|
|
serviceCalls: [], |
|
|
events: [] |
|
|
} |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找import语句 |
|
|
ImportDeclaration(path) { |
|
|
const importSpecifiers = path.node.specifiers |
|
|
importSpecifiers.forEach(specifier => { |
|
|
if (specifier.type === 'ImportSpecifier') { |
|
|
analysis.imports.push({ |
|
|
name: specifier.imported.name, |
|
|
local: specifier.local.name, |
|
|
source: path.node.source.value |
|
|
}) |
|
|
} |
|
|
}) |
|
|
}, |
|
|
|
|
|
// 查找方法定义 |
|
|
FunctionDeclaration(path) { |
|
|
if (path.node.id) { |
|
|
analysis.methods.push(path.node.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找箭头函数 |
|
|
ArrowFunctionExpression(path) { |
|
|
if (path.parent && path.parent.type === 'VariableDeclarator' && path.parent.id) { |
|
|
analysis.methods.push(path.parent.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找服务调用 |
|
|
CallExpression(path) { |
|
|
if (path.node.callee && path.node.callee.type === 'MemberExpression') { |
|
|
const object = path.node.callee.object |
|
|
const property = path.node.callee.property |
|
|
|
|
|
if (object && property && object.name && property.name) { |
|
|
// 检查是否是服务调用 |
|
|
const serviceName = object.name |
|
|
const methodName = property.name |
|
|
|
|
|
if (serviceName.endsWith('Service')) { |
|
|
analysis.serviceCalls.push({ |
|
|
service: serviceName, |
|
|
method: methodName, |
|
|
arguments: path.node.arguments.map(arg => this.extractArgumentValue(arg)) |
|
|
}) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return analysis |
|
|
}, |
|
|
|
|
|
// 分析JavaScript组件AST |
|
|
analyzeJavaScriptComponentAST(ast, componentName) { |
|
|
return this.analyzeVueComponentAST(ast, componentName) |
|
|
}, |
|
|
|
|
|
// 分析服务AST |
|
|
analyzeServiceAST(ast, serviceName) { |
|
|
const analysis = { |
|
|
exports: [], |
|
|
methods: [], |
|
|
apiCalls: [], |
|
|
imports: [] |
|
|
} |
|
|
|
|
|
traverse(ast, { |
|
|
// 查找export语句 |
|
|
ExportNamedDeclaration(path) { |
|
|
if (path.node.declaration && path.node.declaration.type === 'VariableDeclarator') { |
|
|
analysis.exports.push(path.node.declaration.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找方法定义 |
|
|
FunctionDeclaration(path) { |
|
|
if (path.node.id) { |
|
|
analysis.methods.push(path.node.id.name) |
|
|
} |
|
|
}, |
|
|
|
|
|
// 查找API调用 |
|
|
CallExpression(path) { |
|
|
if (path.node.callee && path.node.callee.type === 'MemberExpression') { |
|
|
const object = path.node.callee.object |
|
|
const property = path.node.callee.property |
|
|
|
|
|
if (object && property) { |
|
|
// 检查是否是API调用 |
|
|
if (object.name === 'api' || object.name === 'axios' || object.name === 'http') { |
|
|
const method = property.name |
|
|
const args = path.node.arguments |
|
|
|
|
|
if (args.length > 0 && args[0].type === 'StringLiteral') { |
|
|
analysis.apiCalls.push({ |
|
|
method: method.toUpperCase(), |
|
|
path: args[0].value, |
|
|
arguments: args.slice(1).map(arg => this.extractArgumentValue(arg)) |
|
|
}) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}) |
|
|
|
|
|
return analysis |
|
|
}, |
|
|
|
|
|
// 建立调用关系 |
|
|
buildCallRelations(routerAST, componentASTs, serviceASTs) { |
|
|
const relations = { |
|
|
routes: routerAST.routes, |
|
|
components: new Map(), |
|
|
services: new Map(), |
|
|
callGraph: new Map(), |
|
|
imports: new Map() |
|
|
} |
|
|
|
|
|
// 建立组件关系 |
|
|
componentASTs.forEach((analysis, componentName) => { |
|
|
relations.components.set(componentName, { |
|
|
...analysis, |
|
|
serviceDependencies: analysis.serviceCalls.map(call => call.service) |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 建立服务关系 |
|
|
serviceASTs.forEach((analysis, serviceName) => { |
|
|
relations.services.set(serviceName, { |
|
|
...analysis, |
|
|
apiEndpoints: analysis.apiCalls |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 建立调用图 |
|
|
componentASTs.forEach((componentAnalysis, componentName) => { |
|
|
const calls = [] |
|
|
|
|
|
componentAnalysis.serviceCalls.forEach(call => { |
|
|
calls.push({ |
|
|
type: 'service', |
|
|
target: call.service, |
|
|
method: call.method, |
|
|
component: componentName |
|
|
}) |
|
|
}) |
|
|
|
|
|
relations.callGraph.set(componentName, calls) |
|
|
}) |
|
|
|
|
|
return relations |
|
|
}, |
|
|
|
|
|
// 生成真实的路由映射 |
|
|
generateRealRouteMappings(callRelations) { |
|
|
const mappings = { |
|
|
mainRoutes: [], |
|
|
moduleApiMappings: {}, |
|
|
subRouteMappings: {}, |
|
|
callRelations: callRelations |
|
|
} |
|
|
|
|
|
// 生成主路由 |
|
|
callRelations.routes.forEach(route => { |
|
|
mappings.mainRoutes.push({ |
|
|
path: route.path, |
|
|
name: route.name, |
|
|
module: route.module, |
|
|
description: this.generateDescription(route.name, route.module), |
|
|
type: this.determineRouteType(route.path, route.module), |
|
|
component: route.component |
|
|
}) |
|
|
}) |
|
|
|
|
|
// 生成API映射 |
|
|
callRelations.services.forEach((serviceAnalysis, serviceName) => { |
|
|
const moduleName = this.extractModuleFromService(serviceName) |
|
|
if (moduleName && serviceAnalysis.apiCalls.length > 0) { |
|
|
const apiMapping = this.buildApiMappingFromRealCalls(serviceAnalysis.apiCalls, moduleName) |
|
|
mappings.moduleApiMappings[moduleName] = apiMapping |
|
|
} |
|
|
}) |
|
|
|
|
|
// 生成子路由映射 |
|
|
mappings.subRouteMappings = this.generateSubRouteMappingsFromRelations(callRelations) |
|
|
|
|
|
return mappings |
|
|
}, |
|
|
|
|
|
// 从真实调用构建API映射 |
|
|
buildApiMappingFromRealCalls(apiCalls, moduleName) { |
|
|
const operations = {} |
|
|
const paths = [] |
|
|
|
|
|
apiCalls.forEach(call => { |
|
|
const operation = this.inferOperationFromApiCall(call.path, call.method) |
|
|
if (operation) { |
|
|
operations[operation] = { |
|
|
path: call.path, |
|
|
method: call.method |
|
|
} |
|
|
paths.push(call.path) |
|
|
} |
|
|
}) |
|
|
|
|
|
const basePath = this.extractBasePath(paths) |
|
|
|
|
|
return { |
|
|
basePath: basePath, |
|
|
operations: operations |
|
|
} |
|
|
}, |
|
|
|
|
|
// 从API调用推断操作 |
|
|
inferOperationFromApiCall(path, method) { |
|
|
const pathLower = path.toLowerCase() |
|
|
|
|
|
// 根据路径模式推断操作 |
|
|
if (path.includes('/:id') || path.includes('/{id}')) { |
|
|
if (method === 'GET') return 'detail' |
|
|
if (method === 'PUT') return 'update' |
|
|
if (method === 'DELETE') return 'delete' |
|
|
} |
|
|
|
|
|
if (path.includes('/search')) return 'search' |
|
|
if (path.includes('/filter')) return 'filter' |
|
|
if (path.includes('/roles')) return 'getRoles' |
|
|
if (path.includes('/permissions')) return 'getPermissions' |
|
|
if (path.includes('/assign')) return 'assignRoles' |
|
|
if (path.includes('/remove')) return 'removeRoles' |
|
|
|
|
|
// 根据HTTP方法推断 |
|
|
if (method === 'GET' && !path.includes('/')) return 'list' |
|
|
if (method === 'POST' && !path.includes('/')) return 'create' |
|
|
if (method === 'PUT' && !path.includes('/')) return 'update' |
|
|
if (method === 'DELETE' && !path.includes('/')) return 'delete' |
|
|
|
|
|
// 默认操作名 |
|
|
return `${method.toLowerCase()}_${path.replace(/[^a-zA-Z0-9]/g, '_')}` |
|
|
}, |
|
|
|
|
|
// 从关系生成子路由映射 |
|
|
generateSubRouteMappingsFromRelations(callRelations) { |
|
|
const subRouteMappings = {} |
|
|
|
|
|
callRelations.callGraph.forEach((calls, componentName) => { |
|
|
calls.forEach(call => { |
|
|
if (call.type === 'service') { |
|
|
const operation = this.inferOperationFromServiceMethod(call.method) |
|
|
if (operation && operation !== 'list') { |
|
|
// 找到对应的主路由 |
|
|
const mainRoute = callRelations.routes.find(route => |
|
|
route.component === componentName || |
|
|
route.name.toLowerCase().includes(componentName.toLowerCase()) |
|
|
) |
|
|
|
|
|
if (mainRoute) { |
|
|
const subPath = `${mainRoute.path}/${operation}` |
|
|
subRouteMappings[subPath] = { |
|
|
mainRoute: mainRoute.path, |
|
|
operation: operation |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
}) |
|
|
}) |
|
|
|
|
|
return subRouteMappings |
|
|
}, |
|
|
|
|
|
// 回退到简单分析 |
|
|
fallbackToSimpleAnalysis() { |
|
|
console.log('⚠️ 使用简单分析作为回退...') |
|
|
|
|
|
const mappings = { |
|
|
mainRoutes: [], |
|
|
moduleApiMappings: {}, |
|
|
subRouteMappings: {}, |
|
|
method: 'simple-analysis' |
|
|
} |
|
|
|
|
|
// 简单的路由提取 |
|
|
const routerPath = resolve(__dirname, '../src/renderer/router/index.js') |
|
|
if (fs.existsSync(routerPath)) { |
|
|
const content = fs.readFileSync(routerPath, 'utf-8') |
|
|
mappings.mainRoutes = this.simpleRouteExtraction(content) |
|
|
} |
|
|
|
|
|
this.generateRouteMappingFile(mappings) |
|
|
console.log('✅ 简单分析完成') |
|
|
}, |
|
|
|
|
|
// 简单的路由提取 |
|
|
simpleRouteExtraction(content) { |
|
|
const routes = [] |
|
|
const routeRegex = /path:\s*['"`]([^'"`]+)['"`]/g |
|
|
const nameRegex = /name:\s*['"`]([^'"`]+)['"`]/g |
|
|
|
|
|
let match |
|
|
while ((match = routeRegex.exec(content)) !== null) { |
|
|
const path = match[1] |
|
|
const nameMatch = nameRegex.exec(content) |
|
|
const name = nameMatch ? nameMatch[1] : path.split('/').pop() |
|
|
|
|
|
routes.push({ |
|
|
path, |
|
|
name, |
|
|
module: this.extractModuleFromPath(path), |
|
|
description: this.generateDescription(name, this.extractModuleFromPath(path)), |
|
|
type: this.determineRouteType(path, this.extractModuleFromPath(path)) |
|
|
}) |
|
|
} |
|
|
|
|
|
return routes |
|
|
}, |
|
|
|
|
|
// 查找组件文件 |
|
|
findComponentFiles() { |
|
|
const componentFiles = [] |
|
|
const moduleDirs = ['user-management', 'role-management', 'system-settings'] |
|
|
|
|
|
moduleDirs.forEach(moduleName => { |
|
|
const viewsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/views`) |
|
|
const componentsPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/components`) |
|
|
|
|
|
if (fs.existsSync(viewsPath)) { |
|
|
const files = fs.readdirSync(viewsPath).filter(f => f.endsWith('.vue')) |
|
|
files.forEach(file => { |
|
|
componentFiles.push({ |
|
|
name: file.replace('.vue', ''), |
|
|
path: resolve(viewsPath, file), |
|
|
module: moduleName, |
|
|
type: 'view' |
|
|
}) |
|
|
}) |
|
|
} |
|
|
|
|
|
if (fs.existsSync(componentsPath)) { |
|
|
const files = fs.readdirSync(componentsPath).filter(f => f.endsWith('.vue')) |
|
|
files.forEach(file => { |
|
|
componentFiles.push({ |
|
|
name: file.replace('.vue', ''), |
|
|
path: resolve(componentsPath, file), |
|
|
module: moduleName, |
|
|
type: 'component' |
|
|
}) |
|
|
}) |
|
|
} |
|
|
}) |
|
|
|
|
|
return componentFiles |
|
|
}, |
|
|
|
|
|
// 查找服务文件 |
|
|
findServiceFiles() { |
|
|
const serviceFiles = [] |
|
|
const moduleDirs = ['user-management', 'role-management', 'system-settings'] |
|
|
|
|
|
moduleDirs.forEach(moduleName => { |
|
|
const servicesPath = resolve(__dirname, `../src/renderer/modules/${moduleName}/services`) |
|
|
if (fs.existsSync(servicesPath)) { |
|
|
const files = fs.readdirSync(servicesPath).filter(f => f.endsWith('.js')) |
|
|
files.forEach(file => { |
|
|
serviceFiles.push({ |
|
|
name: file.replace('.js', ''), |
|
|
path: resolve(servicesPath, file), |
|
|
module: moduleName |
|
|
}) |
|
|
}) |
|
|
} |
|
|
}) |
|
|
|
|
|
return serviceFiles |
|
|
}, |
|
|
|
|
|
// 提取组件名称 |
|
|
extractComponentName(node) { |
|
|
if (node.type === 'Identifier') { |
|
|
return node.name |
|
|
} else if (node.type === 'StringLiteral') { |
|
|
return node.value |
|
|
} |
|
|
return null |
|
|
}, |
|
|
|
|
|
// 提取参数值 |
|
|
extractArgumentValue(node) { |
|
|
if (node.type === 'StringLiteral') { |
|
|
return node.value |
|
|
} else if (node.type === 'NumericLiteral') { |
|
|
return node.value |
|
|
} else if (node.type === 'Identifier') { |
|
|
return node.name |
|
|
} |
|
|
return null |
|
|
}, |
|
|
|
|
|
// 从服务方法推断操作 |
|
|
inferOperationFromServiceMethod(methodName) { |
|
|
const methodMap = { |
|
|
'getUsers': 'list', |
|
|
'getUser': 'detail', |
|
|
'createUser': 'create', |
|
|
'updateUser': 'update', |
|
|
'deleteUser': 'delete', |
|
|
'getRoles': 'getRoles', |
|
|
'getRole': 'detail', |
|
|
'createRole': 'create', |
|
|
'updateRole': 'update', |
|
|
'deleteRole': 'delete', |
|
|
'getPermissions': 'getPermissions' |
|
|
} |
|
|
|
|
|
return methodMap[methodName] || methodName |
|
|
}, |
|
|
|
|
|
// 从服务名提取模块名 |
|
|
extractModuleFromService(serviceName) { |
|
|
const serviceMap = { |
|
|
'userService': 'user-management', |
|
|
'roleService': 'role-management', |
|
|
'settingsService': 'system-settings' |
|
|
} |
|
|
|
|
|
return serviceMap[serviceName] || null |
|
|
}, |
|
|
|
|
|
// 提取basePath |
|
|
extractBasePath(paths) { |
|
|
if (paths.length === 0) return '' |
|
|
|
|
|
// 找到所有路径的共同前缀 |
|
|
const firstPath = paths[0] |
|
|
let commonPrefix = '' |
|
|
|
|
|
for (let i = 0; i < firstPath.length; i++) { |
|
|
const char = firstPath[i] |
|
|
if (paths.every(path => path[i] === char)) { |
|
|
commonPrefix += char |
|
|
} else { |
|
|
break |
|
|
} |
|
|
} |
|
|
|
|
|
// 如果找到了完整的前缀，返回它 |
|
|
if (commonPrefix && !commonPrefix.endsWith('/')) { |
|
|
// 找到最后一个斜杠的位置 |
|
|
const lastSlashIndex = commonPrefix.lastIndexOf('/') |
|
|
if (lastSlashIndex > 0) { |
|
|
return commonPrefix.substring(0, lastSlashIndex + 1) |
|
|
} |
|
|
} |
|
|
|
|
|
return commonPrefix |
|
|
}, |
|
|
|
|
|
// 从路径提取模块名 |
|
|
extractModuleFromPath(path) { |
|
|
if (path === '/' || path === '') return 'home' |
|
|
|
|
|
const segments = path.split('/').filter(Boolean) |
|
|
if (segments.length === 0) return 'home' |
|
|
|
|
|
// 获取第一个段作为模块名 |
|
|
const module = segments[0] |
|
|
|
|
|
// 映射模块名 |
|
|
const moduleMap = { |
|
|
'user-management': 'user-management', |
|
|
'role-management': 'role-management', |
|
|
'settings': 'system-settings', |
|
|
'user-profile': 'user-management', |
|
|
'route-sync-test': 'route-sync' |
|
|
} |
|
|
|
|
|
return moduleMap[module] || module |
|
|
}, |
|
|
|
|
|
// 生成路由描述 |
|
|
generateDescription(name, module) { |
|
|
const descriptions = { |
|
|
'home': '首页', |
|
|
'user-management': '用户管理', |
|
|
'role-management': '角色管理', |
|
|
'system-settings': '系统设置', |
|
|
'route-sync': '路由同步测试' |
|
|
} |
|
|
|
|
|
return descriptions[module] || `${name}页面` |
|
|
}, |
|
|
|
|
|
// 确定路由类型 |
|
|
determineRouteType(path, module) { |
|
|
if (path === '/' || path === '') return 'home' |
|
|
|
|
|
// 根据模块确定类型 |
|
|
const typeMap = { |
|
|
'user-management': 'list', |
|
|
'role-management': 'list', |
|
|
'system-settings': 'form', |
|
|
'route-sync': 'test' |
|
|
} |
|
|
|
|
|
return typeMap[module] || 'list' |
|
|
}, |
|
|
|
|
|
// 生成路由映射文件 |
|
|
generateRouteMappingFile(routeMappings) { |
|
|
const mappingContent = `// 自动生成的路由映射文件 |
|
|
// 此文件由 route-mapping-plugin 在构建时生成 |
|
|
// 基于AST解析和Vite编译时关系分析 |
|
|
// 请勿手动修改 |
|
|
|
|
|
export const mainRoutes = ${JSON.stringify(routeMappings.mainRoutes, null, 2)} |
|
|
|
|
|
// 模块到API映射配置（从AST解析提取） |
|
|
export const moduleApiMappings = ${JSON.stringify(routeMappings.moduleApiMappings, null, 2)} |
|
|
|
|
|
// 子路由到主路由的映射（从调用关系提取） |
|
|
export const subRouteMappings = ${JSON.stringify(routeMappings.subRouteMappings, null, 2)} |
|
|
|
|
|
// 分析方法和结果 |
|
|
export const analysisInfo = ${JSON.stringify({ |
|
|
method: routeMappings.method || 'ast-analysis', |
|
|
timestamp: new Date().toISOString(), |
|
|
hasCallRelations: !!routeMappings.callRelations, |
|
|
componentCount: routeMappings.callRelations?.components?.size || 0, |
|
|
serviceCount: routeMappings.callRelations?.services?.size || 0 |
|
|
}, null, 2)} |
|
|
|
|
|
export default { |
|
|
mainRoutes, |
|
|
moduleApiMappings, |
|
|
subRouteMappings, |
|
|
analysisInfo |
|
|
} |
|
|
` |
|
|
|
|
|
const outputPath = resolve(__dirname, '../src/renderer/modules/route-sync/generated-route-mapping.js') |
|
|
fs.writeFileSync(outputPath, mappingContent, 'utf-8') |
|
|
|
|
|
console.log(`✅ 基于AST解析的路由映射文件已生成: ${outputPath}`) |
|
|
} |
|
|
} |
|
|
}
|
|
|
|
