ztxkutils 10.0.11 → 20.0.2

package/zti18n-cli/index.js

@@ -0,0 +1,23 @@
+const program = require('./src');
+const initFileConf = require('./src/command/initFileConf');
+
+program
+  .command('init')
+  .alias('i')
+  .description('init locales conf')
+  .option('--vue', 'init for vue project')
+  .action(function (options) {
+    initFileConf(options.vue);
+  })
+  .on('--help', function () {
+    console.log('  Examples:');
+    console.log();
+    console.log('    $ zti18n init -c ./config/prod.config.js');
+    console.log();
+  });
+
+program.command('*').action(function (cmd) {
+  console.log('unknown command "%s"', cmd);
+});
+
+program.parse(process.argv);

package/zti18n-cli/src/command/collect.js

@@ -0,0 +1,353 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const { transformZeroToDi18n } = require('../../../zti18n-core');
+const mergeOptions = require('../utils/mergeOptions');
+const isChinese = require('../utils/isChinese');
+const log = require('../utils/log');
+
+function getSourceFiles({ entry, exclude }) {
+  return glob.sync(`${entry}/**/*.{js,ts,tsx,jsx,vue}`, {
+    ignore: exclude || [],
+  });
+}
+
+/**
+ * 同步一个非中文语言的配置
+ */
+async function syncOneNonChineseLocalesConf(
+  key,
+  option,
+  chineseLocales,
+  updatedTranslatedWord,
+  publish,
+  confService
+) {
+  const confName = key;
+  const { disableAutoTranslate, translator, appid, privatekey } = option;
+
+  const translate = translator
+    ? require(path.join(process.cwd(), translator))
+    : require('../translate/google');
+
+  log.warning(`start to update conf ${confName}`);
+
+  const res = await confService.getConf(confName, key);
+
+  if (res.code !== 0) {
+    log.error(`! failed to read apollo conf, ${res.message}`);
+    return null;
+  }
+
+  const allKeys = Object.keys(chineseLocales);
+  let mergedLocales = {};
+
+  res.data.forEach((item) => {
+    if (updatedTranslatedWord.hasOwnProperty(item.key)) {
+      mergedLocales[updatedTranslatedWord[item.key]] = item.value;
+    } else if (allKeys.indexOf(item.key) >= 0) {
+      mergedLocales[item.key] = item.value;
+    }
+  });
+
+  mergedLocales = { ...chineseLocales, ...mergedLocales };
+
+  const translateTasks = [];
+
+  Object.keys(mergedLocales).forEach((k) => {
+    const text = mergedLocales[k];
+    let targetLang = key.split(/_|-/)[0];
+    if (isChinese(text)) {
+      if (disableAutoTranslate || !appid || !privatekey) {
+        mergedLocales[k] = text;
+      } else {
+        translateTasks.push([k, targetLang]);
+      }
+    }
+  });
+
+  const total = translateTasks.length;
+
+  // 控制并发数
+  const concurrenceCount = 3;
+
+  while (translateTasks.length > 0) {
+    const tasks = translateTasks.splice(0, concurrenceCount);
+
+    await Promise.all(
+      tasks.map(([k, targetLang]) => {
+        const text = mergedLocales[k];
+
+        return translate(text, targetLang, appid, privatekey)
+          .then((res) => {
+            mergedLocales[k] = res.transResult
+              .replaceAll('{ { ', '{{')
+              .replaceAll(' } }', '}}');
+          })
+          .catch((err) => {
+            log.warning(`[AutoTranslate]: ${err.message}`);
+            mergedLocales[k] = text;
+          });
+      })
+    );
+
+    log.info(`[AutoTranslate]: ${total - translateTasks.length}/${total}`);
+  }
+
+  const updateConfRes = await confService.updateConf(
+    confName,
+    mergedLocales,
+    chineseLocales,
+    key
+  );
+  if (updateConfRes.code !== 0) {
+    log.error(`update conf ${confName} fail, ${res.message}`);
+    return [];
+  }
+
+  log.success(`updated conf ${confName}`);
+
+  if (publish) {
+    log.warning(`start to publish conf ${confName}`);
+    const publishRes = await confService.publishConf(confName);
+    if (publishRes.code === 0) {
+      log.success(`published conf ${confName}`);
+    } else {
+      log.error(`publish conf ${confName} failed, ${publishRes.message}`);
+    }
+  } else {
+    log.warning(`${confName} is updated but unpublished!`);
+  }
+
+  return {
+    key,
+    locales: mergedLocales,
+  };
+}
+
+/**
+ * 同步更新非中文配置
+ * @param {object}  chineseLocales  中文资源
+ * @param {object} updatedTranslatedWord 在远端做过中文文案修改的 key/value
+ * @param {object}  option          参数
+ * @param {boolean} publish         更新后是否立即发布配置
+ */
+async function syncNonChineseLocalesConf(
+  chineseLocales,
+  updatedTranslatedWord,
+  option,
+  publish,
+  confService
+) {
+  const { primaryLocale, supportedLocales } = option;
+
+  const syncTasks = supportedLocales
+    .filter((key) => key !== primaryLocale)
+    .map((key) =>
+      syncOneNonChineseLocalesConf(
+        key,
+        option,
+        chineseLocales,
+        updatedTranslatedWord,
+        publish,
+        confService
+      )
+    );
+
+  const nonChineseLocales = await Promise.all(syncTasks);
+
+  return nonChineseLocales;
+}
+
+/**
+ * 收集源码中的中文字符
+ * @param {object}  option  命令行或者配置文件中传入的参数信息
+ * @param {boolean} publish 同步后，是否立即发布新的配置
+ */
+async function collectChineseWords(option, publish, confService) {
+  const { entry, output, exclude, entryNoImport = [] } = option;
+
+  if (!Array.isArray(entry) && typeof entry !== 'string') {
+    log.error('entry must be a string or array');
+    process.exit(2);
+  }
+
+  let zhData = {};
+  const allTranslatedWord = {};
+  const updatedTranslatedWord = {}; // 在远端做过中文文案修改的 key/value
+  const keysInUse = [];
+
+  const zhConfName = 'zh-CN';
+
+  const res = await confService.getConf(zhConfName, 'zh-CN');
+
+  if (res.code !== 0) {
+    log.error(`failed to read apollo conf, ${res.message}`);
+    process.exit(2);
+  }
+
+  res.data.forEach((item) => {
+    zhData[item.key] = item.value;
+  });
+
+  Object.keys(zhData).forEach((k) => {
+    const chineseValue = zhData[k];
+    if (chineseValue.trim() !== k.replace(/\{context,\s*\S+\}$/, '').trim()) {
+      updatedTranslatedWord[k] = chineseValue;
+    } else {
+      if (Array.isArray(allTranslatedWord[chineseValue])) {
+        allTranslatedWord[chineseValue].push(k);
+      } else {
+        allTranslatedWord[chineseValue] = [k];
+      }
+    }
+  });
+  const outputs = output ? [].concat(output) : [];
+  let targetFiles = [].concat(entry).reduce((prev, cur, index) => {
+    const files = getSourceFiles({ entry: cur, exclude }).map((file) => ({
+      filePath: file,
+      currentEntry: cur,
+      currentOutput: outputs[index],
+      ext: path.extname(file),
+    }));
+    return prev.concat(files);
+  }, []);
+  targetFiles = targetFiles.concat(
+    entryNoImport.reduce((prev, cur, index) => {
+      const files = getSourceFiles({ entry: cur, exclude: [] }).map((file) => ({
+        filePath: file,
+        currentEntry: cur,
+        ext: path.extname(file),
+        noImport: true,
+      }));
+      return prev.concat(files);
+    }, [])
+  );
+
+  targetFiles.forEach((codeFileInfo) => {
+    transformZeroToDi18n(
+      codeFileInfo,
+      allTranslatedWord,
+      updatedTranslatedWord,
+      keysInUse,
+      option
+    );
+    log.success(`done: ${codeFileInfo.filePath}`);
+  });
+
+  const localeResouce = {};
+  const unusedKeys = [];
+  Object.keys(allTranslatedWord).forEach((k) => {
+    allTranslatedWord[k].forEach((key) => {
+      if (keysInUse.includes(key)) {
+        localeResouce[key] = k;
+      } else {
+        unusedKeys.push(key);
+      }
+    });
+  });
+
+  if (unusedKeys.length > 0) {
+    log.info('the following keys are unused and will be removed:');
+    log.info(unusedKeys);
+  }
+
+  const allTranslatedWordKeysCount = Object.keys(allTranslatedWord).reduce(
+    (prev, cur) => prev + allTranslatedWord[cur].length,
+    0
+  );
+  const allLocalesKeyCount = Object.keys(localeResouce).length;
+  const allTranstedInUseCount = allTranslatedWordKeysCount - unusedKeys.length;
+
+  log.info(`keys in use count: ${allTranstedInUseCount}`);
+  log.info(`locales in use count: ${allLocalesKeyCount}`);
+
+  if (allTranstedInUseCount !== allLocalesKeyCount) {
+    log.error('ATTENTION：keys and locales are not match');
+  }
+
+  log.info(`start to update conf ${zhConfName}`);
+  // 更新配置
+  const updateConfRes = await confService.updateConf(
+    zhConfName,
+    localeResouce,
+    {},
+    'zh-CN'
+  );
+
+  if (updateConfRes.code !== 0) {
+    log.error(`update conf ${zhConfName} failed, ${updateConfRes.message}`);
+    return null;
+  }
+
+  log.success(`updated conf ${zhConfName}`);
+
+  const unChineseLocales = await syncNonChineseLocalesConf(
+    localeResouce,
+    updatedTranslatedWord,
+    option,
+    publish,
+    confService
+  );
+
+  // XXX: 英文 publish 也放到这里
+  if (publish) {
+    log.warning(`start to publish conf ${zhConfName}`);
+    const publishRes = await confService.publishConf(zhConfName);
+    if (publishRes.code === 0) {
+      log.success(`published conf ${zhConfName}`);
+    } else {
+      log.error(`publish conf ${zhConfName} failed, ${publishRes.message}`);
+    }
+  } else {
+    log.warning(`${zhConfName} is synced, but unpublihsed !!`);
+  }
+
+  return unChineseLocales.concat({
+    key: 'zh-CN',
+    locales: localeResouce,
+  });
+}
+
+module.exports = function doCollectChineseWords(
+  programOption,
+  publish = false
+) {
+  const options = mergeOptions(programOption, ['entry', 'exclude', 'locales']);
+
+  let confService = null;
+  if (options.localeConf.type === 'file') {
+    const FileConf = require('../conf/FileConf');
+    confService = new FileConf(options.localeConf.folder);
+  } else {
+    const Conf = require(options.localeConf.path);
+    confService = new Conf(options.localeConf);
+  }
+
+  if (!options.entry) {
+    log.error('no entry is specified');
+    process.exit(2);
+  }
+
+  if (Array.isArray(options.entry)) {
+    if (!Array.isArray(options.output)) {
+      log.error('output should be array too, since entry is array');
+      process.exit(2);
+    }
+
+    if (options.output.length !== options.entry.length) {
+      log.error('output length are not equal to entry length');
+      process.exit(2);
+    }
+  }
+
+  if (options.output) {
+    [].concat(options.output).forEach((outputDir) => {
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir);
+      }
+    });
+  }
+
+  return collectChineseWords(options, publish, confService);
+};

