@chaoswise/intl 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 DOCP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/chaoswise-intl.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+const runCollect = require('./scripts/collect');
+const runUpdate = require('./scripts/update');
+
+// 可执行的指令
+const SCRIPTS = ['collect', 'update'];
+
+const args = process.argv.slice(2);
+
+const scriptIndex = args.findIndex(arg => {
+  const script = SCRIPTS.filter(script => arg === script)[0];
+  return arg === script;
+});
+
+const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
+
+if(script === 'collect') {
+  runCollect();
+}
+if(script === 'update') {
+  runUpdate();
+}

package/bin/scripts/collect.js

@@ -0,0 +1,67 @@
+const { v4: uuidv4 } = require('uuid');
+
+const getConf = require('./conf');
+const getTargetFiles = require('./util/getTargetFiles');
+const transformAst = require('./util/transformAst');
+const log = require('./util/log');
+const file = require('./util/file');
+
+const service = require('./service');
+
+async function init() {
+  const conf = getConf();
+  const files = getTargetFiles(conf);
+
+  // 遍历文件，并对代码进行ast处理的方法：transformAst(type, files, conf, replaceWords)
+  // 第一次遍历，只收集中文，不传入replaceWords
+  const info = transformAst('Collect', files, conf);
+
+  // 在国际化平台中获取所有已存在中文信息
+  const res = await service.searchByZh(info.allWords);
+  const wordsMap = res.data;
+
+  const replaceWords = {}; // { zh: id } 需要在代码中替换的词条id
+  const newWords = {}; // { zh1: '待翻译', zh2: '请选择:中文1/中文2' }
+  Object.entries(wordsMap).forEach(([zh, value]) => {
+    // 如果当前中文词条在平台中存在，且对应英文翻译有且只有一条，那么直接替换代码中的中文为当前id，否则生成临时key，让开发者手动确认
+    if (value.length === 1) {
+      replaceWords[zh] = value[0].key;
+    } else {
+      const id = uuidv4();
+      replaceWords[zh] = id;
+      newWords[id] = {
+        zh,
+        en:
+          value.length === 0
+            ? '待翻译'
+            : `该词条在平台中对应多个英文翻译，请手动确认:${value
+                .map((item) => item.en)
+                .join('/')}`,
+      };
+    }
+  });
+
+  // 第二次遍历，传入replaceWords，对代码进行国际化通用API转化，把词条替换成数据库的id，或者脚本临时生成的uuid
+  transformAst('collect', files, conf, replaceWords);
+
+  log.success('脚本执行成功');
+  log.success('自定义配置文件在项目根目录的.intlconfig.js中');
+  // 本次扫描出新的待翻译词条，写入到newWords中
+  if (Object.keys(newWords).length) {
+    const newWordsJsonPath = 'newWords.json';
+
+    let oldNewWords = file.readJson(newWordsJsonPath) || {};
+    file.write(
+      newWordsJsonPath,
+      JSON.stringify({ ...oldNewWords, ...newWords }, null, 2)
+    );
+
+    // 先注释掉，开始做指标时，会用到
+    // const package = file.read('package.json');
+    // file.write(newWordsJsonPath, JSON.stringify({ ...oldNewWords, ...newWords, projectName: package.name }, null, 2));
+    log.success(`需要翻译的文件在项目根目录的newWords.json中`);
+  }
+}
+
+// init();
+module.exports = init;

package/bin/scripts/conf/default.js

@@ -0,0 +1,64 @@
+// default options
+module.exports = function (excludes = []) {
+  var config = {
+    // source path, <string array>
+    // e.g. ['src']
+    entry: ['src'],
+
+    // exclude pattern, <string array>
+    // e.g. ['**/dist/**', '**/*.config.js', '**/*.data.js']
+    exclude: [
+      '**/router.config.js',
+      '**/src/public/**',
+      '**/_MOCK_/**'
+    ],
+
+    // output path, <string array>
+    // e.g. ['dist']
+    output: ['src'], // default i18n in place
+
+    // ignored components, <string array>
+    // e.g. ['EventTracker']
+    ignoreComponents: [],
+
+    // ignored methods, <string array>
+    // e.g. ['MirrorTrack']
+    ignoreMethods: [],
+
+    ignoreAttributes: ['style', 'className'],
+
+    primaryRegx: /[\u4e00-\u9fa5]/,
+
+    // import codes, <string>
+    // e.g. "import { intl } from 'di18n-react';"
+    importCode: "import { intl } from '@chaoswise/intl';",
+
+    // i18n object, <string>
+    // e.g. 'intl'
+    i18nObject: 'intl',
+
+    // i18n method, <string>
+    // e.g. 't'
+    i18nMethod: 'get',
+
+    // babel配置项
+    babelPresets: [],
+    babelPlugins: [],
+
+    // prettier conf, <null | object>
+    // e.g. {}
+    prettier: {
+      singleQuote: true,
+      jsxSingleQuote: true,
+      trailingComma: 'es5',
+      endOfLine: 'lf',
+    },
+
+    // 国际化平台地址
+    baseURL: 'http://10.0.1.133:18000',
+  };
+
+  excludes.forEach((key) => delete config[key]);
+
+  return config;
+};

