@cloudbase/cli 2.9.9 → 2.9.10-beta.0

package/locales/i18next-scanner.config.js

@@ -0,0 +1,206 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+const fs = require('fs')
+const path = require('path')
+const chalk = require('chalk')
+const parser = require('@babel/parser')
+const traverse = require('@babel/traverse').default
+const t = require('@babel/types')
+
+module.exports = {
+    input: [
+        'src/**/*.{ts,js}',
+        'bin/**/*.{js,cjs}',
+        '!**/node_modules/**',
+        // 忽略 framework 和 lowcode
+        '!src/commands/framework/**/*.ts',
+        '!src/commands/lowcode/**/*.ts',
+    ],
+    output: './',
+    options: {
+        debug: false,
+        func: {
+            list: ['t'],
+            extensions: ['.js', '.ts']
+        },
+        // 禁用 Trans 组件解析
+        trans: false,
+        lngs: ['zh','en'],
+        defaultLng: 'zh',
+        defaultValue: '__STRING_NOT_TRANSLATED__',
+        resource: {
+            loadPath: path.resolve(__dirname, 'langs/{{lng}}.json'),
+            savePath: path.resolve(__dirname, 'langs/{{lng}}.json'),
+            jsonIndent: 4,
+            lineEnding: '\n'
+        },
+        nsSeparator: false,
+        keySeparator: false,
+        interpolation: {
+            prefix: '{{',
+            suffix: '}}'
+        },
+        // 禁用复数处理
+        plural: false,
+        metadata: {},
+        allowDynamicKeys: false,
+    },
+    transform: function (file, enc, done) {
+        const parser = this.parser
+        const content = fs.readFileSync(file.path, enc)
+        let count = 0
+
+        // 解析 t() 函数调用
+        parser.parseFuncFromString(content, { list: ['t'] }, (key, options) => {
+            // 使用文本内容作为 key，后续会通过脚本转换为标识
+            parser.set(key, { ...options })
+            ++count
+        })
+
+        if (count > 0) {
+            console.log(`i18next-scanner: ${chalk.yellow(file.relative)}, count=${chalk.cyan(count)}`)
+        }
+
+        // 检测未使用 t() 函数包裹的中文字符串
+        const unwrappedStrings = detectUnwrappedStrings(content, file.relative)
+        if (unwrappedStrings.length > 0) {
+            console.log(`i18next-scanner: ${chalk.red('未处理字符串')} ${chalk.yellow(file.relative)}, count=${chalk.red(unwrappedStrings.length)}`)
+            unwrappedStrings.forEach(item => {
+                const location = item.endLine && item.endLine !== item.line 
+                    ? `L${item.line}:${item.column}-L${item.endLine}:${item.endColumn}`
+                    : `L${item.line}:${item.column}`
+                console.log(`  ${chalk.gray(location)} ${chalk.yellow('"')}${chalk.cyan(item.text)}${chalk.yellow('"')}`)
+            })
+        }
+
+        done()
+    }
+}
+
+// 检测未使用 t() 函数包裹的中文字符串
+function detectUnwrappedStrings(content, filePath) {
+    const unwrappedStrings = []
+    
+    try {
+        // 使用 Babel 解析代码为 AST
+        const ast = parser.parse(content, {
+            sourceType: 'module',
+            allowImportExportEverywhere: true,
+            allowReturnOutsideFunction: true,
+            plugins: [
+                'typescript',
+                'jsx',
+                'decorators-legacy',
+                'classProperties',
+                'objectRestSpread',
+                'functionBind',
+                'exportDefaultFrom',
+                'exportNamespaceFrom',
+                'dynamicImport',
+                'nullishCoalescingOperator',
+                'optionalChaining'
+            ]
+        })
+        
+        // 遍历 AST 节点
+        traverse(ast, {
+            // 检测字符串字面量
+            StringLiteral(path) {
+                const { node, parent } = path
+                const value = node.value
+                
+                // 检查是否包含中文字符
+                if (!containsChinese(value)) {
+                    return
+                }
+                
+                // 检查是否被 t() 函数包裹
+                if (isWrapped(parent)) {
+                    return
+                }
+                
+                // 过滤掉不需要国际化的字符串
+                if (shouldIgnoreString(value)) {
+                    return
+                }
+                
+                unwrappedStrings.push({
+                    text: value,
+                    line: node.loc?.start?.line || 0,
+                    column: node.loc?.start?.column || 0,
+                    endLine: node.loc?.end?.line || 0,
+                    endColumn: node.loc?.end?.column || 0
+                })
+            },
+            
+            // 检测模板字符串
+            TemplateLiteral(path) {
+                const { node, parent } = path
+                
+                // 检查是否被 t() 函数包裹
+                if (isWrapped(parent)) {
+                    return
+                }
+                
+                // 检查模板字符串的各个部分
+                node.quasis.forEach(quasi => {
+                    const value = quasi.value.raw
+                    if (containsChinese(value) && !shouldIgnoreString(value)) {
+                        unwrappedStrings.push({
+                            text: value,
+                            line: quasi.loc?.start?.line || 0,
+                            column: quasi.loc?.start?.column || 0,
+                            endLine: quasi.loc?.end?.line || 0,
+                            endColumn: quasi.loc?.end?.column || 0
+                        })
+                    }
+                })
+            }
+        })
+        
+    } catch (error) {
+        // 如果解析失败，输出警告但不中断流程
+        console.log(`i18next-scanner: 解析文件失败 ${filePath}: ${error.message}`)
+    }
+    
+    return unwrappedStrings
+}
+
+// 检查字符串是否包含中文字符
+function containsChinese(str) {
+    return /[\u4e00-\u9fff]/.test(str)
+}
+
+// 检查字符串是否被 t() 函数包裹
+function isWrapped(parent) {
+    if (!parent) return false
+    
+    // 检查是否是 CallExpression 且 callee 是 Identifier 't'
+    if (t.isCallExpression(parent)) {
+        const callee = parent.callee
+        if (t.isIdentifier(callee) && callee.name === 't') {
+            return true
+        }
+        // 检查是否是 t() 的链式调用
+        if (t.isMemberExpression(callee)) {
+            const object = callee.object
+            if (t.isIdentifier(object) && object.name === 't') {
+                return true
+            }
+        }
+    }
+    
+    return false
+}
+
+// 判断是否应该忽略某个字符串
+function shouldIgnoreString(string) {
+    const trimmed = string.trim()
+    
+    // 如果字符串包含中文字符，则不忽略
+    if (containsChinese(trimmed)) {
+        return false
+    }
+    
+    // 只忽略不包含中文的字符串
+    return true
+}