@fmdeui/fmui 1.0.27 → 1.0.29

package/lib/hooks/composables/useDialogEvents.d.ts

@@ -11,6 +11,10 @@ export interface FormFieldChangeData {
     value: any;
     isValid: boolean;
 }
+export interface FormDialogEventData {
+    dialogVisible?: boolean;
+    dialogName?: string;
+}
 /**
  * 表单事件处理器类型定义
  */
@@ -20,7 +24,7 @@ export interface FormEventHandlers {
     onFieldChange: (data: FormFieldChangeData) => void;
     onFormValidate: (errors: Record<string, string>) => void;
     onFormDialogClose: () => void;
-    onFormDialogOpen: () => void;
+    onFormDialogOpen: (data: FormDialogEventData) => void;
 }
 /**
  * 创建表单事件总线

package/lib/packages/components/fm-layout/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+require('./src/index.vue.js');
+require('./src/type.js');
+var index_vue_vue_type_script_setup_true_name_FLayout_lang = require('./src/index.vue2.js');
+
+const FLayout = index_vue_vue_type_script_setup_true_name_FLayout_lang.default;
+
+exports.FLayout = FLayout;

package/lib/packages/components/fm-layout/src/component/aside.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var aside_vue_vue_type_script_setup_true_name_layoutAside_lang = require('./aside.vue2.js');
+
+
+
+exports.default = aside_vue_vue_type_script_setup_true_name_layoutAside_lang.default;

package/lib/packages/components/fm-layout/src/component/aside.vue2.js

@@ -0,0 +1,179 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var pinia = require('pinia');
+require('../../../../stores/index.js');
+var mitt = require('../../../../utils/mitt.js');
+var routesList = require('../../../../stores/routesList.js');
+var themeConfig = require('../../../../stores/themeConfig.js');
+var tagsViewRoutes = require('../../../../stores/tagsViewRoutes.js');
+
+const _hoisted_1 = { class: "h100" };
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "aside",
+  setup(__props) {
+    const Logo = vue.defineAsyncComponent(() => Promise.resolve().then(function () { return require('../logo/index.vue.js'); }));
+    const Vertical = vue.defineAsyncComponent(() => Promise.resolve().then(function () { return require('../navMenu/vertical.vue.js'); }));
+    const layoutAsideScrollbarRef = vue.ref();
+    const stores = routesList.useRoutesList();
+    const storesThemeConfig = themeConfig.useThemeConfig();
+    const storesTagsViewRoutes = tagsViewRoutes.useTagsViewRoutes();
+    const { routesList: routesList$1 } = pinia.storeToRefs(stores);
+    const { themeConfig: themeConfig$1 } = pinia.storeToRefs(storesThemeConfig);
+    const { isTagsViewCurrenFull } = pinia.storeToRefs(storesTagsViewRoutes);
+    const state = vue.reactive({
+      menuList: [],
+      clientWidth: 0
+    });
+    const setCollapseStyle = vue.computed(() => {
+      const { layout, isCollapse, menuBar } = themeConfig$1.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 = vue.computed(() => {
+      let { layout, isShowLogo } = themeConfig$1.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$1.value.isCollapse = false;
+      document.body.setAttribute("class", "");
+    };
+    const setFilterRoutes = () => {
+      if (themeConfig$1.value.layout === "columns") return false;
+      state.menuList = filterRoutesFun(routesList$1.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$1.value;
+      if (layout !== "columns") return false;
+      if (!bool) mitt.default.emit("restoreDefault");
+      if (themeConfig$1.value.isColumnsMenuHoverPreload) stores.setColumnsMenuHover(bool);
+    };
+    vue.onBeforeMount(() => {
+      initMenuFixed(document.body.clientWidth);
+      setFilterRoutes();
+      mitt.default.on("setSendColumnsChildren", (res) => {
+        state.menuList = res.children;
+      });
+      mitt.default.on("setSendClassicChildren", (res) => {
+        let { layout, isClassicSplitMenu } = themeConfig$1.value;
+        if (layout === "classic" && isClassicSplitMenu) {
+          res.children.length <= 1 ? themeConfig$1.value.isCollapse = true : themeConfig$1.value.isCollapse = false;
+          state.menuList = [];
+          state.menuList = res.children;
+        }
+      });
+      mitt.default.on("getBreadcrumbIndexSetFilterRoutes", () => {
+        setFilterRoutes();
+      });
+      mitt.default.on("layoutMobileResize", (res) => {
+        initMenuFixed(res.clientWidth);
+        closeLayoutAsideMobileMode();
+      });
+    });
+    vue.watch(
+      () => [themeConfig$1.value.isShowLogoChange, themeConfig$1.value.isShowLogo, themeConfig$1.value.layout, themeConfig$1.value.isClassicSplitMenu],
+      ([isShowLogoChange, isShowLogo, layout, isClassicSplitMenu]) => {
+        if (isShowLogoChange !== isShowLogo) {
+          if (layoutAsideScrollbarRef.value) layoutAsideScrollbarRef.value.update();
+        }
+        if (layout === "classic" && isClassicSplitMenu) return false;
+      }
+    );
+    vue.watch(
+      () => routesList$1.value,
+      () => {
+        setFilterRoutes();
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
+      const _component_el_aside = vue.resolveComponent("el-aside");
+      return vue.withDirectives((vue.openBlock(), vue.createElementBlock(
+        "div",
+        _hoisted_1,
+        [
+          vue.createVNode(_component_el_aside, {
+            class: vue.normalizeClass(["layout-aside", setCollapseStyle.value])
+          }, {
+            default: vue.withCtx(() => [
+              setShowLogo.value ? (vue.openBlock(), vue.createBlock(vue.unref(Logo), { key: 0 })) : vue.createCommentVNode("v-if", true),
+              vue.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: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(Vertical), {
+                      menuList: state.menuList
+                    }, null, 8, ["menuList"])
+                  ]),
+                  _: 1
+                  /* STABLE */
+                },
+                512
+                /* NEED_PATCH */
+              )
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["class"])
+        ],
+        512
+        /* NEED_PATCH */
+      )), [
+        [vue.vShow, !vue.unref(isTagsViewCurrenFull)]
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/fm-layout/src/component/columnsAside.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var columnsAside_vue_vue_type_script_setup_true_name_layoutColumnsAside_lang = require('./columnsAside.vue2.js');
+
+
+
+exports.default = columnsAside_vue_vue_type_script_setup_true_name_layoutColumnsAside_lang.default;

package/lib/packages/components/fm-layout/src/component/columnsAside.vue2.js

@@ -0,0 +1,277 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var vueRouter = require('vue-router');
+var pinia = require('pinia');
+require('../../../../stores/index.js');
+var mitt = require('../../../../utils/mitt.js');
+var routesList = require('../../../../stores/routesList.js');
+var themeConfig = require('../../../../stores/themeConfig.js');
+
+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__ */ vue.defineComponent({
+  __name: "columnsAside",
+  setup(__props) {
+    const columnsAsideOffsetTopRefs = vue.ref([]);
+    const columnsAsideActiveRef = vue.ref();
+    const stores = routesList.useRoutesList();
+    const storesThemeConfig = themeConfig.useThemeConfig();
+    const { routesList: routesList$1, isColumnsMenuHover, isColumnsNavHover } = pinia.storeToRefs(stores);
+    const { themeConfig: themeConfig$1 } = pinia.storeToRefs(storesThemeConfig);
+    const route = vueRouter.useRoute();
+    const router = vueRouter.useRouter();
+    const state = vue.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)) mitt.default.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);
+          mitt.default.emit("setSendColumnsChildren", resData);
+        }
+      }
+      if (!v.children || ((_c = v.children) == null ? void 0 : _c.length) === 0) themeConfig$1.value.isCollapse = true;
+      else if (v.children.length > 1) themeConfig$1.value.isCollapse = false;
+    };
+    const onColumnsAsideMenuMouseenter = (v, k) => {
+      if (!themeConfig$1.value.isColumnsMenuHoverPreload) return false;
+      let { path } = v;
+      state.liOldPath = path;
+      state.liOldIndex = k;
+      state.liHoverIndex = k;
+      mitt.default.emit("setSendColumnsChildren", setSendChildren(path));
+      stores.setColumnsMenuHover(false);
+      stores.setColumnsNavHover(true);
+    };
+    const onColumnsAsideMenuMouseleave = async () => {
+      if (!themeConfig$1.value.isColumnsMenuHoverPreload) return false;
+      await stores.setColumnsNavHover(false);
+      setTimeout(() => {
+        if (!isColumnsMenuHover && !isColumnsNavHover) mitt.default.emit("restoreDefault");
+      }, 100);
+    };
+    const onColumnsAsideDown = (k) => {
+      vue.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$1.value.isCollapse = true : themeConfig$1.value.isCollapse = false;
+      return resData;
+    };
+    const setFilterRoutes = () => {
+      var _a;
+      state.columnsAsideList = filterRoutesFun(routesList$1.value);
+      const resData = setMenuAutoCollaps(route.path);
+      onColumnsAsideDown((_a = resData.item) == null ? void 0 : _a.k);
+      setTimeout(() => {
+        mitt.default.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);
+    };
+    vue.onMounted(() => {
+      setFilterRoutes();
+      mitt.default.on("restoreDefault", () => {
+        state.liOldIndex = null;
+        state.liOldPath = null;
+      });
+    });
+    vue.onUnmounted(() => {
+      mitt.default.off("restoreDefault", () => {
+      });
+    });
+    vueRouter.onBeforeRouteUpdate((to) => {
+      const resData = setMenuAutoCollaps(to.path);
+      setColumnsMenuHighlight(to.path);
+      mitt.default.emit("setSendColumnsChildren", resData);
+    });
+    vue.watch(
+      [() => themeConfig$1.value.columnsAsideStyle, isColumnsMenuHover, isColumnsNavHover],
+      () => {
+        themeConfig$1.value.columnsAsideStyle === "columnsRound" ? state.difference = 3 : state.difference = 0;
+        if (!isColumnsMenuHover.value && !isColumnsNavHover.value) {
+          state.liHoverIndex = null;
+          mitt.default.emit("setSendColumnsChildren", setSendChildren(route.path));
+        } else {
+          state.liHoverIndex = state.liOldIndex;
+          if (!state.liOldPath) return false;
+          mitt.default.emit("setSendColumnsChildren", setSendChildren(state.liOldPath));
+        }
+      },
+      {
+        deep: true
+      }
+    );
+    return (_ctx, _cache) => {
+      const _component_SvgIcon = vue.resolveComponent("SvgIcon");
+      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", _hoisted_2, [
+          vue.createElementVNode("img", {
+            src: vue.unref(themeConfig$1).logoUrl,
+            class: "layout-logo-medium-img"
+          }, null, 8, _hoisted_3)
+        ]),
+        vue.createVNode(_component_el_scrollbar, null, {
+          default: vue.withCtx(() => [
+            vue.createElementVNode(
+              "ul",
+              {
+                onMouseleave: _cache[0] || (_cache[0] = ($event) => onColumnsAsideMenuMouseleave())
+              },
+              [
+                (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(state.columnsAsideList, (v, k) => {
+                    return vue.openBlock(), vue.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: vue.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 ? (vue.openBlock(), vue.createElementBlock(
+                        "div",
+                        {
+                          key: 0,
+                          class: vue.normalizeClass(vue.unref(themeConfig$1).columnsAsideLayout)
+                        },
+                        [
+                          vue.createVNode(_component_SvgIcon, {
+                            name: v.meta.icon
+                          }, null, 8, ["name"]),
+                          vue.createElementVNode(
+                            "div",
+                            _hoisted_5,
+                            vue.toDisplayString(_ctx.$t(`message.menu.${v.meta.title}`)),
+                            1
+                            /* TEXT */
+                          )
+                        ],
+                        2
+                        /* CLASS */
+                      )) : (vue.openBlock(), vue.createElementBlock(
+                        "div",
+                        {
+                          key: 1,
+                          class: vue.normalizeClass(vue.unref(themeConfig$1).columnsAsideLayout)
+                        },
+                        [
+                          vue.createElementVNode("a", {
+                            href: v.meta.isLink,
+                            target: "_blank"
+                          }, [
+                            vue.createVNode(_component_SvgIcon, {
+                              name: v.meta.icon
+                            }, null, 8, ["name"]),
+                            vue.createElementVNode(
+                              "div",
+                              _hoisted_7,
+                              vue.toDisplayString(_ctx.$t(`message.menu.${v.meta.title}`)),
+                              1
+                              /* TEXT */
+                            )
+                          ], 8, _hoisted_6)
+                        ],
+                        2
+                        /* CLASS */
+                      ))
+                    ], 42, _hoisted_4);
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                )),
+                vue.createElementVNode(
+                  "div",
+                  {
+                    ref_key: "columnsAsideActiveRef",
+                    ref: columnsAsideActiveRef,
+                    class: vue.normalizeClass(vue.unref(themeConfig$1).columnsAsideStyle)
+                  },
+                  null,
+                  2
+                  /* CLASS */
+                )
+              ],
+              32
+              /* NEED_HYDRATION */
+            )
+          ]),
+          _: 1
+          /* STABLE */
+        })
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/fm-layout/src/component/header.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var header_vue_vue_type_script_setup_true_name_layoutHeader_lang = require('./header.vue2.js');
+
+
+
+exports.default = header_vue_vue_type_script_setup_true_name_layoutHeader_lang.default;

