@fmdeui/fmui 1.0.28 → 1.0.29

package/es/packages/components/fm-layout/src/component/aside.vue.mjs

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

package/es/packages/components/fm-layout/src/component/aside.vue2.mjs

@@ -0,0 +1,175 @@
+import { defineComponent, defineAsyncComponent, ref, reactive, computed, onBeforeMount, watch, resolveComponent, withDirectives, openBlock, createElementBlock, createVNode, normalizeClass, withCtx, createBlock, unref, createCommentVNode, vShow } from 'vue';
+import { storeToRefs } from 'pinia';
+import '../../../../stores/index.mjs';
+import emitter from '../../../../utils/mitt.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-240"];
+        } else {
+          if (isCollapse) return [asideBrColor, "layout-aside-pc-64"];
+          else return [asideBrColor, "layout-aside-pc-240"];
+        }
+      }
+    });
+    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 == null ? void 0 : el.setAttribute("style", "animation: error-img-two 0.3s");
+      setTimeout(() => {
+        var _a;
+        (_a = el == null ? void 0 : el.parentNode) == null ? void 0 : _a.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) => {
+        var _a;
+        return !((_a = item.meta) == null ? void 0 : _a.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/components/fm-layout/src/component/columnsAside.vue.mjs

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

package/es/packages/components/fm-layout/src/component/columnsAside.vue2.mjs

@@ -0,0 +1,273 @@
+import { defineComponent, ref, reactive, onMounted, onUnmounted, watch, resolveComponent, openBlock, createElementBlock, createElementVNode, unref, createVNode, withCtx, Fragment, renderList, normalizeClass, toDisplayString, nextTick } from 'vue';
+import { useRoute, useRouter, onBeforeRouteUpdate } from 'vue-router';
+import { storeToRefs } from 'pinia';
+import '../../../../stores/index.mjs';
+import emitter from '../../../../utils/mitt.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) => {
+      var _a, _b, _c;
+      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 || ((_a = v.children) == null ? void 0 : _a.length) === 0) {
+          router.push(path);
+          onColumnsAsideDown(v.k);
+        } else {
+          const resData = setSendChildren(path);
+          if (Object.keys(resData).length <= 0) return false;
+          onColumnsAsideDown((_b = resData.item) == null ? void 0 : _b.k);
+          emitter.emit("setSendColumnsChildren", resData);
+        }
+      }
+      if (!v.children || ((_c = v.children) == null ? void 0 : _c.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) => {
+      var _a, _b;
+      const resData = setSendChildren(path);
+      !((_a = resData.item) == null ? void 0 : _a.redirect) && resData.children.length == 0 || ((_b = resData.item) == null ? void 0 : _b.redirect) && resData.children.length <= 1 ? themeConfig.value.isCollapse = true : themeConfig.value.isCollapse = false;
+      return resData;
+    };
+    const setFilterRoutes = () => {
+      var _a;
+      state.columnsAsideList = filterRoutesFun(routesList.value);
+      const resData = setMenuAutoCollaps(route.path);
+      onColumnsAsideDown((_a = resData.item) == null ? void 0 : _a.k);
+      setTimeout(() => {
+        emitter.emit("setSendColumnsChildren", resData);
+      }, 500);
+    };
+    const setSendChildren = (path) => {
+      const currentPathSplit = path.split("/");
+      let currentData = { children: [] };
+      state.columnsAsideList.map((v, k) => {
+        if (v.path === `/${currentPathSplit[1]}`) {
+          v["k"] = k;
+          currentData["item"] = { ...v };
+          currentData["children"] = [{ ...v }];
+          if (v.children) currentData["children"] = v.children;
+        }
+      });
+      return currentData;
+    };
+    const filterRoutesFun = (arr) => {
+      return arr.filter((item) => {
+        var _a;
+        return !((_a = item.meta) == null ? void 0 : _a.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/components/fm-layout/src/component/header.vue.mjs

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

package/es/packages/components/fm-layout/src/component/header.vue2.mjs

@@ -0,0 +1,50 @@
+import { defineComponent, defineAsyncComponent, resolveComponent, withDirectives, openBlock, createBlock, withCtx, unref, createElementBlock, Fragment, renderList, renderSlot, mergeProps, vShow } from 'vue';
+import { storeToRefs } from 'pinia';
+import '../../../../stores/index.mjs';
+import { useTagsViewRoutes } from '../../../../stores/tagsViewRoutes.mjs';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "header",
+  setup(__props) {
+    const NavBarsIndex = defineAsyncComponent(() => import('../navBars/index.vue.mjs'));
+    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(() => [
+            !_ctx.$slots.navBars ? (openBlock(), createBlock(unref(NavBarsIndex), { key: 0 }, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(
+                  Fragment,
+                  null,
+                  renderList(_ctx.$slots, (_, name) => {
+                    return renderSlot(_ctx.$slots, name, mergeProps({
+                      key: name,
+                      ref_for: true
+                    }, _ctx.$slots[name].props || {}));
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                ))
+              ]),
+              _: 3
+              /* FORWARDED */
+            })) : renderSlot(_ctx.$slots, "navBars", { key: 1 })
+          ]),
+          _: 3
+          /* FORWARDED */
+        },
+        512
+        /* NEED_PATCH */
+      )), [
+        [vShow, !unref(isTagsViewCurrenFull)]
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/packages/components/fm-layout/src/component/main.vue.mjs

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

package/es/packages/components/fm-layout/src/component/main.vue2.mjs

@@ -0,0 +1,81 @@
+import { defineComponent, defineAsyncComponent, ref, computed, onMounted, resolveComponent, openBlock, createBlock, normalizeStyle, withCtx, createVNode, unref, createCommentVNode } from 'vue';
+import { useRoute } from 'vue-router';
+import { storeToRefs } from 'pinia';
+import '../../../../stores/index.mjs';
+import '../../../../utils/index.mjs';
+import { useTagsViewRoutes } from '../../../../stores/tagsViewRoutes.mjs';
+import { useThemeConfig } from '../../../../stores/themeConfig.mjs';
+import { NextLoading } from '../../../../utils/loading.mjs';
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "main",
+  setup(__props, { expose: __expose }) {
+    const LayoutParentView = defineAsyncComponent(() => import('../routerView/parent.vue.mjs'));
+    const LayoutFooter = defineAsyncComponent(() => import('../footer/index.vue.mjs'));
+    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 };

package/es/packages/components/fm-layout/src/footer/index.vue.mjs

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

package/es/packages/components/fm-layout/src/footer/index.vue2.mjs

@@ -0,0 +1,29 @@
+import { defineComponent, openBlock, createElementBlock, createElementVNode, toDisplayString, unref } from 'vue';
+import { storeToRefs } from 'pinia';
+import '../../../../stores/index.mjs';
+import { useThemeConfig } from '../../../../stores/themeConfig.mjs';
+
+const _hoisted_1 = { class: "layout-footer mb5" };
+const _hoisted_2 = { class: "layout-footer-warp" };
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "index",
+  setup(__props) {
+    const storesThemeConfig = useThemeConfig();
+    const { themeConfig } = storeToRefs(storesThemeConfig);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode(
+            "div",
+            null,
+            toDisplayString(unref(themeConfig).globalTitle) + " " + toDisplayString(unref(themeConfig).copyright),
+            1
+            /* TEXT */
+          )
+        ])
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/packages/components/fm-layout/src/index.vue.mjs

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