cnhis-design-vue 3.1.12-beta.0 → 3.1.12-beta.3

package/es/src/utils/utilExpand.js

@@ -1 +1,714 @@
-export { expandXEUtils } from './utilExpand2.js';
+import moment from 'moment';
+import XEUtils from 'xe-utils';
+
+const expandXEUtils = (() => {
+  const _toString = Object.prototype.toString;
+  const com = {
+    parseCondition: function(conList, data, fieldList) {
+      if (conList && conList.length > 0 && data && data.table) {
+        for (let i = 0; i < conList.length; i++) {
+          let conObj = conList[i];
+          if (conObj && conObj.field_key && conObj.con) {
+            let value = data.table[conObj.field_key];
+            let fieldObj = XEUtils.getFieldByKey(conObj.field_key, fieldList);
+            if (!fieldObj || !value && String(value) !== "0")
+              return false;
+            if (!XEUtils.getConnection(conObj, value, fieldObj)) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    },
+    getFieldByKey: function(fieldKey, fieldList) {
+      if (fieldList && fieldList.length > 0) {
+        for (let i = 0; i < fieldList.length; i++) {
+          let fobj = fieldList[i];
+          if (fobj.columnName == fieldKey) {
+            return fobj;
+          }
+        }
+      }
+    },
+    getConnection: function(cObj, fVal, field) {
+      let con = cObj.con;
+      let value = cObj.value;
+      if ("NULL" == con) {
+        if (fVal) {
+          return false;
+        }
+      } else if ("NOT_NULL" == con) {
+        if (!fVal) {
+          return false;
+        }
+      }
+      if ("TEXT" == field.fieldType) {
+        if ("CL" == con) {
+          if (fVal.indexOf(value) == -1) {
+            return false;
+          }
+        } else if ("NC" == con) {
+          if (fVal.indexOf(value) != -1) {
+            return false;
+          }
+        } else if ("EQ" == con || "QUOTE" == con) {
+          if (value.indexOf("|#|") != -1) {
+            for (let kw in value.split("|#|")) {
+              if (fVal.indexOf(kw) == -1) {
+                return false;
+              }
+            }
+          } else {
+            if (fVal != value) {
+              return false;
+            }
+          }
+        } else if ("NEQ" == con) {
+          if (fVal == value) {
+            return false;
+          }
+        }
+      } else {
+        if ("NUMBER" == field.fieldType) {
+          if (!XEUtils.isNumber(fVal)) {
+            return false;
+          }
+          if ("EQ" == con || "QUOTE" == con) {
+            if (XEUtils.isNumber(value)) {
+              if (fVal * 1 != value * 1) {
+                return false;
+              }
+            } else {
+              if (!XEUtils.getBetween(value, "number", fVal)) {
+                return false;
+              }
+            }
+          } else if ("NEQ" == con) {
+            if (XEUtils.isNumber(value)) {
+              if (fVal * 1 == value * 1) {
+                return false;
+              }
+            }
+          } else if ("BIG" == con) {
+            if (XEUtils.isNumber(value)) {
+              if (fVal * 1 <= value * 1) {
+                return false;
+              }
+            }
+          } else if ("LESS" == con) {
+            if (XEUtils.isNumber(value)) {
+              if (fVal * 1 >= value * 1) {
+                return false;
+              }
+            }
+          }
+        } else {
+          if ("TODAY" == con || "TOMORROW" == con || "YESTERDAY" == con || "THIS_WEEK" == con || "NEXT_WEEK" == con || "UP_WEEK" == con || "THIS_MONTH" == con || "NEXT_MONTH" == con || "UP_MONTH" == con || "THIS_SEASON" == con || "NEXT_SEASON" == con || "UP_SEASON" == con || "THIS_YEAR" == con || "NEXT_YEAR" == con || "UP_YEAR" == con) {
+            if (XEUtils.isDate(fVal)) {
+              let curDate = new Date();
+              let startDate;
+              let endDate;
+              let oneDayTime = 24 * 60 * 60 * 1e3;
+              let fDate = XEUtils.convertDate(fVal);
+              let curDateStr = XEUtils.toDateString(curDate, "yyyy-MM-dd");
+              if ("TODAY" == con) {
+                startDate = XEUtils.convertDate(curDateStr + " 00:00:00");
+                endDate = XEUtils.convertDate(curDateStr + " 23:59:59");
+              } else if ("TOMORROW" == con) {
+                let tomorrowDate = XEUtils.addDate(curDate, 1, "D");
+                let dateStr = tomorrowDate.format("yyyy-MM-dd");
+                startDate = XEUtils.convertDate(dateStr + " 00:00:00");
+                endDate = XEUtils.convertDate(dateStr + " 23:59:59");
+              } else if ("YESTERDAY" == con) {
+                let tomorrowDate = XEUtils.addDate(curDate, -1, "D");
+                let dateStr = tomorrowDate.format("yyyy-MM-dd");
+                startDate = XEUtils.convertDate(dateStr + " 00:00:00");
+                endDate = XEUtils.convertDate(dateStr + " 23:59:59");
+              } else if ("THIS_WEEK" == con) {
+                let day = curDate.getDay() || 7;
+                let mondayTime = curDate.getTime() - (day - 1) * oneDayTime;
+                let mundayTime = curDate.getTime() + (7 - day) * oneDayTime;
+                startDate = new Date(mondayTime);
+                endDate = new Date(mundayTime);
+              } else if ("NEXT_WEEK" == con) {
+                let sevenDays = XEUtils.addDate(curDate, 1, "W");
+                let day = sevenDays.getDay() || 7;
+                let mondayTime = sevenDays.getTime() - (day - 1) * oneDayTime;
+                let mundayTime = sevenDays.getTime() + (7 - day) * oneDayTime;
+                startDate = new Date(mondayTime);
+                endDate = new Date(mundayTime);
+              } else if ("UP_WEEK" == con) {
+                let sevenDays = XEUtils.addDate(curDate, -1, "W");
+                let day = sevenDays.getDay() || 7;
+                let mondayTime = sevenDays.getTime() - (day - 1) * oneDayTime;
+                let mundayTime = sevenDays.getTime() + (7 - day) * oneDayTime;
+                startDate = new Date(mondayTime);
+                endDate = new Date(mundayTime);
+              } else if ("THIS_MONTH" == con) {
+                let date = new Date();
+                date.setDate(1);
+                startDate = date;
+                endDate = XEUtils.addDate(date, 1, "M");
+              } else if ("NEXT_MONTH" == con) {
+                let date = new Date();
+                date.setDate(1);
+                startDate = XEUtils.addDate(date, 1, "M");
+                endDate = XEUtils.addDate(date, 2, "M");
+              } else if ("UP_MONTH" == con) {
+                let date = new Date();
+                date.setDate(1);
+                startDate = XEUtils.addDate(date, -1, "M");
+                endDate = date;
+              } else if ("THIS_SEASON" == con) {
+                startDate = XEUtils.getCurSeasonFirstDay();
+                endDate = XEUtils.addDate(startDate, 3, "M");
+              } else if ("NEXT_SEASON" == con) {
+                startDate = XEUtils.addDate(XEUtils.getCurSeasonFirstDay(), 3, "M");
+                endDate = XEUtils.addDate(startDate, 3, "M");
+              } else if ("UP_SEASON" == con) {
+                endDate = XEUtils.getCurSeasonFirstDay();
+                startDate = XEUtils.addDate(endDate, -3, "M");
+              } else if ("THIS_YEAR" == con) {
+                let date = new Date();
+                startDate = new Date(date.getFullYear() + "/01/01");
+                endDate = XEUtils.addDate(startDate, 1, "Y");
+              } else if ("NEXT_YEAR" == con) {
+                let date = new Date();
+                startDate = XEUtils.addDate(new Date(date.getFullYear() + "/01/01"), 1, "Y");
+                endDate = XEUtils.addDate(startDate, 1, "Y");
+              } else if ("UP_YEAR" == con) {
+                let date = new Date();
+                endDate = new Date(date.getFullYear() + "/01/01");
+                startDate = XEUtils.addDate(endDate, -1, "Y");
+              }
+              if (startDate && endDate) {
+                if (!(startDate.getTime() <= fDate.getTime() && fDate.getTime() < endDate.getTime())) {
+                  return false;
+                }
+              }
+            } else {
+              return false;
+            }
+          } else if ("L_" == con || "N_" == con || "IN_THE_PAST" == con || "IN_THE_FUTURE" == con || "IN_THE_PAST_DI" == con || "IN_THE_FUTURE_DI" == con) {
+            if (cObj["unit"] && XEUtils.isNumber(value)) {
+              if (XEUtils.isDate(fVal)) {
+                let fDate = XEUtils.convertDate(fVal);
+                let curDate = new Date();
+                let unit = cObj["unit"];
+                if ("DAY" == unit || "WEEK" == unit || "MONTH" == unit || "QUARTER" == unit || "YEAR" == unit || "HOUR" == unit) {
+                  let type = "D";
+                  if ("WEEK" == unit) {
+                    type = "W";
+                  } else if ("MONTH" == unit) {
+                    type = "M";
+                  } else if ("QUARTER" == unit) {
+                    type = "Q";
+                  } else if ("YEAR" == unit) {
+                    type = "Y";
+                  } else if ("HOUR" == unit) {
+                    type = "H";
+                  }
+                  let count = value * 1;
+                  if ("L_" == con) {
+                    let targetDate = XEUtils.addDate(new Date(), count * -1, type);
+                    if (fDate.getTime() < targetDate.getTime()) {
+                      return false;
+                    }
+                  } else if ("N_" == con) {
+                    let targetDate = XEUtils.addDate(new Date(), count, type);
+                    if (fDate.getTime() > targetDate.getTime()) {
+                      return false;
+                    }
+                  } else if ("IN_THE_PAST" == con) {
+                    let curTime = fDate.getTime();
+                    let endTime = curDate.getTime();
+                    let startTime = XEUtils.addDate(curDate, count * -1, type).getTime();
+                    if (curTime < startTime || curTime > endTime) {
+                      return false;
+                    }
+                  } else if ("IN_THE_FUTURE" == con) {
+                    let curTime = fDate.getTime();
+                    let startTime = curDate.getTime();
+                    let endTime = XEUtils.addDate(curDate, count, type).getTime();
+                    if (curTime < startTime || curTime > endTime) {
+                      return false;
+                    }
+                  } else if ("IN_THE_PAST_DI" == con || "IN_THE_FUTURE_DI" == con) {
+                    let curTime = fDate.getTime();
+                    let useType = con == "IN_THE_FUTURE_DI" ? "add" : "subtract";
+                    let { startTime, endTime } = XEUtils.addDiDate(curDate, count, unit, useType);
+                    if (curTime < startTime || curTime > endTime) {
+                      return false;
+                    }
+                  }
+                }
+              } else {
+                return false;
+              }
+            }
+          } else if ("IN" == con) {
+            if (XEUtils.isDate(fVal)) {
+              let fDate = XEUtils.convertDate(fVal);
+              if (!value) {
+                if (cObj["start_val"] && cObj["end_val"]) {
+                  let start_val = cObj["start_val"];
+                  let end_val = cObj["end_val"];
+                  if (start_val && end_val && XEUtils.isDate(start_val) && XEUtils.isDate(end_val)) {
+                    let startDate = XEUtils.convertDate(start_val);
+                    let endDate = XEUtils.convertDate(end_val);
+                    if (!(startDate.getTime() <= fDate.getTime() && fDate.getTime() < endDate.getTime())) {
+                      return false;
+                    }
+                  } else {
+                    return false;
+                  }
+                } else if (cObj["start_val"]) {
+                  let start_val = cObj["start_val"];
+                  if (XEUtils.isDate(start_val)) {
+                    let startDate = XEUtils.convertDate(start_val);
+                    if (!(startDate.getTime() <= fDate.getTime())) {
+                      return false;
+                    }
+                  } else {
+                    return false;
+                  }
+                } else if (cObj["end_val"]) {
+                  let end_val = cObj["end_val"];
+                  if (XEUtils.isDate(end_val)) {
+                    let endDate = XEUtils.convertDate(end_val);
+                    if (!(fDate.getTime() < endDate.getTime())) {
+                      return false;
+                    }
+                  } else {
+                    return false;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if ("compare" == con) {
+        if ("TEXT" == field.fieldType) {
+          if (value.indexOf("|#|") != -1) {
+            for (let kw in value.split("|#|")) {
+              if (fVal.indexOf(kw) == -1) {
+                return false;
+              }
+            }
+          } else {
+            if (cObj["mk"] && "like" == cObj["mk"]) {
+              if (fVal.indexOf(value) == -1) {
+                return false;
+              }
+            } else {
+              if (fVal.indexOf(value) == -1) {
+                return false;
+              }
+            }
+          }
+        } else if ("NUMBER" == field.fieldType()) {
+          if (XEUtils.isNumber(value) && XEUtils.isNumber(fVal)) {
+            if (fVal * 1 != value * 1) {
+              return false;
+            }
+          } else {
+            return false;
+          }
+        } else {
+          if (fVal != value) {
+            return false;
+          }
+        }
+      }
+      return true;
+    },
+    getBetween: function(value, type, comVal) {
+      if (value && value.indexOf("~") != -1 && value.split("~").length == 2) {
+        let start = value.split("~")[0];
+        let end = value.split("~")[1];
+        if ("number" == type) {
+          if (XEUtils.isNumber(start) && XEUtils.isNumber(end)) {
+            return start * 1 <= comVal * 1 && comVal * 1 < end * 1;
+          }
+        }
+      }
+    },
+    convertDate: function(str2) {
+      if (str2) {
+        if (str2.indexOf("-") != -1) {
+          str2 = str2 = str2.replace(/-/g, "/");
+          try {
+            let date = new Date(str2);
+            return date;
+          } catch (e) {
+            console.log(e);
+          }
+        } else {
+          try {
+            let date = new Date(str2);
+            return date;
+          } catch (e) {
+            console.log(e);
+          }
+        }
+      }
+    },
+    addDate: function(tempDate, days, unit) {
+      let date = tempDate;
+      if (["D", "H", "W"].includes(unit)) {
+        if (tempDate && XEUtils.isValidDate(tempDate)) {
+          date = date.getTime();
+        }
+      }
+      if (unit == "D") {
+        return new Date(date + days * 24 * 3600 * 1e3);
+      } else if (unit == "W") {
+        return new Date(date + days * 7 * 24 * 3600 * 1e3);
+      } else if (unit == "M") {
+        let newDate = new Date(date);
+        newDate.setMonth(date.getMonth() + days);
+        return newDate;
+      } else if (unit == "Q") {
+        let newDate = new Date(date);
+        newDate.setMonth(date.getMonth() + days * 3);
+        return newDate;
+      } else if (unit == "Y") {
+        let newDate = new Date(date);
+        newDate.setMonth(date.getMonth() + days * 12);
+        return newDate;
+      } else if (unit == "H") {
+        return new Date(date + days * 3600 * 1e3);
+      }
+    },
+    addDiDate: function(curDate, count, unit = "day", type) {
+      let useTime, res = {};
+      let getUnit = unit.toLowerCase();
+      let useUnit = getUnit + "s";
+      if (type == "add") {
+        useTime = moment(curDate).add(count, useUnit);
+      } else {
+        useTime = moment(curDate).subtract(count, useUnit);
+      }
+      res.startTime = useTime.startOf(getUnit).valueOf();
+      res.endTime = useTime.endOf(getUnit).valueOf();
+      return res;
+    },
+    getCurSeasonFirstDay: function() {
+      let curDate = new Date();
+      let year = curDate.getFullYear();
+      let month = curDate.getMonth() + 1;
+      if (month >= 1 && month <= 3) {
+        return new Date(year + "/01/01");
+      } else if (4 <= month && month <= 6) {
+        return new Date(year + "/04/01");
+      } else if (7 <= month && month <= 9) {
+        return new Date(year + "/07/01");
+      } else {
+        return new Date(year + "/10/01");
+      }
+    },
+    isNumber: function(val) {
+      try {
+        let i = val * 1 + 100;
+        if (i > 0 || i < 0 || i == 0) {
+          return true;
+        }
+      } catch (e) {
+        console.log(e);
+      }
+      return false;
+    },
+    isDate: function(data) {
+      if (isNaN(data) && !isNaN(Date.parse(data))) {
+        return true;
+      }
+      return false;
+    }
+  };
+  XEUtils.mixin({
+    ...com,
+    isJSON(str2) {
+      if (typeof str2 == "string") {
+        try {
+          let obj2 = JSON.parse(str2);
+          if (typeof obj2 == "object" && obj2) {
+            return true;
+          } else {
+            return false;
+          }
+        } catch (e) {
+          return false;
+        }
+      }
+      return false;
+    },
+    getBtnStyle(v2) {
+      if (v2.showStyle == "white_bg") {
+        return {
+          "border-color": v2.color,
+          color: v2.color
+        };
+      } else if (v2.showStyle == "none_bg") {
+        return {
+          color: v2.color
+        };
+      } else if (v2.showStyle == "only_icon") {
+        return {
+          "background-color": v2.color,
+          "border-color": v2.color
+        };
+      }
+      return {
+        "background-color": v2.color,
+        "border-color": v2.color
+      };
+    },
+    oldColorMap(str2) {
+      let oldMap = {
+        blue: "blue",
+        sky: "skyblue",
+        azure: "azure",
+        palegreen: "palegreen",
+        yellow: "yellow",
+        darkorange: "darkorange",
+        magenta: "magenta",
+        purple: "purple",
+        maroon: "maroon",
+        orange: "orange",
+        green: "green",
+        red: "red",
+        grey: "grey"
+      };
+      if (!str2 || !oldMap[str2])
+        return "";
+      return oldMap[str2];
+    },
+    validateBirthday(val, title, type) {
+      let res = true;
+      if (!type)
+        return false;
+      let regObj = {
+        DAYReg: /^([0-9]|[1-9][0-9]|[1-2][0-9][0-9]|[3][0-5][0-9]|(360|361|363|362|364|365))$/,
+        MONTHReg: /^(?:[0-9]|1[0-2])$/,
+        YEARReg: /^(?:[1-9]?\d|100)$/
+      };
+      let testReg = `${type}Reg`;
+      if (!regObj[testReg].test(+val)) {
+        window.$message.warning(`${title}${this.$t("1.9.40")}`, 2);
+        res = false;
+      }
+      return res;
+    },
+    handleImageSize(item, defaultHeight) {
+      let res = {
+        display: "inline-block",
+        height: defaultHeight
+      };
+      if (item.h) {
+        res.height = item.h === "adaptive" ? "auto" : item.h + "px";
+      }
+      if (item.w) {
+        res.width = item.w === "adaptive" ? "auto" : item.w + "px";
+      }
+      return res;
+    },
+    handleBigArrayCopy(arr, size = 1e3) {
+      if (!Array.isArray(arr))
+        return arr;
+      let cSize = size || 1e3;
+      const list = XEUtils.chunk(arr, cSize);
+      const copyFunc = (list2 = [], type = "json") => {
+        const obj2 = {
+          json: (v2) => JSON.parse(JSON.stringify(v2)),
+          clone: (v2) => XEUtils.clone(v2, true)
+        };
+        let copyList = [];
+        list2.forEach((v2) => {
+          let rs = obj2[type](v2);
+          copyList.push(rs);
+        });
+        return XEUtils.flatten(copyList);
+      };
+      let res = [];
+      try {
+        res = copyFunc(list, "json");
+      } catch (error) {
+        res = copyFunc(list, "clone");
+      }
+      return res;
+    },
+    getAlphafloat(a, alpha) {
+      if (typeof a !== "undefined") {
+        return parseFloat((a / 256).toFixed(2));
+      }
+      if (typeof alpha !== "undefined") {
+        if (1 < alpha && alpha <= 100) {
+          return parseFloat((alpha / 100).toFixed(2));
+        }
+        if (0 <= alpha && alpha <= 1) {
+          return parseFloat(alpha.toFixed(2));
+        }
+      }
+      return 1;
+    },
+    hexToRGBA(hex, alpha) {
+      const isValidHex = (hex2) => /^#([A-Fa-f0-9]{3,4}){1,2}$/.test(hex2);
+      const getChunksFromString = (st, chunkSize2) => st.match(new RegExp(`.{${chunkSize2}}`, "g"));
+      const convertHexUnitTo256 = (hexStr) => parseInt(hexStr.repeat(2 / hexStr.length), 16);
+      if (!isValidHex(hex)) {
+        console.log("Invalid HEX");
+        return "";
+      }
+      const chunkSize = Math.floor((hex.length - 1) / 3);
+      const hexArr = getChunksFromString(hex.slice(1), chunkSize);
+      const [r, g, b, a] = hexArr.map(convertHexUnitTo256);
+      return {
+        r,
+        g,
+        b,
+        a: XEUtils.getAlphafloat(a, alpha)
+      };
+    },
+    formatTime(type, time) {
+      let format = "";
+      if (!time)
+        return "";
+      switch (type) {
+        case "DATE":
+          format = "yyyy-MM-dd";
+          break;
+        case "DATETIME":
+          format = "yyyy-MM-dd HH:mm:ss";
+          break;
+        case "TIME":
+          format = "HH:mm:ss";
+          break;
+        case "MOUTH":
+          format = "MM-dd";
+          break;
+        case "DATETIMESTR":
+          format = "yyyy\u5E74M\u6708dd\u65E5 HH:mm";
+          break;
+        case "MOUTHTIME":
+          format = "M\u6708d\u65E5 HH:mm";
+          break;
+        case "HM":
+          format = " HH:mm";
+          break;
+      }
+      return XEUtils.toDateString(time, format);
+    },
+    formatDate(date, isShowYear = false) {
+      const today = new Date();
+      const curDate = date || today.getTime();
+      const todayStr = XEUtils.formatTime("DATE", today.getTime());
+      const todayTimeStamp = XEUtils.convertDate(todayStr + " 00:00:00").getTime();
+      const thisYear = today.getFullYear();
+      const curYear = new Date(+curDate).getFullYear();
+      if (curDate > todayTimeStamp) {
+        return XEUtils.formatTime("TIME", curDate);
+      } else {
+        if (!isShowYear)
+          return XEUtils.formatTime("DATETIME", curDate);
+        if (thisYear !== curYear) {
+          return XEUtils.formatTime("DATETIMESTR", curDate);
+        }
+        return XEUtils.formatTime("MOUTHTIME", curDate);
+      }
+    },
+    imgs2imgArr(imgs) {
+      if (!imgs)
+        return [];
+      return imgs.replace(/(,)(data|http)/g, (match, p1, p2) => {
+        return `|${p2}`;
+      }).split("|");
+    },
+    filterOption(input, option) {
+      try {
+        let text = option.componentOptions.children[0].text;
+        let lowText = text.toLowerCase();
+        let lowInput = input.toLowerCase();
+        let flag = false;
+        var reg = /^[a-zA-Z]+$/;
+        if (typeof text === "string" && reg.test(input) && ""._toPinYin) {
+          flag = lowText._toPinYin().indexOf(lowInput) >= 0;
+        }
+        return flag || lowText.indexOf(lowInput) >= 0;
+      } catch (error) {
+        return false;
+      }
+    },
+    stringToValue(item, k = "value") {
+      if (XEUtils.isString(item)) {
+        if (item && item.startsWith("###{")) {
+          let temp = JSON.parse(item.replace("###", ""));
+          item = temp[k];
+        }
+      }
+      return item;
+    },
+    notEmpty(text) {
+      return XEUtils.isBoolean(text) || String(text) === "0" || !!text;
+    },
+    handleSysParams(str, obj = {}, noval = "") {
+      let p = {
+        ...obj
+      };
+      const getValList = (plsList = [], obj = {}) => {
+        var l = [];
+        plsList.forEach((v) => {
+          let c = v;
+          if (v.includes(".")) {
+            try {
+              eval(`c = o.${v}`);
+            } catch (error) {
+              c = "";
+            }
+          }
+          if (XEUtils.notEmpty(c)) {
+            l.push(c);
+          }
+        });
+        return l;
+      };
+      const getVal = (t, r, k) => {
+        return t.replace(r, function() {
+          var pKey = arguments[1];
+          var pls = pKey.split("!");
+          var l2 = getValList(pls, p);
+          var f = l2.find((v2) => XEUtils.notEmpty(v2));
+          var res = f;
+          res = XEUtils.notEmpty(res) ? res : noval;
+          return res;
+        });
+      };
+      if (typeof str === "string") {
+        if (str.includes("form")) {
+          str = getVal(str, /\${(.*?)\}/g);
+        }
+        if (str.includes("sys")) {
+          str = getVal(str, /\${(.*?)\}/g);
+        }
+        if (str.includes("db")) {
+          str = getVal(str, /\${(.*?)\}/g);
+        }
+        if (str.includes("table")) {
+          str = getVal(str, /\${(.*?)\}/g);
+        }
+        if (str.includes("result")) {
+          str = getVal(str, /\${(.*?)\}/g);
+        }
+      }
+      return str;
+    },
+    isPlainObject(obj2) {
+      return _toString.call(obj2) === "[object Object]";
+    }
+  });
+  return () => {
+  };
+})();
+
+export { expandXEUtils };