feima-shortcuts 0.3.0-beta.10 → 0.3.0-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feima-shortcuts",
-  "version": "0.3.0-beta.10",
+  "version": "0.3.0-beta.12",
   "description": "快捷指令",
   "main": "index.js",
   "directories": {

package/src/scripts/check-i18n-views/index.js

@@ -1,238 +1,331 @@
+#!/usr/bin/env node
 const fs = require('fs')
 const path = require('path')
 const glob = require('glob')
+const ts = require('typescript')
 const { parse } = require('@vue/compiler-sfc')
-const babelParser = require('@babel/parser')
-const traverse = require('@babel/traverse').default
 
-/* ---------------- defaults ---------------- */
+const ROOT = process.cwd()
+const SCAN_DIRS = ['src/views'] // components 先预留
+const FILE_EXT = ['vue', 'ts', 'js', 'tsx', 'jsx']
 
-const DEFAULT_OPTIONS = {
-  cwd: process.cwd(),
-  scanDirs: ['src/views', 'src/components'],
-  silent: false,
-}
-
-/* ---------------- utils ---------------- */
+// 匹配 t() 调用：t('key') 或 t('key', 'default')
+const T_FUNCTION_REG = /\bt\s*\(\s*['"`]([^'"`]+)['"`]\s*(?:,\s*['"`][^'"`]*['"`])?\s*\)/g
 
+/**
+ * 扁平化 locale 对象，返回所有 key 的集合
+ */
 function flattenLocale(obj, prefix = '') {
-  let res = []
+  const keys = new Set()
   for (const k in obj) {
     const key = prefix ? `${prefix}.${k}` : k
-    if (typeof obj[k] === 'object' && obj[k] !== null) {
-      res = res.concat(flattenLocale(obj[k], key))
+    if (typeof obj[k] === 'object' && obj[k] !== null && !Array.isArray(obj[k])) {
+      const nestedKeys = flattenLocale(obj[k], key)
+      nestedKeys.forEach(k => keys.add(k))
     } else {
-      res.push(key)
+      keys.add(key)
     }
   }
-  return res
+  return keys
 }
 
+/**
+ * 加载 locale.ts 文件并提取所有定义的 key
+ */
 function loadLocaleKeys(localePath) {
-  if (!fs.existsSync(localePath)) return null
-  const mod = require(localePath)
-  const localeObj = mod.default || mod
-  return flattenLocale(localeObj)
+  if (!fs.existsSync(localePath)) {
+    return null
+  }
+
+  try {
+    const code = fs.readFileSync(localePath, 'utf-8')
+    const sf = ts.createSourceFile(localePath, code, ts.ScriptTarget.Latest, true)
+
+    let obj = null
+
+    function visit(node) {
+      if (
+        ts.isExportAssignment(node) &&
+        ts.isObjectLiteralExpression(node.expression)
+      ) {
+        try {
+          // 使用 eval 来解析对象字面量
+          obj = eval(`(${node.expression.getText()})`)
+        } catch (e) {
+          // 如果解析失败，尝试其他方式
+          console.warn(`⚠️  无法解析 locale 文件: ${localePath}`)
+        }
+      }
+      ts.forEachChild(node, visit)
+    }
+
+    visit(sf)
+    return obj ? flattenLocale(obj) : new Set()
+  } catch (error) {
+    console.warn(`⚠️  读取 locale 文件失败: ${localePath}`, error.message)
+    return null
+  }
 }
 
-function parseCode(code) {
-  return babelParser.parse(code, {
-    sourceType: 'module',
-    plugins: ['typescript', 'jsx'],
-  })
+/**
+ * 从代码中提取所有 t() 调用的 key
+ */
+function extractTKeys(code) {
+  const keys = new Set()
+  let match
+  while ((match = T_FUNCTION_REG.exec(code)) !== null) {
+    keys.add(match[1])
+  }
+  return keys
 }
 
 /**
- * 从当前文件目录开始，向上查找最近的 locale.ts
- * 直到到达 componentsRoot 为止
+ * 检查 locale 导入方式
+ * @returns {Object} { hasCorrectImport, hasOtherImport, importPaths }
  */
-function findNearestLocale(fileDir, componentsRoot) {
-  let current = fileDir
+function checkLocaleImport(code) {
+  const result = {
+    hasCorrectImport: false,
+    hasOtherImport: false,
+    importPaths: []
+  }
+
+  // 匹配 import locale from 'xxx'
+  const importReg = /import\s+locale\s+from\s+['"]([^'"]+)['"]/g
+  let match
 
-  while (current.startsWith(componentsRoot)) {
-    const localePath = path.join(current, 'locale.ts')
-    if (fs.existsSync(localePath)) {
-      return localePath
+  while ((match = importReg.exec(code)) !== null) {
+    const importPath = match[1]
+    result.importPaths.push(importPath)
+    if (importPath === './locale') {
+      result.hasCorrectImport = true
+    } else {
+      result.hasOtherImport = true
     }
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
   }
 
-  return null
+  return result
 }
 
-/* ---------------- core ---------------- */
+/**
+ * 解析 Vue 文件，提取 script 部分的代码
+ */
+function parseVueFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const { descriptor } = parse(content)
+    
+    // 合并所有 script 块的内容
+    let scriptContent = ''
+    if (descriptor.script) {
+      scriptContent += descriptor.script.content
+    }
+    if (descriptor.scriptSetup) {
+      scriptContent += '\n' + descriptor.scriptSetup.content
+    }
+    
+    // 也检查 template 中的 t() 调用
+    if (descriptor.template) {
+      scriptContent += '\n' + descriptor.template.content
+    }
 
-function run(userOptions = {}) {
-  const options = { ...DEFAULT_OPTIONS, ...userOptions }
-  const { cwd, scanDirs, silent } = options
+    return scriptContent
+  } catch (error) {
+    console.warn(`⚠️  解析 Vue 文件失败: ${filePath}`, error.message)
+    return ''
+  }
+}
 
-  let files = []
+/**
+ * 查找文件对应的 locale.ts 路径
+ */
+function findLocalePath(filePath) {
+  const dir = path.dirname(filePath)
+  const localePath = path.join(dir, 'locale.ts')
+  return localePath
+}
 
-  for (const dir of scanDirs) {
-    const absDir = path.join(cwd, dir)
-    if (!fs.existsSync(absDir)) {
-      if (!silent) {
-        console.warn(`⚠️ 目录不存在：${dir}`)
-      }
-      continue
+/**
+ * 扫描单个文件
+ */
+function scanFile(filePath, results) {
+  let code = ''
+  
+  if (filePath.endsWith('.vue')) {
+    code = parseVueFile(filePath)
+  } else {
+    try {
+      code = fs.readFileSync(filePath, 'utf-8')
+    } catch (error) {
+      console.warn(`⚠️  读取文件失败: ${filePath}`, error.message)
+      return
     }
+  }
 
-    files.push(
-      ...glob.sync('**/*.{vue,ts,tsx}', {
-        cwd: absDir,
-        absolute: true,
+  if (!code) return
+
+  // 提取 t() 调用的 key
+  const usedKeys = extractTKeys(code)
+  if (usedKeys.size === 0) return
+
+  // 检查 locale 导入方式
+  const importInfo = checkLocaleImport(code)
+  
+  // 查找对应的 locale.ts
+  const localePath = findLocalePath(filePath)
+  const localeKeys = loadLocaleKeys(localePath)
+
+  const relativePath = path.relative(ROOT, filePath)
+  const relativeLocalePath = path.relative(ROOT, localePath)
+
+  // 如果使用了非标准的导入方式，记录（但不检查 key）
+  if (!importInfo.hasCorrectImport && importInfo.hasOtherImport) {
+    if (!results.invalidImports.has(relativePath)) {
+      results.invalidImports.set(relativePath, {
+        file: relativePath,
+        importPaths: importInfo.importPaths,
+        usedKeys: Array.from(usedKeys)
       })
-    )
+    }
+    return // 非标准导入，不检查 key 是否缺失
   }
 
-  const missingKeys = []
-  const noLocaleUsage = []
-
-  const componentsRoot = path.join(cwd, 'src/components')
-  const viewsRoot = path.join(cwd, 'src/views')
-
-  for (const file of files) {
-    const content = fs.readFileSync(file, 'utf-8')
-
-    let scriptCode = content
-
-    if (file.endsWith('.vue')) {
-      const { descriptor } = parse(content)
-      scriptCode =
-        descriptor.scriptSetup?.content ||
-        descriptor.script?.content ||
-        ''
+  // 如果没有导入 locale，记录（但不检查 key，可能使用全局 locale）
+  if (!importInfo.hasCorrectImport && !importInfo.hasOtherImport) {
+    if (!results.noLocaleImport.has(relativePath)) {
+      results.noLocaleImport.set(relativePath, {
+        file: relativePath,
+        usedKeys: Array.from(usedKeys)
+      })
     }
+    return // 没有导入本地 locale，不检查 key 是否缺失
+  }
 
-    if (!scriptCode) continue
+  // 只有使用标准导入方式（import locale from './locale'）时，才检查 key
+  // 如果 locale.ts 不存在，记录缺失的 key
+  if (!localeKeys) {
+    usedKeys.forEach(key => {
+      if (!results.missingLocale.has(relativePath)) {
+        results.missingLocale.set(relativePath, {
+          file: relativePath,
+          localePath: relativeLocalePath,
+          missingKeys: new Set()
+        })
+      }
+      results.missingLocale.get(relativePath).missingKeys.add(key)
+    })
+    return
+  }
 
-    let ast
-    try {
-      ast = parseCode(scriptCode)
-    } catch {
-      continue
+  // 检查哪些 key 在 locale 中不存在
+  const missingKeys = Array.from(usedKeys).filter(key => !localeKeys.has(key))
+  
+  if (missingKeys.length > 0) {
+    if (!results.missingKeys.has(relativePath)) {
+      results.missingKeys.set(relativePath, {
+        file: relativePath,
+        localePath: relativeLocalePath,
+        missingKeys: new Set()
+      })
     }
-
-    const usedKeys = []
-    let importedLocale = false
-
-    traverse(ast, {
-      ImportDeclaration(p) {
-        if (p.node.source.value === './locale') {
-          importedLocale = true
-        }
-      },
-
-      CallExpression(p) {
-        const callee = p.node.callee
-        if (
-          (callee.type === 'Identifier' && (callee.name === 't' || callee.name === '$t'))
-        ) {
-          const keyArg = p.node.arguments[0]
-          const defaultArg = p.node.arguments[1]
-          if (keyArg && keyArg.type === 'StringLiteral') {
-            usedKeys.push({
-              key: keyArg.value,
-              defaultValue:
-                defaultArg && defaultArg.type === 'StringLiteral'
-                  ? defaultArg.value
-                  : null,
-            })
-          }
-        }
-      },
+    missingKeys.forEach(key => {
+      results.missingKeys.get(relativePath).missingKeys.add(key)
     })
+  }
+}
 
-    if (!usedKeys.length) continue
-
-    const fileDir = path.dirname(file)
-
-    /* ---------- views 逻辑 ---------- */
-    if (file.startsWith(viewsRoot)) {
-      const localePath = path.join(fileDir, 'locale.ts')
-      const localeKeys = loadLocaleKeys(localePath)
-
-      if (!importedLocale || !localeKeys) {
-        noLocaleUsage.push({
-          file: path.relative(cwd, file),
-          keys: usedKeys.map(i => i.key),
-        })
-        continue
-      }
-
-      for (const { key, defaultValue } of usedKeys) {
-        if (!localeKeys.includes(key)) {
-          missingKeys.push({
-            file: path.relative(cwd, file),
-            key,
-            defaultValue,
-          })
-        }
-      }
+/**
+ * 主函数
+ */
+function run() {
+  const results = {
+    invalidImports: new Map(),      // 使用了非 './locale' 的导入
+    noLocaleImport: new Map(),      // 没有导入 locale 但使用了 t()
+    missingLocale: new Map(),       // locale.ts 文件不存在
+    missingKeys: new Map()          // locale.ts 存在但缺少某些 key
+  }
 
-      continue
+  // 扫描所有文件
+  SCAN_DIRS.forEach(dir => {
+    const absDir = path.join(ROOT, dir)
+    if (!fs.existsSync(absDir)) {
+      console.log(`⚠️  目录不存在: ${dir}`)
+      return
     }
 
-    /* ---------- components 逻辑 ---------- */
-    if (file.startsWith(componentsRoot)) {
-      const localePath = findNearestLocale(fileDir, componentsRoot)
-      const localeKeys = localePath && loadLocaleKeys(localePath)
+    FILE_EXT.forEach(ext => {
+      const pattern = `${absDir}/**/*.${ext}`
+      const files = glob.sync(pattern, { nodir: true })
+      files.forEach(file => scanFile(file, results))
+    })
+  })
 
-      if (!localeKeys) {
-        noLocaleUsage.push({
-          file: path.relative(cwd, file),
-          keys: usedKeys.map(i => i.key),
-        })
-        continue
-      }
+  // 输出结果
+  console.log('\n📋 i18n 使用检查结果\n')
 
-      for (const { key, defaultValue } of usedKeys) {
-        if (!localeKeys.includes(key)) {
-          missingKeys.push({
-            file: path.relative(cwd, file),
-            key,
-            defaultValue,
-          })
-        }
+  let hasError = false
+
+  // 1. 输出非标准导入方式
+  if (results.invalidImports.size > 0) {
+    hasError = true
+    console.log('❌ 使用了非标准的 locale 导入方式（应使用 import locale from \'./locale\'）：\n')
+    results.invalidImports.forEach((info, file) => {
+      console.log(`   ${file}`)
+      info.importPaths.forEach(importPath => {
+        console.log(`     ↳ import locale from '${importPath}'`)
+      })
+      if (info.usedKeys && info.usedKeys.length > 0) {
+        console.log(`     使用的 key: ${info.usedKeys.join(', ')}`)
       }
-    }
+    })
+    console.log()
   }
 
-  /* ---------------- output ---------------- */
-
-  if (!silent) {
-    if (missingKeys.length) {
-      console.error('\n❌ 缺失的国际化 key：')
-      missingKeys.forEach(i =>
-        console.error(
-          `  ${i.file}  →  ${i.key}${i.defaultValue ? ` （默认值: ${i.defaultValue}）` : ''}`
-        )
-      )
-    }
+  // 2. 输出没有导入 locale 的文件
+  if (results.noLocaleImport.size > 0) {
+    console.log('⚠️  以下文件使用了 t() 但未导入本地 locale（可能使用全局 locale）：\n')
+    results.noLocaleImport.forEach((info, file) => {
+      console.log(`   ${file}`)
+      console.log(`     使用的 key: ${info.usedKeys.join(', ')}`)
+    })
+    console.log()
+  }
 
-    if (noLocaleUsage.length) {
-      console.warn('\n⚠️ 使用了 $t / t 但未找到 locale.ts：')
-      noLocaleUsage.forEach(i =>
-        console.warn(`  ${i.file}`)
-      )
-    }
+  // 3. 输出缺少 locale.ts 文件的情况
+  if (results.missingLocale.size > 0) {
+    hasError = true
+    console.log('❌ 以下文件使用了 t() 但缺少对应的 locale.ts 文件：\n')
+    results.missingLocale.forEach((info, file) => {
+      console.log(`   ${file}`)
+      console.log(`     期望的 locale 文件: ${info.localePath}`)
+      console.log(`     缺失的 key: ${Array.from(info.missingKeys).join(', ')}`)
+    })
+    console.log()
+  }
 
-    if (!missingKeys.length && !noLocaleUsage.length) {
-      console.log('✅ 国际化检查通过（views + components）')
-    }
+  // 4. 输出缺少的 key
+  if (results.missingKeys.size > 0) {
+    hasError = true
+    console.log('❌ 以下文件使用的 key 在 locale.ts 中未定义：\n')
+    results.missingKeys.forEach((info, file) => {
+      console.log(`   ${file}`)
+      console.log(`     locale 文件: ${info.localePath}`)
+      console.log(`     缺失的 key:`)
+      Array.from(info.missingKeys).forEach(key => {
+        console.log(`       - ${key}`)
+      })
+    })
+    console.log()
   }
 
-  return {
-    success: missingKeys.length === 0,
-    missingKeys,
-    noLocaleUsage,
-    scannedFiles: files.length,
-    options,
+  // 总结
+  if (hasError) {
+    console.log('❗ 检查未通过，请修复上述问题')
+    process.exitCode = 1
+  } else {
+    console.log('✅ 所有检查通过')
   }
 }
 
-/* ---------------- exports ---------------- */
-
 exports.run = run
+