ztxkutils 10.0.11 → 20.0.2

package/dist/request.d.ts

@@ -15,7 +15,20 @@ export interface IOptions extends AxiosRequestConfig {
     isCancelRepeat?: boolean;
     isCancelNoCompleteRequest?: boolean;
     noInterceptorsResponse?: boolean;
+    /**
+     * 是否自主缓存
+     */
+    isAutonomousCatch?: boolean;
+    /**
+     * 每个接口自主缓存的最大限制
+     */
+    autonomousCount?: number;
+    /**
+     * 自主缓存的key值，默认取url
+     */
+    autonomousKey?: string;
 }
 export default function request(myOptions: IOptions, jumpCallback?: any, otherOptions?: any): any;
 export declare function clearNoCompleteRequest(): void;
 export declare function clearCatch(): void;
+export declare function clearAutonomousCatch(url: any): void;

package/dist/request.js

@@ -1,7 +1,8 @@
 import './tslib.es6-35653116.js';
+import './i18next.js';
 import 'axios';
 import 'ztxkui';
-export { N as NEW_AUTHORIZATION, O as OLD_AUTHORIZATION, b as clearCatch, c as clearNoCompleteRequest, a as default } from './request-986d7090.js';
+export { N as NEW_AUTHORIZATION, O as OLD_AUTHORIZATION, d as clearAutonomousCatch, b as clearCatch, c as clearNoCompleteRequest, a as default } from './request-d1972b41.js';
 import './authority-7a91cb9f.js';
 import './crypto-c481f616.js';
 import 'crypto';

package/dist/stompClient.js

@@ -1,3 +1,4 @@
+import instance from './i18next.js';
 import Stomp from 'zt-stompjs';
 import SockJS from 'zt-sockjs-client';
 import { g as getToken } from './authority-7a91cb9f.js';
