cnhis-design-vue 3.1.1 → 3.1.4

package/es/packages/select-person/src/SelectPerson.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,892 @@
+import { defineComponent, ref, reactive, computed, nextTick, watch, onMounted, openBlock, createElementBlock, createVNode, unref, withCtx, createElementVNode, createCommentVNode, createTextVNode, toDisplayString, createBlock, withDirectives, vShow, mergeProps, renderSlot, Fragment, renderList, normalizeClass } from 'vue';
+import { useMessage, NSpin, NInputGroup, NInput, NButton, NCheckbox, NTree, NIcon, NTooltip } from 'naive-ui';
+import { CloseCircleSharp } from '@vicons/ionicons5';
+import vexutils from 'cnhis-design-vue/es/src/utils/vexutils';
+import './SearchTree2.mjs';
+import { filterTree } from './utils/index2.mjs';
+import script$1 from './SearchTree.vue_vue_type_script_setup_true_lang.mjs';
+
+const _hoisted_1 = {
+  class: "personnel"
+};
+const _hoisted_2 = {
+  class: "people-tree"
+};
+const _hoisted_3 = {
+  class: "people-tree-item people-tree-left"
+};
+const _hoisted_4 = /* @__PURE__ */ createTextVNode("\u5168\u9009 ");
+const _hoisted_5 = /* @__PURE__ */ createTextVNode("\u5168\u9009 ");
+const _hoisted_6 = {
+  class: "people-tree-item tags-box"
+};
+var script = /* @__PURE__ */ defineComponent({
+  name: "SelectPerson",
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    isDetail: {
+      type: Boolean,
+      default: false
+    },
+    defaultList: {
+      type: Array,
+      default: () => []
+    },
+    data: {
+      type: Array,
+      default: () => []
+    },
+    searchPlaceholder: {
+      type: String,
+      default: "\u8F93\u5165\u5173\u952E\u5B57\u641C\u7D22"
+    },
+    searchButtonText: {
+      type: String,
+      default: "\u641C\u7D22"
+    },
+    wordbook: {
+      type: Object,
+      default: () => ({})
+    },
+    wordbookChild: {
+      type: Object,
+      default: () => ({})
+    },
+    SearchLoadMore: {
+      type: Boolean,
+      default: false
+    },
+    queryMainTreeData: {
+      type: Function
+    },
+    queryLoadChildData: {
+      type: Function
+    },
+    queryTreeSearch: {
+      type: Function
+    }
+  },
+  emits: ["check", "pubCheckedTreeItem", "handleOk", "change", "submitData", "update:visible"],
+  setup(__props, {
+    emit
+  }) {
+    const props = __props;
+    const $message = useMessage();
+    const FIXEDKEY = "8982eeb4-0439-4100-9805-8cdd12b2256c-front-end-fixed-key";
+    const searchTree = ref(null);
+    const state = reactive({
+      treeData: {
+        main: [],
+        search: []
+      },
+      expandedKeys: [],
+      autoExpandParent: true,
+      dataList: {
+        main: [],
+        other: []
+      },
+      checkedKeys: {
+        main: [],
+        other: []
+      },
+      search: {
+        defaultExpandedKeys: [],
+        status: 0,
+        dataListKeys: {
+          main: [],
+          other: []
+        },
+        records: 0
+      },
+      searchValue: "",
+      searchPage: 1,
+      searchNoMore: false,
+      title: "",
+      checkedLeafKeys: [],
+      spinning: false,
+      loadMorenLoadinng: false,
+      errorMsg: "",
+      defaultShowList: [],
+      checkedKeysMain: [],
+      cacheParentIdObj: {},
+      singleChecked: false,
+      indeterminate: false,
+      searchIndeterminate: false,
+      searchChecked: false
+    });
+    const searchTreeVisable = computed(() => state.search.status == 2);
+    const dataListMainKeys = computed(() => {
+      if (!state.dataList.main.length)
+        return [];
+      return state.dataList.main.map((i) => i.key);
+    });
+    const dataListOtherKeys = computed(() => {
+      if (!state.dataList.other.length)
+        return [];
+      return state.dataList.other.map((i) => i.key);
+    });
+    const checkedTreeItem = computed(() => {
+      let otherItems = state.dataList.other.filter((item) => {
+        return state.checkedKeys.other.includes(item.key);
+      });
+      let mainItems = state.dataList.main.filter((item) => {
+        let {
+          isLeaf,
+          key
+        } = item;
+        let parentId = getParentId(item);
+        let showKeys = [...state.checkedKeys.main, ...otherItems];
+        let checked = showKeys.includes(key);
+        if (isLeaf && parentId && state.checkedKeys.main.some((v) => v == parentId)) {
+          checked = false;
+        }
+        return checked;
+      });
+      let list = uniqArrObj([...mainItems, ...otherItems], "key");
+      return list;
+    });
+    const wordbookConfig = computed(() => {
+      const {
+        parent_id_obj,
+        parent_name_obj
+      } = props.wordbook || {};
+      const {
+        user_id_obj,
+        user_name_obj
+      } = props.wordbookChild || {};
+      return {
+        parent_id_obj,
+        parent_name_obj,
+        user_id_obj,
+        user_name_obj
+      };
+    });
+    const getLoadChildData = computed(() => {
+      if (typeof props.queryLoadChildData == "function") {
+        return onLoadData;
+      }
+      return null;
+    });
+    const renderLabel = ({
+      option
+    }) => {
+      if (option.isLeaf || !option.children) {
+        return createVNode(NTooltip, {
+          "trigger": "hover"
+        }, {
+          default: () => `${option.title} ${option.sub_title || ""}`,
+          trigger: () => createVNode("span", null, [createVNode("span", {
+            "class": "c-title"
+          }, [option.title || option.key, createTextVNode("\u2009 ")]), createVNode("span", {
+            "class": "c-sub-title"
+          }, [option.sub_title])])
+        });
+      } else {
+        return createVNode("span", {
+          "class": "p-title"
+        }, [createVNode("span", null, [option.title || option.key]), treeCount(option.count)]);
+      }
+    };
+    const initDefault = () => {
+      if (getLoadChildData.value) {
+        getDefaultList();
+      } else {
+        nextTick(() => {
+          state.checkedKeys.main = [...props.defaultList];
+        });
+      }
+    };
+    const getDefaultList = () => {
+      let copy = JSON.parse(JSON.stringify(props.defaultList));
+      if (Array.isArray(copy)) {
+        copy.forEach((v) => {
+          handleDefMapping(v);
+          getuniqKey(v);
+          let pId = getParentId(v);
+          state.cacheParentIdObj[pId] = pId;
+        });
+        state.defaultShowList = copy;
+      }
+    };
+    const handleDefMapping = (v) => {
+      const {
+        parent_id_obj,
+        parent_name_obj,
+        user_id_obj,
+        user_name_obj
+      } = wordbookConfig.value || {};
+      const {
+        parent_id_obj_key,
+        parent_name_obj_key
+      } = props.wordbook;
+      const {
+        user_id_obj_key,
+        user_name_obj_key
+      } = props.wordbookChild;
+      v[parent_id_obj] = v[parent_id_obj_key] || v.parent_id;
+      v[parent_name_obj] = v[parent_name_obj_key] || v.parent_name;
+      v[user_id_obj] = v[user_id_obj_key] || v.user_id;
+      v[user_name_obj] = v[user_name_obj_key] || v.user_name;
+    };
+    const staticDataInit = () => {
+      if (!Array.isArray(props.data) || props.data.length == 0)
+        return;
+      state.treeData.main = JSON.parse(JSON.stringify(props.data));
+      generateDataList(state.treeData.main, state.dataList.main);
+    };
+    const getcheckedKeys = () => {
+      let checkedKeysMain = [], checkedKeysOther = [];
+      let copy = JSON.parse(JSON.stringify(props.defaultList));
+      if (Array.isArray(copy)) {
+        copy.forEach((v) => {
+          handleDefMapping(v);
+          let key = getuniqKey(v);
+          checkedKeysMain.push(key);
+          if (String(key).includes(FIXEDKEY)) {
+            checkedKeysOther.push(key);
+          }
+        });
+      }
+      return {
+        checkedKeysMain,
+        checkedKeysOther
+      };
+    };
+    const loadSelected = async () => {
+      try {
+        let list = await Promise.all(state.treeData.main.map(async (v) => {
+          const {
+            parent_id_obj
+          } = props.wordbook || {};
+          if ([v.key, v[parent_id_obj], String(v[parent_id_obj])].includes(state.cacheParentIdObj[v[parent_id_obj]])) {
+            await onLoadData(v);
+            return v;
+          }
+        }));
+        return list;
+      } catch (error) {
+        return Promise.resolve();
+      }
+    };
+    const onLoadData = (option) => {
+      return new Promise(async (resolve) => {
+        if (option.children) {
+          resolve();
+          return;
+        }
+        option.children = await handleLoadChildData(option.key, option);
+        hanldeFilterDefaultShowList(option.children);
+        nextTick(() => {
+          state.treeData.main = [...state.treeData.main];
+        });
+        addCheckedKeysChildrenMain(option);
+        generateDataList(option.children || [], state.dataList.main);
+        resolve();
+      });
+    };
+    const getUsers = async () => {
+      try {
+        if (typeof props.queryMainTreeData !== "function") {
+          return;
+        }
+        state.spinning = true;
+        const {
+          parent_id_obj
+        } = wordbookConfig.value || {};
+        let rows = await props.queryMainTreeData();
+        let list = uniqArrObj(rows || [], parent_id_obj);
+        state.treeData.main = list;
+        generateDataList(state.treeData.main, state.dataList.main);
+        await loadSelected();
+        let {
+          checkedKeysMain,
+          checkedKeysOther
+        } = getcheckedKeys();
+        state.checkedKeys.main.push(...checkedKeysMain);
+        state.checkedKeys.other = [...checkedKeysOther];
+        state.treeData.main.forEach((f) => {
+          if (f && f.children && f.children.length) {
+            let flag = f.children.every((c) => checkedKeysMain.includes(c.key));
+            if (flag && f.key) {
+              state.checkedKeys.main.push(f.key);
+            }
+          }
+        });
+        state.spinning = false;
+      } catch (error) {
+        state.spinning = false;
+        $message.error("\u67E5\u8BE2\u5F02\u5E38");
+      }
+    };
+    const loadMainChildData = (searchResultTreeData) => {
+      return new Promise(async (resolve) => {
+        let promises = searchResultTreeData.map(async (item) => {
+          if (item.users) {
+            let mainTreeItem = state.treeData.main.find((mainItem) => mainItem.key == item.key);
+            if (!mainTreeItem || mainTreeItem && !mainTreeItem.children) {
+              if (!mainTreeItem) {
+                mainTreeItem = {
+                  ...item
+                };
+              }
+              mainTreeItem.children = await handleLoadChildData(item.key, mainTreeItem);
+              generateDataList(mainTreeItem.children, state.dataList.main);
+              addCheckedKeysChildrenMain(mainTreeItem);
+            }
+          }
+        });
+        await Promise.all(promises);
+        resolve();
+      });
+    };
+    const handleLoadChildData = async (key, option) => {
+      let rows = props.queryLoadChildData && await props.queryLoadChildData(key, option);
+      let list = rows;
+      return list;
+    };
+    const generateDataList = (data, dataList) => {
+      for (let i = 0; i < data.length; i++) {
+        const node = data[i];
+        dataList.push({
+          parentId: getParentId(node),
+          ...node
+        });
+        if (node.children) {
+          generateDataList(node.children, dataList);
+        }
+      }
+    };
+    const addCheckedKeysChildrenMain = (item) => {
+      if (!item.key)
+        return;
+      if (!state.checkedKeys.main.includes(String(item.key)))
+        return false;
+      if (!Array.isArray(item.children))
+        return false;
+      item.children.forEach(({
+        key
+      }) => {
+        if (state.checkedKeys.main.includes(key) || !key)
+          return false;
+        state.checkedKeys.main.push(key);
+      });
+    };
+    const hanldeFilterDefaultShowList = (list) => {
+      state.defaultShowList = state.defaultShowList.filter((d) => list.findIndex((l) => getuniqKey(d) == getuniqKey(l)) == -1);
+    };
+    const searchFetch = async (data = {}, config = {}) => {
+      if (typeof props.queryTreeSearch !== "function") {
+        staticDataSearch();
+        state.spinning = false;
+        isSearchAllCheck();
+        return;
+      }
+      if (!state.searchValue) {
+        state.search.status = 0;
+        state.search.defaultExpandedKeys = [];
+        state.expandedKeys = [];
+        state.spinning = false;
+        state.searchNoMore = false;
+        return false;
+      }
+      if (!config.loadMoren) {
+        state.search.status = 1;
+      } else {
+        state.loadMorenLoadinng = true;
+      }
+      let rows = await props.queryTreeSearch(state.searchValue, data);
+      let searchResultTreeData = rows;
+      state.loadMorenLoadinng = false;
+      if (!searchResultTreeData || !searchResultTreeData.length) {
+        if (state.searchPage == 1) {
+          state.search.defaultExpandedKeys = [];
+          state.search.status = 3;
+        } else {
+          state.search.status = 2;
+          state.searchNoMore = true;
+        }
+        state.spinning = false;
+        isSearchAllCheck();
+        return false;
+      }
+      const {
+        parent_id_obj,
+        parent_name_obj,
+        user_count_obj
+      } = props.wordbook || {};
+      props.wordbookChild || {};
+      let pObj = {};
+      searchResultTreeData.forEach((item) => {
+        item[parent_id_obj] && (pObj[item[parent_id_obj]] = {
+          key: item[parent_id_obj],
+          users: []
+        });
+        if (item.users) {
+          insertSearchTreeData(item);
+        } else {
+          insertSearchTreeDataOther(item);
+        }
+      });
+      let pList = [];
+      Object.keys(pObj || {}).forEach((v) => {
+        if (v) {
+          pList.push({
+            ...pObj[v]
+          });
+        }
+      });
+      state.treeData.search.length || 0;
+      if (props.SearchLoadMore) {
+        state.searchNoMore = false;
+      } else {
+        state.searchNoMore = true;
+      }
+      await loadMainChildData(pList);
+      generateSearchDataListKeys(searchResultTreeData);
+      hanldeFilterDefaultShowList(searchResultTreeData);
+      refreshSearchTree();
+      state.search.status = 2;
+      state.spinning = false;
+      isSearchAllCheck();
+    };
+    const refreshSearchTree = () => {
+      if (!searchTreeVisable.value)
+        return false;
+      searchTree.value.setDefaultCheckedKeys();
+      nextTick(() => {
+        isSearchAllCheck();
+      });
+    };
+    const generateSearchDataListKeys = (searchResultTreeData) => {
+      searchResultTreeData.forEach((item) => {
+        if (!dataListMainKeys.value.includes(item.key)) {
+          state.search.dataListKeys.other.push(item.key);
+          item.children && item.children.forEach((childItem) => {
+            state.search.dataListKeys.other.push(childItem.key);
+          });
+          return;
+        }
+        state.search.dataListKeys.main.push(item.key);
+        item.children && item.children.forEach((childItem) => {
+          state.search.dataListKeys.main.push(childItem.key);
+        });
+      });
+    };
+    const insertSearchTreeData = (item) => {
+      const {
+        user_count_obj
+      } = props.wordbook || {};
+      state.search.defaultExpandedKeys.push(item.key);
+      hanldeFilterDefaultShowList(item.children || []);
+      if (item[user_count_obj] == item.children.length) {
+        item.disableCheckbox = false;
+      }
+      state.treeData.search.push(item);
+    };
+    const insertSearchTreeDataOther = (item) => {
+      let formatItem = Object.assign({}, item, {
+        isLeaf: true
+      });
+      state.treeData.search.push(formatItem);
+      if (dataListOtherKeys.value.includes(formatItem.key))
+        return false;
+      generateDataList([formatItem], state.dataList.other);
+    };
+    const isSearchAllCheck = () => {
+      nextTick(() => {
+        let skeyArr = state.treeData.search.map((item) => item.key);
+        let serchCheckedKeys = searchTree.value.checkedKeys;
+        state.searchIndeterminate = !!serchCheckedKeys.length && serchCheckedKeys.length < skeyArr.length;
+        state.searchChecked = serchCheckedKeys.length === skeyArr.length;
+      });
+    };
+    const staticDataSearch = () => {
+      if (!state.title) {
+        state.treeData.main = JSON.parse(JSON.stringify(props.data));
+        return;
+      }
+      let copyData = JSON.parse(JSON.stringify(state.treeData.main));
+      filterTree({
+        value: state.title,
+        data: copyData,
+        prop: "title"
+      });
+      const expandedKeys = [];
+      vexutils.searchTree(copyData, (item) => {
+        if (item.visible) {
+          expandedKeys.push(item.key);
+        }
+        if (item.children?.length) {
+          item.children = item.children.filter((child) => child.visible);
+        }
+      });
+      state.treeData.main = copyData;
+      state.expandedKeys = expandedKeys;
+    };
+    const onExpand = (expandedKeys) => {
+      state.expandedKeys = expandedKeys;
+      state.autoExpandParent = false;
+    };
+    const searchClick = () => {
+      state.searchValue = state.title;
+      state.treeData.search = [];
+      state.search.dataListKeys.other = [];
+      state.search.dataListKeys.main = [];
+      state.search.defaultExpandedKeys = [];
+      state.spinning = true;
+      state.searchPage = 1;
+      searchFetch();
+    };
+    const isAllCheck = (checkedKeys = []) => {
+      if (!checkedKeys || checkedKeys.length == 0) {
+        state.indeterminate = false;
+        state.singleChecked = false;
+      } else {
+        let keyArr = state.treeData.main.map((item) => item.key);
+        let keyArrTemp = keyArr.filter((item) => checkedKeys.indexOf(item) !== -1);
+        state.indeterminate = !(keyArr.length == keyArrTemp.length);
+        state.singleChecked = keyArr.length == keyArrTemp.length;
+      }
+    };
+    const addCheckedkeysMain = (keys) => {
+      let checkedKeys = state.checkedKeys.main;
+      let filterKey = (keys || {}).filter(Boolean);
+      filterKey.forEach((key) => {
+        checkedKeys.push(key);
+        let _getParentKey = getParentKey(key, state.treeData.main);
+        if (!_getParentKey)
+          return;
+        let parent = state.treeData.main.filter((item) => {
+          return item.key == _getParentKey;
+        });
+        let allCheck = (parent[0]?.children || []).every((item) => {
+          return checkedKeys.includes(item.key);
+        });
+        allCheck && checkedKeys.push(_getParentKey);
+      });
+    };
+    const getParentKey = (key, tree) => {
+      let parentKey;
+      for (let i = 0; i < tree.length; i++) {
+        const node = tree[i];
+        if (node.key == key) {
+          parentKey = node.key;
+          return parentKey;
+        }
+        if (node.children) {
+          if (node.children.some((item) => item.key == key)) {
+            parentKey = node.key;
+          } else if (getParentKey(key, node.children)) {
+            parentKey = getParentKey(key, node.children);
+          }
+        }
+      }
+      return parentKey;
+    };
+    const radioChange = (checked) => {
+      if (searchTreeVisable.value) {
+        state.singleChecked = checked;
+      } else {
+        state.searchChecked = checked;
+      }
+      checkAll(checked ? 1 : 2);
+    };
+    const checkAll = (type) => {
+      if (checkAllSearchTree(type))
+        return false;
+      if (type == 1) {
+        state.expandedKeys = [];
+        state.checkedKeys.main = dataListMainKeys.value;
+      } else if (type == 2) {
+        state.checkedKeys.main = [];
+        state.autoExpandParent = true;
+      }
+    };
+    const checkAllSearchTree = (type) => {
+      if (!searchTreeVisable.value)
+        return false;
+      if (type == 1) {
+        let allSearchkeysMain = state.search.dataListKeys.main.filter((key) => {
+          return !state.search.defaultExpandedKeys.includes(key);
+        });
+        let allSearchkeysOther = state.search.dataListKeys.other;
+        state.checkedKeys.main = vexutils.uniq([...state.checkedKeys.main, ...allSearchkeysMain]);
+        state.checkedKeys.other = vexutils.uniq([...state.checkedKeys.other, ...allSearchkeysOther]);
+        state.search.dataListKeys.main.forEach((key) => {
+          let parentKey = getParentKey(key, state.treeData.main);
+          let parent = state.treeData.main.filter((item) => {
+            return item.key == parentKey;
+          });
+          let allCheck = parent[0].children.every((item) => {
+            return state.checkedKeys.main.includes(item.key);
+          });
+          allCheck && state.checkedKeys.main.push(parentKey);
+        });
+        refreshSearchTree();
+      } else if (type == 2) {
+        searchTree.value.emptyCheckedKeys();
+        state.autoExpandParent = true;
+      }
+      isSearchAllCheck();
+      return true;
+    };
+    const removeCheckedkeysMain = (keys) => {
+      let checkedKeysMain = vexutils.clone(state.checkedKeys.main, true);
+      keys.forEach((key) => {
+        let index = checkedKeysMain.findIndex((mainKey) => mainKey == key);
+        if (index !== -1) {
+          checkedKeysMain.splice(index, 1);
+          state.checkedKeys.main = [...checkedKeysMain];
+        }
+        let parentKey = getParentKey(key, state.treeData.main);
+        let parentIndex = checkedKeysMain.findIndex((mainKey) => mainKey == parentKey);
+        if (parentIndex !== -1) {
+          checkedKeysMain.splice(parentIndex, 1);
+        }
+      });
+      state.checkedKeys.main = [...checkedKeysMain];
+    };
+    const addCheckedkeysOther = (keys) => {
+      state.checkedKeys.other.push(...keys);
+    };
+    const removeCheckedkeysOther = (keys) => {
+      let checkedKeys = state.checkedKeys.other;
+      keys.forEach((key) => {
+        let index = checkedKeys.findIndex((otherKey) => otherKey == key);
+        checkedKeys.splice(index, 1);
+        handleDeldefaultShowList(key);
+      });
+      removeCheckedkeysMain(keys);
+    };
+    const handleDeldefaultShowList = (key) => {
+      let len = state?.defaultShowList?.length || 0;
+      if (len > 0) {
+        for (let i = len - 1; i >= 0; i--) {
+          let d = state.defaultShowList[i];
+          if (`${d.parent_id}_${d.user_id}` == key) {
+            closeDefaultTag(d, i);
+          }
+        }
+      }
+    };
+    const closeDefaultTag = (tag, i) => {
+      state.defaultShowList.splice(i, 1);
+      closeTag({
+        parentId: getParentId(tag),
+        ...tag
+      });
+    };
+    const closeTag = (removedTag) => {
+      removedCheckedkeysMain(removedTag);
+      removedCheckedkeysOther(removedTag);
+      refreshSearchTree();
+    };
+    const removeCheckedkeysIncludeChildren = (parentKey) => {
+      let needRemoveChildKeys = state.dataList.main.filter((i) => {
+        let parentId = getParentId(i);
+        return parentId == parentKey || i.key == parentKey;
+      }).map((i) => {
+        return i.key;
+      });
+      state.checkedKeys.main = state.checkedKeys.main.filter((i) => {
+        return !needRemoveChildKeys.includes(i);
+      });
+    };
+    const removedCheckedkeysMain = (tag) => {
+      let checkedKeys = state.checkedKeys.main;
+      let parentId = getParentId(tag);
+      for (let i = 0; i < checkedKeys.length; i++) {
+        if (tag.key == checkedKeys[i] && tag.key == parentId) {
+          removeCheckedkeysIncludeChildren(tag.key);
+          return false;
+        } else if (tag.key == checkedKeys[i]) {
+          checkedKeys.splice(i, 1);
+          return false;
+        }
+      }
+    };
+    const removedCheckedkeysOther = (tag) => {
+      let checkedKeys = state.checkedKeys.other;
+      if (checkedKeys.includes(tag.key)) {
+        for (let i = 0; i < checkedKeys.length; i++) {
+          if (tag.key == checkedKeys[i]) {
+            checkedKeys.splice(i, 1);
+            return false;
+          }
+        }
+      } else {
+        OtherRemoveCheckedkeysIncludeChildren(tag.key);
+      }
+    };
+    const OtherRemoveCheckedkeysIncludeChildren = (parentKey) => {
+      let needRemoveChildKeys = state.dataList.main.filter((i) => {
+        let parentId = getParentId(i);
+        return parentId == parentKey || i.key == parentKey;
+      }).map((i) => {
+        return i.key;
+      });
+      state.checkedKeys.other = state.checkedKeys.other.filter((i) => {
+        return !needRemoveChildKeys.includes(i);
+      });
+    };
+    const searchOnloadMore = () => {
+      state.searchPage = state.searchPage + 1;
+      searchFetch({
+        page: state.searchPage
+      }, {
+        loadMoren: true
+      });
+    };
+    const treeCount = (count) => {
+      if (!count)
+        return "";
+      return `(${count})`;
+    };
+    const getParentId = (v) => {
+      const {
+        parent_id_obj
+      } = wordbookConfig.value || {};
+      return `${v[parent_id_obj]}`;
+    };
+    const uniqArrObj = (arr, name) => {
+      let obj = {};
+      return arr.reduce((cur, next) => {
+        obj[next[name]] ? "" : obj[next[name]] = cur.push(next);
+        return cur;
+      }, []);
+    };
+    const getuniqKey = (v) => {
+      const {
+        user_id_obj
+      } = wordbookConfig.value || {};
+      return `${getParentId(v)}_${v[user_id_obj]}`;
+    };
+    watch(() => props.defaultList, (val) => {
+      if (!val)
+        return;
+      initDefault();
+    }, {
+      immediate: true
+    });
+    watch(() => state.checkedKeys.main, (val) => {
+      isAllCheck(val);
+      isSearchAllCheck();
+      emit("check", val);
+    }, {
+      immediate: true,
+      deep: true
+    });
+    watch(() => props.data, (val) => {
+      staticDataInit();
+    }, {
+      immediate: true
+    });
+    onMounted(() => {
+      getUsers();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [createVNode(unref(NSpin), {
+        show: state.spinning
+      }, {
+        default: withCtx(() => [createElementVNode("div", _hoisted_2, [createCommentVNode(" \u6811\u4E3B\u4F53\u4E0E\u68C0\u7D22 "), createElementVNode("div", _hoisted_3, [createVNode(unref(NInputGroup), {
+          style: {
+            "margin-bottom": "12px"
+          }
+        }, {
+          default: withCtx(() => [createVNode(unref(NInput), {
+            style: {
+              "text-align": "left"
+            },
+            clearable: "",
+            value: state.title,
+            "onUpdate:value": _cache[0] || (_cache[0] = ($event) => state.title = $event),
+            placeholder: __props.searchPlaceholder
+          }, null, 8, ["value", "placeholder"]), createVNode(unref(NButton), {
+            type: "primary",
+            onClick: searchClick
+          }, {
+            default: withCtx(() => [createTextVNode(toDisplayString(__props.searchButtonText), 1)]),
+            _: 1
+          })]),
+          _: 1
+        }), unref(searchTreeVisable) ? (openBlock(), createBlock(unref(NCheckbox), {
+          key: 0,
+          checked: state.searchChecked,
+          "onUpdate:checked": [_cache[1] || (_cache[1] = ($event) => state.searchChecked = $event), radioChange],
+          indeterminate: state.searchIndeterminate
+        }, {
+          default: withCtx(() => [_hoisted_4]),
+          _: 1
+        }, 8, ["checked", "indeterminate"])) : (openBlock(), createBlock(unref(NCheckbox), {
+          key: 1,
+          checked: state.singleChecked,
+          "onUpdate:checked": [_cache[2] || (_cache[2] = ($event) => state.singleChecked = $event), radioChange],
+          indeterminate: state.searchIndeterminate
+        }, {
+          default: withCtx(() => [_hoisted_5]),
+          _: 1
+        }, 8, ["checked", "indeterminate"])), createCommentVNode(' <div v-show="state.search.status == 3 || (state.search.status == 0 && state.treeData.main && state.treeData.main.length == 0)" class="no-data-tips">\r\n            \u67E5\u65E0\u7ED3\u679C\r\n          </div> '), createCommentVNode(" main tree "), withDirectives(createVNode(unref(NTree), {
+          class: "main-tree-container",
+          "checked-keys": state.checkedKeys.main,
+          "onUpdate:checked-keys": _cache[3] || (_cache[3] = ($event) => state.checkedKeys.main = $event),
+          "expanded-keys": state.expandedKeys,
+          checkable: "",
+          cascade: "",
+          "allow-checking-not-loaded": "",
+          selectable: false,
+          data: state.treeData.main,
+          "check-strategy": __props.queryMainTreeData ? "all" : "child",
+          "onUpdate:expandedKeys": onExpand,
+          "on-load": onLoadData,
+          "render-label": renderLabel
+        }, null, 8, ["checked-keys", "expanded-keys", "data", "check-strategy"]), [[vShow, state.search.status == 0]]), createCommentVNode(" search tree "), createVNode(script$1, mergeProps(_ctx.$attrs, {
+          ref_key: "searchTree",
+          ref: searchTree,
+          visible: unref(searchTreeVisable),
+          formatTreeData: state.treeData.search,
+          searchValue: state.searchValue,
+          allCheckedKeys: state.checkedKeys,
+          defaultExpandedKeys: state.search.defaultExpandedKeys,
+          dataListKeys: state.search.dataListKeys,
+          searchNoMore: state.searchNoMore,
+          loadMorenLoadinng: state.loadMorenLoadinng,
+          onAddCheckedkeysMain: addCheckedkeysMain,
+          onRemoveCheckedkeysMain: removeCheckedkeysMain,
+          onAddCheckedkeysOther: addCheckedkeysOther,
+          onRemoveCheckedkeysOther: removeCheckedkeysOther,
+          onSearchOnloadMore: searchOnloadMore
+        }), null, 16, ["visible", "formatTreeData", "searchValue", "allCheckedKeys", "defaultExpandedKeys", "dataListKeys", "searchNoMore", "loadMorenLoadinng"])]), createCommentVNode(" \u6811\u5DF2\u9009\u7684\u6570\u636E "), createElementVNode("div", _hoisted_6, [state.defaultShowList && state.defaultShowList.length ? renderSlot(_ctx.$slots, "default", {
+          key: 0
+        }, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(state.defaultShowList, (tag, i) => {
+          return openBlock(), createElementBlock("div", {
+            class: "tag-item def-item",
+            key: i
+          }, [createTextVNode(toDisplayString(tag.title || tag[__props.wordbookChild.user_name_obj]) + " ", 1), !__props.isDetail ? (openBlock(), createBlock(unref(NIcon), {
+            key: 0,
+            class: "tag-close",
+            component: unref(CloseCircleSharp),
+            onClick: ($event) => closeDefaultTag(tag, i)
+          }, null, 8, ["component", "onClick"])) : createCommentVNode("v-if", true)]);
+        }), 128))]) : createCommentVNode("v-if", true), (openBlock(true), createElementBlock(Fragment, null, renderList(unref(checkedTreeItem), (tag) => {
+          return openBlock(), createElementBlock("div", {
+            class: normalizeClass(["tag-item", {
+              isRoot: !tag.isLeaf
+            }]),
+            key: tag.key
+          }, [createTextVNode(toDisplayString(tag.title || tag.key) + " " + toDisplayString(treeCount(tag.count)) + " ", 1), !__props.isDetail ? (openBlock(), createBlock(unref(NIcon), {
+            key: 0,
+            class: "tag-close",
+            component: unref(CloseCircleSharp),
+            onClick: ($event) => closeTag(tag)
+          }, null, 8, ["component", "onClick"])) : createCommentVNode("v-if", true)], 2);
+        }), 128))])])]),
+        _: 3
+      }, 8, ["show"])]);
+    };
+  }
+});
+
+export { script as default };