yc-design-vue 1.7.6 → 1.7.8

package/es/List/index.js

@@ -1,17 +1,20 @@
-import _List from "./List.vue.js";
-import ListItem from "./ListItem.vue.js";
-import ListItemMeta from "./ListItemMeta.vue.js";
-const List = Object.assign(_List, {
-  item: ListItem,
-  ["item-meta"]: ListItemMeta,
+import _sfc_main from "./List.vue.js";
+/* empty css          */
+import _sfc_main$2 from "./ListItem.vue.js";
+/* empty css              */
+import _sfc_main$1 from "./ListItemMeta.vue.js";
+/* empty css                  */
+const List = Object.assign(_sfc_main, {
+  item: _sfc_main$2,
+  ["item-meta"]: _sfc_main$1,
   install: (app) => {
-    app.component("Yc" + _List.name, _List);
-    app.component("Yc" + ListItem.name, ListItem);
-    app.component("Yc" + ListItemMeta.name, ListItemMeta);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
+    app.component("Yc" + _sfc_main$2.name, _sfc_main$2);
+    app.component("Yc" + _sfc_main$1.name, _sfc_main$1);
   }
 });
 export {
-  ListItem,
-  ListItemMeta,
+  _sfc_main$2 as ListItem,
+  _sfc_main$1 as ListItemMeta,
   List as default
 };

package/es/Menu/Menu.vue.js

@@ -1,7 +1,99 @@
-import _sfc_main from "./Menu.vue2.js";
-/* empty css          */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Menu = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fb059e13"]]);
+import { defineComponent, ref, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createElementVNode, createCommentVNode, renderSlot, createBlock } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { mediaQueryHandler } from "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import _sfc_main$2 from "../_shared/icons/IconMenuFold.vue.js";
+import _sfc_main$3 from "../_shared/icons/IconMenuUnfold.vue.js";
+import useMenuContext from "./hooks/useContext.js";
+import _sfc_main$1 from "./MenuEllipsis.vue.js";
+/* empty css                  */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Menu",
+    inheritAttrs: false
+  },
+  __name: "Menu",
+  props: {
+    theme: { default: void 0 },
+    mode: { default: "vertical" },
+    levelIndent: { default: 20 },
+    autoOpen: { type: Boolean, default: false },
+    collapsed: { type: Boolean, default: void 0 },
+    defaultCollapsed: { type: Boolean, default: false },
+    collapsedWidth: { default: 48 },
+    accordion: { type: Boolean, default: false },
+    showCollapseButton: { type: Boolean, default: false },
+    selectedKeys: { default: void 0 },
+    defaultSelectedKeys: { default: "" },
+    openKeys: { default: void 0 },
+    defaultOpenKeys: { default: () => [] },
+    breakpoint: { default: void 0 },
+    triggerProps: { default: () => {
+      return {};
+    } },
+    tooltipProps: { default: () => {
+      return {};
+    } },
+    autoOpenSelected: { type: Boolean, default: false },
+    autoScrollIntoView: { type: Boolean, default: false },
+    scrollConfig: {},
+    popupMaxHeight: { type: [Boolean, Number], default: 167 }
+  },
+  emits: ["update:selectedKeys", "update:openKeys", "update:collapsed", "collapse", "menu-item-click", "sub-menu-click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const menuRef = ref();
+    const { computedCollapsed, collapsedWidth, breakpoint, menuTree, max, theme } = useMenuContext().provide(props, emits, menuRef);
+    const handleClick = () => {
+      const value = !computedCollapsed.value;
+      computedCollapsed.value = value;
+      emits("collapse", value, "clickTrigger");
+    };
+    mediaQueryHandler((_, order, i) => {
+      if (!breakpoint.value) return;
+      const value = i <= order[breakpoint.value];
+      computedCollapsed.value = value;
+      emits("collapse", value, "responsive");
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-menu",
+          `yc-menu-mode-${_ctx.mode}`,
+          `yc-menu-${unref(theme)}`,
+          _ctx.$attrs.class,
+          {
+            "yc-menu-collapsed": unref(computedCollapsed) && _ctx.mode != "horizontal"
+          }
+        ]),
+        style: normalizeStyle({
+          ..._ctx.$attrs.style || {},
+          width: unref(computedCollapsed) ? unref(collapsedWidth) : (_a = _ctx.$attrs.style) == null ? void 0 : _a.width
+        })
+      }, [
+        createElementVNode("div", {
+          class: "yc-menu-inner",
+          ref_key: "menuRef",
+          ref: menuRef
+        }, [
+          renderSlot(_ctx.$slots, "default"),
+          _ctx.mode == "horizontal" && unref(max) < unref(menuTree).length ? (openBlock(), createBlock(_sfc_main$1, { key: 0 })) : createCommentVNode("", true)
+        ], 512),
+        _ctx.showCollapseButton && _ctx.mode != "horizontal" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "yc-menu-collapse-button",
+          onClick: handleClick
+        }, [
+          !unref(computedCollapsed) ? (openBlock(), createBlock(unref(_sfc_main$2), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$3), { key: 1 }))
+        ])) : createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
 export {
-  _Menu as default
+  _sfc_main as default
 };