package/bin/scripts/conf/index.js

@@ -0,0 +1,42 @@
+const getDefaultConfig = require('./default');
+const file = require('../util/file');
+const prettier = require('prettier');
+
+function createCustomConfig() {
+  // 默认生成的配置文件，不需要给出全量可配置属性
+  const ignoreAttributes = [
+    'primaryRegx',
+    'importCode',
+    'i18nObject',
+    'i18nMethod',
+    'baseURL',
+  ];
+  const defaultConfig = getDefaultConfig(ignoreAttributes);
+
+  const code = `module.exports = ${JSON.stringify(defaultConfig, null, 2)};`;
+
+  file.write(
+    '.intlconfig.js',
+    prettier.format(code, { ...defaultConfig.prettier, parser: 'babel' })
+  );
+}
+
+// 内置一些，不需要被扫描的函数
+const ignoreMethods = [
+];
+Object.keys(console).forEach(key => ignoreMethods.push(`console.${key}`))
+
+module.exports = function () {
+  // 获取用户自定义配置文件
+  const customConfig = file.readJs('.intlconfig.js');
+
+  if (!customConfig) {
+    createCustomConfig();
+  }
+  // 合并配置文件
+  const finalyConf = { ...getDefaultConfig(), ...customConfig };
+
+  finalyConf.ignoreMethods.push(...ignoreMethods);
+
+  return finalyConf;
+};

package/bin/scripts/service/index.js

@@ -0,0 +1,29 @@
+const axios = require('axios');
+const getConf = require('../conf');
+
+const conf = getConf();
+
+axios.defaults.baseURL = (conf.baseURL || '') + '/api/i18n/dictionary';
+
+axios.interceptors.response.use(
+  function (response) {
+    // Any status code that lie within the range of 2xx cause this function to trigger
+    // Do something with response data
+    return response.data;
+  },
+  function (error) {
+    // Any status codes that falls outside the range of 2xx cause this function to trigger
+    // Do something with response error
+    return Promise.reject(error);
+  }
+);
+
+// 在国际化平台中获取所有已存在中文信息
+exports.searchByZh = (zhs) => {
+  return axios.post('/searchByZh', zhs);
+};
+
+// 根据词条id获取所有数据库词条信息
+exports.getJson = (ids) => {
+  return axios.post('/getJson', ids);
+};

package/bin/scripts/update.js

@@ -0,0 +1,32 @@
+const getConf = require('./conf');
+const getTargetFiles = require('./util/getTargetFiles');
+const transformAst = require('./util/transformAst');
+const downloadJson = require('./util/downloadJson');
+const log = require('./util/log');
+const file = require('./util/file');
+
+async function replace() {
+  const conf = getConf();
+  const files = getTargetFiles(conf);
+
+  // relationKey { key: id } key是脚本生成的临时id，id是数据库对应词条的id
+  const relationKey = file.readJson('relationKey.json') || {};
+
+  const info = transformAst('update', files, conf, relationKey);
+  downloadJson(info.downloadIds);
+
+  const needDelete = Boolean(Object.keys(relationKey).length);
+  if (needDelete) {
+    file.delete('newWords.json');
+    file.delete('relationKey.json');
+
+    log.success('newWords.json和relationKey.json 已删除');
+  }
+
+  log.success('脚本执行成功2222');
+}
+
+// replace();
+module.exports = replace;
+
+

package/bin/scripts/util/downloadJson.js

@@ -0,0 +1,9 @@
+const service = require('../service');
+const file = require('./file');
+
+module.exports = async function downloadJson(downloadIds) {
+  const res = await service.getJson(downloadIds);
+  const { zh, en } = res.data;
+  file.write('locales/zh-CN.json', JSON.stringify(zh, null, 2));
+  file.write('locales/en-US.json', JSON.stringify(en, null, 2));
+};

