@cloudbase/cli 2.11.6 → 2.11.7

package/lib/utils/tools/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./uid"), exports);
+__exportStar(require("./time"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./encoding"), exports);

package/lib/utils/tools/object.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstLetterToLowerCase = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+lodash_1.default.mixin({
+    deep: function (obj, mapper) {
+        return mapper(lodash_1.default.mapValues(obj, function (v) {
+            if (lodash_1.default.isPlainObject(v)) {
+                return lodash_1.default.deep(v, mapper);
+            }
+            if (lodash_1.default.isArray(v)) {
+                return lodash_1.default.map(v, val => lodash_1.default.deep(val, mapper));
+            }
+            return v;
+        }));
+    }
+});
+function firstLetterToLowerCase(data) {
+    return lodash_1.default.deep(data, function (x) {
+        return lodash_1.default.mapKeys(x, function (val, key) {
+            return key.charAt(0).toLowerCase() + key.slice(1);
+        });
+    });
+}
+exports.firstLetterToLowerCase = firstLetterToLowerCase;

package/lib/utils/tools/time.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.formatDate = void 0;
+function formatDate(dateParam, fmtParam) {
+    let date;
+    let fmt = fmtParam;
+    if (date instanceof Date === false) {
+        date = new Date(dateParam);
+    }
+    if (/(y+)/.test(fmt)) {
+        fmt = fmt.replace(RegExp.$1, String(date.getFullYear()).substr(4 - RegExp.$1.length));
+    }
+    let expMap = {
+        'M+': date.getMonth() + 1,
+        'd+': date.getDate(),
+        'h+': date.getHours(),
+        'm+': date.getMinutes(),
+        's+': date.getSeconds(),
+        S: date.getMilliseconds()
+    };
+    for (let exp in expMap) {
+        if (new RegExp('(' + exp + ')').test(fmt)) {
+            fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1
+                ? expMap[exp]
+                : ('00' + expMap[exp]).substr(String(expMap[exp]).length));
+        }
+    }
+    return fmt;
+}
+exports.formatDate = formatDate;
+function sleep(time) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(resolve => {
+            setTimeout(() => {
+                resolve();
+            }, time);
+        });
+    });
+}
+exports.sleep = sleep;

package/lib/utils/tools/uid.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidv4 = exports.random = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+function random(len = 8) {
+    if (!Number.isInteger(len)) {
+        throw new Error('len must be an integer');
+    }
+    return crypto_1.default
+        .randomBytes(len)
+        .toString('hex')
+        .substring(0, len);
+}
+exports.random = random;
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuidv4 = uuidv4;

package/lib/utils/url.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGatewayUrl = exports.EUrl = exports.EDomain = void 0;
+const i18n_1 = require("../i18n");
+exports.EDomain = {
+    Console: (0, i18n_1.isIntl)() ? 'console.tencentcloud.com' : 'console.cloud.tencent.com',
+    Official: (0, i18n_1.isIntl)() ? 'www.tencentcloud.com' : 'cloud.tencent.com',
+    Gateway: (0, i18n_1.isIntl)() ? 'api.intl.tcloudbasegateway.com' : 'api.tcloudbasegateway.com',
+    Tcb: (0, i18n_1.isIntl)() ? 'tcb.tencentcloud.com' : 'tcb.cloud.tencent.com',
+    Docs: 'docs.cloudbase.net'
+};
+exports.EUrl = Object.assign(Object.assign({}, ((domains) => Object.keys(domains).reduce((acc, key) => {
+    acc[key] = `https://${domains[key]}`;
+    return acc;
+}, {}))(exports.EDomain)), { Docs: `https://${exports.EDomain.Docs}` + ((0, i18n_1.isIntl)() ? '/en' : ''), DevPlatform: `https://${exports.EDomain.Tcb}/dev`, TcbConsole: `https://${exports.EDomain.Console}/tcb`, CloudAdmin: `https://${exports.EDomain.Tcb}/cloud-admin` });
+function getGatewayUrl(envId) {
+    return `https://${envId}.${exports.EDomain.Gateway}`;
+}
+exports.getGatewayUrl = getGatewayUrl;

