zmdms-utils 0.0.82 → 0.0.84

package/dist/es/math.js

@@ -107,6 +107,7 @@ function divide(num1, num2, precision) {
  * 四舍五入保留小数
  */
 function exactRound(num, ratio) {
+    var _a;
     try {
         var _num1 = num == null ? NaN : Number(num);
         if (isNaN(_num1)) {
@@ -116,12 +117,27 @@ function exactRound(num, ratio) {
         var value = new Decimal(num).toFixed(ratio);
         // 设置exactRound去掉小数位后面的0
         var exactRoundType = window.__EXACT_ROUND_TYPE__;
-        var exactRoundTypePrecision = window
-            .__EXACT_ROUND_TYPE_PRECISION__;
+        var exactRoundTypePrecision = (_a = window.__EXACT_ROUND_TYPE_PRECISION__) !== null && _a !== void 0 ? _a : 2;
         if (exactRoundType === "TRIM_ZEROS" &&
             (exactRoundTypePrecision || ratio) === ratio) {
             value = Number(value);
         }
+        else if (exactRoundType === "PRESERVE_TRAILING_ZEROS" &&
+            ratio > exactRoundTypePrecision) {
+            var str = String(Number(value));
+            // 如果包含小数点
+            if (str.includes(".")) {
+                // 根据exactRoundTypePrecision控制保留的位数
+                // 提取整数部分和小数部分
+                var _b = str.split("."), intPart = _b[0], decimalPart = _b[1];
+                // 确保小数部分至少有precision位，不足则补0
+                var paddedDecimal = decimalPart;
+                if (paddedDecimal.length > exactRoundTypePrecision) {
+                    paddedDecimal = paddedDecimal.padEnd(exactRoundTypePrecision, "0");
+                }
+                value = "".concat(intPart, ".").concat(paddedDecimal);
+            }
+        }
         return value;
         // return Number(num).toFixed(ratio);
     }

package/dist/es/validate.js

@@ -43,5 +43,172 @@ var isChineseValidate = {
     regex: /[\u4e00-\u9fa5]/,
     message: "请输入中文！",
 };
+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: "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!",
+        };
+    }
+    // 检查密码是否与用户名相同
+    if (password === username) {
+        return {
+            result: false,
+            message: "密码与用户名相同!",
+        };
+    }
+    // 检查密码中是否有相同且连续的字符 超过三次
+    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: "密码中有相同且连续超过三次的字符!",
+                };
+            }
+        }
+        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: "\u4ECE\u7B2C".concat(startChart + 1, "\u4E2A\u5B57\u7B26\u5F00\u59CB\uFF0C\u6709\u8FDE\u7EED").concat(currentConsecutiveCount === 1 ? "递减" : "递增", "\u8D85\u8FC7\u4E09\u4F4D\u7684\u5B57\u6BCD\u6216\u6570\u5B57!"),
+                    };
+                }
+            }
+            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: "\u4ECE\u7B2C".concat(startChart + 1, "\u4E2A\u5B57\u7B26\u5F00\u59CB\uFF0C\u6709\u6309\u952E\u76D8\u6A2A\u5411\u8FDE\u7EED").concat(currentConsecutiveCount === 1 ? "递减" : "递增", "\u8D85\u8FC7\u4E09\u4F4D\u7684\u5B57\u6BCD!"),
+                    };
+                }
+            }
+            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: "\u4ECE\u7B2C".concat(startChart + 1, "\u4E2A\u5B57\u7B26\u5F00\u59CB\uFF0C\u6709\u6309\u952E\u76D8\u7AD6\u5411\u8FDE\u7EED").concat(currentConsecutiveCount === 1 ? "递减" : "递增", "\u8D85\u8FC7\u4E09\u4F4D\u7684\u5B57\u6BCD\u6216\u6570\u5B57!"),
+                    };
+                }
+            }
+            else {
+                // 需要重置规则
+                count = 0;
+                startChart = 0;
+            }
+            currentConsecutiveCount = consecutiveCount;
+        }
+        else {
+            count = 0;
+            startChart = 0;
+            currentConsecutiveCount = 0;
+        }
+    }
+    // 如果通过了所有的检查，则返回true
+    return {
+        result: true,
+    };
+}
 
-export { emailValidate, idCardValidate, isChineseValidate, morePhoneValidate, phoneValidate, strLenValidate };
+export { emailValidate, idCardValidate, isChineseValidate, morePhoneValidate, phoneValidate, strLenValidate, validatePassword };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zmdms-utils",
-  "version": "0.0.82",
+  "version": "0.0.84",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/publish.py