package/zti18n-cli/src/command/convert.js

@@ -0,0 +1,17 @@
+const {
+  transformReactIntlToReactIntlUniversal,
+} = require('../../../zti18n-core');
+const mergeOptions = require('../utils/mergeOptions');
+const log = require('../utils/log');
+
+module.exports = function doConvertToReactIntlUniversal(programOption) {
+  const options = mergeOptions(programOption, ['entry', 'exclude', 'locales']);
+
+  if (!options.entry) {
+    log.error('\n · 使用 -e [path] 或 --entry [path] 命令增加待转换的源码目录');
+    log.error(" · 或在配置文件中设置 'entry' 字段\n");
+    process.exit(2);
+  }
+
+  transformReactIntlToReactIntlUniversal(options);
+};

package/zti18n-cli/src/command/convert2.js

@@ -0,0 +1,35 @@
+const fs = require('fs');
+const { transformReactIntlUniveralToDi18n } = require('../../../zti18n-core');
+const mergeOptions = require('../utils/mergeOptions');
+const log = require('../utils/log');
+
+module.exports = function doConvert(programOption) {
+  const options = mergeOptions(programOption, ['entry', 'exclude', 'locales']);
+
+  if (!options.entry) {
+    log.error('no entry is specified');
+    process.exit(2);
+  }
+
+  if (Array.isArray(options.entry)) {
+    if (!Array.isArray(options.output)) {
+      log.error('output should be array too, since entry is array');
+      process.exit(2);
+    }
+
+    if (options.output.length !== options.entry.length) {
+      log.error('output length are not equal to entry length');
+      process.exit(2);
+    }
+  }
+
+  if (options.output) {
+    [].concat(options.output).forEach((outputDir) => {
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir);
+      }
+    });
+  }
+
+  return transformReactIntlUniveralToDi18n(options);
+};

