@web-utils/component 2.7.36 → 2.7.37

package/dist/chunks/form-item-mixin.a56c101a.js

@@ -1,166 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-import { d as filterProperties } from "./utils.2a3ffac9.js";
-import Col from "element-ui/lib/col";
-import FormItem from "element-ui/lib/form-item";
-const elColManualBindKeys = ["span"];
-const elColKeys = [...Object.keys(Col.props)];
-const elColAutoBindKeys = elColKeys.filter((key) => !elColManualBindKeys.includes(key));
-const elFormItemManualBindKeys = ["label", "prop", "rules", "labelWidth", "required"];
-const elFormItemKeys = [...Object.keys(FormItem.props)];
-const elFormItemAutoBindKeys = elFormItemKeys.filter((key) => !elFormItemManualBindKeys.includes(key));
-const formItemAutoBindKeys = [
-  "wrapCol",
-  "wrapFormItem",
-  "unwrap",
-  "prefixConfig",
-  "block",
-  "placeholder",
-  "prefixPick",
-  "half",
-  ...elColKeys,
-  ...elFormItemKeys
-];
-const formItemMixin = {
-  inject: {
-    elForm: {
-      default: {}
-    },
-    formItemGroup: {
-      default: {}
-    }
-  },
-  props: {
-    disabled: Boolean,
-    wrapCol: {
-      type: Boolean,
-      default: true
-    },
-    wrapFormItem: {
-      type: Boolean,
-      default: true
-    },
-    unwrap: Boolean,
-    half: Boolean,
-    prefixConfig: Boolean,
-    block: Boolean,
-    placeholder: {
-      type: [Boolean, String],
-      default: true
-    },
-    formItemClass: String,
-    prefixPick: Boolean,
-    // el-form-item
-    label: String,
-    labelWidth: String,
-    prop: String,
-    required: Boolean,
-    rules: [Object, Array],
-    error: String,
-    validateStatus: String,
-    for: String,
-    inlineMessage: {
-      type: [String, Boolean],
-      default: ""
-    },
-    showMessage: {
-      type: Boolean,
-      default: true
-    },
-    size: String,
-    // el-col
-    span: {
-      type: Number,
-      default: 12
-    },
-    tag: {
-      type: String,
-      default: "div"
-    },
-    offset: Number,
-    pull: Number,
-    push: Number,
-    xs: [Number, Object],
-    sm: [Number, Object],
-    md: [Number, Object],
-    lg: [Number, Object],
-    xl: [Number, Object]
-  },
-  computed: {
-    prefix() {
-      if (this.prefixConfig) {
-        return "请配置";
-      } else if (this.prefixPick) {
-        return "请选择";
-      } else {
-        return "请输入";
-      }
-    },
-    message() {
-      var _a;
-      return `${this.prefix}${((_a = this.label) == null ? void 0 : _a.replace("：", "")) || ""}`;
-    },
-    computeRules() {
-      const rules = [...this.rules || []];
-      if (this.required) {
-        const requireRule = rules.find((value) => value.required);
-        if (requireRule) {
-          if (!requireRule.ref) {
-            requireRule.message = rules.message || this.message;
-          } else {
-            requireRule.label = requireRule.label || this.label;
-          }
-        } else {
-          rules.unshift(this.getRequireRule());
-        }
-      }
-      return rules.concat(this.getRules());
-    },
-    computeSpan() {
-      return this.block ? 24 : this.span;
-    },
-    formItemProps() {
-      return filterProperties(__spreadValues(__spreadValues({}, this.$props), this.$attrs), formItemAutoBindKeys);
-    },
-    elFormItemProps() {
-      return filterProperties(__spreadValues(__spreadValues({}, this.$props), this.$attrs), elFormItemAutoBindKeys);
-    },
-    elColProps() {
-      return filterProperties(__spreadValues(__spreadValues({}, this.$props), this.$attrs), elColAutoBindKeys);
-    }
-  },
-  watch: {
-    computeRules() {
-      var _a, _b;
-      (_b = (_a = this.elForm) == null ? void 0 : _a.clearValidate) == null ? void 0 : _b.call(_a, this.prop);
-    }
-  },
-  methods: {
-    getRules() {
-      return [];
-    },
-    getRequireRule() {
-      return {
-        required: true,
-        message: this.message
-      };
-    }
-  }
-};
-export {
-  formItemMixin as f
-};