package/bin/scripts/util/file.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+const log = require('./log');
+const folder = require('./folder');
+
+// 项目根目录
+const rootPath = process.cwd();
+// 获取指定文件全路径
+const getPath = (relativePath) => path.resolve(rootPath, relativePath);
+
+const baseRead = (relativePath) => {
+  const fullPath = getPath(relativePath);
+  let data = null;
+  try {
+    data = fs.readFileSync(fullPath, { encoding: 'utf-8' });
+  } catch (error) {}
+  return data;
+};
+
+module.exports = {
+  // 读取指定文件
+  read: baseRead,
+  // 读取json文件
+  readJson(relativePath) {
+    let data = baseRead(relativePath);
+    try {
+      data = JSON.parse(data);
+    } catch (error) {
+      log.error(error);
+      data = null;
+    }
+    return data;
+  },
+  // 读取js module 文件
+  readJs(relativePath) {
+    const fullPath = getPath(relativePath);
+    try {
+      return require(fullPath);
+    } catch (error) {}
+  },
+  // 对指定文件写入信息
+  write(relativePath, data) {
+    const fullPath = getPath(relativePath);
+
+    let res = null;
+    try {
+      const index = fullPath.lastIndexOf('/');
+      const folderPath = fullPath.slice(0, index);
+      // 构建文件所需目录
+      folder.insure(folderPath);
+
+      res = fs.writeFileSync(fullPath, data, { encoding: 'utf-8' });
+    } catch (error) {
+      log.error(error);
+    }
+    return res;
+  },
+  // 删除文件
+  delete(relativePath) {
+    const fullPath = getPath(relativePath);
+    try {
+      fs.unlinkSync(fullPath);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  },
+};

package/bin/scripts/util/folder.js

@@ -0,0 +1,34 @@
+const fs = require('fs');
+const path = require('path');
+const log = require('./log');
+
+/* 
+  根据文件夹路径构建文件夹目录，比如：a/b/c/d
+  按文件夹层级依次判断该”文件夹名称“是否存在：
+    1、如果不存在则创建新的目录
+    2、如果存在并且不是”文件夹类型“，则程序退出，给出相应错误提示（同一路径下不能同名）
+*/
+function insure(folderPath) {
+  const folderPathArr = folderPath.split(path.sep).filter(Boolean);
+  let currentPath = '/';
+
+  do {
+    currentPath = path.resolve(currentPath, folderPathArr.shift());
+
+    let has = fs.existsSync(currentPath);
+    let isFolder = false;
+    if (!has) {
+      fs.mkdirSync(currentPath);
+      isFolder = true;
+    } else {
+      const stat = fs.statSync(currentPath);
+      isFolder = stat.isDirectory();
+    }
+
+    if (!isFolder) {
+      log.error(currentPath + '只能是文件夹');
+      process.exit(1);
+    }
+  } while (folderPathArr.length);
+}
+module.exports = { insure };

package/bin/scripts/util/getTargetFiles.js

@@ -0,0 +1,25 @@
+const path = require('path');
+const glob = require('glob');
+
+function getSourceFiles({ entry, exclude }) {
+  return glob.sync(`${entry}/**/*.{js,ts,tsx,jsx}`, {
+    ignore: exclude || [],
+  });
+}
+
+// 根据入口entry，获取所有需要扫描的文件
+module.exports = function ({ entry, output, exclude }) {
+  const outputs = output ? [].concat(output) : [];
+
+  const 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);
+  }, []);
+
+  return targetFiles;
+};

package/bin/scripts/util/log.js

@@ -0,0 +1,8 @@
+const chalk = require('chalk');
+
+module.exports = {
+  info: (msg) => console.log(chalk.cyan(msg)),
+  warn: (msg) => console.log(chalk.yellow(msg)),
+  success: (msg) => console.log(chalk.green(msg)),
+  error: (msg) => console.log(chalk.red(msg)),
+};

package/bin/scripts/util/makeVisitorCollect.js

