@chaoswise/intl 1.1.0 → 1.2.1

package/bin/scripts/collect.js

@@ -5,22 +5,31 @@ const getTargetFiles = require('./util/getTargetFiles');
 const transformAst = require('./util/transformAst');
 const log = require('./util/log');
 const file = require('./util/file');
-const getGroupName = require('./util/getGroupName');
+const writeNewWordsFile = require('./util/writeNewWordsFile');
 const { readWordJson } = require('./util/getWord');
+const getGroupName = require('./util/getGroupName');
 
 const service = require('./service');
 
 async function collect() {
-  log.info('词条扫描中...')
+
+  log.info('工程扫描中...')
+
   const conf = getConf();
+  const groupName = getGroupName();
+  const newWordsFileType = conf.newWordsFileType || 'excel';
+
+  // 检查newWordsFileType
+  if (!['json', 'excel'].includes(newWordsFileType)) {
+    log.error(`配置：newWordsFileType 只能为json或者excel`);
+    process.exit(1);
+  }
 
   // 读取wordJson
   if (conf.localWordPath && !readWordJson(conf.localWordPath)) {
     log.error('localWordPath配置有误');
     process.exit(1);
   }
-  // 读取groupName
-  const groupName = getGroupName();
 
   // 获取需要遍历的文件
   const files = getTargetFiles(conf);
@@ -31,6 +40,8 @@ async function collect() {
 
   // 在国际化平台中获取所有已存在中文信息
   const res = await service.searchByZh(info.allWords);
+  // 在国际化平台记录特殊方法
+  await service.saveMethod({ groupName, specialMethod: info.specialMethod });
 
   if (res.code !== 10000) {
     log.error('请求数据出错:' + res.msg);
@@ -41,10 +52,13 @@ async function collect() {
 
   const replaceWords = {}; // { zh: id } 需要在代码中替换的词条id
   const newWords = {}; // { zh1: '待翻译', zh2: '请选择:中文1/中文2' }
+  const exist = {}; // 根据中文只查出一条数据的已有词条
   Object.entries(wordsMap).forEach(([word, value]) => {
     // 如果当前中文词条在平台中存在，且对应英文翻译有且只有一条，那么直接替换代码中的中文为当前id，否则生成临时key，让开发者手动确认
     if (value.length === 1) {
-      replaceWords[word] = value[0].key;
+      const { id, key, zh, en } = value[0];
+      replaceWords[word] = key;
+      exist[id] = { id, key, zh, en };
     } else {
       const id = uuidv4();
       replaceWords[word] = id;
@@ -60,22 +74,25 @@ async function collect() {
     }
   });
 
+
+  // 在国际化平台中保存所有已存在词条
+  await service.saveExist({groupName, exist});
+
   // 第二次遍历，传入replaceWords，对代码进行国际化通用API转化，把词条替换成数据库的id，或者脚本临时生成的uuid
   transformAst('collect', files, conf, replaceWords);
 
-  log.success('脚本执行成功');
-  log.success('自定义配置文件在项目根目录的.intlconfig.js中');
+  log.success('★★★ 脚本执行成功 ★★★');
+  log.info('国际化配置文件： .intlconfig.js，可根据需求自定义修改');
   // 本次扫描出新的待翻译词条，写入到newWords中
   if (Object.keys(newWords).length) {
-    const newWordsJsonPath = 'newWords.json';
-
-    const oldNewWords = file.readJson(newWordsJsonPath) || {};
-    file.write(
-      newWordsJsonPath,
-      JSON.stringify({ ...oldNewWords, ...newWords, groupName }, null, 2)
-    );
+    writeNewWordsFile(newWordsFileType, newWords);
+  }
 
-    log.success(`需要翻译的文件在项目根目录的newWords.json中`);
+  const warnLogs = log.logs.warn;
+  if (warnLogs.length) {
+    const fileName = `intl.logs.warn.${(new Date).toLocaleString().replace(/[\/ ]/g, '_')}.txt`;
+    file.write(fileName, JSON.stringify(warnLogs, null, 2));
+    log.warn(`存在脚本无法处理的情况，具体查看 ${fileName} 手动处理`);
   }
 }
 

package/bin/scripts/conf/default.js

@@ -55,30 +55,30 @@ module.exports = function (excludes = []) {
       endOfLine: 'lf',
     },
 
-    // <Tag id={{ key: 'id' }} defaultMessage='中文' />
-    // intlTag 是 'Tag'
-    // intlTagIdPath 是 'id.key'
+    // <FormattedMessage id='id' defaultMessage='中文' />
+    // intlTag 是 'FormattedMessage'
+    // intlTagIdPath 是 'id'
     // intlTagDefaultWordPath 是 'defaultMessage'，并且如果不配置，默认是'defaultMessage'
-    intlTag: '',
-    intlTagIdPath: '',
-    intlTagDefaultWordPath: '',
+    intlTag: 'FormattedMessage',
+    intlTagIdPath: 'id',
+    intlTagDefaultWordPath: 'defaultMessage',
 
     // intl.formatMessage({
-    //   key: 'id',
+    //   id: 'id',
     //   defaultMessage: '默认值',
     // })
     // intlFunctionName 是 intl.formatMessage
-    // intlFunctionIdPath 是 '0.key'。 如果 配置成 'key' 也行，intlFunctionIdPath如果不以数字开头，会在前面加上'0.' 'key' 就会变成 '0.key'
+    // intlFunctionIdPath 是 '0.id'。 如果 配置成 'id' 也行，intlFunctionIdPath如果不以数字开头，会在前面加上'0.' 'id' 就会变成 '0.id'
     // intlFunctionDefaultWordPath 是 '0.defaultMessage',其他的说明同intlFunctionIdPath
-    intlFunctionName: '',
-    intlFunctionIdPath: '',
-    intlFunctionDefaultWordPath: '',
+    intlFunctionName: 'intl.formatMessage',
+    intlFunctionIdPath: 'id',
+    intlFunctionDefaultWordPath: 'defaultMessage',
 
     // 做过国际化的项目，中文config的路径。例如：'src/local/zh.json'
     localWordPath: '',
 
     // 配置 需要被脚本删除的依赖包的名字
-    removePkgName: [],
+    removePkgName: ['react-intl'],
 
     // 需要删除的函数和装饰器 的名称
     removeFunctionName: ['injectIntl'],
@@ -86,8 +86,11 @@ module.exports = function (excludes = []) {
     // package.json中项目名称的key
     groupNameKey: 'packageName',
 
-    // 特殊文件处理的正则  这里默认匹配router.config.js
-    specialFileReg: [/src\/config\/router\.config\.js/],
+    // 特殊文件处理数组的每一项为正则或者字符串  这里默认匹配router.config.js
+    specialFileReg: ['src/config/router.config.js'],
+
+    // newWords文件的类型 json或者excel
+    newWordsFileType: 'excel',
 
     // 国际化平台地址
     baseURL: 'http://10.0.1.133:18000',

package/bin/scripts/conf/initConfig.js

@@ -10,7 +10,7 @@ module.exports = function initConfig() {
   const customConfig = getCustomConfig();
 
   if (customConfig) {
-    console.log(`${customConfigName}已存在，请手动删除本地已经有的配置文件再重新执行 npm run intl-init`);
+    log.error(`${customConfigName}已存在，请删除后重新执行`);
     return;
   }
 
@@ -33,5 +33,5 @@ module.exports = function initConfig() {
     prettier.format(code, { ...defaultConfig.prettier, parser: 'babel' })
   );
 
-  log.success(`初始化配置文件成功：.intlconfig.js`);
+  log.success(`★★★ 初始化配置文件成功：.intlconfig.js ★★★`);
 }

package/bin/scripts/service/index.js

@@ -3,7 +3,7 @@ const getConf = require('../conf');
 
 const conf = getConf();
 
-axios.defaults.baseURL = (conf.baseURL || '') + '/api/i18n/dictionary';
+axios.defaults.baseURL = (conf.baseURL || '') + '/api/i18n';
 
 axios.interceptors.response.use(
   function (response) {
@@ -20,10 +20,20 @@ axios.interceptors.response.use(
 
 // 在国际化平台中获取所有已存在中文信息
 exports.searchByZh = (zhs) => {
-  return axios.post('/searchByZh', zhs);
+  return axios.post('/dictionary/searchByZh', zhs);
 };
 
 // 根据词条id获取所有数据库词条信息
 exports.getJson = ({ groupName, downloadIds }) => {
-  return axios.post('/getJson', { groupName, downloadIds });
+  return axios.post('/dictionary/getJson', { groupName, downloadIds });
+};
+
+// 保存替换的特殊方法
+exports.saveMethod = (data) => {
+  return axios.post('/history/method/save', data);
+};
+
+// 保存已有词条
+exports.saveExist = (data) => {
+  return axios.post('/history/exist/save', data);
 };

package/bin/scripts/update.js

@@ -6,6 +6,7 @@ const log = require('./util/log');
 const file = require('./util/file');
 
 async function update() {
+  log.info('词条更新中...')
   const conf = getConf();
   const files = getTargetFiles(conf);
 
@@ -13,17 +14,17 @@ async function update() {
   const relationKey = file.readJson('relationKey.json') || {};
 
   const info = transformAst('update', files, conf, relationKey);
-  await downloadJson(info.downloadIds);
+  await downloadJson(info.downloadIds.filter(Boolean));
 
   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('newWords.json和relationKey.json 已删除');
   }
 
-  log.success('脚本执行成功');
+  log.success('★★★ 脚本执行成功 ★★★');
 }
 
 // update();

package/bin/scripts/util/FormPath/contexts.d.ts

@@ -0,0 +1,10 @@
+export declare type Context = {
+    flag: string;
+    [key: string]: any;
+};
+export declare const bracketContext: Context;
+export declare const bracketArrayContext: Context;
+export declare const bracketDContext: Context;
+export declare const parenContext: Context;
+export declare const braceContext: Context;
+export declare const destructorContext: Context;

package/bin/scripts/util/FormPath/contexts.js

@@ -0,0 +1,23 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destructorContext = exports.braceContext = exports.parenContext = exports.bracketDContext = exports.bracketArrayContext = exports.bracketContext = void 0;
+var ContextType = function (flag, props) {
+    return __assign({ flag: flag }, props);
+};
+exports.bracketContext = ContextType("[]");
+exports.bracketArrayContext = ContextType("[\\d]");
+exports.bracketDContext = ContextType("[[]]");
+exports.parenContext = ContextType("()");
+exports.braceContext = ContextType("{}");
+exports.destructorContext = ContextType("{x}");

package/bin/scripts/util/FormPath/destructor.d.ts

@@ -0,0 +1,15 @@
+import { Segments, Node, DestrcutorRules } from './types';
+declare type Mutatators = {
+    getIn: (segments: Segments, source: any) => any;
+    setIn: (segments: Segments, source: any, value: any) => void;
+    deleteIn?: (segments: Segments, source: any) => any;
+    existIn?: (segments: Segments, source: any, start: number) => boolean;
+};
+export declare const getDestructor: (source: string) => any;
+export declare const setDestructor: (source: string, rules: DestrcutorRules) => void;
+export declare const parseDestructorRules: (node: Node) => DestrcutorRules;
+export declare const setInByDestructor: (source: any, rules: DestrcutorRules, value: any, mutators: Mutatators) => void;
+export declare const getInByDestructor: (source: any, rules: DestrcutorRules, mutators: Mutatators) => {};
+export declare const deleteInByDestructor: (source: any, rules: DestrcutorRules, mutators: Mutatators) => void;
+export declare const existInByDestructor: (source: any, rules: DestrcutorRules, start: number, mutators: Mutatators) => boolean;
+export {};

package/bin/scripts/util/FormPath/destructor.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.existInByDestructor = exports.deleteInByDestructor = exports.getInByDestructor = exports.setInByDestructor = exports.parseDestructorRules = exports.setDestructor = exports.getDestructor = void 0;
+var types_1 = require("./types");
+var utils_1 = require("./utils");
+var DestrcutorCache = new Map();
+var isValid = function (val) { return val !== undefined && val !== null; };
+exports.getDestructor = function (source) {
+    return DestrcutorCache.get(source);
+};
+exports.setDestructor = function (source, rules) {
+    DestrcutorCache.set(source, rules);
+};
+exports.parseDestructorRules = function (node) {
+    var rules = [];
+    if (types_1.isObjectPattern(node)) {
+        var index_1 = 0;
+        node.properties.forEach(function (child) {
+            rules[index_1] = {
+                path: []
+            };
+            rules[index_1].key = child.key.value;
+            rules[index_1].path.push(child.key.value);
+            if (types_1.isIdentifier(child.value)) {
+                rules[index_1].key = child.value.value;
+            }
+            var basePath = rules[index_1].path;
+            var childRules = exports.parseDestructorRules(child.value);
+            var k = index_1;
+            childRules.forEach(function (rule) {
+                if (rules[k]) {
+                    rules[k].key = rule.key;
+                    rules[k].path = basePath.concat(rule.path);
+                }
+                else {
+                    rules[k] = {
+                        key: rule.key,
+                        path: basePath.concat(rule.path)
+                    };
+                }
+                k++;
+            });
+            if (k > index_1) {
+                index_1 = k;
+            }
+            else {
+                index_1++;
+            }
+        });
+        return rules;
+    }
+    else if (types_1.isArrayPattern(node)) {
+        var index_2 = 0;
+        node.elements.forEach(function (child, key) {
+            rules[index_2] = {
+                path: []
+            };
+            rules[index_2].key = key;
+            rules[index_2].path.push(key);
+            if (types_1.isIdentifier(child)) {
+                rules[index_2].key = child.value;
+            }
+            var basePath = rules[index_2].path;
+            var childRules = exports.parseDestructorRules(child);
+            var k = index_2;
+            childRules.forEach(function (rule) {
+                if (rules[k]) {
+                    rules[k].key = rule.key;
+                    rules[k].path = basePath.concat(rule.path);
+                }
+                else {
+                    rules[k] = {
+                        key: rule.key,
+                        path: basePath.concat(rule.path)
+                    };
+                }
+                k++;
+            });
+            if (k > index_2) {
+                index_2 = k;
+            }
+            else {
+                index_2++;
+            }
+        });
+        return rules;
+    }
+    if (types_1.isDestructorExpression(node)) {
+        return exports.parseDestructorRules(node.value);
+    }
+    return rules;
+};
+exports.setInByDestructor = function (source, rules, value, mutators) {
+    rules.forEach(function (_a) {
+        var key = _a.key, path = _a.path;
+        mutators.setIn([key], source, mutators.getIn(path, value));
+    });
+};
+exports.getInByDestructor = function (source, rules, mutators) {
+    var response = {};
+    if (rules.length) {
+        if (utils_1.isNum(rules[0].path[0])) {
+            response = [];
+        }
+    }
+    source = isValid(source) ? source : {};
+    rules.forEach(function (_a) {
+        var key = _a.key, path = _a.path;
+        mutators.setIn(path, response, source[key]);
+    });
+    return response;
+};
+exports.deleteInByDestructor = function (source, rules, mutators) {
+    rules.forEach(function (_a) {
+        var key = _a.key;
+        mutators.deleteIn([key], source);
+    });
+};
+exports.existInByDestructor = function (source, rules, start, mutators) {
+    return rules.every(function (_a) {
+        var key = _a.key;
+        return mutators.existIn([key], source, start);
+    });
+};

package/bin/scripts/util/FormPath/index.d.ts

@@ -0,0 +1,49 @@
+import { Segments, Node, Pattern } from './types';
+export * from './types';
+export declare class Path {
+    entire: string;
+    segments: Segments;
+    isMatchPattern: boolean;
+    isWildMatchPattern: boolean;
+    haveExcludePattern: boolean;
+    matchScore: number;
+    tree: Node;
+    private matchCache;
+    private includesCache;
+    constructor(input: Pattern);
+    toString(): string;
+    toArray(): Segments;
+    get length(): number;
+    private parse;
+    private parseString;
+    concat: (...args: Pattern[]) => Path;
+    slice: (start?: number, end?: number) => Path;
+    push: (item: Pattern) => this;
+    pop: () => void;
+    splice: (start: number, deleteCount?: number, ...items: Array<string | number>) => this;
+    forEach: (callback: (key: string | number) => any) => void;
+    map: (callback: (key: string | number) => any) => any[];
+    reduce: <T>(callback: (buf: T, item: string | number, index: number) => T, initial: T) => T;
+    getNearestChildPathBy: (target?: Pattern) => Path;
+    parent: () => Path;
+    includes: (pattern: Pattern) => any;
+    transform: <T>(regexp: string | RegExp, callback: (...args: string[]) => T) => string | T;
+    match: (pattern: Pattern) => boolean;
+    matchAliasGroup: (name: Pattern, alias: Pattern) => boolean;
+    existIn: (source?: any, start?: number | Path) => boolean;
+    getIn: (source?: any) => any;
+    setIn: (source?: any, value?: any) => any;
+    deleteIn: (source?: any) => any;
+    static match(pattern: Pattern): {
+        (target: any): boolean;
+        path: Path;
+    };
+    static transform<T>(pattern: Pattern, regexp: string | RegExp, callback: (...args: string[]) => T): any;
+    static parse(path?: Pattern): Path;
+    static getPath(path?: Pattern): Path;
+    static getIn: (source: any, pattern: Pattern) => any;
+    static setIn: (source: any, pattern: Pattern, value: any) => any;
+    static deleteIn: (source: any, pattern: Pattern) => any;
+    static existIn: (source: any, pattern: Pattern, start?: number | Path) => boolean;
+}
+export default Path;