@cloudbase/cli 2.10.0-beta.0 → 2.10.1-alpha.0

package/lib/utils/tools/index.js

@@ -1,20 +0,0 @@
-"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

@@ -1,28 +0,0 @@
-"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

@@ -1,49 +0,0 @@
-"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

@@ -1,25 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-"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

@@ -1,72 +0,0 @@
-"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

@@ -1,160 +0,0 @@
-# 国际化功能使用说明
-
-## 概述
-
-本项目使用 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

@@ -1,206 +0,0 @@
-/* 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
-}

package/locales/index.js

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