@@ -3,7 +3,7 @@ import os
 os.system('yarn')
 os.system('npm config set registry https://registry.npmjs.org')
 os.system('yarn config set registry https://registry.yarnpkg.com')
-os.system('npm config set proxy http://127.0.0.1:7890')
+# os.system('npm config set proxy http://127.0.0.1:7890')
 os.system('yarn build')
 os.system('npm publish')
 os.system('npm config set registry https://registry.npmmirror.com')

package/src/locales/i18n.ts

@@ -1,18 +1,18 @@
-import i18next from "i18next";
-import { initReactI18next } from "react-i18next";
-
-type InitOptions = Parameters<typeof i18next.init>;
-
-/**
- * 初始化逻辑
- * - 本函数主要用于初始化 i18next 实例，同时使用 react-i18next 插件进行 react 组件的支持
- * - 本函数的调用时机，一般是在项目的入口文件中进行调用，如 src/main.tsx 中
- * @param options 参数 同i18next.init 第一个参数
- * @param callback 参数 同i18next.init 第二个参数
- * @returns
- */
-function initLocale(options: InitOptions[0], callback?: InitOptions[1]) {
-  return i18next.use(initReactI18next).init(options, callback);
-}
-
-export { initLocale, i18next as i18n };
+import i18next from "i18next";
+import { initReactI18next } from "react-i18next";
+
+type InitOptions = Parameters<typeof i18next.init>;
+
+/**
+ * 初始化逻辑
+ * - 本函数主要用于初始化 i18next 实例，同时使用 react-i18next 插件进行 react 组件的支持
+ * - 本函数的调用时机，一般是在项目的入口文件中进行调用，如 src/main.tsx 中
+ * @param options 参数 同i18next.init 第一个参数
+ * @param callback 参数 同i18next.init 第二个参数
+ * @returns
+ */
+function initLocale(options: InitOptions[0], callback?: InitOptions[1]) {
+  return i18next.use(initReactI18next).init(options, callback);
+}
+
+export { initLocale, i18next as i18n };

package/src/locales/index.ts

@@ -1,8 +1,8 @@
-// i18n实例 及 初始化方法
-export { i18n, initLocale } from "./i18n";
-
-// 代理的 useTranslation 函数
-export { useTranslation, Trans } from "./use-translation";
-
-// 导出 t 函数（应对在非 react 组件环境下进行使用的场景）
-export { safeT } from "./t-in-non-react";
+// i18n实例 及 初始化方法
+export { i18n, initLocale } from "./i18n";
+
+// 代理的 useTranslation 函数
+export { useTranslation, Trans } from "./use-translation";
+
+// 导出 t 函数（应对在非 react 组件环境下进行使用的场景）
+export { safeT } from "./t-in-non-react";

package/src/locales/t-in-non-react.ts