@@ -58,18 +59,22 @@ var StompClient = /** @class */ (function () {
         this.clearIsClient = setTimeout(function () {
             _this.clearIsClient = null;
             if (!_this.isClient) {
-                console.log("\u8FDE\u63A5\u5DF2\u53D1\u8D77\uFF0C\u4F46\u662F10\u79D2\u540E\u672A\u6210\u529F\u5EFA\u7ACB\u8FDE\u63A5\uFF0C\u624B\u52A8\u65AD\u5F00\u91CD\u8FDE!system=" + _this.connectWsConfig.systemType);
+                console.log(instance.t('连接已发起，但是10秒后未成功建立连接，手动断开重连!system={{slot0}}', { slot0: _this.connectWsConfig.systemType }));
                 try {
                     _this.client.disconnect(function () {
                         _this.client = null;
                     });
                 }
                 catch (err) {
-                    console.log('---连接未建立的关闭出错---', err);
+                    console.log(instance.t('---连接未建立的关闭出错---'), err);
                 }
                 _this.reconnectionNum++;
                 var timeInterval = _this.getReconnectionTime();
-                console.log("---\u7B2C" + _this.reconnectionNum + "\u6B21\u91CD\u8FDE\uFF01time=" + Date.now() + "system=" + _this.connectWsConfig.systemType + "---");
+                console.log(instance.t('---第{{slot0}}次重连！time={{slot1}}system={{slot2}}---', {
+                    slot0: _this.reconnectionNum,
+                    slot1: Date.now(),
+                    slot2: _this.connectWsConfig.systemType,
+                }));
                 if (_this.clearIsClientNo) {
                     clearTimeout(_this.clearIsClientNo);
                     _this.clearIsClientNo = null;
@@ -112,7 +117,11 @@ var StompClient = /** @class */ (function () {
                 _this.clearIsClientYes = null;
             }
             _this.reconnectionNum = 0;
-            console.log("---------\u8FDE\u63A5\u6210\u529F time=" + Date.now() + " system=" + _this.connectWsConfig.systemType + " time=" + Date.now() + "--------");
+            console.log(instance.t('---------连接成功 time={{slot0}} system={{slot1}} time={{slot2}}--------', {
+                slot0: Date.now(),
+                slot1: _this.connectWsConfig.systemType,
+                slot2: Date.now(),
+            }));
             // 连接成功后，将当前已注册的，未执行的 连接通道 连接
             var subscriptionsFnKeys = Object.keys(_this.subscriptionsFn);
             if (Array.isArray(subscriptionsFnKeys)) {
@@ -145,7 +154,7 @@ var StompClient = /** @class */ (function () {
         }, 
         // 连接失败回调
         function (err) {
-            console.log("---------\u8FDE\u63A5\u5931\u8D25 system=" + _this.connectWsConfig.systemType + " time=" + Date.now() + "--------");
+            console.log(instance.t('---------连接失败 system={{slot0}} time={{slot1}}--------', { slot0: _this.connectWsConfig.systemType, slot1: Date.now() }));
             console.log(err);
             if (_this.userClose) {
                 _this.userClose = false; // 重新初始化 重新计算
@@ -161,7 +170,7 @@ var StompClient = /** @class */ (function () {
                     clearTimeout(_this.clearIsClientYes);
                     _this.clearIsClientYes = null;
                 }
-                console.log('用户主动关闭');
+                console.log(instance.t('用户主动关闭'));
                 return;
             }
             _this.isClient = true;
@@ -211,14 +220,18 @@ var StompClient = /** @class */ (function () {
                 });
             }
             catch (err) {
-                console.log("---\u8FDE\u63A5\u5DF2\u5EFA\u7ACB\u7684\u5173\u95ED\u51FA\u9519 time=" + Date.now() + "system=" + _this.connectWsConfig.systemType + "---", err);
+                console.log(instance.t('---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---', { slot0: Date.now(), slot1: _this.connectWsConfig.systemType }), err);
             }
             _this.reconnectionNum++;
             // const timeInterval =
             //   Math.ceil(this.reconnectionNum / 5) *
             //   (this.connectWsConfig.reconnectionTime ?? 3000);
             var timeInterval = _this.getReconnectionTime();
-            console.log("---\u7B2C" + _this.reconnectionNum + "\u6B21\u91CD\u8FDE\uFF01time=" + Date.now() + "system=" + _this.connectWsConfig.systemType);
+            console.log(instance.t('---第{{slot0}}次重连！time={{slot1}}system={{slot2}}', {
+                slot0: _this.reconnectionNum,
+                slot1: Date.now(),
+                slot2: _this.connectWsConfig.systemType,
+            }));
             _this.clearIsClientYes = setTimeout(function () {
                 _this.init();
             }, timeInterval > _this.maxReconnectiontime

package/dist/useFileIdToBase64.js

@@ -4,6 +4,8 @@ import './authority-7a91cb9f.js';
 import './tools-390e3466.js';
 import './tslib.es6-35653116.js';
 import 'dayjs';
+import './crypto-c481f616.js';
+import 'crypto';
 
 /**
  * 图片附件id转base64字符串

package/dist/validate-21b58a69.js

@@ -0,0 +1,260 @@
+import instance from './i18next.js';
+
+/**
+ * @description 常用正则表达式
+ */
+var validate = {
+    /**
+     * @description 长度验证，最小长度字符，0-200个字符
+     */
+    smallLenValidate: /^(?:\s*)[\s\S]{0,200}(?:\s*)$/,
+    /**
+     * @description 长度验证，中等长度字符，0-400个字符
+     */
+    middleLenValidate: /^(?:\s*)[\s\S]{0,400}(?:\s*)$/,
+    /**
+     * @description 长度验证，最大长度字符，0-600个字符
+     */
+    largeLenValidate: /^(?:\s*)[\s\S]{0,600}(?:\s*)$/,
+    /**
+     * @description 长度验证，最大长度字符，0-5000个字符
+     */
+    maxlargeLenValidate: /^(?:\s*)[\s\S]{0,5000}(?:\s*)$/,
+    /**
+     * @description 电话号码验证
+     */
+    // phoneValidate: /^1(3\d|4\d|5\d|6\d|7\d|8\d|9\d)\d{8}$/,
+    // 数字 横线 长度 0 - 15位/^([0-9])|(\-)*$/
+    phoneValidate: /^[0-9\-]{0,15}$/,
+    /**
+     * @description 短信验证码 接受11位手机号
+     */
+    shortPhoneValidate: /^1[0-9]{10}$/,
+    /**
+     * @description 身份证验证
+     *              18位 最后一位可以是X x
+     */
+    idCardValidate: /^[1-9]\d{5}(18|19|20|(3\d))\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/,
+    /**
+     * @description 邮箱验证
+     */
+    emailValidate: /^([\s\S])+\@([A-Za-z0-9_\-\.])+\.([A-Za-z]{2,8})$/,
+    /**
+     * @description 密码验证
+     */
+    // passwordValidate: /^(?![0-9]+$)(?![a-z]+$)(?![A-Z]+$)(?!([^(0-9a-zA-Z)])+$)^.{8,16}$/,
+    passwordValidate: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).{8,}$/,
+    /**
+     * @description 空格验证
+     */
+    spaceValidate: /^[^\s]*$/g,
+};
+var commonMessage = {
+    smallLenMessage: function (type) {
+        if (type === void 0) { type = ''; }
+        return instance.t('{{type}}超过最大字符长度200', { type: type });
+    },
+    middleLenMessage: function (type) {
+        if (type === void 0) { type = ''; }
+        return instance.t('{{type}}超过最大字符长度400', { type: type });
+    },
+    largeLenMessage: function (type) {
+        if (type === void 0) { type = ''; }
+        return instance.t('{{type}}超过最大字符长度600', { type: type });
+    },
+    maxlargeLenValidate: function (type) {
+        if (type === void 0) { type = ''; }
+        return instance.t('{{type}}超过最大字符长度5000', { type: type });
+    },
+    phoneMessage: instance.t('请输入正确的手机号'),
+    idCardMessage: instance.t('请输入正确的身份证'),
+    emailMessage: instance.t('请输入正确的邮箱'),
+    // passwordMessage: '密码由8-16位的字母+数字，字母+特殊字符，数字+特殊字符组成',
+    passwordMessage: instance.t('密码必须包含大小写字母、数字、特殊字符且最小长度为8，且不能出现连续数字或字符，不能出现相同字符，且禁止使用用户账号作为密码'),
+    spaceMessage: instance.t('请勿输入空格'),
+};
+var alphabet1 = [
+    'abcdefghijklmnopqrstuvwxyz',
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    '0123456789',
+];
+var alphabet2 = ['qwertyuiop', 'asdfghjkl', 'zxcvbnm'];
+var alphabet3 = ['qaz', 'wsx', 'edc', 'rfv', 'tgb', 'yhn', 'ujm'];
+function isConsecutiveChars(char1, char2, alphabetArr) {
+    // const lowerCaseAlphabet = 'abcdefghijklmnopqrstuvwxyz'; // 小写字母
+    // const upperCaseAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; // 大写字母
+    // const numeric = '0123456789'; // 数字
+    // 找到包含两个字符的字符集
+    var alphabet = alphabetArr.find(function (alph) { return alph.includes(char1) && alph.includes(char2); });
+    if (!alphabet) {
+        return false; // 如果两个字符不在同一字符集中，那么它们不可能连续
+    }
+    var index1 = alphabet.indexOf(char1);
+    var index2 = alphabet.indexOf(char2);
+    // return Math.abs(index1 - index2) === 1; // 如果两个字符在字符集中的位置相邻，那么它们是连续的
+    return index1 - index2;
+}
+function validatePassword(password, username) {
+    // 用正则表达式检查密码基本规则
+    var regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).{8,}$/;
+    if (!regex.test(password)) {
+        return {
+            result: false,
+            message: instance.t('密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!'),
+        };
+    }
+    // 检查密码是否与用户名相同
+    if (password === username) {
+        return {
+            result: false,
+            message: instance.t('密码与用户名相同!'),
+        };
+    }
+    // 检查密码中是否有相同且连续的字符 超过三次
+    var count1 = 0;
+    for (var i = 0; i < password.length - 1; i++) {
+        if (password[i] === password[i + 1]) {
+            count1++;
+            if (count1 >= 2) {
+                return {
+                    result: false,
+                    message: instance.t('密码中有相同且连续超过三次的字符!'),
+                };
+            }
+        }
+        else {
+            count1 = 0;
+        }
+    }
+    // 检查密码中是否有连续的字母或数字 连续超过三次
+    var count = 0;
+    var startChart = 0;
+    var currentConsecutiveCount = 0; // 记录上次是递增还是递减
+    // 第一次循环 找出 连续字母 数字
+    for (var i = 0; i < password.length - 1; i++) {
+        var consecutiveCount = isConsecutiveChars(password[i], password[i + 1], alphabet1);
+        // 是递增 还是 递减
+        if (consecutiveCount === 1 || consecutiveCount === -1) {
+            if (currentConsecutiveCount === 0) {
+                currentConsecutiveCount = consecutiveCount;
+            }
+            if (count === 0) {
+                startChart = i;
+            }
+            // 如果记录到上次跟本次的连续规则相同
+            if (currentConsecutiveCount === consecutiveCount) {
+                count++;
+                if (count >= 2) {
+                    // 密码中不应含有连续的字母或数字
+                    return {
+                        result: false,
+                        message: instance.t('从第{{slot0}}个字符开始，有连续{{slot1}}超过三位的字母或数字!', {
+                            slot0: startChart + 1,
+                            slot1: currentConsecutiveCount === 1 ? '递减' : '递增',
+                        }),
+                    };
+                }
+            }
+            else {
+                // 需要重置规则
+                count = 0;
+                startChart = 0;
+            }
+            currentConsecutiveCount = consecutiveCount;
+        }
+        else {
+            count = 0;
+            startChart = 0;
+            currentConsecutiveCount = 0;
+        }
+    }
+    // 第二次循环 找出键盘连续横排字母
+    for (var i = 0; i < password.length - 1; i++) {
+        var consecutiveCount = isConsecutiveChars(password[i], password[i + 1], alphabet2);
+        // 是递增 还是 递减
+        if (consecutiveCount === 1 || consecutiveCount === -1) {
+            if (currentConsecutiveCount === 0) {
+                currentConsecutiveCount = consecutiveCount;
+            }
+            if (count === 0) {
+                startChart = i;
+            }
+            // 如果记录到上次跟本次的连续规则相同
+            if (currentConsecutiveCount === consecutiveCount) {
+                count++;
+                if (count >= 2) {
+                    // 密码中不应含有连续的字母或数字
+                    return {
+                        result: false,
+                        message: instance.t('从第{{slot0}}个字符开始，有按键盘横向连续{{slot1}}超过三位的字母!', {
+                            slot0: startChart + 1,
+                            slot1: currentConsecutiveCount === 1 ? '递减' : '递增',
+                        }),
+                    };
+                }
+            }
+            else {
+                // 需要重置规则
+                count = 0;
+                startChart = 0;
+            }
+            currentConsecutiveCount = consecutiveCount;
+        }
+        else {
+            count = 0;
+            startChart = 0;
+            currentConsecutiveCount = 0;
+        }
+    }
+    // 第三次循环 找出键盘连续竖排字母
+    for (var i = 0; i < password.length - 1; i++) {
+        var consecutiveCount = isConsecutiveChars(password[i], password[i + 1], alphabet3);
+        // 是递增 还是 递减
+        if (consecutiveCount === 1 || consecutiveCount === -1) {
+            if (currentConsecutiveCount === 0) {
+                currentConsecutiveCount = consecutiveCount;
+            }
+            if (count === 0) {
+                startChart = i;
+            }
+            // 如果记录到上次跟本次的连续规则相同
+            if (currentConsecutiveCount === consecutiveCount) {
+                count++;
+                if (count >= 2) {
+                    // 密码中不应含有连续的字母或数字
+                    return {
+                        result: false,
+                        message: instance.t('从第{{slot0}}个字符开始，有按键盘竖向连续{{slot1}}超过三位的字母或数字!', {
+                            slot0: startChart + 1,
+                            slot1: currentConsecutiveCount === 1 ? '递减' : '递增',
+                        }),
+                    };
+                }
+            }
+            else {
+                // 需要重置规则
+                count = 0;
+                startChart = 0;
+            }
+            currentConsecutiveCount = consecutiveCount;
+        }
+        else {
+            count = 0;
+            startChart = 0;
+            currentConsecutiveCount = 0;
+        }
+    }
+    // 如果通过了所有的检查，则返回true
+    return {
+        result: true,
+    };
+}
+
+var validate$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  validatePassword: validatePassword,
+  validate: validate,
+  commonMessage: commonMessage
+});
+
+export { validatePassword as a, validate as b, commonMessage as c, validate$1 as v };

package/dist/validate.js

@@ -1 +1,2 @@
-export { c as commonMessage, b as validate, a as validatePassword } from './validate-18e52490.js';
+import './i18next.js';
+export { c as commonMessage, b as validate, a as validatePassword } from './validate-21b58a69.js';

package/dist/workflow.js

@@ -1,12 +1,10 @@
+import instance from './i18next.js';
 import { useEffect } from 'react';
 import { g as getUrlSearch } from './tools-390e3466.js';
 import { WORKFLOW_HIDEFRAME_KEY } from './constants.js';
 import './tslib.es6-35653116.js';
 import 'dayjs';
 
-/**
- * @description 审批工作流相关操作
- */
 /**
  * @description 通过iframe双向通信逻辑
  */
@@ -14,7 +12,7 @@ function useOnmessage(messageFn, isDebugger) {
     useEffect(function () {
         var messageHandle = function (e) {
             if (isDebugger) {
-                console.log('父页面传递过来的消息', e);
+                console.log(instance.t('父页面传递过来的消息'), e);
             }
             var messageData = {};
             try {
@@ -22,7 +20,7 @@ function useOnmessage(messageFn, isDebugger) {
             }
             catch (err) {
                 if (isDebugger) {
-                    console.log('父页面传递过来的消息解析报错', err);
+                    console.log(instance.t('父页面传递过来的消息解析报错'), err);
                 }
             }
             messageFn && messageFn(messageData);

package/locales/en-US.json

@@ -0,0 +1,64 @@
+{
+  "拦截重复请求": "拦截重复请求",
+  "切换将清空已选数据！": "切换将清空已选数据！",
+  "确认": "确认",
+  "取消": "取消",
+  "数据请求成功": "数据请求成功",
+  "数据请求失败": "数据请求失败",
+  "必须传入获取Ws长连接的方法": "必须传入获取Ws长连接的方法",
+  "获取ws链接地址失败!": "获取ws链接地址失败!",
+  "获取ws地址失败!": "获取ws地址失败!",
+  "浏览器不支持WebSocket": "浏览器不支持WebSocket",
+  "连接建立": "连接建立",
+  "识别结果：": "识别结果：",
+  "ws连接出错了!": "ws连接出错了!",
+  "连接异常": "连接异常",
+  "连接关闭": "连接关闭",
+  "你没有引入路由相关API，请引入!": "你没有引入路由相关API，请引入!",
+  "握手成功": "握手成功",
+  "收到讯飞的语音提示": "收到讯飞的语音提示",
+  "出错了:": "出错了:",
+  "连接出错了": "连接出错了",
+  "收到录音的最后帧!": "收到录音的最后帧!",
+  "你没有传入 获取指令的接口，这将导致错误!": "你没有传入 获取指令的接口，这将导致错误!",
+  "不支持处理该指令，请重说!": "不支持处理该指令，请重说!",
+  "{{slot0}} 第{{slot1}}行{{title}} {{slot2}}": "{{slot0}} 第{{slot1}}行{{title}} {{slot2}}",
+  "{{slot0}} 第{{slot1}}行{{title}}为空!": "{{slot0}} 第{{slot1}}行{{title}}为空!",
+  "中文": "中文",
+  "英文": "英文",
+  "数据库打开成功": "数据库打开成功",
+  "数据库打开报错!": "数据库打开报错!",
+  "浙商中拓": "浙商中拓",
+  "{{slot0}} 微软雅黑": "{{slot0}} 微软雅黑",
+  "刷新token遭到频繁调用，请联系管理员查看是否接口权限出现问题，可能是{{slot0}}接口出现问题": "刷新token遭到频繁调用，请联系管理员查看是否接口权限出现问题，可能是{{slot0}}接口出现问题",
+  "token已经刷新成功，请重新提交！": "token已经刷新成功，请重新提交！",
+  "登录过期！": "登录过期！",
+  "请求超时，请稍后再试，请去列表确认数据是否插入成功，请勿重复提交！ 接口地址:{{slot0}} 请求方式:{{slot1}} 请求超时时间:{{slot2}}": "请求超时，请稍后再试，请去列表确认数据是否插入成功，请勿重复提交！ 接口地址:{{slot0}} 请求方式:{{slot1}} 请求超时时间:{{slot2}}",
+  "接口: {{slot0}} 未找到！": "接口: {{slot0}} 未找到！",
+  "你的账号已在其他地方登录！": "你的账号已在其他地方登录！",
+  "连接已发起，但是10秒后未成功建立连接，手动断开重连!system={{slot0}}": "连接已发起，但是10秒后未成功建立连接，手动断开重连!system={{slot0}}",
+  "---连接未建立的关闭出错---": "---连接未建立的关闭出错---",
+  "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}---": "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}---",
+  "---------连接成功 time={{slot0}} system={{slot1}} time={{slot2}}--------": "---------连接成功 time={{slot0}} system={{slot1}} time={{slot2}}--------",
+  "---------连接失败 system={{slot0}} time={{slot1}}--------": "---------连接失败 system={{slot0}} time={{slot1}}--------",
+  "用户主动关闭": "用户主动关闭",
+  "---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---": "---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---",
+  "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}": "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}",
+  "{{type}}超过最大字符长度200": "{{type}}超过最大字符长度200",
+  "{{type}}超过最大字符长度400": "{{type}}超过最大字符长度400",
+  "{{type}}超过最大字符长度600": "{{type}}超过最大字符长度600",
+  "{{type}}超过最大字符长度5000": "{{type}}超过最大字符长度5000",
+  "请输入正确的手机号": "请输入正确的手机号",
+  "请输入正确的身份证": "请输入正确的身份证",
+  "请输入正确的邮箱": "请输入正确的邮箱",
+  "密码必须包含大小写字母、数字、特殊字符且最小长度为8，且不能出现连续数字或字符，不能出现相同字符，且禁止使用用户账号作为密码": "密码必须包含大小写字母、数字、特殊字符且最小长度为8，且不能出现连续数字或字符，不能出现相同字符，且禁止使用用户账号作为密码",
+  "请勿输入空格": "请勿输入空格",
+  "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!": "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!",
+  "密码与用户名相同!": "密码与用户名相同!",
+  "密码中有相同且连续超过三次的字符!": "密码中有相同且连续超过三次的字符!",
+  "从第{{slot0}}个字符开始，有连续{{slot1}}超过三位的字母或数字!": "从第{{slot0}}个字符开始，有连续{{slot1}}超过三位的字母或数字!",
+  "从第{{slot0}}个字符开始，有按键盘横向连续{{slot1}}超过三位的字母!": "从第{{slot0}}个字符开始，有按键盘横向连续{{slot1}}超过三位的字母!",
+  "从第{{slot0}}个字符开始，有按键盘竖向连续{{slot1}}超过三位的字母或数字!": "从第{{slot0}}个字符开始，有按键盘竖向连续{{slot1}}超过三位的字母或数字!",
+  "父页面传递过来的消息": "父页面传递过来的消息",
+  "父页面传递过来的消息解析报错": "父页面传递过来的消息解析报错"
+}

package/locales/zh-CN.json

@@ -0,0 +1,64 @@
+{
+  "拦截重复请求": "拦截重复请求",
+  "切换将清空已选数据！": "切换将清空已选数据！",
+  "确认": "确认",
+  "取消": "取消",
+  "数据请求成功": "数据请求成功",
+  "数据请求失败": "数据请求失败",
+  "必须传入获取Ws长连接的方法": "必须传入获取Ws长连接的方法",
+  "获取ws链接地址失败!": "获取ws链接地址失败!",
+  "获取ws地址失败!": "获取ws地址失败!",
+  "浏览器不支持WebSocket": "浏览器不支持WebSocket",
+  "连接建立": "连接建立",
+  "识别结果：": "识别结果：",
+  "ws连接出错了!": "ws连接出错了!",
+  "连接异常": "连接异常",
+  "连接关闭": "连接关闭",
+  "你没有引入路由相关API，请引入!": "你没有引入路由相关API，请引入!",
+  "握手成功": "握手成功",
+  "收到讯飞的语音提示": "收到讯飞的语音提示",
+  "出错了:": "出错了:",
+  "连接出错了": "连接出错了",
+  "收到录音的最后帧!": "收到录音的最后帧!",
+  "你没有传入 获取指令的接口，这将导致错误!": "你没有传入 获取指令的接口，这将导致错误!",
+  "不支持处理该指令，请重说!": "不支持处理该指令，请重说!",
+  "{{slot0}} 第{{slot1}}行{{title}} {{slot2}}": "{{slot0}} 第{{slot1}}行{{title}} {{slot2}}",
+  "{{slot0}} 第{{slot1}}行{{title}}为空!": "{{slot0}} 第{{slot1}}行{{title}}为空!",
+  "中文": "中文",
+  "英文": "英文",
+  "数据库打开成功": "数据库打开成功",
+  "数据库打开报错!": "数据库打开报错!",
+  "浙商中拓": "浙商中拓",
+  "{{slot0}} 微软雅黑": "{{slot0}} 微软雅黑",
+  "刷新token遭到频繁调用，请联系管理员查看是否接口权限出现问题，可能是{{slot0}}接口出现问题": "刷新token遭到频繁调用，请联系管理员查看是否接口权限出现问题，可能是{{slot0}}接口出现问题",
+  "token已经刷新成功，请重新提交！": "token已经刷新成功，请重新提交！",
+  "登录过期！": "登录过期！",
+  "请求超时，请稍后再试，请去列表确认数据是否插入成功，请勿重复提交！ 接口地址:{{slot0}} 请求方式:{{slot1}} 请求超时时间:{{slot2}}": "请求超时，请稍后再试，请去列表确认数据是否插入成功，请勿重复提交！ 接口地址:{{slot0}} 请求方式:{{slot1}} 请求超时时间:{{slot2}}",
+  "接口: {{slot0}} 未找到！": "接口: {{slot0}} 未找到！",
+  "你的账号已在其他地方登录！": "你的账号已在其他地方登录！",
+  "连接已发起，但是10秒后未成功建立连接，手动断开重连!system={{slot0}}": "连接已发起，但是10秒后未成功建立连接，手动断开重连!system={{slot0}}",
+  "---连接未建立的关闭出错---": "---连接未建立的关闭出错---",
+  "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}---": "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}---",
+  "---------连接成功 time={{slot0}} system={{slot1}} time={{slot2}}--------": "---------连接成功 time={{slot0}} system={{slot1}} time={{slot2}}--------",
+  "---------连接失败 system={{slot0}} time={{slot1}}--------": "---------连接失败 system={{slot0}} time={{slot1}}--------",
+  "用户主动关闭": "用户主动关闭",
+  "---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---": "---连接已建立的关闭出错 time={{slot0}}system={{slot1}}---",
+  "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}": "---第{{slot0}}次重连！time={{slot1}}system={{slot2}}",
+  "{{type}}超过最大字符长度200": "{{type}}超过最大字符长度200",
+  "{{type}}超过最大字符长度400": "{{type}}超过最大字符长度400",
+  "{{type}}超过最大字符长度600": "{{type}}超过最大字符长度600",
+  "{{type}}超过最大字符长度5000": "{{type}}超过最大字符长度5000",
+  "请输入正确的手机号": "请输入正确的手机号",
+  "请输入正确的身份证": "请输入正确的身份证",
+  "请输入正确的邮箱": "请输入正确的邮箱",
+  "密码必须包含大小写字母、数字、特殊字符且最小长度为8，且不能出现连续数字或字符，不能出现相同字符，且禁止使用用户账号作为密码": "密码必须包含大小写字母、数字、特殊字符且最小长度为8，且不能出现连续数字或字符，不能出现相同字符，且禁止使用用户账号作为密码",
+  "请勿输入空格": "请勿输入空格",
+  "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!": "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!",
+  "密码与用户名相同!": "密码与用户名相同!",
+  "密码中有相同且连续超过三次的字符!": "密码中有相同且连续超过三次的字符!",
+  "从第{{slot0}}个字符开始，有连续{{slot1}}超过三位的字母或数字!": "从第{{slot0}}个字符开始，有连续{{slot1}}超过三位的字母或数字!",
+  "从第{{slot0}}个字符开始，有按键盘横向连续{{slot1}}超过三位的字母!": "从第{{slot0}}个字符开始，有按键盘横向连续{{slot1}}超过三位的字母!",
+  "从第{{slot0}}个字符开始，有按键盘竖向连续{{slot1}}超过三位的字母或数字!": "从第{{slot0}}个字符开始，有按键盘竖向连续{{slot1}}超过三位的字母或数字!",
+  "父页面传递过来的消息": "父页面传递过来的消息",
+  "父页面传递过来的消息解析报错": "父页面传递过来的消息解析报错"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztxkutils",
-  "version": "10.0.11",
+  "version": "20.0.2",
   "description": "",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -10,11 +10,17 @@
     "prepublish": "yarn build"
   },
   "files": [
-    "dist"
+    "dist",
+    "./zti18n-cli",
+    "./zti18n-core",
+    "./locales"
   ],
   "keywords": [],
   "author": "ZTXK",
   "license": "MIT",
+  "bin": {
+    "zti18n": "./zti18n-cli/bin/index.js"
+  },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^19.0.0",
     "@rollup/plugin-json": "^4.1.0",
@@ -47,14 +53,45 @@
     "ztxkui": "^0.4.1"
   },
   "dependencies": {
+    "@babel/core": "^7.18.10",
+    "@babel/generator": "^7.18.0",
+    "@babel/plugin-proposal-optional-chaining": "^7.18.9",
+    "@babel/plugin-syntax-async-generators": "^7.8.4",
+    "@babel/plugin-syntax-class-properties": "^7.12.13",
+    "@babel/plugin-syntax-decorators": "^7.18.6",
+    "@babel/plugin-syntax-do-expressions": "^7.18.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-flow": "^7.18.6",
+    "@babel/plugin-syntax-function-bind": "^7.18.6",
+    "@babel/plugin-syntax-function-sent": "^7.18.6",
+    "@babel/plugin-syntax-jsx": "^7.18.6",
+    "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+    "@babel/preset-typescript": "^7.18.6",
+    "@babel/traverse": "^7.18.10",
+    "@babel/types": "^7.18.10",
+    "@prettier/plugin-pug": "^1.8.1",
+    "@typescript-eslint/typescript-estree": "^3.8.0",
+    "babel-template": "^6.26.0",
+    "chalk": "^3.0.0",
+    "commander": "^2.18.0",
     "crypto-js": "^4.1.1",
     "decimal.js-light": "^2.5.1",
     "dexie": "^3.2.3",
+    "di18n-core": "^0.1.29",
+    "glob": "^7.1.6",
+    "i18next": "^23.16.4",
+    "inquirer": "^6.2.2",
     "js-base64": "^3.6.0",
     "jwt-decode": "^3.1.2",
+    "mustache": "^4.0.1",
+    "parse5": "^5.1.1",
+    "pug-lexer": "^4.1.0",
+    "pug-parser": "^5.0.1",
+    "pug-source-gen": "0.0.2",
     "screenfull": "^5.1.0",
     "sockjs-client": "^1.5.1",
     "stompjs": "^2.3.3",
+    "vue-template-compiler": "^2.7.16",
     "zt-sockjs-client": "^0.0.2",
     "zt-stompjs": "^1.1.2"
   },
@@ -68,8 +105,8 @@
     "react": ">=17.0.1",
     "react-dom": ">=17.0.1",
     "react-router-dom": ">=5.2.0",
-    "ztxkui": ">=0.4.1",
     "zt-sockjs-client": ">=0.0.1",
-    "zt-stompjs": ">=1.0.3"
+    "zt-stompjs": ">=1.0.3",
+    "ztxkui": ">=0.4.1"
   }
 }

package/zti18n-cli/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../');