@web-utils/component 2.7.30 → 2.7.32

package/dist/chunks/{mixins.6a394a6c.js → mixins.e1939731.mjs}

@@ -1,9 +1,10 @@
 const uploaderMixin = {
   inject: ["uploader"]
-}, supportMixin = {
+};
+const supportMixin = {
   data() {
     return {
-      support: !0
+      support: true
     };
   },
   mounted() {

package/dist/chunks/{packages.419bde01.js → packages.c4ea639d.mjs}

@@ -47,12 +47,18 @@ const list = {
     title: "需要引入mock模拟数据包",
     github: "https://github.com/Colingo/mock"
   }
-}, packages = (() => ({
-  logs: function(name) {
-    const obj = list[name], log = createLogger(name);
-    log.warning(obj.title), log.warning(`CDN:${obj.url || "-"}`), log.warning(`GITHUB:${obj.github || "-"}`);
-  }
-}))();
+};
+const packages = (() => {
+  return {
+    logs: function(name) {
+      const obj = list[name];
+      const log = createLogger(name);
+      log.warning(obj.title);
+      log.warning(`CDN:${obj.url || "-"}`);
+      log.warning(`GITHUB:${obj.github || "-"}`);
+    }
+  };
+})();
 export {
   packages as p
 };

package/dist/chunks/{permission.07c49abf.js → permission.9c766972.mjs}