package/zti18n-cli/src/command/initFileConf.js

@@ -0,0 +1,133 @@
+const glob = require('glob');
+const fs = require('fs');
+const path = require('path');
+const inquirer = require('inquirer');
+const prettier = require('prettier');
+const FileConf = require('../conf/FileConf');
+const reactOptions = require('../utils/reactOptions');
+const vueOptions = require('../utils/vueOptions');
+const log = require('../utils/log');
+
+function getLocaleFiles({ path, exclude }) {
+  return glob.sync(`${path}/**/*.json`, {
+    ignore: (exclude || []).map((e) => `${path}/${e}`),
+  });
+}
+
+async function doInquire() {
+  // 1. whether overwrite?
+  let configExist = true;
+  try {
+    fs.accessSync('./zti18n.config.js');
+  } catch (e) {
+    configExist = false;
+  }
+
+  if (configExist) {
+    const ans = await inquirer.prompt([
+      {
+        name: 'overwrite',
+        type: 'confirm',
+        message: '配置文件 zti18n.config.js 已存在，是否覆盖？',
+      },
+    ]);
+
+    if (!ans.overwrite) process.exit(0);
+  }
+
+  // 2. first i18n?
+  let ans = await inquirer.prompt([
+    {
+      name: 'firstI18n',
+      type: 'confirm',
+      message: '是否初次国际化？',
+    },
+    {
+      name: 'localePath',
+      type: 'input',
+      message: '请输入现有国际化资源路径：',
+      when(answers) {
+        return !answers.firstI18n;
+      },
+    },
+  ]);
+
+  return ans;
+}
+
+module.exports = async function initFileConf(isVue) {
+  const answers = await doInquire();
+  const { localePath = 'locales', firstI18n } = answers;
+
+  const defaultOptions = isVue ? vueOptions : reactOptions;
+  const options = {
+    ...defaultOptions,
+    localeConf: { type: 'file', folder: localePath },
+  };
+
+  // 配置信息写入文件
+  fs.writeFileSync(
+    './zti18n.config.js',
+    prettier.format('module.exports = ' + JSON.stringify(options), {
+      parser: 'babel',
+      singleQuote: true,
+      trailingComma: 'es5',
+    }),
+    'utf8'
+  );
+
+  let createTasks = [];
+  const confService = new FileConf(options.localeConf.folder);
+
+  if (!firstI18n) {
+    // 非首次国际化，本地代码中已有国际化资源
+    const locales = getLocaleFiles({ path: localePath });
+
+    // 读取国际化资源
+    const data = locales.map((element) => {
+      // TODO: 支持国际化资源为 js 文件的情况，目前只支持为 json 文件。
+      const json = fs.readFileSync(element, {
+        encoding: 'utf-8',
+      });
+
+      // 使用现有文件名为语言 key
+      const key = path.parse(element).name;
+
+      return {
+        key,
+        value: JSON.parse(json),
+        confName: key,
+      };
+    });
+
+    createTasks = data.map(({ confName, value, key }) => {
+      let commentValue = {};
+      if (key !== options.primaryLocale) {
+        commentValue = data.find((d) => d.key === options.primaryLocale).value;
+      }
+      return confService.createConf(confName, value, commentValue, key);
+    });
+  } else {
+    // 首次国际化，只需要创建配置
+    createTasks = options.supportedLocales.map((key) => {
+      const value = { TBD: 'TBD' }; // 创建配置时，必须要有一个 k/V
+      const confName = key; // 初始化时，先创建测试环境的配置
+      return confService.createConf(confName, value, {}, key);
+    });
+  }
+
+  const createTaskResults = await Promise.all(createTasks);
+  log.success('[done] conf created');
+  console.log(createTaskResults);
+
+  // 将已有国际化资源的配置发布
+  if (!firstI18n) {
+    const publishTasks = options.supportedLocales.map((key) => {
+      return confService.publishConf(`${key}-test`);
+    });
+
+    const publishTaskResults = await Promise.all(publishTasks);
+    log.success('[done] conf published');
+    console.log(publishTaskResults);
+  }
+};