package/lib/utils/validator.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCpuMem = exports.validateIp = exports.assertHas = exports.assertTruthy = void 0;
+const error_1 = require("../error");
+const constant_1 = require("../constant");
+const run_1 = require("../run");
+const i18n_1 = require("../i18n");
+function assertTruthy(val, errMsg) {
+    let ok;
+    if (Array.isArray(val)) {
+        ok = val.every(item => Boolean(val));
+    }
+    else {
+        ok = Boolean(val);
+    }
+    if (!ok) {
+        throw new error_1.CloudBaseError(errMsg);
+    }
+}
+exports.assertTruthy = assertTruthy;
+function assertHas(obj, prop, errMsg) {
+    if (!obj[prop]) {
+        throw new error_1.CloudBaseError(errMsg);
+    }
+}
+exports.assertHas = assertHas;
+const validateIp = (ip) => {
+    if (Object.prototype.toString.call(ip) !== '[object String]')
+        return false;
+    const fields = ip.split('.');
+    if (fields.length !== 4 ||
+        fields.find(item => isNaN(Number(item)) || Number(item) < 0 || Number(item) > 255))
+        return false;
+    return true;
+};
+exports.validateIp = validateIp;
+const validateCpuMem = (cpuInput, memInput) => {
+    if (cpuInput !== undefined && memInput !== undefined) {
+        let cpuSet = (0, run_1.convertNumber)(cpuInput);
+        let memSet = (0, run_1.convertNumber)(memInput);
+        let validMemSet = constant_1.CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet);
+        if (!validMemSet || !validMemSet.mems.length || !validMemSet.mems.includes(memSet)) {
+            throw new error_1.CloudBaseError((0, i18n_1.t)('cpu 与 mem 规格不匹配，当前规格：cpu: {{cpu}}, mem: {{mem}}\n请使用下列规格组合之一：{{options}}', {
+                cpu: cpuInput,
+                mem: memInput,
+                options: constant_1.CPU_MEM_OPTS.map(({ cpu, mems }) => `${cpu}-${mems.join('/')}`).join('，')
+            }));
+        }
+        return { cpuOutput: cpuSet, memOutput: memSet };
+    }
+    if (cpuInput) {
+        let cpuSet = (0, run_1.convertNumber)(cpuInput);
+        let validSet = constant_1.CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet);
+        if (!validSet) {
+            throw new error_1.CloudBaseError((0, i18n_1.t)('不支持当前 cpu 规格，请使用下列 cpu 规格之一：{{options}}', {
+                options: constant_1.CPU_MEM_OPTS.map(({ cpu }) => cpu).join('，')
+            }));
+        }
+        return { cpuOutput: cpuSet, memOutput: constant_1.CPU_MEM_OPTS.find(({ cpu }) => cpu === cpuSet).mems[0] };
+    }
+    if (memInput) {
+        let memSet = (0, run_1.convertNumber)(memInput);
+        let validSet = constant_1.CPU_MEM_OPTS.find(({ mems }) => mems.includes(memSet));
+        if (!validSet) {
+            throw new error_1.CloudBaseError((0, i18n_1.t)('不支持当前 mem 规格，请使用下列 mem 规格之一：{{options}}', {
+                options: constant_1.CPU_MEM_OPTS.map(({ mems }) => mems.join('/')).join('，')
+            }));
+        }
+        return { cpuOutput: validSet.cpu, memOutput: memSet };
+    }
+};
+exports.validateCpuMem = validateCpuMem;

package/locales/README.md