package/dist/chunks/init.38cbb3a2.js

@@ -1,142 +0,0 @@
-import { s as sendDic, l as loadLocalDic, a as loadDic, b as loadCascaderDic } from "./dic.e57b75f2.js";
-import { d as deepClone, D as DIC_PROPS } from "./util.b0d0b0ad.js";
-import { s as slot } from "./slot.55598d0f.js";
-import { isBlank } from "@web-utils/core";
-const init = {
-  mixins: [slot],
-  props: {
-    defaults: {
-      type: Object,
-      default() {
-        return {};
-      }
-    },
-    option: {
-      type: Object,
-      required: true,
-      default: () => {
-        return {};
-      }
-    }
-  },
-  watch: {
-    defaults: {
-      handler(val) {
-        this.objectOption = val;
-      },
-      deep: true
-    },
-    objectOption: {
-      handler(val) {
-        this.$emit("update:defaults", val);
-      },
-      deep: true
-    },
-    propOption: {
-      handler(list) {
-        const result = {};
-        list.forEach((ele) => {
-          result[ele.prop] = ele;
-        });
-        this.$set(this, "objectOption", result);
-      },
-      deep: true
-    },
-    option: {
-      handler() {
-        this.init(false);
-      },
-      deep: true
-    }
-  },
-  data() {
-    return {
-      DIC: {},
-      cascaderDIC: {},
-      tableOption: {},
-      isMobile: "",
-      objectOption: {}
-    };
-  },
-  created() {
-    this.init();
-  },
-  computed: {
-    resultOption() {
-      return Object.assign(deepClone(this.tableOption), {
-        column: this.propOption
-      });
-    },
-    rowKey() {
-      return this.tableOption.rowKey || DIC_PROPS.rowKey;
-    },
-    formRules() {
-      const result = {};
-      this.propOption.forEach((ele) => {
-        if (ele.rules && ele.display !== false) {
-          result[ele.prop] = ele.rules;
-        }
-      });
-      return result;
-    },
-    isMediumSize() {
-      return this.controlSize;
-    },
-    controlSize() {
-      return this.tableOption.size || this.$AVUE.size;
-    }
-  },
-  methods: {
-    init(type) {
-      this.tableOption = this.option;
-      this.getIsMobile();
-      this.handleLocalDic();
-      if (type !== false)
-        this.handleLoadDic();
-    },
-    dicInit(type) {
-      if (type === "cascader") {
-        this.handleLoadCascaderDic();
-      } else {
-        this.handleLoadDic();
-      }
-    },
-    getIsMobile() {
-      this.isMobile = document.body.clientWidth <= 768;
-    },
-    updateDic(prop, list) {
-      const column = this.findObject(this.propOption, prop);
-      if (isBlank(list) && isBlank(prop)) {
-        this.handleLoadDic();
-      } else if (isBlank(list) && !isBlank(column.dicUrl)) {
-        sendDic({
-          column
-        }).then((list2) => {
-          this.$set(this.DIC, prop, list2);
-        });
-      } else {
-        this.$set(this.DIC, prop, list);
-      }
-    },
-    handleSetDic(list, res = {}) {
-      Object.keys(res).forEach((ele) => {
-        this.$set(list, ele, res[ele]);
-      });
-    },
-    // 本地字典
-    handleLocalDic() {
-      this.handleSetDic(this.DIC, loadLocalDic(this.resultOption));
-    },
-    // 网络字典加载
-    handleLoadDic() {
-      loadDic(this.resultOption).then((res) => this.handleSetDic(this.DIC, res));
-    },
-    // 级联字典加载
-    handleLoadCascaderDic() {
-      loadCascaderDic(this.propOption, this.data).then((res) => this.handleSetDic(this.cascaderDIC, res));
-    }
-  }
-};
-export {
-  init as i
-};

