td-web-cli 0.1.0

package/src/api/index.ts

@@ -0,0 +1,188 @@
+import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { normalizeError } from '../utils/index.js';
+
+// GET 请求封装
+export const getData = async <T>(
+  url: string,
+  params: Record<string, unknown> = {},
+  headers: Record<string, string> = {}
+): Promise<T> => {
+  const res = await axios.get<T>(url, { params, headers });
+  return res.data;
+};
+
+// POST 请求封装
+export const postData = async <T, R>(
+  url: string,
+  params: T,
+  headers: Record<string, string> = {}
+): Promise<R> => {
+  const res = await axios.post<T, AxiosResponse<R>>(url, params, {
+    headers,
+  });
+  return res.data;
+};
+
+// 流式传输 POST 请求（带取消功能）
+export const postStream = async <T>(
+  url: string,
+  params: T,
+  headers: Record<string, string> = {},
+  onData: (chunk: string) => void,
+  onError?: (error: Error) => void,
+  onComplete?: () => void,
+  signal?: AbortSignal
+): Promise<void> => {
+  const config: AxiosRequestConfig = {
+    headers,
+    responseType: 'stream',
+    signal, // 添加 AbortSignal 支持
+  };
+
+  try {
+    const response = await axios.post(url, params, config);
+
+    // 处理流数据
+    const stream = response.data;
+    let buffer = '';
+
+    // 监听 abort 事件
+    const onAbort = (): void => {
+      stream.destroy(new Error('请求已中止'));
+    };
+
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    stream.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString();
+
+      // 处理可能的多个消息在一个chunk中
+      const parts = buffer.split('\n');
+      buffer = parts.pop() || ''; // 保留未完成的部分
+
+      parts.forEach((part) => {
+        if (part.trim()) {
+          onData(part.trim());
+        }
+      });
+    });
+
+    stream.on('end', () => {
+      signal?.removeEventListener('abort', onAbort);
+      if (buffer.trim()) {
+        onData(buffer.trim());
+      }
+      onComplete?.();
+    });
+
+    stream.on('error', (err: Error) => {
+      signal?.removeEventListener('abort', onAbort);
+      // 如果是主动取消的请求，不触发 onError
+      if (err.message !== '请求已中止') {
+        onError?.(err);
+      }
+    });
+  } catch (error) {
+    // 如果是取消的请求，不触发 onError
+    if (!axios.isCancel(error)) {
+      onError?.(normalizeError(error));
+    }
+  }
+};
+
+// SSE 传输 POST 请求（带取消功能）
+export const postSSE = async <T>(
+  url: string,
+  params: T,
+  headers: Record<string, string> = {},
+  onMessage: (event: string, data: string) => void,
+  onError?: (error: Error) => void,
+  signal?: AbortSignal
+): Promise<void> => {
+  const config: AxiosRequestConfig = {
+    headers: {
+      ...headers,
+      Accept: 'text/event-stream',
+    },
+    responseType: 'stream',
+    signal, // 添加 AbortSignal 支持
+  };
+
+  try {
+    const response = await axios.post(url, params, config);
+    const stream = response.data;
+    let buffer = '';
+
+    // 监听 abort 事件
+    const onAbort = (): void => {
+      stream.destroy(new Error('请求已中止'));
+    };
+
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    stream.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString();
+
+      // 处理SSE格式（以\n\n分隔的多个事件）
+      const events = buffer.split('\n\n');
+      buffer = events.pop() || '';
+
+      events.forEach((eventStr) => {
+        if (eventStr.trim()) {
+          const event: Record<string, string> = {};
+          eventStr.split('\n').forEach((line) => {
+            const sepIndex = line.indexOf(':');
+            if (sepIndex !== -1) {
+              const key = line.slice(0, sepIndex).trim();
+              // 注意 trimStart 保留 value 中的空格
+              event[key] = line.slice(sepIndex + 1).trimStart();
+            }
+          });
+
+          if (event.event || event.data) {
+            onMessage(event.event || 'message', event.data || '');
+          }
+        }
+      });
+    });
+
+    stream.on('error', (err: Error) => {
+      signal?.removeEventListener('abort', onAbort);
+      // 如果是主动取消的请求，不触发 onError
+      if (err.message !== '请求已中止') {
+        onError?.(err);
+      }
+    });
+
+    stream.on('end', () => {
+      signal?.removeEventListener('abort', onAbort);
+    });
+  } catch (error) {
+    // 如果是取消的请求，不触发 onError
+    if (!axios.isCancel(error)) {
+      onError?.(normalizeError(error));
+    }
+  }
+};
+
+// PUT 请求封装
+export const putData = async <T, R>(
+  url: string,
+  params: T,
+  headers: Record<string, string> = {}
+): Promise<R> => {
+  const res = await axios.put<T, AxiosResponse<R>>(url, params, {
+    headers,
+  });
+  return res.data;
+};
+
+// DELETE 请求封装
+export const deleteData = async <T>(
+  url: string,
+  params: Record<string, unknown> = {},
+  headers: Record<string, string> = {}
+): Promise<T> => {
+  const res = await axios.delete<T>(url, { params, headers });
+  return res.data;
+};

