mirror of
https://github.com/Kuingsmile/PicList.git
synced 2026-05-06 20:42:57 +08:00
500 lines
15 KiB
JavaScript
500 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
import { readdirSync, readFileSync, writeFileSync } from 'node:fs'
|
||
import { basename, dirname, extname, join, relative } from 'node:path'
|
||
import { fileURLToPath } from 'node:url'
|
||
import { load, dump } from 'js-yaml'
|
||
|
||
const __filename = fileURLToPath(import.meta.url)
|
||
const __dirname = dirname(__filename)
|
||
|
||
const LOCALE_DIR = join(__dirname, '../public/i18n')
|
||
const SRC_DIR = join(__dirname, '../src')
|
||
|
||
// Parse command line arguments
|
||
const args = process.argv.slice(2)
|
||
const isVerbose = args.includes('--verbose') || args.includes('-v')
|
||
const shouldDelete = args.includes('--delete') || args.includes('-d')
|
||
const isDryRun = args.includes('--dry-run')
|
||
|
||
const colors = {
|
||
reset: '\x1b[0m',
|
||
bright: '\x1b[1m',
|
||
red: '\x1b[31m',
|
||
green: '\x1b[32m',
|
||
yellow: '\x1b[33m',
|
||
blue: '\x1b[34m',
|
||
magenta: '\x1b[35m',
|
||
cyan: '\x1b[36m'
|
||
}
|
||
|
||
function colorize(text, color) {
|
||
return `${colors[color]}${text}${colors.reset}`
|
||
}
|
||
|
||
console.log(`\n🔍 Analyzing i18n keys in ${LOCALE_DIR} and source files in ${SRC_DIR}`)
|
||
if (shouldDelete) {
|
||
console.log(colorize(`🗑️ Delete mode enabled ${isDryRun ? '(DRY RUN)' : ''}`, 'yellow'))
|
||
}
|
||
console.log('')
|
||
|
||
function flattenKeys(obj, prefix = '') {
|
||
const keys = []
|
||
|
||
for (const [key, value] of Object.entries(obj)) {
|
||
const fullKey = prefix ? `${prefix}.${key}` : key
|
||
|
||
if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
|
||
keys.push(...flattenKeys(value, fullKey))
|
||
} else {
|
||
keys.push(fullKey)
|
||
}
|
||
}
|
||
|
||
return keys
|
||
}
|
||
|
||
function readLocaleFile(filePath) {
|
||
try {
|
||
const content = readFileSync(filePath, 'utf8')
|
||
return load(content) || {}
|
||
} catch (error) {
|
||
console.error(colorize(`Error reading ${filePath}: ${error.message}`, 'red'))
|
||
return {}
|
||
}
|
||
}
|
||
|
||
function getAllI18nKeys() {
|
||
const localeFiles = readdirSync(LOCALE_DIR).filter(file => file.endsWith('.yml'))
|
||
const allKeys = new Set()
|
||
const localeData = {}
|
||
|
||
console.log(colorize('\n📁 Found locale files:', 'blue'))
|
||
|
||
for (const file of localeFiles) {
|
||
const filePath = join(LOCALE_DIR, file)
|
||
const locale = basename(file, '.yml')
|
||
const data = readLocaleFile(filePath)
|
||
const keys = flattenKeys(data)
|
||
|
||
localeData[locale] = {
|
||
file: filePath,
|
||
keys,
|
||
data
|
||
}
|
||
|
||
keys.forEach(key => allKeys.add(key))
|
||
|
||
console.log(` ${colorize('✓', 'green')} ${file} (${keys.length} keys)`)
|
||
}
|
||
|
||
return {
|
||
allKeys: Array.from(allKeys).sort(),
|
||
localeData
|
||
}
|
||
}
|
||
|
||
function findFiles(dir, extensions = ['.vue', '.ts', '.js']) {
|
||
const files = []
|
||
|
||
function walk(currentDir) {
|
||
try {
|
||
const entries = readdirSync(currentDir, { withFileTypes: true })
|
||
|
||
for (const entry of entries) {
|
||
const fullPath = join(currentDir, entry.name)
|
||
|
||
if (entry.isDirectory()) {
|
||
if (!['node_modules', '.git', 'dist', 'build', 'target', 'dist_electron'].includes(entry.name)) {
|
||
walk(fullPath)
|
||
}
|
||
} else if (entry.isFile()) {
|
||
const ext = extname(entry.name)
|
||
if (extensions.includes(ext)) {
|
||
files.push(fullPath)
|
||
}
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.warn(colorize(`Warning: Cannot read directory ${currentDir}: ${error.message}`, 'yellow'))
|
||
}
|
||
}
|
||
|
||
walk(dir)
|
||
return files
|
||
}
|
||
|
||
function findKeyUsage(keys) {
|
||
const usage = {}
|
||
const dynamicPatterns = []
|
||
|
||
keys.forEach(key => {
|
||
usage[key] = {
|
||
used: false,
|
||
files: [],
|
||
patterns: [],
|
||
dynamicMatch: false
|
||
}
|
||
})
|
||
|
||
console.log(colorize('\n🔍 Searching for key usage in source files...', 'blue'))
|
||
|
||
const sourceFiles = findFiles(SRC_DIR)
|
||
|
||
console.log(` Found ${sourceFiles.length} source files to analyze`)
|
||
|
||
const searchPatterns = [
|
||
/\$T\s*\(\s*['"`]([^'"`]+)['"`]/g,
|
||
/(?:^|[^a-zA-Z$])T\s*\(\s*['"`]([^'"`]+)['"`]/g,
|
||
/\{\{\s*\$T\s*\(\s*['"`]([^'"`]+)['"`]/g,
|
||
/i18nManager\.T\s*\(\s*['"`]([^'"`]+)['"`]/g
|
||
]
|
||
|
||
const dynamicPattern = /\$T\s*\(\s*`([^`]*\$\{[^}]+\}[^`]*)`/g
|
||
|
||
sourceFiles.forEach(filePath => {
|
||
try {
|
||
const content = readFileSync(filePath, 'utf8')
|
||
const relativePath = relative(join(__dirname, '..'), filePath)
|
||
|
||
searchPatterns.forEach((pattern, patternIndex) => {
|
||
let match
|
||
while ((match = pattern.exec(content)) !== null) {
|
||
const key = match[1]
|
||
if (usage[key]) {
|
||
usage[key].used = true
|
||
if (!usage[key].files.includes(relativePath)) {
|
||
usage[key].files.push(relativePath)
|
||
}
|
||
if (!usage[key].patterns.includes(patternIndex)) {
|
||
usage[key].patterns.push(patternIndex)
|
||
}
|
||
}
|
||
}
|
||
})
|
||
|
||
let dynamicMatch
|
||
while ((dynamicMatch = dynamicPattern.exec(content)) !== null) {
|
||
const templateString = dynamicMatch[1]
|
||
|
||
const staticParts = templateString.split(/\$\{[^}]+\}/)
|
||
|
||
const patternInfo = {
|
||
template: templateString,
|
||
file: relativePath,
|
||
staticParts
|
||
}
|
||
|
||
if (!dynamicPatterns.some(p => p.template === templateString && p.file === relativePath)) {
|
||
dynamicPatterns.push(patternInfo)
|
||
}
|
||
|
||
keys.forEach(key => {
|
||
if (matchesDynamicPattern(key, staticParts)) {
|
||
if (usage[key]) {
|
||
usage[key].used = true
|
||
usage[key].dynamicMatch = true
|
||
if (!usage[key].files.includes(relativePath)) {
|
||
usage[key].files.push(relativePath)
|
||
}
|
||
if (!usage[key].patterns.includes('dynamic')) {
|
||
usage[key].patterns.push('dynamic')
|
||
}
|
||
}
|
||
}
|
||
})
|
||
}
|
||
} catch (error) {
|
||
console.error(colorize(`Error reading ${filePath}: ${error.message}`, 'red'))
|
||
}
|
||
})
|
||
|
||
usage._dynamicPatterns = dynamicPatterns
|
||
|
||
return usage
|
||
}
|
||
|
||
function matchesDynamicPattern(key, staticParts) {
|
||
if (staticParts.length === 0) return false
|
||
|
||
let keyIndex = 0
|
||
|
||
for (let i = 0; i < staticParts.length; i++) {
|
||
const part = staticParts[i]
|
||
|
||
if (part === '') {
|
||
if (i < staticParts.length - 1) {
|
||
const nextPart = staticParts[i + 1]
|
||
if (nextPart) {
|
||
const nextIndex = key.indexOf(nextPart, keyIndex)
|
||
if (nextIndex === -1) return false
|
||
keyIndex = nextIndex
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
if (i === 0) {
|
||
if (!key.startsWith(part)) return false
|
||
keyIndex = part.length
|
||
} else if (i === staticParts.length - 1) {
|
||
if (part && !key.endsWith(part)) return false
|
||
} else {
|
||
const index = key.indexOf(part, keyIndex)
|
||
if (index === -1) return false
|
||
keyIndex = index + part.length
|
||
}
|
||
}
|
||
|
||
return true
|
||
}
|
||
|
||
function findLocaleInconsistencies(localeData) {
|
||
const locales = Object.keys(localeData)
|
||
const inconsistencies = {}
|
||
|
||
if (locales.length < 2) {
|
||
return inconsistencies
|
||
}
|
||
|
||
locales.forEach(locale => {
|
||
const currentKeys = new Set(localeData[locale].keys)
|
||
inconsistencies[locale] = {
|
||
missing: [],
|
||
extra: []
|
||
}
|
||
|
||
locales.forEach(otherLocale => {
|
||
if (locale !== otherLocale) {
|
||
localeData[otherLocale].keys.forEach(key => {
|
||
if (!currentKeys.has(key) && !inconsistencies[locale].missing.includes(key)) {
|
||
inconsistencies[locale].missing.push(key)
|
||
}
|
||
})
|
||
}
|
||
})
|
||
|
||
localeData[locale].keys.forEach(key => {
|
||
const existsInOthers = locales.some(
|
||
otherLocale => locale !== otherLocale && localeData[otherLocale].keys.includes(key)
|
||
)
|
||
if (!existsInOthers) {
|
||
inconsistencies[locale].extra.push(key)
|
||
}
|
||
})
|
||
})
|
||
|
||
return inconsistencies
|
||
}
|
||
|
||
function deleteUnusedKeys(unusedKeys, localeData, isDryRun = false) {
|
||
const results = {}
|
||
|
||
Object.entries(localeData).forEach(([locale, data]) => {
|
||
results[locale] = {
|
||
deleted: [],
|
||
errors: []
|
||
}
|
||
|
||
try {
|
||
const updatedData = { ...data.data }
|
||
|
||
unusedKeys.forEach(key => {
|
||
if (key in updatedData) {
|
||
if (!isDryRun) {
|
||
delete updatedData[key]
|
||
}
|
||
results[locale].deleted.push(key)
|
||
}
|
||
})
|
||
|
||
if (!isDryRun && results[locale].deleted.length > 0) {
|
||
const yamlContent = dump(updatedData, {
|
||
indent: 2,
|
||
lineWidth: -1,
|
||
noRefs: true,
|
||
sortKeys: false
|
||
})
|
||
writeFileSync(data.file, yamlContent, 'utf8')
|
||
}
|
||
} catch (error) {
|
||
results[locale].errors.push(`Failed to process ${locale}: ${error.message}`)
|
||
}
|
||
})
|
||
|
||
return results
|
||
}
|
||
|
||
function main() {
|
||
console.log(colorize('🌐 PicList - I18n Usage Analyzer', 'cyan'))
|
||
console.log(colorize('==================================', 'cyan'))
|
||
|
||
const { allKeys, localeData } = getAllI18nKeys()
|
||
|
||
console.log(colorize(`\n📊 Total unique keys found: ${allKeys.length}`, 'yellow'))
|
||
const usage = findKeyUsage(allKeys)
|
||
const dynamicPatterns = usage._dynamicPatterns || []
|
||
delete usage._dynamicPatterns
|
||
|
||
const usedKeys = allKeys.filter(key => usage[key].used)
|
||
const unusedKeys = allKeys.filter(key => !usage[key].used)
|
||
const dynamicallyUsedKeys = usedKeys.filter(key => usage[key].dynamicMatch)
|
||
const staticUsedKeys = usedKeys.filter(key => !usage[key].dynamicMatch)
|
||
|
||
const inconsistencies = findLocaleInconsistencies(localeData)
|
||
|
||
console.log(colorize('\n📈 Usage Summary:', 'blue'))
|
||
console.log(` ${colorize('✓', 'green')} Used keys: ${usedKeys.length}`)
|
||
console.log(` ${colorize('→', 'cyan')} Static usage: ${staticUsedKeys.length}`)
|
||
console.log(` ${colorize('→', 'magenta')} Dynamic usage: ${dynamicallyUsedKeys.length}`)
|
||
console.log(` ${colorize('✗', 'red')} Unused keys: ${unusedKeys.length}`)
|
||
console.log(` ${colorize('📊', 'yellow')} Usage rate: ${((usedKeys.length / allKeys.length) * 100).toFixed(1)}%`)
|
||
|
||
if (dynamicPatterns.length > 0) {
|
||
console.log(colorize('\n🔮 Dynamic I18n Patterns Detected:', 'magenta'))
|
||
console.log(colorize('===================================', 'magenta'))
|
||
|
||
dynamicPatterns.forEach((pattern, index) => {
|
||
console.log(colorize(`\n${index + 1}. Template: \`${pattern.template}\``, 'cyan'))
|
||
console.log(` File: ${pattern.file}`)
|
||
console.log(` Static parts: [${pattern.staticParts.map(p => `"${p}"`).join(', ')}]`)
|
||
|
||
const matchingKeys = allKeys.filter(key => matchesDynamicPattern(key, pattern.staticParts))
|
||
if (matchingKeys.length > 0) {
|
||
console.log(
|
||
` ${colorize('Matches', 'green')} (${matchingKeys.length}): ${matchingKeys.slice(0, 5).join(', ')}${
|
||
matchingKeys.length > 5 ? '...' : ''
|
||
}`
|
||
)
|
||
}
|
||
})
|
||
}
|
||
|
||
if (unusedKeys.length > 0) {
|
||
console.log(colorize('\n🗑️ Unused I18n Keys:', 'red'))
|
||
console.log(colorize('====================', 'red'))
|
||
|
||
const groupedUnused = {}
|
||
unusedKeys.forEach(key => {
|
||
const namespace = key.includes('.') ? key.split('.')[0] : 'ROOT'
|
||
if (!groupedUnused[namespace]) {
|
||
groupedUnused[namespace] = []
|
||
}
|
||
groupedUnused[namespace].push(key)
|
||
})
|
||
|
||
Object.entries(groupedUnused).forEach(([namespace, keys]) => {
|
||
console.log(colorize(`\n[${namespace}] - ${keys.length} unused keys:`, 'yellow'))
|
||
keys.forEach(key => {
|
||
console.log(` ${colorize('✗', 'red')} ${key}`)
|
||
})
|
||
})
|
||
} else {
|
||
console.log(colorize('\n🎉 No unused keys found! All i18n keys are being used.', 'green'))
|
||
}
|
||
|
||
const hasInconsistencies = Object.values(inconsistencies).some(inc => inc.missing.length > 0 || inc.extra.length > 0)
|
||
|
||
if (hasInconsistencies) {
|
||
console.log(colorize('\n⚠️ Locale Inconsistencies:', 'yellow'))
|
||
console.log(colorize('=========================', 'yellow'))
|
||
|
||
Object.entries(inconsistencies).forEach(([locale, data]) => {
|
||
if (data.missing.length > 0 || data.extra.length > 0) {
|
||
console.log(colorize(`\n[${locale}.yml]:`, 'cyan'))
|
||
|
||
if (data.missing.length > 0) {
|
||
console.log(colorize(` Missing ${data.missing.length} keys:`, 'red'))
|
||
data.missing.forEach(key => {
|
||
console.log(` ${colorize('✗', 'red')} ${key}`)
|
||
})
|
||
}
|
||
|
||
if (data.extra.length > 0) {
|
||
console.log(colorize(` Extra ${data.extra.length} keys:`, 'blue'))
|
||
data.extra.forEach(key => {
|
||
console.log(` ${colorize('!', 'blue')} ${key}`)
|
||
})
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
if (isVerbose) {
|
||
console.log(colorize('\n📋 Sample Used Keys (first 10):', 'blue'))
|
||
console.log(colorize('=================================', 'blue'))
|
||
|
||
usedKeys.slice(0, 10).forEach(key => {
|
||
const files = usage[key].files.slice(0, 3)
|
||
const moreFiles = usage[key].files.length > 3 ? ` (+${usage[key].files.length - 3} more)` : ''
|
||
const usageType = usage[key].dynamicMatch ? colorize('(dynamic)', 'magenta') : colorize('(static)', 'cyan')
|
||
console.log(` ${colorize('✓', 'green')} ${key} ${usageType}`)
|
||
console.log(` Used in: ${files.join(', ')}${moreFiles}`)
|
||
})
|
||
|
||
if (dynamicallyUsedKeys.length > 0) {
|
||
console.log(colorize('\n🔮 Dynamic Key Usage Details:', 'magenta'))
|
||
console.log(colorize('=============================', 'magenta'))
|
||
|
||
dynamicallyUsedKeys.slice(0, 5).forEach(key => {
|
||
const files = usage[key].files.slice(0, 2)
|
||
console.log(` ${colorize('✨', 'magenta')} ${key}`)
|
||
console.log(` Files: ${files.join(', ')}`)
|
||
})
|
||
|
||
if (dynamicallyUsedKeys.length > 5) {
|
||
console.log(` ... and ${dynamicallyUsedKeys.length - 5} more dynamic keys`)
|
||
}
|
||
}
|
||
}
|
||
|
||
if (shouldDelete && unusedKeys.length > 0) {
|
||
console.log(colorize('\n🗑️ Deleting Unused Keys:', 'yellow'))
|
||
console.log(colorize('=========================', 'yellow'))
|
||
|
||
if (isDryRun) {
|
||
console.log(colorize('🔍 DRY RUN MODE - No files will be modified', 'cyan'))
|
||
}
|
||
|
||
const deletionResults = deleteUnusedKeys(unusedKeys, localeData, isDryRun)
|
||
|
||
Object.entries(deletionResults).forEach(([locale, result]) => {
|
||
console.log(colorize(`\n[${locale}.yml]:`, 'cyan'))
|
||
if (result.deleted.length > 0) {
|
||
console.log(colorize(` Deleted ${result.deleted.length} keys:`, 'green'))
|
||
result.deleted.forEach(key => {
|
||
console.log(` ${colorize('✓', 'green')} ${key}`)
|
||
})
|
||
}
|
||
if (result.errors.length > 0) {
|
||
console.log(colorize(` Errors ${result.errors.length}:`, 'red'))
|
||
result.errors.forEach(error => {
|
||
console.log(` ${colorize('✗', 'red')} ${error}`)
|
||
})
|
||
}
|
||
})
|
||
|
||
if (!isDryRun) {
|
||
console.log(colorize('\n✨ Deletion complete! Remember to regenerate type definitions.', 'green'))
|
||
console.log(colorize('💡 Run `yarn i18n` to update TypeScript types', 'blue'))
|
||
}
|
||
}
|
||
|
||
console.log(colorize('\n✨ Analysis complete!', 'cyan'))
|
||
|
||
if (unusedKeys.length > 0 && !shouldDelete) {
|
||
console.log(colorize('\n💡 Tips:', 'blue'))
|
||
console.log(colorize('- Run with --verbose (-v) flag to see usage details of used keys', 'blue'))
|
||
console.log(colorize('- Run with --delete (-d) flag to automatically remove unused keys', 'blue'))
|
||
console.log(colorize('- Run with --delete --dry-run to preview what would be deleted', 'blue'))
|
||
} else if (unusedKeys.length === 0) {
|
||
console.log(colorize('\n💡 Tip: Run with --verbose (-v) flag to see usage details of used keys', 'blue'))
|
||
}
|
||
|
||
if (unusedKeys.length > 0 && !shouldDelete) {
|
||
process.exit(1)
|
||
}
|
||
}
|
||
|
||
main()
|