feima-shortcuts 0.3.0-beta.8 → 0.3.1

package/bin/feima.js

@@ -32,7 +32,7 @@ program
   .command('check-i18n-views')
   .description('检查已使用未创建的 key')
   .action(() => {
-    checkI18nViews.run();
+    checkI18nViews.run()
   })
 
 

package/package.json

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

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

@@ -1,171 +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
 
-/* ---------------- defaults ---------------- */
+const ROOT = process.cwd()
+const SCAN_DIRS = ['src/views'] // views 目录
+const COMPONENTS_DIR = 'src/components' // components 目录
+const FILE_EXT = ['vue', 'ts', 'js', 'tsx', 'jsx']
 
-const DEFAULT_OPTIONS = {
-  cwd: process.cwd(),
-  viewsDir: 'src/views',
-  silent: false,
-}
+// 匹配 t() 调用：t('key') 或 t('key', 'default')
+const T_FUNCTION_REG = /\bt\s*\(\s*['"`]([^'"`]+)['"`]\s*(?:,\s*['"`][^'"`]*['"`])?\s*\)/g
 
-/* ---------------- utils ---------------- */
+// 匹配 $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') {
-      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
 }
 
-/* ---------------- core ---------------- */
+/**
+ * 从代码中提取所有 $t() 调用的 key
+ */
+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 = {}) {
-  // ✅ 保证 options 永远有值
-  const options = { ...DEFAULT_OPTIONS, ...userOptions }
-  const { cwd, viewsDir, silent } = options
+/**
+ * 检查 locale 导入方式
+ * @returns {Object} { hasCorrectImport, hasOtherImport, importPaths }
+ */
+function checkLocaleImport(code) {
+  const result = {
+    hasCorrectImport: false,
+    hasOtherImport: false,
+    importPaths: []
+  }
 
-  const absViewsDir = path.join(cwd, viewsDir)
+  // 匹配 import locale from 'xxx'
+  const importReg = /import\s+locale\s+from\s+['"]([^'"]+)['"]/g
+  let match
 
-  if (!fs.existsSync(absViewsDir)) {
-    if (!silent) {
-      console.warn(`⚠️ views 目录不存在：${viewsDir}`)
-    }
-    return {
-      success: true,
-      missingKeys: [],
-      noLocaleUsage: [],
-      scannedFiles: 0,
+  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 files = glob.sync('**/*.{vue,ts,tsx}', {
-    cwd: absViewsDir,
-    absolute: true,
-  })
+  return result
+}
 
-  const missingKeys = []
-  const noLocaleUsage = []
+/**
+ * 解析 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
-
-    const ast = parseCode(scriptCode)
+  if (!code) return
 
-    let usedLocale = false
-    const usedKeys = []
+  // 提取 t() 调用的 key
+  const usedKeys = extractTKeys(code)
+  if (usedKeys.size === 0) return
 
-    traverse(ast, {
-      ImportDeclaration(p) {
-        if (p.node.source.value === './locale') {
-          usedLocale = true
-        }
-      },
-
-      CallExpression(p) {
-        const callee = p.node.callee
-        if (
-          (callee.type === 'Identifier' && callee.name === 't') ||
-          (callee.type === 'Identifier' && callee.name === '$t')
-        ) {
-          const arg = p.node.arguments[0]
-          if (arg && arg.type === 'StringLiteral') {
-            usedKeys.push(arg.value)
-          }
-        }
-      },
-    })
+  // 检查 locale 导入方式
+  const importInfo = checkLocaleImport(code)
+  
+  // 查找对应的 locale.ts
+  const localePath = findLocalePath(filePath)
+  const localeKeys = loadLocaleKeys(localePath)
 
-    if (!usedKeys.length) continue
+  const relativePath = path.relative(ROOT, filePath)
+  const relativeLocalePath = path.relative(ROOT, localePath)
 
-    const localePath = path.join(path.dirname(file), 'locale.ts')
-    const localeKeys = loadLocaleKeys(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 是否缺失
+  }
 
-    if (!usedLocale || !localeKeys) {
-      noLocaleUsage.push({
-        file: path.relative(cwd, file),
-        keys: usedKeys,
+  // 如果没有导入 locale，记录（但不检查 key，可能使用全局 locale）
+  if (!importInfo.hasCorrectImport && !importInfo.hasOtherImport) {
+    if (!results.noLocaleImport.has(relativePath)) {
+      results.noLocaleImport.set(relativePath, {
+        file: relativePath,
+        usedKeys: Array.from(usedKeys)
       })
-      continue
     }
+    return // 没有导入本地 locale，不检查 key 是否缺失
+  }
 
-    for (const key of usedKeys) {
-      if (!localeKeys.includes(key)) {
-        missingKeys.push({
-          file: path.relative(cwd, file),
-          key,
+  // 只有使用标准导入方式（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
+  }
+
+  // 检查哪些 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)
+    })
   }
+}
 
-  /* ---------------- output ---------------- */
+/**
+ * 检查组件目录（使用 $t 注入方式）
+ */
+function checkComponent(componentDir, results) {
+  const localePath = path.join(componentDir, 'locale.ts')
+  if (!fs.existsSync(localePath)) {
+    return // 组件没有 locale.ts，跳过
+  }
 
-  if (!silent) {
-    if (missingKeys.length) {
-      console.error('\n❌ 缺失的国际化 key：')
-      missingKeys.forEach(i =>
-        console.error(`  ${i.file}  →  ${i.key}`)
-      )
-    }
+  const localeKeys = loadLocaleKeys(localePath)
+  if (!localeKeys) {
+    console.warn(`⚠️  无法加载组件 locale: ${path.relative(ROOT, localePath)}`)
+    return
+  }
+
+  // 递归扫描组件目录下的所有文件
+  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 (noLocaleUsage.length) {
-      console.warn('\n⚠️ 使用了 t/$t 但未使用 ./locale：')
-      noLocaleUsage.forEach(i =>
-        console.warn(`  ${i.file}`)
-      )
+      if (code) {
+        // 提取 $t() 调用的 key
+        const dollarTKeys = extractDollarTKeys(code)
+        dollarTKeys.forEach(key => allUsedKeys.add(key))
+      }
+    })
+  })
+
+  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
+            })
+          }
+        }
+      }
+    })
+  }
+}
 
