379 lines
11 KiB
JavaScript
379 lines
11 KiB
JavaScript
/*
|
|
CommonJS runtime for applying translations from Excel to source code.
|
|
*/
|
|
const path = require('node:path')
|
|
const fs = require('node:fs')
|
|
const { Project, SyntaxKind, Node } = require('ts-morph')
|
|
const XLSX = require('xlsx')
|
|
|
|
const WORKDIR = process.cwd()
|
|
const TRANSLATES_FILE = path.join(WORKDIR, 'scripts', 'translates.xlsx')
|
|
const REPORT_FILE = path.join(WORKDIR, 'scripts', 'translation-report.json')
|
|
const CONFLICTS_FILE = path.join(WORKDIR, 'scripts', 'translation-conflicts.xlsx')
|
|
|
|
// 统计信息
|
|
const stats = {
|
|
total: 0,
|
|
success: 0,
|
|
conflicts: 0,
|
|
fileNotFound: 0,
|
|
textNotFound: 0,
|
|
multipleMatches: 0,
|
|
}
|
|
|
|
// 冲突列表
|
|
const conflicts = []
|
|
|
|
// 成功替换列表
|
|
const successfulReplacements = []
|
|
|
|
function loadTranslations() {
|
|
console.log('📖 读取翻译数据...')
|
|
const wb = XLSX.readFile(TRANSLATES_FILE)
|
|
const ws = wb.Sheets[wb.SheetNames[0]]
|
|
const data = XLSX.utils.sheet_to_json(ws, { defval: '' })
|
|
|
|
// 筛选出需要替换的条目
|
|
let translations = data.filter(
|
|
(row) => row.text && row.corrected_text && row.text !== row.corrected_text
|
|
)
|
|
|
|
// 去重：按 file + line + text 去重，保留第一个
|
|
const seen = new Set()
|
|
translations = translations.filter((row) => {
|
|
const key = `${row.file}:${row.line}:${row.text}`
|
|
if (seen.has(key)) {
|
|
return false
|
|
}
|
|
seen.add(key)
|
|
return true
|
|
})
|
|
|
|
console.log(`📊 找到 ${translations.length} 条需要替换的翻译（已去重）`)
|
|
stats.total = translations.length
|
|
|
|
return translations
|
|
}
|
|
|
|
function groupByFile(translations) {
|
|
const groups = new Map()
|
|
for (const translation of translations) {
|
|
const filePath = path.join(WORKDIR, translation.file)
|
|
if (!groups.has(filePath)) {
|
|
groups.set(filePath, [])
|
|
}
|
|
groups.get(filePath).push(translation)
|
|
}
|
|
return groups
|
|
}
|
|
|
|
function findTextInNode(node, targetText, kind) {
|
|
if (!node) return null
|
|
|
|
// 处理 JSX 文本节点
|
|
if (Node.isJsxText(node)) {
|
|
const text = node.getText().replace(/\s+/g, ' ').trim()
|
|
if (text === targetText) return node
|
|
}
|
|
|
|
// 处理字符串字面量
|
|
if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
|
|
const text = node.getLiteralText()
|
|
if (text === targetText) return node
|
|
}
|
|
|
|
// 处理 JSX 表达式中的字符串
|
|
if (Node.isJsxExpression(node)) {
|
|
const expr = node.getExpression()
|
|
if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
|
|
const text = expr.getLiteralText()
|
|
if (text === targetText) return node
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
function findTextInFile(sourceFile, translation) {
|
|
const { text, line, kind } = translation
|
|
const matches = []
|
|
|
|
sourceFile.forEachDescendant((node) => {
|
|
// 根据 kind 类型进行不同的匹配
|
|
if (kind === 'text') {
|
|
// 查找 JSX 文本节点
|
|
if (Node.isJsxText(node)) {
|
|
const nodeText = node.getText().replace(/\s+/g, ' ').trim()
|
|
if (nodeText === text) {
|
|
matches.push({ node, type: 'jsx-text', line: node.getStartLineNumber() })
|
|
}
|
|
}
|
|
// 查找 JSX 表达式中的字符串
|
|
if (Node.isJsxExpression(node)) {
|
|
const expr = node.getExpression()
|
|
if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
|
|
const nodeText = expr.getLiteralText()
|
|
if (nodeText === text) {
|
|
matches.push({ node: expr, type: 'jsx-expression', line: node.getStartLineNumber() })
|
|
}
|
|
}
|
|
}
|
|
} else if (['placeholder', 'title', 'alt', 'label', 'aria'].includes(kind)) {
|
|
// 查找 JSX 属性
|
|
if (Node.isJsxAttribute(node)) {
|
|
const name = node.getNameNode().getText().toLowerCase()
|
|
const value = getStringFromInitializer(node)
|
|
if (value === text) {
|
|
matches.push({ node, type: 'jsx-attribute', line: node.getStartLineNumber() })
|
|
}
|
|
}
|
|
} else if (['toast', 'dialog', 'error', 'validation'].includes(kind)) {
|
|
// 查找函数调用中的字符串参数
|
|
if (Node.isCallExpression(node)) {
|
|
const args = node.getArguments()
|
|
for (const arg of args) {
|
|
if (Node.isStringLiteral(arg) || Node.isNoSubstitutionTemplateLiteral(arg)) {
|
|
const nodeText = arg.getLiteralText()
|
|
if (nodeText === text) {
|
|
matches.push({ node: arg, type: 'function-arg', line: node.getStartLineNumber() })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
return matches
|
|
}
|
|
|
|
function getStringFromInitializer(attr) {
|
|
const init = attr.getInitializer()
|
|
if (!init) return undefined
|
|
if (Node.isStringLiteral(init) || Node.isNoSubstitutionTemplateLiteral(init)) {
|
|
return init.getLiteralText()
|
|
}
|
|
if (Node.isJsxExpression(init)) {
|
|
const expr = init.getExpression()
|
|
if (!expr) return undefined
|
|
if (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr)) {
|
|
return expr.getLiteralText()
|
|
}
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
function replaceText(node, newText, type) {
|
|
try {
|
|
if (type === 'jsx-text') {
|
|
// JSX 文本节点需要特殊处理，保持空白字符
|
|
const originalText = node.getText()
|
|
const newTextWithWhitespace = originalText.replace(/\S+/g, newText)
|
|
node.replaceWithText(newTextWithWhitespace)
|
|
} else if (type === 'jsx-expression' || type === 'function-arg') {
|
|
// 字符串字面量
|
|
if (Node.isStringLiteral(node)) {
|
|
node.replaceWithText(`"${newText}"`)
|
|
} else if (Node.isNoSubstitutionTemplateLiteral(node)) {
|
|
node.replaceWithText(`\`${newText}\``)
|
|
}
|
|
} else if (type === 'jsx-attribute') {
|
|
// JSX 属性值
|
|
const init = node.getInitializer()
|
|
if (init) {
|
|
if (Node.isStringLiteral(init)) {
|
|
init.replaceWithText(`"${newText}"`)
|
|
} else if (Node.isNoSubstitutionTemplateLiteral(init)) {
|
|
init.replaceWithText(`\`${newText}\``)
|
|
} else if (Node.isJsxExpression(init)) {
|
|
const expr = init.getExpression()
|
|
if (expr && (Node.isStringLiteral(expr) || Node.isNoSubstitutionTemplateLiteral(expr))) {
|
|
if (Node.isStringLiteral(expr)) {
|
|
expr.replaceWithText(`"${newText}"`)
|
|
} else {
|
|
expr.replaceWithText(`\`${newText}\``)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
} catch (error) {
|
|
console.error(`❌ 替换失败: ${error.message}`)
|
|
return false
|
|
}
|
|
}
|
|
|
|
function processFile(filePath, translations) {
|
|
if (!fs.existsSync(filePath)) {
|
|
console.log(`❌ 文件不存在: ${path.relative(WORKDIR, filePath)}`)
|
|
translations.forEach((t) => {
|
|
conflicts.push({
|
|
...t,
|
|
conflictType: 'FILE_NOT_FOUND',
|
|
conflictReason: '文件不存在',
|
|
})
|
|
})
|
|
stats.fileNotFound += translations.length
|
|
return
|
|
}
|
|
|
|
console.log(`📝 处理文件: ${path.relative(WORKDIR, filePath)}`)
|
|
|
|
try {
|
|
const project = new Project({
|
|
tsConfigFilePath: path.join(WORKDIR, 'tsconfig.json'),
|
|
skipAddingFilesFromTsConfig: true,
|
|
})
|
|
const sourceFile = project.addSourceFileAtPath(filePath)
|
|
|
|
for (const translation of translations) {
|
|
const { text, corrected_text, line, kind } = translation
|
|
|
|
// 首先在指定行附近查找
|
|
let matches = findTextInFile(sourceFile, translation)
|
|
|
|
// 如果没找到，在整个文件中搜索
|
|
if (matches.length === 0) {
|
|
matches = findTextInFile(sourceFile, translation)
|
|
}
|
|
|
|
if (matches.length === 0) {
|
|
conflicts.push({
|
|
...translation,
|
|
conflictType: 'TEXT_NOT_FOUND_IN_FILE',
|
|
conflictReason: '在文件中找不到匹配的文本',
|
|
})
|
|
stats.textNotFound++
|
|
continue
|
|
}
|
|
|
|
if (matches.length > 1) {
|
|
conflicts.push({
|
|
...translation,
|
|
conflictType: 'MULTIPLE_MATCHES',
|
|
conflictReason: `找到 ${matches.length} 个匹配项，需要人工确认`,
|
|
})
|
|
stats.multipleMatches++
|
|
continue
|
|
}
|
|
|
|
// 执行替换
|
|
const match = matches[0]
|
|
const success = replaceText(match.node, corrected_text, match.type)
|
|
|
|
if (success) {
|
|
successfulReplacements.push({
|
|
...translation,
|
|
actualLine: match.line,
|
|
replacementType: match.type,
|
|
})
|
|
stats.success++
|
|
console.log(`✅ 替换成功: "${text}" -> "${corrected_text}" (行 ${match.line})`)
|
|
} else {
|
|
conflicts.push({
|
|
...translation,
|
|
conflictType: 'REPLACEMENT_FAILED',
|
|
conflictReason: '替换操作失败',
|
|
})
|
|
stats.conflicts++
|
|
}
|
|
}
|
|
|
|
// 保存修改后的文件
|
|
sourceFile.saveSync()
|
|
} catch (error) {
|
|
console.error(`❌ 处理文件失败: ${filePath}`, error.message)
|
|
translations.forEach((t) => {
|
|
conflicts.push({
|
|
...t,
|
|
conflictType: 'PARSE_ERROR',
|
|
conflictReason: `文件解析失败: ${error.message}`,
|
|
})
|
|
})
|
|
stats.conflicts += translations.length
|
|
}
|
|
}
|
|
|
|
function generateReport() {
|
|
console.log('\n📊 生成报告...')
|
|
|
|
// 生成成功替换报告
|
|
const report = {
|
|
timestamp: new Date().toISOString(),
|
|
stats,
|
|
successfulReplacements,
|
|
conflicts: conflicts.map((c) => ({
|
|
file: c.file,
|
|
line: c.line,
|
|
text: c.text,
|
|
corrected_text: c.corrected_text,
|
|
conflictType: c.conflictType,
|
|
conflictReason: c.conflictReason,
|
|
})),
|
|
}
|
|
|
|
fs.writeFileSync(REPORT_FILE, JSON.stringify(report, null, 2))
|
|
console.log(`📄 成功替换报告已保存: ${REPORT_FILE}`)
|
|
|
|
// 生成冲突报告 Excel
|
|
if (conflicts.length > 0) {
|
|
const conflictRows = conflicts.map((c) => ({
|
|
file: c.file,
|
|
line: c.line,
|
|
text: c.text,
|
|
corrected_text: c.corrected_text,
|
|
conflictType: c.conflictType,
|
|
conflictReason: c.conflictReason,
|
|
route: c.route,
|
|
componentOrFn: c.componentOrFn,
|
|
kind: c.kind,
|
|
keyOrLocator: c.keyOrLocator,
|
|
}))
|
|
|
|
const ws = XLSX.utils.json_to_sheet(conflictRows)
|
|
const wb = XLSX.utils.book_new()
|
|
XLSX.utils.book_append_sheet(wb, ws, 'conflicts')
|
|
XLSX.writeFile(wb, CONFLICTS_FILE)
|
|
console.log(`📄 冲突报告已保存: ${CONFLICTS_FILE}`)
|
|
}
|
|
}
|
|
|
|
function printSummary() {
|
|
console.log('\n📈 处理完成！')
|
|
console.log(`总翻译条目: ${stats.total}`)
|
|
console.log(`✅ 成功替换: ${stats.success}`)
|
|
console.log(`❌ 文件不存在: ${stats.fileNotFound}`)
|
|
console.log(`❌ 文本未找到: ${stats.textNotFound}`)
|
|
console.log(`❌ 多处匹配: ${stats.multipleMatches}`)
|
|
console.log(`❌ 其他冲突: ${stats.conflicts}`)
|
|
console.log(`\n成功率: ${((stats.success / stats.total) * 100).toFixed(1)}%`)
|
|
}
|
|
|
|
async function main() {
|
|
console.log('🚀 开始应用翻译...\n')
|
|
|
|
try {
|
|
// 1. 读取翻译数据
|
|
const translations = loadTranslations()
|
|
|
|
// 2. 按文件分组
|
|
const fileGroups = groupByFile(translations)
|
|
|
|
// 3. 处理每个文件
|
|
for (const [filePath, fileTranslations] of fileGroups) {
|
|
processFile(filePath, fileTranslations)
|
|
}
|
|
|
|
// 4. 生成报告
|
|
generateReport()
|
|
|
|
// 5. 打印总结
|
|
printSummary()
|
|
} catch (error) {
|
|
console.error('❌ 执行失败:', error)
|
|
process.exitCode = 1
|
|
}
|
|
}
|
|
|
|
main()
|