leisure-core 1.0.2 → 1.0.4

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

@@ -0,0 +1,469 @@
+<template>
+  <div class="le-input-wrapper">
+    <el-input
+      ref="inputRef"
+      v-bind="mergedAttrs"
+      :class="['le-input', $attrs.class, { 'is-error': hasError }]"
+      :style="$attrs.style"
+      clearable
+      @input="handleInput"
+      @blur="handleBlur"
+      @clear="handleClear"
+      @focus="handleFocus"
+    >
+      <!-- 显式透传 prepend 插槽 -->
+      <template v-if="$slots.prepend" #prepend>
+        <slot name="prepend" />
+      </template>
+
+      <!-- 显式透传 append 插槽 -->
+      <template v-if="$slots.append" #append>
+        <slot name="append" />
+      </template>
+
+      <!-- 显式透传 prefix 插槽 -->
+      <template v-if="$slots.prefix" #prefix>
+        <slot name="prefix" />
+      </template>
+      <template v-if="showCount" #suffix>
+        <span class="input-count" :class="{ 'is-error': isOverMaxLength }">
+          {{ valueLength }}/{{ computedMaxlength }}
+        </span>
+      </template>
+      <template v-else-if="$slots.suffix" #suffix>
+        <slot name="suffix" />
+      </template>
+    </el-input>
+
+    <div v-if="hasError && errorMessage" class="error-message">
+      {{ errorMessage }}
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  name: "le-input-validate",
+  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,
+    },
+    allowNegative: {
+      type: Boolean,
+      default: false,
+    },
+  },
+
+  data() {
+    return {
+      hasError: false,
+      errorMessage: "",
+      internalValue: this.value,
+      isTouched: false,
+      isFocused: false,
+    };
+  },
+
+  computed: {
+    mergedAttrs() {
+      const attrs = { ...this.$attrs };
+
+      delete attrs.class;
+      delete attrs.style;
+      delete attrs.number;
+      delete attrs.mobile;
+      delete attrs.email;
+      delete attrs.amount;
+      delete attrs.maxlength;
+      delete attrs.showCount;
+      delete attrs.validator;
+      delete attrs.value;
+      delete attrs.allowDecimal;
+      delete attrs.decimalLimit;
+      delete attrs.allowNegative;
+
+      return {
+        ...attrs,
+        value: this.displayValue,
+        maxlength: this.computedMaxlength,
+      };
+    },
+
+    computedMaxlength() {
+      if (this.maxlength) {
+        return Number(this.maxlength);
+      }
+      if (this.mobile) {
+        return 11;
+      }
+      return null;
+    },
+
+    valueLength() {
+      return String(this.internalValue || "").length;
+    },
+
+    isOverMaxLength() {
+      return (
+        this.computedMaxlength && this.valueLength > this.computedMaxlength
+      );
+    },
+
+    displayValue() {
+      if (
+        this.amount &&
+        !this.isFocused &&
+        this.internalValue !== undefined &&
+        this.internalValue !== ""
+      ) {
+        return this.formatAmount(this.internalValue);
+      }
+      return this.internalValue;
+    },
+  },
+
+  watch: {
+    value(newVal) {
+      this.internalValue = newVal;
+    },
+
+    internalValue(newVal) {
+      this.validateInput(newVal);
+      this.$listeners.change && this.$listeners.change(newVal);
+    },
+  },
+
+  methods: {
+    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
+      ) {
+        processedValue = processedValue.slice(0, this.computedMaxlength);
+      }
+
+      this.internalValue = processedValue;
+      this.$emit("input", processedValue);
+      this.$listeners.input && this.$listeners.input(processedValue);
+    },
+
+    handleBlur(event) {
+      this.isTouched = true;
+      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);
+    },
+
+    handleClear() {
+      this.hasError = false;
+      this.errorMessage = "";
+      this.$emit("clear");
+      this.$listeners.clear && this.$listeners.clear();
+    },
+
+    formatNumber(value) {
+      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) {
+          filtered = parts[0] + "." + parts[1].substring(0, this.decimalLimit);
+        }
+      }
+
+      return filtered;
+    },
+
+    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);
+      }
+
+      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}`;
+      } else {
+        formatted = integerPart;
+      }
+
+      if (isNegative && formatted !== "") {
+        formatted = "-" + formatted;
+      }
+
+      return formatted;
+    },
+
+    validateInput(value, showError = false) {
+      if (!this.isTouched && !showError) return true;
+
+      let isValid = true;
+      let message = "";
+      const strValue = String(value || "");
+
+      if (this.number && strValue) {
+        let numberPattern;
+        if (this.allowNegative) {
+          numberPattern = /^-?\d*\.?\d*$/;
+        } else {
+          numberPattern = /^\d*\.?\d*$/;
+        }
+        if (!numberPattern.test(strValue)) {
+          isValid = false;
+          message = "请输入有效的数值";
+        }
+      }
+
+      if (this.mobile && strValue) {
+        if (!/^1[3-9]\d{9}$/.test(strValue)) {
+          isValid = false;
+          message = "请输入有效的手机号码";
+        }
+      }
+
+      if (this.email && strValue) {
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue)) {
+          isValid = false;
+          message = "请输入有效的邮箱地址";
+        }
+      }
+
+      if (this.amount && strValue) {
+        const cleanValue = strValue.replace(/,/g, "");
+        let amountPattern;
+        if (this.allowNegative) {
+          // 更严格的金额正则：不允许单独的负号、小数点、负号+小数点
+          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
+            ? /^(?:[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) {
+          isValid = false;
+          message = customResult || "输入内容不符合要求";
+        }
+      }
+
+      this.hasError = !isValid && (this.isTouched || showError);
+      this.errorMessage = message;
+
+      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();
+    },
+  },
+};
+</script>
+
+<style scoped>
+.le-input-wrapper {
+  position: relative;
+}
+
+.le-input.is-error ::v-deep .el-input__inner {
+  border-color: #f56c6c;
+}
+
+.input-count {
+  font-size: 12px;
+  color: #909399;
+}
+
+.input-count.is-error {
+  color: #f56c6c;
+}
+
+.error-message {
+  color: #f56c6c;
+  font-size: 12px;
+  line-height: 1;
+  padding-top: 4px;
+}
+</style>

package/le-libs/js/drag.js

@@ -0,0 +1,78 @@
+export default {
+  bind(el, binding, vnode) {
+    const dialogHeaderEl = el.querySelector(".el-dialog__header");
+    const dragDom = el.querySelector(".el-dialog");
+    dialogHeaderEl.style.cssText += ";cursor:move;";
+    dragDom.style.cssText += ";top:0px;";
+
+    // 获取原有属性 ie dom元素.currentStyle 火狐谷歌 window.getComputedStyle(dom元素, null);
+    const getStyle = (function () {
+      if (window.document.currentStyle) {
+        return (dom, attr) => dom.currentStyle[attr];
+      } else {
+        return (dom, attr) => getComputedStyle(dom, false)[attr];
+      }
+    })();
+
+    dialogHeaderEl.onmousedown = (e) => {
+      // 鼠标按下，计算当前元素距离可视区的距离
+      const disX = e.clientX - dialogHeaderEl.offsetLeft;
+      const disY = e.clientY - dialogHeaderEl.offsetTop;
+
+      const dragDomWidth = dragDom.offsetWidth;
+      // const dragDomHeight = dragDom.offsetHeight
+
+      const screenWidth = document.body.clientWidth;
+      const screenHeight = document.body.clientHeight;
+
+      const minDragDomLeft = dragDom.offsetLeft;
+      const maxDragDomLeft = screenWidth - dragDom.offsetLeft - dragDomWidth;
+
+      const minDragDomTop = dragDom.offsetTop;
+      // const maxDragDomTop = screenHeight - dragDom.offsetTop - dragDomHeight
+      const maxDragDomTop = screenHeight - dragDom.offsetTop; // 不需要-dragDomHeight
+
+      // 获取到的值带px 正则匹配替换
+      let styL = getStyle(dragDom, "left");
+      let styT = getStyle(dragDom, "top");
+
+      if (styL.includes("%")) {
+        styL = +document.body.clientWidth * (+styL.replace(/\%/g, "") / 100);
+        styT = +document.body.clientHeight * (+styT.replace(/\%/g, "") / 100);
+      } else {
+        styL = +styL.replace(/\px/g, "");
+        styT = +styT.replace(/\px/g, "");
+      }
+
+      document.onmousemove = function (e) {
+        // 通过事件委托，计算移动的距离
+        let left = e.clientX - disX;
+        let top = e.clientY - disY;
+
+        // 边界处理
+        if (-left > minDragDomLeft) {
+          left = -minDragDomLeft;
+        } else if (left > maxDragDomLeft) {
+          left = maxDragDomLeft;
+        }
+
+        if (-top > minDragDomTop) {
+          top = -minDragDomTop;
+        } else if (top > maxDragDomTop) {
+          top = maxDragDomTop;
+        }
+
+        // 移动当前元素
+        dragDom.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
+
+        // emit onDrag event
+        vnode.child.$emit("dragDialog");
+      };
+
+      document.onmouseup = function (e) {
+        document.onmousemove = null;
+        document.onmouseup = null;
+      };
+    };
+  },
+};

package/le-libs/js/event.js

@@ -0,0 +1,3 @@
+import Vue from "vue";
+
+export const EventBus = new Vue();

package/le-libs/js/hrequest.js

@@ -0,0 +1,76 @@
+import axios from "axios";
+import router from "@/router";
+import store from "@/store";
+import { Message } from "element-ui";
+import dayjs from "dayjs";
+
+let calMethod = null;
+
+function sign(param) {
+  if (!param) return "";
+  param = param.toString();
+  if (calMethod) {
+    return calMethod(param);
+  } else return "";
+}
+
+function setCalMethod(param) {
+  calMethod = param;
+}
+
+const msg = (info) =>
+  Message({
+    message: info,
+    type: "error",
+    duration: 2000,
+  });
+
+const service = axios.create({
+  baseURL: process.env.VUE_APP_BASE_API,
+  timeout: 50000,
+});
+
+service.interceptors.request.use(
+  (config) => {
+    if (!config.headers["Content-Type"]) {
+      config.headers["Content-Type"] = "application/json;";
+    }
+
+    let userinfo = store.getters.userinfo;
+    if (userinfo != undefined && userinfo.token != undefined) {
+      config.headers["authentication"] = userinfo.token;
+    }
+    const timestamp = dayjs().unix();
+    config.headers["timestamp"] = timestamp;
+    config.headers["sign"] = sign(timestamp);
+    return config;
+  },
+  (error) => {
+    Promise.reject(error);
+  },
+);
+
+service.interceptors.response.use(
+  (response) => {
+    const code = response.data.code;
+    const info = response.data.info;
+    if (code == "801" || code == "802") {
+      router.push({ path: "/" });
+    } else if (code !== "10000" || code == "803") {
+      console.log("请求失败,code和info分别为", code, info);
+      msg(info);
+      // return Promise.reject(info);
+    } else {
+      return response;
+    }
+  },
+  (error) => {
+    console.log("请求失败:" + error);
+    return Promise.reject(error);
+  },
+);
+
+export default {
+  service,
+  setCalMethod,
+};