@@ -1,65 +1,65 @@
-/**
- * t 函数封装：
- * - 本文件的几个 t 函数，主要用于弥补一些在 React 组件之外使用的场景
- * - 常规情况下，在 react 组件中，更加推荐的是使用 react-i18next 包中的 t 函数，即 const { t } = useTranslate(); 形式
- */
-import { i18n } from "./i18n";
-import type { TOpionsEx } from "./t-options";
-import { getTFuncArgs } from "./t-options";
-
-/** 包裹一层 try-catch 的 t 函数 */
-const tryT = (
-  key: string,
-  defaultValueOrOptions: string | TOpionsEx
-): string => {
-  const { defaultValue, options } = getTFuncArgs(defaultValueOrOptions);
-  if (!key) {
-    // 情况1：键名为空，返回默认值或键名
-    console.error(
-      `tryT: 请不要传入空 key 值进行 i18n.t 函数执行，这将会导致直接返回空字符串！`
-    );
-    return defaultValue || key;
-  }
-  if (!i18n.exists(key)) {
-    // 情况2：键名不存在，返回默认值或键名
-    console.error(
-      `tryT: i18n-key '${key}' 不存在，请检查对应的 @/locales/resources/locales/xx.json 中是否存在对应值`
-    );
-    return defaultValue || key;
-  }
-  try {
-    // 情况3：尝试执行 i18n.t 函数
-    return i18n.t(key, options);
-  } catch (err) {
-    // 情况4：执行 i18n.t 函数异常，返回默认值或键名
-    console.error(`tryT: i18n.t key=${key} 函数执行异常：err=`, err);
-    return defaultValue || key;
-  }
-};
-
-/**
- * 同步版本的 i18n.t 函数（应对在 react 组件外使用的翻译函数）
- * - 如果 i18n 未初始化，则返回默认值或键名
- * - 如果 i18n 初始化后，键名不存在，则返回默认值或键名
- * - 其他正常情况（已经初始化+键名存在），则返回翻译值
- * @description 本函数为在非 react 组件中使用的翻译函数；（在react中请求使用 useTranslate() 返回的 t 函数）
- * @param {string} key
- * @param {TOpionsEx|string} defaultValue 必填值
- * @returns {string}
- * @example
- *   const txt = t('someLocaleKey', '兜底默认值');
- */
-export function safeT(
-  key: string,
-  defaultValueOrOptions: string | TOpionsEx
-): string {
-  if (i18n.isInitialized) {
-    return tryT(key, defaultValueOrOptions);
-  }
-  // 异常情况：没有初始化完成时，返回默认值
-  const { defaultValue } = getTFuncArgs(defaultValueOrOptions);
-  console.warn(
-    `safeT: i18n is not initialized. Returning defaultValue(${defaultValue}) or origin key (${key}).`
-  );
-  return defaultValue || key;
-}
+/**
+ * t 函数封装：
+ * - 本文件的几个 t 函数，主要用于弥补一些在 React 组件之外使用的场景
+ * - 常规情况下，在 react 组件中，更加推荐的是使用 react-i18next 包中的 t 函数，即 const { t } = useTranslate(); 形式
+ */
+import { i18n } from "./i18n";
+import type { TOpionsEx } from "./t-options";
+import { getTFuncArgs } from "./t-options";
+
+/** 包裹一层 try-catch 的 t 函数 */
+const tryT = (
+  key: string,
+  defaultValueOrOptions: string | TOpionsEx
+): string => {
+  const { defaultValue, options } = getTFuncArgs(defaultValueOrOptions);
+  if (!key) {
+    // 情况1：键名为空，返回默认值或键名
+    console.error(
+      `tryT: 请不要传入空 key 值进行 i18n.t 函数执行，这将会导致直接返回空字符串！`
+    );
+    return defaultValue || key;
+  }
+  if (!i18n.exists(key)) {
+    // 情况2：键名不存在，返回默认值或键名
+    console.error(
+      `tryT: i18n-key '${key}' 不存在，请检查对应的 @/locales/resources/locales/xx.json 中是否存在对应值`
+    );
+    return defaultValue || key;
+  }
+  try {
+    // 情况3：尝试执行 i18n.t 函数
+    return i18n.t(key, options);
+  } catch (err) {
+    // 情况4：执行 i18n.t 函数异常，返回默认值或键名
+    console.error(`tryT: i18n.t key=${key} 函数执行异常：err=`, err);
+    return defaultValue || key;
+  }
+};
+
+/**
+ * 同步版本的 i18n.t 函数（应对在 react 组件外使用的翻译函数）
+ * - 如果 i18n 未初始化，则返回默认值或键名
+ * - 如果 i18n 初始化后，键名不存在，则返回默认值或键名
+ * - 其他正常情况（已经初始化+键名存在），则返回翻译值
+ * @description 本函数为在非 react 组件中使用的翻译函数；（在react中请求使用 useTranslate() 返回的 t 函数）
+ * @param {string} key
+ * @param {TOpionsEx|string} defaultValue 必填值
+ * @returns {string}
+ * @example
+ *   const txt = t('someLocaleKey', '兜底默认值');
+ */
+export function safeT(
+  key: string,
+  defaultValueOrOptions: string | TOpionsEx
+): string {
+  if (i18n.isInitialized) {
+    return tryT(key, defaultValueOrOptions);
+  }
+  // 异常情况：没有初始化完成时，返回默认值
+  const { defaultValue } = getTFuncArgs(defaultValueOrOptions);
+  console.warn(
+    `safeT: i18n is not initialized. Returning defaultValue(${defaultValue}) or origin key (${key}).`
+  );
+  return defaultValue || key;
+}

package/src/locales/t-options.ts