-    if (!missingKeys.length && !noLocaleUsage.length) {
-      console.log('✅ views 国际化检查通过')
+/**
+ * 主函数
+ */
+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
     }
+
+    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}`)
+  }
+
+  // 输出结果
+  console.log('\n📋 i18n 使用检查结果\n')
+
+  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()
+  }
+
+  // 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()
   }
 
-  return {
-    success: missingKeys.length === 0,
-    missingKeys,
-    noLocaleUsage,
-    scannedFiles: files.length,
-    options, // 🔍 调试/日志时很有用
+  // 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()
+  }
+
+  // 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()
+    })
   }
-}
 
-/* ---------------- exports ---------------- */
+  // 总结
+  if (hasError) {
+    console.log('❗ 检查未通过，请修复上述问题')
+    process.exitCode = 1
+  } else {
+    console.log('✅ 所有检查通过')
+  }
+}
 
 exports.run = run
+

package/src/scripts/restful-api/old.js

@@ -4,7 +4,7 @@ const { makeDir } = require("../../utils/makeDir");
 const fileName = "index.ts";
 
 const postTemplat = (apiPath, functionName) => {
-  return `export const ${functionName}: any = (options: any) => {
+  return `export const ${functionName} = (options: any) => {
   const isFormData = options?.data instanceof FormData;
 
   const data = isFormData
@@ -37,7 +37,7 @@ function splitString(input) {
 const fileData = (answers, functionName) => { 
   if (fs.existsSync(`./${fileName}`)) {
     const data = fs.readFileSync(`./${fileName}`, "utf8");
-    if (data.includes(`export const ${functionName}: any`)) {
+    if (data.includes(`export const ${functionName} `)) {
       return "";
     }
     return data;