package/src/api/interface.ts

@@ -0,0 +1,6 @@
+const api = {
+  LANGUAGE_TOOL_V2_LANGUAGES: 'https://api.languagetool.org/v2/languages',
+  LANGUAGE_TOOL_V2_CHECK: 'https://api.languagetool.org/v2/check',
+};
+
+export default api;

package/src/config/setting.json

@@ -0,0 +1,47 @@
+{
+  "i18n": {
+    "defaultKey": "en",
+    "langs": {
+      "cn": ["简体中文"],
+      "zh": ["繁体中文"],
+      "en": ["英语"],
+      "it": ["意大利语"],
+      "brpt": ["巴西葡语"],
+      "uk": ["乌克兰语"],
+      "ru": ["俄语"],
+      "es": ["欧洲西语"],
+      "hu": ["匈牙利语"],
+      "pl": ["波兰语"],
+      "tr": ["土耳其语"],
+      "de": ["德语"],
+      "fr": ["法语"],
+      "ro": ["罗马尼亚语"],
+      "ko": ["韩语"],
+      "cs": ["捷克语"],
+      "laes": ["拉美西语"],
+      "pt": ["欧洲葡语"],
+      "nl": ["荷兰语"]
+    },
+    "longCodes": {
+      "cn": "zh-CN",
+      "zh": "zh-TW",
+      "en": "en-US",
+      "it": "it-IT",
+      "brpt": "pt-BR",
+      "uk": "uk-UA",
+      "ru": "ru-RU",
+      "es": "es-ES",
+      "hu": "hu-HU",
+      "pl": "pl-PL",
+      "tr": "tr-TR",
+      "de": "de-DE",
+      "fr": "fr-FR",
+      "ro": "ro-RO",
+      "ko": "ko-KR",
+      "cs": "cs-CZ",
+      "laes": "es-MX",
+      "pt": "pt-PT",
+      "nl": "nl-NL"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * CLI入口脚本
+ * 通过交互式选择执行不同模块功能
+ */
+
+import { Command } from 'commander';
+import { select, Separator } from '@inquirer/prompts';
+import { i18n } from './modules/i18n/index.js';
+import { logger, loggerError } from './utils/index.js';
+
+const program = new Command();
+
+/**
+ * 主程序入口函数
+ * 解析命令行参数，交互式选择模块并执行对应功能
+ */
+async function main() {
+  try {
+    logger.info('td-web-cli程序启动');
+
+    // 解析命令行参数
+    program.parse(process.argv);
+    logger.info(`命令行参数解析完成：${process.argv.slice(2).join(' ')}`);
+
+    // 定义可用模块选项
+    const moduleChoices = [
+      {
+        name: '国际化',
+        value: 'i18n',
+        description: '国际化相关功能',
+      },
+    ];
+
+    // 交互式选择模块
+    const answer = await select({
+      message: '请选择要执行的模块：',
+      choices: [
+        ...moduleChoices,
+        new Separator(), // 分割线，便于未来扩展更多模块
+      ],
+      default: 'i18n', // 默认选项
+      pageSize: 10, // 最大显示选项数
+      loop: true, // 选项循环滚动
+    });
+
+    // 查找选择模块的名称，方便日志输出
+    const selectedModule = moduleChoices.find((item) => item.value === answer);
+
+    if (!selectedModule) {
+      logger.warn('未选择有效模块，程序已退出');
+      process.exit(0);
+    }
+
+    logger.info(`用户选择模块：${selectedModule.name}`);
+
+    // 根据选择执行对应模块
+    switch (answer) {
+      case 'i18n':
+        logger.info(`${selectedModule.name}模块开始执行`);
+        await i18n(program);
+        logger.info(`${selectedModule.name}模块执行完成`);
+        break;
+      default:
+        logger.warn(`${selectedModule.name}模块暂未实现，程序已退出`);
+        process.exit(0);
+    }
+  } catch (error: unknown) {
+    // 记录错误日志，方便排查
+    loggerError(error, logger);
+    console.error('程序执行时发生异常，已记录日志，程序已退出');
+    process.exit(1);
+  }
+}
+
+// 启动主程序
+main();

package/src/modules/i18n/excel2json/index.ts

@@ -0,0 +1,380 @@
+import { Command } from 'commander';
+import { input } from '@inquirer/prompts';
+import XLSX from 'xlsx';
+import fs from 'fs';
+import path from 'path';
+import {
+  getTimestamp,
+  logger,
+  loggerError,
+  normalizeError,
+  CheckResult,
+  languageToolCheck,
+  getLanguageTool,
+} from '../../../utils/index.js';
+
+type Row = (string | number | null | undefined)[];
+
+/**
+ * 国际化配置类型定义
+ * defaultKey: 默认语言key
+ * langs: 语言映射，key为语言标识，value为语言名称数组（支持多名称匹配）
+ * longCodes: 语言长代码映射，key为语言标识，value为语言长代码
+ */
+interface I18nConfig {
+  defaultKey: string;
+  langs: Record<string, string[]>;
+  longCodes: Record<string, string>;
+}
+
+/**
+ * 读取并解析配置文件
+ * @param configPath 配置文件路径
+ * @returns I18nConfig 配置对象
+ * @throws 配置文件不存在或格式错误时抛出异常
+ */
+function loadConfig(configPath: string): I18nConfig {
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`配置文件不存在：${configPath}`);
+  }
+  const content = fs.readFileSync(configPath, { encoding: 'utf-8' });
+  const json = JSON.parse(content);
+  if (!json.i18n) {
+    throw new Error('配置文件格式错误，缺少i18n');
+  }
+  if (!json.i18n.defaultKey) {
+    throw new Error('配置文件格式错误，缺少i18n.defaultKey');
+  }
+  if (!json.i18n.langs) {
+    throw new Error('配置文件格式错误，缺少i18n.langs');
+  }
+  if (!json.i18n.longCodes) {
+    throw new Error('配置文件格式错误，缺少i18n.longCodes');
+  }
+  return json.i18n;
+}
+
+/**
+ * 匹配excel表头列名对应的语言key，支持大小写不敏感匹配
+ * 先匹配语言key本身，再匹配语言名称数组（包含关系）
+ * @param colName 表头列名
+ * @param langs 语言映射
+ * @returns 匹配到的语言key，未匹配返回null
+ */
+function matchLangKey(
+  colName: string,
+  langs: Record<string, string[]>
+): string | null {
+  if (!colName) return null;
+  const colNameLower = colName.toLowerCase();
+
+  // 先尝试匹配语言key
+  for (const langKey of Object.keys(langs)) {
+    if (langKey.toLowerCase() === colNameLower) {
+      return langKey;
+    }
+  }
+
+  // 再尝试匹配语言名称（包含关系）
+  for (const [langKey, names] of Object.entries(langs)) {
+    if (
+      names.some((name) => name && colNameLower.includes(name.toLowerCase()))
+    ) {
+      return langKey;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 去除字符串首尾的单引号或双引号
+ * @param str 输入字符串
+ * @returns 去除引号后的字符串
+ */
+function trimQuotes(str: string): string {
+  if (
+    (str.startsWith('"') && str.endsWith('"')) ||
+    (str.startsWith("'") && str.endsWith("'"))
+  ) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+
+/**
+ * 批量检测词条文本，返回所有检测结果
+ * @param texts 词条数组
+ * @param language 语言代码
+ * @returns 检测结果数组，顺序对应输入texts
+ *
+ * 说明：
+ * 这里将所有词条用换行符拼接成一个字符串，一次性调用语言检测接口，
+ * 以减少请求次数和提升性能。
+ * 返回结果数组中只包含一个元素，即合并检测的结果。
+ */
+async function batchCheckTexts(
+  texts: string[],
+  language: string
+): Promise<(CheckResult | null)[]> {
+  const results: (CheckResult | null)[] = [];
+  try {
+    // 将词条用换行符拼接，避免词条间干扰，推荐换行分隔
+    const joinedText = texts.join('\n');
+    const res = await languageToolCheck(joinedText, language);
+    results.push(res);
+  } catch (error) {
+    loggerError(error, logger);
+    results.push(null);
+  }
+  return results;
+}
+
+/**
+ * excel转json功能主函数
+ * 读取用户输入的excel路径，解析内容，根据配置生成多语言json文件
+ * 并对配置文件中所有语言对应的词条进行语言检测
+ * @param program Commander命令行实例
+ */
+export async function excel2json(program: Command) {
+  // 配置文件默认路径
+  const configPath = path.join(process.cwd(), 'src/config/setting.json');
+  let i18nConfig: I18nConfig;
+
+  // 加载配置文件
+  try {
+    logger.info(`开始加载配置文件：${configPath}`);
+    i18nConfig = loadConfig(configPath);
+    logger.info('配置文件加载成功');
+  } catch (error: unknown) {
+    const msg = `读取配置文件失败：${normalizeError(error).stack}，程序已退出`;
+    logger.error(msg);
+    console.error('程序执行时发生异常，已记录日志，程序已退出');
+    process.exit(1);
+  }
+
+  // 尝试调用接口获取支持的语言列表，更新 longCodes
+  try {
+    logger.info('尝试获取在线支持的语言列表...');
+    const languageTools = await getLanguageTool();
+    logger.info(`成功获取语言列表，覆盖配置文件中的 longCodes`);
+
+    // 构建新的 longCodes 映射
+    const newLongCodes: Record<string, string> = {};
+    // 语言标识对应语言名称列表，方便匹配
+    const langNameToKey: Record<string, string> = {};
+    for (const [key, names] of Object.entries(i18nConfig.langs)) {
+      names.forEach((name) => {
+        langNameToKey[name.toLowerCase()] = key;
+      });
+    }
+
+    for (const lang of languageTools) {
+      // 尝试根据语言名称匹配配置中的语言key
+      const lowerName = lang.name.toLowerCase();
+      const matchedKey =
+        langNameToKey[lowerName] ||
+        Object.keys(i18nConfig.langs).find(
+          (k) => k.toLowerCase() === lowerName
+        );
+      if (matchedKey) {
+        newLongCodes[matchedKey] = lang.longCode;
+      }
+    }
+
+    // 替换旧的 longCodes，保留未匹配的旧值
+    i18nConfig.longCodes = { ...i18nConfig.longCodes, ...newLongCodes };
+  } catch (error) {
+    logger.warn(
+      `获取在线语言列表失败，使用本地配置 longCodes，错误：${normalizeError(error).stack}`
+    );
+  }
+
+  // 交互式输入excel文件路径并校验
+  const answer = await input({
+    message: '请输入excel文件路径：',
+    validate: (value) => {
+      const cleaned = value.trim().replace(/^['"]|['"]$/g, '');
+      if (cleaned.length === 0) return '路径不能为空';
+      if (!fs.existsSync(cleaned)) return '文件不存在，请输入有效路径';
+      if (!/\.(xls|xlsx)$/i.test(cleaned))
+        return '请输入有效的excel文件路径（.xls或.xlsx）';
+      return true;
+    },
+  });
+
+  // 规范化路径，支持相对路径转绝对路径，去除首尾引号
+  const excelPath = path.resolve(
+    process.cwd(),
+    answer.trim().replace(/^['"]|['"]$/g, '')
+  );
+
+  try {
+    logger.info(`开始读取excel文件：${excelPath}`);
+
+    // 读取excel文件
+    const workbook = XLSX.readFile(excelPath);
+    const firstSheetName = workbook.SheetNames[0];
+    if (!firstSheetName) {
+      logger.error('excel文件没有任何工作表，程序已退出');
+      console.error('程序执行时发生异常，已记录日志，程序已退出');
+      process.exit(1);
+    }
+
+    // 读取第一个工作表的数据，按行读取，header=1表示返回二维数组
+    const sheet = workbook.Sheets[firstSheetName];
+    const rows: Row[] = XLSX.utils.sheet_to_json(sheet, { header: 1 });
+
+    if (rows.length < 2) {
+      logger.error('工作表数据不足，至少需要两行（表头+数据），程序已退出');
+      console.error('程序执行时发生异常，已记录日志，程序已退出');
+      process.exit(1);
+    }
+
+    logger.info('开始解析表头');
+    // 处理表头行，去除空格，转成字符串
+    const headerRow = rows[0].map((cell) => (cell ? String(cell).trim() : ''));
+
+    // 根据表头匹配语言列，建立列索引到语言key的映射
+    const colIndexToLangKey: Record<number, string> = {};
+    headerRow.forEach((colName, idx) => {
+      const langKey = matchLangKey(colName, i18nConfig.langs);
+      if (langKey) {
+        colIndexToLangKey[idx] = langKey;
+      }
+    });
+
+    // 获取默认语言列索引
+    const defaultLang = i18nConfig.defaultKey;
+    const defaultColIndex = Object.entries(colIndexToLangKey).find(
+      ([, langKey]) => langKey === defaultLang
+    )?.[0];
+
+    if (defaultColIndex === undefined) {
+      logger.error(`找不到默认语言列：${defaultLang}，程序已退出`);
+      console.error('程序执行时发生异常，已记录日志，程序已退出');
+      process.exit(1);
+    }
+    const defaultColNum = Number(defaultColIndex);
+
+    // 初始化所有语言词条对象（包括默认语言）
+    const langTranslations: Record<string, Record<string, string>> = {};
+    Object.values(colIndexToLangKey).forEach((langKey) => {
+      langTranslations[langKey] = {};
+    });
+
+    logger.info('开始解析数据行');
+    // 遍历数据行，提取所有语言词条
+    // key统一用默认语言列的值，其他语言对应的列为翻译内容
+    const langKeysMap: Record<string, string[]> = {}; // 语言key => 词条数组
+    Object.keys(langTranslations).forEach((langKey) => {
+      langKeysMap[langKey] = [];
+    });
+
+    for (let i = 1; i < rows.length; i++) {
+      const row = rows[i];
+      const keyCell = row[defaultColNum];
+      if (keyCell === undefined || keyCell === null || keyCell === '') continue;
+
+      let key = String(keyCell).trim();
+      key = trimQuotes(key); // 去除引号
+
+      // 跳过空key，避免写入无效数据
+      if (key.length === 0) continue;
+
+      // 默认语言的词条即key本身
+      langTranslations[defaultLang][key] = key;
+      langKeysMap[defaultLang].push(key);
+
+      // 其他语言词条
+      for (const [colIdxStr, langKey] of Object.entries(colIndexToLangKey)) {
+        const colIdx = Number(colIdxStr);
+        if (langKey === defaultLang) continue;
+        const valCell = row[colIdx];
+        if (valCell !== undefined && valCell !== null && valCell !== '') {
+          const valStr = String(valCell);
+          langTranslations[langKey][key] = valStr;
+          langKeysMap[langKey].push(valStr);
+        }
+      }
+    }
+
+    // 对所有语言词条批量进行语言检测（包括默认语言）
+    for (const [langKey, texts] of Object.entries(langKeysMap)) {
+      const longCode = i18nConfig.longCodes[langKey];
+      if (!longCode) {
+        logger.warn(`语言(${langKey})未配置 longCode，跳过检测`);
+        continue;
+      }
+      if (texts.length === 0) {
+        logger.info(`语言(${langKey})无词条，跳过检测`);
+        continue;
+      }
+
+      logger.info(
+        `开始对语言(${langKey})词条进行语言检测，词条数量：${texts.length}`
+      );
+
+      const checkResults = await batchCheckTexts(texts, longCode);
+
+      if (!checkResults || checkResults.length === 0 || !checkResults[0]) {
+        logger.error(`语言(${langKey})词条检测失败`);
+        continue;
+      }
+
+      const result = checkResults[0];
+      if (result.matches.length === 0) {
+        logger.info(`语言(${langKey})词条检测无错误`);
+      } else {
+        logger.info(
+          `语言(${langKey})词条检测发现问题，词条数量: ${result.matches.length}`
+        );
+        for (const match of result.matches) {
+          logger.info(
+            `- 错误: ${match.message}\n  出错句子: ${match.sentence}\n  建议替换: ${match.replacements
+              .map((r) => r.value)
+              .join(', ')}`
+          );
+        }
+      }
+    }
+
+    // 输出目录：excel文件所在目录下的“lang_时间戳”文件夹
+    const excelDir = path.dirname(excelPath);
+    const timestamp = getTimestamp();
+    const outputRoot = path.join(excelDir, `lang_${timestamp}`);
+    if (!fs.existsSync(outputRoot)) {
+      fs.mkdirSync(outputRoot, { recursive: true });
+    }
+
+    logger.info(`开始生成语言文件，输出目录：${outputRoot}`);
+
+    // 按语言生成对应的json文件，默认语言的key=value不生成文件
+    for (const [langKey, translations] of Object.entries(langTranslations)) {
+      if (Object.keys(translations).length === 0) continue;
+
+      if (langKey === defaultLang) {
+        logger.info(`跳过默认语言(${langKey})的json文件生成`);
+        continue; // 跳过默认语言文件生成
+      }
+
+      const langDir = path.join(outputRoot, langKey);
+      if (!fs.existsSync(langDir)) {
+        fs.mkdirSync(langDir, { recursive: true });
+      }
+
+      const filePath = path.join(langDir, 'translate.json');
+      fs.writeFileSync(filePath, JSON.stringify(translations, null, 2), {
+        encoding: 'utf-8',
+      });
+      logger.info(`已生成语言文件：${filePath}`);
+    }
+
+    logger.info('全部转换完成', true);
+  } catch (error: unknown) {
+    // 记录错误日志，方便排查
+    loggerError(error, logger);
+    console.error('程序执行时发生异常，已记录日志，程序已退出');
+    process.exit(1);
+  }
+}

package/src/modules/i18n/extractEntry/index.ts

@@ -0,0 +1,3 @@
+export function run() {
+  console.log('提取词条');
+}