@@ -0,0 +1,160 @@
+# 国际化功能使用说明
+
+## 概述
+
+本项目使用 i18next 实现国际化功能，支持中文和英文两种语言。
+
+## 使用方法
+
+### 1. 在代码中使用
+
+```typescript
+import { t } from 'src/i18n'
+
+// 使用 t() 函数包装需要国际化的文本
+console.log(t('你好')) // 你好
+// 插值
+console.log(t('你好, {{name}}', { name: 'TCB' })) // 你好, TCB
+```
+
+### 2. 扫描和生成标识
+
+```bash
+npm run i18n:scan
+```
+
+## 工作流程
+
+1. **开发阶段**：在代码中使用 `t('文本内容')` 包装需要国际化的文本
+2. **扫描阶段**：运行 `npm run i18n:scan` 扫描代码并提取文本
+3. **生成阶段**：自动为每个文本生成唯一的标识（格式：`k_${hash}`）
+4. **增量管理**：在 `locales/inc/` 目录下生成增量词条文件
+5. **翻译阶段**：开发者在 `inc/en.json` 中填写英文翻译
+6. **同步阶段**：运行 `npm run i18n:sync` 将翻译同步到正式语言文件，并清理增量目录(可选)
+
+## 文件结构
+
+```
+locales/
+├── scripts/                      # 脚本目录
+│   ├── generate.js               # 标识生成脚本
+│   └── sync.js                   # 翻译同步脚本
+├── inc/                          # 增量词条目录（临时）
+│   ├── zh.json                   # 增量中文词条
+│   └── en.json                   # 增量英文翻译
+├── langs/                        # 正式语言文件
+│   ├── zh.json                   # 中文语言文件
+│   └── en.json                   # 英文语言文件
+├── i18next-scanner.config.js     # 扫描配置
+├── mapping.json                  # 文本到标识的映射文件
+└── README.md                     # 本说明文档
+```
+
+## 标识生成规则
+
+- 标识格式：`k_${hash}`
+- 相同文本生成相同标识
+- 使用简单的字符串哈希算法
+- 支持增量更新，只处理新增文本
+
+## 核心特性
+
+- 已有英文翻译不会被覆盖
+- 自动识别和保留现有翻译
+- 增量词条单独放在 `inc` 目录下
+- 与正式语言文件分离，便于管理
+- 自动化同步增量词条
+- 只处理新增或修改的文本
+- 自动移除不再使用的词条
+
+## 命令说明
+
+- **`npm run i18n:scan`**：完整的国际化处理流程
+  - 扫描代码中的 `t()` 函数调用
+  - 提取需要国际化的文本
+  - 生成唯一标识
+  - 更新语言文件
+  - 生成增量词条文件
+
+- **`npm run i18n:sync`**：同步增量翻译
+  - 将 `inc/en.json` 中的翻译同步到正式语言文件
+  - 只同步有效的翻译（跳过 `__STRING_NOT_TRANSLATED__`）
+  - 自动更新 `langs/en.json`
+
+## 增量词条翻译流程
+
+### 步骤1：生成增量文件
+```bash
+npm run i18n
+```
+- 扫描代码，生成增量词条
+- 在 `locales/inc/` 目录下创建文件
+
+### 步骤2：编辑翻译
+编辑 `locales/inc/en.json` 文件：
+```json
+{
+  "k_4293de80": "Test Text 001",
+  "k_62b2fe13": "Welcome to CloudBase CLI",
+  "k_28810860": "Hehe Haha",
+  "k_29c6c120": "Available configurations:"
+}
+```
+
+### 步骤3：同步翻译
+```bash
+npm run i18n:sync
+```
+- 将翻译同步到正式语言文件
+- 显示同步进度和结果
+
+## 注意事项
+
+1. 确保在代码中使用 `t()` 函数包装需要国际化的文本
+2. 运行 `npm run i18n:scan` 后会自动生成增量词条文件
+3. 在 `inc/en.json` 中填写英文翻译
+4. 翻译完成后运行 `npm run i18n:sync` 同步到正式文件
+5. 同步完成后 `inc` 目录会自动清理，无需手动删除
+6. 语言文件中的 key 会自动更新为生成的标识
+
+## 示例
+
+### 源码
+```typescript
+// 代码中
+console.log(t('欢迎使用云开发 CLI'))
+```
+
+### 扫描后
+```json
+// mapping.json
+{
+  "欢迎使用云开发 CLI": "k_62b2fe13"
+}
+
+// inc/zh.json
+{
+  "k_62b2fe13": "欢迎使用云开发 CLI"
+}
+
+// inc/en.json
+{
+  "k_62b2fe13": "__STRING_NOT_TRANSLATED__"
+}
+```
+
+### 翻译后
+```json
+// inc/en.json
+{
+  "k_62b2fe13": "Welcome to CloudBase CLI"
+}
+```
+
+### 同步后
+```json
+// langs/en.json
+{
+  "k_62b2fe13": "Welcome to CloudBase CLI"
+}
+```

package/locales/i18next-scanner.config.js

@@ -0,0 +1,211 @@
+/* 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 (!trimmed) {
+        return true
+    }
+    
+    // 忽略纯数字、URL、文件路径等不需要国际化的字符串
+    if (/^https?:\/\//.test(trimmed) || /^\/[\/\w\-\.]+$/.test(trimmed) || /^\d+$/.test(trimmed)) {
+        return true
+    }
+    
+    // 其他包含中文的字符串都需要国际化
+    return false
+}

package/locales/index.js

@@ -0,0 +1,5 @@
+const en = require('./langs/en.json')
+const zh = require('./langs/zh.json')
+const mappingData = require('./mapping.json')
+
+module.exports = { en, zh, mappingData }