package/es/Menu/Menu.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./Menu.vue.js";
+/* empty css          */
+export {
+  _sfc_main as default
+};

package/es/Menu/MenuEllipsis.vue.js

@@ -1,7 +1,94 @@
-import _sfc_main from "./MenuEllipsis.vue2.js";
-/* empty css                  */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const MenuEllipsis = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4ac4d739"]]);
+import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, createVNode, unref, withCtx, createElementVNode, Fragment, renderList, createBlock } from "vue";
+import _sfc_main$2 from "../_shared/icons/IconArrowDown.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import _sfc_main$1 from "../_shared/icons/IconMore.vue.js";
+import useMenuContext, { isMenuItemActive } from "./hooks/useContext.js";
+import _sfc_main$3 from "./MenuPopOption.vue.js";
+import Dropdown from "../Dropdown/index.js";
+const _hoisted_1 = {
+  class: /* @__PURE__ */ normalizeClass(["yc-menu-item-wrapper", "yc-menu-item-mode-horizontal"])
+};
+const _hoisted_2 = { class: "yc-menu-item-title" };
+const _hoisted_3 = { class: "yc-menu-icon-suffix" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MenuEllipsis",
+  setup(__props) {
+    const {
+      computedSelectedKeys,
+      theme,
+      triggerProps,
+      popupMaxHeight,
+      menuTree,
+      max,
+      emits
+    } = useMenuContext().inject();
+    const submenus = computed(() => menuTree.value.slice(max.value));
+    const isSelected = computed(() => {
+      return submenus.value.some((item) => {
+        return isMenuItemActive(
+          menuTree.value,
+          item.path,
+          computedSelectedKeys.value
+        );
+      });
+    });
+    const handleSelect = (value) => {
+      if (computedSelectedKeys.value == value) return;
+      computedSelectedKeys.value = value;
+      emits("menu-item-click", value);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(unref(Dropdown), {
+          "popup-max-height": unref(popupMaxHeight),
+          "trigger-props": {
+            position: "bl",
+            popupOffset: 20,
+            showArrow: true,
+            ...unref(triggerProps)
+          },
+          onSelect: handleSelect
+        }, {
+          content: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(submenus.value, (node) => {
+              return openBlock(), createBlock(_sfc_main$3, {
+                key: node.path,
+                "tree-node": node,
+                "popup-max-height": unref(popupMaxHeight),
+                "trigger-props": unref(triggerProps),
+                "computed-selected-keys": unref(computedSelectedKeys)
+              }, null, 8, ["tree-node", "popup-max-height", "trigger-props", "computed-selected-keys"]);
+            }), 128))
+          ]),
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "yc-menu-item",
+                "yc-menu-item-ellipsis",
+                `yc-menu-item-${unref(theme)}`,
+                {
+                  "yc-menu-item-selected": isSelected.value
+                }
+              ])
+            }, [
+              createElementVNode("div", _hoisted_2, [
+                createVNode(unref(_sfc_main$1))
+              ]),
+              createElementVNode("div", _hoisted_3, [
+                createVNode(unref(_sfc_main$2))
+              ])
+            ], 2)
+          ]),
+          _: 1
+        }, 8, ["popup-max-height", "trigger-props"])
+      ]);
+    };
+  }
+});
 export {
-  MenuEllipsis as default
+  _sfc_main as default
 };

