@web-utils/component 2.0.13 → 2.2.0

package/chunks/event.NHA7rYFE.mjs

@@ -0,0 +1,236 @@
+import { D as r, a as i, b as a } from "./util.C2Bhx22L.mjs";
+import { s as l } from "./slot.j1uMmBnG.mjs";
+import { isBlank as s } from "@web-utils/core";
+import { i as p } from "./dataformat.X_61lMA7.mjs";
+const f = {
+  mixins: [l],
+  data() {
+    return {
+      stringMode: !1,
+      name: "",
+      text: void 0,
+      propsHttpDefault: r,
+      propsDefault: i
+    };
+  },
+  props: {
+    blur: Function,
+    focus: Function,
+    change: Function,
+    click: Function,
+    typeformat: Function,
+    control: Function,
+    separator: {
+      type: String,
+      default: a
+    },
+    params: {
+      type: Object,
+      default: () => ({})
+    },
+    listType: {
+      type: String
+    },
+    tableData: {
+      type: Object
+    },
+    value: {},
+    column: {
+      type: Object,
+      default: () => ({})
+    },
+    label: {
+      type: String,
+      default: ""
+    },
+    readonly: {
+      type: Boolean,
+      default: !1
+    },
+    size: {
+      type: String,
+      default: ""
+    },
+    tip: {
+      type: String,
+      default: ""
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    dataType: {
+      type: String
+    },
+    clearable: {
+      type: Boolean,
+      default: !0
+    },
+    type: {
+      type: String,
+      default: ""
+    },
+    dicUrl: {
+      type: String,
+      default: ""
+    },
+    dicMethod: {
+      type: String,
+      default: ""
+    },
+    dicFormatter: Function,
+    dicQuery: {
+      type: Object,
+      default: () => ({})
+    },
+    dic: {
+      type: Array,
+      default: () => []
+    },
+    placeholder: {
+      type: String,
+      default: ""
+    },
+    rules: {
+      type: Array
+    },
+    min: {
+      type: Number
+    },
+    max: {
+      type: Number
+    },
+    multiple: {
+      type: Boolean,
+      default: !1
+    },
+    button: {
+      type: Boolean,
+      default: !1
+    },
+    group: {
+      type: Boolean,
+      default: !1
+    },
+    row: {
+      type: Boolean,
+      default: !1
+    },
+    prop: {
+      type: String,
+      default: ""
+    },
+    border: {
+      type: Boolean,
+      default: !1
+    },
+    popperClass: {
+      type: String
+    },
+    propsHttp: {
+      type: Object,
+      default: () => r
+    },
+    props: {
+      type: Object,
+      default: () => i
+    }
+  },
+  watch: {
+    text: {
+      handler(t) {
+        this.handleChange(t);
+      }
+    },
+    value: {
+      handler() {
+        this.initVal();
+      }
+    }
+  },
+  computed: {
+    clearableVal() {
+      return this.disabled ? !1 : this.clearable;
+    },
+    componentName() {
+      return `el-${this.name}${this.button ? "-button" : ""}`;
+    },
+    required() {
+      return !s(this.rules);
+    },
+    isArray() {
+      return this.dataType === "array";
+    },
+    isString() {
+      return this.dataType === "string";
+    },
+    isNumber() {
+      return this.dataType === "number";
+    },
+    nameKey() {
+      return this.propsHttp.name || this.propsHttpDefault.name;
+    },
+    urlKey() {
+      return this.propsHttp.url || this.propsHttpDefault.url;
+    },
+    resKey() {
+      return this.propsHttp.res || this.propsHttpDefault.res;
+    },
+    groupsKey() {
+      return this.props.groups || this.propsDefault.groups;
+    },
+    valueKey() {
+      return this.props.value || this.propsDefault.value;
+    },
+    descKey() {
+      return this.props.desc || this.propsDefault.desc;
+    },
+    leafKey() {
+      return this.props.leaf || this.propsDefault.leaf;
+    },
+    labelKey() {
+      return this.props.label || this.propsDefault.label;
+    },
+    childrenKey() {
+      return this.props.children || this.propsDefault.children;
+    },
+    disabledKey() {
+      return this.props.disabled || this.propsDefault.disabled;
+    },
+    idKey() {
+      return this.props.id || this.propsDefault.id;
+    }
+  },
+  created() {
+    this.initVal();
+  }
+}, y = {
+  methods: {
+    bindEvent(t, e) {
+      e = Object.assign(e, { column: this.column }, this.tableData), typeof this[t] == "function" && (t === "change" ? this.column.cell !== !0 && this[t](e) : this[t](e)), this.$emit(t, e);
+    },
+    initVal() {
+      this.stringMode = typeof this.value == "string", this.text = p(this.value, this);
+    },
+    getLabelText(t) {
+      return s(t) ? "" : typeof this.typeformat == "function" ? this.typeformat(t, this.labelKey, this.valueKey) : t[this.labelKey];
+    },
+    handleFocus(t) {
+      this.bindEvent("focus", { value: this.value, event: t });
+    },
+    handleBlur(t) {
+      this.bindEvent("blur", { value: this.value, event: t });
+    },
+    handleClick(t) {
+      this.bindEvent("click", { value: this.value, event: t });
+    },
+    handleChange(t) {
+      let e = t;
+      (this.isString || this.isNumber || this.stringMode || this.listType === "picture-img") && Array.isArray(t) && (e = t.join(this.separator)), this.bindEvent("change", { value: e }), this.$emit("input", e);
+    }
+  }
+};
+export {
+  y as e,
+  f as p
+};

package/chunks/form-input-mixin.IKogWBfn.mjs

@@ -0,0 +1,24 @@
+import { f as e } from "./form-item-mixin.BilKDUlK.mjs";
+import { d as r } from "./index.LGsb2aDq.mjs";
+const o = {
+  mixins: [e],
+  props: {
+    value: [Boolean, String, Array, Number, Object, Date],
+    readonly: Boolean,
+    disabled: Boolean
+  },
+  computed: {
+    computePlaceholder() {
+      return this.placeholder === !0 ? this.message : this.placeholder;
+    },
+    listeners() {
+      return r(this.$listeners, "input", !1);
+    },
+    inputDisabled() {
+      return this.disabled;
+    }
+  }
+};
+export {
+  o as f
+};

package/chunks/form-item-mixin.BilKDUlK.mjs

@@ -0,0 +1,140 @@
+var m = Object.defineProperty;
+var l = Object.getOwnPropertySymbols;
+var f = Object.prototype.hasOwnProperty, c = Object.prototype.propertyIsEnumerable;
+var i = (e, r, t) => r in e ? m(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t, s = (e, r) => {
+  for (var t in r || (r = {}))
+    f.call(r, t) && i(e, t, r[t]);
+  if (l)
+    for (var t of l(r))
+      c.call(r, t) && i(e, t, r[t]);
+  return e;
+};
+import { d as o } from "./index.LGsb2aDq.mjs";
+import a from "element-ui/lib/col";
+import u from "element-ui/lib/form-item";
+const d = ["span"], n = [...Object.keys(a.props || a.default.props)], h = n.filter((e) => !d.includes(e)), b = ["label", "prop", "rules", "labelWidth", "required"], p = [...Object.keys(u.props || u.default.props)], g = p.filter((e) => !b.includes(e)), y = [
+  "wrapCol",
+  "wrapFormItem",
+  "unwrap",
+  "prefixConfig",
+  "block",
+  "placeholder",
+  "prefixPick",
+  "half",
+  ...n,
+  ...p
+], C = {
+  inject: {
+    elForm: {
+      default: {}
+    },
+    formItemGroup: {
+      default: {}
+    }
+  },
+  props: {
+    disabled: Boolean,
+    wrapCol: {
+      type: Boolean,
+      default: !0
+    },
+    wrapFormItem: {
+      type: Boolean,
+      default: !0
+    },
+    unwrap: Boolean,
+    half: Boolean,
+    prefixConfig: Boolean,
+    block: Boolean,
+    placeholder: {
+      type: [Boolean, String],
+      default: !0
+    },
+    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: !0
+    },
+    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() {
+      return this.prefixConfig ? "请配置" : this.prefixPick ? "请选择" : "请输入";
+    },
+    message() {
+      var e;
+      return `${this.prefix}${((e = this.label) == null ? void 0 : e.replace("：", "")) || ""}`;
+    },
+    computeRules() {
+      const e = [...this.rules || []];
+      if (this.required) {
+        const r = e.find((t) => t.required);
+        r ? r.ref ? r.label = r.label || this.label : r.message = e.message || this.message : e.unshift(this.getRequireRule());
+      }
+      return e.concat(this.getRules());
+    },
+    computeSpan() {
+      return this.block ? 24 : this.span;
+    },
+    formItemProps() {
+      return o(s(s({}, this.$props), this.$attrs), y);
+    },
+    elFormItemProps() {
+      return o(s(s({}, this.$props), this.$attrs), g);
+    },
+    elColProps() {
+      return o(s(s({}, this.$props), this.$attrs), h);
+    }
+  },
+  watch: {
+    computeRules() {
+      var e, r;
+      (r = (e = this.elForm) == null ? void 0 : e.clearValidate) == null || r.call(e, this.prop);
+    }
+  },
+  methods: {
+    getRules() {
+      return [];
+    },
+    getRequireRule() {
+      return {
+        required: !0,
+        message: this.message
+      };
+    }
+  }
+};
+export {
+  C as f
+};

package/{dist/chunks/822300f3.js → chunks/form-pick-mixin.y-qhZJi6.mjs}

@@ -1,11 +1,11 @@
-const formPickMixin = {
+const e = {
   props: {
     prefixPick: {
       type: Boolean,
-      default: true
+      default: !0
     }
   }
 };
 export {
-  formPickMixin as f
+  e as f
 };

package/chunks/index.LGsb2aDq.mjs

@@ -0,0 +1,185 @@
+import { isObject as u, isString as a, hasOwn as f, isPlainObject as p, isArray as h, camelize as g, isFunction as m } from "@web-utils/core";
+import x from "vue";
+const T = (e, r) => p(e) || a(e) ? [r, e] : h(e) ? [r, ...e] : [r];
+function E() {
+  const e = window.navigator.userAgent, r = e.indexOf("MSIE ");
+  if (r > 0)
+    return parseInt(e.substring(r + 5, e.indexOf(".", r)), 10);
+  if (e.indexOf("Trident/") > 0) {
+    const o = e.indexOf("rv:");
+    return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
+  }
+  const l = e.indexOf("Edge/");
+  return l > 0 ? parseInt(e.substring(l + 5, e.indexOf(".", l)), 10) : -1;
+}
+function z(e, r) {
+  for (const t in r)
+    x.set(e, t, r[t]);
+  return e;
+}
+const I = (e, r) => {
+  if (!e || !r)
+    return null;
+  let t = e;
+  for (; t && r(t); )
+    t = t.$parent;
+  return t;
+}, w = [
+  "data",
+  "height",
+  "max-height",
+  "stripe",
+  "border",
+  "size",
+  "fit",
+  "show-header",
+  "highlight-current-row",
+  "current-row-key",
+  "row-class-name",
+  "row-style",
+  "cell-class-name",
+  "cell-style",
+  "header-row-class-name",
+  "header-row-style",
+  "header-cell-class-name",
+  "header-cell-style",
+  "row-key",
+  "empty-text",
+  "default-expand-all",
+  "expand-row-keys",
+  "default-sort",
+  "tooltip-effect",
+  "show-summary",
+  "sum-text",
+  "summary-method",
+  "span-method",
+  "select-on-indeterminate ",
+  "indent",
+  "lazy",
+  "load",
+  "tree-props"
+], b = [
+  "select",
+  "select-all",
+  "selection-change",
+  "cell-mouse-enter",
+  "cell-mouse-leave",
+  "cell-click",
+  "cell-dblclick",
+  "row-click",
+  "row-contextmenu",
+  // 'row-dblclick',
+  "header-click",
+  "header-contextmenu",
+  "sort-change",
+  "filter-change",
+  "current-change",
+  "header-dragend",
+  "expand-change"
+], y = [
+  "type",
+  "index",
+  "column-key",
+  "label",
+  "prop",
+  "width",
+  "min-width",
+  "fixed",
+  "render-header",
+  "sortable",
+  "sort-method",
+  "sort-by",
+  "sort-orders",
+  "resizable",
+  "formatter",
+  "show-overflow-tooltip",
+  "align",
+  "header-align",
+  "class-name",
+  "label-class-name",
+  "selectable",
+  "reserve-selection",
+  "filters",
+  "filter-placement",
+  "filter-multiple",
+  "filter-method",
+  "filtered-value"
+], k = [
+  "data",
+  "empty-text",
+  "node-key",
+  "props",
+  "render-after-expand",
+  "load",
+  "render-content",
+  "highlight-current",
+  "default-expand-all",
+  "expand-on-click-node",
+  "check-on-click-node",
+  "auto-expand-parent",
+  "default-expanded-keys",
+  "show-checkbox",
+  "check-strictly",
+  "default-checked-keys",
+  "current-node-key",
+  "filter-node-method",
+  "accordion",
+  "indent",
+  "icon-class",
+  "lazy",
+  "draggable",
+  "allow-drag",
+  "allow-drop"
+], v = [
+  "node-click",
+  "node-contextmenu",
+  "check-change",
+  "check",
+  "current-change",
+  "node-expand",
+  "node-collapse",
+  "node-drag-start",
+  "node-drag-enter",
+  "node-drag-leave",
+  "node-drag-over",
+  "node-drag-end",
+  "node-drop"
+], s = (e, r, t = !0) => {
+  if (u(e)) {
+    let l = r;
+    a(r) && (l = l.split(","));
+    const o = {};
+    return l.forEach((n) => {
+      f(e, n) && (t ? o[n] = e[n] : l.includes(n) || (o[n] = e[n]));
+    }), o;
+  }
+  return e;
+}, A = (e) => {
+  const r = {};
+  for (const t in e)
+    r[g(t)] = e[t];
+  return r;
+}, V = (e) => s(e, w), K = (e) => s(e, y), R = (e) => s(e, b), S = (e) => s(e, k), F = (e) => s(e, v), c = (e = "", r) => {
+  const t = r || {};
+  return (e || "").replace(/{(.*?)}/g, (o, n) => {
+    if (n.indexOf(":")) {
+      const [i, d] = n.split(":");
+      return t[i] ? t[i] : d;
+    } else
+      return t[n] || "";
+  });
+}, M = (e, r) => m(e) ? c(e(r), r) : a(e) ? c(e, r) : null;
+export {
+  S as a,
+  F as b,
+  z as c,
+  s as d,
+  I as e,
+  K as f,
+  T as g,
+  V as h,
+  R as i,
+  E as j,
+  M as k,
+  A as n
+};

package/chunks/init.Ac4dKUJB.mjs

@@ -0,0 +1,122 @@
+import { s as a, l as n, a as h, b as r } from "./dic.6tk91Dmq.mjs";
+import { d, a as c } from "./util.C2Bhx22L.mjs";
+import { s as l } from "./slot.j1uMmBnG.mjs";
+import { isBlank as s } from "@web-utils/core";
+const f = {
+  mixins: [l],
+  props: {
+    defaults: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    option: {
+      type: Object,
+      required: !0,
+      default: () => ({})
+    }
+  },
+  watch: {
+    defaults: {
+      handler(t) {
+        this.objectOption = t;
+      },
+      deep: !0
+    },
+    objectOption: {
+      handler(t) {
+        this.$emit("update:defaults", t);
+      },
+      deep: !0
+    },
+    propOption: {
+      handler(t) {
+        const i = {};
+        t.forEach((e) => {
+          i[e.prop] = e;
+        }), this.$set(this, "objectOption", i);
+      },
+      deep: !0
+    },
+    option: {
+      handler() {
+        this.init(!1);
+      },
+      deep: !0
+    }
+  },
+  data() {
+    return {
+      DIC: {},
+      cascaderDIC: {},
+      tableOption: {},
+      isMobile: "",
+      objectOption: {}
+    };
+  },
+  created() {
+    this.init();
+  },
+  computed: {
+    resultOption() {
+      return Object.assign(d(this.tableOption), {
+        column: this.propOption
+      });
+    },
+    rowKey() {
+      return this.tableOption.rowKey || c.rowKey;
+    },
+    formRules() {
+      const t = {};
+      return this.propOption.forEach((i) => {
+        i.rules && i.display !== !1 && (t[i.prop] = i.rules);
+      }), t;
+    },
+    isMediumSize() {
+      return this.controlSize;
+    },
+    controlSize() {
+      return this.tableOption.size || this.$AVUE.size;
+    }
+  },
+  methods: {
+    init(t) {
+      this.tableOption = this.option, this.getIsMobile(), this.handleLocalDic(), t !== !1 && this.handleLoadDic();
+    },
+    dicInit(t) {
+      t === "cascader" ? this.handleLoadCascaderDic() : this.handleLoadDic();
+    },
+    getIsMobile() {
+      this.isMobile = document.body.clientWidth <= 768;
+    },
+    updateDic(t, i) {
+      const e = this.findObject(this.propOption, t);
+      s(i) && s(t) ? this.handleLoadDic() : s(i) && !s(e.dicUrl) ? a({
+        column: e
+      }).then((o) => {
+        this.$set(this.DIC, t, o);
+      }) : this.$set(this.DIC, t, i);
+    },
+    handleSetDic(t, i = {}) {
+      Object.keys(i).forEach((e) => {
+        this.$set(t, e, i[e]);
+      });
+    },
+    // 本地字典
+    handleLocalDic() {
+      this.handleSetDic(this.DIC, n(this.resultOption));
+    },
+    // 网络字典加载
+    handleLoadDic() {
+      h(this.resultOption).then((t) => this.handleSetDic(this.DIC, t));
+    },
+    // 级联字典加载
+    handleLoadCascaderDic() {
+      r(this.propOption, this.data).then((t) => this.handleSetDic(this.cascaderDIC, t));
+    }
+  }
+};
+export {
+  f as i
+};