ztxkutils 20.0.1 → 20.0.2

package/dist/request.js

@@ -2,7 +2,7 @@ import './tslib.es6-35653116.js';
 import './i18next.js';
 import 'axios';
 import 'ztxkui';
-export { N as NEW_AUTHORIZATION, O as OLD_AUTHORIZATION, d as clearAutonomousCatch, b as clearCatch, c as clearNoCompleteRequest, a as default } from './request-f600ad7a.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/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,2 +1,2 @@
 import './i18next.js';
-export { c as commonMessage, b as validate, a as validatePassword } from './validate-21164759.js';
+export { c as commonMessage, b as validate, a as validatePassword } from './validate-21b58a69.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztxkutils",
-  "version": "20.0.1",
+  "version": "20.0.2",
   "description": "",
   "main": "./dist/index.js",
   "module": "./dist/index.js",