@keyblade/pro-components 0.0.1-alpha.6 → 0.0.1-alpha.8

package/es/components.d.ts

@@ -1,6 +1,7 @@
 declare module 'vue' {
     interface GlobalComponents {
         KbProBreadcrumb: typeof import('./index')['ProBreadcrumb'];
+        KbProLayout: typeof import('./index')['ProLayout'];
         KbProMenu: typeof import('./index')['ProMenu'];
         KbProPageWrapper: typeof import('./index')['ProPageWrapper'];
         KbProReuseTabs: typeof import('./index')['ProReuseTabs'];

package/es/index.d.ts

@@ -4,6 +4,8 @@ declare const _default: {
 };
 export default _default;
 export { default as ProBreadcrumb } from './pro-breadcrumb';
+export { default as ProLayout } from './pro-layout';
+export type { EProLayoutTheme } from './pro-layout';
 export { default as ProMenu } from './pro-menu';
 export type { IProMenuItem } from './pro-menu';
 export { default as ProPageWrapper } from './pro-page-wrapper';

package/es/index.js

@@ -6,9 +6,12 @@ import { ProPageWrapper } from "./pro-page-wrapper/index.js";
 import { ProPageWrapper as ProPageWrapper2 } from "./pro-page-wrapper/index.js";
 import { ProReuseTabs } from "./pro-reuse-tabs/index.js";
 import { ProReuseTabs as ProReuseTabs2 } from "./pro-reuse-tabs/index.js";
+import { ProLayout } from "./pro-layout/index.js";
+import { ProLayout as ProLayout2 } from "./pro-layout/index.js";
 const index = {
   install(app) {
     app.use(ProBreadcrumb);
+    app.use(ProLayout);
     app.use(ProMenu);
     app.use(ProPageWrapper);
     app.use(ProReuseTabs);
@@ -16,6 +19,7 @@ const index = {
 };
 export {
   ProBreadcrumb2 as ProBreadcrumb,
+  ProLayout2 as ProLayout,
   ProMenu2 as ProMenu,
   ProPageWrapper2 as ProPageWrapper,
   ProReuseTabs2 as ProReuseTabs,

package/es/pro-layout/enum.d.ts

@@ -0,0 +1,5 @@
+/** 主题 */
+export declare enum EProLayoutTheme {
+    light = "light",
+    dark = "dark"
+}

package/es/pro-layout/enum.js

@@ -0,0 +1,8 @@
+var EProLayoutTheme = /* @__PURE__ */ ((EProLayoutTheme2) => {
+  EProLayoutTheme2["light"] = "light";
+  EProLayoutTheme2["dark"] = "dark";
+  return EProLayoutTheme2;
+})(EProLayoutTheme || {});
+export {
+  EProLayoutTheme
+};

package/es/pro-layout/hooks/index.d.ts

@@ -0,0 +1,20 @@
+import { type Ref } from 'vue';
+import type { IProMenuItem } from '../../pro-menu';
+export declare function useHooks(menuItems: Ref<IProMenuItem[]>, options: {
+    tabsMode: boolean;
+}): {
+    menuSelectedKeys: Ref<string[]>;
+    menuOpenKeys: Ref<string[]>;
+    onMenuItemClick: (key: string) => void;
+    onSubMenuClick: (key: string, openKeys: string[]) => void;
+    activeMenuItem: Ref<IProMenuItem | undefined>;
+    breadcrumbItems: Ref<string[]>;
+    tabs: Ref<{
+        name: string;
+        title: string;
+        fullPath: string;
+        active: boolean;
+    }[]>;
+    onTabClick: (key: string) => void;
+    onTabDelete: (key: string) => void;
+};

package/es/pro-layout/hooks/index.js

@@ -0,0 +1,148 @@
+import { ref, watch } from "vue";
+import { useRoute, useRouter } from "vue-router";
+function useHooks(menuItems, options) {
+  const route = useRoute();
+  const router = useRouter();
+  const menuSelectedKeys = ref([]);
+  const menuOpenKeys = ref([]);
+  const onMenuItemClick = (key) => {
+    menuSelectedKeys.value = [key];
+  };
+  const onSubMenuClick = (key, openKeys) => {
+    menuOpenKeys.value = openKeys;
+  };
+  const activeMenuItem = ref();
+  const menuItemMap = ref({});
+  const breadcrumbItems = ref([]);
+  const tabs = ref([]);
+  const setBreadcrumbItems = () => {
+    var _a, _b;
+    const menuItemPaths = [];
+    const recursion = (_menuItem) => {
+      var _a2;
+      let find = false;
+      for (const i in _menuItem) {
+        if (_menuItem[i].name === ((_a2 = activeMenuItem.value) == null ? void 0 : _a2.name)) {
+          find = true;
+          menuItemPaths.push(_menuItem[i]);
+        }
+        const children = _menuItem[i].children;
+        if (children) {
+          const node = recursion(children);
+          if (node) {
+            menuItemPaths.push(_menuItem[i]);
+          }
+        }
+      }
+      return find;
+    };
+    recursion(menuItems.value);
+    const activeMenuItemPaths = menuItemPaths.reverse();
+    const parentMenuPaths = activeMenuItemPaths.filter((_, i) => i !== activeMenuItemPaths.length - 1);
+    const keySet = /* @__PURE__ */ new Set([...parentMenuPaths.map((v) => v.name), ...menuOpenKeys.value]);
+    menuOpenKeys.value = [...keySet];
+    const activeMenuItemTitles = activeMenuItemPaths.map((v) => v.title);
+    breadcrumbItems.value = ((_a = activeMenuItem.value) == null ? void 0 : _a.breadcrumbs) ? (_b = activeMenuItem.value) == null ? void 0 : _b.breadcrumbs : activeMenuItemTitles.length !== 0 ? activeMenuItemTitles : [];
+  };
+  function setTabs() {
+    const { name: menuItemName, title: menuItemTitle, noAffix } = activeMenuItem.value;
+    if (noAffix) {
+      return;
+    }
+    let findIndex = -1;
+    tabs.value.forEach((v, i) => {
+      v.active = false;
+      if (v.name === menuItemName) {
+        findIndex = i;
+      }
+    });
+    const newTab = {
+      name: menuItemName,
+      title: menuItemTitle ?? menuItemName,
+      fullPath: route.fullPath,
+      active: true
+    };
+    if (~findIndex) {
+      const findTab = tabs.value[findIndex];
+      if (findTab.fullPath === route.fullPath) {
+        findTab.active = true;
+        findTab.fullPath = route.fullPath;
+      } else {
+        tabs.value.splice(findIndex, 1);
+        setTimeout(() => {
+          tabs.value.push(newTab);
+        });
+      }
+    } else {
+      tabs.value.push(newTab);
+    }
+  }
+  const onTabClick = (key) => {
+    const findTabIndex = tabs.value.findIndex((v) => v.name === key);
+    const findTab = tabs.value[findTabIndex];
+    router.push(findTab.fullPath);
+  };
+  const onTabDelete = (key) => {
+    let activeIndex = -1;
+    let findTabIndex = -1;
+    tabs.value.forEach((tab, index) => {
+      if (tab.name === key) {
+        findTabIndex = index;
+      }
+      if (tab.active) {
+        activeIndex = index;
+      }
+    });
+    if (activeIndex === findTabIndex) {
+      let tab;
+      if (findTabIndex === 0) {
+        tab = tabs.value[findTabIndex + 1];
+      } else {
+        tab = tabs.value[findTabIndex - 1];
+      }
+      tab.active = true;
+      router.push(tab.fullPath);
+    }
+    tabs.value.splice(findTabIndex, 1);
+  };
+  watch(menuItems, () => {
+    const _menuItemMap = {};
+    const fn = (_menuItem) => {
+      _menuItem.forEach((menuItem) => {
+        if (menuItem.children && menuItem.children.length > 0) {
+          fn(menuItem.children);
+        }
+        delete menuItem["children"];
+        _menuItemMap[menuItem.name] = menuItem;
+      });
+    };
+    fn(JSON.parse(JSON.stringify(menuItems.value)));
+    menuItemMap.value = _menuItemMap;
+  }, { immediate: true });
+  watch(() => route.name, () => {
+    const routeName = route.name;
+    activeMenuItem.value = menuItemMap.value[routeName];
+    if (!(activeMenuItem == null ? void 0 : activeMenuItem.value)) {
+      return;
+    }
+    menuSelectedKeys.value = [activeMenuItem.value.name];
+    setBreadcrumbItems();
+    if (options.tabsMode) {
+      setTabs();
+    }
+  }, { immediate: true });
+  return {
+    menuSelectedKeys,
+    menuOpenKeys,
+    onMenuItemClick,
+    onSubMenuClick,
+    activeMenuItem,
+    breadcrumbItems,
+    tabs,
+    onTabClick,
+    onTabDelete
+  };
+}
+export {
+  useHooks
+};

package/es/pro-layout/hooks/theme.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+import { EProLayoutTheme } from '../enum';
+export declare function useThemeHooks(initValue: EProLayoutTheme): {
+    currentTheme: Readonly<Ref<EProLayoutTheme>>;
+    onToggleCurrentTheme: () => void;
+};

package/es/pro-layout/hooks/theme.js

@@ -0,0 +1,41 @@
+import { ref, watch, readonly } from "vue";
+import { EProLayoutTheme } from "../enum.js";
+function useThemeHooks(initValue) {
+  const themeStorageKey = "theme";
+  const theme = ref(localStorage.getItem(themeStorageKey) ?? initValue);
+  const setTheme = (_theme) => {
+    switch (_theme) {
+      case EProLayoutTheme.light:
+        document.body.removeAttribute("arco-theme");
+        break;
+      case EProLayoutTheme.dark:
+        document.body.setAttribute("arco-theme", "dark");
+        break;
+    }
+    theme.value = _theme;
+    localStorage.setItem(themeStorageKey, theme.value);
+  };
+  const onToggleTheme = () => {
+    switch (theme.value) {
+      case EProLayoutTheme.light:
+        setTheme(EProLayoutTheme.dark);
+        break;
+      case EProLayoutTheme.dark:
+        setTheme(EProLayoutTheme.light);
+        break;
+    }
+  };
+  watch(theme, () => {
+    setTheme(theme.value);
+  }, { immediate: true });
+  watch(() => initValue, () => {
+    setTheme(initValue);
+  });
+  return {
+    currentTheme: readonly(theme),
+    onToggleCurrentTheme: onToggleTheme
+  };
+}
+export {
+  useThemeHooks
+};

package/es/pro-layout/index.d.ts

@@ -0,0 +1,379 @@
+import type { EProLayoutTheme } from './enum';
+import type { IProMenuItem } from '../pro-menu';
+import type { ComponentInternalInstance, ExtractPropTypes, PropType, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentPublicInstance, ComponentOptionsBase, Ref, ComputedRef, ComponentOptionsMixin, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, App } from 'vue';
+declare const ProLayout: {
+    new (...args: any[]): {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            menuItems: IProMenuItem[];
+            headerTitle: string;
+            headerLogo: string;
+            headerRightItemSlotNames: string[];
+            hideThemeItem: boolean;
+            footerTitle: string;
+            theme: EProLayoutTheme;
+            tabsMode: boolean;
+            user: {
+                name: string;
+                avatar?: string | undefined;
+            };
+        }> & Omit<Readonly<ExtractPropTypes<{
+            menuItems: {
+                type: PropType<IProMenuItem[]>;
+                required: false;
+                default: () => never[];
+            };
+            headerTitle: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            headerLogo: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            headerRightItemSlotNames: {
+                type: PropType<string[]>;
+                required: false;
+                default: () => never[];
+            };
+            hideThemeItem: {
+                type: PropType<boolean>;
+                required: false;
+                default: boolean;
+            };
+            footerTitle: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            theme: {
+                type: PropType<EProLayoutTheme>;
+                required: false;
+                default: EProLayoutTheme;
+            };
+            tabsMode: {
+                type: PropType<boolean>;
+                required: false;
+                default: boolean;
+            };
+            user: {
+                type: PropType<{
+                    name: string;
+                    avatar?: string | undefined;
+                }>;
+                required: false;
+                default: undefined;
+            };
+        }>> & VNodeProps & AllowedComponentProps & ComponentCustomProps, "menuItems" | "headerTitle" | "headerLogo" | "headerRightItemSlotNames" | "hideThemeItem" | "footerTitle" | "theme" | "tabsMode" | "user">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot | undefined;
+        }>;
+        $root: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<ExtractPropTypes<{
+            menuItems: {
+                type: PropType<IProMenuItem[]>;
+                required: false;
+                default: () => never[];
+            };
+            headerTitle: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            headerLogo: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            headerRightItemSlotNames: {
+                type: PropType<string[]>;
+                required: false;
+                default: () => never[];
+            };
+            hideThemeItem: {
+                type: PropType<boolean>;
+                required: false;
+                default: boolean;
+            };
+            footerTitle: {
+                type: PropType<string>;
+                required: false;
+                default: string;
+            };
+            theme: {
+                type: PropType<EProLayoutTheme>;
+                required: false;
+                default: EProLayoutTheme;
+            };
+            tabsMode: {
+                type: PropType<boolean>;
+                required: false;
+                default: boolean;
+            };
+            user: {
+                type: PropType<{
+                    name: string;
+                    avatar?: string | undefined;
+                }>;
+                required: false;
+                default: undefined;
+            };
+        }>>, {
+            prefixClsName: string;
+            props: any;
+            menuItems: Ref<IProMenuItem[]>;
+            slots: Readonly<{
+                [name: string]: Slot | undefined;
+            }>;
+            currentTheme: Readonly<Ref<EProLayoutTheme>>;
+            onToggleCurrentTheme: () => void;
+            menuSelectedKeys: Ref<string[]>;
+            menuOpenKeys: Ref<string[]>;
+            onMenuItemClick: (key: string) => void;
+            onSubMenuClick: (key: string, openKeys: string[]) => void;
+            activeMenuItem: Ref<IProMenuItem | undefined>;
+            breadcrumbItems: Ref<string[]>;
+            tabs: Ref<{
+                name: string;
+                title: string;
+                fullPath: string;
+                active: boolean;
+            }[]>;
+            onTabClick: (key: string) => void;
+            onTabDelete: (key: string) => void;
+            keepAliveKeys: ComputedRef<string[]>;
+            siderWidth: number;
+            siderCollapsedWidth: number;
+            siderWidthPx: string;
+            siderCollapsedWidthPx: string;
+            siderCollapsed: Ref<boolean>;
+            onSiderCollapse: (val: boolean) => void;
+            readonly EProLayoutTheme: typeof EProLayoutTheme;
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+            menuItems: IProMenuItem[];
+            headerTitle: string;
+            headerLogo: string;
+            headerRightItemSlotNames: string[];
+            hideThemeItem: boolean;
+            footerTitle: string;
+            theme: EProLayoutTheme;
+            tabsMode: boolean;
+            user: {
+                name: string;
+                avatar?: string | undefined;
+            };
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: WatchOptions<boolean> | undefined): WatchStopHandle;
+    } & Readonly<ExtractPropTypes<{
+        menuItems: {
+            type: PropType<IProMenuItem[]>;
+            required: false;
+            default: () => never[];
+        };
+        headerTitle: {
+            type: PropType<string>;
+            required: false;
+            default: string;
+        };
+        headerLogo: {
+            type: PropType<string>;
+            required: false;
+            default: string;
+        };
+        headerRightItemSlotNames: {
+            type: PropType<string[]>;
+            required: false;
+            default: () => never[];
+        };
+        hideThemeItem: {
+            type: PropType<boolean>;
+            required: false;
+            default: boolean;
+        };
+        footerTitle: {
+            type: PropType<string>;
+            required: false;
+            default: string;
+        };
+        theme: {
+            type: PropType<EProLayoutTheme>;
+            required: false;
+            default: EProLayoutTheme;
+        };
+        tabsMode: {
+            type: PropType<boolean>;
+            required: false;
+            default: boolean;
+        };
+        user: {
+            type: PropType<{
+                name: string;
+                avatar?: string | undefined;
+            }>;
+            required: false;
+            default: undefined;
+        };
+    }>> & ShallowUnwrapRef<{
+        prefixClsName: string;
+        props: any;
+        menuItems: Ref<IProMenuItem[]>;
+        slots: Readonly<{
+            [name: string]: Slot | undefined;
+        }>;
+        currentTheme: Readonly<Ref<EProLayoutTheme>>;
+        onToggleCurrentTheme: () => void;
+        menuSelectedKeys: Ref<string[]>;
+        menuOpenKeys: Ref<string[]>;
+        onMenuItemClick: (key: string) => void;
+        onSubMenuClick: (key: string, openKeys: string[]) => void;
+        activeMenuItem: Ref<IProMenuItem | undefined>;
+        breadcrumbItems: Ref<string[]>;
+        tabs: Ref<{
+            name: string;
+            title: string;
+            fullPath: string;
+            active: boolean;
+        }[]>;
+        onTabClick: (key: string) => void;
+        onTabDelete: (key: string) => void;
+        keepAliveKeys: ComputedRef<string[]>;
+        siderWidth: number;
+        siderCollapsedWidth: number;
+        siderWidthPx: string;
+        siderCollapsedWidthPx: string;
+        siderCollapsed: Ref<boolean>;
+        onSiderCollapse: (val: boolean) => void;
+        readonly EProLayoutTheme: typeof EProLayoutTheme;
+    }> & {} & ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<{
+    menuItems: {
+        type: PropType<IProMenuItem[]>;
+        required: false;
+        default: () => never[];
+    };
+    headerTitle: {
+        type: PropType<string>;
+        required: false;
+        default: string;
+    };
+    headerLogo: {
+        type: PropType<string>;
+        required: false;
+        default: string;
+    };
+    headerRightItemSlotNames: {
+        type: PropType<string[]>;
+        required: false;
+        default: () => never[];
+    };
+    hideThemeItem: {
+        type: PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    footerTitle: {
+        type: PropType<string>;
+        required: false;
+        default: string;
+    };
+    theme: {
+        type: PropType<EProLayoutTheme>;
+        required: false;
+        default: EProLayoutTheme;
+    };
+    tabsMode: {
+        type: PropType<boolean>;
+        required: false;
+        default: boolean;
+    };
+    user: {
+        type: PropType<{
+            name: string;
+            avatar?: string | undefined;
+        }>;
+        required: false;
+        default: undefined;
+    };
+}>>, {
+    prefixClsName: string;
+    props: any;
+    menuItems: Ref<IProMenuItem[]>;
+    slots: Readonly<{
+        [name: string]: Slot | undefined;
+    }>;
+    currentTheme: Readonly<Ref<EProLayoutTheme>>;
+    onToggleCurrentTheme: () => void;
+    menuSelectedKeys: Ref<string[]>;
+    menuOpenKeys: Ref<string[]>;
+    onMenuItemClick: (key: string) => void;
+    onSubMenuClick: (key: string, openKeys: string[]) => void;
+    activeMenuItem: Ref<IProMenuItem | undefined>;
+    breadcrumbItems: Ref<string[]>;
+    tabs: Ref<{
+        name: string;
+        title: string;
+        fullPath: string;
+        active: boolean;
+    }[]>;
+    onTabClick: (key: string) => void;
+    onTabDelete: (key: string) => void;
+    keepAliveKeys: ComputedRef<string[]>;
+    siderWidth: number;
+    siderCollapsedWidth: number;
+    siderWidthPx: string;
+    siderCollapsedWidthPx: string;
+    siderCollapsed: Ref<boolean>;
+    onSiderCollapse: (val: boolean) => void;
+    readonly EProLayoutTheme: typeof EProLayoutTheme;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    menuItems: IProMenuItem[];
+    headerTitle: string;
+    headerLogo: string;
+    headerRightItemSlotNames: string[];
+    hideThemeItem: boolean;
+    footerTitle: string;
+    theme: EProLayoutTheme;
+    tabsMode: boolean;
+    user: {
+        name: string;
+        avatar?: string | undefined;
+    };
+}, {}, string> & VNodeProps & AllowedComponentProps & ComponentCustomProps & {
+    install: (app: App) => void;
+};
+export * from './enum';
+export { ProLayout };
+export default ProLayout;

package/es/pro-layout/index.js

@@ -0,0 +1,25 @@
+import _sfc_main from "./pro-layout.vue.js";
+import "./pro-layout.vue2.js";
+import { Layout, Space, Typography, Tooltip, Button, Dropdown, Avatar } from "@arco-design/web-vue";
+import { ProMenu } from "../pro-menu/index.js";
+import { ProReuseTabs } from "../pro-reuse-tabs/index.js";
+import { ProPageWrapper } from "../pro-page-wrapper/index.js";
+const ProLayout = Object.assign(_sfc_main, {
+  install: (app) => {
+    app.use(Layout);
+    app.use(Space);
+    app.use(Typography);
+    app.use(Tooltip);
+    app.use(Button);
+    app.use(Dropdown);
+    app.use(Avatar);
+    app.use(ProMenu);
+    app.use(ProReuseTabs);
+    app.use(ProPageWrapper);
+    app.component("KbProLayout", _sfc_main);
+  }
+});
+export {
+  ProLayout,
+  ProLayout as default
+};