feima-shortcuts 0.3.0-beta.11 → 0.3.0-beta.13

package/package.json

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

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

@@ -1,271 +1,485 @@
+#!/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
 
-const DEFAULT_OPTIONS = {
-  cwd: process.cwd(),
-  scanDirs: ['src/views', 'src/components'],
-  silent: false,
-}
+const ROOT = process.cwd()
+const SCAN_DIRS = ['src/views'] // views 目录
+const COMPONENTS_DIR = 'src/components' // components 目录
+const FILE_EXT = ['vue', 'ts', 'js', 'tsx', 'jsx']
+
+// 匹配 t() 调用：t('key') 或 t('key', 'default')
+const T_FUNCTION_REG = /\bt\s*\(\s*['"`]([^'"`]+)['"`]\s*(?:,\s*['"`][^'"`]*['"`])?\s*\)/g
 
+// 匹配 $t() 调用：$t('key') 或 $t('key', 'default')
+const DOLLAR_T_FUNCTION_REG = /\$t\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
+  }
 
-function parseCode(code) {
-  return babelParser.parse(code, {
-    sourceType: 'module',
-    plugins: ['typescript', 'jsx'],
-  })
+  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
+  }
 }
 
 /**
- * components 目录专用：
- * 向上查找最近含 locale.ts 的目录（包含自身目录）
- * 到达 componentsRoot 停止
+ * 从代码中提取所有 t() 调用的 key
  */
-function findNearestLocale(fileDir, componentsRoot) {
-  let current = fileDir
-  while (current.startsWith(componentsRoot)) {
-    const localePath = path.join(current, 'locale.ts')
-    if (fs.existsSync(localePath)) {
-      return localePath
-    }
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
+function extractTKeys(code) {
+  const keys = new Set()
+  let match
+  while ((match = T_FUNCTION_REG.exec(code)) !== null) {
+    keys.add(match[1])
   }
-  return null
+  return keys
 }
 
 /**
- * views 目录专用：
- * 只查找当前文件同目录的 locale.ts
+ * 从代码中提取所有 $t() 调用的 key
  */
-function findViewsLocale(fileDir) {
-  const localePath = path.join(fileDir, 'locale.ts')
-  if (fs.existsSync(localePath)) return localePath
-  return null
+function extractDollarTKeys(code) {
+  const keys = new Set()
+  let match
+  while ((match = DOLLAR_T_FUNCTION_REG.exec(code)) !== null) {
+    keys.add(match[1])
+  }
+  return keys
 }
 
-function run(userOptions = {}) {
-  const options = { ...DEFAULT_OPTIONS, ...userOptions }
-  const { cwd, scanDirs, silent } = options
+/**
+ * 检查 locale 导入方式
+ * @returns {Object} { hasCorrectImport, hasOtherImport, importPaths }
+ */
+function checkLocaleImport(code) {
+  const result = {
+    hasCorrectImport: false,
+    hasOtherImport: false,
+    importPaths: []
+  }
 
-  let files = []
+  // 匹配 import locale from 'xxx'
+  const importReg = /import\s+locale\s+from\s+['"]([^'"]+)['"]/g
+  let match
 
-  for (const dir of scanDirs) {
-    const absDir = path.join(cwd, dir)
-    if (!fs.existsSync(absDir)) {
-      if (!silent) console.warn(`⚠️ 目录不存在：${dir}`)
-      continue
+  while ((match = importReg.exec(code)) !== null) {
+    const importPath = match[1]
+    result.importPaths.push(importPath)
+    if (importPath === './locale') {
+      result.hasCorrectImport = true
+    } else {
+      result.hasOtherImport = true
     }
-    files.push(
-      ...glob.sync('**/*.{vue,ts,tsx}', {
-        cwd: absDir,
-        absolute: true,
-      })
-    )
   }
 
-  const missingKeys = []
-  const noLocaleUsage = []
+  return result
+}
 
-  const componentsRoot = path.join(cwd, 'src/components')
-  const viewsRoot = path.join(cwd, 'src/views')
+/**
+ * 解析 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
+    }
 
-  for (const file of files) {
-    const content = fs.readFileSync(file, 'utf-8')
+    return scriptContent
+  } catch (error) {
+    console.warn(`⚠️  解析 Vue 文件失败: ${filePath}`, error.message)
+    return ''
+  }
+}
 
-    let scriptCode = content
+/**
+ * 查找文件对应的 locale.ts 路径
+ */
+function findLocalePath(filePath) {
+  const dir = path.dirname(filePath)
+  const localePath = path.join(dir, 'locale.ts')
+  return localePath
+}
 
-    if (file.endsWith('.vue')) {
-      const { descriptor } = parse(content)
-      scriptCode =
-        descriptor.scriptSetup?.content ||
-        descriptor.script?.content ||
-        ''
+/**
+ * 扫描单个文件
+ */
+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
     }
+  }
 
-    if (!scriptCode) continue
-
-    let ast
-    try {
-      ast = parseCode(scriptCode)
-    } catch {
-      continue
+  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 usedKeys = []
-    let importedLocale = false // 只对 views 生效
+  // 如果没有导入 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 是否缺失
+  }
 
-    traverse(ast, {
-      ImportDeclaration(p) {
-        if (p.node.source.value === './locale') {
-          importedLocale = true
-        }
-      },
-      CallExpression(p) {
-        const callee = p.node.callee
-
-        if (file.startsWith(viewsRoot)) {
-          // src/views 目录：只检查 t()
-          if (
-            callee.type === 'Identifier' &&
-            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,
-              })
-            }
-          }
-        } else if (file.startsWith(componentsRoot)) {
-          // src/components 目录：只检查 $t()
-          if (
-            callee.type === 'Identifier' &&
-            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,
-              })
-            }
-          }
-        }
-      },
+  // 只有使用标准导入方式（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
+  }
 