@@ -1,6 +1,11 @@
 const permission = (() => {
   function init(el, binding) {
-    binding.value === !1 ? el.style.display = "none" : el.style.display = "";
+    const value = binding.value;
+    if (value === false) {
+      el.style.display = "none";
+    } else {
+      el.style.display = "";
+    }
   }
   return {
     bind(el, binding) {

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

@@ -0,0 +1,35 @@
+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.9d568df9.js → tab-mixin.9d848bf6.mjs}

@@ -1,15 +1,23 @@
 const parentMixin = {
   mounted() {
-    this.value >= 0 && (this.currentIndex = this.value), this.updateIndex();
+    if (this.value >= 0) {
+      this.currentIndex = this.value;
+    }
+    this.updateIndex();
   },
   methods: {
     updateIndex() {
-      if (!this.$children || !this.$children.length)
+      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, children[i].currentSelected && (this.index = i);
+      for (let i = 0; i < children.length; i++) {
+        children[i].currentIndex = i;
+        if (children[i].currentSelected) {
+          this.index = i;
+        }
+      }
     }
   },
   props: {
@@ -17,7 +25,10 @@ const parentMixin = {
   },
   watch: {
     currentIndex(val, oldVal) {
-      oldVal > -1 && this.$children[oldVal] && (this.$children[oldVal].currentSelected = !1), val > -1 && this.$children[val] && (this.$children[val].currentSelected = !0), this.$emit("input", val), this.$emit("on-index-change", 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;
@@ -33,11 +44,12 @@ const parentMixin = {
       number: this.$children.length
     };
   }
-}, childMixin = {
+};
+const childMixin = {
   props: {
     selected: {
       type: Boolean,
-      default: !1
+      default: false
     }
   },
   mounted() {
@@ -55,14 +67,20 @@ const parentMixin = {
         this.$parent.$emit("on-before-index-change", this.currentIndex);
         return;
       }
-      (typeof this.disabled == "undefined" || this.disabled === !1) && (this.currentSelected = !0, this.$parent.currentIndex = this.currentIndex, this.$nextTick(() => {
-        this.$emit("on-item-click", this.currentIndex);
-      }));
+      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) {
-      val && (this.$parent.index = this.currentIndex);
+      if (val) {
+        this.$parent.index = this.currentIndex;
+      }
     },
     selected(val) {
       this.currentSelected = val;

package/dist/chunks/util.b0d0b0ad.mjs

@@ -0,0 +1,478 @@
+import { isBlank, getObjType } from "@web-utils/core";
+const KEY_COMPONENT_NAME = "fy-";
+const DIC_PROPS = {
+  rowKey: "id",
+  rowParentKey: "parentId",
+  nodeKey: "id",
+  label: "label",
+  value: "value",
+  desc: "desc",
+  groups: "groups",
+  title: "title",
+  leaf: "leaf",
+  children: "children",
+  hasChildren: "hasChildren",
+  labelText: "名称",
+  disabled: "disabled"
+};
+const DIC_HTTP_PROPS = {
+  name: "name",
+  url: "url",
+  fileName: "file",
+  res: ""
+};
+const DATE_LIST = [
+  "dates",
+  "date",
+  "datetime",
+  "datetimerange",
+  "daterange",
+  "time",
+  "timerange",
+  "week",
+  "month",
+  "monthrange",
+  "year"
+];
+const INPUT_LIST = ["tree", "number", "icon", "color", "table", "map"];
+const ARRAY_LIST = ["img", "array", "url"];
+const MULTIPLE_LIST = ["cascader", "tree", "select"];
+const RANGE_LIST = ["slider"];
+const ARRAY_VALUE_LIST = ARRAY_LIST.concat(["upload", "dynamic", "map", "checkbox", "cascader", "dynamic", "timerange", "monthrange", "daterange", "datetimerange", "dates"]);
+const SELECT_LIST = DATE_LIST.concat(["select", "checkbox", "radio", "cascader", "tree", "color", "icon", "table", "map"]);
+const DIC_SHOW_SPLIT = " | ";
+const DIC_SPLIT = ",";
+const typeList = {
+  img: /\.(gif|jpg|jpeg|png|webp|svg|GIF|JPG|JPEG|PNG|WEBP|SVG)/,
+  video: /\.(swf|avi|flv|mpg|rm|mov|wav|asf|3gp|mkv|rmvb|ogg|mp4)/,
+  audio: /\.(mp3|wav|MP3|WAV)/
+};
+const isMediaType = (url, type2) => {
+  if (isBlank(url))
+    return;
+  if (typeList.audio.test(url) || type2 === "audio") {
+    return "audio";
+  } else if (typeList.video.test(url) || type2 === "video") {
+    return "video";
+  } else if (typeList.img.test(url) || type2 === "img") {
+    return "img";
+  }
+  return false;
+};
+function getFixed(val = 0, len = 2) {
+  return Number(val.toFixed(len));
+}
+function getAsVal(obj2, bind2 = "") {
+  let result2 = deepClone(obj2);
+  if (isBlank(bind2))
+    return result2;
+  bind2.split(".").forEach((ele) => {
+    result2 = !isBlank(result2[ele]) ? result2[ele] : "";
+  });
+  return result2;
+}
+function setAsVal(obj, bind = "", value) {
+  let result;
+  const type = getObjType(value);
+  if (isBlank(value)) {
+    if (type === "array") {
+      result = `obj.${bind}=[]`;
+    } else if (type === "object") {
+      result = `obj.${bind}={}`;
+    } else if (["number", "boolean"].includes(type)) {
+      result = `obj.${bind}=undefined`;
+    } else {
+      result = `obj.${bind}=''`;
+    }
+  } else {
+    if (type === "string") {
+      result = `obj.${bind}='${value}'`;
+    } else {
+      result = `obj.${bind}=${value}`;
+    }
+  }
+  eval(result);
+  return obj;
+}
+function downFile(url, saveName) {
+  if (typeof url === "object" && url instanceof Blob) {
+    url = URL.createObjectURL(url);
+  }
+  const aLink = document.createElement("a");
+  aLink.href = url;
+  aLink.download = saveName || "";
+  let event;
+  if (window.MouseEvent) {
+    event = new MouseEvent("click");
+  } else {
+    event = document.createEvent("MouseEvents");
+    event.initMouseEvent(
+      "click",
+      true,
+      false,
+      window,
+      0,
+      0,
+      0,
+      0,
+      0,
+      false,
+      false,
+      false,
+      false,
+      0,
+      null
+    );
+  }
+  aLink.dispatchEvent(event);
+}
+function strCorNum(list) {
+  list.forEach((ele, index) => {
+    list[index] = Number(ele);
+  });
+  return list;
+}
+function extend() {
+  let target = arguments[0] || {};
+  let deep = false;
+  const arr = Array.prototype.slice.call(arguments);
+  let i = 1;
+  let options, src, key, copy;
+  let isArray = false;
+  if (typeof target === "boolean") {
+    deep = target;
+    i++;
+    target = arguments[1];
+  }
+  for (; i < arr.length; i++) {
+    if ((options = arr[i]) != null) {
+      for (key in options) {
+        copy = options[key];
+        src = target[key];
+        if (deep && (toString.call(copy) === "[object Object]" || (isArray = toString.call(copy) === "[object Array]"))) {
+          if (isArray) {
+            src = toString.call(src) === "[object Array]" ? src : [];
+          } else {
+            src = toString.call(src) === "[object Object]" ? src : {};
+          }
+          target[key] = extend(deep, src, copy);
+        } else if (copy !== void 0 && copy !== src) {
+          target[key] = copy;
+        }
+      }
+    }
+  }
+  return target;
+}
+function createObj(obj2, bind2) {
+  const list = bind2.split(".");
+  const first = list.splice(0, 1)[0];
+  const deep = {};
+  deep[first] = {};
+  if (list.length >= 2) {
+    const start = "{";
+    const end = "}";
+    let result2 = "";
+    list.forEach((ele) => {
+      result2 = `${result2}${start}"${ele}":`;
+    });
+    result2 = `${result2}""`;
+    for (let i = 0; i < list.length; i++) {
+      result2 = `${result2}${end}`;
+    }
+    result2 = JSON.parse(result2);
+    deep[first] = result2;
+  }
+  obj2 = extend(true, obj2, deep);
+  return obj2;
+}
+function dataURLtoFile(dataurl, filename) {
+  const arr = dataurl.split(",");
+  const mime = arr[0].match(/:(.*?);/)[1];
+  const bstr = atob(arr[1]);
+  let n = bstr.length;
+  const u8arr = new Uint8Array(n);
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n);
+  }
+  return new File([u8arr], filename, {
+    type: mime
+  });
+}
+function findObject(list, value2, key = "prop") {
+  let result2 = -1;
+  const type2 = (() => {
+    let result3;
+    list.forEach((ele) => {
+      if (ele.column) {
+        result3 = "group";
+      } else if (ele.children) {
+        result3 = "tree";
+      }
+    });
+    return result3;
+  })();
+  if (type2 === "group") {
+    list.forEach((ele) => {
+      const val = findArray(ele.column, value2, key, true);
+      if (val !== -1)
+        result2 = val;
+    });
+  } else if (type2 === "tree") {
+    result2 = findLabelNode(list, value2, { value: key }, true);
+  } else {
+    result2 = findArray(list, value2, key, true);
+  }
+  return result2;
+}
+function randomId() {
+  const $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  const maxPos = $chars.length;
+  let id = "";
+  for (let i = 0; i < 16; i++) {
+    id += $chars.charAt(Math.floor(Math.random() * maxPos));
+  }
+  return id;
+}
+const deepClone = (data) => {
+  const type2 = getObjType(data);
+  let obj2;
+  if (type2 === "array")
+    obj2 = [];
+  else if (type2 === "object")
+    obj2 = {};
+  else
+    return data;
+  if (type2 === "array") {
+    for (var i = 0, len = data.length; i < len; i++) {
+      data[i] = (() => {
+        if (data[i] === 0) {
+          return data[i];
+        }
+        return data[i];
+      })();
+      if (data[i]) {
+        delete data[i].$parent;
+      }
+      obj2.push(deepClone(data[i]));
+    }
+  } else if (type2 === "object") {
+    for (const key in data) {
+      if (data) {
+        delete data.$parent;
+      }
+      obj2[key] = deepClone(data[key]);
+    }
+  }
+  return obj2;
+};
+const setPx = (val, defval = "") => {
+  if (!val) {
+    val = defval;
+  }
+  if (!val) {
+    return "";
+  }
+  val = `${val}`;
+  if (val.indexOf("%") === -1 && val.indexOf("px") === -1) {
+    val = `${val}px`;
+  }
+  return val;
+};
+const detailDataType = (value2, type2) => {
+  if (isBlank(value2))
+    return value2;
+  if (type2 === "number") {
+    return Number(value2);
+  } else if (type2 === "string") {
+    return `${value2}`;
+  } else {
+    return value2;
+  }
+};
+const detailDic = (list = [], props = {}, type2) => {
+  const valueKey = props.value || DIC_PROPS.value;
+  const childrenKey = props.children || DIC_PROPS.children;
+  list.forEach((ele) => {
+    ele[valueKey] = detailDataType(ele[valueKey], type2);
+    if (ele[childrenKey])
+      detailDic(ele[childrenKey], props, type2);
+  });
+  return list;
+};
+const findByValue = (dic, value2, props) => {
+  if (isBlank(dic))
+    return value2;
+  const isArray = value2 instanceof Array;
+  const list = isArray ? value2 : [value2];
+  props = props || DIC_PROPS;
+  const result2 = [];
+  for (let i = 0; i < list.length; i++) {
+    result2.push(findLabelNode(dic, list[i], props) || list[i]);
+  }
+  if (isArray) {
+    return result2.join(DIC_SHOW_SPLIT);
+  }
+  return result2.join();
+};
+const filterParams = (form, list = ["", "$"], deep = true) => {
+  const data = deep ? deepClone(form) : form;
+  for (const o in data) {
+    if (list.includes("")) {
+      if (isBlank(data[o]))
+        delete data[o];
+    }
+    if (list.includes("$")) {
+      if (o.indexOf("$") !== -1)
+        delete data[o];
+    }
+  }
+  return data;
+};
+const detailDicGroup = (dic = [], props = {}) => {
+  let list = deepClone(dic);
+  const groupsKey = props[DIC_PROPS.groups] || DIC_PROPS.groups;
+  dic.forEach((ele) => {
+    if (ele[groupsKey]) {
+      list = list.concat(ele[groupsKey]);
+    }
+  });
+  return list;
+};
+const findLabelNode = (dic, value2, props, obj2) => {
+  let result2;
+  if (!obj2)
+    dic = detailDicGroup(dic, props);
+  const rev = (dic1) => {
+    const labelKey = props.label || DIC_PROPS.label;
+    const valueKey = props.value || DIC_PROPS.value;
+    const childrenKey = props.children || DIC_PROPS.children;
+    for (let i = 0; i < dic1.length; i++) {
+      const ele = dic1[i];
+      const children = ele[childrenKey] || [];
+      if (ele[valueKey] === value2) {
+        result2 = obj2 ? ele : ele[labelKey];
+      } else {
+        rev(children);
+      }
+    }
+  };
+  rev(dic);
+  return result2;
+};
+const getDeepData = (res) => {
+  return (Array.isArray(res) ? res : res.data) || [];
+};
+const getObjValue = (data, params = "", type2) => {
+  const list = params.split(".");
+  let result2 = data;
+  if (list[0] === "" && type2 !== "object") {
+    return getDeepData(data);
+  } else if (list[0] !== "") {
+    list.forEach((ele) => {
+      result2 = result2[ele];
+    });
+  }
+  return result2;
+};
+const findArray = (dic, value2, valueKey, obj2) => {
+  valueKey = valueKey || DIC_PROPS.value;
+  for (let i = 0; i < dic.length; i++) {
+    if (dic[i][valueKey] === value2) {
+      return obj2 ? dic[i] : i;
+    }
+  }
+  return -1;
+};
+const getPasswordChar = (result2 = "", char) => {
+  const len = result2.toString().length;
+  result2 = "";
+  for (let i = 0; i < len; i++) {
+    result2 = result2 + char;
+  }
+  return result2;
+};
+const arraySort = (list = [], prop, callback) => {
+  return list.filter((ele) => !isBlank(ele[prop])).sort((a, b) => callback(a, b)).concat(list.filter((ele) => isBlank(ele[prop])));
+};
+const clearVal = (obj2, propList, list = []) => {
+  if (!obj2)
+    return {};
+  propList.forEach((ele) => {
+    if (list.includes(ele))
+      ;
+    else if (ele.includes("$")) {
+      delete obj2[ele];
+    } else if (!isBlank(obj2[ele])) {
+      const type2 = getObjType(obj2[ele]);
+      if (type2 === "array")
+        obj2[ele] = [];
+      else if (type2 === "object")
+        obj2[ele] = {};
+      else if (["number", "boolean"].includes(type2))
+        obj2[ele] = void 0;
+      else
+        obj2[ele] = "";
+    }
+  });
+  return obj2;
+};
+const optVal = (val, def) => {
+  if (typeof val === "boolean") {
+    return val;
+  }
+  return !isBlank(val) ? val : def;
+};
+function uploadFun(column = {}, safe) {
+  safe = safe || this;
+  const list = ["uploadPreview", "uploadBefore", "uploadAfter", "uploadDelete", "uploadError", "uploadExceed"];
+  const result2 = {};
+  if (column.type === "upload") {
+    list.forEach((ele) => {
+      if (!column[ele]) {
+        result2[ele] = safe[ele];
+      }
+    });
+  } else {
+    list.forEach((ele) => {
+      result2[ele] = safe[ele];
+    });
+  }
+  return result2;
+}
+export {
+  ARRAY_VALUE_LIST as A,
+  downFile as B,
+  DIC_PROPS as D,
+  INPUT_LIST as I,
+  KEY_COMPONENT_NAME as K,
+  MULTIPLE_LIST as M,
+  RANGE_LIST as R,
+  SELECT_LIST as S,
+  arraySort as a,
+  DIC_SHOW_SPLIT as b,
+  DIC_SPLIT as c,
+  deepClone as d,
+  strCorNum as e,
+  ARRAY_LIST as f,
+  getAsVal as g,
+  getPasswordChar as h,
+  isMediaType as i,
+  DATE_LIST as j,
+  findByValue as k,
+  detailDic as l,
+  getObjValue as m,
+  findObject as n,
+  optVal as o,
+  detailDataType as p,
+  createObj as q,
+  randomId as r,
+  setPx as s,
+  DIC_HTTP_PROPS as t,
+  uploadFun as u,
+  filterParams as v,
+  getFixed as w,
+  setAsVal as x,
+  clearVal as y,
+  dataURLtoFile as z
+};