@chaoswise/intl 1.1.0 → 1.2.0

package/bin/scripts/collect.js

@@ -5,7 +5,7 @@ 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 service = require('./service');
@@ -13,14 +13,19 @@ const service = require('./service');
 async function collect() {
   log.info('词条扫描中...')
   const conf = getConf();
+  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);
@@ -67,15 +72,14 @@ async function collect() {
   log.success('自定义配置文件在项目根目录的.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.warnToLog(`警告日志文件:${fileName}`);
   }
 }
 

package/bin/scripts/conf/default.js

@@ -89,6 +89,9 @@ module.exports = function (excludes = []) {
     // 特殊文件处理的正则  这里默认匹配router.config.js
     specialFileReg: [/src\/config\/router\.config\.js/],
 
+    // newWords文件的类型 json或者excel
+    newWordsFileType: 'excel',
+
     // 国际化平台地址
     baseURL: 'http://10.0.1.133:18000',
   };

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;