@fmdevui/fm-dev 1.0.14 → 1.0.16

package/es/core/types/router/index.d.ts

@@ -2,7 +2,7 @@ export type { RouteRecordRaw, RouteRecordSingleView, RouteRecordSingleViewWithCh
 export type RouteItem<T = any> = {
     path: string;
     name?: string | symbol | undefined | null;
-    redirect?: string;
+    redirect?: any;
     k?: T;
     meta?: {
         title?: string;
@@ -18,7 +18,7 @@ export type RouteItem<T = any> = {
         isIframeOpen?: string;
         loading?: boolean;
     };
-    children: T[];
+    children: RouteItem[];
     query?: {
         [key: string]: T;
     };

package/es/core/ui/components/editor/index.vue.d.ts

@@ -0,0 +1,52 @@
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    disable: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    height: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    getHtml: StringConstructor;
+    getText: StringConstructor;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:getHtml": (...args: any[]) => void;
+    "update:getText": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    disable: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    height: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    getHtml: StringConstructor;
+    getText: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:getHtml"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:getText"?: ((...args: any[]) => any) | undefined;
+}>, {
+    placeholder: string;
+    mode: string;
+    height: string;
+    disable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/es/make-installer.mjs

@@ -3,7 +3,13 @@ import { elSvg } from './packages/core/ui/components/svgIcon/index.mjs';
 
 const makeInstaller = (components = []) => {
   const install = (app) => {
-    components.forEach((component) => app.component(component.name, component));
+    components.forEach(
+      (component) => {
+        if (!app._context.components[component.name]) {
+          app.component(component.name, component);
+        }
+      }
+    );
     if (app)
       elSvg(app);
   };

package/es/node_modules/.pnpm/@wangeditor_editor@5.1.23/node_modules/@wangeditor/editor/dist/css/style.css.mjs

@@ -0,0 +1,3 @@
+var undefined$1 = undefined;
+
+export { undefined$1 as default };

package/es/packages/core/layout/component/aside.vue.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './aside.vue2.mjs';
+
+
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/aside.vue2.mjs

@@ -0,0 +1,171 @@
+import { defineComponent, defineAsyncComponent, ref, reactive, computed, onBeforeMount, watch, resolveComponent, withDirectives, openBlock, createElementBlock, createVNode, normalizeClass, withCtx, createBlock, createCommentVNode, unref, vShow } from 'vue';
+import { storeToRefs } from 'pinia';
+import '../../stores/index.mjs';
+import emitter from '../../utils/emit/index.mjs';
+import { useRoutesList } from '../../stores/routesList.mjs';
+import { useThemeConfig } from '../../stores/themeConfig.mjs';
+import { useTagsViewRoutes } from '../../stores/tagsViewRoutes.mjs';
+
+const _hoisted_1 = { class: "h100" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "aside",
+  setup(__props) {
+    const Logo = defineAsyncComponent(() => import('../logo/index.vue.mjs'));
+    const Vertical = defineAsyncComponent(() => import('../navMenu/vertical.vue.mjs'));
+    const layoutAsideScrollbarRef = ref();
+    const stores = useRoutesList();
+    const storesThemeConfig = useThemeConfig();
+    const storesTagsViewRoutes = useTagsViewRoutes();
+    const { routesList } = storeToRefs(stores);
+    const { themeConfig } = storeToRefs(storesThemeConfig);
+    const { isTagsViewCurrenFull } = storeToRefs(storesTagsViewRoutes);
+    const state = reactive({
+      menuList: [],
+      clientWidth: 0
+    });
+    const setCollapseStyle = computed(() => {
+      const { layout, isCollapse, menuBar } = themeConfig.value;
+      const asideBrTheme = ["#FFFFFF", "#FFF", "#fff", "#ffffff"];
+      const asideBrColor = asideBrTheme.includes(menuBar) ? "layout-el-aside-br-color" : "";
+      if (state.clientWidth <= 1e3) {
+        if (isCollapse) {
+          document.body.setAttribute("class", "el-popup-parent--hidden");
+          const asideEle = document.querySelector(".layout-container");
+          const modeDivs = document.createElement("div");
+          modeDivs.setAttribute("class", "layout-aside-mobile-mode");
+          asideEle.appendChild(modeDivs);
+          modeDivs.addEventListener("click", closeLayoutAsideMobileMode);
+          return [asideBrColor, "layout-aside-mobile", "layout-aside-mobile-open"];
+        } else {
+          closeLayoutAsideMobileMode();
+          return [asideBrColor, "layout-aside-mobile", "layout-aside-mobile-close"];
+        }
+      } else {
+        if (layout === "columns" || layout === "classic") {
+          if (isCollapse) return [asideBrColor, "layout-aside-pc-1"];
+          else return [asideBrColor, "layout-aside-pc-220"];
+        } else {
+          if (isCollapse) return [asideBrColor, "layout-aside-pc-64"];
+          else return [asideBrColor, "layout-aside-pc-220"];
+        }
+      }
+    });
+    const setShowLogo = computed(() => {
+      let { layout, isShowLogo } = themeConfig.value;
+      return isShowLogo && layout === "defaults" || isShowLogo && layout === "columns";
+    });
+    const closeLayoutAsideMobileMode = () => {
+      const el = document.querySelector(".layout-aside-mobile-mode");
+      el?.setAttribute("style", "animation: error-img-two 0.3s");
+      setTimeout(() => {
+        el?.parentNode?.removeChild(el);
+      }, 300);
+      const clientWidth = document.body.clientWidth;
+      if (clientWidth < 1e3) themeConfig.value.isCollapse = false;
+      document.body.setAttribute("class", "");
+    };
+    const setFilterRoutes = () => {
+      if (themeConfig.value.layout === "columns") return false;
+      state.menuList = filterRoutesFun(routesList.value);
+    };
+    const filterRoutesFun = (arr) => {
+      return arr.filter((item) => !item.meta?.isHide).map((item) => {
+        item = Object.assign({}, item);
+        if (item.children) item.children = filterRoutesFun(item.children);
+        return item;
+      });
+    };
+    const initMenuFixed = (clientWidth) => {
+      state.clientWidth = clientWidth;
+    };
+    const onAsideEnterLeave = (bool) => {
+      let { layout } = themeConfig.value;
+      if (layout !== "columns") return false;
+      if (!bool) emitter.emit("restoreDefault");
+      if (themeConfig.value.isColumnsMenuHoverPreload) stores.setColumnsMenuHover(bool);
+    };
+    onBeforeMount(() => {
+      initMenuFixed(document.body.clientWidth);
+      setFilterRoutes();
+      emitter.on("setSendColumnsChildren", (res) => {
+        state.menuList = res.children;
+      });
+      emitter.on("setSendClassicChildren", (res) => {
+        let { layout, isClassicSplitMenu } = themeConfig.value;
+        if (layout === "classic" && isClassicSplitMenu) {
+          res.children.length <= 1 ? themeConfig.value.isCollapse = true : themeConfig.value.isCollapse = false;
+          state.menuList = [];
+          state.menuList = res.children;
+        }
+      });
+      emitter.on("getBreadcrumbIndexSetFilterRoutes", () => {
+        setFilterRoutes();
+      });
+      emitter.on("layoutMobileResize", (res) => {
+        initMenuFixed(res.clientWidth);
+        closeLayoutAsideMobileMode();
+      });
+    });
+    watch(
+      () => [themeConfig.value.isShowLogoChange, themeConfig.value.isShowLogo, themeConfig.value.layout, themeConfig.value.isClassicSplitMenu],
+      ([isShowLogoChange, isShowLogo, layout, isClassicSplitMenu]) => {
+        if (isShowLogoChange !== isShowLogo) {
+          if (layoutAsideScrollbarRef.value) layoutAsideScrollbarRef.value.update();
+        }
+        if (layout === "classic" && isClassicSplitMenu) return false;
+      }
+    );
+    watch(
+      () => routesList.value,
+      () => {
+        setFilterRoutes();
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_el_scrollbar = resolveComponent("el-scrollbar");
+      const _component_el_aside = resolveComponent("el-aside");
+      return withDirectives((openBlock(), createElementBlock(
+        "div",
+        _hoisted_1,
+        [
+          createVNode(_component_el_aside, {
+            class: normalizeClass(["layout-aside", setCollapseStyle.value])
+          }, {
+            default: withCtx(() => [
+              setShowLogo.value ? (openBlock(), createBlock(unref(Logo), { key: 0 })) : createCommentVNode("v-if", true),
+              createVNode(
+                _component_el_scrollbar,
+                {
+                  class: "flex-auto",
+                  ref_key: "layoutAsideScrollbarRef",
+                  ref: layoutAsideScrollbarRef,
+                  onMouseenter: _cache[0] || (_cache[0] = ($event) => onAsideEnterLeave(true)),
+                  onMouseleave: _cache[1] || (_cache[1] = ($event) => onAsideEnterLeave(false))
+                },
+                {
+                  default: withCtx(() => [
+                    createVNode(unref(Vertical), {
+                      menuList: state.menuList
+                    }, null, 8, ["menuList"])
+                  ]),
+                  _: 1
+                  /* STABLE */
+                },
+                512
+                /* NEED_PATCH */
+              )
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["class"])
+        ],
+        512
+        /* NEED_PATCH */
+      )), [
+        [vShow, !unref(isTagsViewCurrenFull)]
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/columnsAside.vue.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from './columnsAside.vue2.mjs';
+import './columnsAside.vue3.mjs';
+import _export_sfc from '../../../../_virtual/_plugin-vue_export-helper.mjs';
+
+var cclaside = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-11ae0e31"]]);
+
+export { cclaside as default };

package/es/packages/core/layout/component/columnsAside.vue2.mjs

@@ -0,0 +1,270 @@
+import { defineComponent, ref, reactive, nextTick, onMounted, onUnmounted, watch, resolveComponent, createElementBlock, openBlock, createElementVNode, createVNode, unref, withCtx, Fragment, renderList, normalizeClass, toDisplayString } from 'vue';
+import { useRoute, useRouter, onBeforeRouteUpdate } from 'vue-router';
+import { storeToRefs } from 'pinia';
+import '../../stores/index.mjs';
+import emitter from '../../utils/emit/index.mjs';
+import { useRoutesList } from '../../stores/routesList.mjs';
+import { useThemeConfig } from '../../stores/themeConfig.mjs';
+
+const _hoisted_1 = { class: "layout-columns-aside" };
+const _hoisted_2 = { class: "layout-logo" };
+const _hoisted_3 = ["src"];
+const _hoisted_4 = ["onClick", "onMouseenter", "title"];
+const _hoisted_5 = { class: "columns-vertical-title font12" };
+const _hoisted_6 = ["href"];
+const _hoisted_7 = { class: "columns-vertical-title font12" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "columnsAside",
+  setup(__props) {
+    const columnsAsideOffsetTopRefs = ref([]);
+    const columnsAsideActiveRef = ref();
+    const stores = useRoutesList();
+    const storesThemeConfig = useThemeConfig();
+    const { routesList, isColumnsMenuHover, isColumnsNavHover } = storeToRefs(stores);
+    const { themeConfig } = storeToRefs(storesThemeConfig);
+    const route = useRoute();
+    const router = useRouter();
+    const state = reactive({
+      columnsAsideList: [],
+      liIndex: 0,
+      liOldIndex: null,
+      liHoverIndex: null,
+      liOldPath: null,
+      difference: 0,
+      routeSplit: []
+    });
+    const setColumnsAsideMove = (k) => {
+      if (k === void 0) return false;
+      state.liIndex = k;
+      columnsAsideActiveRef.value.style.top = `${columnsAsideOffsetTopRefs.value[k].offsetTop + state.difference}px`;
+    };
+    const onColumnsAsideMenuClick = async (v) => {
+      let { path, redirect } = v;
+      if (redirect) {
+        onColumnsAsideDown(v.k);
+        if (route.path.startsWith(redirect)) emitter.emit("setSendColumnsChildren", setSendChildren(redirect));
+        else router.push(redirect);
+      } else {
+        if (!v.children || v.children?.length === 0) {
+          router.push(path);
+          onColumnsAsideDown(v.k);
+        } else {
+          const resData = setSendChildren(path);
+          if (Object.keys(resData).length <= 0) return false;
+          onColumnsAsideDown(resData.item?.k);
+          emitter.emit("setSendColumnsChildren", resData);
+        }
+      }
+      if (!v.children || v.children?.length === 0) themeConfig.value.isCollapse = true;
+      else if (v.children.length > 1) themeConfig.value.isCollapse = false;
+    };
+    const onColumnsAsideMenuMouseenter = (v, k) => {
+      if (!themeConfig.value.isColumnsMenuHoverPreload) return false;
+      let { path } = v;
+      state.liOldPath = path;
+      state.liOldIndex = k;
+      state.liHoverIndex = k;
+      emitter.emit("setSendColumnsChildren", setSendChildren(path));
+      stores.setColumnsMenuHover(false);
+      stores.setColumnsNavHover(true);
+    };
+    const onColumnsAsideMenuMouseleave = async () => {
+      if (!themeConfig.value.isColumnsMenuHoverPreload) return false;
+      await stores.setColumnsNavHover(false);
+      setTimeout(() => {
+        if (!isColumnsMenuHover && !isColumnsNavHover) emitter.emit("restoreDefault");
+      }, 100);
+    };
+    const onColumnsAsideDown = (k) => {
+      nextTick(() => {
+        setColumnsAsideMove(k);
+      });
+    };
+    const setMenuAutoCollaps = (path) => {
+      const resData = setSendChildren(path);
+      !resData.item?.redirect && resData.children.length == 0 || resData.item?.redirect && resData.children.length <= 1 ? themeConfig.value.isCollapse = true : themeConfig.value.isCollapse = false;
+      return resData;
+    };
+    const setFilterRoutes = () => {
+      state.columnsAsideList = filterRoutesFun(routesList.value);
+      const resData = setMenuAutoCollaps(route.path);
+      onColumnsAsideDown(resData.item?.k);
+      setTimeout(() => {
+        emitter.emit("setSendColumnsChildren", resData);
+      }, 500);
+    };
+    const setSendChildren = (path) => {
+      const currentPathSplit = path.split("/");
+      let currentData = { children: [], item: void 0 };
+      const matched = state.columnsAsideList.find((v, k) => {
+        if (v.path === `/${currentPathSplit[1]}`) {
+          v["k"] = k;
+          return true;
+        }
+        return false;
+      });
+      if (matched) {
+        currentData.item = { ...matched };
+        currentData.children = matched.children ? [...matched.children] : [{ ...matched }];
+      }
+      return currentData;
+    };
+    const filterRoutesFun = (arr) => {
+      return arr.filter((item) => !item.meta?.isHide).map((item) => {
+        item = Object.assign({}, item);
+        if (item.children) item.children = filterRoutesFun(item.children);
+        return item;
+      });
+    };
+    const setColumnsMenuHighlight = (path) => {
+      state.routeSplit = path.split("/");
+      state.routeSplit.shift();
+      const routeFirst = `/${state.routeSplit[0]}`;
+      const currentSplitRoute = state.columnsAsideList.find((v) => v.path === routeFirst);
+      if (!currentSplitRoute) return false;
+      setTimeout(() => {
+        onColumnsAsideDown(currentSplitRoute.k);
+      }, 0);
+    };
+    onMounted(() => {
+      setFilterRoutes();
+      emitter.on("restoreDefault", () => {
+        state.liOldIndex = null;
+        state.liOldPath = null;
+      });
+    });
+    onUnmounted(() => {
+      emitter.off("restoreDefault", () => {
+      });
+    });
+    onBeforeRouteUpdate((to) => {
+      const resData = setMenuAutoCollaps(to.path);
+      setColumnsMenuHighlight(to.path);
+      emitter.emit("setSendColumnsChildren", resData);
+    });
+    watch(
+      [() => themeConfig.value.columnsAsideStyle, isColumnsMenuHover, isColumnsNavHover],
+      () => {
+        themeConfig.value.columnsAsideStyle === "columnsRound" ? state.difference = 3 : state.difference = 0;
+        if (!isColumnsMenuHover.value && !isColumnsNavHover.value) {
+          state.liHoverIndex = null;
+          emitter.emit("setSendColumnsChildren", setSendChildren(route.path));
+        } else {
+          state.liHoverIndex = state.liOldIndex;
+          if (!state.liOldPath) return false;
+          emitter.emit("setSendColumnsChildren", setSendChildren(state.liOldPath));
+        }
+      },
+      {
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_SvgIcon = resolveComponent("SvgIcon");
+      const _component_el_scrollbar = resolveComponent("el-scrollbar");
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("img", {
+            src: unref(themeConfig).logoUrl,
+            class: "layout-logo-medium-img"
+          }, null, 8, _hoisted_3)
+        ]),
+        createVNode(_component_el_scrollbar, null, {
+          default: withCtx(() => [
+            createElementVNode(
+              "ul",
+              {
+                onMouseleave: _cache[0] || (_cache[0] = ($event) => onColumnsAsideMenuMouseleave())
+              },
+              [
+                (openBlock(true), createElementBlock(
+                  Fragment,
+                  null,
+                  renderList(state.columnsAsideList, (v, k) => {
+                    return openBlock(), createElementBlock("li", {
+                      key: k,
+                      onClick: ($event) => onColumnsAsideMenuClick(v),
+                      onMouseenter: ($event) => onColumnsAsideMenuMouseenter(v, k),
+                      ref_for: true,
+                      ref: (el) => {
+                        if (el) columnsAsideOffsetTopRefs.value[k] = el;
+                      },
+                      class: normalizeClass({ "layout-columns-active": state.liIndex === k, "layout-columns-hover": state.liHoverIndex === k }),
+                      title: _ctx.$t(`message.menu.${v.meta.title}`)
+                    }, [
+                      !v.meta.isLink || v.meta.isLink && v.meta.isIframe ? (openBlock(), createElementBlock(
+                        "div",
+                        {
+                          key: 0,
+                          class: normalizeClass(unref(themeConfig).columnsAsideLayout)
+                        },
+                        [
+                          createVNode(_component_SvgIcon, {
+                            name: v.meta.icon
+                          }, null, 8, ["name"]),
+                          createElementVNode(
+                            "div",
+                            _hoisted_5,
+                            toDisplayString(_ctx.$t(`message.menu.${v.meta.title}`)),
+                            1
+                            /* TEXT */
+                          )
+                        ],
+                        2
+                        /* CLASS */
+                      )) : (openBlock(), createElementBlock(
+                        "div",
+                        {
+                          key: 1,
+                          class: normalizeClass(unref(themeConfig).columnsAsideLayout)
+                        },
+                        [
+                          createElementVNode("a", {
+                            href: v.meta.isLink,
+                            target: "_blank"
+                          }, [
+                            createVNode(_component_SvgIcon, {
+                              name: v.meta.icon
+                            }, null, 8, ["name"]),
+                            createElementVNode(
+                              "div",
+                              _hoisted_7,
+                              toDisplayString(_ctx.$t(`message.menu.${v.meta.title}`)),
+                              1
+                              /* TEXT */
+                            )
+                          ], 8, _hoisted_6)
+                        ],
+                        2
+                        /* CLASS */
+                      ))
+                    ], 42, _hoisted_4);
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                )),
+                createElementVNode(
+                  "div",
+                  {
+                    ref_key: "columnsAsideActiveRef",
+                    ref: columnsAsideActiveRef,
+                    class: normalizeClass(unref(themeConfig).columnsAsideStyle)
+                  },
+                  null,
+                  2
+                  /* CLASS */
+                )
+              ],
+              32
+              /* NEED_HYDRATION */
+            )
+          ]),
+          _: 1
+          /* STABLE */
+        })
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/columnsAside.vue3.mjs

@@ -0,0 +1,3 @@
+var undefined$1 = undefined;
+
+export { undefined$1 as default };

package/es/packages/core/layout/component/header.vue.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './header.vue2.mjs';
+
+
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/header.vue2.mjs

@@ -0,0 +1,34 @@
+import { defineComponent, resolveComponent, withDirectives, openBlock, createBlock, withCtx, createVNode, unref, vShow } from 'vue';
+import { storeToRefs } from 'pinia';
+import '../../stores/index.mjs';
+import navBars from '../navBars/index.vue.mjs';
+import { useTagsViewRoutes } from '../../stores/tagsViewRoutes.mjs';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "header",
+  setup(__props) {
+    const NavBarsIndex = navBars;
+    const storesTagsViewRoutes = useTagsViewRoutes();
+    const { isTagsViewCurrenFull } = storeToRefs(storesTagsViewRoutes);
+    return (_ctx, _cache) => {
+      const _component_el_header = resolveComponent("el-header");
+      return withDirectives((openBlock(), createBlock(
+        _component_el_header,
+        { class: "layout-header" },
+        {
+          default: withCtx(() => [
+            createVNode(unref(NavBarsIndex))
+          ]),
+          _: 1
+          /* STABLE */
+        },
+        512
+        /* NEED_PATCH */
+      )), [
+        [vShow, !unref(isTagsViewCurrenFull)]
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/main.vue.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './main.vue2.mjs';
+
+
+
+export { _sfc_main as default };

package/es/packages/core/layout/component/main.vue2.mjs

@@ -0,0 +1,84 @@
+import { defineComponent, ref, computed, onMounted, resolveComponent, createBlock, openBlock, normalizeStyle, withCtx, createVNode, createCommentVNode, unref } from 'vue';
+import { useRoute } from 'vue-router';
+import { storeToRefs } from 'pinia';
+import '../../stores/index.mjs';
+import { NextLoading } from '../../ui/loading/index.mjs';
+import '../routerView/parent.vue.mjs';
+import '../footer/index.vue.mjs';
+import _sfc_main$1 from '../routerView/parent.vue2.mjs';
+import _sfc_main$2 from '../footer/index.vue2.mjs';
+import { useTagsViewRoutes } from '../../stores/tagsViewRoutes.mjs';
+import { useThemeConfig } from '../../stores/themeConfig.mjs';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "main",
+  setup(__props, { expose: __expose }) {
+    const LayoutParentView = _sfc_main$1;
+    const LayoutFooter = _sfc_main$2;
+    const layoutMainScrollbarRef = ref();
+    const route = useRoute();
+    const storesTagsViewRoutes = useTagsViewRoutes();
+    const storesThemeConfig = useThemeConfig();
+    const { themeConfig } = storeToRefs(storesThemeConfig);
+    const { isTagsViewCurrenFull } = storeToRefs(storesTagsViewRoutes);
+    const isFooter = computed(() => {
+      return themeConfig.value.isFooter && !route.meta.isIframe;
+    });
+    const isFixedHeader = computed(() => {
+      return themeConfig.value.isFixedHeader;
+    });
+    const setBacktopClass = computed(() => {
+      if (themeConfig.value.isFixedHeader) return `.layout-backtop-header-fixed .el-scrollbar__wrap`;
+      else return `.layout-backtop .el-scrollbar__wrap`;
+    });
+    const setMainHeight = computed(() => {
+      if (isTagsViewCurrenFull.value) return "0px";
+      const { isTagsview, layout } = themeConfig.value;
+      if (isTagsview && layout !== "classic") return "85px";
+      else return "51px";
+    });
+    onMounted(() => {
+      NextLoading.done(600);
+    });
+    __expose({
+      layoutMainScrollbarRef
+    });
+    return (_ctx, _cache) => {
+      const _component_el_scrollbar = resolveComponent("el-scrollbar");
+      const _component_el_backtop = resolveComponent("el-backtop");
+      const _component_el_main = resolveComponent("el-main");
+      return openBlock(), createBlock(_component_el_main, {
+        class: "layout-main",
+        style: normalizeStyle(isFixedHeader.value ? `height: calc(100% - ${setMainHeight.value})` : `minHeight: calc(100% - ${setMainHeight.value})`)
+      }, {
+        default: withCtx(() => [
+          createVNode(
+            _component_el_scrollbar,
+            {
+              ref_key: "layoutMainScrollbarRef",
+              ref: layoutMainScrollbarRef,
+              class: "layout-main-scroll layout-backtop-header-fixed",
+              "wrap-class": "layout-main-scroll",
+              "view-class": "layout-main-scroll"
+            },
+            {
+              default: withCtx(() => [
+                createVNode(unref(LayoutParentView)),
+                isFooter.value ? (openBlock(), createBlock(unref(LayoutFooter), { key: 0 })) : createCommentVNode("v-if", true)
+              ]),
+              _: 1
+              /* STABLE */
+            },
+            512
+            /* NEED_PATCH */
+          ),
+          createVNode(_component_el_backtop, { target: setBacktopClass.value }, null, 8, ["target"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["style"]);
+    };
+  }
+});
+
+export { _sfc_main as default };