package/es/Menu/MenuEllipsis.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./MenuEllipsis.vue.js";
+/* empty css                  */
+export {
+  _sfc_main as default
+};

package/es/Menu/MenuItem.vue.js

@@ -1,7 +1,232 @@
-import _sfc_main from "./MenuItem.vue2.js";
-/* empty css              */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const MenuItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b7fff6ba"]]);
+import { defineComponent, toRefs, useAttrs, computed, ref, onMounted, createElementBlock, createCommentVNode, unref, openBlock, normalizeClass, createVNode, createBlock, withCtx, createElementVNode, withDirectives, normalizeStyle, renderSlot, vShow, Fragment, renderList, resolveDynamicComponent } from "vue";
+import { createReusableTemplate } from "../node_modules/@vueuse/core/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../_shared/utils/dom.js";
+import { isUndefined } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import useMenuContext, { isMenuItemActive, getPopupMaxHeight } from "./hooks/useContext.js";
+import _sfc_main$1 from "./MenuPopOption.vue.js";
+import Dropdown from "../Dropdown/index.js";
+import Tooltip from "../Tooltip/index.js";
+const _hoisted_1 = {
+  key: 1,
+  class: "yc-menu-icon"
+};
+const _hoisted_2 = {
+  key: 2,
+  class: "yc-menu-icon-suffix"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "MenuItem"
+  },
+  __name: "MenuItem",
+  props: {
+    path: { default: "" },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const { path, disabled } = toRefs(props);
+    const { reuse: ReuseTemplate, define: DefineTemplate } = createReusableTemplate();
+    const attrs = useAttrs();
+    const {
+      computedSelectedKeys,
+      computedOpenKeys,
+      computedCollapsed,
+      levelIndent,
+      mode,
+      theme,
+      autoOpen,
+      autoOpenSelected,
+      accordion,
+      triggerProps,
+      tooltipProps,
+      autoScrollIntoView,
+      scrollConfig,
+      popupMaxHeight: _popupMaxHeight,
+      menuTreeNodes,
+      menuTree,
+      max,
+      menuItemWidths,
+      emits
+    } = useMenuContext().inject();
+    const curNode = computed(() => {
+      const node = menuTreeNodes.value.find(
+        (item) => item.path == path.value
+      ) || { type: "menuitem", level: 0 };
+      return node;
+    });
+    const curIndex = computed(() => {
+      return menuTree.value.findIndex((item) => item.path == path.value);
+    });
+    const submenus = computed(() => {
+      var _a;
+      return ((_a = menuTree.value[curIndex.value]) == null ? void 0 : _a.children) || [];
+    });
+    const isSubmenu = computed(() => {
+      return curNode.value.type == "submenu";
+    });
+    const isRoot = computed(() => {
+      return curNode.value.level === 0;
+    });
+    const isSelected = computed(() => {
+      return isMenuItemActive(
+        menuTree.value,
+        path.value,
+        computedSelectedKeys.value
+      );
+    });
+    const popupMaxHeight = computed(() => {
+      return !isUndefined(attrs.popupMaxHeight) ? getPopupMaxHeight(attrs.popupMaxHeight) : _popupMaxHeight.value;
+    });
+    const menuItemRef = ref();
+    const handleSelect = (value) => {
+      if (computedSelectedKeys.value == value) return;
+      computedSelectedKeys.value = value;
+      emits("menu-item-click", value);
+    };
+    const handleClick = () => {
+      if (mode.value != "vertical" && isSubmenu.value || computedCollapsed.value) {
+        return;
+      }
+      if (!isSubmenu.value && !disabled.value && computedSelectedKeys.value != path.value) {
+        computedSelectedKeys.value = path.value;
+        return emits("menu-item-click", path.value);
+      }
+      if (computedOpenKeys.value.includes(path.value)) {
+        computedOpenKeys.value = computedOpenKeys.value.filter(
+          (item) => item != path.value
+        );
+      } else {
+        computedOpenKeys.value = accordion.value ? [path.value] : [...computedOpenKeys.value, path.value];
+      }
+      emits("sub-menu-click", path.value, computedOpenKeys.value);
+    };
+    onMounted(() => {
+      var _a;
+      if (isRoot.value) {
+        menuItemWidths.value[curIndex.value] = menuItemRef.value.offsetWidth;
+      }
+      if (autoScrollIntoView.value && computedSelectedKeys.value == path.value) {
+        (_a = menuItemRef.value) == null ? void 0 : _a.scrollIntoView(scrollConfig.value);
+      }
+      if (!isSubmenu.value || !autoOpen.value || !autoOpenSelected.value || !isSelected.value) {
+        return;
+      }
+      computedOpenKeys.value.push(path.value);
+    });
+    return (_ctx, _cache) => {
+      return curIndex.value < unref(max) ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        class: normalizeClass([
+          "yc-menu-item-wrapper",
+          `yc-menu-item-${unref(theme)}`,
+          {
+            "yc-menu-item-mode-horizontal": unref(mode) == "horizontal"
+          }
+        ])
+      }, [
+        createVNode(unref(DefineTemplate), null, {
+          default: withCtx(() => [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "yc-menu-item",
+                {
+                  "yc-menu-item-selected": isSelected.value,
+                  "yc-menu-item-disabled": unref(disabled),
+                  "yc-menu-item-collapsed": unref(computedCollapsed)
+                }
+              ]),
+              ref_key: "menuItemRef",
+              ref: menuItemRef,
+              onClick: handleClick
+            }, [
+              !isRoot.value ? (openBlock(), createElementBlock("div", {
+                key: 0,
+                class: "yc-menu-indent",
+                style: normalizeStyle({
+                  width: unref(valueToPx)(unref(levelIndent) * curNode.value.level),
+                  height: unref(valueToPx)(unref(levelIndent))
+                })
+              }, null, 4)) : createCommentVNode("", true),
+              _ctx.$slots.icon ? (openBlock(), createElementBlock("div", _hoisted_1, [
+                renderSlot(_ctx.$slots, "icon")
+              ])) : createCommentVNode("", true),
+              withDirectives(createElementVNode("div", {
+                class: normalizeClass([
+                  "yc-menu-item-title",
+                  {
+                    "text-ellipsis": unref(mode) != "horizontal"
+                  }
+                ])
+              }, [
+                renderSlot(_ctx.$slots, "default")
+              ], 2), [
+                [vShow, !unref(computedCollapsed)]
+              ]),
+              _ctx.$slots.suffix ? withDirectives((openBlock(), createElementBlock("div", _hoisted_2, [
+                renderSlot(_ctx.$slots, "suffix")
+              ], 512)), [
+                [vShow, !unref(computedCollapsed)]
+              ]) : createCommentVNode("", true)
+            ], 2)
+          ]),
+          _: 3
+        }),
+        isSubmenu.value && isRoot.value && (unref(mode) != "vertical" || unref(computedCollapsed)) ? (openBlock(), createBlock(unref(Dropdown), {
+          key: 0,
+          "popup-max-height": popupMaxHeight.value,
+          "trigger-props": {
+            autoFitPosition: false,
+            position: unref(mode) == "horizontal" ? "bl" : "rt",
+            animationName: unref(mode) == "horizontal" ? "slide-dynamic-origin" : "zoom-in-fade-out",
+            popupOffset: unref(mode) == "vertical" ? 14 : 20,
+            showArrow: true,
+            ...unref(triggerProps)
+          },
+          onSelect: handleSelect
+        }, {
+          content: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(submenus.value, (node) => {
+              return openBlock(), createBlock(_sfc_main$1, {
+                key: node.path,
+                "tree-node": node,
+                "popup-max-height": popupMaxHeight.value,
+                "trigger-props": unref(triggerProps),
+                "computed-selected-keys": unref(computedSelectedKeys)
+              }, null, 8, ["tree-node", "popup-max-height", "trigger-props", "computed-selected-keys"]);
+            }), 128))
+          ]),
+          default: withCtx(() => [
+            createVNode(unref(ReuseTemplate))
+          ]),
+          _: 1
+        }, 8, ["popup-max-height", "trigger-props"])) : !isSubmenu.value && isRoot.value && unref(computedCollapsed) ? (openBlock(), createBlock(unref(Tooltip), {
+          key: 1,
+          position: "rt",
+          "trigger-props": {
+            autoFitPosition: false,
+            popupOffset: unref(mode) == "vertical" ? 14 : 18,
+            showArrow: true,
+            ...unref(tooltipProps),
+            ...unref(triggerProps)
+          }
+        }, {
+          content: withCtx(() => [
+            (openBlock(), createBlock(resolveDynamicComponent(_ctx.$slots.default)))
+          ]),
+          default: withCtx(() => [
+            createVNode(unref(ReuseTemplate))
+          ]),
+          _: 1
+        }, 8, ["trigger-props"])) : (openBlock(), createBlock(unref(ReuseTemplate), { key: 2 }))
+      ], 2)) : createCommentVNode("", true);
+    };
+  }
+});
 export {
-  MenuItem as default
+  _sfc_main as default
 };

