@dt-frames/ui 3.0.1 → 4.0.1

package/es/components/tree/index.js

@@ -1,1199 +0,0 @@
-import { isProd, getDynamicProps, useI18n, isArray, isFunction, isEmpty, isBoolean, getSlot } from "@dt-frames/core";
-import { ref, onUnmounted, unref, watch, defineComponent, computed, onMounted, nextTick, createVNode, isVNode, Fragment, getCurrentInstance, render, useSlots, openBlock, createElementBlock, toDisplayString, createCommentVNode, renderSlot, createBlock, withModifiers, withCtx, renderList, normalizeProps, guardReactiveProps, createTextVNode, createElementVNode, useAttrs, reactive, toRaw, createSlots, withDirectives, mergeProps, vShow } from "vue";
-import { Input, MenuItem, MenuDivider, Menu as Menu$1, Dropdown, Tree, Empty, Spin } from "ant-design-vue/es";
-import { cloneDeep, omit, difference, get } from "lodash-es";
-import { Menu, Divider } from "ant-design-vue";
-import { Icon } from "../icons";
-import { useDebounceFn } from "@vueuse/core";
-function useTree(props) {
-  const treeRef = ref(null);
-  const loadedRef = ref(null);
-  function register(instance) {
-    isProd() && onUnmounted(() => {
-      treeRef.value = null;
-      loadedRef.value = null;
-    });
-    if (unref(loadedRef) && isProd() && instance === unref(treeRef))
-      return;
-    treeRef.value = instance;
-    loadedRef.value = true;
-    watch(
-      () => props,
-      () => {
-        props && instance.setProps(getDynamicProps(props));
-      },
-      {
-        immediate: true,
-        deep: true
-      }
-    );
-  }
-  const methods = {
-    setProps: (props2) => unref(treeRef)?.setProps(props2),
-    setExpandedKeys: (keys) => unref(treeRef)?.setExpandedKeys(keys),
-    getExpandedKeys: () => unref(treeRef)?.getExpandedKeys(),
-    setSelectedKeys: (keys) => unref(treeRef)?.setSelectedKeys(keys),
-    getSelectedKeys: () => unref(treeRef)?.getSelectedKeys(),
-    setCheckedKeys: (keys) => unref(treeRef)?.setCheckedKeys(keys),
-    getCheckedKeys: () => unref(treeRef)?.getCheckedKeys(),
-    insertNodeByKey: (opt) => unref(treeRef)?.insertNodeByKey(opt),
-    insertNodesByKey: (opt) => unref(treeRef)?.insertNodesByKey(opt),
-    deleteNodeByKey: (key) => unref(treeRef)?.deleteNodeByKey(key),
-    updateNodeByKey: (key, node) => unref(treeRef)?.updateNodeByKey(key, node),
-    getSelectedNode: (key, treeList, selectNode) => unref(treeRef)?.getSelectedNode(key, treeList, selectNode),
-    checkAll: (checkAll) => unref(treeRef)?.checkAll(checkAll),
-    expandAll: (expandAll) => unref(treeRef)?.expandAll(expandAll),
-    onStrictlyChange: (strictly) => unref(treeRef)?.onStrictlyChange(strictly),
-    filterByLevel: (level) => unref(treeRef)?.filterByLevel(level),
-    setSearchValue: (value) => unref(treeRef)?.setSearchValue(value),
-    getSearchValue: () => unref(treeRef)?.getSearchValue()
-  };
-  return [register, methods];
-}
-const BasicProps = {
-  expandLevel: {
-    type: Number,
-    default: 0
-  },
-  defaultExpandAll: {
-    type: Boolean
-  },
-  height: {
-    type: [Number, String]
-  },
-  showIcon: {
-    type: Boolean,
-    default: false
-  },
-  blockNode: {
-    type: Boolean,
-    default: true
-  },
-  fieldNames: {
-    type: Object,
-    default: {
-      children: "children",
-      title: "title",
-      key: "key"
-    }
-  },
-  disabled: {
-    type: Boolean,
-    default: false
-  },
-  draggable: {
-    type: Boolean,
-    default: false
-  },
-  filterTreeNode: {
-    type: Function
-  },
-  multiple: {
-    type: Boolean,
-    default: false
-  },
-  selectable: {
-    type: Boolean,
-    default: false
-  },
-  showLine: {
-    type: Boolean,
-    default: false
-  },
-  activeKey: {
-    type: [String, Number]
-  },
-  loading: {
-    type: Boolean,
-    default: false
-  },
-  checkStrictly: {
-    type: Boolean,
-    default: false
-  },
-  expandedKeys: {
-    type: Array,
-    default: () => []
-  },
-  selectedKeys: {
-    type: Array,
-    default: () => []
-  },
-  checkedKeys: {
-    type: Array,
-    default: () => []
-  },
-  beforeRightClick: {
-    type: Function,
-    default: void 0
-  },
-  rightMenuList: {
-    type: Array
-  },
-  renderIcon: {
-    type: Function
-  },
-  highlight: {
-    type: [Boolean, String],
-    default: false
-  },
-  action: {
-    type: Function
-  },
-  clickRowToExpand: {
-    type: Boolean,
-    default: false
-  },
-  searchValue: {
-    type: String,
-    default: ""
-  },
-  filterFn: {
-    type: Function,
-    default: void 0
-  },
-  checkable: {
-    type: Boolean,
-    default: false
-  },
-  expandOnSearch: {
-    type: Boolean,
-    default: true
-  },
-  treeData: {
-    type: Array
-  },
-  value: {
-    type: [Object, Array]
-  },
-  title: {
-    type: String,
-    default: ""
-  },
-  toolbar: Boolean,
-  search: {
-    type: Boolean,
-    default: false
-  }
-};
-const searchProps = {
-  title: {
-    type: String,
-    default: ""
-  },
-  toolbar: {
-    type: Boolean,
-    default: false
-  },
-  checkable: {
-    type: Boolean,
-    default: false
-  },
-  search: {
-    type: Boolean,
-    default: false
-  },
-  searchText: {
-    type: String,
-    default: ""
-  },
-  checkAll: {
-    type: Function,
-    default: void 0
-  },
-  expandAll: {
-    type: Function,
-    default: void 0
-  }
-};
-const rightMenuProps = {
-  width: {
-    type: Number,
-    default: 106
-  },
-  customEvent: {
-    type: Object,
-    default: null
-  },
-  styles: {
-    type: Object
-  },
-  showIcon: {
-    type: Boolean,
-    default: true
-  },
-  axis: {
-    type: Object,
-    default: () => {
-      return { x: 0, y: 0 };
-    }
-  },
-  items: {
-    type: Array,
-    default: () => []
-  },
-  node: {
-    type: Object
-  }
-};
-function eachTree(treeDatas, callBack, parentNode = {}, config = { children: "children" }) {
-  treeDatas.forEach((el) => {
-    const newNode = callBack(el, parentNode) || el;
-    if (el[config.children]) {
-      eachTree(el[config.children], callBack, newNode, config);
-    }
-  });
-}
-function forEach(tree, func, config = {}) {
-  const list = [...tree];
-  const { children = "children" } = config;
-  for (let i = 0; i < list.length; i++) {
-    if (func(list[i])) {
-      return;
-    }
-    children && list[i][children] && list.splice(i + 1, 0, ...list[i][children]);
-  }
-}
-function filter(tree, func, config = {}) {
-  const children = config.children || "children";
-  function listFilter(list) {
-    return list.map((node) => ({ ...node })).filter((node) => {
-      node[children] = node[children] && listFilter(node[children]);
-      return func(node) || node[children] && node[children].length;
-    });
-  }
-  return listFilter(tree);
-}
-function treeToList(tree, config = {}) {
-  const { children = "children" } = config;
-  const result = [...tree];
-  for (let i = 0; i < result.length; i++) {
-    if (!result[i][children])
-      continue;
-    result.splice(i + 1, 0, ...result[i][children]);
-  }
-  return result;
-}
-function _isSlot(s) {
-  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
-}
-const _sfc_main$2 = /* @__PURE__ */ defineComponent({
-  name: "ContextMenu",
-  props: rightMenuProps,
-  setup(props) {
-    const wrapRef = ref(null);
-    const showRef = ref(false);
-    const ItemContent = (props2) => {
-      const {
-        item
-      } = props2;
-      return createVNode("span", {
-        "class": "px-4 w-full flex items-center",
-        "onClick": props2.handler.bind(null, item)
-      }, [props2.showIcon && item.icon && createVNode("i", {
-        "class": "i mr-2 " + item.icon
-      }, null), createVNode("span", null, [item.label])]);
-    };
-    const getStyle = computed(() => {
-      const {
-        axis,
-        items,
-        styles,
-        width
-      } = props;
-      const {
-        x,
-        y
-      } = axis || {
-        x: 0,
-        y: 0
-      };
-      const menuHeight = (items || []).length * 40;
-      const body = document.body;
-      const left = body.clientWidth < x + width ? x - width : x;
-      const top = body.clientHeight < y + menuHeight ? y - menuHeight : y;
-      return {
-        ...styles,
-        position: "absolute",
-        width: `${width}px`,
-        left: `${left + 1}px`,
-        top: `${top + 1}px`,
-        zIndex: 9999
-      };
-    });
-    function handleAction(item, e) {
-      const {
-        handler,
-        disabled
-      } = item;
-      if (disabled)
-        return;
-      showRef.value = false;
-      e?.stopPropagation();
-      e?.preventDefault();
-      handler?.(props.node);
-    }
-    function renderMenuItem(items) {
-      const visibleItems = items.filter((item) => !item.hidden);
-      return visibleItems.map((item) => {
-        const {
-          disabled,
-          label,
-          children,
-          divider = false
-        } = item;
-        const contentProps = {
-          item,
-          handler: handleAction,
-          showIcon: props.showIcon
-        };
-        if (!children || children.length === 0) {
-          return createVNode(Fragment, null, [createVNode(Menu.Item, {
-            "disabled": disabled,
-            "class": "dt-context-menu__item",
-            "key": label
-          }, {
-            default: () => [createVNode(ItemContent, contentProps, null)]
-          }), divider ? createVNode(Divider, {
-            "key": `d-${label}`
-          }, null) : null]);
-        }
-        return createVNode(Menu.SubMenu, {
-          "key": label,
-          "disabled": disabled,
-          "popupClassName": "dt-context-menu__popup"
-        }, {
-          title: () => createVNode(ItemContent, contentProps, null),
-          default: () => renderMenuItem(children)
-        });
-      });
-    }
-    onMounted(() => {
-      nextTick(() => showRef.value = true);
-    });
-    onUnmounted(() => {
-      const el = unref(wrapRef);
-      el && document.body.removeChild(el);
-    });
-    return () => {
-      let _slot;
-      if (!unref(showRef)) {
-        return null;
-      }
-      const {
-        items
-      } = props;
-      return createVNode("div", {
-        "class": "dt-context-menu fixed top-0 left-0 z-50 block m-0"
-      }, [createVNode(Menu, {
-        "inlineIndent": 12,
-        "mode": "vertical",
-        "ref": wrapRef,
-        "style": unref(getStyle)
-      }, _isSlot(_slot = renderMenuItem(items)) ? _slot : {
-        default: () => [_slot]
-      })]);
-    };
-  }
-});
-function useContextMenu() {
-  const menuManager = {
-    domList: [],
-    resolve: () => {
-    }
-  };
-  function createContextMenu(options) {
-    const { event, node } = options || {};
-    event && event?.preventDefault();
-    return new Promise((resolve) => {
-      const body = document.body;
-      const container = document.createElement("div");
-      const propsData = { node };
-      if (options.styles) {
-        propsData.styles = options.styles;
-      }
-      if (options.items) {
-        propsData.items = options.items;
-      }
-      if (options.event) {
-        propsData.customEvent = event;
-        propsData.axis = { x: event.clientX, y: event.clientY };
-      }
-      const vm = createVNode(_sfc_main$2, propsData);
-      render(vm, container);
-      const handleClick = function() {
-        menuManager.resolve("");
-      };
-      menuManager.domList.push(container);
-      const remove = function() {
-        menuManager.domList.forEach((dom) => {
-          try {
-            dom && body.removeChild(dom);
-          } catch (error) {
-          }
-        });
-        body.removeEventListener("click", handleClick);
-        body.removeEventListener("scroll", handleClick);
-      };
-      menuManager.resolve = function(arg) {
-        remove();
-        resolve(arg);
-      };
-      remove();
-      body.appendChild(container);
-      body.addEventListener("click", handleClick);
-      body.addEventListener("scroll", handleClick);
-    });
-  }
-  function destroyContextMenu() {
-    if (menuManager) {
-      menuManager.resolve("");
-      menuManager.domList = [];
-    }
-  }
-  if (getCurrentInstance()) {
-    onUnmounted(() => {
-      destroyContextMenu();
-    });
-  }
-  return [createContextMenu, destroyContextMenu];
-}
-function useMethod(treeDataRef, getFieldNames, props) {
-  function getAllKeys(list) {
-    const keys = [];
-    const treeData = list || unref(treeDataRef);
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return keys;
-    for (let index = 0; index < treeData.length; index++) {
-      const node = treeData[index];
-      keys.push(node[keyField]);
-      const children = node[childrenField];
-      if (children && children.length) {
-        keys.push(...getAllKeys(children));
-      }
-    }
-    return keys;
-  }
-  function getEnabledKeys(list) {
-    const keys = [];
-    const treeData = list || unref(treeDataRef);
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return keys;
-    for (let index = 0; index < treeData.length; index++) {
-      const node = treeData[index];
-      node.disabled !== true && node.selectable !== false && keys.push(node[keyField]);
-      const children = node[childrenField];
-      if (children && children.length) {
-        keys.push(...getEnabledKeys(children));
-      }
-    }
-    return keys;
-  }
-  function getChildrenKeys(nodeKey, list) {
-    const keys = [];
-    const treeData = list || unref(treeDataRef);
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return keys;
-    for (let index = 0; index < treeData.length; index++) {
-      const node = treeData[index];
-      const children = node[childrenField];
-      if (nodeKey === node[keyField]) {
-        keys.push(node[keyField]);
-        if (children && children.length) {
-          keys.push(...getAllKeys(children));
-        }
-      } else {
-        if (children && children.length) {
-          keys.push(...getChildrenKeys(nodeKey, children));
-        }
-      }
-    }
-    return keys;
-  }
-  function updateNodeByKey(key, node, list) {
-    if (!key)
-      return;
-    const treeData = list || unref(treeDataRef);
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return;
-    for (let index = 0; index < treeData.length; index++) {
-      const element = treeData[index];
-      const children = element[childrenField];
-      if (element[keyField] === key) {
-        treeData[index] = { ...treeData[index], ...node };
-        break;
-      } else if (children && children.length) {
-        updateNodeByKey(key, node, element[childrenField]);
-      }
-    }
-  }
-  function filterByLevel(level = 1, list, currentLevel = 1) {
-    if (!level)
-      return [];
-    const res = [];
-    const data = list || unref(treeDataRef) || [];
-    for (let index = 0; index < data.length; index++) {
-      const item = data[index];
-      const { key: keyField, children: childrenField } = unref(getFieldNames);
-      const key = keyField ? item[keyField] : "";
-      const children = childrenField ? item[childrenField] : [];
-      res.push(key);
-      if (children && children.length && currentLevel < level) {
-        currentLevel += 1;
-        res.push(...filterByLevel(level, children, currentLevel));
-      }
-    }
-    return res;
-  }
-  function insertNodeByKey({ parentKey = null, node, push = "push" }) {
-    const treeData = cloneDeep(unref(treeDataRef));
-    if (!parentKey) {
-      treeData[push](node);
-      treeDataRef.value = treeData;
-      return;
-    }
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return;
-    forEach(treeData, (treeItem) => {
-      if (treeItem[keyField] === parentKey) {
-        treeItem[childrenField] = treeItem[childrenField] || [];
-        treeItem[childrenField][push](node);
-        return true;
-      }
-    });
-    treeDataRef.value = treeData;
-  }
-  function insertNodesByKey({ parentKey = null, list, push = "push" }) {
-    const treeData = cloneDeep(unref(treeDataRef));
-    if (!list || list.length < 1)
-      return;
-    if (!parentKey) {
-      for (let i = 0; i < list.length; i++) {
-        treeData[push](list[i]);
-      }
-    } else {
-      const { key: keyField, children: childrenField } = unref(getFieldNames);
-      if (!childrenField || !keyField)
-        return;
-      forEach(treeData, (treeItem) => {
-        if (treeItem[keyField] === parentKey) {
-          treeItem[childrenField] = treeItem[childrenField] || [];
-          for (let i = 0; i < list.length; i++) {
-            treeItem[childrenField][push](list[i]);
-          }
-          treeDataRef.value = treeData;
-          return true;
-        }
-      });
-    }
-  }
-  function deleteNodeByKey(key, list) {
-    if (!key)
-      return;
-    const treeData = list || unref(treeDataRef);
-    const { key: keyField, children: childrenField } = unref(getFieldNames);
-    if (!childrenField || !keyField)
-      return;
-    for (let index = 0; index < treeData.length; index++) {
-      const element = treeData[index];
-      const children = element[childrenField];
-      if (element[keyField] === key) {
-        treeData.splice(index, 1);
-        break;
-      } else if (children && children.length) {
-        deleteNodeByKey(key, element[childrenField]);
-      }
-    }
-  }
-  function getSelectedNode(key, list, selectedNode) {
-    if (!key && key !== 0)
-      return null;
-    const treeData = list || unref(treeDataRef);
-    const { children: childrenField } = unref(getFieldNames);
-    treeData.forEach((item) => {
-      if (selectedNode?.key || selectedNode?.key === 0)
-        return selectedNode;
-      if (item.key === key) {
-        selectedNode = item;
-        return;
-      }
-      if (item[childrenField] && item[childrenField].length) {
-        selectedNode = getSelectedNode(key, item[childrenField], selectedNode);
-      }
-    });
-    return selectedNode || null;
-  }
-  function onDrop(info) {
-    const dropKey = info.node.key;
-    const dragKey = info.dragNode.key;
-    const dropPos = info.node.pos.split("-");
-    const dropPosition = info.dropPosition - Number(dropPos[dropPos.length - 1]);
-    const { children: childrenField } = unref(getFieldNames);
-    const loop = (data2, key, callback) => {
-      data2.forEach((item, index) => {
-        if (item.key === key)
-          return callback(item, index, data2);
-        if (item[childrenField])
-          return loop(item[childrenField], key, callback);
-      });
-    };
-    const data = [...treeDataRef.value];
-    let dragObj;
-    loop(data, dragKey, (item, index, arr) => {
-      arr.splice(index, 1);
-      dragObj = item;
-    });
-    if (!info.dropToGap) {
-      loop(data, dropKey, (item) => {
-        item[childrenField] = item[childrenField] || [];
-        item[childrenField].unshift(dragObj);
-      });
-    } else if ((info.node.children || []).length > 0 && info.node.expanded && dropPosition === 1) {
-      loop(data, dropKey, (item) => {
-        item[childrenField] = item[childrenField] || [];
-        item[childrenField].unshift(dragObj);
-      });
-    } else {
-      let ar = [];
-      let i = 0;
-      loop(data, dropKey, (_item, index, arr) => {
-        ar = arr;
-        i = index;
-      });
-      dropPosition === -1 ? ar.splice(i, 0, dragObj) : ar.splice(i + 1, 0, dragObj);
-    }
-    unref(props).onDrop && unref(props).onDrop({ data, info });
-    treeDataRef.value = data;
-  }
-  return {
-    getAllKeys,
-    getEnabledKeys,
-    getChildrenKeys,
-    updateNodeByKey,
-    filterByLevel,
-    insertNodeByKey,
-    insertNodesByKey,
-    deleteNodeByKey,
-    getSelectedNode,
-    onDrop
-  };
-}
-var ToolbarEnum = /* @__PURE__ */ ((ToolbarEnum2) => {
-  ToolbarEnum2[ToolbarEnum2["SELECT_ALL"] = 0] = "SELECT_ALL";
-  ToolbarEnum2[ToolbarEnum2["UN_SELECT_ALL"] = 1] = "UN_SELECT_ALL";
-  ToolbarEnum2[ToolbarEnum2["EXPAND_ALL"] = 2] = "EXPAND_ALL";
-  ToolbarEnum2[ToolbarEnum2["UN_EXPAND_ALL"] = 3] = "UN_EXPAND_ALL";
-  return ToolbarEnum2;
-})(ToolbarEnum || {});
-const _hoisted_1$1 = { class: "dt-tree-header flex px-2 py-1.5 items-center" };
-const _hoisted_2 = {
-  key: 0,
-  class: "text-center leading-8 m-0 font-normal"
-};
-const _hoisted_3 = {
-  key: 1,
-  class: "dt-tree-search flex flex-1 items-center"
-};
-const _hoisted_4 = {
-  key: 0,
-  class: "flex-1 flex items-center"
-};
-const _hoisted_5 = /* @__PURE__ */ createElementVNode("i", { class: "i ic:baseline-format-list-bulleted text-right cursor-pointer toolbar" }, null, -1);
-const _sfc_main$1 = /* @__PURE__ */ defineComponent({
-  __name: "TreeHeader",
-  props: searchProps,
-  emits: [
-    "search"
-  ],
-  setup(__props, { emit: emits }) {
-    const props = __props;
-    const slots = useSlots();
-    const { t } = useI18n("UI");
-    const searchValue = ref("");
-    function emitChange(value) {
-      emits("search", value);
-    }
-    function handleMenuClick(e) {
-      const { key } = e;
-      switch (key) {
-        case ToolbarEnum.SELECT_ALL:
-          props.checkAll?.(true);
-          break;
-        case ToolbarEnum.UN_SELECT_ALL:
-          props.checkAll?.(false);
-          break;
-        case ToolbarEnum.EXPAND_ALL:
-          props.expandAll?.(true);
-          break;
-        case ToolbarEnum.UN_EXPAND_ALL:
-          props.expandAll?.(false);
-          break;
-      }
-    }
-    const toolbarList = computed(() => {
-      const { checkable } = props;
-      const defaultToolbarList = [
-        { label: t("EXPAND_ALL"), value: ToolbarEnum.EXPAND_ALL },
-        {
-          label: t("COLLAPSE_ALL"),
-          value: ToolbarEnum.UN_EXPAND_ALL
-        }
-      ];
-      return checkable ? [
-        { label: t("SELECT_ALL1"), value: ToolbarEnum.SELECT_ALL },
-        {
-          label: t("CANCEL_SELECT_ALL"),
-          value: ToolbarEnum.UN_SELECT_ALL,
-          divider: checkable
-        },
-        ...defaultToolbarList
-      ] : defaultToolbarList;
-    });
-    const debounceEmitChange = useDebounceFn(emitChange, 200);
-    watch(
-      () => searchValue.value,
-      (v) => {
-        debounceEmitChange(v);
-      }
-    );
-    return (_ctx, _cache) => {
-      const _component_AInput = Input;
-      const _component_AMenuItem = MenuItem;
-      const _component_AMenuDivider = MenuDivider;
-      const _component_AMenu = Menu$1;
-      const _component_ADropdown = Dropdown;
-      return openBlock(), createElementBlock("div", _hoisted_1$1, [
-        _ctx.title ? (openBlock(), createElementBlock("h4", _hoisted_2, toDisplayString(_ctx.title), 1)) : createCommentVNode("", true),
-        _ctx.search || _ctx.toolbar ? (openBlock(), createElementBlock("div", _hoisted_3, [
-          _ctx.search ? (openBlock(), createElementBlock("div", _hoisted_4, [
-            unref(slots).addonBefore ? renderSlot(_ctx.$slots, "addonBefore", { key: 0 }) : createCommentVNode("", true),
-            createVNode(_component_AInput, {
-              size: "small",
-              allowClear: "",
-              value: searchValue.value,
-              "onUpdate:value": _cache[0] || (_cache[0] = ($event) => searchValue.value = $event),
-              placeholder: unref(t)("FILTER")
-            }, null, 8, ["value", "placeholder"]),
-            unref(slots).addonAfter ? renderSlot(_ctx.$slots, "addonAfter", { key: 1 }) : createCommentVNode("", true)
-          ])) : createCommentVNode("", true),
-          _ctx.toolbar ? (openBlock(), createBlock(_component_ADropdown, {
-            key: 1,
-            onClick: _cache[1] || (_cache[1] = withModifiers(() => {
-            }, ["prevent"]))
-          }, {
-            overlay: withCtx(() => [
-              createVNode(_component_AMenu, { onClick: handleMenuClick }, {
-                default: withCtx(() => [
-                  (openBlock(true), createElementBlock(Fragment, null, renderList(toolbarList.value, (item) => {
-                    return openBlock(), createElementBlock(Fragment, {
-                      key: item.value
-                    }, [
-                      createVNode(_component_AMenuItem, normalizeProps(guardReactiveProps({ key: item.value })), {
-                        default: withCtx(() => [
-                          createTextVNode(toDisplayString(item.label), 1)
-                        ]),
-                        _: 2
-                      }, 1040),
-                      item.divider ? (openBlock(), createBlock(_component_AMenuDivider, { key: 0 })) : createCommentVNode("", true)
-                    ], 64);
-                  }), 128))
-                ]),
-                _: 1
-              })
-            ]),
-            default: withCtx(() => [
-              _hoisted_5
-            ]),
-            _: 1
-          })) : createCommentVNode("", true)
-        ])) : createCommentVNode("", true)
-      ]);
-    };
-  }
-});
-const _hoisted_1 = {
-  class: "dt-tree h-full flex flex-col"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "index",
-  props: BasicProps,
-  emits: ["register", "update:expandedKeys", "update:selectedKeys", "update:value", "check", "change", "clickNode", "drop", "update:searchValue"],
-  setup(__props, {
-    emit
-  }) {
-    const props = __props;
-    const attrs = useAttrs();
-    const slots = useSlots();
-    const propsRef = ref(props);
-    const {
-      t
-    } = useI18n("UI");
-    const activeKey = ref(props.activeKey);
-    const state = reactive({
-      checkStrictly: props.checkStrictly,
-      expandedKeys: props.expandedKeys || [],
-      selectedKeys: props.selectedKeys || [],
-      checkedKeys: props.checkedKeys || []
-    });
-    const searchState = reactive({
-      startSearch: false,
-      searchText: "",
-      searchData: []
-    });
-    const treeDataRef = ref([]);
-    const getFieldNames = computed(() => {
-      const {
-        fieldNames
-      } = unref(propsRef);
-      return {
-        children: "children",
-        title: "title",
-        key: "key",
-        ...fieldNames
-      };
-    });
-    const getTreeData = computed(() => {
-      return (searchState.startSearch ? searchState.searchData : unref(treeDataRef)) ?? [];
-    });
-    const getNotFound = computed(() => {
-      return !getTreeData.value || getTreeData.value.length === 0;
-    });
-    const getIcon = (params, icon) => {
-      if (!icon) {
-        if (unref(propsRef).renderIcon && isFunction(unref(propsRef).renderIcon)) {
-          return unref(propsRef).renderIcon(params);
-        } else if (!params?.isLeaf) {
-          const svgIcon = "svg " + (state.expandedKeys.includes(params.key) ? "ui-forder-open" : "ui-forder");
-          return createVNode(Icon, {
-            "name": svgIcon,
-            "size": 22
-          }, null);
-        }
-      }
-      return createVNode("i", {
-        "class": `i ${icon}`
-      }, null);
-    };
-    const treeData = computed(() => {
-      const data = cloneDeep(getTreeData.value);
-      const {
-        title: titleField,
-        key: keyField,
-        children: childrenField
-      } = unref(getFieldNames);
-      eachTree(data, (item, _parent) => {
-        const searchText = searchState.searchText;
-        const {
-          highlight
-        } = unref(propsRef);
-        const icon = getIcon(item, item.icon);
-        const title = get(item, titleField);
-        const searchIdx = searchText ? title.indexOf(searchText) : -1;
-        const isHighlight = searchState.startSearch && !isEmpty(searchText) && highlight && searchIdx !== -1;
-        const highlightStyle = `color: ${isBoolean(highlight) ? "#f50" : highlight}`;
-        const titleDom = isHighlight ? createVNode("span", {
-          "class": "tree-content"
-        }, [createVNode("span", null, [title.substr(0, searchIdx)]), createVNode("span", {
-          "style": highlightStyle
-        }, [searchText]), createVNode("span", null, [title.substr(searchIdx + searchText.length)])]) : title;
-        item._title = item[titleField];
-        item[titleField] = createVNode("span", {
-          "class": `tree-title ${unref(activeKey) === item[keyField] ? "tree-active-node" : ""}`
-        }, [slots?.title ? getSlot(slots, "title", item) : createVNode(Fragment, null, [createVNode("span", {
-          "class": "flex items-center flex-1",
-          "onClick": handleClickNode.bind(null, item[keyField], item[childrenField], item)
-        }, [unref(getBindValues).showIcon && icon, titleDom]), createVNode("span", {
-          "class": "tree-action"
-        }, [renderAction(item)])])]);
-      }, {}, {
-        children: childrenField
-      });
-      return data;
-    });
-    const getBindValues = computed(() => {
-      let propsData = {
-        ...attrs,
-        ...props,
-        ...omit(unref(propsRef), ["onDrop"]),
-        expandedKeys: state.expandedKeys,
-        selectedKeys: state.selectedKeys,
-        checkedKeys: state.checkedKeys,
-        checkStrictly: state.checkStrictly,
-        fieldNames: unref(getFieldNames),
-        "onUpdate:expandedKeys": (v) => {
-          state.expandedKeys = v;
-          emit("update:expandedKeys", v);
-        },
-        "onUpdate:selectedKeys": (v) => {
-          state.selectedKeys = v;
-          emit("update:selectedKeys", v);
-        },
-        onCheck: (v, e) => {
-          let currentValue = toRaw(state.checkedKeys);
-          if (isArray(currentValue) && searchState.startSearch) {
-            const {
-              key
-            } = unref(getFieldNames);
-            currentValue = difference(currentValue, getChildrenKeys(e.node.$attrs.node[key]));
-            if (e.checked) {
-              currentValue.push(e.node.$attrs.node[key]);
-            }
-            state.checkedKeys = currentValue;
-          } else {
-            state.checkedKeys = v;
-          }
-          const rawVal = toRaw(state.checkedKeys);
-          emit("update:value", rawVal);
-          emit("check", rawVal, e);
-        },
-        onRightClick: handleRightClick
-      };
-      return omit(propsData, "treeData", "class");
-    });
-    const showTitle = computed(() => {
-      const {
-        title,
-        toolbar,
-        search
-      } = unref(propsRef);
-      return title || toolbar || search || slots.headerTitle;
-    });
-    function handleClickNode(key, children, node) {
-      emit("clickNode", node);
-      activeKey.value = node[unref(getFieldNames).key];
-      if (!unref(propsRef).clickRowToExpand || !children || children.length === 0) {
-        return;
-      }
-      if (!state.expandedKeys.includes(key)) {
-        setExpandedKeys([...state.expandedKeys, key]);
-      } else {
-        const keys = [...state.expandedKeys];
-        const index = keys.findIndex((item) => item === key);
-        if (index !== -1) {
-          keys.splice(index, 1);
-        }
-        setExpandedKeys(keys);
-      }
-    }
-    function renderAction(node) {
-      const {
-        action
-      } = unref(propsRef);
-      if (action && isFunction(action)) {
-        return createVNode(Fragment, null, [action(node)]);
-      }
-      return null;
-    }
-    function handleSearch(searchValue) {
-      if (searchValue !== searchState.searchText) {
-        searchState.searchText = searchValue;
-      }
-      emit("update:searchValue", searchValue);
-      if (!searchValue) {
-        searchState.startSearch = false;
-        return;
-      }
-      const {
-        filterFn,
-        expandOnSearch
-      } = unref(propsRef);
-      const {
-        title: titleField,
-        key: keyField
-      } = unref(getFieldNames);
-      const matchedKeys = [];
-      searchState.startSearch = true;
-      searchState.searchData = filter(unref(treeDataRef), (node) => {
-        const result = filterFn ? filterFn(searchValue, node, unref(getFieldNames)) : node[titleField]?.includes(searchValue) ?? false;
-        if (result) {
-          matchedKeys.push(node[keyField]);
-        }
-        return result;
-      }, unref(getFieldNames));
-      if (expandOnSearch) {
-        const expandKeys = treeToList(searchState.searchData).map((val) => {
-          return val[keyField];
-        });
-        if (expandKeys && expandKeys.length) {
-          setExpandedKeys(expandKeys);
-        }
-      }
-    }
-    const [createContextMenu] = useContextMenu();
-    async function handleRightClick({
-      event,
-      node
-    }) {
-      const {
-        rightMenuList: menuList = [],
-        beforeRightClick
-      } = unref(propsRef);
-      let contextMenuOptions = {
-        event,
-        items: [],
-        node
-      };
-      if (beforeRightClick && isFunction(beforeRightClick)) {
-        let result = await beforeRightClick(node, event);
-        if (Array.isArray(result)) {
-          contextMenuOptions.items = result;
-        } else {
-          Object.assign(contextMenuOptions, result);
-        }
-      } else {
-        contextMenuOptions.items = menuList;
-      }
-      if (!contextMenuOptions.items?.length) {
-        return;
-      }
-      contextMenuOptions.items = contextMenuOptions.items.filter((item) => !item.hidden);
-      createContextMenu(contextMenuOptions);
-    }
-    const {
-      deleteNodeByKey,
-      insertNodeByKey,
-      insertNodesByKey,
-      filterByLevel,
-      updateNodeByKey,
-      getAllKeys,
-      getChildrenKeys,
-      getEnabledKeys,
-      getSelectedNode,
-      onDrop
-    } = useMethod(treeDataRef, getFieldNames, propsRef);
-    function setExpandedKeys(keys) {
-      state.expandedKeys = keys;
-    }
-    function getExpandedKeys() {
-      return state.expandedKeys;
-    }
-    function setSelectedKeys(keys) {
-      state.selectedKeys = keys;
-    }
-    function getSelectedKeys() {
-      return state.selectedKeys;
-    }
-    function setCheckedKeys(keys) {
-      state.checkedKeys = keys;
-    }
-    function getCheckedKeys() {
-      return state.checkedKeys;
-    }
-    function checkAll(checkAll2) {
-      state.checkedKeys = checkAll2 ? getEnabledKeys() : [];
-      emit("check", state.checkedKeys);
-    }
-    function expandAll(expandAll2) {
-      state.expandedKeys = expandAll2 ? getAllKeys() : [];
-    }
-    function onStrictlyChange(strictly) {
-      state.checkStrictly = strictly;
-    }
-    const treeActionMethods = {
-      setProps,
-      setExpandedKeys,
-      getExpandedKeys,
-      setSelectedKeys,
-      getSelectedKeys,
-      setCheckedKeys,
-      getCheckedKeys,
-      insertNodeByKey,
-      insertNodesByKey,
-      deleteNodeByKey,
-      updateNodeByKey,
-      getSelectedNode,
-      checkAll,
-      expandAll,
-      onStrictlyChange,
-      filterByLevel: (level) => {
-        state.expandedKeys = filterByLevel(level);
-      },
-      setSearchValue: (value) => {
-        handleSearch(value);
-      },
-      getSearchValue: () => {
-        return searchState.searchText;
-      }
-    };
-    onMounted(() => {
-      emit("register", treeActionMethods);
-    });
-    watch(() => state.checkedKeys, () => {
-      const v = toRaw(state.checkedKeys);
-      emit("update:value", v);
-      emit("change", v);
-    });
-    function setProps(_props) {
-      const aProps = {
-        ...props,
-        ...propsRef.value,
-        ..._props
-      };
-      propsRef.value = aProps;
-      treeDataRef.value = unref(aProps.treeData);
-      handleSearch(searchState.searchText);
-      if (aProps.searchValue && aProps.searchValue !== searchState.searchText) {
-        searchState.searchText = aProps.searchValue;
-      }
-      state.checkedKeys = toRaw(aProps.value || []);
-      activeKey.value = aProps.activeKey;
-      state.expandedKeys = aProps.expandedKeys;
-      state.selectedKeys = aProps.selectedKeys;
-      state.checkedKeys = aProps.checkedKeys;
-      state.checkStrictly = aProps.checkStrictly;
-      const level = aProps.expandLevel;
-      state.expandedKeys = filterByLevel(level);
-      if (aProps.defaultExpandAll) {
-        expandAll(true);
-      }
-    }
-    return (_ctx, _cache) => {
-      const _component_ATree = Tree;
-      const _component_AEmpty = Empty;
-      const _component_ASpin = Spin;
-      return openBlock(), createElementBlock("div", _hoisted_1, [unref(showTitle) ? (openBlock(), createBlock(_sfc_main$1, {
-        key: 0,
-        title: unref(propsRef).title,
-        toolbar: unref(propsRef).toolbar,
-        search: unref(propsRef).search,
-        checkable: unref(propsRef).checkable,
-        "search-text": unref(searchState).searchText,
-        "check-all": checkAll,
-        "expand-all": expandAll,
-        onSearch: handleSearch
-      }, createSlots({
-        _: 2
-      }, [renderList(Object.keys(_ctx.$slots), (item) => {
-        return {
-          name: item,
-          fn: withCtx(() => [renderSlot(_ctx.$slots, item)])
-        };
-      })]), 1032, ["title", "toolbar", "search", "checkable", "search-text"])) : createCommentVNode("", true), createVNode(_component_ASpin, {
-        spinning: _ctx.loading,
-        tip: unref(t)("LOADING")
-      }, {
-        default: withCtx(() => [withDirectives(createElementVNode("div", null, [createVNode(_component_ATree, mergeProps(unref(getBindValues), {
-          "show-icon": false,
-          "tree-data": unref(treeData),
-          onDrop: unref(onDrop)
-        }), createSlots({
-          _: 2
-        }, [_ctx.$slots.switcherIcon ? {
-          name: "switcherIcon",
-          fn: withCtx((data) => [renderSlot(_ctx.$slots, "switcherIcon", normalizeProps(guardReactiveProps(data || {})))]),
-          key: "0"
-        } : void 0]), 1040, ["tree-data", "onDrop"])], 512), [[vShow, !unref(getNotFound)]]), withDirectives(createVNode(_component_AEmpty, null, null, 512), [[vShow, unref(getNotFound)]])]),
-        _: 3
-      }, 8, ["spinning", "tip"])]);
-    };
-  }
-});
-export {
-  _sfc_main as DtTree,
-  useTree
-};