td-octopus 0.0.1

package/README.md

@@ -0,0 +1,66 @@
+# octopus
+====
+
+## 安装
+
+```
+
+npm install td-octopus -g
+
+```
+
+## 使用
+
+```
+otp <cmd> [-args]
+
+命令：
+  otp extract [dirPath] [prefix]  extract [dirPath] [prefix]
+                                  一键批量替换指定文件夹下的所有文案
+  otp import [langs]              import [langs]
+                                  将excel中人工翻译的部分替换未翻译的key
+  otp init                        init 初始化配置文件
+  otp translate                   translate 通过对比zh-CN目录,获取各语言未翻译的
+                                  部分,并生成excel文件
+
+选项：
+  -v, --version  显示版本号                                               [布尔]
+  -h, --help     显示帮助信息                                             [布尔]
+
+copyright 2022 同盾
+
+```
+
+## otp-config.json 说明
+
+```
+{
+  "otpDir": "./.octopus", // 语言包目录
+  "proType": "react", // 项目类型
+  "srcLang": "zh-CN", // 提取中文目录
+  "distLangs": [ "en-US", "zh-TW" ], // 需要转换的语言
+  "googleApiKey": "", // google翻译 这期没做
+  "baiduApiKey": { "appId": "", "appKey": "" }, // 百度翻译 这期没做
+  "baiduLangMap": { "en-US": "en" }, // 百度翻译 这期没做
+  "translateOptions": { "concurrentLimit": 10, "requestOptions": {} }, // google翻译 这期没做
+  "fileSuffix": [".ts", ".js", ".vue", ".jsx", ".tsx"], // 支持符合JS语法的后缀名
+  "defaultTranslateKeyApi": "Pinyin", // 默认生成的JSON key 使用拼音前5个
+  "importI18N": "import I18N from 'src/utils/I18N';",
+  "include": [], // 需要翻译的目录&也可以命令行输入参数
+  "exclude": [] // 过滤目录&文件
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/bin/main.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const checkUpdate = require('../src/lib/update');
+
+const curTime = new Date();
+const year = curTime.getFullYear();
+
+checkUpdate()
+
+const pkg = require('../package');
+const argv = require('yargs')
+    .usage('$0 <cmd> [-args]')
+    .commandDir('../cmds')
+    .demand(1)
+    .version(pkg.version)
+    .alias('v', 'version')
+    .help()
+    .alias('h', 'help')
+    .epilog(`copyright ${year} 同盾`)
+    .argv;

package/cmds/extract.js

@@ -0,0 +1,23 @@
+const fs = require('fs');
+const { isString } = require('lodash');
+const { extractAll } = require('../src/extract/extract');
+
+exports.command = 'extract [dirPath] [prefix]';
+
+exports.describe = 'extract [dirPath] [prefix] 一键批量替换指定文件夹下的所有文案';
+
+exports.handler = async (argv) => {
+    if (argv.prefix) {
+        console.log('请指定翻译后文案 key 值的前缀 extract src xxx');
+    }
+    if (isString(argv.prefix) && !new RegExp(/^([-_a-zA-Z1-9$]+)+$/).test(argv.prefix)) {
+        console.log('字母、下滑线、破折号、$ 字符组成的变量名');
+    } else {
+        const extractAllParams = {
+            prefix: isString(argv.prefix) && argv.prefix,
+            dirPath: isString(argv.dirPath) && argv.dirPath,
+        };
+
+        extractAll(extractAllParams);
+    }
+}

package/cmds/import.js

@@ -0,0 +1,9 @@
+const { excel } = require('../src/import');
+
+exports.command = 'import [langs]';
+
+exports.describe = 'import [langs] 将excel中人工翻译的部分替换未翻译的key';
+
+exports.handler = (args) => {
+    excel(args.langs)
+}

package/cmds/init.js

@@ -0,0 +1,22 @@
+const { initProject } = require('../src/init');
+const inquirer = require('inquirer');
+const { spining } = require('../src/utils')
+
+exports.command = 'init';
+
+exports.describe = 'init 初始化配置文件';
+
+exports.handler = async () => {
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'type',
+            message: '请选择项目类型',
+            choices: ['react', 'vue', 'typescript'],
+            default: 'react'
+        }
+    ]);
+    spining('初始化项目', async () => {
+        initProject(answers);
+    });
+}

package/cmds/translate.js

@@ -0,0 +1,9 @@
+const { translate } = require('../src/translate');
+
+exports.command = 'translate';
+
+exports.describe = 'translate 通过对比zh-CN目录,获取各语言未翻译的部分,并生成excel文件';
+
+exports.handler = () => {
+    translate()
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "td-octopus",
+  "version": "0.0.1",
+  "description": "I18N tool",
+  "author": "Anthony Li",
+  "bin": {
+    "otp": "bin/main.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@babel/core": "^7.18.2",
+    "baidu-translate": "^1.1.0",
+    "colors": "^1.4.0",
+    "glob": "^8.0.3",
+    "google-translate": "^3.0.0",
+    "inquirer": "^8.2.4",
+    "lodash": "^4.17.11",
+    "ora": "^5.4.1",
+    "pinyin-pro": "^3.3.1",
+    "prettier": "^2.7.1",
+    "shelljs": "^0.8.5",
+    "slash2": "^2.0.0",
+    "ts-node": "^10.8.1",
+    "typescript": "^3.2.2",
+    "update-notifier": "^4.1.0",
+    "vue-template-compiler": "^2.6.14",
+    "xlsx": "^0.18.5",
+    "yargs": "^15.3.1"
+  },
+  "keywords": [
+    "I18N",
+    "tool"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:TDFE/octopus.git"
+  }
+}

package/src/extract/extract.js

@@ -0,0 +1,332 @@
+const slash = require('slash2');
+const _ = require('lodash');
+const path = require('path');
+
+const { getSpecifiedFiles, readFile, writeFile, isFile, isDirectory } = require('./file');
+const { translateText, findMatchKey, findMatchValue,  translateKeyText,  getProjectConfig } = require('../utils');
+const { successInfo, failInfo, highlightText } = require('../utils/colors');
+const { findChineseText } = require('./findChineseText');
+const { getSuggestLangObj } = require('./getLangData');
+
+const { replaceAndUpdate, hasImportI18N, createImportI18N } = require('./replace');
+
+const CONFIG = getProjectConfig();
+
+function formatExclude(exclude){
+  return (exclude || []).map(p => path.resolve(process.cwd(), p));
+}
+
+function removeLangsFiles(files) {
+  const langsDir = path.resolve(process.cwd(), CONFIG.otpDir);
+  return files.filter(file => {
+    const completeFile = path.resolve(process.cwd(), file);
+    return !completeFile.includes(langsDir);
+  });
+}
+
+/**
+ * 递归匹配项目中所有的代码的中文
+ */
+function findAllChineseText(dir) {
+  const first = dir.split(',')[0];
+
+  let files = [];
+  if (isDirectory(first)) {
+    const dirPath = path.resolve(process.cwd(), dir);
+    files = getSpecifiedFiles(dirPath, formatExclude(CONFIG.exclude));
+  } else {
+    files = removeLangsFiles(dir.split(','));
+  }
+  const filterFiles = files.filter(file => {
+    let flag = false;
+    for (let index = 0; index < CONFIG.fileSuffix.length; index++) {
+      const element = CONFIG.fileSuffix[index];
+      flag  = file.endsWith(element);
+      if (flag) {
+        break;
+      }
+    }
+    return (isFile(file) && flag);
+  });
+  const allTexts = filterFiles.reduce((pre, file) => {
+    const code = readFile(file);
+    const texts = findChineseText(code, file);
+    // 调整文案顺序，保证从后面的文案往前替换，避免位置更新导致替换出错
+    const sortTexts = _.sortBy(texts, obj => -obj.range.start);
+    if (texts.length > 0) {
+      console.log(`${highlightText(file)} 发现 ${highlightText(texts.length)} 处中文文案`);
+    }
+
+    return texts.length > 0 ? pre.concat({ file, texts: sortTexts }) : pre;
+  }, []);
+
+  return allTexts;
+}
+
+/**
+ * 处理作为key值的翻译原文
+ */
+function getTransOriginText(text) {
+  // 避免翻译的字符里包含数字或者特殊字符等情况，只过滤出汉字和字母
+  const reg = /[a-zA-Z\u4e00-\u9fa5]+/g;
+  const findText = text.match(reg) || [];
+  const transOriginText = findText ? findText.join('').slice(0, 5) : '中文符号';
+
+  return transOriginText;
+}
+
+/**
+ * @param currentFilename 文件路径
+ * @returns string[]
+ */
+function getSuggestion(currentFilename) {
+  let suggestion = [];
+  const suggestPageRegex = /\/pages\/\w+\/([^\/]+)\/([^\/\.]+)/;
+
+  if (currentFilename.includes('/pages/')) {
+    suggestion = currentFilename.match(suggestPageRegex);
+  }
+  if (suggestion) {
+    suggestion.shift();
+  }
+  /** 如果没有匹配到 Key */
+  if (!(suggestion && suggestion.length)) {
+    const names = slash(currentFilename).split('/');
+    const fileName = _.last(names);
+    let fileKey = fileName.split('.')[0].replace(new RegExp('-', 'g'), '_');
+    let dir = names[names.length - 2].replace(new RegExp('-', 'g'), '_');
+    if (dir === fileKey) {
+      suggestion = [dir];
+    } else {
+      suggestion = [dir, fileKey];
+    }
+  }
+
+  return suggestion;
+}
+
+/**
+ * 统一处理key值，已提取过的文案直接替换，翻译后的key若相同，加上出现次数
+ * @param currentFilename 文件路径
+ * @param langsPrefix 替换后的前缀
+ * @param translateTexts 翻译后的key值
+ * @param targetStrs 当前文件提取后的文案
+ * @returns any[] 最终可用于替换的key值和文案
+ */
+function getReplaceableStrs(currentFilename, langsPrefix, translateTexts, targetStrs) {
+  const finalLangObj = getSuggestLangObj();
+  const virtualMemory = {};
+  const suggestion = getSuggestion(currentFilename);
+
+  const replaceableStrs = targetStrs.reduce((prev, curr, i) => {
+    const key = findMatchKey(finalLangObj, curr.text);
+    if (!virtualMemory[curr.text]) {
+      if (key) {
+        virtualMemory[curr.text] = key;
+        return prev.concat({
+          fileName:currentFilename,
+          target: curr,
+          key,
+          targetStrs,
+          needWrite: false
+        });
+      }
+      const transText = translateTexts[i] && _.camelCase(translateTexts[i]);
+      let suffix = suggestion.length ? suggestion.join('.') + '.' : '';
+      suffix = suffix.toLocaleLowerCase();
+      let transKey = `${suffix}${transText}`;
+      if (langsPrefix) {
+        transKey = `${langsPrefix}.${transText}`;
+      }
+      let occurTime = 1;
+      // 防止出现前四位相同但是整体文案不同的情况
+      while (
+        findMatchValue(finalLangObj, transKey) !== curr.text &&
+        _.keys(finalLangObj).includes(`${transKey}${occurTime >= 2 ? occurTime : ''}`)
+      ) {
+        occurTime++;
+      }
+      if (occurTime >= 2) {
+        transKey = `${transKey}${occurTime}`;
+      }
+      virtualMemory[curr.text] = transKey;
+      finalLangObj[transKey] = curr.text;
+      return prev.concat({
+        fileName:currentFilename,
+        target: curr,
+        key: transKey,
+        targetStrs,
+        needWrite: true
+      });
+    } else {
+      return prev.concat({
+        fileName:currentFilename,
+        target: curr,
+        key: virtualMemory[curr.text],
+        targetStrs,
+        needWrite: true
+      });
+    }
+  }, []);
+
+  return replaceableStrs;
+}
+
+/**
+ * 递归匹配项目中所有的代码的中文
+ * @param {dirPath} 文件夹路径
+ */
+function extractAll({ dirPath, prefix }) {
+    const searchErrorMsg=[]; // 检索失败
+    const extractAction = []; // 执行翻译行为
+    const proType = CONFIG.proType;
+    const dirArr = dirPath ? [dirPath] : CONFIG.include && CONFIG.include.length > 0 ? CONFIG.include : ['./'];
+    // 去除I18N
+    const langsPrefix = prefix ? prefix : null;
+    // 翻译源配置错误，则终止
+    const origin = CONFIG.defaultTranslateKeyApi || 'Pinyin';
+    if (!['Pinyin', 'Google', 'Baidu'].includes(CONFIG.defaultTranslateKeyApi)) {
+        console.log(
+        `opt 仅支持 ${highlightText('Pinyin、Google、Baidu')}，请修改 ${highlightText('defaultTranslateKeyApi')} 配置项`
+        );
+        return;
+    }
+
+    const allTargetStrs = _.flatten(dirArr.map(findAllChineseText));
+    if (allTargetStrs.length === 0) {
+        console.log(highlightText('没有发现可替换的文案！'));
+        return;
+    }
+
+    // 对当前文件进行文案检索
+    const generateSearch = async (item, proType) => {
+        const currentFilename = item.file;
+
+        // 过滤掉模板字符串内的中文，避免替换时出现异常
+        const targetStrs = item.texts.reduce((pre, strObj, i) => {
+            // 因为文案已经根据位置倒排，所以比较时只需要比较剩下的文案即可
+            const afterStrs = item.texts.slice(i + 1);
+            if (afterStrs.some(obj => strObj.range.end <= obj.range.end)) {
+                return pre;
+            }
+            return pre.concat(strObj);
+        }, []);
+
+        const len = item.texts.length - targetStrs.length;
+        if (len > 0) {
+            searchErrorMsg.push(`${currentFilename}中存在 ${highlightText(len)} 处文案，请避免在模板字符串的变量中嵌套中文`);
+            return;
+        }
+
+        let translateTexts;
+
+        if (origin !== 'Google') {
+            // 翻译中文文案，百度和pinyin将文案进行拼接统一翻译
+            const delimiter = origin === 'Baidu' ? '\n' : '$';
+            const translateOriginTexts = targetStrs.reduce((prev, curr, i) => {
+                const transOriginText = getTransOriginText(curr.text);
+                if (i === 0) {
+                return transOriginText;
+                }
+                return `${prev}${delimiter}${transOriginText}`;
+            }, []);
+
+            translateTexts = await translateKeyText(translateOriginTexts, origin);
+        } else {
+            // google并发性较好，且未找到有效的分隔符，故仍然逐个文案进行翻译
+            const translatePromises = targetStrs.reduce((prev, curr) => {
+                const transOriginText = getTransOriginText(curr.text);
+                return prev.concat(translateText(transOriginText, 'en_US'));
+            }, []);
+
+            [...translateTexts] = await Promise.all(translatePromises);
+        }
+
+        if (translateTexts.length === 0) {
+            failInfo(`${currentFilename}未得到翻译结果！`);
+            return;
+        }
+
+        // 记录替换对象
+        const replaceableStrs = getReplaceableStrs(currentFilename, langsPrefix, translateTexts, targetStrs);
+        extractAction.push(replaceableStrs);
+    };
+
+    // 对文件进行替换
+    const generateReplace = async (item, proType) => {
+        let [currentFilename,targetStrs]=[,];
+        await item
+        .reduce((prev, obj) => {
+            return prev.then(() => {
+                currentFilename = obj.fileName;
+                targetStrs = obj.targetStrs;
+                console.log(`${currentFilename} 替换中...`);
+                return replaceAndUpdate(currentFilename, obj.target, `I18N.${obj.key}`, false, obj.needWrite, proType);
+            });
+        }, Promise.resolve())
+        .then(() => {
+            // 添加 import I18N
+            if (!hasImportI18N(currentFilename)) {
+                const code = createImportI18N(currentFilename);
+                writeFile(currentFilename, code);
+            }
+            successInfo(`${currentFilename} 替换完成，共替换 ${targetStrs.length} 处文案！`);
+        })
+        .catch(e => {
+            failInfo(e.message);
+        });
+    };
+
+    new Promise((resolve)=>{
+        allTargetStrs
+        .reduce((prev, current) => {
+            return prev.then(() => {
+                return generateSearch(current, proType);
+            });
+        }, Promise.resolve())
+        .then(() => {
+            successInfo('📢 📢 📢 📢 检索完成！');
+            // 如果全部检索成功则进行翻译
+            if(!searchErrorMsg?.length){
+                resolve();
+            }else{
+                failInfo("--------------------------------");
+                failInfo("但存在以下文件检索失败：");
+                failInfo("--------------------------------");
+                searchErrorMsg?.forEach(msg=>{
+                    failInfo(msg||"替换失败");
+                })
+            }
+        }).catch(e=>{
+            failInfo(e||"替换失败");
+        });
+    }).then(()=>{
+        // 开始替换
+        // 提示翻译源
+        if (CONFIG.defaultTranslateKeyApi === 'Pinyin') {
+            console.log(
+            `当前使用 ${highlightText('Pinyin')} 作为key值的翻译源，若想得到更好的体验，可配置 ${highlightText(
+                'googleApiKey'
+            )} 或 ${highlightText('baiduApiKey')}，并切换 ${highlightText('defaultTranslateKeyApi')}`
+            );
+        } else {
+            console.log(`当前使用 ${highlightText(CONFIG.defaultTranslateKeyApi)} 作为key值的翻译源`);
+        }
+
+        console.log('即将截取每个中文文案的前5位翻译生成key值，并替换中...');
+
+        extractAction.reduce((prev,current)=>{
+            return prev.then(() => {
+                return generateReplace(current, proType);
+            });
+        }, Promise.resolve())
+        .then(() => {
+            successInfo('替换完成！');
+        }).catch(e=>{
+            failInfo(e||"替换成功");
+        });
+    })
+
+}
+
+module.exports = { extractAll };

package/src/extract/file.js

@@ -0,0 +1,64 @@
+ const fs = require('fs');
+ const path = require('path');
+ const _ = require('lodash');
+
+/**
+ * 获取文件夹下符合要求的所有文件
+ * @function getSpecifiedFiles
+ * @param  {string} dir 路径
+ * @param {exclude} 忽略文件夹或文件
+ */
+function getSpecifiedFiles(dir, exclude = []) {
+  return fs.readdirSync(dir).reduce((files, file) => {
+    const name = path.join(dir, file);
+    const isDirectory = fs.statSync(name).isDirectory();
+    const isFile = fs.statSync(name).isFile();
+
+    if (isDirectory) {
+      return files.concat(getSpecifiedFiles(name, exclude));
+    }
+
+    if (isFile && !_.find(exclude, p=>name.includes(p))) {
+      return files.concat(name);
+    }
+    return files;
+  }, []);
+}
+
+/**
+ * 读取文件
+ * @param fileName
+ */
+function readFile(fileName) {
+  if (fs.existsSync(fileName)) {
+    return fs.readFileSync(fileName, 'utf-8');
+  }
+}
+
+/**
+ * 读取文件
+ * @param fileName
+ */
+function writeFile(filePath, file) {
+  if (fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, file);
+  }
+}
+
+/**
+ * 判断是文件
+ * @param path
+ */
+function isFile(path) {
+  return fs.statSync(path).isFile();
+}
+
+/**
+ * 判断是文件夹
+ * @param path
+ */
+function isDirectory(path) {
+  return fs.statSync(path).isDirectory();
+}
+
+module.exports = { getSpecifiedFiles, readFile, writeFile, isFile, isDirectory };