@@ -1,24 +1,24 @@
-"use strict";
-import type { TOptions } from "i18next";
-
-export interface TOpionsEx extends TOptions {
-  defaultValue: string; // 必须填值
-}
-
-/**
- * 获取 t 函数的参数
- * @param {string | TOpionsEx} defaultValueOrOptions 默认值或者选项
- * @returns { {defaultValue: string, options: TOpionsEx} } 默认值和选项
- */
-export function getTFuncArgs(defaultValueOrOptions: string | TOpionsEx) {
-  let options: TOpionsEx | null = null;
-  let defaultValue = "";
-  if (typeof defaultValueOrOptions === "string") {
-    defaultValue = defaultValueOrOptions;
-    options = { defaultValue };
-  } else {
-    options = defaultValueOrOptions;
-    defaultValue = options.defaultValue;
-  }
-  return { defaultValue, options };
-}
+"use strict";
+import type { TOptions } from "i18next";
+
+export interface TOpionsEx extends TOptions {
+  defaultValue: string; // 必须填值
+}
+
+/**
+ * 获取 t 函数的参数
+ * @param {string | TOpionsEx} defaultValueOrOptions 默认值或者选项
+ * @returns { {defaultValue: string, options: TOpionsEx} } 默认值和选项
+ */
+export function getTFuncArgs(defaultValueOrOptions: string | TOpionsEx) {
+  let options: TOpionsEx | null = null;
+  let defaultValue = "";
+  if (typeof defaultValueOrOptions === "string") {
+    defaultValue = defaultValueOrOptions;
+    options = { defaultValue };
+  } else {
+    options = defaultValueOrOptions;
+    defaultValue = options.defaultValue;
+  }
+  return { defaultValue, options };
+}

package/src/locales/use-translation.ts