-    if (!usedKeys.length) 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()
+      })
+    }
+    missingKeys.forEach(key => {
+      results.missingKeys.get(relativePath).missingKeys.add(key)
+    })
+  }
+}
 
-    const fileDir = path.dirname(file)
+/**
+ * 检查组件目录（使用 $t 注入方式）
+ */
+function checkComponent(componentDir, results) {
+  const localePath = path.join(componentDir, 'locale.ts')
+  if (!fs.existsSync(localePath)) {
+    return // 组件没有 locale.ts，跳过
+  }
 
-    if (file.startsWith(viewsRoot)) {
-      // views 逻辑：只查同目录 locale.ts，且 vue 文件必须导入 locale
-      const localePath = findViewsLocale(fileDir)
-      const localeKeys = localePath && loadLocaleKeys(localePath)
+  const localeKeys = loadLocaleKeys(localePath)
+  if (!localeKeys) {
+    console.warn(`⚠️  无法加载组件 locale: ${path.relative(ROOT, localePath)}`)
+    return
+  }
 
-      if (file.endsWith('.vue') && !importedLocale) {
-        noLocaleUsage.push({
-          file: path.relative(cwd, file),
-          keys: usedKeys.map(i => i.key),
-          reason: 'vue 文件未 import locale',
-        })
-        continue
+  // 递归扫描组件目录下的所有文件
+  const allUsedKeys = new Set()
+  const componentFiles = []
+
+  FILE_EXT.forEach(ext => {
+    const pattern = `${componentDir}/**/*.${ext}`
+    const files = glob.sync(pattern, { nodir: true })
+    files.forEach(file => {
+      componentFiles.push(file)
+      let code = ''
+      
+      if (file.endsWith('.vue')) {
+        code = parseVueFile(file)
+      } else {
+        try {
+          code = fs.readFileSync(file, 'utf-8')
+        } catch (error) {
+          console.warn(`⚠️  读取文件失败: ${file}`, error.message)
+          return
+        }
       }
 
-      if (!localeKeys) {
-        noLocaleUsage.push({
-          file: path.relative(cwd, file),
-          keys: usedKeys.map(i => i.key),
-          reason: '同目录无 locale.ts',
-        })
-        continue
+      if (code) {
+        // 提取 $t() 调用的 key
+        const dollarTKeys = extractDollarTKeys(code)
+        dollarTKeys.forEach(key => allUsedKeys.add(key))
       }
+    })
+  })
 
-      for (const { key, defaultValue } of usedKeys) {
-        if (!localeKeys.includes(key)) {
-          missingKeys.push({
-            file: path.relative(cwd, file),
-            key,
-            defaultValue,
-          })
+  if (allUsedKeys.size === 0) {
+    return // 组件中没有使用 $t()
+  }
+
+  // 检查哪些 key 在 locale 中不存在
+  const missingKeys = Array.from(allUsedKeys).filter(key => !localeKeys.has(key))
+  
+  if (missingKeys.length > 0) {
+    const relativeComponentDir = path.relative(ROOT, componentDir)
+    const relativeLocalePath = path.relative(ROOT, localePath)
+    
+    if (!results.componentMissingKeys.has(relativeComponentDir)) {
+      results.componentMissingKeys.set(relativeComponentDir, {
+        componentDir: relativeComponentDir,
+        localePath: relativeLocalePath,
+        missingKeys: new Set(),
+        files: []
+      })
+    }
+    
+    missingKeys.forEach(key => {
+      results.componentMissingKeys.get(relativeComponentDir).missingKeys.add(key)
+    })
+    
+    // 记录使用了这些 key 的文件
+    componentFiles.forEach(file => {
+      let code = ''
+      if (file.endsWith('.vue')) {
+        code = parseVueFile(file)
+      } else {
+        try {
+          code = fs.readFileSync(file, 'utf-8')
+        } catch (error) {
+          return
+        }
+      }
+      
+      if (code) {
+        const dollarTKeys = extractDollarTKeys(code)
+        const fileMissingKeys = Array.from(dollarTKeys).filter(key => missingKeys.includes(key))
+        if (fileMissingKeys.length > 0) {
+          const relativeFile = path.relative(ROOT, file)
+          const info = results.componentMissingKeys.get(relativeComponentDir)
+          if (!info.files.find(f => f.file === relativeFile)) {
+            info.files.push({
+              file: relativeFile,
+              missingKeys: fileMissingKeys
+            })
+          }
         }
       }
-      continue
+    })
+  }
+}
+
+/**
+ * 主函数
+ */
+function run() {
+  const results = {
+    invalidImports: new Map(),      // 使用了非 './locale' 的导入
+    noLocaleImport: new Map(),      // 没有导入 locale 但使用了 t()
+    missingLocale: new Map(),       // locale.ts 文件不存在
+    missingKeys: new Map(),          // locale.ts 存在但缺少某些 key
+    componentMissingKeys: new Map() // 组件中 $t() 的 key 在 locale.ts 中缺失
+  }
+
+  // 扫描 views 目录
+  SCAN_DIRS.forEach(dir => {
+    const absDir = path.join(ROOT, dir)
+    if (!fs.existsSync(absDir)) {
+      console.log(`⚠️  目录不存在: ${dir}`)
+      return
     }
 
-    if (file.startsWith(componentsRoot)) {
-      // components 逻辑：向上找最近 locale.ts
-      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))
+    })
+  })
+
+  // 扫描 components 目录
+  const componentsDir = path.join(ROOT, COMPONENTS_DIR)
+  if (fs.existsSync(componentsDir)) {
+    // 找到所有有 locale.ts 的组件目录
+    const localeFiles = glob.sync(`${componentsDir}/**/locale.ts`, { nodir: true })
+    localeFiles.forEach(localeFile => {
+      const componentDir = path.dirname(localeFile)
+      checkComponent(componentDir, results)
+    })
+  } else {
+    console.log(`⚠️  目录不存在: ${COMPONENTS_DIR}`)
+  }
 
-      if (!localeKeys) {
-        noLocaleUsage.push({
-          file: path.relative(cwd, file),
-          keys: usedKeys.map(i => i.key),
-          reason: '未找到可用 locale.ts',
-        })
-        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(', ')}`)
       }
-      continue
-    }
+    })
+    console.log()
   }
 
-  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}  →  原因: ${i.reason}，涉及 keys: ${i.keys.join(', ')}`
-        )
-      )
-    }
+  // 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()
+  }
+
+  // 5. 输出组件中缺失的 key
+  if (results.componentMissingKeys.size > 0) {
+    hasError = true
+    console.log('❌ 以下组件使用的 $t() key 在 locale.ts 中未定义：\n')
+    results.componentMissingKeys.forEach((info, componentDir) => {
+      console.log(`   组件: ${componentDir}`)
+      console.log(`     locale 文件: ${info.localePath}`)
+      console.log(`     缺失的 key:`)
+      Array.from(info.missingKeys).forEach(key => {
+        console.log(`       - ${key}`)
+      })
+      if (info.files && info.files.length > 0) {
+        console.log(`     使用位置:`)
+        info.files.forEach(fileInfo => {
+          console.log(`       ${fileInfo.file}`)
+          if (fileInfo.missingKeys && fileInfo.missingKeys.length > 0) {
+            console.log(`         缺失的 key: ${fileInfo.missingKeys.join(', ')}`)
+          }
+        })
+      }
+      console.log()
+    })
   }
 
-  return {
-    success: missingKeys.length === 0,
-    missingKeys,
-    noLocaleUsage,
-    scannedFiles: files.length,
-    options,
+  // 总结
+  if (hasError) {
+    console.log('❗ 检查未通过，请修复上述问题')
+    process.exitCode = 1
+  } else {
+    console.log('✅ 所有检查通过')
   }
 }
 
 exports.run = run
+