@dt-frames/ui 2.0.1 → 2.0.3

package/es/theme/index.js

@@ -0,0 +1,3255 @@
+import { BackTop, Breadcrumb, Empty, InputSearch, Popover, Avatar, Tooltip, Select, Switch, Divider, Button, Drawer, MenuItem, SubMenu, Menu, LayoutHeader, LayoutSider, MenuDivider, Dropdown, TabPane, Tabs, LayoutContent, Layout, ConfigProvider } from "ant-design-vue/es";
+import "ant-design-vue/es/config-provider/style";
+import "ant-design-vue/es/layout/style";
+import { toRaw, unref, computed, onMounted, nextTick, defineComponent, openBlock, createBlock, createCommentVNode, createElementBlock, createElementVNode, normalizeClass, normalizeStyle, withDirectives, toDisplayString, vShow, ref, watchEffect, createVNode, withCtx, Fragment, renderList, resolveDirective, getCurrentInstance, inject, onUnmounted, h, provide, onBeforeUnmount, resolveDynamicComponent, renderSlot, mergeProps, createTextVNode, watch, normalizeProps, guardReactiveProps, resolveComponent, reactive, toRef, withModifiers, createSlots, Transition, KeepAlive } from "vue";
+import { useRouter, RouterView } from "vue-router";
+import { DtCache, CacheKey, deepMerge, Pages, useGo, useRedo, Language, isObject, useTimeoutFn, useI18n, isBoolean, localeList, changeLocale, off, on, getParentSlots, isFunction, copyText, isUrl, openWindow, isNullAndUnDef, menuList2Map, useApp, withInstall as withInstall$1 } from "@dt-frames/core";
+import { defineStore } from "pinia";
+import { trim } from "lodash-es";
+import { useDebounceFn, useFullscreen, useThrottleFn } from "@vueuse/core";
+import "ant-design-vue/es/back-top/style";
+import "ant-design-vue/es/breadcrumb/style";
+import "ant-design-vue/es/popover/style";
+import "ant-design-vue/es/input/style";
+import "ant-design-vue/es/empty/style";
+import { Popover as Popover$1, Modal, LayoutFooter } from "ant-design-vue";
+import "ant-design-vue/es/avatar/style";
+import "ant-design-vue/es/drawer/style";
+import "ant-design-vue/es/button/style";
+import "ant-design-vue/es/divider/style";
+import "ant-design-vue/es/tooltip/style";
+import "ant-design-vue/es/select/style";
+import "ant-design-vue/es/switch/style";
+import "ant-design-vue/es/menu/style";
+import "ant-design-vue/es/tabs/style";
+import "ant-design-vue/es/dropdown/style";
+import zhCN from "ant-design-vue/es/locale/zh_CN";
+import en from "ant-design-vue/es/locale/en_US";
+import require$$0 from "dayjs";
+var Theme = /* @__PURE__ */ ((Theme2) => {
+  Theme2["DARK"] = "dark";
+  Theme2["LIGHT"] = "light";
+  return Theme2;
+})(Theme || {});
+var MenuType = /* @__PURE__ */ ((MenuType2) => {
+  MenuType2["SIDE"] = "sidebar";
+  MenuType2["TOP_MENU"] = "top-menu";
+  MenuType2["MIX"] = "mix";
+  return MenuType2;
+})(MenuType || {});
+var MenuMode = /* @__PURE__ */ ((MenuMode2) => {
+  MenuMode2["INLINE"] = "inline";
+  MenuMode2["HORIZONTAL"] = "horizontal";
+  MenuMode2["VERTICAL"] = "vertical";
+  return MenuMode2;
+})(MenuMode || {});
+var ContentMode = /* @__PURE__ */ ((ContentMode2) => {
+  ContentMode2["FULL"] = "full";
+  ContentMode2["FIXED"] = "fixed";
+  return ContentMode2;
+})(ContentMode || {});
+var MenuSplitTye = /* @__PURE__ */ ((MenuSplitTye2) => {
+  MenuSplitTye2[MenuSplitTye2["NONE"] = 0] = "NONE";
+  MenuSplitTye2[MenuSplitTye2["TOP"] = 1] = "TOP";
+  MenuSplitTye2[MenuSplitTye2["LEFT"] = 2] = "LEFT";
+  return MenuSplitTye2;
+})(MenuSplitTye || {});
+var UiSize = /* @__PURE__ */ ((UiSize2) => {
+  UiSize2["LARGE"] = "large";
+  UiSize2["MIDDLE"] = "middle";
+  UiSize2["SMALL"] = "small";
+  return UiSize2;
+})(UiSize || {});
+const defaultThemeConf = {
+  content: {
+    contentMode: ContentMode.FULL
+  },
+  headOptions: {
+    fixed: true,
+    theme: Theme.LIGHT,
+    showLogo: true,
+    showBackToTop: true,
+    useLockPage: true,
+    size: UiSize.SMALL,
+    showSize: true,
+    showBreadCrumb: true,
+    showFullScreen: true,
+    showSearch: true,
+    showNotice: true,
+    showLocaleSwitch: true,
+    showSettingTheme: true,
+    showLoginOut: true
+  },
+  menuOptions: {
+    fixed: true,
+    theme: Theme.DARK,
+    collapsed: false,
+    collapsedShowTitle: false,
+    canDrag: true,
+    show: true,
+    hidden: false,
+    split: false,
+    menuWidth: 240,
+    trigger: true,
+    type: MenuType.SIDE,
+    mode: MenuMode.INLINE
+  },
+  footerOptions: {
+    show: false,
+    height: 48,
+    title: "Copyright(C) 2021 by www.ithinkdt.com. All rights reserved.",
+    subTitle: "Privacy Statement"
+  },
+  routeReuse: {
+    show: true,
+    cache: true,
+    canDrag: true,
+    showQuick: true,
+    showRedo: true,
+    showFold: true
+  }
+};
+const useThemeStore = defineStore({
+  id: "dt-theme",
+  state: () => ({
+    themeConf: DtCache.getLocal(CacheKey.THEME) ?? defaultThemeConf,
+    pageLoading: false
+  }),
+  getters: {
+    getThemeConf() {
+      return this.themeConf;
+    },
+    getHeaderConf() {
+      return this.themeConf.headOptions;
+    },
+    getMenuConf() {
+      return this.themeConf.menuOptions;
+    },
+    getFooterConf() {
+      return this.themeConf.footerOptions;
+    },
+    getRouteReuseConf() {
+      return this.themeConf.routeReuse;
+    },
+    getPageLoading() {
+      return this.pageLoading;
+    }
+  },
+  actions: {
+    setThemeConf(options = {}) {
+      let newThemeConf = deepMerge(this.themeConf, options);
+      this.themeConf = deepMerge(defaultThemeConf, newThemeConf);
+      DtCache.setLocal(CacheKey.THEME, this.themeConf);
+    }
+  }
+});
+const useRouteReuseStore = defineStore({
+  id: "route-reuse",
+  state: () => ({
+    cacheTabList: /* @__PURE__ */ new Set(),
+    tabList: DtCache.getLocal(CacheKey.THEME)?.routeReuse?.cache ? DtCache.getLocal(CacheKey.ROUTE_REUSE) || [] : [],
+    lastDragEndIndex: 0
+  }),
+  getters: {
+    getTabList() {
+      return this.tabList;
+    },
+    getCachedTabList() {
+      return Array.from(this.cacheTabList);
+    },
+    getLastDragEndIndex() {
+      return this.lastDragEndIndex;
+    }
+  },
+  actions: {
+    async addTab(route) {
+      const { path, name, fullPath, params, query, meta } = route;
+      if (path === Pages.NOT_FOUND || path === Pages.LOGIN || path === Pages.BASE_PAGE) {
+        return;
+      }
+      let updateIndex = -1;
+      const tabHasExits = this.tabList.some((tab, index) => {
+        updateIndex = index;
+        return (tab.fullPath || tab.path) === (fullPath || path);
+      });
+      if (tabHasExits) {
+        const curTab = toRaw(this.tabList)[updateIndex];
+        curTab.params = params || curTab.params;
+        curTab.query = query || curTab.query;
+        curTab.fullPath = fullPath || curTab.fullPath;
+        this.tabList.splice(updateIndex, 1, curTab);
+      } else {
+        this.tabList.push(JSON.parse(JSON.stringify(route)));
+      }
+      this.updateCacheTab();
+    },
+    closeTab(path, router) {
+      const go = useGo(router);
+      const index = this.tabList.findIndex((item) => item.path === path);
+      let page;
+      if (index === 0) {
+        if (this.tabList.length !== 1) {
+          page = this.tabList[index + 1];
+        }
+      } else {
+        page = this.tabList[index - 1];
+      }
+      this.bulkCloseTabs([path]);
+      this.updateCacheTab();
+      path === router.currentRoute.value.path && go(page.path);
+    },
+    closeAllTab(currentRoute, router) {
+      const go = useGo(router);
+      let filterTabList = this.tabList.filter((item) => item?.meta?.affix ?? false);
+      const route = filterTabList.length > 0 ? filterTabList[filterTabList.length - 1] : unref(currentRoute);
+      this.tabList = [route];
+      this.updateCacheTab();
+      go(route.path);
+    },
+    closeLeftTabs(path) {
+      const index = this.tabList.findIndex((item) => item.path === path);
+      if (index > 0) {
+        const leftTabs = this.tabList.slice(0, index);
+        const pathList = [];
+        for (const item of leftTabs) {
+          const affix = item?.meta?.affix ?? false;
+          if (!affix) {
+            pathList.push(item.fullPath);
+          }
+        }
+        this.bulkCloseTabs(pathList);
+      }
+      this.updateCacheTab();
+    },
+    closeRightTabs(path) {
+      const index = this.tabList.findIndex((item) => item.path === path);
+      if (index >= 0 && index < this.tabList.length - 1) {
+        const rightTabs = this.tabList.slice(index + 1, this.tabList.length);
+        const pathList = [];
+        for (const item of rightTabs) {
+          const affix = item?.meta?.affix ?? false;
+          if (!affix) {
+            pathList.push(item.fullPath);
+          }
+        }
+        this.bulkCloseTabs(pathList);
+      }
+      this.updateCacheTab();
+    },
+    closeOtherTabs(path) {
+      const pathList = [];
+      for (let item of this.tabList) {
+        const affix = item?.meta?.affix ?? false;
+        if (item.path !== path && !affix) {
+          pathList.push(item.path);
+        }
+      }
+      this.bulkCloseTabs(pathList);
+      this.updateCacheTab();
+    },
+    bulkCloseTabs(pathList) {
+      this.tabList = this.tabList.filter((item) => !pathList.includes(item.fullPath));
+    },
+    updateCacheTab() {
+      const cacheTab = DtCache.getLocal(CacheKey.THEME)?.routeReuse?.cache;
+      cacheTab && DtCache.setLocal(CacheKey.ROUTE_REUSE, this.tabList);
+      const cacheMap = /* @__PURE__ */ new Set();
+      for (const tab of this.tabList) {
+        if (tab.meta?.hideTab) {
+          continue;
+        }
+        const name = tab.name;
+        cacheMap.add(name);
+      }
+      this.cacheTabList = cacheMap;
+    },
+    async refreshPage(router) {
+      const findTab = this.getCachedTabList.find((item) => item === unref(router.currentRoute).name);
+      if (findTab) {
+        this.cacheTabList.delete(findTab.toString());
+      }
+      const redo = useRedo(router);
+      await redo();
+    },
+    sortTabs(oldIndex, newIndex) {
+      const currentTab = this.tabList[oldIndex];
+      this.tabList.splice(oldIndex, 1);
+      this.tabList.splice(newIndex, 0, currentTab);
+      this.lastDragEndIndex = this.lastDragEndIndex + 1;
+    }
+  }
+});
+function useMenu() {
+  const { getMenuConf, setThemeConf } = useThemeStore();
+  const getCollapsedShowTitle = computed(() => getMenuConf.collapsedShowTitle);
+  const getIsSidebarType = computed(() => getMenuConf.type === MenuType.SIDE);
+  const getMenuFixed = computed(() => getMenuConf.fixed);
+  const getShowMenu = computed(() => getMenuConf.show);
+  const getShowSidebar = computed(() => {
+    return unref(getSplit) || unref(getShowMenu) && unref(getMenuMode) !== MenuMode.HORIZONTAL;
+  });
+  const getMenuHidden = computed(() => getMenuConf.hidden);
+  const getMenuTheme = computed(() => getMenuConf.theme);
+  const getTrigger = computed(() => getMenuConf.trigger);
+  const getCanDrag = computed(() => getMenuConf.canDrag);
+  const getIsMixMode = computed(() => {
+    return unref(getMenuMode) === MenuMode.INLINE && unref(getMenuType) === MenuType.MIX;
+  });
+  const getMenuWidth = computed(() => unref(getIsMixMode) ? Number(getMenuConf.menuWidth) - 40 : getMenuConf.menuWidth);
+  const getLogoWidth = computed(() => getMenuConf.menuWidth);
+  const getMenuType = computed(() => getMenuConf.type);
+  const getIsTopMenu = computed(() => unref(getMenuType) === MenuType.TOP_MENU);
+  const getMenuMode = computed(() => getMenuConf.mode);
+  const getSplit = computed(() => getMenuConf.split);
+  const getCollapsed = computed(() => getMenuConf.collapsed);
+  const getIsHorizontal = computed(() => unref(getMenuMode) === MenuMode.HORIZONTAL);
+  const setThemeStore = (conf = {}) => setThemeConf(conf);
+  const toggleCollapsed = () => setThemeStore({
+    menuOptions: {
+      collapsed: !unref(getCollapsed)
+    }
+  });
+  const getMiniWidthNumber = computed(() => getMenuConf.collapsedShowTitle ? 80 : 48);
+  const getRealWidth = computed(() => {
+    return unref(getCollapsed) ? unref(getMiniWidthNumber) : unref(getMenuWidth);
+  });
+  const getCalcContentWidth = computed(() => {
+    const width = unref(getIsTopMenu) || !unref(getShowMenu) || unref(getSplit) && unref(getMenuHidden) ? 0 : unref(getRealWidth);
+    return `calc(100% - ${unref(width)}px)`;
+  });
+  return {
+    getCollapsedShowTitle,
+    getIsSidebarType,
+    getMenuFixed,
+    getShowMenu,
+    getShowSidebar,
+    getMenuHidden,
+    getMenuTheme,
+    getTrigger,
+    getMenuWidth,
+    getLogoWidth,
+    getMenuType,
+    getIsTopMenu,
+    getMenuMode,
+    getSplit,
+    getCollapsed,
+    getIsHorizontal,
+    getMiniWidthNumber,
+    getRealWidth,
+    getCalcContentWidth,
+    getIsMixMode,
+    getCanDrag,
+    toggleCollapsed,
+    setThemeStore
+  };
+}
+function useMultipleTab() {
+  const { getRouteReuseConf } = useThemeStore();
+  const getShowMultipleTab = computed(() => getRouteReuseConf.show);
+  const getShowQuick = computed(() => getRouteReuseConf.showQuick);
+  const getShowRedo = computed(() => getRouteReuseConf.showRedo);
+  const getCanCache = computed(() => getRouteReuseConf.cache);
+  const getCanDrag = computed(() => getRouteReuseConf.canDrag);
+  return {
+    getShowMultipleTab,
+    getShowQuick,
+    getShowRedo,
+    getCanCache,
+    getCanDrag
+  };
+}
+function useHeader() {
+  const HEADER_HEIGHT = 48;
+  const TABS_HEIGHT = 33;
+  const { getHeaderConf = {} } = useThemeStore();
+  const {
+    getIsSidebarType,
+    getMenuType,
+    getShowMenu,
+    getMenuHidden,
+    getTrigger,
+    getMenuMode,
+    getSplit,
+    getIsTopMenu,
+    getIsMixMode
+  } = useMenu();
+  const { getShowMultipleTab } = useMultipleTab();
+  const getHeaderTheme = computed(() => getHeaderConf.theme);
+  const getFixed = computed(() => getHeaderConf.fixed);
+  const getShowHeaderLogo = computed(() => unref(getShowLogo) && !unref(getIsSidebarType));
+  const getShowSearch = computed(() => getHeaderConf.showSearch);
+  const getShowHeaderTrigger = computed(() => {
+    if (unref(getMenuType) === MenuType.TOP_MENU || !unref(getShowMenu) || unref(getMenuHidden)) {
+      return false;
+    }
+    return unref(getTrigger);
+  });
+  const getShowBreadCrumb = computed(() => getHeaderConf.showBreadCrumb);
+  const getShowBread = computed(
+    () => unref(getMenuMode) !== MenuMode.HORIZONTAL && !unref(getSplit) && unref(getShowBreadCrumb)
+  );
+  const getShowTopMenu = computed(() => unref(getMenuMode) === MenuMode.HORIZONTAL || unref(getSplit));
+  const getShowNotice = computed(() => getHeaderConf.showNotice);
+  const getShowFullScreen = computed(() => getHeaderConf.showFullScreen);
+  const getShowLocale = computed(() => getHeaderConf.showLocaleSwitch);
+  const getShowSettingTheme = computed(() => getHeaderConf.showSettingTheme);
+  const getShowFullHeaderRef = computed(() => {
+    return !unref(getIsSidebarType) && !unref(getIsTopMenu);
+  });
+  const getHeaderHeight = computed(() => {
+    let height = 0;
+    height += HEADER_HEIGHT;
+    if (unref(getShowMultipleTab) && !unref(getSplit)) {
+      height += TABS_HEIGHT;
+    }
+    return height;
+  });
+  const getTabsHeight = computed(() => TABS_HEIGHT);
+  const getShowInsetHeaderRef = computed(() => {
+    return unref(getIsSidebarType) || unref(getIsTopMenu);
+  });
+  const getShowBackToTop = computed(() => getHeaderConf.showBackToTop);
+  const getIsZH = computed(() => {
+    let local = DtCache.getLocal(CacheKey.LOCALE);
+    if (!local)
+      return true;
+    return local === Language.ZH;
+  });
+  const getUiSize = computed(() => getHeaderConf?.size ?? UiSize.SMALL);
+  const getShowUiSize = computed(() => getHeaderConf?.showSize);
+  const getShowLogo = computed(() => getHeaderConf.showLogo);
+  const getShowLoginOut = computed(() => getHeaderConf.showLoginOut);
+  const loginOutClick = getHeaderConf.logoutClick;
+  return {
+    getHeaderTheme,
+    getFixed,
+    getShowSearch,
+    getShowHeaderLogo,
+    getShowHeaderTrigger,
+    getShowBread,
+    getShowTopMenu,
+    getShowFullScreen,
+    getShowLocale,
+    getShowSettingTheme,
+    getShowNotice,
+    getShowFullHeaderRef,
+    getHeaderHeight,
+    getTabsHeight,
+    getShowInsetHeaderRef,
+    getShowBackToTop,
+    getIsZH,
+    getUiSize,
+    getShowLogo,
+    getShowLoginOut,
+    getShowUiSize,
+    loginOutClick
+  };
+}
+function useTheme() {
+  const { getThemeConf, getPageLoading } = useThemeStore();
+  const getLayoutContentMode = computed(() => getThemeConf.content.contentMode);
+  const getFooter = computed(() => getThemeConf.footerOptions || {});
+  const getShowFooter = computed(() => isObject(getThemeConf.footerOptions) ? getThemeConf.footerOptions.show : true);
+  const getContentMode = computed(() => getThemeConf.content.contentMode);
+  const getOpenPageLoading = computed(() => getPageLoading);
+  return {
+    getLayoutContentMode,
+    getPageLoading,
+    getFooter,
+    getShowFooter,
+    getContentMode,
+    getOpenPageLoading
+  };
+}
+function deleteChildrenProp(menu) {
+  let obj = { ...menu };
+  delete obj.children;
+  return obj;
+}
+function getBreadCrumb(path, menus) {
+  const _menus = menus || DtCache.getLocal(CacheKey.MENUS)?.children || [];
+  let routes = [];
+  let getParentByPath = (menu, path2 = "") => {
+    if (menu.children && menu.children.length) {
+      menu.children.forEach((subMenu) => {
+        subMenu.parentMenus = [...menu.parentMenus].concat([deleteChildrenProp(subMenu)]);
+        getParentByPath(subMenu, path2);
+      });
+    }
+    if (menu.url === path2) {
+      routes = menu.parentMenus;
+    }
+  };
+  _menus.forEach((menu) => {
+    menu.parentMenus = [deleteChildrenProp(menu)];
+    getParentByPath(menu, path);
+  });
+  return routes;
+}
+function getFilterMenu(filter = "", flag = false) {
+  let _menus = [];
+  if (!trim(filter) && !flag)
+    return _menus;
+  let getTargetMenus = (menusArr) => {
+    menusArr.forEach((menu) => {
+      if (menu.children && menu.children.length) {
+        getTargetMenus(menu.children);
+      } else if (menu.label.indexOf(filter) !== -1 || flag && !trim(filter)) {
+        _menus.push(menu);
+      }
+    });
+  };
+  getTargetMenus(DtCache.getLocal(CacheKey.MENUS)?.children);
+  return _menus;
+}
+function useOpenKeys(menuState, menus, type) {
+  async function setOpenKeys(path) {
+    if (type === MenuType.TOP_MENU)
+      return;
+    useTimeoutFn(
+      () => {
+        if (menus?.length === 0) {
+          menuState.openKeys = [];
+          return;
+        }
+        const parentNodes = getBreadCrumb(path, menus);
+        menuState.openKeys = parentNodes.map((it) => it.id);
+      },
+      20,
+      true
+    );
+  }
+  const getOpenKeys = computed(() => menuState.openKeys);
+  function resetKeys() {
+    menuState.selectedKeys = [];
+    menuState.openKeys = [];
+  }
+  function handleOpenChange(openKeys) {
+    menuState.openKeys = openKeys;
+  }
+  return {
+    getOpenKeys,
+    setOpenKeys,
+    resetKeys,
+    handleOpenChange
+  };
+}
+function useDragLine(siderRef, dragBarRef) {
+  const { getMiniWidthNumber, getCollapsed, setThemeStore } = useMenu();
+  onMounted(() => {
+    nextTick(() => {
+      const exec = useDebounceFn(changeWrapWidth, 80);
+      exec();
+    });
+  });
+  function getEl(elRef) {
+    const el = unref(elRef);
+    if (!el)
+      return null;
+    if (Reflect.has(el, "$el")) {
+      return unref(elRef)?.$el;
+    }
+    return unref(elRef);
+  }
+  function handleMouseMove(ele, wrap, clientX) {
+    document.onmousemove = function(innerE) {
+      innerE = innerE || window.event;
+      let iT = ele.left + (innerE.clientX - clientX);
+      const maxT = 800;
+      const minT = unref(getMiniWidthNumber);
+      iT < 0 && (iT = 0);
+      iT > maxT && (iT = maxT);
+      iT < minT && (iT = minT);
+      ele.style.left = wrap.style.width = iT + "px";
+      return false;
+    };
+  }
+  function removeMouseup(ele) {
+    const wrap = getEl(siderRef);
+    document.onmouseup = function() {
+      document.onmousemove = null;
+      document.onmouseup = null;
+      wrap.style.transition = "width 0.2s";
+      const width = parseInt(wrap.style.width);
+      setThemeStore({
+        menuOptions: {
+          menuWidth: width
+        }
+      });
+      ele.releaseCapture?.();
+    };
+  }
+  function changeWrapWidth() {
+    const ele = getEl(dragBarRef);
+    if (!ele)
+      return;
+    const wrap = getEl(siderRef);
+    if (!wrap)
+      return;
+    ele.onmousedown = (e) => {
+      wrap.style.transition = "unset";
+      const clientX = e?.clientX;
+      ele.left = ele.offsetLeft;
+      handleMouseMove(ele, wrap, clientX);
+      removeMouseup(ele);
+      ele.setCapture?.();
+      return false;
+    };
+  }
+}
+const _sfc_main$y = /* @__PURE__ */ defineComponent({
+  __name: "back-top",
+  setup(__props) {
+    const getTarget = () => document.getElementById("dt-layout-content");
+    const { getShowBackToTop } = useHeader();
+    return (_ctx, _cache) => {
+      const _component_ABackTop = BackTop;
+      return unref(getShowBackToTop) ? (openBlock(), createBlock(_component_ABackTop, {
+        key: 0,
+        target: getTarget,
+        visibilityHeight: 300
+      })) : createCommentVNode("", true);
+    };
+  }
+});
+const _sfc_main$x = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$y);
+    };
+  }
+});
+const _sfc_main$w = /* @__PURE__ */ defineComponent({
+  __name: "fullscreen",
+  setup(__props) {
+    const { toggle, isFullscreen } = useFullscreen();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        class: "dt_header_icon text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300",
+        onClick: _cache[0] || (_cache[0] = (...args) => unref(toggle) && unref(toggle)(...args))
+      }, [
+        createElementVNode("i", {
+          class: normalizeClass(["i block", !unref(isFullscreen) ? "ic:baseline-fullscreen" : "ic:baseline-fullscreen-exit"])
+        }, null, 2)
+      ]);
+    };
+  }
+});
+const _hoisted_1$i = ["src"];
+const _sfc_main$v = /* @__PURE__ */ defineComponent({
+  __name: "logo",
+  props: {
+    theme: { type: String, validator: (v) => ["light", "dark"].includes(v) },
+    showTitle: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const { t } = useI18n("UI");
+    const title = t("COMPANY_NAME");
+    const { getLogoWidth } = useMenu();
+    const getLogoClass = computed(() => {
+      return `${props.theme} dt-logo px-2.5 text-sm flex items-center pl-2.5 cursor-pointer text-center transition-all duration-200 ease-in-out `;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(getLogoClass)),
+        style: normalizeStyle({
+          minWidth: `${unref(getLogoWidth)}px`
+        })
+      }, [
+        createElementVNode("img", { src: "/node_modules/@dt-frames/ui/es/assets/imgs/logo/logo.png" }, null, 8, _hoisted_1$i),
+        withDirectives(createElementVNode("div", { class: "dt-logo__title text-base font-bold transition-all duration-500 pl-3" }, toDisplayString(unref(title)), 513), [
+          [vShow, __props.showTitle]
+        ])
+      ], 6);
+    };
+  }
+});
+const _sfc_main$u = /* @__PURE__ */ defineComponent({
+  __name: "trigger",
+  props: { theme: String },
+  setup(__props) {
+    const props = __props;
+    const { getCollapsed, toggleCollapsed } = useMenu();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["flex w-12 h-full cursor-pointer items-center justify-center", props.theme]),
+        onClick: _cache[0] || (_cache[0] = (...args) => unref(toggleCollapsed) && unref(toggleCollapsed)(...args))
+      }, [
+        createElementVNode("i", {
+          class: normalizeClass(["i leading-none", unref(getCollapsed) ? "ic:baseline-format-indent-increase" : "ic:baseline-format-indent-decrease"])
+        }, null, 2)
+      ], 2);
+    };
+  }
+});
+const _hoisted_1$h = { class: "dt-breadcrumb" };
+const _sfc_main$t = /* @__PURE__ */ defineComponent({
+  __name: "bread-crumb",
+  setup(__props) {
+    const { getIsZH } = useHeader();
+    let routes = ref([]);
+    const { currentRoute = null } = useRouter();
+    watchEffect(() => {
+      if (!currentRoute || currentRoute.value.path === "/")
+        return;
+      routes.value = getBreadCrumb(currentRoute.value.path);
+    });
+    return (_ctx, _cache) => {
+      const _component_ABreadcrumb = Breadcrumb;
+      return openBlock(), createElementBlock("div", _hoisted_1$h, [
+        createVNode(_component_ABreadcrumb, { routes: unref(routes) }, {
+          itemRender: withCtx(({ route }) => [
+            createElementVNode("span", null, toDisplayString((unref(getIsZH) ? route.label : route.enLabel) || route.meta?.title), 1)
+          ]),
+          _: 1
+        }, 8, ["routes"])
+      ]);
+    };
+  }
+});
+const _hoisted_1$g = {
+  key: 0,
+  class: "dt-menu-filter h-7 pr-2"
+};
+const _hoisted_2$8 = ["onClick"];
+const _hoisted_3$5 = {
+  key: 0,
+  class: "flex items-center justify-center h-full overflow-hidden"
+};
+const _sfc_main$s = /* @__PURE__ */ defineComponent({
+  __name: "menu-filter",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const menuList = ref([]);
+    const router = useRouter();
+    const filter = ref("");
+    const { getShowSearch, getIsZH } = useHeader();
+    const isUseDef = computed(() => {
+      return isBoolean(getShowSearch.value);
+    });
+    function visibleChange(e) {
+      if (e) {
+        filterMenu();
+      } else {
+        filter.value = null;
+      }
+    }
+    function filterMenu() {
+      menuList.value = getFilterMenu(filter.value, true);
+    }
+    function navigation(url) {
+      router.push(url);
+      setTimeout(() => {
+        filter.value = "";
+        menuList.value = [];
+      });
+    }
+    return (_ctx, _cache) => {
+      const _component_AEmpty = Empty;
+      const _component_AInputSearch = InputSearch;
+      const _component_APopover = Popover;
+      return unref(isUseDef) ? (openBlock(), createElementBlock("div", _hoisted_1$g, [
+        createVNode(_component_APopover, {
+          placement: "bottom",
+          overlayClassName: "dt-menu-filter__popover",
+          trigger: "focus",
+          onVisibleChange: visibleChange
+        }, {
+          content: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(menuList.value, (menu) => {
+              return openBlock(), createElementBlock("p", {
+                onClick: ($event) => navigation(menu.url),
+                class: "px-5 leading-9 border-gray-200 border-dashed border-b m-0 cursor-pointer transition-all duration-300 text-13"
+              }, toDisplayString(unref(getIsZH) ? menu.label : menu.enLabel), 9, _hoisted_2$8);
+            }), 256)),
+            !menuList.value.length ? (openBlock(), createElementBlock("div", _hoisted_3$5, [
+              createVNode(_component_AEmpty, {
+                description: "\u6682\u65E0\u6570\u636E",
+                imageStyle: { width: "100%" }
+              })
+            ])) : createCommentVNode("", true)
+          ]),
+          default: withCtx(() => [
+            createVNode(_component_AInputSearch, {
+              value: filter.value,
+              "onUpdate:value": _cache[0] || (_cache[0] = ($event) => filter.value = $event),
+              placeholder: unref(t)("FILTER_MORE"),
+              onInput: filterMenu,
+              size: unref(UiSize).SMALL
+            }, null, 8, ["value", "placeholder", "size"])
+          ]),
+          _: 1
+        })
+      ])) : createCommentVNode("", true);
+    };
+  }
+});
+const _hoisted_1$f = { class: "lang m-0" };
+const _hoisted_2$7 = ["onClick"];
+const _hoisted_3$4 = {
+  class: "pr-2",
+  size: 16
+};
+const _hoisted_4$2 = /* @__PURE__ */ createElementVNode("span", { class: "dt_header_icon text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300" }, [
+  /* @__PURE__ */ createElementVNode("i", { class: "block i ic:baseline-language" })
+], -1);
+const _sfc_main$r = /* @__PURE__ */ defineComponent({
+  __name: "lang-picker",
+  props: {
+    reload: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const visible = ref(false);
+    let currentLang = DtCache.getLocal(CacheKey.LOCALE);
+    async function toggleLang(lang) {
+      visible.value = false;
+      if (lang !== currentLang) {
+        currentLang = lang;
+        await changeLocale(lang);
+        props.reload && location.reload();
+      }
+    }
+    return (_ctx, _cache) => {
+      const _component_APopover = Popover;
+      const _directive_icon = resolveDirective("icon");
+      return openBlock(), createBlock(_component_APopover, {
+        placement: "bottom",
+        visible: visible.value,
+        "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => visible.value = $event),
+        overlayClassName: "dt-lang-picker__popover",
+        trigger: "click"
+      }, {
+        content: withCtx(() => [
+          createElementVNode("ul", _hoisted_1$f, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(localeList), (it) => {
+              return openBlock(), createElementBlock("li", {
+                onClick: ($event) => toggleLang(it.event),
+                class: normalizeClass(["px-4 my-1 leading-9 flex border-gray-200 cursor-pointer hover:bg-gray-100 transition-all duration-300 text-13", it.event === unref(currentLang) ? "active bg-gray-100" : ""])
+              }, [
+                withDirectives(createElementVNode("span", _hoisted_3$4, null, 512), [
+                  [_directive_icon, it.icon]
+                ]),
+                createElementVNode("span", null, toDisplayString(it.text), 1)
+              ], 10, _hoisted_2$7);
+            }), 256))
+          ])
+        ]),
+        default: withCtx(() => [
+          _hoisted_4$2
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+const isServer = typeof window === "undefined";
+const BAR_MAP = {
+  vertical: {
+    offset: "offsetHeight",
+    scroll: "scrollTop",
+    scrollSize: "scrollHeight",
+    size: "height",
+    key: "vertical",
+    axis: "Y",
+    client: "clientY",
+    direction: "top"
+  },
+  horizontal: {
+    offset: "offsetWidth",
+    scroll: "scrollLeft",
+    scrollSize: "scrollWidth",
+    size: "width",
+    key: "horizontal",
+    axis: "X",
+    client: "clientX",
+    direction: "left"
+  }
+};
+function renderThumbStyle({ move, size, bar }) {
+  const style = {};
+  const translate = `translate${bar.axis}(${move}%)`;
+  style[bar.size] = size;
+  style.transform = translate;
+  style.msTransform = translate;
+  style.webkitTransform = translate;
+  return style;
+}
+function resizeHandler(entries) {
+  for (const entry of entries) {
+    const listeners = entry.target.__resizeListeners__ || [];
+    if (listeners.length) {
+      listeners.forEach((fn) => {
+        fn();
+      });
+    }
+  }
+}
+function addResizeListener(element, fn) {
+  if (isServer)
+    return;
+  if (!element.__resizeListeners__) {
+    element.__resizeListeners__ = [];
+    element.__ro__ = new ResizeObserver(resizeHandler);
+    element.__ro__.observe(element);
+  }
+  element.__resizeListeners__.push(fn);
+}
+function removeResizeListener(element, fn) {
+  if (!element || !element.__resizeListeners__)
+    return;
+  element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
+  if (!element.__resizeListeners__.length) {
+    element.__ro__.disconnect();
+  }
+}
+const Bar = defineComponent({
+  name: "Bar",
+  props: {
+    vertical: Boolean,
+    size: String,
+    move: Number
+  },
+  setup(props) {
+    const instance = getCurrentInstance();
+    const thumb = ref();
+    const wrap = inject("scroll-bar-wrap", {});
+    const bar = computed(() => {
+      return BAR_MAP[props.vertical ? "vertical" : "horizontal"];
+    });
+    const barStore = ref({});
+    const cursorDown = ref();
+    const clickThumbHandler = (e) => {
+      if (e.ctrlKey || e.button === 2) {
+        return;
+      }
+      window.getSelection()?.removeAllRanges();
+      startDrag(e);
+      barStore.value[bar.value.axis] = e.currentTarget[bar.value.offset] - (e[bar.value.client] - e.currentTarget.getBoundingClientRect()[bar.value.direction]);
+    };
+    const clickTrackHandler = (e) => {
+      const offset = Math.abs(
+        e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]
+      );
+      const thumbHalf = thumb.value[bar.value.offset] / 2;
+      const thumbPositionPercentage = (offset - thumbHalf) * 100 / instance?.vnode.el?.[bar.value.offset];
+      wrap.value[bar.value.scroll] = thumbPositionPercentage * wrap.value[bar.value.scrollSize] / 100;
+    };
+    const startDrag = (e) => {
+      e.stopImmediatePropagation();
+      cursorDown.value = true;
+      on(document, "mousemove", mouseMoveDocumentHandler);
+      on(document, "mouseup", mouseUpDocumentHandler);
+      document.onselectstart = () => false;
+    };
+    const mouseMoveDocumentHandler = (e) => {
+      if (cursorDown.value === false)
+        return;
+      const prevPage = barStore.value[bar.value.axis];
+      if (!prevPage)
+        return;
+      const offset = (instance?.vnode.el?.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
+      const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
+      const thumbPositionPercentage = (offset - thumbClickPosition) * 100 / instance?.vnode.el?.[bar.value.offset];
+      wrap.value[bar.value.scroll] = thumbPositionPercentage * wrap.value[bar.value.scrollSize] / 100;
+    };
+    function mouseUpDocumentHandler() {
+      cursorDown.value = false;
+      barStore.value[bar.value.axis] = 0;
+      off(document, "mousemove", mouseMoveDocumentHandler);
+      document.onselectstart = null;
+    }
+    onUnmounted(() => {
+      off(document, "mouseup", mouseUpDocumentHandler);
+    });
+    return () => h(
+      "div",
+      {
+        class: ["scrollbar__bar", "is-" + bar.value.key],
+        onMousedown: clickTrackHandler
+      },
+      h("div", {
+        ref: thumb,
+        class: "scrollbar__thumb",
+        onMousedown: clickThumbHandler,
+        style: renderThumbStyle({
+          size: props.size,
+          move: props.move,
+          bar: bar.value
+        })
+      })
+    );
+  }
+});
+const _hoisted_1$e = { class: "scrollbar relative h-full overflow-hidden" };
+const _sfc_main$q = /* @__PURE__ */ defineComponent({
+  __name: "scroll-bar",
+  props: {
+    wrapClass: {
+      type: [String, Array],
+      default: ""
+    },
+    wrapStyle: Array,
+    viewClass: {
+      type: [String, Array],
+      default: ""
+    },
+    viewStyle: {
+      type: [String, Array],
+      default: ""
+    },
+    noresize: Boolean,
+    tag: {
+      type: String,
+      default: "div"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const sizeWidth = ref("0");
+    const sizeHeight = ref("0");
+    const moveX = ref(0);
+    const moveY = ref(0);
+    const wrap = ref();
+    const resize = ref();
+    provide("scroll-bar-wrap", wrap);
+    const style = computed(() => {
+      let rsStyle = {};
+      if (Array.isArray(props.wrapStyle)) {
+        props.wrapStyle.forEach((it) => {
+          if (it)
+            rsStyle = Object.assign({}, rsStyle, it);
+        });
+      }
+      return rsStyle;
+    });
+    const handleScroll = () => {
+      moveY.value = unref(wrap).scrollTop * 100 / unref(wrap).clientHeight;
+      moveX.value = unref(wrap).scrollLeft * 100 / unref(wrap).clientWidth;
+    };
+    const update = () => {
+      if (!unref(wrap))
+        return;
+      const heightPercentage = unref(wrap).clientHeight * 100 / unref(wrap).scrollHeight;
+      const widthPercentage = unref(wrap).clientWidth * 100 / unref(wrap).scrollWidth;
+      sizeHeight.value = heightPercentage < 100 ? heightPercentage + "%" : "";
+      sizeWidth.value = widthPercentage < 100 ? widthPercentage + "%" : "";
+    };
+    onMounted(() => {
+      nextTick(update);
+      if (!props.noresize) {
+        addResizeListener(unref(resize), update);
+        addResizeListener(unref(wrap), update);
+        addEventListener("resize", update);
+      }
+    });
+    onBeforeUnmount(() => {
+      if (!props.noresize) {
+        removeResizeListener(unref(resize), update);
+        removeResizeListener(unref(wrap), update);
+        removeEventListener("resize", update);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$e, [
+        createElementVNode("div", {
+          ref_key: "wrap",
+          ref: wrap,
+          class: normalizeClass([[__props.wrapClass, "scrollbar__wrap--hidden-default"], "h-full overflow-auto"]),
+          style: normalizeStyle(unref(style)),
+          onScroll: handleScroll
+        }, [
+          (openBlock(), createBlock(resolveDynamicComponent(__props.tag), {
+            class: normalizeClass(["box-border", __props.viewClass]),
+            ref_key: "resize",
+            ref: resize,
+            style: normalizeStyle(__props.viewStyle)
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["class", "style"]))
+        ], 38),
+        createVNode(unref(Bar), {
+          move: moveX.value,
+          size: sizeWidth.value
+        }, null, 8, ["move", "size"]),
+        createVNode(unref(Bar), {
+          vertical: "",
+          move: moveY.value,
+          size: sizeHeight.value
+        }, null, 8, ["move", "size"])
+      ]);
+    };
+  }
+});
+const _sfc_main$p = /* @__PURE__ */ defineComponent({
+  __name: "scroll-container",
+  setup(__props) {
+    const scrollbarRef = ref(null);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$q, mergeProps({
+        ref_key: "scrollbarRef",
+        ref: scrollbarRef
+      }, _ctx.$attrs, { class: "w-full h-full" }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const _sfc_main$o = /* @__PURE__ */ defineComponent({
+  __name: "slot-container",
+  props: {
+    template: {
+      type: Function
+    },
+    data: {
+      type: Object
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const Container = h("div", [props.template(props.data)]);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Container));
+    };
+  }
+});
+const withInstall = (comp) => {
+  comp.install = (app) => {
+    app.component(comp.name, comp);
+  };
+  return comp;
+};
+const DtScrollContainer = withInstall(_sfc_main$p);
+const DtSlotContainer = withInstall(_sfc_main$o);
+const _hoisted_1$d = { class: "dt_header_icon text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300 relative" };
+const _sfc_main$n = /* @__PURE__ */ defineComponent({
+  __name: "notify",
+  setup(__props) {
+    const slots = getParentSlots(null, "dt-theme");
+    return (_ctx, _cache) => {
+      const _component_APopover = Popover;
+      const _directive_icon = resolveDirective("icon");
+      return openBlock(), createBlock(_component_APopover, {
+        trigger: "click",
+        overlayClassName: "dt-notify__popover"
+      }, {
+        content: withCtx(() => [
+          unref(slots).notify ? (openBlock(), createBlock(unref(DtSlotContainer), {
+            key: 0,
+            template: unref(slots).notify
+          }, null, 8, ["template"])) : createCommentVNode("", true)
+        ]),
+        default: withCtx(() => [
+          createElementVNode("span", _hoisted_1$d, [
+            withDirectives(createElementVNode("span", null, null, 512), [
+              [_directive_icon, "ant-design:bell-outlined"]
+            ]),
+            unref(slots).notifyBadge ? (openBlock(), createBlock(unref(DtSlotContainer), {
+              key: 0,
+              template: unref(slots).notifyBadge
+            }, null, 8, ["template"])) : createCommentVNode("", true)
+          ])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const _hoisted_1$c = { class: "lang m-0" };
+const _hoisted_2$6 = ["onClick"];
+const _hoisted_3$3 = /* @__PURE__ */ createElementVNode("span", { class: "dt_header_icon text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300" }, [
+  /* @__PURE__ */ createElementVNode("i", { class: "block i ic:baseline-format-size" })
+], -1);
+const _sfc_main$m = /* @__PURE__ */ defineComponent({
+  __name: "size",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const { setThemeConf } = useThemeStore();
+    const { getUiSize } = useHeader();
+    const sizeList = [
+      {
+        text: t("LARGE_SIZE"),
+        event: UiSize.LARGE
+      },
+      {
+        text: t("MIDDLE_SIZE"),
+        event: UiSize.MIDDLE
+      },
+      {
+        text: t("SMALL_SIZE"),
+        event: UiSize.SMALL
+      }
+    ];
+    const visible = ref(false);
+    async function toggleLang(size) {
+      visible.value = false;
+      setThemeConf({
+        headOptions: {
+          size
+        }
+      });
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Popover$1), {
+        placement: "bottom",
+        visible: visible.value,
+        "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => visible.value = $event),
+        overlayClassName: "dt-size__popover",
+        trigger: "click"
+      }, {
+        content: withCtx(() => [
+          createElementVNode("ul", _hoisted_1$c, [
+            (openBlock(), createElementBlock(Fragment, null, renderList(sizeList, (it) => {
+              return createElementVNode("li", {
+                onClick: ($event) => toggleLang(it.event),
+                class: normalizeClass(["px-4 my-1 leading-9 flex border-gray-200 cursor-pointer hover:bg-gray-100 transition-all duration-300 text-13", it.event === unref(getUiSize) ? "active bg-gray-100" : ""])
+              }, [
+                createElementVNode("span", null, toDisplayString(it.text), 1)
+              ], 10, _hoisted_2$6);
+            }), 64))
+          ])
+        ]),
+        default: withCtx(() => [
+          _hoisted_3$3
+        ]),
+        _: 1
+      }, 8, ["visible"]);
+    };
+  }
+});
+const _hoisted_1$b = { class: "m-0" };
+const _hoisted_2$5 = {
+  class: "pr-2",
+  size: 16
+};
+const _hoisted_3$2 = { class: "dt_header_icon h-12 text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300 flex items-center" };
+const _hoisted_4$1 = ["src"];
+const _hoisted_5 = { class: "pl-2 text-13" };
+const _sfc_main$l = /* @__PURE__ */ defineComponent({
+  __name: "user-info",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const go = useGo();
+    const { getShowLoginOut, loginOutClick } = useHeader();
+    const slots = getParentSlots(null, "dt-theme");
+    const getUserInfo = DtCache.getLocal(CacheKey.USER_INFO);
+    function signOut() {
+      if (loginOutClick && isFunction(loginOutClick)) {
+        loginOutClick();
+      } else {
+        go(Pages.LOGIN);
+      }
+    }
+    return (_ctx, _cache) => {
+      const _component_AAvatar = Avatar;
+      const _component_APopover = Popover;
+      const _directive_icon = resolveDirective("icon");
+      return openBlock(), createBlock(_component_APopover, {
+        placement: "bottom",
+        overlayClassName: "dt-user-info__popover",
+        trigger: "click"
+      }, {
+        content: withCtx(() => [
+          createElementVNode("div", _hoisted_1$b, [
+            unref(slots).userInfo ? (openBlock(), createBlock(unref(DtSlotContainer), {
+              key: 0,
+              template: unref(slots).userInfo
+            }, null, 8, ["template"])) : createCommentVNode("", true),
+            unref(getShowLoginOut) ? (openBlock(), createElementBlock("div", {
+              key: 1,
+              onClick: _cache[0] || (_cache[0] = ($event) => signOut()),
+              class: "px-4 my-1 leading-9 flex border-gray-200 cursor-pointer hover:bg-gray-100 transition-all duration-300 text-13"
+            }, [
+              withDirectives(createElementVNode("span", _hoisted_2$5, null, 512), [
+                [_directive_icon, "ant-design:logout-outlined"]
+              ]),
+              createElementVNode("span", null, toDisplayString(unref(t)("LOGIN_OUT")), 1)
+            ])) : createCommentVNode("", true)
+          ])
+        ]),
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_3$2, [
+            createVNode(_component_AAvatar, { size: 28 }, {
+              icon: withCtx(() => [
+                createElementVNode("img", { src: "/node_modules/@dt-frames/ui/es/assets/imgs/header/avatar.png" }, null, 8, _hoisted_4$1)
+              ]),
+              _: 1
+            }),
+            createElementVNode("span", _hoisted_5, toDisplayString(unref(getUserInfo)?.userNo), 1)
+          ])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+var HandlerEnum = /* @__PURE__ */ ((HandlerEnum2) => {
+  HandlerEnum2[HandlerEnum2["CHANGE_LAYOUT"] = 0] = "CHANGE_LAYOUT";
+  HandlerEnum2[HandlerEnum2["SHOW_BREADCRUMB"] = 1] = "SHOW_BREADCRUMB";
+  HandlerEnum2[HandlerEnum2["SHOW_SEARCH"] = 2] = "SHOW_SEARCH";
+  HandlerEnum2[HandlerEnum2["SHOW_SIZE"] = 3] = "SHOW_SIZE";
+  HandlerEnum2[HandlerEnum2["SHOW_NOTICY"] = 4] = "SHOW_NOTICY";
+  HandlerEnum2[HandlerEnum2["SHOW_FULL_SCREEN"] = 5] = "SHOW_FULL_SCREEN";
+  HandlerEnum2[HandlerEnum2["SHOW_LOCAL"] = 6] = "SHOW_LOCAL";
+  HandlerEnum2[HandlerEnum2["SHOW_ROUTE_REUSE"] = 7] = "SHOW_ROUTE_REUSE";
+  HandlerEnum2[HandlerEnum2["SHOW_FOOTER"] = 8] = "SHOW_FOOTER";
+  HandlerEnum2[HandlerEnum2["CONTENT_MODE"] = 9] = "CONTENT_MODE";
+  return HandlerEnum2;
+})(HandlerEnum || {});
+function changeTheme(event, value = {}) {
+  let conf = {};
+  switch (event) {
+    case 0:
+      const { mode, type, split, headTheme, menuTheme } = value;
+      conf = {
+        headOptions: {
+          theme: headTheme
+        },
+        menuOptions: {
+          mode,
+          type,
+          split,
+          theme: menuTheme,
+          show: true
+        }
+      };
+      break;
+    case 1:
+      conf = {
+        headOptions: {
+          showBreadCrumb: value
+        }
+      };
+      break;
+    case 2:
+      conf = {
+        headOptions: {
+          showSearch: value
+        }
+      };
+      break;
+    case 4:
+      conf = {
+        headOptions: {
+          showNotice: value
+        }
+      };
+      break;
+    case 3:
+      conf = {
+        headOptions: {
+          showSize: value
+        }
+      };
+      break;
+    case 5:
+      conf = {
+        headOptions: {
+          showFullScreen: value
+        }
+      };
+      break;
+    case 6:
+      conf = {
+        headOptions: {
+          showLocaleSwitch: value
+        }
+      };
+      break;
+    case 7:
+      conf = {
+        routeReuse: {
+          show: value
+        }
+      };
+      break;
+    case 8:
+      conf = {
+        footerOptions: {
+          show: value
+        }
+      };
+      break;
+    case 9:
+      conf = {
+        content: {
+          contentMode: value
+        }
+      };
+      break;
+  }
+  useThemeStore().setThemeConf(conf);
+}
+const _hoisted_1$a = { class: "flex flex-row justify-center dt-menu-type" };
+const _hoisted_2$4 = ["onClick"];
+const _hoisted_3$1 = /* @__PURE__ */ createElementVNode("div", { class: "dt-menu-type__item" }, null, -1);
+const _hoisted_4 = [
+  _hoisted_3$1
+];
+const _sfc_main$k = /* @__PURE__ */ defineComponent({
+  __name: "menu-type",
+  setup(__props) {
+    const { getMenuType, getMenuMode } = useMenu();
+    const menuTypeList = [
+      {
+        title: "\u5DE6\u4FA7\u83DC\u5355\u6A21\u5F0F",
+        headTheme: Theme.LIGHT,
+        menuTheme: Theme.DARK,
+        mode: MenuMode.INLINE,
+        type: MenuType.SIDE,
+        split: false
+      },
+      {
+        title: "\u83DC\u5355\u6DF7\u5408\u6A21\u5F0F",
+        headTheme: Theme.DARK,
+        menuTheme: Theme.LIGHT,
+        mode: MenuMode.INLINE,
+        type: MenuType.MIX,
+        split: true
+      },
+      {
+        title: "\u9876\u90E8\u83DC\u5355\u6A21\u5F0F",
+        headTheme: Theme.DARK,
+        menuTheme: Theme.LIGHT,
+        mode: MenuMode.HORIZONTAL,
+        type: MenuType.TOP_MENU,
+        split: false
+      }
+    ];
+    function changeMenuType(item) {
+      changeTheme(HandlerEnum.CHANGE_LAYOUT, item);
+    }
+    return (_ctx, _cache) => {
+      const _component_ATooltip = Tooltip;
+      return openBlock(), createElementBlock("div", _hoisted_1$a, [
+        (openBlock(), createElementBlock(Fragment, null, renderList(menuTypeList, (item) => {
+          return createVNode(_component_ATooltip, {
+            key: item.title,
+            title: item.title,
+            placement: "bottom"
+          }, {
+            default: withCtx(() => [
+              createElementVNode("div", {
+                onClick: ($event) => changeMenuType(item),
+                class: normalizeClass([
+                  `dt-menu-type__list p-3 relative w-14 h-12 mr-4 overflow-hidden cursor-pointer bg-slate-100 rounded shadow-sm
+						shadow-gray-200`,
+                  `dt-menu-type__item--${item.type}`,
+                  {
+                    [`dt-menu-type__item--active`]: unref(getMenuType) === item.type && unref(getMenuMode) === item.mode
+                  }
+                ])
+              }, _hoisted_4, 10, _hoisted_2$4)
+            ]),
+            _: 2
+          }, 1032, ["title"]);
+        }), 64))
+      ]);
+    };
+  }
+});
+const _hoisted_1$9 = { class: "flex justify-between mb-5" };
+const _sfc_main$j = /* @__PURE__ */ defineComponent({
+  __name: "select",
+  props: {
+    event: { type: Number },
+    disabled: { type: Boolean },
+    title: { type: String },
+    def: { type: [String, Number] },
+    initValue: { type: [String, Number] },
+    options: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const getBindValue = computed(() => {
+      return props.def ? { value: props.def, defaultValue: props.initValue || props.def } : {};
+    });
+    function handleChange(val) {
+      props.event && changeTheme(props.event, val);
+    }
+    return (_ctx, _cache) => {
+      const _component_ASelect = Select;
+      return openBlock(), createElementBlock("div", _hoisted_1$9, [
+        createElementVNode("span", null, toDisplayString(__props.title), 1),
+        createVNode(_component_ASelect, mergeProps(unref(getBindValue), {
+          disabled: __props.disabled,
+          size: "small",
+          class: "w-32",
+          options: __props.options,
+          onChange: handleChange
+        }), null, 16, ["disabled", "options"])
+      ]);
+    };
+  }
+});
+const _hoisted_1$8 = { class: "flex justify-between mb-5" };
+const _sfc_main$i = /* @__PURE__ */ defineComponent({
+  __name: "switch",
+  props: {
+    event: {
+      type: Number
+    },
+    disabled: { type: Boolean },
+    title: { type: String },
+    def: {
+      type: Boolean
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { t } = useI18n("UI");
+    const getBindValue = computed(() => {
+      return props.def ? { checked: props.def } : {};
+    });
+    function handleChange(e) {
+      props.event && changeTheme(props.event, e);
+    }
+    return (_ctx, _cache) => {
+      const _component_ASwitch = Switch;
+      return openBlock(), createElementBlock("div", _hoisted_1$8, [
+        createElementVNode("span", null, toDisplayString(__props.title), 1),
+        createVNode(_component_ASwitch, mergeProps(unref(getBindValue), {
+          disabled: __props.disabled,
+          checkedChildren: unref(t)("ON"),
+          unCheckedChildren: unref(t)("OFF"),
+          onChange: handleChange
+        }), null, 16, ["disabled", "checkedChildren", "unCheckedChildren"])
+      ]);
+    };
+  }
+});
+const _sfc_main$h = /* @__PURE__ */ defineComponent({
+  __name: "feature",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const {
+      getShowBread,
+      getShowSearch,
+      getShowUiSize,
+      getShowNotice,
+      getShowFullScreen,
+      getShowLocale
+    } = useHeader();
+    const { getShowMultipleTab } = useMultipleTab();
+    const { getShowFooter, getContentMode } = useTheme();
+    const switchItems = [
+      {
+        title: t("BREAD_CURB"),
+        event: HandlerEnum.SHOW_BREADCRUMB,
+        def: getShowBread
+      },
+      {
+        title: t("MENU_FILTER"),
+        event: HandlerEnum.SHOW_SEARCH,
+        def: getShowSearch
+      },
+      {
+        title: t("NOTICE"),
+        event: HandlerEnum.SHOW_NOTICY,
+        def: getShowNotice
+      },
+      {
+        title: t("SIZE"),
+        event: HandlerEnum.SHOW_SIZE,
+        def: getShowUiSize
+      },
+      {
+        title: t("SHOW_FULLE"),
+        event: HandlerEnum.SHOW_FULL_SCREEN,
+        def: getShowFullScreen
+      },
+      {
+        title: t("LOCAL"),
+        event: HandlerEnum.SHOW_LOCAL,
+        def: getShowLocale
+      },
+      {
+        title: t("ROUTE_REUSE"),
+        event: HandlerEnum.SHOW_ROUTE_REUSE,
+        def: getShowMultipleTab
+      },
+      {
+        title: t("SHOW_FOOTER"),
+        event: HandlerEnum.SHOW_FOOTER,
+        def: getShowFooter
+      }
+    ];
+    const selectItems = [
+      {
+        title: t("CONTENT_FIXED_WIDTH"),
+        event: HandlerEnum.CONTENT_MODE,
+        def: getContentMode,
+        options: [
+          {
+            value: ContentMode.FULL,
+            label: t("FULL")
+          },
+          {
+            value: ContentMode.FIXED,
+            label: t("FIXED")
+          }
+        ]
+      }
+    ];
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        (openBlock(), createElementBlock(Fragment, null, renderList(switchItems, (item) => {
+          return createVNode(_sfc_main$i, {
+            key: item.title,
+            title: item.title,
+            event: item.event,
+            def: unref(item.def)
+          }, null, 8, ["title", "event", "def"]);
+        }), 64)),
+        (openBlock(), createElementBlock(Fragment, null, renderList(selectItems, (item) => {
+          return createVNode(_sfc_main$j, {
+            key: item.title,
+            title: item.title,
+            event: item.event,
+            def: unref(item.def),
+            options: item.options
+          }, null, 8, ["title", "event", "def", "options"]);
+        }), 64))
+      ], 64);
+    };
+  }
+});
+const _hoisted_1$7 = { class: "mt-5" };
+const _hoisted_2$3 = { class: "dt-setting-theme__tips p-3 text-12 bg-gray-100 rounded" };
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
+  __name: "setting-theme",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const visible = ref(false);
+    const {
+      getShowBread,
+      getShowSearch,
+      getShowUiSize,
+      getShowNotice,
+      getShowFullScreen,
+      getShowLocale
+    } = useHeader();
+    const { getShowMultipleTab } = useMultipleTab();
+    const { getShowFooter, getContentMode } = useTheme();
+    const { getMenuType, getMenuMode } = useMenu();
+    const defaultConf = getConfig();
+    function getConfig() {
+      return {
+        contentMode: unref(getContentMode),
+        menuOptions: {
+          mode: unref(getMenuMode),
+          type: unref(getMenuType),
+          split: unref(getMenuType) === MenuType.MIX ? true : false
+        },
+        headOptions: {
+          showBreadCrumb: unref(getShowBread),
+          showSearch: unref(getShowSearch),
+          notice: unref(getShowNotice),
+          showFullScreen: unref(getShowFullScreen),
+          showLocaleSwitch: unref(getShowLocale)
+        },
+        mulTabsOptions: {
+          show: unref(getShowMultipleTab)
+        },
+        footerOptions: {
+          show: unref(getShowFooter)
+        }
+      };
+    }
+    function copy() {
+      const afterUpdateConfig = getConfig();
+      let copyObj = {};
+      const isDiff = (newVal, oldVal) => newVal !== oldVal ? newVal : null;
+      const isSameObj = (val1, val2) => JSON.stringify(val1) === JSON.stringify(val2);
+      const getDiff = (target, orgTarget) => {
+        let obj = {};
+        for (let it in target) {
+          if (isDiff(target[it], orgTarget[it]) !== null) {
+            obj[it] = target[it];
+          }
+        }
+        return obj;
+      };
+      for (let it in afterUpdateConfig) {
+        if (!isSameObj(afterUpdateConfig[it], defaultConf[it])) {
+          copyObj[it] = getDiff(afterUpdateConfig[it], defaultConf[it]);
+        }
+      }
+      if (Object.keys(copyObj).length) {
+        if (copyText(JSON.stringify(copyObj).replaceAll('"', ""))) {
+          Modal.success({
+            centered: true,
+            okText: "\u786E\u5B9A",
+            title: "\u64CD\u4F5C\u6210\u529F",
+            content: "\u590D\u5236\u6210\u529F,\u8BF7\u5230 src/core/settings/theme.ts \u4E2D\u4FEE\u6539\u914D\u7F6E\uFF01"
+          });
+        }
+      } else {
+        Modal.info({
+          centered: true,
+          okText: "\u786E\u5B9A",
+          title: "\u62F7\u8D1D\u63D0\u793A",
+          content: "\u672A\u68C0\u6D4B\u5230\u4FEE\u6539\u4EFB\u4F55\u914D\u7F6E\u4FE1\u606F!"
+        });
+      }
+    }
+    function reset() {
+      useThemeStore().setThemeConf(defaultConf);
+    }
+    return (_ctx, _cache) => {
+      const _component_ADivider = Divider;
+      const _component_AButton = Button;
+      const _component_ADrawer = Drawer;
+      const _directive_icon = resolveDirective("icon");
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("span", {
+          onClick: _cache[0] || (_cache[0] = ($event) => visible.value = true),
+          class: "dt_header_icon text-lg text-gray-800 cursor-pointer px-3 hover:bg-gray-500 hover:bg-opacity-50 transition-all duration-300 relative"
+        }, [
+          withDirectives(createElementVNode("span", null, null, 512), [
+            [_directive_icon, "ant-design:setting-outlined"]
+          ])
+        ]),
+        createVNode(_component_ADrawer, {
+          visible: visible.value,
+          "onUpdate:visible": _cache[1] || (_cache[1] = ($event) => visible.value = $event),
+          title: unref(t)("PROJECT_SETTING"),
+          placement: "right",
+          width: "320"
+        }, {
+          default: withCtx(() => [
+            createVNode(_component_ADivider, null, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(unref(t)("NAV_MODE")), 1)
+              ]),
+              _: 1
+            }),
+            createVNode(unref(_sfc_main$k)),
+            createVNode(_component_ADivider, null, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(unref(t)("PAGE_SHOW")), 1)
+              ]),
+              _: 1
+            }),
+            createVNode(unref(_sfc_main$h)),
+            createVNode(_component_ADivider),
+            createElementVNode("div", _hoisted_1$7, [
+              createVNode(_component_AButton, {
+                onClick: copy,
+                class: "mb-3",
+                type: "primary",
+                block: ""
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref(t)("COPY")), 1)
+                ]),
+                _: 1
+              }),
+              createVNode(_component_AButton, {
+                onClick: reset,
+                class: "mb-3",
+                block: ""
+              }, {
+                default: withCtx(() => [
+                  createTextVNode(toDisplayString(unref(t)("RESET")), 1)
+                ]),
+                _: 1
+              })
+            ]),
+            createElementVNode("div", _hoisted_2$3, toDisplayString(unref(t)("DRAWER_TIPS")), 1)
+          ]),
+          _: 1
+        }, 8, ["visible", "title"])
+      ], 64);
+    };
+  }
+});
+function useSplitMenu(splitType) {
+  const menusRef = ref([]);
+  const { currentRoute } = useRouter();
+  const { menusMap } = getMenusMap();
+  const { getIsHorizontal, getSplit } = useMenu();
+  const throttleHandleSplitLeftMenu = useThrottleFn(handleSplitLeftMenu, 50);
+  const splitNotLeft = computed(
+    () => unref(splitType) !== MenuSplitTye.LEFT && !unref(getIsHorizontal)
+  );
+  const getSplitLeft = computed(
+    () => !unref(getSplit) || unref(splitType) !== MenuSplitTye.LEFT
+  );
+  const getSplitTop = computed(
+    () => unref(splitType) === MenuSplitTye.TOP
+  );
+  const normalType = computed(
+    () => !unref(getSplit) || unref(splitType) === MenuSplitTye.NONE
+  );
+  watch(
+    [() => unref(currentRoute)?.path, () => unref(splitType)],
+    ([path]) => {
+      if (unref(splitNotLeft))
+        return;
+      throttleHandleSplitLeftMenu(path);
+    },
+    {
+      immediate: true
+    }
+  );
+  watch(
+    () => getSplit.value,
+    () => {
+      if (unref(splitNotLeft))
+        return;
+      getMenus2();
+    }
+  );
+  function handleSplitLeftMenu(path) {
+    if (unref(getSplitLeft))
+      return;
+    menusRef.value = menusMap.filter((it) => it.includesPath.includes(path))[0]?.children;
+  }
+  async function getMenus2() {
+    if (unref(normalType)) {
+      menusRef.value = DtCache.getLocal(CacheKey.MENUS)?.children;
+      return;
+    }
+    if (unref(getSplitTop)) {
+      menusRef.value = await getShallowMenus();
+    }
+  }
+  getMenus2();
+  return { menusRef };
+}
+function getMenus() {
+  return DtCache.getLocal(CacheKey.MENUS)?.children;
+}
+function getFirstMenuPath(item) {
+  let isFind = false, path = "";
+  const getPath = (menu) => {
+    if (isFind)
+      return;
+    if (menu.children && menu.children.length) {
+      menu.children.forEach((node) => getPath(node));
+    } else {
+      path = menu.url;
+      isFind = true;
+    }
+  };
+  getPath(item);
+  return path;
+}
+function getMenusMap() {
+  const menus = getMenus();
+  const menusMap = [];
+  const getPaths = (menu, path) => {
+    if (menu.children && menu.children.length) {
+      menu.children.forEach((node) => getPaths(node, path));
+    } else {
+      path.push(menu.url);
+    }
+    return path;
+  };
+  menus.map((item) => {
+    item.url = getFirstMenuPath(item);
+    menusMap.push({
+      parentPath: item.url,
+      children: item.children || [],
+      includesPath: getPaths(item, [])
+    });
+  });
+  return { menusMap };
+}
+function getShallowMenus() {
+  const menus = getMenus();
+  const shallowMenuList = menus.map((item) => {
+    item.url = getFirstMenuPath(item);
+    return { ...item, children: void 0 };
+  });
+  return shallowMenuList;
+}
+const BasicMenu = {
+  items: {
+    type: Array
+  },
+  collapsedShowTitle: Boolean,
+  inlineIndent: {
+    default: 20
+  },
+  mode: {
+    type: String,
+    default: MenuMode.INLINE
+  },
+  type: {
+    type: String,
+    default: MenuType.SIDE
+  },
+  theme: {
+    default: Theme.DARK
+  },
+  inlineCollapsed: Boolean,
+  isHorizontal: Boolean,
+  beforeClickFn: {
+    type: Function
+  },
+  mixSider: Boolean
+};
+const ItemProp = {
+  item: {
+    type: Object,
+    default: {}
+  },
+  theme: {
+    type: String,
+    default: Theme.DARK
+  },
+  isHorizontal: Boolean,
+  showTitle: Boolean,
+  beforeClickFn: {
+    type: Function
+  }
+};
+const contentProps = {
+  item: {
+    type: Object,
+    default: {}
+  },
+  showTitle: Boolean,
+  level: Number,
+  isHorizontal: Boolean
+};
+({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  collapse: Boolean,
+  mixSider: Boolean,
+  theme: {
+    default: Theme.DARK
+  },
+  collapsedShowTitle: Boolean,
+  beforeClickFn: {
+    type: Function
+  },
+  isSplitMenu: Boolean
+});
+const _sfc_main$f = /* @__PURE__ */ defineComponent({
+  __name: "menu-item-content",
+  props: contentProps,
+  setup(__props) {
+    const { getIsZH, getUiSize } = useHeader();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        class: normalizeClass(["dt-basic-menu-item-content-flex items-center dt-menu-item h-full", unref(getUiSize)])
+      }, [
+        createElementVNode("i", {
+          class: normalizeClass(["menu-icon i", _ctx.item.icon])
+        }, null, 2),
+        createElementVNode("span", null, toDisplayString(unref(getIsZH) ? _ctx.item.label : _ctx.item.enLabel), 1)
+      ], 2);
+    };
+  }
+});
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
+  __name: "basic-menu-item",
+  props: ItemProp,
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      const _component_AMenuItem = MenuItem;
+      return openBlock(), createBlock(_component_AMenuItem, {
+        key: _ctx.item.url
+      }, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$f, normalizeProps(guardReactiveProps(props)), null, 16)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
+  __name: "basic-sub-menu-item",
+  props: ItemProp,
+  setup(__props) {
+    const props = __props;
+    const { getShowMenu } = useMenu();
+    const {
+      theme,
+      item
+    } = props;
+    const menuHasChildren = (menu) => {
+      return !!menu.children && menu.children.length > 0;
+    };
+    return (_ctx, _cache) => {
+      const _component_BasicSubMenuItem = resolveComponent("BasicSubMenuItem", true);
+      const _component_ASubMenu = SubMenu;
+      return openBlock(), createElementBlock(Fragment, null, [
+        !menuHasChildren(unref(item)) && unref(getShowMenu) ? (openBlock(), createBlock(_sfc_main$e, normalizeProps(mergeProps({ key: 0 }, props)), null, 16)) : createCommentVNode("", true),
+        menuHasChildren(unref(item)) && unref(getShowMenu) ? (openBlock(), createBlock(_component_ASubMenu, {
+          class: normalizeClass([unref(theme)]),
+          key: unref(item).id,
+          popupClassName: "app-top-menu-popup"
+        }, {
+          title: withCtx(() => [
+            createVNode(_sfc_main$f, mergeProps(props, { item: unref(item) }), null, 16, ["item"])
+          ]),
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(item).children, (childrenItem) => {
+              return openBlock(), createBlock(_component_BasicSubMenuItem, mergeProps({
+                key: childrenItem.id
+              }, props, { item: childrenItem }), null, 16, ["item"]);
+            }), 128))
+          ]),
+          _: 1
+        }, 8, ["class"])) : createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+const _sfc_main$c = /* @__PURE__ */ defineComponent({
+  __name: "basic-menu",
+  props: BasicMenu,
+  emits: ["menuClick"],
+  setup(__props, { emit: emits }) {
+    const {
+      theme,
+      items,
+      mode,
+      type,
+      isHorizontal,
+      inlineIndent,
+      mixSider,
+      beforeClickFn
+    } = __props;
+    const { getSplit } = useMenu();
+    const { currentRoute } = useRouter();
+    const menuState = reactive({
+      defaultSelectedKeys: [],
+      openKeys: [],
+      selectedKeys: [],
+      collapsedOpenKeys: []
+    });
+    const { handleOpenChange, setOpenKeys, getOpenKeys } = useOpenKeys(
+      menuState,
+      items,
+      type
+    );
+    watch(
+      () => currentRoute.value.path,
+      (val) => {
+        if (val === "/")
+          return;
+        handleMenuChange(val);
+      },
+      {
+        immediate: true
+      }
+    );
+    async function handleMenuChange(path) {
+      setOpenKeys(path);
+      if (isHorizontal && unref(getSplit)) {
+        const parentPath = getBreadCrumb(path, items);
+        menuState.selectedKeys = [parentPath?.[0]?.url];
+      } else {
+        const parentPaths = await getBreadCrumb(path);
+        menuState.selectedKeys = parentPaths.reduce((keys, it) => {
+          it.url && keys.push(it.url);
+          return keys;
+        }, []);
+      }
+    }
+    const { getCollapsed } = useMenu();
+    const getInlineCollapsed = computed(() => {
+      const isInline = unref(mode) === MenuMode.INLINE;
+      if (isInline) {
+        return mixSider ? false : unref(getCollapsed);
+      }
+      return false;
+    });
+    async function handleMenuClick(item) {
+      if (beforeClickFn && isFunction(beforeClickFn)) {
+        const flag = await beforeClickFn(item.key);
+        if (!flag)
+          return;
+      }
+      emits("menuClick", item.key);
+      menuState.selectedKeys = [item.key];
+    }
+    return (_ctx, _cache) => {
+      const _component_AMenu = Menu;
+      return openBlock(), createBlock(_component_AMenu, {
+        theme: _ctx.theme,
+        selectedKeys: menuState.selectedKeys,
+        defaultSelectedKeys: menuState.defaultSelectedKeys,
+        openKeys: menuState.openKeys,
+        inlineIndent: _ctx.inlineIndent,
+        subMenuOpenDelay: 0.2,
+        mode: _ctx.mode,
+        collapsible: "",
+        onClick: handleMenuClick,
+        onOpenChange: unref(handleOpenChange),
+        collapsed: unref(getInlineCollapsed),
+        class: normalizeClass(unref(getSplit) ? "dt-split-menu" : "")
+      }, {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item) => {
+            return openBlock(), createBlock(_sfc_main$d, {
+              key: item.id,
+              item,
+              theme: _ctx.theme,
+              isHorizontal: _ctx.isHorizontal
+            }, null, 8, ["item", "theme", "isHorizontal"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["theme", "selectedKeys", "defaultSelectedKeys", "openKeys", "inlineIndent", "subMenuOpenDelay", "mode", "onOpenChange", "collapsed", "class"]);
+    };
+  }
+});
+const _sfc_main$b = defineComponent({
+  name: "LayoutMenu",
+  props: {
+    theme: String,
+    splitType: {
+      type: Number,
+      default: MenuSplitTye.NONE
+    },
+    isHorizontal: Boolean,
+    menuMode: String
+  },
+  setup(props) {
+    const {
+      getMenuType,
+      getMenuMode,
+      getMenuTheme,
+      getCollapsed,
+      getCollapsedShowTitle,
+      getIsHorizontal,
+      getIsSidebarType,
+      getSplit
+    } = useMenu();
+    const {
+      getShowLogo
+    } = useHeader();
+    const {
+      menusRef
+    } = useSplitMenu(toRef(props, "splitType"));
+    const slots = getParentSlots(null, "dt-theme");
+    const getComputedTheme = computed(() => props.theme || unref(getMenuTheme));
+    const getComputedMenuMode = computed(() => props.menuMode || unref(getMenuMode));
+    const getIsShowLogo = computed(() => unref(getShowLogo) && unref(getIsSidebarType));
+    const getUseScroll = computed(() => {
+      return !unref(getIsHorizontal) && (unref(getIsSidebarType) || props.splitType === MenuSplitTye.LEFT || props.splitType === MenuSplitTye.NONE);
+    });
+    const getLogoClass = computed(() => [`dt-menu-logo`, unref(getComputedTheme)]);
+    const getMenuProps = computed(() => {
+      const menus = unref(menusRef);
+      return {
+        menus,
+        beforeClickFn: beforeMenuClickFn,
+        items: menus,
+        theme: unref(getComputedTheme),
+        collapse: unref(getCollapsed),
+        collapsedShowTitle: unref(getCollapsedShowTitle),
+        onMenuClick: handleMenuClick
+      };
+    });
+    const go = useGo();
+    function beforeMenuClickFn(path) {
+      if (!isUrl(path)) {
+        return true;
+      }
+      openWindow(path);
+      return false;
+    }
+    function handleMenuClick(path) {
+      go(path);
+    }
+    function renderHeader() {
+      if (slots.logo) {
+        return createVNode(DtSlotContainer, {
+          "template": slots.logo,
+          "data": {
+            theme: unref(getComputedTheme),
+            collapsed: unref(getCollapsed)
+          }
+        }, null);
+      }
+      if (!unref(getIsShowLogo))
+        return null;
+      return createVNode(_sfc_main$v, {
+        "showTitle": !unref(getCollapsed),
+        "class": unref(getLogoClass),
+        "theme": unref(getComputedTheme)
+      }, null);
+    }
+    function renderFooter() {
+      if (unref(getMenuType) === MenuType.SIDE || unref(getMenuType) === MenuType.MIX && props.splitType === 2) {
+        return slots.menuFooter ? createVNode(DtSlotContainer, {
+          "template": slots.menuFooter,
+          "data": {
+            theme: unref(getComputedTheme),
+            collapsed: unref(getCollapsed)
+          }
+        }, null) : null;
+      }
+      return null;
+    }
+    function renderMenu() {
+      const {
+        menus,
+        ...menuProps
+      } = unref(getMenuProps);
+      if (!menus || !menus.length)
+        return null;
+      return createVNode(_sfc_main$c, mergeProps(menuProps, {
+        "isHorizontal": props.isHorizontal,
+        "type": unref(getMenuType),
+        "showLogo": unref(getIsShowLogo),
+        "mode": unref(getComputedMenuMode),
+        "items": menus
+      }), null);
+    }
+    return () => {
+      return createVNode(Fragment, null, [renderHeader(), unref(getUseScroll) ? createVNode(DtScrollContainer, null, {
+        default: () => renderMenu()
+      }) : renderMenu(), renderFooter()]);
+    };
+  }
+});
+const _hoisted_1$6 = { class: "dt-header-left flex h-full items-center" };
+const _hoisted_2$2 = {
+  key: 0,
+  class: "flex-1 h-full min-w-0 items-center"
+};
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  props: {
+    fixed: Boolean
+  },
+  setup(__props) {
+    const props = __props;
+    const { getSplit } = useMenu();
+    const {
+      getHeaderTheme,
+      getShowHeaderLogo,
+      getShowHeaderTrigger,
+      getShowBread,
+      getShowLocale,
+      getShowFullScreen,
+      getShowSettingTheme,
+      getShowNotice,
+      getShowTopMenu,
+      getShowSearch,
+      getShowUiSize
+    } = useHeader();
+    const getSplitType = computed(() => {
+      return unref(getSplit) ? MenuSplitTye.TOP : MenuSplitTye.NONE;
+    });
+    const getMenuMode = computed(() => {
+      return unref(getSplit) ? MenuMode.HORIZONTAL : null;
+    });
+    const getHeaderCls = computed(() => {
+      let theme = unref(getHeaderTheme);
+      let cls = "dt-header flex p-0 items-center justify-between ";
+      if (props.fixed) {
+        cls += "fixed top-0 left-0 w-full z-10 ";
+      }
+      cls += `dt-header--${theme}`;
+      return cls;
+    });
+    return (_ctx, _cache) => {
+      const _component_ALayoutHeader = LayoutHeader;
+      return openBlock(), createBlock(_component_ALayoutHeader, {
+        class: normalizeClass([unref(getHeaderCls), "flex items-center justify-between"])
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$6, [
+            unref(getShowHeaderLogo) ? (openBlock(), createBlock(unref(_sfc_main$v), {
+              key: 0,
+              theme: unref(getHeaderTheme),
+              class: "dt-header-logo"
+            }, null, 8, ["theme"])) : createCommentVNode("", true),
+            unref(getShowHeaderTrigger) && !unref(getSplit) ? (openBlock(), createBlock(unref(_sfc_main$u), {
+              key: 1,
+              theme: unref(getHeaderTheme)
+            }, null, 8, ["theme"])) : createCommentVNode("", true),
+            unref(getShowBread) ? (openBlock(), createBlock(unref(_sfc_main$t), { key: 2 })) : createCommentVNode("", true)
+          ]),
+          unref(getShowTopMenu) ? (openBlock(), createElementBlock("div", _hoisted_2$2, [
+            createVNode(_sfc_main$b, {
+              isHorizontal: true,
+              theme: unref(getHeaderTheme),
+              splitType: unref(getSplitType),
+              menuMode: unref(getMenuMode)
+            }, null, 8, ["theme", "splitType", "menuMode"])
+          ])) : createCommentVNode("", true),
+          createElementVNode("div", {
+            class: "dt-header-action flex items-center",
+            style: normalizeStyle({
+              "padding-right": unref(getShowSettingTheme) ? "" : "20px"
+            })
+          }, [
+            unref(getShowSearch) ? (openBlock(), createBlock(unref(_sfc_main$s), { key: 0 })) : createCommentVNode("", true),
+            unref(getShowNotice) ? (openBlock(), createBlock(unref(_sfc_main$n), { key: 1 })) : createCommentVNode("", true),
+            unref(getShowUiSize) ? (openBlock(), createBlock(unref(_sfc_main$m), { key: 2 })) : createCommentVNode("", true),
+            unref(getShowFullScreen) ? (openBlock(), createBlock(unref(_sfc_main$w), { key: 3 })) : createCommentVNode("", true),
+            unref(getShowLocale) ? (openBlock(), createBlock(unref(_sfc_main$r), {
+              key: 4,
+              reload: true
+            })) : createCommentVNode("", true),
+            createVNode(unref(_sfc_main$l)),
+            unref(getShowSettingTheme) ? (openBlock(), createBlock(unref(_sfc_main$g), { key: 5 })) : createCommentVNode("", true)
+          ], 4)
+        ]),
+        _: 1
+      }, 8, ["class"]);
+    };
+  }
+});
+function useMenuSwitch() {
+  const brokenRef = ref(false);
+  const { getMiniWidthNumber } = useMenu();
+  const getCollapsedWidth = computed(() => {
+    return unref(brokenRef) ? 0 : unref(getMiniWidthNumber);
+  });
+  function onBreakPointChange(broken) {
+    brokenRef.value = broken;
+  }
+  return { getCollapsedWidth, onBreakPointChange };
+}
+function useTrigger() {
+  const { getTrigger, getSplit } = useMenu();
+  const getShowTrigger = computed(() => {
+    const trigger = unref(getTrigger);
+    return trigger && unref(getSplit);
+  });
+  const getTriggerAttr = computed(() => {
+    if (unref(getShowTrigger)) {
+      return {};
+    }
+    return {
+      trigger: null
+    };
+  });
+  return { getTriggerAttr, getShowTrigger };
+}
+const _sfc_main$9 = /* @__PURE__ */ defineComponent({
+  __name: "sider-trigger",
+  props: {
+    type: {
+      type: String,
+      default: null
+    }
+  },
+  setup(__props) {
+    const { getCollapsed, toggleCollapsed } = useMenu();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        onClick: _cache[0] || (_cache[0] = withModifiers(
+          (...args) => unref(toggleCollapsed) && unref(toggleCollapsed)(...args),
+          ["stop"]
+        ))
+      }, [
+        createElementVNode("i", {
+          class: normalizeClass(["i", unref(getCollapsed) ? "ant-design:double-right-outlined" : "ant-design:double-left-outlined"])
+        }, null, 2)
+      ]);
+    };
+  }
+});
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
+  __name: "drag-bar",
+  setup(__props) {
+    const { getCollapsed, getCanDrag, getMenuWidth } = useMenu();
+    const getDragBarStyle = computed(() => {
+      if (!unref(getCollapsed)) {
+        return { left: `${unref(getMenuWidth)}px` };
+      }
+      return {};
+    });
+    const getClass = computed(() => {
+      return [
+        "dt-darg-bar",
+        {
+          "dt-darg-bar--hide": !unref(getCanDrag)
+        }
+      ];
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(getClass)),
+        style: normalizeStyle(unref(getDragBarStyle))
+      }, null, 6);
+    };
+  }
+});
+const _sfc_main$7 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const {
+      getMenuFixed,
+      getSplit,
+      getMenuHidden,
+      getMenuWidth,
+      getCollapsed,
+      getMenuTheme,
+      getRealWidth,
+      getIsMixMode
+    } = useMenu();
+    const {
+      getCollapsedWidth,
+      onBreakPointChange
+    } = useMenuSwitch();
+    const {
+      getTriggerAttr,
+      getShowTrigger
+    } = useTrigger();
+    const dragBarRef = ref(null);
+    const sideRef = ref(null);
+    const hiddenDomStyle = computed(() => {
+      const width = `${unref(getRealWidth)}px`;
+      return {
+        width,
+        overflow: "hidden",
+        flex: `0 0 ${width}`,
+        maxWidth: width,
+        minWidth: width,
+        transition: "all 0.2s"
+      };
+    });
+    const showClassSideBarRef = computed(() => {
+      const {
+        menusRef
+      } = useSplitMenu(getSplitType);
+      if (!unref(menusRef)?.length)
+        return false;
+      return unref(getSplit) ? !unref(getMenuHidden) : true;
+    });
+    useDragLine(sideRef, dragBarRef);
+    const getSiderClass = computed(() => {
+      let cls = `dt-sideBar overflow-hidden z-10 `;
+      if (unref(getMenuFixed)) {
+        cls += `dt-sideBar--fixed t-0 l-0 h-full `;
+      }
+      if (unref(getIsMixMode)) {
+        cls += "dt-sideBar--mix ";
+      }
+      return cls;
+    });
+    const getSplitType = computed(() => {
+      return unref(getSplit) ? MenuSplitTye.LEFT : MenuSplitTye.NONE;
+    });
+    const getMode = computed(() => {
+      return unref(getSplit) ? MenuMode.INLINE : null;
+    });
+    const renderTrigger = h(_sfc_main$9);
+    return (_ctx, _cache) => {
+      const _component_ALayoutSider = LayoutSider;
+      return openBlock(), createElementBlock(Fragment, null, [unref(getMenuFixed) ? withDirectives((openBlock(), createElementBlock("div", {
+        key: 0,
+        style: normalizeStyle(unref(hiddenDomStyle))
+      }, null, 4)), [[vShow, unref(showClassSideBarRef)]]) : createCommentVNode("", true), withDirectives(createVNode(_component_ALayoutSider, mergeProps({
+        ref_key: "sideRef",
+        ref: sideRef,
+        collapsible: "",
+        breakpoint: "lg",
+        class: unref(getSiderClass),
+        width: unref(getMenuWidth),
+        collapsed: unref(getCollapsed),
+        collapsedWidth: unref(getCollapsedWidth),
+        onBreakpoint: unref(onBreakPointChange),
+        theme: unref(getMenuTheme),
+        trigger: unref(renderTrigger)
+      }, unref(getTriggerAttr)), {
+        default: withCtx(() => [createVNode(_sfc_main$b, {
+          theme: unref(getMenuTheme),
+          menuMode: unref(getMode),
+          splitType: unref(getSplitType)
+        }, null, 8, ["theme", "menuMode", "splitType"]), createVNode(_sfc_main$8, {
+          ref_key: "dragBarRef",
+          ref: dragBarRef
+        }, null, 512)]),
+        _: 1
+      }, 16, ["class", "width", "collapsed", "collapsedWidth", "onBreakpoint", "theme", "trigger"]), [[vShow, unref(showClassSideBarRef)]])], 64);
+    };
+  }
+});
+const _hoisted_1$5 = /* @__PURE__ */ createElementVNode("i", { class: "block i ic:baseline-autorenew" }, null, -1);
+const _hoisted_2$1 = [
+  _hoisted_1$5
+];
+const _sfc_main$6 = /* @__PURE__ */ defineComponent({
+  __name: "TabRedo",
+  setup(__props) {
+    const tabStore = useRouteReuseStore();
+    const router = useRouter();
+    function handleRedo() {
+      tabStore.refreshPage(router);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        onClick: handleRedo,
+        class: "inline-block w-9 h-9 leading-9 -mt-0.5 text-zinc-600 text-center cursor-pointer border-l border-zinc-300 hover:text-zinc-900"
+      }, _hoisted_2$1);
+    };
+  }
+});
+function useTabDropdown() {
+  const router = useRouter();
+  const { currentRoute } = router;
+  const tabStore = useRouteReuseStore();
+  const state = reactive({
+    current: null,
+    currentIndex: 0
+  });
+  const getDropMenuList = computed(() => {
+    const { t } = useI18n("UI");
+    const { path, meta } = unref(currentRoute);
+    const curItem = state.current;
+    const isCurItem = curItem ? curItem.path === path : false;
+    const index = state.currentIndex;
+    const closeLeftDisabled = index === 0 || !isCurItem;
+    const disabled = tabStore.getTabList.length === 1;
+    const closeRightDisabled = !isCurItem || index === tabStore.getTabList.length - 1 && tabStore.getLastDragEndIndex >= 0;
+    const dropMenuList = [
+      {
+        icon: "ic:baseline-close",
+        text: t("CLOSE_CURRENT_TAG"),
+        onClick: () => tabStore.closeTab(path, router),
+        disabled: !!meta?.affix || disabled,
+        divider: true
+      },
+      {
+        icon: "mdi:arrow-collapse-left",
+        text: t("CLOSE_LEFT_TAGS"),
+        onClick: () => tabStore.closeLeftTabs(path),
+        disabled: closeLeftDisabled,
+        divider: false
+      },
+      {
+        icon: "mdi:arrow-collapse-right",
+        text: t("CLOSE_RIGHT_TAGS"),
+        onClick: () => tabStore.closeRightTabs(path),
+        disabled: closeRightDisabled,
+        divider: true
+      },
+      {
+        icon: "ic:baseline-sync-alt",
+        text: t("CLOSE_OTHER_TAGS"),
+        onClick: () => tabStore.closeOtherTabs(path),
+        disabled: disabled || !isCurItem
+      },
+      {
+        icon: "ic:baseline-horizontal-rule",
+        text: t("CLOSE_ALL_TAGE"),
+        onClick: () => tabStore.closeAllTab(currentRoute, router),
+        disabled
+      }
+    ];
+    return dropMenuList;
+  });
+  function handleContext(e) {
+    e?.preventDefault();
+    const { path } = unref(currentRoute);
+    const index = tabStore.getTabList.findIndex((tab) => tab.path === path);
+    state.current = unref(currentRoute);
+    state.currentIndex = index;
+  }
+  function handleMenuEvent(item) {
+    item.onClick?.();
+  }
+  return {
+    getDropMenuList,
+    handleContext,
+    handleMenuEvent
+  };
+}
+const _hoisted_1$4 = /* @__PURE__ */ createElementVNode("i", { class: "block i ic:baseline-keyboard-arrow-down" }, null, -1);
+const _hoisted_2 = [
+  _hoisted_1$4
+];
+const _hoisted_3 = { class: "text-13" };
+const _sfc_main$5 = /* @__PURE__ */ defineComponent({
+  __name: "TabContent",
+  setup(__props) {
+    const { getDropMenuList, handleContext, handleMenuEvent } = useTabDropdown();
+    return (_ctx, _cache) => {
+      const _component_AMenuItem = MenuItem;
+      const _component_AMenuDivider = MenuDivider;
+      const _component_AMenu = Menu;
+      const _component_ADropdown = Dropdown;
+      return openBlock(), createBlock(_component_ADropdown, {
+        placement: "bottomRight",
+        trigger: ["click"],
+        overlayClassName: "dt-reuse-tabs__dropdown"
+      }, {
+        overlay: withCtx(() => [
+          createVNode(_component_AMenu, null, {
+            default: withCtx(() => [
+              (openBlock(true), createElementBlock(Fragment, null, renderList(unref(getDropMenuList), (item, index) => {
+                return openBlock(), createElementBlock(Fragment, { key: index }, [
+                  createVNode(_component_AMenuItem, {
+                    onClick: ($event) => unref(handleMenuEvent)(item),
+                    disabled: item.disabled
+                  }, {
+                    default: withCtx(() => [
+                      createElementVNode("i", {
+                        class: normalizeClass(["i pr-4", item.icon])
+                      }, null, 2),
+                      createElementVNode("span", _hoisted_3, toDisplayString(item.text), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["onClick", "disabled"]),
+                  item.divider ? (openBlock(), createBlock(_component_AMenuDivider, {
+                    key: `d-${index}`
+                  })) : createCommentVNode("", true)
+                ], 64);
+              }), 128))
+            ]),
+            _: 1
+          })
+        ]),
+        default: withCtx(() => [
+          createElementVNode("span", {
+            onClick: _cache[0] || (_cache[0] = (...args) => unref(handleContext) && unref(handleContext)(...args)),
+            class: "inline-block w-9 h-9 leading-9 -mt-0.5 text-zinc-600 text-center cursor-pointer border-l border-zinc-300 hover:text-zinc-900"
+          }, _hoisted_2)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+function initAffixTabs() {
+  const affixList = ref([]);
+  const tabStore = useRouteReuseStore();
+  const router = useRouter();
+  const filterAffixTabs = (routes = []) => {
+    return routes && routes.reduce((tabs, route) => {
+      if (route.meta && route.meta.affix) {
+        tabs.push(toRaw(route));
+      }
+      return tabs;
+    }, []);
+  };
+  const addAffixTabs = () => {
+    const affixTabs = filterAffixTabs(router.getRoutes());
+    affixList.value = affixTabs;
+    for (const tab of affixTabs) {
+      tabStore.addTab({
+        meta: tab.meta,
+        name: tab.name,
+        path: tab.path
+      });
+    }
+  };
+  let isAddAffix = false;
+  if (!isAddAffix) {
+    addAffixTabs();
+    isAddAffix = true;
+  }
+  return affixList.value.map((item) => item.meta?.title).filter(Boolean);
+}
+function useSortable(el, options) {
+  function initSortable() {
+    nextTick(async () => {
+      if (!el)
+        return;
+      const Sortable = (await import("sortablejs")).default;
+      Sortable.create(unref(el), {
+        animation: 500,
+        delay: 400,
+        delayOnTouchOnly: true,
+        ...options
+      });
+    });
+  }
+  return { initSortable };
+}
+function useTabsDrag(affixList) {
+  const tabStore = useRouteReuseStore();
+  const { getCanDrag } = useMultipleTab();
+  nextTick(() => {
+    if (!unref(getCanDrag))
+      return;
+    const el = document.querySelectorAll(`.dt-reuse-tabs .ant-tabs-nav-list`)?.[0];
+    const { initSortable } = useSortable(el, {
+      filter: (e) => {
+        const text = e?.target?.innerText;
+        if (!text)
+          return false;
+        return affixList.includes(text);
+      },
+      onEnd: (evt) => {
+        const { oldIndex, newIndex } = evt;
+        if (isNullAndUnDef(oldIndex) || isNullAndUnDef(newIndex) || oldIndex === newIndex)
+          return;
+        tabStore.sortTabs(oldIndex, newIndex);
+      }
+    });
+    initSortable();
+  });
+}
+const _hoisted_1$3 = { class: "dt-reuse-tabs leading-8 border-b border-solid border-gray-200" };
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const { t } = useI18n("UI");
+    const router = useRouter();
+    const go = useGo(router);
+    const tabStore = useRouteReuseStore();
+    const { getShowQuick, getShowRedo } = useMultipleTab();
+    const menuLabelMap = menuList2Map();
+    const activeKeyRef = ref(null);
+    const getTabsState = computed(() => {
+      return tabStore.getTabList.filter((item) => !item.meta?.hideTab);
+    });
+    const unClose = computed(() => unref(getTabsState).length === 1);
+    function handleChange(activeKey) {
+      activeKeyRef.value = activeKey;
+      go(activeKey);
+    }
+    function handleEdit(targetKey) {
+      if (unref(unClose))
+        return;
+      tabStore.closeTab(targetKey, router);
+    }
+    const affixTextList = initAffixTabs();
+    useTabsDrag(affixTextList);
+    watch(
+      () => router.currentRoute.value.path,
+      (v) => {
+        if (v === "/" || v === "/login")
+          return;
+        const { meta = {} } = unref(router.currentRoute);
+        const { hideTab = false } = meta;
+        if (activeKeyRef.value !== v) {
+          activeKeyRef.value = v;
+        }
+        if (!hideTab) {
+          tabStore.addTab(unref(router.currentRoute));
+        }
+      },
+      {
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_ATabPane = TabPane;
+      const _component_ATabs = Tabs;
+      return openBlock(), createElementBlock("div", _hoisted_1$3, [
+        createVNode(_component_ATabs, {
+          type: "editable-card",
+          size: "small",
+          animated: false,
+          hideAdd: true,
+          tabBarGutter: 3,
+          activeKey: activeKeyRef.value,
+          onChange: handleChange,
+          onEdit: handleEdit,
+          class: "h-8"
+        }, createSlots({
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(getTabsState), (item) => {
+              return openBlock(), createBlock(_component_ATabPane, {
+                key: item.query ? item.fullPath : item.path,
+                closable: !(item && item.meta && item.meta.affix)
+              }, {
+                tab: withCtx(() => [
+                  createElementVNode("span", null, toDisplayString(unref(menuLabelMap).get(item.path) || unref(t)("UNKNOWN_ROUTE")), 1)
+                ]),
+                _: 2
+              }, 1032, ["closable"]);
+            }), 128))
+          ]),
+          _: 2
+        }, [
+          unref(getShowRedo) || unref(getShowQuick) ? {
+            name: "rightExtra",
+            fn: withCtx(() => [
+              unref(getShowRedo) ? (openBlock(), createBlock(unref(_sfc_main$6), { key: 0 })) : createCommentVNode("", true),
+              unref(getShowQuick) ? (openBlock(), createBlock(unref(_sfc_main$5), { key: 1 })) : createCommentVNode("", true)
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["activeKey"])
+      ]);
+    };
+  }
+});
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "multiple-header",
+  setup(__props) {
+    const {
+      getHeaderHeight,
+      getFixed,
+      getShowFullHeaderRef,
+      getHeaderTheme,
+      getShowInsetHeaderRef,
+      getTabsHeight
+    } = useHeader();
+    const { getCalcContentWidth, getIsMixMode, getIsTopMenu, getSplit } = useMenu();
+    const { getShowMultipleTab } = useMultipleTab();
+    const getPlaceholderDomStyle = computed(() => {
+      let height = unref(getHeaderHeight);
+      if (unref(getIsMixMode)) {
+        height = unref(getShowMultipleTab) ? unref(getTabsHeight) : 0;
+      }
+      return {
+        height: `${height}px`
+      };
+    });
+    const getSplitType = computed(() => {
+      return unref(getSplit) ? MenuSplitTye.LEFT : MenuSplitTye.NONE;
+    });
+    const { menusRef } = useSplitMenu(getSplitType);
+    const getWrapStyle = computed(() => {
+      const style = {};
+      if (unref(getSplit) && !unref(menusRef)?.length) {
+        style.width = "100%";
+      } else if (unref(getFixed)) {
+        style.width = unref(getCalcContentWidth);
+      }
+      if (unref(getShowFullHeaderRef))
+        style.top = "48px";
+      return style;
+    });
+    const getClass = computed(() => {
+      let cls = "transition-width duration-200 flex-auto";
+      if (unref(getFixed)) {
+        cls += " fixed top-0 right-0 w-full";
+      }
+      return cls;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", null, [
+        unref(getFixed) ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          style: normalizeStyle(unref(getPlaceholderDomStyle))
+        }, null, 4)) : createCommentVNode("", true),
+        createElementVNode("div", {
+          style: normalizeStyle(unref(getWrapStyle)),
+          class: normalizeClass(unref(getClass))
+        }, [
+          unref(getShowInsetHeaderRef) ? (openBlock(), createBlock(_sfc_main$a, { key: 0 })) : createCommentVNode("", true),
+          unref(getShowMultipleTab) ? (openBlock(), createBlock(_sfc_main$4, { key: 1 })) : createCommentVNode("", true)
+        ], 6)
+      ]);
+    };
+  }
+});
+const _hoisted_1$2 = { class: "pr-2.5" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const { getFooter } = useTheme();
+    const { title, subTitle, height } = unref(getFooter);
+    const footerOptions = computed(() => {
+      return {
+        lineHeight: `${height - 1}px`,
+        height: `${height}px`,
+        padding: "0",
+        width: `100%`,
+        color: "rgb(156,163,175)"
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(LayoutFooter), {
+        class: "text-center p-0 w-full block border-t border-gray-200",
+        style: normalizeStyle(unref(footerOptions))
+      }, {
+        default: withCtx(() => [
+          createElementVNode("span", _hoisted_1$2, toDisplayString(unref(title)), 1),
+          createElementVNode("span", null, toDisplayString(unref(subTitle)), 1)
+        ]),
+        _: 1
+      }, 8, ["style"]);
+    };
+  }
+});
+const _hoisted_1$1 = ["loading"];
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const { getTransitionMode } = useApp();
+    const { getLayoutContentMode, getPageLoading, getOpenPageLoading } = useTheme();
+    const { getCanCache } = useMultipleTab();
+    const tabStore = useRouteReuseStore();
+    function getTransitionName(route) {
+      return route.meta.transitionName || unref(getTransitionMode);
+    }
+    const getCaches = computed(() => {
+      return tabStore.getCachedTabList;
+    });
+    return (_ctx, _cache) => {
+      const _component_router_view = resolveComponent("router-view");
+      const _component_ALayoutContent = LayoutContent;
+      return openBlock(), createElementBlock("div", {
+        id: "dt-layout-content",
+        class: normalizeClass([["dt-layout-content", unref(getLayoutContentMode)], "relative flex-auto overflow-x-hidden min-h-0 flex"]),
+        loading: unref(getPageLoading) && unref(getOpenPageLoading)
+      }, [
+        createVNode(_component_ALayoutContent, null, {
+          default: withCtx(() => [
+            createVNode(_component_router_view, null, {
+              default: withCtx(({ Component, route }) => [
+                createVNode(Transition, {
+                  name: getTransitionName(route)
+                }, {
+                  default: withCtx(() => [
+                    !route.meta.hideTab && unref(getCanCache) ? (openBlock(), createBlock(KeepAlive, {
+                      key: 0,
+                      include: unref(getCaches)
+                    }, [
+                      (openBlock(), createBlock(resolveDynamicComponent(Component), {
+                        key: route.path
+                      }))
+                    ], 1032, ["include"])) : (openBlock(), createBlock(resolveDynamicComponent(Component), { key: 1 }))
+                  ]),
+                  _: 2
+                }, 1032, ["name"])
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        })
+      ], 10, _hoisted_1$1);
+    };
+  }
+});
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var zhCn = { exports: {} };
+(function(module, exports) {
+  !function(e, _) {
+    module.exports = _(require$$0);
+  }(commonjsGlobal, function(e) {
+    function _(e2) {
+      return e2 && "object" == typeof e2 && "default" in e2 ? e2 : { default: e2 };
+    }
+    var t = _(e), d = { name: "zh-cn", weekdays: "\u661F\u671F\u65E5_\u661F\u671F\u4E00_\u661F\u671F\u4E8C_\u661F\u671F\u4E09_\u661F\u671F\u56DB_\u661F\u671F\u4E94_\u661F\u671F\u516D".split("_"), weekdaysShort: "\u5468\u65E5_\u5468\u4E00_\u5468\u4E8C_\u5468\u4E09_\u5468\u56DB_\u5468\u4E94_\u5468\u516D".split("_"), weekdaysMin: "\u65E5_\u4E00_\u4E8C_\u4E09_\u56DB_\u4E94_\u516D".split("_"), months: "\u4E00\u6708_\u4E8C\u6708_\u4E09\u6708_\u56DB\u6708_\u4E94\u6708_\u516D\u6708_\u4E03\u6708_\u516B\u6708_\u4E5D\u6708_\u5341\u6708_\u5341\u4E00\u6708_\u5341\u4E8C\u6708".split("_"), monthsShort: "1\u6708_2\u6708_3\u6708_4\u6708_5\u6708_6\u6708_7\u6708_8\u6708_9\u6708_10\u6708_11\u6708_12\u6708".split("_"), ordinal: function(e2, _2) {
+      return "W" === _2 ? e2 + "\u5468" : e2 + "\u65E5";
+    }, weekStart: 1, yearStart: 4, formats: { LT: "HH:mm", LTS: "HH:mm:ss", L: "YYYY/MM/DD", LL: "YYYY\u5E74M\u6708D\u65E5", LLL: "YYYY\u5E74M\u6708D\u65E5Ah\u70B9mm\u5206", LLLL: "YYYY\u5E74M\u6708D\u65E5ddddAh\u70B9mm\u5206", l: "YYYY/M/D", ll: "YYYY\u5E74M\u6708D\u65E5", lll: "YYYY\u5E74M\u6708D\u65E5 HH:mm", llll: "YYYY\u5E74M\u6708D\u65E5dddd HH:mm" }, relativeTime: { future: "%s\u5185", past: "%s\u524D", s: "\u51E0\u79D2", m: "1 \u5206\u949F", mm: "%d \u5206\u949F", h: "1 \u5C0F\u65F6", hh: "%d \u5C0F\u65F6", d: "1 \u5929", dd: "%d \u5929", M: "1 \u4E2A\u6708", MM: "%d \u4E2A\u6708", y: "1 \u5E74", yy: "%d \u5E74" }, meridiem: function(e2, _2) {
+      var t2 = 100 * e2 + _2;
+      return t2 < 600 ? "\u51CC\u6668" : t2 < 900 ? "\u65E9\u4E0A" : t2 < 1100 ? "\u4E0A\u5348" : t2 < 1300 ? "\u4E2D\u5348" : t2 < 1800 ? "\u4E0B\u5348" : "\u665A\u4E0A";
+    } };
+    return t.default.locale(d, null, true), d;
+  });
+})(zhCn);
+var esUs = { exports: {} };
+(function(module, exports) {
+  !function(e, s) {
+    module.exports = s(require$$0);
+  }(commonjsGlobal, function(e) {
+    function s(e2) {
+      return e2 && "object" == typeof e2 && "default" in e2 ? e2 : { default: e2 };
+    }
+    var o = s(e), d = { name: "es-us", weekdays: "domingo_lunes_martes_mi\xE9rcoles_jueves_viernes_s\xE1bado".split("_"), weekdaysShort: "dom._lun._mar._mi\xE9._jue._vie._s\xE1b.".split("_"), weekdaysMin: "do_lu_ma_mi_ju_vi_s\xE1".split("_"), months: "enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre".split("_"), monthsShort: "ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic".split("_"), relativeTime: { future: "en %s", past: "hace %s", s: "unos segundos", m: "un minuto", mm: "%d minutos", h: "una hora", hh: "%d horas", d: "un d\xEDa", dd: "%d d\xEDas", M: "un mes", MM: "%d meses", y: "un a\xF1o", yy: "%d a\xF1os" }, ordinal: function(e2) {
+      return e2 + "\xBA";
+    }, formats: { LT: "h:mm A", LTS: "h:mm:ss A", L: "MM/DD/YYYY", LL: "D [de] MMMM [de] YYYY", LLL: "D [de] MMMM [de] YYYY h:mm A", LLLL: "dddd, D [de] MMMM [de] YYYY h:mm A" } };
+    return o.default.locale(d, null, true), d;
+  });
+})(esUs);
+const _hoisted_1 = { class: "dt-theme w-full h-full" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const { currentRoute } = useRouter();
+    const { getShowFullHeaderRef, getIsZH, getHeaderHeight, getUiSize } = useHeader();
+    const { getSplit, getShowMenu, getShowSidebar } = useMenu();
+    const { getFooter, getShowFooter } = useTheme();
+    const { height } = unref(getFooter);
+    require$$0.locale(unref(getIsZH) ? "zh-cn" : "en");
+    const layoutClass = computed(() => {
+      let cls = "ant-layout";
+      if (unref(getShowMenu)) {
+        cls += " flex flex-auto min-h-0 flex-row";
+      }
+      return cls;
+    });
+    const layoutOption = computed(() => {
+      if (unref(getSplit)) {
+        return {
+          paddingTop: unref(getHeaderHeight) + "px",
+          background: "#f0f2f5"
+        };
+      }
+    });
+    const getContentStyle = computed(() => {
+      return {
+        flex: unref(getSplit) ? `0 0 calc(100% -  ${unref(getShowFooter) || 0}px)` : `0 0 calc(100% - ${unref(getShowFooter) ? height : 0}px - ${unref(getHeaderHeight)}px)`,
+        overflowY: "auto"
+      };
+    });
+    return (_ctx, _cache) => {
+      const _component_ALayout = Layout;
+      const _component_AConfigProvider = ConfigProvider;
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_component_AConfigProvider, {
+          locale: unref(getIsZH) ? unref(zhCN) : unref(en),
+          "component-size": unref(getUiSize)
+        }, {
+          default: withCtx(() => [
+            unref(currentRoute)?.name && unref(currentRoute).meta?.requiresAuth !== false ? (openBlock(), createBlock(_component_ALayout, {
+              key: 0,
+              class: "w-full h-full flex"
+            }, {
+              default: withCtx(() => [
+                createVNode(_sfc_main$x),
+                unref(getShowFullHeaderRef) ? (openBlock(), createBlock(_sfc_main$a, {
+                  key: 0,
+                  fixed: ""
+                })) : createCommentVNode("", true),
+                createVNode(_component_ALayout, {
+                  class: normalizeClass(unref(layoutClass)),
+                  style: normalizeStyle(unref(layoutOption))
+                }, {
+                  default: withCtx(() => [
+                    unref(getShowSidebar) ? (openBlock(), createBlock(_sfc_main$7, { key: 0 })) : createCommentVNode("", true),
+                    createVNode(_component_ALayout, { class: "dt-theme-main flex w-full h-ful" }, {
+                      default: withCtx(() => [
+                        createVNode(_sfc_main$3),
+                        createVNode(_sfc_main$1, {
+                          style: normalizeStyle(unref(getContentStyle))
+                        }, null, 8, ["style"]),
+                        unref(getFooter) && unref(getFooter)["show"] ? (openBlock(), createBlock(_sfc_main$2, { key: 0 })) : createCommentVNode("", true)
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                }, 8, ["class", "style"])
+              ]),
+              _: 1
+            })) : (openBlock(), createBlock(unref(RouterView), { key: 1 }))
+          ]),
+          _: 1
+        }, 8, ["locale", "component-size"])
+      ]);
+    };
+  }
+});
+const EN = {
+  "UI": {
+    "ADD": "Add ",
+    "DELETE_CONFIRM": "Delete Confirm",
+    "CONFIRM_DELETE": "Confirm that you want to delete the selected data\uFF1F",
+    "NEED_CURD": "Missing curd function configuration, pass the curd parameter returned by useSource to the useCurd configuration option!",
+    "EDIT": "Edit ",
+    "EMPTY": "No Selected Data Yet!",
+    "EMPTY_URL": "Request Url Can Not Empty!",
+    "MULTIFY_DELETE_CONFIRM": "Batch Deletion Confirmation",
+    "CONFIRM_MULTIFY_DELETE": "Confirm that you want to delete the selected data in batches?",
+    "ADVANCED": "Retract",
+    "EXPAND": "Expand",
+    "SELECT_ICON": "Select Icon",
+    "MUSE_FUNCTION": "openDialog must be a fouction",
+    "NEED_RENDER": "Configure the render function",
+    "SEARCH": "Search",
+    "RESET": "Reset",
+    "PLEASE_INPUT": "Please Input",
+    "PLEASE_SELECT": "Please Select",
+    "PLEASE_SET_ICON": "Please Set The Icon",
+    "INPUT_FILTER": "Enter Filter Criteria",
+    "EXIT_FULLSCREEN": "Exit Full Screen",
+    "FULLSCREEN": "Full Screen",
+    "SAVE": "Save",
+    "CLOSE": "Close",
+    "ADD_SUCCESS": "Add Success!",
+    "UPDATE_SUCCESS": "Update data successfully!",
+    "MULTIFY": "Batch",
+    "DELETE_SUCCESS": "Successfully delete!",
+    "COLUMN_CONTROL": "Column Control",
+    "COLUMN_SHOW": "Column Show",
+    "INDEX": "Serial Number",
+    "CHECKBOX": "Checkbox",
+    "FIXED_TO_LEFT": "Fixed to the left",
+    "FIXED_TO_RIGHT": "Fixed to the right",
+    "EXPORT": "Export",
+    "EXPORT_CURRENT_PAGE": "Export the current page",
+    "EXPORT_SELECT_COLUMN": "Export Selected columns",
+    "EXPORT_ALL": "Export all columns",
+    "SELECT_ALL": "Select All",
+    "SETTING_EXPORT_COLUMN": "Setting the export column",
+    "NO_EXPORT_COLUMN": "There are no exported columns!",
+    "NUMBER": "Number",
+    "ACTIONS": "Actions",
+    "TOTAL_PAGE": "Total {total}",
+    "FILTER": "Filter",
+    "EXPAND_ALL": "Expand All",
+    "COLLAPSE_ALL": "Collapse All",
+    "SELECT_ALL1": "Select All",
+    "CANCEL_SELECT_ALL": "Cancel Select All",
+    "LEVEL_CONNECTION": "Level Connection",
+    "LEVEL_SOLATE": "Independent Hierarchy",
+    "LOADING": "Loading...",
+    "SUPPORT_FILES": "Support {message} format",
+    "MAX_SIZE": "Not exceeding {maxSize}M",
+    "MAX_NUMBER": "A maximum of {maxNumber} files can be selected",
+    "SUPPORT_TYPES": "Upload Types: pptx\u3001doc\u3001jpg\u3001jpeg\u3001png\u3001bmp\u3001gif\u3001xls\u3001xlsx\u3001txt\u3001rar\u3001zip\u30017z\u3001tar\u3001gz",
+    "FILE_UPLOAD": "Files Upload",
+    "FILE_NAME": "File Name",
+    "FILE_STATUS": "Upload Status",
+    "PREVIEW": "Preview",
+    "DELETE": "Delete",
+    "HISTORY_UPLOAD": "History Upload",
+    "MAX_MB": "Only files up to {maxSize}MB can be uploaded!",
+    "PRE_UPLOAD": "To Upload",
+    "COMPANY_NAME": "Longi Co overseas tax system",
+    "FILTER_MORE": "Menu Search...",
+    "LARGE_SIZE": "Large Size",
+    "MIDDLE_SIZE": "Middle Size",
+    "SMALL_SIZE": "Small Size",
+    "MODIFY_PASSWORD": "Modify Password",
+    "LOGIN_OUT": "Log out",
+    "CLOSE_CURRENT_TAG": "Close the current tab",
+    "CLOSE_LEFT_TAGS": "Close the left tab",
+    "CLOSE_RIGHT_TAGS": "Close the right tab",
+    "CLOSE_OTHER_TAGS": "Close other tabs",
+    "CLOSE_ALL_TAGE": "Close All",
+    "SETTING_THEME": "Style Settings",
+    "PROJECT_SETTING": "Project Configuration",
+    "NAV_MODE": "Navigation bar mode",
+    "PAGE_SHOW": "Interface Display",
+    "COPY": "Copy",
+    "DRAWER_TIPS": "The function mainly real-time preview layout effect, more complete configuration in the SRC/core/Settings/theme.ts.  The layout preview function will be turned off in production.",
+    "FULL": "Flow-based",
+    "FIXED": "Fixed width",
+    "BREAD_CURB": "Bread crumbs",
+    "MENU_FILTER": "Menu search",
+    "NOTICE": "Notification",
+    "SIZE": "Size",
+    "SHOW_FULLE": "Page full screen",
+    "LOCAL": "Internationalization",
+    "ROUTE_REUSE": "Routing reuse",
+    "SHOW_FOOTER": "Show Footer",
+    "CONTENT_FIXED_WIDTH": "Content area width",
+    "ON": "On",
+    "OFF": "Off",
+    "UNKNOWN_ROUTE": "Unknown route",
+    "COPY_SUCCESS": "Copy Success\uFF01"
+  }
+};
+const ZH = {
+  "UI": {
+    "ADD": "\u65B0\u589E",
+    "DELETE_CONFIRM": "\u5220\u9664\u786E\u8BA4",
+    "CONFIRM_DELETE": "\u786E\u8BA4\u8981\u5220\u9664\u9009\u4E2D\u7684\u6570\u636E\uFF1F",
+    "NEED_CURD": "\u7F3A\u5C11curd\u51FD\u6570\u914D\u7F6E, \u8BF7\u5C06useSource\u4E2D\u8FD4\u56DE\u7684curd\u53C2\u6570\u4F20\u5165useCurd\u914D\u7F6E\u9879\u4E2D!",
+    "EDIT": "\u7F16\u8F91",
+    "EMPTY": "\u6682\u65E0\u9009\u4E2D\u7684\u6570\u636E!",
+    "EMPTY_URL": "\u8BF7\u6C42url\u4E0D\u80FD\u4E3A\u7A7A!",
+    "MULTIFY_DELETE_CONFIRM": "\u6279\u91CF\u5220\u9664\u786E\u8BA4",
+    "CONFIRM_MULTIFY_DELETE": "\u786E\u8BA4\u8981\u6279\u91CF\u5220\u9664\u9009\u4E2D\u7684\u6570\u636E\uFF1F",
+    "ADVANCED": "\u6536\u8D77",
+    "EXPAND": "\u5C55\u5F00",
+    "SELECT_ICON": "\u9009\u62E9\u5B57\u4F53\u56FE\u6807",
+    "MUSE_FUNCTION": "openDialog\u5FC5\u987B\u662F\u51FD\u6570",
+    "NEED_RENDER": "\u8BF7\u914D\u7F6Erender\u51FD\u6570",
+    "SEARCH": "\u67E5\u8BE2",
+    "RESET": "\u91CD\u7F6E",
+    "PLEASE_INPUT": "\u8BF7\u8F93\u5165",
+    "PLEASE_SELECT": "\u8BF7\u9009\u62E9",
+    "PLEASE_SET_ICON": "\u8BF7\u8BBE\u7F6E\u56FE\u6807",
+    "INPUT_FILTER": "\u8BF7\u8F93\u5165\u8FC7\u6EE4\u6761\u4EF6",
+    "EXIT_FULLSCREEN": "\u9000\u51FA\u5168\u5C4F",
+    "FULLSCREEN": "\u5168\u5C4F",
+    "SAVE": "\u4FDD\u5B58",
+    "CLOSE": "\u5173\u95ED",
+    "ADD_SUCCESS": "\u65B0\u589E\u6210\u529F\uFF01",
+    "UPDATE_SUCCESS": "\u66F4\u65B0\u6570\u636E\u6210\u529F\uFF01",
+    "MULTIFY": "\u6279\u91CF",
+    "DELETE_SUCCESS": "\u5220\u9664\u6210\u529F\uFF01",
+    "COLUMN_CONTROL": "\u5217\u63A7\u5236",
+    "COLUMN_SHOW": "\u5217\u5C55\u793A",
+    "INDEX": "\u5E8F\u5217\u53F7",
+    "CHECKBOX": "\u590D\u9009\u6846",
+    "FIXED_TO_LEFT": "\u56FA\u5B9A\u5230\u5DE6\u4FA7",
+    "FIXED_TO_RIGHT": "\u56FA\u5B9A\u5230\u53F3\u4FA7",
+    "EXPORT": "\u5BFC\u51FA",
+    "DOWNLOAD_TEMPLATE": "\u6A21\u677F\u4E0B\u8F7D",
+    "EXPORT_CURRENT_PAGE": "\u5BFC\u51FA\u5F53\u524D\u9875",
+    "EXPORT_SELECT_COLUMN": "\u5BFC\u51FA\u9009\u4E2D\u5217",
+    "EXPORT_ALL": "\u5BFC\u51FA\u6240\u6709\u5217",
+    "SELECT_ALL": "\u5168\u9009",
+    "SETTING_EXPORT_COLUMN": "\u8BBE\u7F6E\u5BFC\u51FA\u5217",
+    "NO_EXPORT_COLUMN": "\u6682\u65E0\u53EF\u5BFC\u51FA\u7684\u5217\uFF01",
+    "NUMBER": "\u5E8F\u53F7",
+    "ACTIONS": "\u64CD\u4F5C",
+    "TOTAL_PAGE": "\u603B\u5171{total}\u6761",
+    "FILTER": "\u8FC7\u6EE4",
+    "EXPAND_ALL": "\u5C55\u5F00\u5168\u90E8",
+    "COLLAPSE_ALL": "\u6298\u53E0\u5168\u90E8",
+    "SELECT_ALL1": "\u9009\u62E9\u5168\u90E8",
+    "CANCEL_SELECT_ALL": "\u53D6\u6D88\u9009\u62E9",
+    "LEVEL_CONNECTION": "\u5C42\u7EA7\u5173\u8054",
+    "LEVEL_SOLATE": "\u5C42\u7EA7\u72EC\u7ACB",
+    "LOADING": "\u52A0\u8F7D\u4E2D...",
+    "SUPPORT_FILES": "\u652F\u6301{message}\u683C\u5F0F",
+    "MAX_SIZE": "\u4E0D\u8D85\u8FC7{maxSize}M",
+    "MAX_NUMBER": "\u6700\u591A\u53EF\u9009\u62E9{maxNumber}\u4E2A\u6587\u4EF6",
+    "SUPPORT_TYPES": "\u8BF7\u4E0A\u4F20pptx\u3001doc\u3001jpg\u3001jpeg\u3001png\u3001bmp\u3001gif\u3001xls\u3001xlsx\u3001txt\u3001rar\u3001zip\u30017z\u3001tar\u3001gz\u683C\u5F0F\u6587\u4EF6",
+    "FILE_UPLOAD": "\u6587\u4EF6\u4E0A\u4F20",
+    "FILE_NAME": "\u6587\u4EF6\u540D\u79F0",
+    "FILE_STATUS": "\u4E0A\u4F20\u72B6\u6001",
+    "PREVIEW": "\u9884\u89C8",
+    "DELETE": "\u5220\u9664",
+    "HISTORY_UPLOAD": "\u5386\u53F2\u4E0A\u4F20",
+    "MAX_MB": "\u53EA\u80FD\u4E0A\u4F20\u4E0D\u8D85\u8FC7{maxSize}MB\u7684\u6587\u4EF6!",
+    "PRE_UPLOAD": "\u5F85\u4E0A\u4F20",
+    "COMPANY_NAME": "\u5B89\u5FBD\u6DF1\u8FEA\u4E2D\u53F0\u7CFB\u7EDF\u6A21\u677F",
+    "FILTER_MORE": "\u83DC\u5355\u68C0\u7D22...",
+    "LARGE_SIZE": "\u5927\u5C3A\u5BF8",
+    "MIDDLE_SIZE": "\u4E2D\u5C3A\u5BF8",
+    "SMALL_SIZE": "\u5C0F\u5C3A\u5BF8",
+    "MODIFY_PASSWORD": "\u4FEE\u6539\u5BC6\u7801",
+    "LOGIN_OUT": "\u9000\u51FA\u7CFB\u7EDF",
+    "CLOSE_CURRENT_TAG": "\u5173\u95ED\u5F53\u524D\u6807\u7B7E\u9875",
+    "CLOSE_LEFT_TAGS": "\u5173\u95ED\u5DE6\u4FA7\u6807\u7B7E\u9875",
+    "CLOSE_RIGHT_TAGS": "\u5173\u95ED\u53F3\u4FA7\u6807\u7B7E\u9875",
+    "CLOSE_OTHER_TAGS": "\u5173\u95ED\u5176\u4ED6\u6807\u7B7E\u9875",
+    "CLOSE_ALL_TAGE": "\u5173\u95ED\u5168\u90E8\u6807\u7B7E\u9875",
+    "SETTING_THEME": "\u98CE\u683C\u8BBE\u7F6E",
+    "PROJECT_SETTING": "\u9879\u76EE\u914D\u7F6E",
+    "NAV_MODE": "\u5BFC\u822A\u680F\u6A21\u5F0F",
+    "PAGE_SHOW": "\u754C\u9762\u663E\u793A",
+    "COPY": "\u62F7\u8D1D",
+    "DRAWER_TIPS": "\u8BE5\u529F\u80FD\u4E3B\u8981\u5B9E\u65F6\u9884\u89C8\u5404\u79CD\u5E03\u5C40\u6548\u679C\uFF0C\u66F4\u591A\u5B8C\u6574\u914D\u7F6E\u5728 src/core/settings/theme.ts \u4E2D\u8BBE\u7F6E\uFF0C\u5728\u751F\u4EA7\u73AF\u5883\u8BE5\u5E03\u5C40\u9884\u89C8\u529F\u80FD\u5C06\u88AB\u5173\u95ED\u3002",
+    "FULL": "\u6D41\u5F0F",
+    "FIXED": "\u5B9A\u5BBD",
+    "BREAD_CURB": "\u9762\u5305\u5C51",
+    "MENU_FILTER": "\u83DC\u5355\u68C0\u7D22",
+    "NOTICE": "\u901A\u77E5\u516C\u544A",
+    "SIZE": "\u5143\u7D20\u5C3A\u5BF8",
+    "SHOW_FULLE": "\u9875\u9762\u5168\u5C4F",
+    "LOCAL": "\u56FD\u9645\u5316",
+    "ROUTE_REUSE": "\u8DEF\u7531\u590D\u7528",
+    "SHOW_FOOTER": "\u663E\u793A\u5E95\u90E8",
+    "CONTENT_FIXED_WIDTH": "\u5185\u5BB9\u533A\u57DF\u5BBD\u5EA6",
+    "ON": "\u5F00",
+    "OFF": "\u5173",
+    "DOWNLOAD": "\u4E0B\u8F7D",
+    "UNKNOWN_ROUTE": "\u672A\u77E5\u8DEF\u7531",
+    "COPY_SUCCESS": "\u62F7\u8D1D\u6210\u529F\uFF01"
+  }
+};
+const uiLang = (lang) => lang === Language.ZH ? ZH : EN;
+const DtTheme = withInstall$1(_sfc_main);
+export {
+  DtTheme,
+  defaultThemeConf,
+  uiLang,
+  useRouteReuseStore,
+  useThemeStore
+};