@@ -1,76 +1,76 @@
-import { useTranslation, Trans } from "react-i18next";
-import type { TOpionsEx } from "./t-options";
-import { getTFuncArgs } from "./t-options";
-
-type Prams = Parameters<typeof useTranslation>;
-type NS = Prams[0];
-type Options = Prams[1];
-
-type EnhanceTFunc = (
-  key: string,
-  defaultValueOrOptions: string | TOpionsEx
-) => string;
-
-/**
- * 这里只是简单代理一下useTranslation，方便后续扩展或添加其他逻辑
- * @param ns 命名空间 大多数情况下都不需要传入这个参数，除非你用到了命名空间。
- * @param options 其他参数 大多数情况下，都不需要关注这个参数。
- * options.keyPrefix 为所有翻译键添加前缀
- *  // JSON 文件：{ "greeting": { "welcome": "Welcome" } }
- *  const { t } = useTranslation('common', { keyPrefix: 'greeting' });
- *  // 使用时省略前缀
- *  t('welcome'); // 等价于 t('greeting:welcome')
- * @returns { t, i18n, ready }
- * t: 翻译方法
- * i18n: i18next实例 访问 i18next 的完整 API（如切换语言、加载命名空间）
- * i18n.changeLanguage('zh-CN'); 使用它切换语言，可以触发组件渲染。但是当前项目中是使用全局刷新的模式，来更新语言的。
- * ready: 是否加载完成
- */
-function useZtTranslation(ns?: NS, options?: Options) {
-  const { t: _tOld, i18n, ready } = useTranslation(ns, options);
-
-  // 扩展t方法，用于处理嵌套的翻译键
-  const tEnhance: EnhanceTFunc = (key, defaultValueOrOptions) => {
-    const { defaultValue, options } = getTFuncArgs(defaultValueOrOptions);
-
-    if (!key) {
-      // 情况1：键名为空，返回默认值或键名
-      console.error(
-        `tEnhance: 请不要传入空 key 值进行 t 函数执行，这将会导致直接返回空字符串！`
-      );
-      return defaultValue || key;
-    }
-    if (!i18n.exists(key)) {
-      // 情况2：键名不存在，返回默认值或键名
-      console.error(
-        `tEnhance: i18n-key '${key}' 不存在，请检查对应的 @/locales/resources/locales/xx.json 中是否存在对应值`
-      );
-      return defaultValue || key;
-    }
-    try {
-      return _tOld(key, options);
-    } catch (error) {
-      console.warn(`tEnhance: t 函数执行异常，请检查! key=${key}, err=`, error);
-      return defaultValue || key || "unknown";
-    }
-  };
-
-  return {
-    /**
-     * t函数的使用方式：基本上使用1、2两种方式就可以了。
-     * 1、t('key') // 基础用法
-     * 2、t('greeting', { name: 'John' }); // 对应 JSON: "greeting": "Hello {{name}}"
-     * 3、t('auth:login'); // 显式指定命名空间
-     *
-     * 关于t函数的第二个参数的说明。
-     * 为了防止一些异常情况，翻译失败。可以传入一个默认值。这个默认值就是原本的中文就行。
-     * 1、t('key', '默认值');
-     * 2、t('key', { defaultValue: '默认值', ...otherOptions });
-     */
-    t: tEnhance,
-    i18n,
-    ready,
-  };
-}
-
-export { useZtTranslation as useTranslation, Trans };
+import { useTranslation, Trans } from "react-i18next";
+import type { TOpionsEx } from "./t-options";
+import { getTFuncArgs } from "./t-options";
+
+type Prams = Parameters<typeof useTranslation>;
+type NS = Prams[0];
+type Options = Prams[1];
+
+type EnhanceTFunc = (
+  key: string,
+  defaultValueOrOptions: string | TOpionsEx
+) => string;
+
+/**
+ * 这里只是简单代理一下useTranslation，方便后续扩展或添加其他逻辑
+ * @param ns 命名空间 大多数情况下都不需要传入这个参数，除非你用到了命名空间。
+ * @param options 其他参数 大多数情况下，都不需要关注这个参数。
+ * options.keyPrefix 为所有翻译键添加前缀
+ *  // JSON 文件：{ "greeting": { "welcome": "Welcome" } }
+ *  const { t } = useTranslation('common', { keyPrefix: 'greeting' });
+ *  // 使用时省略前缀
+ *  t('welcome'); // 等价于 t('greeting:welcome')
+ * @returns { t, i18n, ready }
+ * t: 翻译方法
+ * i18n: i18next实例 访问 i18next 的完整 API（如切换语言、加载命名空间）
+ * i18n.changeLanguage('zh-CN'); 使用它切换语言，可以触发组件渲染。但是当前项目中是使用全局刷新的模式，来更新语言的。
+ * ready: 是否加载完成
+ */
+function useZtTranslation(ns?: NS, options?: Options) {
+  const { t: _tOld, i18n, ready } = useTranslation(ns, options);
+
+  // 扩展t方法，用于处理嵌套的翻译键
+  const tEnhance: EnhanceTFunc = (key, defaultValueOrOptions) => {
+    const { defaultValue, options } = getTFuncArgs(defaultValueOrOptions);
+
+    if (!key) {
+      // 情况1：键名为空，返回默认值或键名
+      console.error(
+        `tEnhance: 请不要传入空 key 值进行 t 函数执行，这将会导致直接返回空字符串！`
+      );
+      return defaultValue || key;
+    }
+    if (!i18n.exists(key)) {
+      // 情况2：键名不存在，返回默认值或键名
+      console.error(
+        `tEnhance: i18n-key '${key}' 不存在，请检查对应的 @/locales/resources/locales/xx.json 中是否存在对应值`
+      );
+      return defaultValue || key;
+    }
+    try {
+      return _tOld(key, options);
+    } catch (error) {
+      console.warn(`tEnhance: t 函数执行异常，请检查! key=${key}, err=`, error);
+      return defaultValue || key || "unknown";
+    }
+  };
+
+  return {
+    /**
+     * t函数的使用方式：基本上使用1、2两种方式就可以了。
+     * 1、t('key') // 基础用法
+     * 2、t('greeting', { name: 'John' }); // 对应 JSON: "greeting": "Hello {{name}}"
+     * 3、t('auth:login'); // 显式指定命名空间
+     *
+     * 关于t函数的第二个参数的说明。
+     * 为了防止一些异常情况，翻译失败。可以传入一个默认值。这个默认值就是原本的中文就行。
+     * 1、t('key', '默认值');
+     * 2、t('key', { defaultValue: '默认值', ...otherOptions });
+     */
+    t: tEnhance,
+    i18n,
+    ready,
+  };
+}
+
+export { useZtTranslation as useTranslation, Trans };

package/src/math.ts