@@ -0,0 +1,347 @@
+const log = require('./log');
+const t = require('@babel/types');
+
+module.exports = function(
+  {
+    primaryRegx,
+    i18nObject,
+    i18nMethod,
+    importCode,
+    ignoreLines,
+    ignoreMethods,
+    ignoreComponents = [],
+    ignoreAttributes,
+  },
+  returns
+) {
+  const { replaceWords, allWords, downloadIds } = returns;
+  const hacked = {};
+
+  // XXX: [TRICKY] 防止中文转码为 unicode
+  function hackValue(value, id) {
+    if (id) hacked[id] = true;
+
+    return Object.assign(t.StringLiteral(value), {
+      extra: {
+        raw: `'${id}'`, // id
+        rawValue: value, // zh
+      },
+    });
+  }
+
+  // 是否忽略
+  function shouldIgnore(node) {
+    if (node?.loc) {
+      return ignoreLines.includes(node.loc.start.line);
+    }
+    return false;
+  }
+
+  // 是否命中替换的正则
+  function isPrimary(str) {
+    return primaryRegx.test(str);
+  }
+
+  /*
+  去掉首尾空白字符，中间的连续空白字符替换成一个空格
+  例如：
+    <div>
+      中文
+    <div>
+    会提取”/n中文/n“作为记录标记,需要用formatWhitespace去掉
+  */
+  function formatWhitespace(str) {
+    return str.trim().replace(/\s+/g, ' ');
+  }
+
+  // 处理模板字符串中的变量
+  function makeObjectExpression(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]') return null;
+
+    // 存储每一项变量
+    const ObjectPropertyArr = [];
+    Object.keys(obj).forEach((k) => {
+      const node = obj[k].value;
+      // 模板字符串中，变量存在函数调用的情况下：如果当前变量为函数，那么需要处理函数的中文参数，比如：`hello ${getText('中文')}`
+      if (!shouldIgnore(node) && node?.type === 'CallExpression') {
+        node.arguments = dealArgs(node.arguments);
+      }
+      ObjectPropertyArr.push(
+        t.ObjectProperty(
+          t.Identifier(k),
+          obj[k].isAstNode ? obj[k].value : t.Identifier(obj[k])
+        )
+      );
+    });
+    return t.ObjectExpression(ObjectPropertyArr);
+  }
+
+  // 更新allWords
+  function updateWordsInfo(zh) {
+    if (allWords.includes(zh)) return;
+    allWords.push(zh);
+  }
+
+  // 处理函数的argments
+  function dealArgs(args) {
+    if (!Array.isArray(args)) return args;
+    const resArgs = []; // 参数处理完，用resArgs保存
+    args.forEach(node => {
+       // 字符串变量
+      if (node.type === 'StringLiteral' && isPrimary(node.value)) {
+        resArgs.push(makeReplace(node.value));
+      }
+      // 函数或方法调用表达式
+      else if (node.type === 'CallExpression') {
+        const { needReplace, value, skip } = dealCallExpressionNode(node);
+        // 跳过国际化API转化
+        if (skip) {
+          resArgs.push(node);
+        } else {
+          // 对当前函数再次进行参数处理，自调用
+          node.arguments = dealArgs(node.arguments);
+          resArgs.push(node);
+        }
+      }
+      // 字符串模版
+      else if (node.type === 'TemplateLiteral') {
+        const { needReplace, value, variable, } = dealTemplateLiteralNode(node);
+        resArgs.push(
+          needReplace
+            ? makeReplace(value, Object.keys(variable).length ? variable : null)
+            : node
+        );
+      }
+      // ObjectExpression和ObjectProperty，是为了处理参数存在对象的情况，比如：{x:'中文'}
+      else if (node.type === 'ObjectExpression') { // Object
+        node.properties = dealArgs(node.properties);
+        resArgs.push(node);
+      } else if (node.type === 'ObjectProperty') { // Object的属性
+        const res = dealArgs([node.value]);
+        node.value = res[0];
+        resArgs.push(node);
+      } else if (node.type === 'ArrayExpression') { // Array
+        node.elements = dealArgs(node.elements);
+        resArgs.push(node);
+      } else {
+        resArgs.push(node);
+      }
+    })
+    return resArgs;
+  }
+
+  // 替换字符串为我们使用的国际化API
+  function makeReplace(value, variables) {
+    // 存在文案替换
+    returns.hasTouch = true;
+
+    value = formatWhitespace(value);
+
+    updateWordsInfo(value);
+    // 将中文词条替换为国际化api:init.t(id/key)
+    const id = replaceWords[value];
+
+    // 生成新的ast节点
+    const v = hackValue(value, id);
+    const objExp = makeObjectExpression(variables);
+    const defaultV = hackValue(value, value);
+
+    return t.callExpression(
+      t.memberExpression(
+        t.callExpression(
+          // MemberExpression 成员表达式。
+          // 如果computed为true，则节点对应于一个computed（a[b]）成员表达式，并且属性是一个表达式。
+          // 如果computed为false，则节点对应于静态（a.b）成员表达式，属性为标识符或PrivateName。
+          i18nObject
+            ? t.memberExpression(t.identifier(i18nObject), t.identifier(i18nMethod))
+            : t.identifier(i18nMethod),
+          objExp ? [v, objExp] : [v]
+        )
+        , t.identifier('d')
+      ),
+      [defaultV]
+    );
+  }
+
+  // 字符串模版
+  function dealTemplateLiteralNode(node) {
+    let value = '';
+    let needReplace = false;
+    let slotIndex = 0;
+    const variable = {}; // 存储模版中的变量
+    if (
+      !shouldIgnore(node) &&
+      node.quasis.some((word) => isPrimary(word.value.cooked))
+    ) {
+      const tempArr = [...node.quasis, ...node.expressions];
+      tempArr.sort((a, b) => a.start - b.start);
+
+      tempArr.forEach(function (nd) {
+        if (nd.type === 'TemplateElement') {
+          value += nd.value.cooked;
+          if (isPrimary(nd.value.cooked)) {
+            needReplace = true;
+          }
+        } else if (nd.type === 'Identifier') {
+          value += `{${nd.name}}`;
+          variable[nd.name] = nd.name;
+
+          needReplace = true;
+        } else {
+          // 例如 CallExpression 等
+          const identifier = `slot${slotIndex++}`;
+          value += `{${identifier}}`;
+          variable[identifier] = { isAstNode: true, value: nd };
+          needReplace = true;
+        }
+      });
+    }
+
+    return {
+      needReplace: needReplace && value.trim() /*处理模板字符串为空的情况，比如：` `*/,
+      value,
+      variable,
+    }
+  }
+  // 字符串变量
+  function dealStringLiteralNode(node, path) {
+    let needReplace = false;
+    let { value } = node;
+    if (!shouldIgnore(node) && isPrimary(value)) {
+      switch (path?.parent?.type) {
+        // 组件属性，比如：<Root prop='中文' /> 中的prop
+        case 'JSXAttribute':
+          // ignoreComponents 可忽略一些组件
+          if (!ignoreComponents.includes(path?.parentPath?.parent?.name?.name)) {
+            needReplace = true;
+          }
+          break;
+
+        case 'ObjectProperty':
+        // 赋值运算符表达式，比如：const c = (a = '中文单词')
+        case 'AssignmentExpression':
+        case 'CallExpression':
+        // 比如：new A('中文词条')
+        case 'NewExpression':
+        default:
+          needReplace = true;
+          break;
+      }
+    }
+    return { needReplace, value };
+  }
+  // 函数表达式
+  function dealCallExpressionNode(node) {
+    const res = {
+      needReplace: false,
+      value: null,
+      skip: false,
+    }
+    if (shouldIgnore(node)) {
+      res.skip = true;
+      return res;
+    }
+
+    // 处理 ignoreMethods
+    if (node.callee.type === 'MemberExpression') {
+      let parentNode = '';
+      if (node.callee.object.name) {
+        parentNode = node.callee.object.name;
+      } else if (node.callee.object.property) {
+        // 处理忽略类似 a.b.c 方法情况
+        parentNode = node.callee.object.property.name;
+      }
+
+      const callExpression = `${parentNode}.${node.callee.property.name}`;
+
+      if (ignoreMethods.includes(callExpression)) {
+        res.skip = true;
+        return res;
+      }
+    }
+
+    if (node.callee.type === 'Identifier') {
+      if (ignoreMethods.includes(node.callee.name)) {
+        res.skip = true;
+        return res;
+      }
+    }
+
+    return res;
+  }
+
+  return {
+    // 导入声明，比如：import foo from "mod";
+    ImportDeclaration(path) {
+      // 是否已经导入过 intl 的依赖
+      const m = importCode.match(/from ["'](.*)["']/);
+      const pkgName = m ? m[1] : '';
+      if (path.node.source.value === pkgName) {
+        returns.hasImport = true;
+      }
+      path.skip();
+    },
+
+    // 字符串模版，比如：`我的${bar}${fun('哈哈')}中文` intl.t(我的{bar}{slot1}中文,{bar:fdsafdsdf,slot1:fn()})
+    TemplateLiteral(path) {
+      const { node } = path;
+
+      const { needReplace, value, variable, } = dealTemplateLiteralNode(node);
+      if (needReplace) {
+        path.replaceWith(makeReplace(value, Object.keys(variable).length ? variable : null));
+      }
+      path.skip();
+    },
+
+    // 字符串变量
+    StringLiteral(path) {
+      const { node } = path;
+      let { value } = node;
+
+      const { needReplace } = dealStringLiteralNode(node, path);
+      if (needReplace) {
+        let res = makeReplace(value);
+        if (path.parent.type === 'JSXAttribute') {
+          res = t.JSXExpressionContainer(res);
+        }
+        path.replaceWith(res);
+        path.skip();
+      } else if (isPrimary(value)) {
+        log.warn('ignore 1!!!!!!', value);
+      }
+    },
+
+    // 函数或方法调用表达式，比如：a('中午')
+    CallExpression(path) {
+      const { node } = path;
+
+      const { needReplace, value, skip } = dealCallExpressionNode(node);
+      if (needReplace) {
+        path.replaceWith(makeReplace(value));
+      }
+      if (skip) path.skip();
+    },
+
+    // JSX文本节点
+    JSXText(path) {
+      const { node } = path;
+
+      if (!shouldIgnore(node) && isPrimary(node.value)) {
+        // 将中文替换为 JSX 表达式
+        path.replaceWith(t.JSXExpressionContainer(makeReplace(node.value)));
+      }
+
+      path.skip();
+    },
+
+    // JSX 元素属性
+    JSXAttribute(path) {
+      const { node } = path;
+
+      // 跳过被忽略的属性，比如 style、className 等
+      if (ignoreAttributes.includes(node.name.name)) {
+        path.skip();
+      }
+    },
+  };
+}

package/bin/scripts/util/makeVisitorUpdate.js

@@ -0,0 +1,149 @@
+const t = require('@babel/types');
+
+module.exports = function f(
+  {
+    i18nObject,
+    i18nMethod,
+    importCode,
+  },
+  returns
+) {
+  const { replaceWords, downloadIds } = returns;
+
+  // XXX: [TRICKY] 防止中文转码为 unicode
+  function hackValue(value, id) {
+
+    return Object.assign(t.StringLiteral(value), {
+      extra: {
+        raw: `'${id}'`, // id
+        rawValue: value, // 临时id
+      },
+    });
+  }
+
+  /*
+  去掉首尾空白字符，中间的连续空白字符替换成一个空格
+  例如：
+    <div>
+      中文
+    <div>
+    会提取”/n中文/n“作为记录标记,需要用formatWhitespace去掉
+  */
+  function formatWhitespace(str) {
+    return str.trim().replace(/\s+/g, ' ');
+  }
+
+  // 处理模板字符串中的变量
+  function makeObjectExpression(obj) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]') return null;
+
+    // 存储每一项变量
+    const ObjectPropertyArr = [];
+    Object.keys(obj).forEach((k) => {
+      ObjectPropertyArr.push(
+        t.ObjectProperty(
+          t.Identifier(k),
+          obj[k].isAstNode ? obj[k].value : t.Identifier(obj[k])
+        )
+      );
+    });
+    return t.ObjectExpression(ObjectPropertyArr);
+  }
+
+  // 替换字符串为我们使用的国际化API
+  function makeReplace(value, variables) {
+
+    // 存在临时id替换
+    returns.hasTouch = true;
+
+    value = formatWhitespace(value);
+
+    // 将临时id替换为数据词条的id
+    const id = replaceWords[value];
+
+    // 生成新的ast节点
+    const v = hackValue(value, id);
+    const objExp = makeObjectExpression(variables);
+
+    return t.callExpression(
+      // MemberExpression 成员表达式。
+      // 如果computed为true，则节点对应于一个computed（a[b]）成员表达式，并且属性是一个表达式。
+      // 如果computed为false，则节点对应于静态（a.b）成员表达式，属性为标识符或PrivateName。
+      i18nObject
+        ? t.memberExpression(t.identifier(i18nObject), t.identifier(i18nMethod))
+        : t.identifier(i18nMethod),
+      objExp ? [v, objExp] : [v]
+    );
+  }
+
+  // 函数或方法调用表达式
+  function dealCallExpressionNode(node) {
+    const res = {
+      needReplace: false,
+      value: null,
+      skip: false,
+    }
+
+    if (
+      (node.callee.type === 'MemberExpression' &&
+        node.callee.object.name === i18nObject &&
+        node.callee.property.name === i18nMethod) ||
+      (node.callee.type === 'Identifier' && node.callee.name === i18nMethod)
+    ) {
+      // 收集现有的 key
+      const args = node.arguments;
+      if(!args.length) {
+        return res;
+      }
+
+      let key = args[0].value;
+
+      // intl.t(key)
+      // replaceWords { key: id }
+      const id = replaceWords[key];
+      if (id) {
+        // intl.t(key)
+        // 需要把脚本临时生成的key换成id，并存下词条的id
+        res.needReplace = true;
+        res.value = key;
+        downloadIds.push(id);
+      } else {
+        // intl.t(id)
+        // 把intl.t(id)中id对应的词条下载就行
+        downloadIds.push(key);
+      }
+    }
+
+    return res;
+  }
+
+  return {
+    // 导入声明，比如：import foo from "mod";
+    ImportDeclaration(path) {
+      // 是否已经导入过 intl 的依赖
+      const m = importCode.match(/from ["'](.*)["']/);
+      const pkgName = m ? m[1] : '';
+      if (path.node.source.value === pkgName) {
+        returns.hasImport = true;
+      }
+      path.skip();
+    },
+
+    // 函数或方法调用表达式，比如：a('中午')
+    CallExpression(path) {
+      const { node } = path;
+
+      if (!node.ignore) {
+        const { needReplace, value, skip } = dealCallExpressionNode(node);
+
+        if (needReplace) {
+          const res = makeReplace(value);
+          path.replaceWith(res);
+
+          path.node.ignore = true;
+        }
+        if (skip) path.skip();
+      }
+    },
+  };
+}

package/bin/scripts/util/transformAst.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const path = require('path');
+const prettier = require('prettier');
+const babel = require('@babel/core');
+const generate = require('@babel/generator').default;
+const traverse = require('@babel/traverse').default;
+const pluginSyntaxJSX = require('@babel/plugin-syntax-jsx');
+const pluginSyntaxProposalOptionalChaining = require('@babel/plugin-proposal-optional-chaining');
+const pluginSyntaxClassProperties = require('@babel/plugin-syntax-class-properties');
+const pluginSyntaxDecorators = require('@babel/plugin-syntax-decorators');
+const pluginSyntaxObjectRestSpread = require('@babel/plugin-syntax-object-rest-spread');
+const pluginSyntaxAsyncGenerators = require('@babel/plugin-syntax-async-generators');
+const pluginSyntaxDoExpressions = require('@babel/plugin-syntax-do-expressions');
+const pluginSyntaxDynamicImport = require('@babel/plugin-syntax-dynamic-import');
+const pluginSyntaxFunctionBind = require('@babel/plugin-syntax-function-bind');
+const presetTypescript = require('@babel/preset-typescript').default;
+
+const makeVisitorCollect = require('./makeVisitorCollect');
+const makeVisitorUpdate = require('./makeVisitorUpdate');
+
+// 获取文件中需要忽略转化通用国际化API规范的所有行号
+function getIgnoreLines(ast) {
+  const ignoreBlocks = [];
+  for (const comment of ast.comments) {
+    const { type, value, loc } = comment;
+    const last = ignoreBlocks.length - 1;
+
+    // 单行注释，比如 //
+    if (type === 'CommentLine' && value.trim() === 'cw-i18n-disable-line') {
+      ignoreBlocks.push({
+        start: loc.start.line,
+        end: loc.start.line,
+      });
+    }
+    // 多行注释，比如 /* */
+    else if (type === 'CommentBlock' && value.trim() === 'cw-i18n-disable') {
+      // 处理 di18n-disable 关闭 di18n-enable又开启的情况
+      if (last < 0 || ignoreBlocks[last].end) {
+        ignoreBlocks.push({
+          start: loc.start.line,
+        });
+      }
+    } else if (type === 'CommentBlock' && value.trim() === 'cw-i18n-enable') {
+      // 处理 di18n-disable 关闭 di18n-enable又开启的情况
+      if (last >= 0 && !ignoreBlocks[last].end) {
+        ignoreBlocks[last].end = loc.start.line;
+      }
+    }
+  }
+
+  // 如果缺少 disable-enable，直接作用到最后一行
+  const len = ignoreBlocks.length;
+  if (len > 0 && !ignoreBlocks[len - 1].end) {
+    ignoreBlocks[len - 1].end = ast.loc.end.line;
+  }
+
+  // 转换成需要忽略的行号
+  const ignoreLines = [];
+  for (const block of ignoreBlocks) {
+    for (let i = block.start; i <= block.end; i++) {
+      ignoreLines.push(i);
+    }
+  }
+
+  return ignoreLines;
+}
+
+module.exports = function (type, files = [], conf = {}, replaceWords) {
+  const {
+    entry,
+    output,
+    primaryRegx,
+    importCode,
+    i18nObject,
+    i18nMethod,
+    babelPresets = [],
+    babelPlugins = [],
+    ignoreComponents,
+    ignoreMethods,
+    ignoreAttributes,
+  } = conf;
+
+  const allWords = []; // 收集到的所有词条
+  const downloadIds = []; // 需要从平台下载的词条id
+
+  // babel配置
+  const transformOptions = {
+    sourceType: 'module',
+    ast: true,
+    configFile: false,
+    presets: [
+      ...babelPresets,
+      [
+        presetTypescript,
+        { isTSX: true, allExtensions: true },
+      ]
+    ],
+    plugins: [
+      pluginSyntaxJSX,
+      pluginSyntaxProposalOptionalChaining,
+      pluginSyntaxClassProperties,
+      [pluginSyntaxDecorators, { decoratorsBeforeExport: true }],
+      pluginSyntaxObjectRestSpread,
+      pluginSyntaxAsyncGenerators,
+      pluginSyntaxDoExpressions,
+      pluginSyntaxDynamicImport,
+      pluginSyntaxFunctionBind,
+      ...babelPlugins,
+    ],
+  };
+
+  const opts = {
+    primaryRegx,
+    i18nObject,
+    i18nMethod,
+    importCode,
+    ignoreLines: [],
+    ignoreMethods,
+    ignoreComponents,
+    ignoreAttributes,
+  };
+
+  // 处理所有文件
+  files.forEach((file) => {
+    const { filePath } = file;
+    const isTSX = ['.ts', '.tsx'].includes(path.extname(filePath));
+
+    const r = {
+      allWords,
+      replaceWords: replaceWords || {},
+      downloadIds,
+      hasImport: false, // 是否已经引入通用国际化API，import {init} from ...;
+      hasTouch: false, // 是否存在需要替换的词条
+    };
+    const sourceCode = fs.readFileSync(filePath, 'utf8');
+    const ast = babel.parseSync(sourceCode, transformOptions);
+    opts.ignoreLines = getIgnoreLines(ast);
+
+    let makeVisitor = makeVisitorCollect;
+    if (type === 'update') {
+      makeVisitor = makeVisitorUpdate
+    }
+
+    const visitor = makeVisitor(opts, r);
+    traverse(ast, visitor);
+
+    // 不传入需要替换的文词条则不进行文件修改
+    // 在只需要提取中文词条的情况下不传入replaceWords
+    if (!replaceWords) return;
+
+    // https://stackoverflow.com/a/55478641
+    let { code } = generate(ast, {
+      retainLines: true,
+      decoratorsBeforeExport: true,
+    });
+
+    if (!r.hasTouch) {
+      code = sourceCode;
+    } else if (!r.hasImport && importCode) {
+      code = `${importCode}\n${code}`;
+    }
+
+    // 自定义格式化代码
+    if (r.hasTouch) {
+      if (conf.prettier) {
+        const parser = isTSX ? 'typescript' : 'babel';
+        code = prettier.format(code, { ...conf.prettier, parser });
+      }
+
+      const target = output ? filePath.replace(entry, output) : filePath;
+      fs.writeFileSync(target, code, { encoding: 'utf-8' });
+    }
+  });
+
+  return {
+    allWords,
+    downloadIds,
+  };
+};

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+_Object$defineProperty(exports, "context", {
+  enumerable: true,
+  get: function get() {
+    return _context["default"];
+  }
+});
+_Object$defineProperty(exports, "intl", {
+  enumerable: true,
+  get: function get() {
+    return _reactIntlUniversal["default"];
+  }
+});
+_Object$defineProperty(exports, "useIntl", {
+  enumerable: true,
+  get: function get() {
+    return _useIntl["default"];
+  }
+});
+var _useIntl = _interopRequireDefault(require("./useIntl"));
+var _context = _interopRequireDefault(require("./useIntl/context"));
+var _reactIntlUniversal = _interopRequireDefault(require("react-intl-universal"));

package/lib/useIntl/context.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+var IntlStore = /*#__PURE__*/function () {
+  function IntlStore() {
+    (0, _classCallCheck2["default"])(this, IntlStore);
+    (0, _defineProperty2["default"])(this, "locales", {});
+    (0, _defineProperty2["default"])(this, "currentLocale", 'zh');
+  }
+  (0, _createClass2["default"])(IntlStore, [{
+    key: "registerLocales",
+    value:
+    // 存储语言
+    function registerLocales(locales) {
+      this.locales = locales;
+    }
+  }, {
+    key: "setLocale",
+    value:
+    // 更新当前语言
+    function setLocale(locale) {
+      this.currentLocale = locale;
+    }
+  }]);
+  return IntlStore;
+}();
+var _default = new IntlStore();
+exports["default"] = _default;

package/lib/useIntl/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+var _react = require("react");
+var _reactIntlUniversal = _interopRequireDefault(require("react-intl-universal"));
+var _useForceUpdate = _interopRequireDefault(require("./use-force-update"));
+var _context = _interopRequireDefault(require("./context"));
+var useIntl = function useIntl() {
+  var _useState = (0, _react.useState)(true),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var _useState3 = (0, _react.useState)(_context["default"].currentLocale),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    currentLocale = _useState4[0],
+    setCurrentLocale = _useState4[1];
+  var forceUpdate = (0, _useForceUpdate["default"])();
+  var registerLocales = function registerLocales(locales) {
+    _context["default"].registerLocales(locales);
+  };
+  var setLocale = function setLocale(locale) {
+    _context["default"].setLocale(locale);
+    setCurrentLocale(locale);
+    _reactIntlUniversal["default"].init({
+      currentLocale: locale,
+      locales: _context["default"].locales
+    });
+    if (loading) {
+      setLoading(false);
+    }
+    console.log('强制刷新');
+    forceUpdate();
+  };
+  return {
+    currentLocale: currentLocale,
+    registerLocales: registerLocales,
+    setLocale: setLocale,
+    loading: loading
+  };
+};
+var _default = useIntl;
+exports["default"] = _default;

package/lib/useIntl/use-force-update.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useForceUpdate;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+var _react = require("react");
+var createNewObject = function createNewObject() {
+  return {};
+};
+function useForceUpdate() {
+  var _useState = (0, _react.useState)(createNewObject),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    setValue = _useState2[1];
+  return (0, _react.useCallback)(function () {
+    setValue(createNewObject());
+  }, []);
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@chaoswise/intl",
+  "version": "1.0.0",
+  "author": "cloudwiser",
+  "description": "intl",
+  "main": "lib/index.js",
+  "bin": {
+    "chaoswise-intl": "bin/chaoswise-intl.js"
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.cloudwise.com/DOCP/aops_web_commons.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "init": "npm i",
+    "build": "gulp build --gulpfile ./scripts/gulpfile.js"
+  },
+  "keywords": [
+    "intl"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.20.5",
+    "@babel/generator": "^7.20.5",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-proposal-decorators": "^7.17.9",
+    "@babel/plugin-proposal-export-default-from": "^7.16.7",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.7",
+    "@babel/plugin-proposal-object-rest-spread": "^7.17.3",
+    "@babel/plugin-proposal-optional-chaining": "^7.18.9",
+    "@babel/plugin-proposal-private-methods": "^7.16.11",
+    "@babel/plugin-syntax-async-generators": "^7.8.4",
+    "@babel/plugin-syntax-class-properties": "^7.12.13",
+    "@babel/plugin-syntax-decorators": "^7.19.0",
+    "@babel/plugin-syntax-do-expressions": "^7.18.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-function-bind": "^7.18.6",
+    "@babel/plugin-syntax-jsx": "^7.18.6",
+    "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+    "@babel/plugin-transform-arrow-functions": "^7.16.7",
+    "@babel/plugin-transform-block-scoping": "^7.16.7",
+    "@babel/plugin-transform-classes": "^7.16.7",
+    "@babel/plugin-transform-destructuring": "^7.17.7",
+    "@babel/plugin-transform-for-of": "^7.16.7",
+    "@babel/plugin-transform-parameters": "^7.16.7",
+    "@babel/plugin-transform-shorthand-properties": "^7.16.7",
+    "@babel/plugin-transform-spread": "^7.16.7",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.18.6",
+    "@babel/runtime-corejs3": "^7.11.2",
+    "@babel/traverse": "^7.20.5",
+    "@babel/types": "^7.20.5",
+    "axios": "^0.21.1",
+    "babel-eslint": "^10.1.0",
+    "babel-loader": "^8.2.4",
+    "babel-plugin-import": "^1.13.0",
+    "babel-plugin-macros": "^3.1.0",
+    "babel-plugin-polyfill-corejs3": "^0.5.2",
+    "chalk": "^2.4.1",
+    "gulp": "^4.0.2",
+    "gulp-babel": "^8.0.0",
+    "gulp-typescript": "^5.0.1",
+    "gulp-connect": "^5.7.0",
+    "gulp-jsdoc3": "^3.0.0",
+    "prettier": "^2.8.1",
+    "glob": "^8.0.3",
+    "react-intl-universal": "^2.6.11",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1"
+  },
+  "license": "MIT"
+}