leisure-core 0.6.62 → 0.6.63

package/le-input-validate/src/main.vue

@@ -30,57 +30,46 @@ export default {
   inheritAttrs: false,
 
   props: {
-    // 数值类型
     number: {
       type: Boolean,
       default: false,
     },
-    // 手机号类型
     mobile: {
       type: Boolean,
       default: false,
     },
-    // 邮箱类型
     email: {
       type: Boolean,
       default: false,
     },
-    // 金额类型
     amount: {
       type: Boolean,
       default: false,
     },
-    // 最大长度
     maxlength: {
       type: [Number, String],
       default: null,
     },
-    // 是否显示字数统计
     showCount: {
       type: Boolean,
       default: false,
     },
-    // 自定义验证函数
     validator: {
       type: Function,
       default: null,
     },
-    // 值
     value: {
       type: [String, Number],
       default: "",
     },
-    // 是否允许小数
     allowDecimal: {
       type: Boolean,
       default: true,
     },
-    // 小数位数限制
     decimalLimit: {
       type: Number,
       default: 2,
     },
-    // 新增：是否允许负数（仅对 number 和 amount 类型生效）
     allowNegative: {
       type: Boolean,
       default: false,
@@ -101,11 +90,8 @@ export default {
     mergedAttrs() {
       const attrs = { ...this.$attrs };
 
-      // 移除已单独处理的属性
       delete attrs.class;
       delete attrs.style;
-
-      // 移除props中定义的属性，避免重复
       delete attrs.number;
       delete attrs.mobile;
       delete attrs.email;
@@ -116,9 +102,8 @@ export default {
       delete attrs.value;
       delete attrs.allowDecimal;
       delete attrs.decimalLimit;
-      delete attrs.allowNegative; // 新增
+      delete attrs.allowNegative;
 
-      // 合并值，确保我们的 value 逻辑优先
       return {
         ...attrs,
         value: this.displayValue,
@@ -130,7 +115,6 @@ export default {
       if (this.maxlength) {
         return Number(this.maxlength);
       }
-      // 手机号默认11位
       if (this.mobile) {
         return 11;
       }
@@ -148,7 +132,6 @@ export default {
     },
 
     displayValue() {
-      // 金额类型在非聚焦状态下显示格式化后的值
       if (
         this.amount &&
         !this.isFocused &&
@@ -168,7 +151,6 @@ export default {
 
     internalValue(newVal) {
       this.validateInput(newVal);
-      // 触发外部监听的事件
       this.$listeners.change && this.$listeners.change(newVal);
     },
   },
@@ -177,22 +159,18 @@ export default {
     handleInput(value) {
       let processedValue = value;
 
-      // 数值类型处理
       if (this.number) {
         processedValue = this.formatNumber(value);
       }
 
-      // 手机号类型处理
       if (this.mobile) {
         processedValue = this.formatMobile(value);
       }
 
-      // 金额类型处理
       if (this.amount) {
         processedValue = this.formatAmountInput(value);
       }
 
-      // 长度限制
       if (
         this.computedMaxlength &&
         processedValue.length > this.computedMaxlength
@@ -202,8 +180,6 @@ export default {
 
       this.internalValue = processedValue;
       this.$emit("input", processedValue);
-
-      // 触发外部监听的事件
       this.$listeners.input && this.$listeners.input(processedValue);
     },
 
@@ -212,16 +188,12 @@ export default {
       this.isFocused = false;
       this.validateInput(this.internalValue, true);
       this.$emit("blur", event);
-
-      // 触发外部监听的事件
       this.$listeners.blur && this.$listeners.blur(event);
     },
 
     handleFocus(event) {
       this.isFocused = true;
       this.$emit("focus", event);
-
-      // 触发外部监听的事件
       this.$listeners.focus && this.$listeners.focus(event);
     },
 
@@ -229,37 +201,29 @@ export default {
       this.hasError = false;
       this.errorMessage = "";
       this.$emit("clear");
-
-      // 触发外部监听的事件
       this.$listeners.clear && this.$listeners.clear();
     },
 
     formatNumber(value) {
-      // 根据 allowNegative 决定是否保留负号
       let filtered = value;
       if (this.allowNegative) {
-        // 允许负数：保留数字、小数点、负号，但负号只能出现在开头，多个负号只保留第一个
+        // 允许负数：保留数字、小数点、负号，负号只能出现在开头
         filtered = value.replace(/[^\d.-]/g, "");
-        // 处理多个负号的情况：只保留第一个负号，并确保负号在开头
         const hasNegative = filtered.startsWith("-");
         filtered = filtered.replace(/-/g, "");
         if (hasNegative) {
           filtered = "-" + filtered;
         }
-        // 处理小数点后多余的小数点
         filtered = filtered.replace(/(\..*)\./g, "$1");
       } else {
-        // 不允许负数：直接过滤掉负号
         filtered = value.replace(/[^\d.]/g, "");
         filtered = filtered.replace(/(\..*)\./g, "$1");
       }
 
-      // 如果不允许小数，移除小数点
       if (this.number && !this.allowDecimal) {
         filtered = filtered.replace(/\./g, "");
       }
 
-      // 如果允许小数，限制小数位数
       if (this.number && this.allowDecimal && this.decimalLimit > 0) {
         const parts = filtered.split(".");
         if (parts.length === 2 && parts[1].length > this.decimalLimit) {
@@ -271,69 +235,62 @@ export default {
     },
 
     formatMobile(value) {
-      // 只允许数字
       return value.replace(/\D/g, "");
     },
 
     formatAmountInput(value) {
-      // 金额输入过滤
       let filteredValue = value;
 
       if (this.allowNegative) {
-        // 允许负数：保留数字、小数点、负号，负号只能出现在开头
         filteredValue = value.replace(/[^\d.-]/g, "");
         const hasNegative = filteredValue.startsWith("-");
         filteredValue = filteredValue.replace(/-/g, "");
         if (hasNegative) {
           filteredValue = "-" + filteredValue;
         }
+        // 修复：允许临时输入 '-' 或 '-.'，不清空，以便用户继续输入小数部分
+        if (filteredValue === "-" || filteredValue === "-.") {
+          return filteredValue;
+        }
       } else {
-        // 不允许负数：只保留数字和小数点
         filteredValue = value.replace(/[^\d.]/g, "");
       }
 
-      // 如果禁止小数，则删除所有小数点
       if (!this.allowDecimal) {
         return filteredValue.replace(/\./g, "");
       }
 
-      // 处理多个小数点的情况
       const parts = filteredValue.split(".");
       if (parts.length > 2) {
         filteredValue = parts[0] + "." + parts.slice(1).join("");
       }
 
-      // 限制小数位数
       if (parts.length === 2 && parts[1].length > this.decimalLimit) {
         filteredValue =
           parts[0] + "." + parts[1].substring(0, this.decimalLimit);
       }
 
-      // 特殊情况：单独的负号或负号+小数点不允许，清除无效输入
-      if (filteredValue === "-" || filteredValue === "-.") {
-        filteredValue = "";
-      }
-
       return filteredValue;
     },
 
     formatAmount(value) {
       if (value === undefined || value === null || value === "") return "";
 
-      // 将值转换为字符串，处理负数
       const strValue = String(value);
       const isNegative = strValue.startsWith("-");
       let absValue = isNegative ? strValue.slice(1) : strValue;
 
-      // 分割整数和小数部分
+      // 修复：处理无效的中间状态，如 '-' 或 '-.'
+      if (absValue === "" || absValue === ".") {
+        return strValue;
+      }
+
       const parts = absValue.split(".");
       let integerPart = parts[0];
       let decimalPart = parts.length > 1 ? parts[1] : "";
 
-      // 对整数部分添加千分位分隔符
       integerPart = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 
-      // 组合整数和小数部分
       let formatted = "";
       if (decimalPart && this.allowDecimal) {
         formatted = `${integerPart}.${decimalPart}`;
@@ -341,7 +298,6 @@ export default {
         formatted = integerPart;
       }
 
-      // 添加负号
       if (isNegative && formatted !== "") {
         formatted = "-" + formatted;
       }
@@ -354,15 +310,12 @@ export default {
 
       let isValid = true;
       let message = "";
-
       const strValue = String(value || "");
 
-      // 数值验证
       if (this.number && strValue) {
         let numberPattern;
         if (this.allowNegative) {
-          // 允许负数：可选负号，整数或小数
-          numberPattern = new RegExp(`^-?\\d*\\.?\\d*$`);
+          numberPattern = /^-?\d*\.?\d*$/;
         } else {
           numberPattern = /^\d*\.?\d*$/;
         }
@@ -372,7 +325,6 @@ export default {
         }
       }
 
-      // 手机号验证
       if (this.mobile && strValue) {
         if (!/^1[3-9]\d{9}$/.test(strValue)) {
           isValid = false;
@@ -380,7 +332,6 @@ export default {
         }
       }
 
-      // 邮箱验证
       if (this.email && strValue) {
         if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue)) {
           isValid = false;
@@ -388,40 +339,56 @@ export default {
         }
       }
 
-      // 金额验证
       if (this.amount && strValue) {
-        // 去除千分位分隔符后再验证
         const cleanValue = strValue.replace(/,/g, "");
         let amountPattern;
         if (this.allowNegative) {
-          amountPattern = this.allowDecimal
-            ? new RegExp(`^-?\\d+(\\.\\d{0,${this.decimalLimit}})?$`)
-            : /^-?\d+$/;
+          // 更严格的金额正则：不允许单独的负号、小数点、负号+小数点
+          if (this.allowDecimal) {
+            amountPattern = /^-?(?:[1-9]\d*|0)(?:\.\d{0,2})?$|^-?0\.\d{0,2}$/;
+          } else {
+            amountPattern = /^-?(?:[1-9]\d*|0)$/;
+          }
+          // 临时允许用户输入过程中的不完整状态，但最终提交时需完整
+          // 这里先检查完整格式，如果是不完整状态（如 '-'、'-.'、'.'）也认为无效
+          if (
+            cleanValue === "-" ||
+            cleanValue === "-." ||
+            cleanValue === "." ||
+            cleanValue === ""
+          ) {
+            isValid = false;
+            message = this.allowDecimal
+              ? "请输入有效的金额"
+              : "请输入有效的整数金额";
+          } else if (!amountPattern.test(cleanValue)) {
+            isValid = false;
+            message = this.allowDecimal
+              ? `请输入有效的金额（最多${this.decimalLimit}位小数）`
+              : "请输入有效的金额（整数）";
+          }
         } else {
           amountPattern = this.allowDecimal
-            ? new RegExp(`^\\d+(\\.\\d{0,${this.decimalLimit}})?$`)
-            : /^\d+$/;
-        }
-        if (!amountPattern.test(cleanValue)) {
-          isValid = false;
-          message = this.allowDecimal
-            ? `请输入有效的金额（最多${this.decimalLimit}位小数）`
-            : "请输入有效的金额（整数）";
+            ? /^(?:[1-9]\d*|0)(?:\.\d{0,2})?$|^0\.\d{0,2}$/
+            : /^(?:[1-9]\d*|0)$/;
+          if (!amountPattern.test(cleanValue)) {
+            isValid = false;
+            message = this.allowDecimal
+              ? `请输入有效的金额（最多${this.decimalLimit}位小数）`
+              : "请输入有效的金额（整数）";
+          }
         }
-        // 额外检查负数是否允许
         if (!this.allowNegative && cleanValue.startsWith("-")) {
           isValid = false;
           message = "不允许输入负数";
         }
       }
 
-      // 最大长度验证
       if (this.computedMaxlength && strValue.length > this.computedMaxlength) {
         isValid = false;
         message = `输入内容不能超过${this.computedMaxlength}个字符`;
       }
 
-      // 自定义验证
       if (this.validator && typeof this.validator === "function") {
         const customResult = this.validator(value);
         if (customResult !== true) {
@@ -436,25 +403,21 @@ export default {
       return isValid;
     },
 
-    // 公开方法：手动验证
     validate() {
       this.isTouched = true;
       return this.validateInput(this.internalValue, true);
     },
 
-    // 公开方法：清除验证状态
     clearValidate() {
       this.hasError = false;
       this.errorMessage = "";
       this.isTouched = false;
     },
 
-    // 公开方法：聚焦输入框
     focus() {
       this.$refs.inputRef?.focus();
     },
 
-    // 公开方法：失焦输入框
     blur() {
       this.$refs.inputRef?.blur();
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leisure-core",
-  "version": "0.6.62",
+  "version": "0.6.63",
   "description": "leisure-core是京心数据基于vue2.x开发的一套后台管理系统桌面端组件库，封装了大量实用的UI控件模板,非常方便开发者快速搭建前端应用",
   "private": false,
   "author": "北方乐逍遥(zcx7878)",