package/lib/packages/components/fm-layout/src/component/header.vue2.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var pinia = require('pinia');
+require('../../../../stores/index.js');
+var tagsViewRoutes = require('../../../../stores/tagsViewRoutes.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "header",
+  setup(__props) {
+    const NavBarsIndex = vue.defineAsyncComponent(() => Promise.resolve().then(function () { return require('../navBars/index.vue.js'); }));
+    const storesTagsViewRoutes = tagsViewRoutes.useTagsViewRoutes();
+    const { isTagsViewCurrenFull } = pinia.storeToRefs(storesTagsViewRoutes);
+    return (_ctx, _cache) => {
+      const _component_el_header = vue.resolveComponent("el-header");
+      return vue.withDirectives((vue.openBlock(), vue.createBlock(
+        _component_el_header,
+        { class: "layout-header" },
+        {
+          default: vue.withCtx(() => [
+            !_ctx.$slots.navBars ? (vue.openBlock(), vue.createBlock(vue.unref(NavBarsIndex), { key: 0 }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(
+                  vue.Fragment,
+                  null,
+                  vue.renderList(_ctx.$slots, (_, name) => {
+                    return vue.renderSlot(_ctx.$slots, name, vue.mergeProps({
+                      key: name,
+                      ref_for: true
+                    }, _ctx.$slots[name].props || {}));
+                  }),
+                  128
+                  /* KEYED_FRAGMENT */
+                ))
+              ]),
+              _: 3
+              /* FORWARDED */
+            })) : vue.renderSlot(_ctx.$slots, "navBars", { key: 1 })
+          ]),
+          _: 3
+          /* FORWARDED */
+        },
+        512
+        /* NEED_PATCH */
+      )), [
+        [vue.vShow, !vue.unref(isTagsViewCurrenFull)]
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/fm-layout/src/component/main.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var main_vue_vue_type_script_setup_true_name_layoutMain_lang = require('./main.vue2.js');
+
+
+
+exports.default = main_vue_vue_type_script_setup_true_name_layoutMain_lang.default;

package/lib/packages/components/fm-layout/src/component/main.vue2.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var vueRouter = require('vue-router');
+var pinia = require('pinia');
+require('../../../../stores/index.js');
+require('../../../../utils/index.js');
+var tagsViewRoutes = require('../../../../stores/tagsViewRoutes.js');
+var themeConfig = require('../../../../stores/themeConfig.js');
+var loading = require('../../../../utils/loading.js');
+
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "main",
+  setup(__props, { expose: __expose }) {
+    const LayoutParentView = vue.defineAsyncComponent(() => Promise.resolve().then(function () { return require('../routerView/parent.vue.js'); }));
+    const LayoutFooter = vue.defineAsyncComponent(() => Promise.resolve().then(function () { return require('../footer/index.vue.js'); }));
+    const layoutMainScrollbarRef = vue.ref();
+    const route = vueRouter.useRoute();
+    const storesTagsViewRoutes = tagsViewRoutes.useTagsViewRoutes();
+    const storesThemeConfig = themeConfig.useThemeConfig();
+    const { themeConfig: themeConfig$1 } = pinia.storeToRefs(storesThemeConfig);
+    const { isTagsViewCurrenFull } = pinia.storeToRefs(storesTagsViewRoutes);
+    const isFooter = vue.computed(() => {
+      return themeConfig$1.value.isFooter && !route.meta.isIframe;
+    });
+    const isFixedHeader = vue.computed(() => {
+      return themeConfig$1.value.isFixedHeader;
+    });
+    const setBacktopClass = vue.computed(() => {
+      if (themeConfig$1.value.isFixedHeader) return `.layout-backtop-header-fixed .el-scrollbar__wrap`;
+      else return `.layout-backtop .el-scrollbar__wrap`;
+    });
+    const setMainHeight = vue.computed(() => {
+      if (isTagsViewCurrenFull.value) return "0px";
+      const { isTagsview, layout } = themeConfig$1.value;
+      if (isTagsview && layout !== "classic") return "85px";
+      else return "51px";
+    });
+    vue.onMounted(() => {
+      loading.NextLoading.done(600);
+    });
+    __expose({
+      layoutMainScrollbarRef
+    });
+    return (_ctx, _cache) => {
+      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
+      const _component_el_backtop = vue.resolveComponent("el-backtop");
+      const _component_el_main = vue.resolveComponent("el-main");
+      return vue.openBlock(), vue.createBlock(_component_el_main, {
+        class: "layout-main",
+        style: vue.normalizeStyle(isFixedHeader.value ? `height: calc(100% - ${setMainHeight.value})` : `minHeight: calc(100% - ${setMainHeight.value})`)
+      }, {
+        default: vue.withCtx(() => [
+          vue.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: vue.withCtx(() => [
+                vue.createVNode(vue.unref(LayoutParentView)),
+                isFooter.value ? (vue.openBlock(), vue.createBlock(vue.unref(LayoutFooter), { key: 0 })) : vue.createCommentVNode("v-if", true)
+              ]),
+              _: 1
+              /* STABLE */
+            },
+            512
+            /* NEED_PATCH */
+          ),
+          vue.createVNode(_component_el_backtop, { target: setBacktopClass.value }, null, 8, ["target"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["style"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/packages/components/fm-layout/src/footer/index.vue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_vue_vue_type_script_setup_true_name_layoutFooter_lang = require('./index.vue2.js');
+
+
+
+exports.default = index_vue_vue_type_script_setup_true_name_layoutFooter_lang.default;