package/dist/chunks/permission.9c766972.js

@@ -1,21 +0,0 @@
-const permission = (() => {
-  function init(el, binding) {
-    const value = binding.value;
-    if (value === false) {
-      el.style.display = "none";
-    } else {
-      el.style.display = "";
-    }
-  }
-  return {
-    bind(el, binding) {
-      init(el, binding);
-    },
-    update(el, binding) {
-      init(el, binding);
-    }
-  };
-})();
-export {
-  permission as p
-};

package/dist/chunks/slot.55598d0f.js

@@ -1,35 +0,0 @@
-const slot = {
-  methods: {
-    getSlotName(item = {}, type = "D", slot2) {
-      const result = {
-        F: "Form",
-        H: "Header",
-        E: "Error",
-        L: "Label",
-        S: "Search",
-        T: "Type",
-        D: ""
-      };
-      const name = item.prop + result[type];
-      if (slot2)
-        return slot2[name];
-      return name;
-    },
-    getSlotList(list = [], slot2, propList) {
-      propList = propList.map((ele) => ele.prop);
-      return Object.keys(slot2).filter((ele) => {
-        let result = false;
-        if (!propList.includes(ele)) {
-          list.forEach((name) => {
-            if (ele.includes(name))
-              result = true;
-          });
-        }
-        return result;
-      });
-    }
-  }
-};
-export {
-  slot as s
-};

package/dist/chunks/tab-mixin.9d848bf6.js

@@ -1,99 +0,0 @@
-const parentMixin = {
-  mounted() {
-    if (this.value >= 0) {
-      this.currentIndex = this.value;
-    }
-    this.updateIndex();
-  },
-  methods: {
-    updateIndex() {
-      if (!this.$children || !this.$children.length) {
-        return;
-      }
-      this.number = this.$children.length;
-      const children = this.$children;
-      for (let i = 0; i < children.length; i++) {
-        children[i].currentIndex = i;
-        if (children[i].currentSelected) {
-          this.index = i;
-        }
-      }
-    }
-  },
-  props: {
-    value: Number
-  },
-  watch: {
-    currentIndex(val, oldVal) {
-      oldVal > -1 && this.$children[oldVal] && (this.$children[oldVal].currentSelected = false);
-      val > -1 && this.$children[val] && (this.$children[val].currentSelected = true);
-      this.$emit("input", val);
-      this.$emit("on-index-change", val, oldVal);
-    },
-    index(val) {
-      this.currentIndex = val;
-    },
-    value(val) {
-      this.index = val;
-    }
-  },
-  data() {
-    return {
-      index: -1,
-      currentIndex: this.index,
-      number: this.$children.length
-    };
-  }
-};
-const childMixin = {
-  props: {
-    selected: {
-      type: Boolean,
-      default: false
-    }
-  },
-  mounted() {
-    this.$parent.updateIndex();
-  },
-  beforeDestroy() {
-    const $parent = this.$parent;
-    this.$nextTick(() => {
-      $parent.updateIndex();
-    });
-  },
-  methods: {
-    onItemClick(hasLink) {
-      if (this.$parent.preventDefault) {
-        this.$parent.$emit("on-before-index-change", this.currentIndex);
-        return;
-      }
-      if (typeof this.disabled === "undefined" || this.disabled === false) {
-        this.currentSelected = true;
-        this.$parent.currentIndex = this.currentIndex;
-        this.$nextTick(() => {
-          this.$emit("on-item-click", this.currentIndex);
-        });
-      }
-    }
-  },
-  watch: {
-    currentSelected(val) {
-      if (val) {
-        this.$parent.index = this.currentIndex;
-      }
-    },
-    selected(val) {
-      this.currentSelected = val;
-    }
-  },
-  data() {
-    return {
-      currentIndex: -1,
-      currentSelected: this.selected
-    };
-  }
-};
-export {
-  childMixin as c,
-  parentMixin as p
-};