cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/packages/form-table/src/hooks/useSearch.js

@@ -0,0 +1,1153 @@
+import vexutils from '../../../../src/utils/vexutils';
+import { ref, computed, onMounted, nextTick, h } from 'vue';
+import { useItemDefault } from '../../../../packages/form-table/src/hooks/useItemDefault';
+
+const SELECT_LIST = ["SEARCH_MORE", "SEARCH", "SEARCH_CASCADE", "LEVEL_SEARCH_CASCADE"];
+function useSearch({
+  loadDataPrimary_key,
+  optionsRequestSource,
+  axios,
+  $qs,
+  dropdownHide,
+  curAddBtnItem,
+  message,
+  Choose_to_complete,
+  noAllow_check_mid_level,
+  selsectVisible,
+  baseForm,
+  refs,
+  $t,
+  $_handleTracherLog,
+  open,
+  wrapperRef,
+  props,
+  emit
+}) {
+  const {
+    formTable,
+    hasErr,
+    handleGetJsonStr,
+    handleSetFieldsValue,
+    handleGetUniqueKey,
+    handleSysParams,
+    defaultInit,
+    handleTableBlur,
+    handleFormParams,
+    radioColor,
+    handleGetAgeUnit,
+    handleAgeToBirthDay,
+    changeAgeSelect,
+    handlerSetIdCarInfoValidate,
+    getInputCheck,
+    getCustomRegular,
+    checkDigital,
+    checkAgeJson,
+    checkAge,
+    checkMultipleChoice,
+    checkLength,
+    checkinputBlank,
+    handlerGetDateType,
+    checkSearchCascade,
+    checkMultipleTree,
+    handleDateClearBtn,
+    handleStartDateEndDate,
+    showTimePanel,
+    momentLib,
+    judgeTimeBoundary,
+    setTimeValue,
+    judgeTimeRange,
+    isSameDate,
+    setDefaultCurrent,
+    handleDefaultRimeRange,
+    judgeMinMaxDateIsSameDate,
+    handleDefaultTimeRange,
+    changeTimeDate,
+    setTimeRangeArr
+  } = useItemDefault({ message, props, emit });
+  const fetching = ref(false);
+  const timeout = ref(null);
+  const curOptions = ref([]);
+  const selectedOptions = ref([]);
+  const levelNum = ref(1);
+  const cascaderInitLabel = ref(true);
+  const defList = ref([]);
+  const panelOpen = ref(false);
+  const hideHotSearch = ref(false);
+  const searchAddObj = ref({});
+  const searchPageConfig = ref({
+    keyword: void 0,
+    isFetching: false,
+    isRequest: false,
+    hasNextPage: false,
+    page: 1,
+    total: 1
+  });
+  const optionsMaxWidth = ref("100%");
+  const cacheReqOptionsParams = ref("");
+  const hotSearchConfig = ref({
+    hotList: [],
+    latestList: [],
+    isRequest: false,
+    isclose: true
+  });
+  const searchShowHotList = ref(false);
+  const curMultipleSelected = ref([]);
+  const showHotSearchConfig = computed(() => {
+    const { hotList = [], latestList = [] } = (hotSearchConfig == null ? void 0 : hotSearchConfig.value) || {};
+    let f = hotList.length || latestList.length;
+    return f && !searchPageConfig.value.keyword;
+  });
+  const showSearchEmpty = computed(() => {
+    if (props.item.free_entry != "1")
+      return false;
+    const len = curOptions.value.length;
+    const i = curOptions.value.slice(0, 2).findIndex((ele) => ele.is_free_entry_input__add);
+    return i < 0 ? false : len < i + 2;
+  });
+  const selectIsOpen = computed(() => {
+    const { html_type, show_type } = props.item;
+    if (["SEARCH_MORE", "SEARCH"].includes(html_type)) {
+      return !["pop", "dialog"].includes(show_type);
+    }
+    return true;
+  });
+  const isnoPages = computed(() => {
+    return searchPageConfig.value.page <= 1 && !searchPageConfig.value.hasNextPage;
+  });
+  function init() {
+    const {
+      validate = {},
+      html_type = void 0,
+      name,
+      default_val,
+      show_type = void 0,
+      guage_num = void 0
+    } = props.item;
+    let targetStr = props.defaultValue[name] || default_val;
+    targetStr = handleSysParams(targetStr);
+    if (html_type == "SEARCH") {
+      if (targetStr) {
+        nextTick(() => {
+          handleRequestedOptions(props.item, targetStr, true);
+        });
+      }
+    } else if (html_type == "SEARCH_MORE") {
+      hanldeInitSearchMoreVal(props.item);
+    }
+    cacheReqOptionsParams.value = "";
+  }
+  async function hanldeInitSearchMoreVal(i, v) {
+    var _a;
+    try {
+      const item = i;
+      let n;
+      if (v) {
+        n = v;
+      } else {
+        n = props.defaultValue[item.name] || item.default_val;
+      }
+      if (n) {
+        if (typeof n === "string") {
+          n = handleSysParams(n);
+        }
+        n = handleGetJsonStr(n) || {};
+        let NOWORDBOOK = item.wordbook.type != "WORDBOOK";
+        if (n && n.objs && n.objs.length) {
+          let curUniqueLabel;
+          if (NOWORDBOOK) {
+            curUniqueLabel = await handleRequestedUniqueKey(item.wordbook.id);
+          }
+          curUniqueLabel = curUniqueLabel || void 0;
+          let defList2 = [];
+          const defOptions = [];
+          let l = [], objs = [];
+          let objStr = typeof n.objStr === "string" ? [...new Set(n.objStr.split(","))].join(",") : n.objStr;
+          n.objs.forEach((f) => {
+            let v2 = typeof f === "object" ? JSON.parse(JSON.stringify(f)) : f;
+            v2.myUniqueKey = v2[curUniqueLabel] || "";
+            v2.myUniqueLabel = curUniqueLabel || "";
+            defList2.push({
+              key: `${v2[item.wordbook.value_key]}-${v2[curUniqueLabel] || ""}`,
+              label: hanlderGetSearchLabel(item, v2)
+            });
+            let k = `${v2[item.wordbook.value_key]}-${v2["myUniqueKey"]}`;
+            if (!l.includes(k)) {
+              defOptions.push({
+                ...v2
+              });
+              l.push(k);
+              objs.push({
+                ...f
+              });
+            }
+          });
+          if (l.length !== (((_a = n == null ? void 0 : n.objs) == null ? void 0 : _a.length) || void 0)) {
+            props.formType[item.val_key].filtration_val = JSON.stringify({
+              objStr,
+              objs
+            });
+          }
+          item.defOptions = defOptions;
+          if (defOptions && defOptions.length) {
+            curOptions.value = [...defOptions];
+            selectedOptions.value = [...defOptions || []];
+          }
+          defList2 = vexutils.uniqArrObj(defList2, "key");
+          props.row[item.val_key] = defList2;
+          Reflect.set(props.item, "useFormValue", defList2);
+          emit("valueOnChange", [...defOptions], props.item, props.row);
+        } else {
+          props.defaultValue[item.name] = [];
+        }
+      } else {
+        props.defaultValue[item.name] = [];
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  }
+  function getSearchDefParams(keyword, itemData = {}, other = {}) {
+    const { wordbook, html_type, autograph } = itemData;
+    const isCascade = html_type.includes("SEARCH_CASCADE");
+    const fieldKeys = wordbook.fieldKeys || wordbook.search_key;
+    let conObj = wordbook.conObj;
+    const extraParams = {
+      primaryKey: wordbook.primary_key,
+      levelKey: wordbook.level_key
+    };
+    const pageSizeConfig = {
+      pageSize: isCascade ? 1e4 : 20
+    };
+    const params = {
+      wordbookId: wordbook.id,
+      autograph,
+      wordbookType: wordbook.type || "WORDBOOK",
+      preConObj: wordbook.preConObj ? JSON.stringify(wordbook.preConObj) : void 0,
+      conObj: conObj ? JSON.stringify(conObj) : void 0,
+      preSqlExpression: wordbook.preSqlExpression || void 0,
+      sqlExpression: wordbook.sqlExpression || void 0,
+      fieldKeys: fieldKeys ? JSON.stringify(fieldKeys) : void 0,
+      keyword: keyword || "",
+      page: 1,
+      ...isCascade ? extraParams : {},
+      ...isCascade ? pageSizeConfig : {}
+    };
+    if (other.page) {
+      params.page = other.page;
+      searchPageConfig.value.isFetching = true;
+    }
+    return params;
+  }
+  function getCascadeParams(params, itemData, otherConfig, defFalg) {
+    const { wordbook, html_type } = itemData;
+    if (html_type.includes("LEVEL_SEARCH_CASCADE")) {
+      let pageObj = void 0;
+      if (Object.keys(otherConfig || {}).length > 0) {
+        let { levelNum: levelNum2 = 1, pageSetting } = otherConfig || {};
+        levelNum2.value = levelNum2;
+        loadDataPrimary_key.value = otherConfig.loadDataPrimary_key;
+        pageObj = pageSetting;
+      }
+      const { levelSetting = [] } = wordbook;
+      let curLevel = levelSetting[levelNum.value - 1];
+      if ((defFalg || !loadDataPrimary_key.value) && wordbook.conObjFirstLevel) {
+        params.conObj = wordbook.conObjFirstLevel ? JSON.stringify(wordbook.conObjFirstLevel) : void 0;
+        params.sqlExperssions = wordbook.sqlExpressionFirstLevel || void 0;
+      } else {
+        let conObjList = [];
+        if (loadDataPrimary_key.value) {
+          conObjList.push({
+            field_key: wordbook.level_key,
+            con: "EQ",
+            value: loadDataPrimary_key.value
+          });
+        }
+        if (curLevel && html_type === "LEVEL_SEARCH_CASCADE2") {
+          conObjList.push({
+            field_key: wordbook.grade_key,
+            con: "EQ",
+            value: curLevel.level
+          });
+        }
+        if (pageObj) {
+          Object.assign(params, pageObj);
+        }
+        params.conObj = JSON.stringify(conObjList);
+        params.sqlExperssions = "";
+      }
+    }
+    return params;
+  }
+  function handleRowUnique(rows, itemData, uniqueConfig = {}) {
+    const { myUniqueKey, reqUniqueKey } = uniqueConfig;
+    const { wordbook } = itemData;
+    return rows.reduce((acc, cur) => {
+      cur.setting = wordbook.setting;
+      cur.showLabel = "";
+      cur.myUniqueKey = cur[myUniqueKey] || "";
+      cur.myUniqueLabel = reqUniqueKey || "";
+      if (wordbook.render_key && wordbook.render_key.length > 0) {
+        wordbook.render_key.forEach((ren) => {
+          cur.showLabel += `\u224C${formatField(cur[ren])}`;
+        });
+        cur.showLabel = cur.showLabel.slice(1);
+      } else {
+        cur.showLabel = cur[wordbook.value_key];
+      }
+      if (typeof cur === "object") {
+        Object.keys(cur || {}).forEach((t) => cur[t] = formatFieldValue(cur[t]));
+      }
+      return acc.some((v) => {
+        return `${v[wordbook.value_key]}-${v[myUniqueKey]}` == `${cur[wordbook.value_key]}-${cur[myUniqueKey]}`;
+      }) ? acc : [...acc, cur];
+    }, []);
+  }
+  function handleGetSearchDefVal(defFalg, rowData, itemData, uniqueConfig = {}) {
+    const { is_plugin_set, keyword } = uniqueConfig;
+    const { wordbook, html_type, val_key, default_val, name } = itemData;
+    let defVal = props.defaultValue[name] || handleSysParams(default_val || "");
+    if (is_plugin_set) {
+      defVal = keyword;
+    }
+    if (defFalg && rowData.length) {
+      let defItem = rowData[0];
+      let itemKkey = `${defItem[wordbook.value_key]}>>>${defItem["myUniqueKey"]}`;
+      if (html_type == "SEARCH") {
+        const f = rowData.find((r) => r[wordbook.value_key] == defVal);
+        if (f) {
+          defItem = f;
+          itemKkey = `${f[wordbook.value_key]}>>>${f["myUniqueKey"]}`;
+          handleSearchSelect(itemKkey, itemData, "", {
+            eventType: defFalg ? "init" : "trigger"
+          });
+        }
+        if (defVal != defItem[wordbook.value_key]) {
+          if (f) {
+            itemKkey = `${f[wordbook.value_key]}>>>${f["myUniqueKey"]}`;
+          } else {
+            itemKkey = defVal;
+          }
+        }
+        if (itemKkey) {
+          handleSetFieldsValue({ [itemData.val_key]: itemKkey });
+        } else {
+          Reflect.set(itemData, "useFormValue", void 0);
+        }
+      } else if (html_type == "SEARCH_MORE") {
+        itemKkey.replace(">>>", "-");
+        handleSetFieldsValue({
+          [itemData.val_key]: [
+            {
+              key: itemKkey,
+              label: defItem["showLabel"] || defItem[wordbook.value_key]
+            }
+          ]
+        }, itemData);
+        multipleSelect({
+          key: itemKkey,
+          label: defItem["showLabel"] || defItem[wordbook.value_key]
+        }, itemData);
+      }
+    } else if (defFalg) {
+      if (html_type == "SEARCH") {
+        handleSetFieldsValue({
+          [itemData.val_key]: void 0
+        }, itemData);
+      }
+    }
+  }
+  async function handleRequestedOptions(itemData = {}, keyword = void 0, defFalg = false, otherConfig = {}) {
+    const closeLoading = () => {
+      fetching.value = false;
+      searchPageConfig.value.isFetching = false;
+    };
+    try {
+      const { wordbook = {}, val_key, html_type, free_entry, show_type } = itemData;
+      let { queryParamsType, queryParams = [] } = wordbook;
+      if (Object.keys(wordbook || {}).length === 0) {
+        return;
+      }
+      if (keyword && typeof keyword === "string")
+        keyword = keyword.replace(/^\s+|\s+$/, "");
+      const isCascade = html_type.includes("SEARCH_CASCADE");
+      const NOWORDBOOK = wordbook.type != "WORDBOOK";
+      const ISDICTIONARY = wordbook.type === "DICTIONARY";
+      let params = getSearchDefParams(keyword, itemData, otherConfig);
+      let formData = getFormValue();
+      let queryArr = ["SEARCH", "SEARCH_MORE", "SEARCH_CASCADE", "LEVEL_SEARCH_CASCADE", "LEVEL_SEARCH_CASCADE2"];
+      if (queryArr.includes(html_type) && queryParamsType == 1) {
+        let tempFormData = handleQueryParams(formData, queryParams);
+        Object.assign(params, tempFormData);
+      } else {
+        Object.assign(params, formData);
+      }
+      const arr = ["SEARCH", "SEARCH_MORE"];
+      if (arr.includes(html_type) && ISDICTIONARY) {
+        Object.assign(params, {
+          dictType: JSON.stringify(wordbook.dictType)
+        });
+      }
+      cacheReqOptionsParams.value = JSON.stringify(params);
+      let reqUniqueKey;
+      let myUniqueKey = "theUniqueKey";
+      if (NOWORDBOOK) {
+        reqUniqueKey = await handleRequestedUniqueKey(wordbook.id);
+        myUniqueKey = reqUniqueKey || void 0;
+      }
+      if (html_type == "SEARCH_MORE" && myUniqueKey == "theUniqueKey") {
+        myUniqueKey = void 0;
+      }
+      props.formType[val_key].wordbook && (props.formType[val_key].wordbook.myUniqueLabel = myUniqueKey);
+      fetching.value = true;
+      if (!html_type.includes("SEARCH_CASCADE")) {
+        cancelOptionsRequest && cancelOptionsRequest();
+      }
+      optionsRequestSource.value = axios.CancelToken.source();
+      if (keyword && !defFalg) {
+        let key = typeof keyword === "string" ? keyword.trim() : keyword;
+        key && handleSearchTracher(itemData, {
+          keyword: key
+        });
+      }
+      Object.assign(params, {
+        asyncCount: 1
+      });
+      return axios.post(`/tableReader/getWordbookData`, $qs.stringify(params), {
+        cancelToken: optionsRequestSource.value.token
+      }).then(({ data }) => {
+        if (otherConfig.page) {
+          handleSearchScrollTop(itemData);
+        }
+        optionsRequestSource.value = null;
+        fetching.value = false;
+        if (data.result === "SUCCESS") {
+          searchAddObj.value[`${itemData.val_key}_${itemData.name}`] = true;
+          let { rows, fieldList, page, total, hasNextPage } = data.map;
+          itemData._hasNextPage = hasNextPage;
+          searchPageConfig.value = Object.assign(searchPageConfig.value, {
+            page,
+            hasNextPage,
+            isRequest: true,
+            keyword
+          });
+          let rowData = [];
+          if (isCascade) {
+            wordbook.myUniqueLabel = myUniqueKey;
+            wordbook.myUniqueKey = myUniqueKey;
+            wordbook.isLoadData = html_type == "LEVEL_SEARCH_CASCADE";
+            if (wordbook.isLoadData) {
+              levelNum.value = defFalg ? 1 : levelNum.value;
+            }
+            rows = hanldeRemoveDuplicates(rows, {
+              key: wordbook.value_key
+            });
+            handleFormCascade(rows, wordbook);
+            rowData = rows;
+          } else {
+            rowData = handleRowUnique(rows, itemData, {
+              myUniqueKey,
+              reqUniqueKey
+            });
+            if (html_type == "SEARCH" && show_type == "tree") {
+              Object.assign(wordbook, {
+                myUniqueLabel: myUniqueKey,
+                myUniqueKey
+              });
+              return rowData;
+            }
+            if (rowData.length > 0 && wordbook.render_key && wordbook.render_key.length > 1) {
+              rowData.unshift(Object.assign({}, {
+                showLabel: getTitleHeader(fieldList, wordbook.render_key),
+                myUniqueKey: Math.random()
+              }));
+            }
+          }
+          const searchList = ["SEARCH", "SEARCH_CASCADE", "SEARCH_MORE", "LEVEL_SEARCH_CASCADE"];
+          if (searchList.includes(html_type)) {
+            if (html_type != "LEVEL_SEARCH_CASCADE") {
+              curOptions.value = rowData;
+            } else {
+              (defFalg || !loadDataPrimary_key.value) && (curOptions.value = rowData);
+            }
+          }
+          handleGetSearchDefVal(defFalg, rowData, itemData, {
+            myUniqueKey,
+            reqUniqueKey,
+            keyword,
+            ...otherConfig
+          });
+          return rowData;
+        }
+        return [];
+      }).catch((err) => {
+        console.log(err);
+      }).finally(() => {
+        closeLoading();
+      });
+    } catch (error) {
+      closeLoading();
+      console.log(error);
+    }
+  }
+  function handleFreeEntry(option = {}) {
+    const { rowData, keyword, wordbook, fieldList, myUniqueKey } = option;
+    if (!keyword)
+      return;
+    const curKey = +new Date();
+    const data = {
+      [myUniqueKey]: curKey,
+      myUniqueKey: curKey,
+      myUniqueLabel: myUniqueKey,
+      [wordbook.value_key]: keyword,
+      is_free_entry_input__add: true
+    };
+    const hasRenderKey = wordbook.render_key && wordbook.render_key.length > 1;
+    if (rowData.length === 0) {
+      curOptions.value = [];
+      if (hasRenderKey) {
+        rowData.unshift({
+          showLabel: getTitleHeader(fieldList, wordbook.render_key),
+          myUniqueKey: Math.random()
+        });
+      }
+    }
+    hasRenderKey ? rowData.splice(1, 0, data) : rowData.unshift(data);
+    curOptions.value = rowData;
+  }
+  function formatField(value) {
+    let res = value;
+    try {
+      if (res && typeof res == "string" && res.startsWith("###")) {
+        res = res.slice(3);
+        res = JSON.parse(res);
+        res = res.change_text;
+      }
+      return res || "";
+    } catch (error) {
+      return "";
+    }
+  }
+  function formatFieldValue(value) {
+    try {
+      if (value && typeof value == "string" && value.startsWith("###")) {
+        value = value.slice(3);
+        value = JSON.parse(value);
+        value = value.value;
+      }
+      return value || "";
+    } catch (error) {
+      console.log(error);
+      return "";
+    }
+  }
+  function getTitleHeader(fieldList, renderKey) {
+    let titleHeader = "";
+    let renderKeyArr = [];
+    if (Array.isArray(renderKey)) {
+      renderKeyArr = [...renderKey];
+    } else {
+      renderKeyArr = [renderKey];
+    }
+    renderKeyArr.forEach((render) => {
+      for (let i = 0; i < fieldList.length; i++) {
+        if (render === fieldList[i].columnName) {
+          titleHeader += `\u224C${fieldList[i].title}`;
+          break;
+        }
+      }
+    });
+    titleHeader = titleHeader.slice(1);
+    return titleHeader;
+  }
+  function handleRequestedUniqueKey(id) {
+    const starTiem = +new Date();
+    const getUniqueKey = (resolve, reject) => {
+      setTimeout(() => {
+        const res = handleGetUniqueKey(id);
+        if (res && res.status) {
+          resolve(res.value);
+        } else {
+          let curTime = +new Date();
+          if (curTime - starTiem > 5e3) {
+            reject("\u83B7\u53D6UniqueKe \u5F02\u5E38!!");
+            return;
+          }
+          getUniqueKey(resolve, reject);
+        }
+      }, 16);
+    };
+    return new Promise((resolve, reject) => {
+      getUniqueKey(resolve, reject);
+    });
+  }
+  function dealDictionatySearch(val) {
+    curOptions.value = curOptions.value.filter((i) => {
+      return i.showLabel.includes(val);
+    });
+  }
+  function handleMultipleSearch(val, itemData) {
+    clearTimeout(timeout.value);
+    const { wordbook = {}, html_type } = itemData;
+    const ISDICTIONARY = wordbook.type === "DICTIONARY";
+    const arr = ["SEARCH", "SEARCH_MORE"];
+    if (arr.includes(html_type) && ISDICTIONARY && val) {
+      dealDictionatySearch(val);
+      return;
+    }
+    searchPageConfig.value.keyword = val || void 0;
+    if (dropdownHide.value && !val) {
+      return;
+    }
+    timeout.value = setTimeout(() => {
+      handleRequestedOptions(itemData, val);
+    }, 200);
+  }
+  function multipleSelect(e, item) {
+    const valKey = item.wordbook.value_key;
+    const selectList = selectedOptions.value || [];
+    const isSelect = selectList.some((v) => `${v[valKey]}-${v["myUniqueKey"]}` == e.key);
+    let selectItem = {};
+    if (!isSelect) {
+      const fdItem = curOptions.value.find((v) => `${v[valKey]}-${v["myUniqueKey"]}` == e.key);
+      selectList.push({
+        ...fdItem
+      });
+      selectItem = fdItem;
+    }
+    selectedOptions.value = [...selectList];
+    emit("valueOnChange", [...selectList], item, props.row);
+    hanlderSendSelectLog(item, selectItem);
+    handleTableBlur();
+  }
+  function multipleDeselect(e, item) {
+    const valKey = item.wordbook.value_key;
+    const selectList = selectedOptions.value || [];
+    const fnIndex = selectList.findIndex((v) => `${v[valKey]}-${v["myUniqueKey"]}` == e.key);
+    if (fnIndex != -1) {
+      selectList.splice(fnIndex, 1);
+    }
+    selectedOptions.value = [...selectList];
+    emit("valueOnChange", [...selectList], item, props.row);
+  }
+  function handlerAddOptions(data, item) {
+    curAddBtnItem.value = item;
+    emit("handlerAddOptions", { data });
+  }
+  function searchMoreOnChange(value, item) {
+    props.formType[item.val_key].isOnchange = "00";
+    if (!value || value.length === 0) {
+      emit("valueOnChange", [], item, props.row);
+    }
+  }
+  function handleFormCascade(list = [], v = {}, level = 1) {
+    list.forEach((item) => {
+      item.myLabel = hanldeGetCascadelabel(v.render_key, item) || item[v["value_key"]];
+      item.myUniqueKey = item[v.myUniqueKey];
+      item.myUniqueLabel = v.myUniqueKey;
+      if (v.isLoadData) {
+        item.isLeaf = v.level_num ? levelNum.value >= v.level_num : false;
+      } else {
+        if (level >= v.level_num) {
+          delete item.children;
+        }
+        if (item.children && item.children.length) {
+          handleFormCascade(item.children, v, level + 1);
+        }
+      }
+    });
+  }
+  function hanldeGetCascadelabel(v = [], k = {}) {
+    if (Array.isArray(v) && v.length) {
+      const l = [];
+      v.forEach((i) => {
+        let res = formatField(k[i]);
+        l.push(res);
+      });
+      if (l.length == 0) {
+        return "";
+      }
+      return l.join("_");
+    }
+    return "";
+  }
+  function handleCascaderChange(option, item) {
+    Choose_to_complete.value = false;
+    cascaderInitLabel.value = false;
+    let [value, selectedOptions2] = option;
+    selectedOptions2 = selectedOptions2 || [];
+    let isAllowClear = value.length === 0 && selectedOptions2.length === 0;
+    if (item.allow_check_mid_level && item.is_allow_check_mid == 1 && !isAllowClear) {
+      if (item.allow_check_mid_level > ((value == null ? void 0 : value.length) || 0)) {
+        noAllow_check_mid_level.value = true;
+        return;
+      }
+    }
+    noAllow_check_mid_level.value = false;
+    item.selectValue = value;
+    item.selectedOptions = null;
+    item.selectedOptions = selectedOptions2;
+    selectedOptions2.value = [...selectedOptions2];
+    emit("valueOnChange", [...selectedOptions2], item, props.row);
+    props.formType[item.val_key].isOnchange = "00";
+    if (value.length == 0 && selectedOptions2.length == 0) {
+      props.defaultValue[item.name] = "";
+      props.formType[item.val_key].default_val = "";
+      hideHotSearch.value = true;
+    }
+    Choose_to_complete.value = true;
+  }
+  function handleCascaderFilter(inputValue, path) {
+    return path.some((option) => option.myLabel.toLowerCase().indexOf(inputValue.toLowerCase()) > -1);
+  }
+  async function handleCascadeLoadData(selectedOptions2) {
+    levelNum.value = selectedOptions2.length + 1;
+    const targetOption = selectedOptions2[selectedOptions2.length - 1];
+    loadDataPrimary_key.value = targetOption[props.item.wordbook.primary_key];
+    targetOption.loading = true;
+    try {
+      const res = await handleRequestedOptions(props.item, "", false);
+      targetOption.loading = false;
+      targetOption.children = res && res.length ? [...res] : void 0;
+      curOptions.value = [...curOptions.value];
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  function handlerDropdownVisibleChange(e, data) {
+    if (e) {
+      handleCalculateOptionsMaxWidth();
+    }
+    let isRequest = true;
+    if (optionsMaxWidth.value === "100%") {
+      handleCalculateOptionsMaxWidth();
+    }
+    dropdownHide.value = !e;
+    if (Object.keys(data || {}).length > 0) {
+      const searchList2 = ["SEARCH_CASCADE", "LEVEL_SEARCH_CASCADE"];
+      if (searchList2.includes(data.html_type)) {
+        isRequest = !(curOptions.value && curOptions.value.length);
+      }
+      if (e && ["SEARCH_MORE", "SEARCH"].includes(data.html_type)) {
+        handlerSearchOnFocus(data);
+      }
+      if (e && isRequest) {
+        handleRequestedOptions(data);
+      }
+      if (!e && noAllow_check_mid_level.value && searchList2.includes(data.html_type)) {
+        setTimeout(() => {
+          Reflect.set(data, "useFormValue", null);
+        }, 16);
+      }
+    }
+    if (!e) {
+      handleCascaderTracher();
+      setTimeout(() => {
+        searchPageConfig.value.keyword = void 0;
+      }, 300);
+    }
+  }
+  function hanlderGetSearchLabel(config, v) {
+    const { wordbook } = config;
+    let showLabel = "";
+    if (!v.is_free_entry_input__add && wordbook.show_key && wordbook.show_key.length) {
+      wordbook.show_key.forEach((s) => {
+        showLabel += ` ${formatField(v[s])}`;
+      });
+      return showLabel;
+    }
+    return v[wordbook.value_key];
+  }
+  function hanlderSendSelectLog(item = {}, value) {
+    const show_key = (item.wordbook && item.wordbook.show_key || [])[0];
+    const label = show_key ? value[show_key] : "";
+    label && handleSearchTracher(item, {
+      select: label
+    });
+  }
+  function handleSearchSelect(e, option, type, eventConfig) {
+    var _a;
+    (option == null ? void 0 : option.bindEventSetting) || [];
+    "init" === (eventConfig == null ? void 0 : eventConfig.eventType);
+    getFormValue();
+    const searchOption = curOptions.value;
+    let selectItem = searchOption.find((ele) => `${ele[option.wordbook.value_key]}>>>${ele["myUniqueKey"]}` === e);
+    const is_free = (selectItem == null ? void 0 : selectItem.is_free_entry_input__add) || false;
+    if (is_free) {
+      selectItem = {};
+    }
+    const setting = ((_a = option == null ? void 0 : option.wordbook) == null ? void 0 : _a.setting) || {};
+    if (Object.keys(selectItem || {}).length > 0 && type === "select") {
+      hanlderSendSelectLog(option, selectItem);
+    }
+    if (selectItem && setting) {
+      Object.keys(selectItem).forEach((s) => {
+        if (selectItem[s] && typeof selectItem[s] == "string" && selectItem[s].startsWith("###")) {
+          selectItem[s] = selectItem[s].slice(3);
+          selectItem[s] = JSON.parse(selectItem[s]);
+          selectItem[s] = selectItem[s].value;
+        }
+      });
+    }
+  }
+  function handleSearchChangePage(type = "next") {
+    let cType = type || "next";
+    let { page, keyword = void 0 } = searchPageConfig.value;
+    page = cType === "next" ? page + 1 : page - 1;
+    handleRequestedOptions(props.item, keyword, false, { page });
+  }
+  function handleCalculateOptionsMaxWidth() {
+    var _a;
+    if (!SELECT_LIST.includes(((_a = props.item) == null ? void 0 : _a.html_type) || void 0)) {
+      return;
+    }
+    nextTick(() => {
+      var _a2;
+      const offsetWidth = (_a2 = wrapperRef.value) == null ? void 0 : _a2.offsetWidth;
+      let res = offsetWidth, maxwith;
+      try {
+        let item = wrapperRef.value.querySelector(".ant-select");
+        if (!item)
+          return;
+        const itemRect = item.getBoundingClientRect();
+        let baseDom = formTable.$el;
+        const baseRect = baseDom.getBoundingClientRect();
+        maxwith = baseRect.right - itemRect.left;
+        if (typeof offsetWidth === "number" && isFinite(maxwith)) {
+          if (maxwith > offsetWidth) {
+            res = maxwith;
+          } else {
+            res = offsetWidth;
+          }
+        }
+      } catch (error) {
+        res = offsetWidth;
+      }
+      res = parseInt(res + "", 10);
+      optionsMaxWidth.value = `${res}px`;
+    });
+  }
+  function handlerSearchOnFocus(item) {
+    if (selectIsOpen.value)
+      return;
+    let { queryParamsType, queryParams = [] } = item.wordbook || {};
+    nextTick(() => {
+      selsectVisible.value = true;
+      let formData = props.row;
+      let params = formData;
+      if (queryParamsType == 1) {
+        params = handleQueryParams(formData, queryParams);
+      }
+      emit("opentableSelect", true, props.item, params);
+    });
+  }
+  function handleQueryParams(formData, queryParams) {
+    let tempFormData = {};
+    if (queryParams.length) {
+      queryParams.forEach((v) => {
+        if (v in formData) {
+          tempFormData[v] = formData[v];
+        }
+      });
+    }
+    return tempFormData;
+  }
+  function confirmSelect({ value, selectRow = [], myUniqueKey }) {
+    if (props.item.html_type === "SEARCH_MORE") {
+      let selecteds = baseForm.value.getFieldValue(props.item.val_key) || [];
+      props.formType[props.item.val_key].isOnchange = "00";
+      let mergeValList = [...value, ...selecteds];
+      let mergeSelectList = [...selectRow, ...curMultipleSelected.value];
+      let valueList = hanldeRemoveDuplicates(mergeValList, {
+        key: "key"
+      });
+      let list = hanldeRemoveDuplicates(mergeSelectList, {
+        key: myUniqueKey
+      });
+      let copy = JSON.parse(JSON.stringify(list));
+      curOptions.value = [...copy];
+      Reflect.set(props.item, "useFormValue", valueList);
+      curMultipleSelected.value = [...copy];
+      emit("valueOnChange", [...copy], props.item, props.row);
+    } else {
+      curOptions.value = [...selectRow];
+      Reflect.set(props.item, "useFormValue", value);
+      handleSearchSelect(value, props.item);
+    }
+  }
+  function hanldeRemoveDuplicates(list = [], config = {}) {
+    if (!Array.isArray(list))
+      return [];
+    const { key } = config;
+    let obj = {};
+    if (!key)
+      return list;
+    let resList = list.reduce((cur, next) => {
+      obj[next[key]] ? "" : obj[next[key]] = cur.push(next);
+      return cur;
+    }, []);
+    return [...resList];
+  }
+  function getFormValue() {
+    var _a;
+    let tempRow = JSON.parse(JSON.stringify(props.row));
+    tempRow = (_a = props.handleFormTableValue) == null ? void 0 : _a.call(props, tempRow, tempRow == null ? void 0 : tempRow._rowIndex_, true);
+    for (let key in tempRow) {
+      if (key.startsWith("_") && key.endsWith("_")) {
+        delete tempRow[key];
+      }
+    }
+    return tempRow;
+  }
+  function cancelOptionsRequest() {
+    if (optionsRequestSource.value && typeof optionsRequestSource.value.cancel === "function") {
+      optionsRequestSource.value.cancel("\u8BF7\u6C42\u5DF2\u53D6\u6D88\uFF01");
+      optionsRequestSource.value = null;
+    }
+  }
+  function getHotSearchConfig() {
+    if (!SELECT_LIST.includes(props.item.html_type) || props.item.is_recommend != "1")
+      return;
+    axios.get("form/commonLatestAndHot", {
+      params: {
+        formId: props.params_formId,
+        valKey: props.item.val_key,
+        htmlType: props.item.html_type
+      }
+    }).then(({ data }) => {
+      var _a, _b;
+      if (data.result == "SUCCESS") {
+        hotSearchConfig.value.isRequest = true;
+        let hotList = (((_a = data == null ? void 0 : data.map) == null ? void 0 : _a.hotList) || []).filter(Boolean);
+        let latestList = (((_b = data == null ? void 0 : data.map) == null ? void 0 : _b.latestList) || []).filter(Boolean);
+        hotSearchConfig.value = Object.assign(hotSearchConfig.value, {
+          hotList,
+          latestList
+        });
+      }
+    }).catch((err) => {
+      console.log(err, "getHotSearchConfig");
+    });
+  }
+  function handleSelectHotKeyword(key) {
+    var _a, _b, _c;
+    const input = (_a = wrapperRef.value) == null ? void 0 : _a.querySelector(".ant-select-search__field");
+    if (input) {
+      input.value = key;
+      var event = new InputEvent("input");
+      input.dispatchEvent(event);
+    } else {
+      open.value = false;
+      if (SELECT_LIST.includes(props.item.html_type)) {
+        if (!key.keyword)
+          return;
+        handleSearchTracher(props.item, { select: key.value, keyword: key.keyword });
+        let input2 = (_b = wrapperRef.value) == null ? void 0 : _b.querySelector(".ant-cascader-input");
+        let cascader = (_c = wrapperRef.value) == null ? void 0 : _c.querySelector(".ant-cascader-picker");
+        cascader && cascader.blur();
+        if (input2) {
+          input2.blur();
+        }
+      }
+    }
+  }
+  function hanldeClearLately() {
+    axios.post("form/deleteLatestAndHot", $qs.stringify({
+      formId: props.params_formId,
+      valKey: props.item.val_key,
+      htmlType: props.item.html_type
+    })).then(({ data }) => {
+      if (data.result == "SUCCESS") ; else {
+        message.warning(data.resultMsg || $t("1.7.1.10"));
+      }
+    });
+  }
+  function closeHotSearch() {
+    hideHotSearch.value = false;
+    searchShowHotList.value = false;
+  }
+  function handleSearchTracher(item, obj = { keyword: "", select: "" }) {
+    if (!SELECT_LIST.includes((item == null ? void 0 : item.html_type) || void 0))
+      return;
+    const { keyword = "", select = "" } = obj || {};
+    try {
+      let key = item.html_type === "SEARCH_MORE" ? "\u8868\u5355\u641C\u7D22\u591A\u9009\u6846" : item.html_type === "SEARCH" ? "\u8868\u5355\u641C\u7D22\u6846" : item.html_type === "SEARCH_CASCADE" ? "\u8868\u5355\u7EA7\u8054\u641C\u7D22" : "\u8868\u5355\u9010\u7EA7\u7EA7\u8054";
+      $_handleTracherLog(key, {
+        \u8868\u5355ID: props.params_formId,
+        \u5B57\u6BB5Key: item.val_key,
+        \u5B57\u6BB5\u540D\u79F0: item.name,
+        \u641C\u7D22\u5173\u952E\u5B57: keyword,
+        \u9009\u4E2D\u503C: select
+      });
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  function hanldercheckOption(data) {
+    return data.wordbook && data.wordbook.add_btn;
+  }
+  function handleSearchScrollTop(item) {
+    try {
+      let c = `.search-menu-${item.val_key}`;
+      let list = document.querySelectorAll(c);
+      list.forEach((v) => {
+        let u = v.querySelector(".ant-select-dropdown-menu");
+        if (u) {
+          u.scrollTop = 0;
+        }
+      });
+    } catch (error) {
+      console.log(error, "handleSearchScrollTop");
+    }
+  }
+  function handleCascaderTracher() {
+    if (!Choose_to_complete.value) {
+      return;
+    }
+    const CASCADELIST = ["LEVEL_SEARCH_CASCADE", "SEARCH_CASCADE"];
+    nextTick(() => {
+      var _a;
+      if (!CASCADELIST.includes(props.item.html_type))
+        return;
+      if (Array.isArray(selectedOptions) && selectedOptions.length > 0) {
+        let val = props.row[props.item.val_key];
+        let keyword = "";
+        if (vexutils.isJSON(val)) {
+          keyword = ((_a = JSON.parse(val)) == null ? void 0 : _a.objStr) || "";
+        }
+        if (!keyword)
+          return;
+        handleSearchTracher(props.item, {
+          select: val,
+          keyword
+        });
+      }
+    });
+    Choose_to_complete.value = false;
+  }
+  function handleSearchBlur() {
+    try {
+      let k = `search-${props.item.val_key}`;
+      let t = refs[k];
+      if (Array.isArray(t)) {
+        t = t[0];
+      }
+      searchShowHotList.value = false;
+      t == null ? void 0 : t.blur();
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  onMounted(() => {
+    init();
+  });
+  const VNodes = (props2) => h(props2.vnodes);
+  VNodes.props = ["vnodes"];
+  return {
+    VNodes,
+    fetching,
+    timeout,
+    curOptions,
+    selectedOptions,
+    levelNum,
+    cascaderInitLabel,
+    defList,
+    panelOpen,
+    searchAddObj,
+    searchPageConfig,
+    optionsMaxWidth,
+    cacheReqOptionsParams,
+    hotSearchConfig,
+    searchShowHotList,
+    showHotSearchConfig,
+    showSearchEmpty,
+    selectIsOpen,
+    isnoPages,
+    init,
+    hanldeInitSearchMoreVal,
+    getSearchDefParams,
+    getCascadeParams,
+    handleRowUnique,
+    handleGetSearchDefVal,
+    handleRequestedOptions,
+    handleFreeEntry,
+    formatField,
+    formatFieldValue,
+    getTitleHeader,
+    handleRequestedUniqueKey,
+    dealDictionatySearch,
+    handleMultipleSearch,
+    multipleSelect,
+    multipleDeselect,
+    handlerAddOptions,
+    searchMoreOnChange,
+    handleFormCascade,
+    hanldeGetCascadelabel,
+    handleCascaderChange,
+    handleCascaderFilter,
+    handleCascadeLoadData,
+    handlerDropdownVisibleChange,
+    hanlderGetSearchLabel,
+    hanlderSendSelectLog,
+    handleSearchSelect,
+    handleSearchChangePage,
+    handleCalculateOptionsMaxWidth,
+    handlerSearchOnFocus,
+    handleQueryParams,
+    hideHotSearch,
+    confirmSelect,
+    hanldeRemoveDuplicates,
+    getFormValue,
+    cancelOptionsRequest,
+    getHotSearchConfig,
+    handleSelectHotKeyword,
+    hanldeClearLately,
+    closeHotSearch,
+    handleSearchTracher,
+    hanldercheckOption,
+    handleSearchScrollTop,
+    handleCascaderTracher,
+    handleSearchBlur,
+    curMultipleSelected,
+    formTable,
+    hasErr,
+    handleGetJsonStr,
+    handleSetFieldsValue,
+    handleGetUniqueKey,
+    handleSysParams,
+    defaultInit,
+    handleTableBlur,
+    handleFormParams,
+    radioColor,
+    handleGetAgeUnit,
+    handleAgeToBirthDay,
+    changeAgeSelect,
+    handlerSetIdCarInfoValidate,
+    getInputCheck,
+    getCustomRegular,
+    checkDigital,
+    checkAgeJson,
+    checkAge,
+    checkMultipleChoice,
+    checkLength,
+    checkinputBlank,
+    handlerGetDateType,
+    checkSearchCascade,
+    checkMultipleTree,
+    handleDateClearBtn,
+    handleStartDateEndDate,
+    showTimePanel,
+    momentLib,
+    judgeTimeBoundary,
+    setTimeValue,
+    judgeTimeRange,
+    isSameDate,
+    setDefaultCurrent,
+    handleDefaultRimeRange,
+    judgeMinMaxDateIsSameDate,
+    handleDefaultTimeRange,
+    changeTimeDate,
+    setTimeRangeArr
+  };
+}
+
+export { useSearch };