@@ -116,13 +116,30 @@ export function exactRound(num: numType, ratio: number) {
     let value: numType = new Decimal(num).toFixed(ratio);
     // 设置exactRound去掉小数位后面的0
     const exactRoundType = (window as any).__EXACT_ROUND_TYPE__;
-    const exactRoundTypePrecision = (window as any)
-      .__EXACT_ROUND_TYPE_PRECISION__;
+    const exactRoundTypePrecision =
+      (window as any).__EXACT_ROUND_TYPE_PRECISION__ ?? 2;
     if (
       exactRoundType === "TRIM_ZEROS" &&
       (exactRoundTypePrecision || ratio) === ratio
     ) {
       value = Number(value);
+    } else if (
+      exactRoundType === "PRESERVE_TRAILING_ZEROS" &&
+      ratio > exactRoundTypePrecision
+    ) {
+      const str = String(Number(value));
+      // 如果包含小数点
+      if (str.includes(".")) {
+        // 根据exactRoundTypePrecision控制保留的位数
+        // 提取整数部分和小数部分
+        const [intPart, decimalPart] = str.split(".");
+        // 确保小数部分至少有precision位，不足则补0
+        let paddedDecimal = decimalPart;
+        if (paddedDecimal.length > exactRoundTypePrecision) {
+          paddedDecimal = paddedDecimal.padEnd(exactRoundTypePrecision, "0");
+        }
+        value = `${intPart}.${paddedDecimal}`;
+      }
     }
     return value;
     // return Number(num).toFixed(ratio);

package/src/validate.ts

@@ -48,3 +48,201 @@ export const isChineseValidate = {
   regex: /[\u4e00-\u9fa5]/,
   message: "请输入中文！",
 };
+
+const alphabet1 = [
+  "abcdefghijklmnopqrstuvwxyz",
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  "0123456789",
+];
+
+const alphabet2 = ["qwertyuiop", "asdfghjkl", "zxcvbnm"];
+const alphabet3 = ["qaz", "wsx", "edc", "rfv", "tgb", "yhn", "ujm"];
+
+function isConsecutiveChars(
+  char1: string,
+  char2: string,
+  alphabetArr: string[]
+) {
+  // const lowerCaseAlphabet = 'abcdefghijklmnopqrstuvwxyz'; // 小写字母
+  // const upperCaseAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; // 大写字母
+  // const numeric = '0123456789'; // 数字
+
+  // 找到包含两个字符的字符集
+  const alphabet = alphabetArr.find(
+    (alph) => alph.includes(char1) && alph.includes(char2)
+  );
+
+  if (!alphabet) {
+    return false; // 如果两个字符不在同一字符集中，那么它们不可能连续
+  }
+
+  const index1 = alphabet.indexOf(char1);
+  const index2 = alphabet.indexOf(char2);
+
+  // return Math.abs(index1 - index2) === 1; // 如果两个字符在字符集中的位置相邻，那么它们是连续的
+  return index1 - index2;
+}
+
+export function validatePassword(password: string, username: string) {
+  // 用正则表达式检查密码基本规则
+  const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\da-zA-Z]).{8,}$/;
+  if (!regex.test(password)) {
+    return {
+      result: false,
+      message:
+        "密码中必须包含大小写字母、数字、特殊字符,且长度必须大于8个字符!",
+    };
+  }
+
+  // 检查密码是否与用户名相同
+  if (password === username) {
+    return {
+      result: false,
+      message: "密码与用户名相同!",
+    };
+  }
+
+  // 检查密码中是否有相同且连续的字符 超过三次
+  let count1 = 0;
+  for (let i = 0; i < password.length - 1; i++) {
+    if (password[i] === password[i + 1]) {
+      count1++;
+      if (count1 >= 2) {
+        return {
+          result: false,
+          message: "密码中有相同且连续超过三次的字符!",
+        };
+      }
+    } else {
+      count1 = 0;
+    }
+  }
+
+  // 检查密码中是否有连续的字母或数字 连续超过三次
+  let count = 0;
+  let startChart = 0;
+  let currentConsecutiveCount = 0; // 记录上次是递增还是递减
+
+  // 第一次循环 找出 连续字母 数字
+  for (let i = 0; i < password.length - 1; i++) {
+    const 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: `从第${startChart + 1}个字符开始，有连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母或数字!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+  // 第二次循环 找出键盘连续横排字母
+  for (let i = 0; i < password.length - 1; i++) {
+    const 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: `从第${startChart + 1}个字符开始，有按键盘横向连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+  // 第三次循环 找出键盘连续竖排字母
+  for (let i = 0; i < password.length - 1; i++) {
+    const 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: `从第${startChart + 1}个字符开始，有按键盘竖向连续${
+              currentConsecutiveCount === 1 ? "递减" : "递增"
+            }超过三位的字母或数字!`,
+          };
+        }
+      } else {
+        // 需要重置规则
+        count = 0;
+        startChart = 0;
+      }
+      currentConsecutiveCount = consecutiveCount;
+    } else {
+      count = 0;
+      startChart = 0;
+      currentConsecutiveCount = 0;
+    }
+  }
+
+  // 如果通过了所有的检查，则返回true
+  return {
+    result: true,
+  };
+}