package/es/Menu/MenuItem.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./MenuItem.vue.js";
+/* empty css              */
+export {
+  _sfc_main as default
+};

package/es/Menu/MenuItemGroup.vue.js

@@ -1,7 +1,42 @@
-import _sfc_main from "./MenuItemGroup.vue2.js";
-/* empty css                   */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const MenuItemGroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-dbb6c4a3"]]);
+import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, renderSlot, createTextVNode, toDisplayString, normalizeStyle } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import useMenuContext from "./hooks/useContext.js";
+const _hoisted_1 = { class: "yc-menu-group-title text-ellipsis" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "MenuItemGroup"
+  },
+  __name: "MenuItemGroup",
+  props: {
+    title: { default: "" }
+  },
+  setup(__props) {
+    const { levelIndent, theme } = useMenuContext().inject();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["yc-menu-group", `yc-menu-group-${unref(theme)}`])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(_ctx.title), 1)
+          ])
+        ]),
+        createElementVNode("div", {
+          class: "yc-menu-group-content",
+          style: normalizeStyle({
+            paddingLeft: unref(valueToPx)(unref(levelIndent))
+          })
+        }, [
+          renderSlot(_ctx.$slots, "default")
+        ], 4)
+      ], 2);
+    };
+  }
+});
 export {
-  MenuItemGroup as default
+  _sfc_main as default
 };