package/zti18n-cli/src/command/publish.js

@@ -0,0 +1,24 @@
+const path = require('path');
+const mergeOptions = require('../utils/mergeOptions');
+const log = require('../utils/log');
+
+module.exports = async function publish(programOption, env = '') {
+  const options = mergeOptions(programOption, ['locales']);
+
+  let confService = null;
+  if (options.localeConf.type === 'file') {
+    const FileConf = require('../conf/FileConf');
+    confService = new FileConf(options.locales);
+  } else {
+    const Conf = require(path.join(process.cwd(), options.localeConf.path));
+    confService = new Conf(options.localeConf);
+  }
+
+  const publishTasks = options.supportedLocales.map((key) => {
+    return confService.publishConf(`${key}-${env}`);
+  });
+
+  const publishTaskResults = await Promise.all(publishTasks);
+  log.success('[done] conf published');
+  console.log(publishTaskResults);
+};

package/zti18n-cli/src/conf/BaseConf.js

@@ -0,0 +1,21 @@
+module.exports = class BaseConf {
+  createService() {
+    return Promise.resolve(true);
+  }
+
+  createConf() {
+    throw new Error('`createConf` must be overrided');
+  }
+
+  updateConf() {
+    throw new Error('`updateConf` must be overrided');
+  }
+
+  getConf() {
+    throw new Error('`getConf` must be overrided');
+  }
+
+  publishConf() {
+    return Promise.resolve(true);
+  }
+};