package/es/Menu/MenuItemGroup.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./MenuItemGroup.vue.js";
+/* empty css                   */
+export {
+  _sfc_main as default
+};

package/es/Menu/MenuPopOption.vue.js

@@ -1,7 +1,9 @@
 import { defineComponent, resolveComponent, createBlock, openBlock, unref, withCtx, resolveDynamicComponent, createElementBlock, Fragment, renderList } from "vue";
 import "../Dropdown/index.js";
-import Doption from "../Dropdown/Doption.vue.js";
-import Dsubmenu from "../Dropdown/Dsubmenu.vue.js";
+import _sfc_main$1 from "../Dropdown/Doption.vue.js";
+/* empty css                       */
+import _sfc_main$2 from "../Dropdown/Dsubmenu.vue.js";
+/* empty css                        */
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
     name: "PopOption"
@@ -16,7 +18,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props) {
     return (_ctx, _cache) => {
       const _component_pop_option = resolveComponent("pop-option");
-      return _ctx.treeNode.type == "menuitem" ? (openBlock(), createBlock(unref(Doption), {
+      return _ctx.treeNode.type == "menuitem" ? (openBlock(), createBlock(unref(_sfc_main$1), {
         key: 0,
         value: _ctx.treeNode.path,
         "is-active": _ctx.computedSelectedKeys == _ctx.treeNode.path
@@ -25,7 +27,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           (openBlock(), createBlock(resolveDynamicComponent(_ctx.treeNode.label)))
         ]),
         _: 1
-      }, 8, ["value", "is-active"])) : (openBlock(), createBlock(unref(Dsubmenu), {
+      }, 8, ["value", "is-active"])) : (openBlock(), createBlock(unref(_sfc_main$2), {
         key: 1,
         "popup-max-height": _ctx.popupMaxHeight,
         "trigger-props": {

package/es/Menu/SubMenu.vue.js

@@ -1,7 +1,81 @@
-import _sfc_main from "./SubMenu.vue2.js";
-/* empty css             */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const SubMenu = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ce1875b7"]]);
+import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, createVNode, createSlots, withCtx, renderSlot, createTextVNode, toDisplayString, withDirectives, createElementVNode, vShow } from "vue";
+import useMenuContext from "./hooks/useContext.js";
+import _sfc_main$2 from "../_shared/icons/IconArrowDown.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+/* empty css                                    */
+import _sfc_main$3 from "../_shared/components/ExpandTransition.vue2.js";
+/* empty css                                         */
+import "./index.js";
+import _sfc_main$1 from "./MenuItem.vue.js";
+/* empty css              */
+const _hoisted_1 = { class: "yc-menu-inline-content" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "SubMenu"
+  },
+  __name: "SubMenu",
+  props: {
+    path: { default: "" },
+    title: { default: "" },
+    selectable: { type: Boolean, default: false },
+    popup: { type: Boolean, default: false },
+    popupMaxHeight: { type: [Boolean, Number], default: void 0 }
+  },
+  setup(__props) {
+    const { mode, theme, computedOpenKeys, computedCollapsed } = useMenuContext().inject();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["yc-menu-inline", `yc-menu-inline-${unref(theme)}`])
+      }, [
+        createVNode(unref(_sfc_main$1), {
+          "is-submenu": "",
+          path: _ctx.path,
+          popupMaxHeight: _ctx.popupMaxHeight,
+          class: "yc-menu-inline-header"
+        }, createSlots({
+          suffix: withCtx(() => [
+            renderSlot(_ctx.$slots, "expand-icon-down", {}, () => [
+              createVNode(unref(_sfc_main$2), {
+                rotate: unref(computedOpenKeys).includes(_ctx.path) ? 180 : 0
+              }, null, 8, ["rotate"])
+            ])
+          ]),
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "title", {}, () => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ])
+          ]),
+          _: 2
+        }, [
+          _ctx.$slots.icon ? {
+            name: "icon",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "icon")
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["path", "popupMaxHeight"]),
+        createVNode(unref(_sfc_main$3), null, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", _hoisted_1, [
+              renderSlot(_ctx.$slots, "default")
+            ], 512), [
+              [
+                vShow,
+                unref(mode) == "vertical" && !unref(computedCollapsed) && unref(computedOpenKeys).includes(_ctx.path)
+              ]
+            ])
+          ]),
+          _: 3
+        })
+      ], 2);
+    };
+  }
+});
 export {
-  SubMenu as default
+  _sfc_main as default
 };

package/es/Menu/SubMenu.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./SubMenu.vue.js";
+/* empty css             */
+export {
+  _sfc_main as default
+};