yc-design-vue 1.0.1

package/es/Menu/hooks/useContext.js

@@ -0,0 +1,263 @@
+import { toRefs, computed, useSlots, ref, provide, inject, isVNode } from "vue";
+import "../../node_modules/tinycolor2/esm/tinycolor.js";
+import "../../_shared/utils/dom.js";
+import { throttle, valueToPx } from "../../_shared/utils/fn.js";
+import { isUndefined, isBoolean, isNumber, isObject, isFunction } from "../../_shared/utils/is.js";
+import "../../_shared/utils/time.js";
+import "../../Empty/index.js";
+/* empty css                            */
+import useControlValue from "../../_shared/utils/control.js";
+import "../index.js";
+import { nanoid } from "../../node_modules/nanoid/index.browser.js";
+import { useResizeObserver } from "../../node_modules/@vueuse/core/index.js";
+import SubMenu from "../SubMenu.vue.js";
+import MenuItem from "../MenuItem.vue.js";
+const MENU_CONTEXT_KEY = "menu-context";
+function FlattenMenuTree(vnodes, componentName) {
+  const result = [];
+  const traverse = (nodes, parentId = null, depth = 0) => {
+    var _a, _b, _c;
+    if (!nodes) return;
+    const nodeList = Array.isArray(nodes) ? nodes : [nodes];
+    for (const node of nodeList) {
+      if (!isVNode(node)) continue;
+      const id = nanoid(8);
+      const name = (_a = node.type) == null ? void 0 : _a.name;
+      const isSubMenu = name === SubMenu.name;
+      const props = node.props;
+      const children = node.children;
+      const subTree = (_b = node.component) == null ? void 0 : _b.subTree;
+      const childParentId = isSubMenu ? id : parentId;
+      const childDepth = isSubMenu ? depth + 1 : depth;
+      if (componentName.includes(name)) {
+        result.push({
+          id,
+          type: isSubMenu ? "submenu" : "menuitem",
+          label: () => {
+            var _a2, _b2;
+            if (isSubMenu) {
+              return ((_a2 = children.title) == null ? void 0 : _a2.call(children)) || props.title;
+            } else {
+              return (_b2 = children.default) == null ? void 0 : _b2.call(children);
+            }
+          },
+          path: props.path,
+          parentId,
+          level: depth
+        });
+      }
+      if (subTree) {
+        traverse(subTree);
+      } else if (Array.isArray(children)) {
+        traverse(children, childParentId, childDepth);
+      } else if (isObject(children)) {
+        for (const key of Object.keys(children)) {
+          if (!isFunction(children[key])) continue;
+          traverse(((_c = children[key]) == null ? void 0 : _c.call(children)) || [], childParentId, childDepth);
+        }
+      }
+    }
+  };
+  traverse(vnodes);
+  return result;
+}
+function buildMenuTree(flatData) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const tree = [];
+  flatData.forEach((node) => {
+    nodeMap.set(node.id, { ...node, children: [] });
+  });
+  nodeMap.forEach((node) => {
+    if (node.parentId === null) {
+      tree.push(node);
+    } else {
+      const parent = nodeMap.get(node.parentId);
+      if (parent) {
+        parent.children.push(node);
+      }
+    }
+  });
+  return tree;
+}
+function isMenuItemActive(menuTree, currentPath, activePath) {
+  if (currentPath === activePath) {
+    return true;
+  }
+  const findNode = (nodes, path) => {
+    for (const node of nodes) {
+      if (node.path === path) return node;
+      if (node.children && node.children.length > 0) {
+        const found = findNode(node.children, path);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  const currentNode = findNode(menuTree, currentPath);
+  if (!currentNode) return false;
+  const checkSubtree = (node, targetPath) => {
+    if (node.path === targetPath) return true;
+    if (node.children) {
+      return node.children.some(
+        (child) => checkSubtree(child, targetPath)
+      );
+    }
+    return false;
+  };
+  return checkSubtree(currentNode, activePath);
+}
+const getPopupMaxHeight = (popupMaxHeight) => {
+  if (isUndefined(popupMaxHeight) || isBoolean(popupMaxHeight) && popupMaxHeight) {
+    return 167;
+  }
+  if (isNumber(popupMaxHeight)) {
+    return popupMaxHeight;
+  }
+};
+const useContext = () => {
+  const provide$1 = (props, emits, menuRef) => {
+    const {
+      selectedKeys,
+      defaultSelectedKeys,
+      openKeys,
+      defaultOpenKeys,
+      levelIndent,
+      collapsed,
+      defaultCollapsed,
+      breakpoint,
+      accordion,
+      autoOpen,
+      triggerProps,
+      tooltipProps,
+      autoOpenSelected,
+      mode,
+      theme,
+      autoScrollIntoView,
+      scrollConfig,
+      collapsedWidth,
+      popupMaxHeight: _popupMaxHeight
+    } = toRefs(props);
+    const computedSelectedKeys = useControlValue(
+      selectedKeys,
+      defaultSelectedKeys.value,
+      (val) => {
+        emits("update:selectedKeys", val);
+      }
+    );
+    const computedCollapsed = useControlValue(
+      collapsed,
+      defaultCollapsed.value,
+      (val) => {
+        {
+          computedOpenKeys.value = [];
+        }
+        emits("update:collapsed", val);
+      }
+    );
+    const computedOpenKeys = useControlValue(
+      openKeys,
+      defaultOpenKeys.value,
+      (val) => {
+        emits("update:openKeys", val);
+      }
+    );
+    const popupMaxHeight = computed(() => {
+      return getPopupMaxHeight(_popupMaxHeight.value);
+    });
+    const slots = useSlots();
+    const menuTreeNodes = computed(() => {
+      var _a;
+      return FlattenMenuTree(((_a = slots.default) == null ? void 0 : _a.call(slots)) || [], [
+        SubMenu.name,
+        MenuItem.name
+      ]);
+    });
+    const menuItemWidths = ref([]);
+    const menuTree = computed(() => buildMenuTree(menuTreeNodes.value));
+    const max = ref(1e6);
+    if (mode.value == "horizontal") {
+      useResizeObserver(
+        menuRef,
+        throttle(() => {
+          const menuWidth = menuRef.value.offsetWidth - 52;
+          let maxCount = 0;
+          let totalWidth = 0;
+          for (let i = 0; i < menuTree.value.length; i++) {
+            const gap = i > 0 ? 4 : 0;
+            const curWidth = totalWidth + gap + menuItemWidths.value[i];
+            if (curWidth > menuWidth) {
+              break;
+            }
+            totalWidth = curWidth;
+            maxCount++;
+          }
+          max.value = maxCount;
+          console.log(max.value, "max");
+        }, 200)
+      );
+    }
+    provide(MENU_CONTEXT_KEY, {
+      computedSelectedKeys,
+      computedOpenKeys,
+      computedCollapsed,
+      levelIndent,
+      accordion,
+      autoOpen,
+      triggerProps,
+      tooltipProps,
+      mode,
+      autoOpenSelected,
+      popupMaxHeight,
+      autoScrollIntoView,
+      scrollConfig,
+      theme,
+      menuTreeNodes,
+      menuTree,
+      max,
+      menuItemWidths,
+      emits
+    });
+    return {
+      computedCollapsed,
+      breakpoint,
+      collapsedWidth: computed(() => valueToPx(collapsedWidth.value)),
+      menuTree,
+      max
+    };
+  };
+  const inject$1 = () => {
+    return inject(MENU_CONTEXT_KEY, {
+      computedSelectedKeys: ref(""),
+      computedOpenKeys: ref([]),
+      levelIndent: ref(20),
+      computedCollapsed: ref(false),
+      accordion: ref(false),
+      autoOpen: ref(false),
+      tooltipProps: ref({}),
+      triggerProps: ref({}),
+      autoOpenSelected: ref(false),
+      mode: ref("vertical"),
+      theme: ref("light"),
+      popupMaxHeight: ref(),
+      autoScrollIntoView: ref(false),
+      scrollConfig: ref({}),
+      menuTreeNodes: ref([]),
+      menuTree: ref([]),
+      max: ref(1e4),
+      menuItemWidths: ref([]),
+      emits: () => {
+      }
+    });
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  FlattenMenuTree,
+  buildMenuTree,
+  useContext as default,
+  getPopupMaxHeight,
+  isMenuItemActive
+};

package/es/Menu/index.d.ts

@@ -0,0 +1,214 @@
+import { App } from 'vue';
+import { default as _Menu } from './Menu.vue';
+import { default as _MenuItem } from './MenuItem.vue';
+import { default as _SubMenu } from './SubMenu.vue';
+import { default as _MenuItemGroup } from './MenuItemGroup.vue';
+export type MenuInstance = InstanceType<typeof _Menu>;
+export type MenuItemInstance = InstanceType<typeof _MenuItem>;
+export type SubMenuInstance = InstanceType<typeof _SubMenu>;
+export type MenuItemGroupInstance = InstanceType<typeof _MenuItemGroup>;
+export * from './type';
+declare const Menu: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MenuProps> & Readonly<{
+        onCollapse?: ((collapsed: boolean, type: "clickTrigger" | "responsive") => any) | undefined;
+        "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((value: string) => any) | undefined;
+        "onUpdate:openKeys"?: ((value: string) => any) | undefined;
+        "onMenu-item-click"?: ((key: string) => any) | undefined;
+        "onSub-menu-click"?: ((key: string, openKeys: string[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        collapse: (collapsed: boolean, type: "clickTrigger" | "responsive") => any;
+        "update:collapsed": (value: boolean) => any;
+        "update:selectedKeys": (value: string) => any;
+        "update:openKeys": (value: string) => any;
+        "menu-item-click": (key: string) => any;
+        "sub-menu-click": (key: string, openKeys: string[]) => any;
+    }, import('vue').PublicProps, {
+        mode: import('./type').MenuMode;
+        triggerProps: import('..').TriggerProps;
+        collapsed: boolean;
+        breakpoint: import('..').BreakpointName;
+        theme: import('..').Theme;
+        popupMaxHeight: import('./type').PopupMaxHeight;
+        accordion: boolean;
+        defaultCollapsed: boolean;
+        collapsedWidth: number | string;
+        selectedKeys: string;
+        defaultSelectedKeys: string;
+        openKeys: string[];
+        defaultOpenKeys: string[];
+        levelIndent: number;
+        autoOpen: boolean;
+        tooltipProps: import('..').TooltipProps;
+        autoOpenSelected: boolean;
+        autoScrollIntoView: boolean;
+        showCollapseButton: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        menuRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').MenuProps> & Readonly<{
+        onCollapse?: ((collapsed: boolean, type: "clickTrigger" | "responsive") => any) | undefined;
+        "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((value: string) => any) | undefined;
+        "onUpdate:openKeys"?: ((value: string) => any) | undefined;
+        "onMenu-item-click"?: ((key: string) => any) | undefined;
+        "onSub-menu-click"?: ((key: string, openKeys: string[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        mode: import('./type').MenuMode;
+        triggerProps: import('..').TriggerProps;
+        collapsed: boolean;
+        breakpoint: import('..').BreakpointName;
+        theme: import('..').Theme;
+        popupMaxHeight: import('./type').PopupMaxHeight;
+        accordion: boolean;
+        defaultCollapsed: boolean;
+        collapsedWidth: number | string;
+        selectedKeys: string;
+        defaultSelectedKeys: string;
+        openKeys: string[];
+        defaultOpenKeys: string[];
+        levelIndent: number;
+        autoOpen: boolean;
+        tooltipProps: import('..').TooltipProps;
+        autoOpenSelected: boolean;
+        autoScrollIntoView: boolean;
+        showCollapseButton: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').MenuProps> & Readonly<{
+    onCollapse?: ((collapsed: boolean, type: "clickTrigger" | "responsive") => any) | undefined;
+    "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((value: string) => any) | undefined;
+    "onUpdate:openKeys"?: ((value: string) => any) | undefined;
+    "onMenu-item-click"?: ((key: string) => any) | undefined;
+    "onSub-menu-click"?: ((key: string, openKeys: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    collapse: (collapsed: boolean, type: "clickTrigger" | "responsive") => any;
+    "update:collapsed": (value: boolean) => any;
+    "update:selectedKeys": (value: string) => any;
+    "update:openKeys": (value: string) => any;
+    "menu-item-click": (key: string) => any;
+    "sub-menu-click": (key: string, openKeys: string[]) => any;
+}, string, {
+    mode: import('./type').MenuMode;
+    triggerProps: import('..').TriggerProps;
+    collapsed: boolean;
+    breakpoint: import('..').BreakpointName;
+    theme: import('..').Theme;
+    popupMaxHeight: import('./type').PopupMaxHeight;
+    accordion: boolean;
+    defaultCollapsed: boolean;
+    collapsedWidth: number | string;
+    selectedKeys: string;
+    defaultSelectedKeys: string;
+    openKeys: string[];
+    defaultOpenKeys: string[];
+    levelIndent: number;
+    autoOpen: boolean;
+    tooltipProps: import('..').TooltipProps;
+    autoOpenSelected: boolean;
+    autoScrollIntoView: boolean;
+    showCollapseButton: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').MenuSlots> & import('./type').MenuSlots;
+}) & {
+    item: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MenuItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            disabled: boolean;
+            path: string;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            menuItemRef: HTMLDivElement;
+        }, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').MenuItemProps> & Readonly<{}>, {}, {}, {}, {}, {
+            disabled: boolean;
+            path: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').MenuItemProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        disabled: boolean;
+        path: string;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').MenuItemSlots> & import('./type').MenuItemSlots;
+    });
+    submenu: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').SubMenuProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            title: string;
+            path: string;
+            popupMaxHeight: import('./type').PopupMaxHeight;
+            selectable: boolean;
+            popup: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').SubMenuProps> & Readonly<{}>, {}, {}, {}, {}, {
+            title: string;
+            path: string;
+            popupMaxHeight: import('./type').PopupMaxHeight;
+            selectable: boolean;
+            popup: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').SubMenuProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        title: string;
+        path: string;
+        popupMaxHeight: import('./type').PopupMaxHeight;
+        selectable: boolean;
+        popup: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').SubMenuSlots> & import('./type').SubMenuSlots;
+    });
+    group: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').MenuItemGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            title: string;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').MenuItemGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+            title: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').MenuItemGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        title: string;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').MenuItemGroupSlots> & import('./type').MenuItemGroupSlots;
+    });
+    install: (app: App) => void;
+};
+export { _MenuItem as MenuItem, _MenuItemGroup as MenuItemGroup, _SubMenu as SubMenu, };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcMenu: typeof Menu;
+        YcSubMenu: typeof _SubMenu;
+        YcMenuItem: typeof _MenuItem;
+        YcMenuItemGroup: typeof _MenuItemGroup;
+    }
+}
+export default Menu;

package/es/Menu/index.js

@@ -0,0 +1,21 @@
+import _Menu from "./Menu.vue.js";
+import MenuItem from "./MenuItem.vue.js";
+import SubMenu from "./SubMenu.vue.js";
+import MenuItemGroup from "./MenuItemGroup.vue.js";
+const Menu = Object.assign(_Menu, {
+  item: MenuItem,
+  submenu: SubMenu,
+  group: MenuItemGroup,
+  install: (app) => {
+    app.component("Yc" + _Menu.name, _Menu);
+    app.component("Yc" + MenuItem.name, MenuItem);
+    app.component("Yc" + SubMenu.name, SubMenu);
+    app.component("Yc" + MenuItemGroup.name, MenuItemGroup);
+  }
+});
+export {
+  MenuItem,
+  MenuItemGroup,
+  SubMenu,
+  Menu as default
+};

package/es/Menu/type.d.ts

@@ -0,0 +1,68 @@
+import { BreakpointName } from '../Grid';
+import { TooltipProps } from '../Tooltip';
+import { TriggerProps } from '../Trigger';
+import { Theme } from '../_shared/type';
+export interface MenuProps {
+    theme?: Theme;
+    mode?: MenuMode;
+    levelIndent?: number;
+    autoOpen?: boolean;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    collapsedWidth?: number | string;
+    accordion?: boolean;
+    showCollapseButton?: boolean;
+    selectedKeys?: string;
+    defaultSelectedKeys?: string;
+    openKeys?: string[];
+    defaultOpenKeys?: string[];
+    breakpoint?: BreakpointName;
+    triggerProps?: TriggerProps;
+    tooltipProps?: TooltipProps;
+    autoOpenSelected?: boolean;
+    autoScrollIntoView?: boolean;
+    scrollConfig?: ScrollIntoViewOptions;
+    popupMaxHeight?: PopupMaxHeight;
+}
+export interface MenuEmits {
+    (e: 'update:selectedKeys', value: string): void;
+    (e: 'update:openKeys', value: string): void;
+    (e: 'update:collapsed', value: boolean): void;
+    (e: 'collapse', collapsed: boolean, type: 'clickTrigger' | 'responsive'): void;
+    (e: 'menu-item-click', key: string): void;
+    (e: 'sub-menu-click', key: string, openKeys: string[]): void;
+}
+export interface MenuSlots {
+    default(): void;
+}
+export interface SubMenuProps {
+    path?: string;
+    title?: string;
+    selectable?: boolean;
+    popup?: boolean;
+    popupMaxHeight?: PopupMaxHeight;
+}
+export interface SubMenuSlots {
+    default(): void;
+    title(): void;
+    icon(): void;
+    ['expand-icon-down'](): void;
+}
+export interface MenuItemProps {
+    path?: string;
+    disabled?: boolean;
+}
+export interface MenuItemSlots {
+    default(): void;
+    icon(): void;
+    suffix(): void;
+}
+export interface MenuItemGroupProps {
+    title?: string;
+}
+export interface MenuItemGroupSlots {
+    default(): void;
+    title(): void;
+}
+export type MenuMode = 'vertical' | 'horizontal';
+export type PopupMaxHeight = boolean | number;

package/es/Message/Message.vue.d.ts

@@ -0,0 +1,15 @@
+import { MessageProps } from './type';
+declare const _default: import('vue').DefineComponent<MessageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<MessageProps> & Readonly<{}>, {
+    duration: number;
+    content: import('../_shared/type').RenderContent;
+    icon: import('vue').RenderFunction;
+    type: import('./type').MessageType;
+    id: string;
+    onClose: (id: string | number) => void;
+    closable: boolean;
+    showIcon: boolean;
+    isReset: boolean;
+    onDestory: (id: string | number) => void;
+    resetOnHover: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLIElement>;
+export default _default;

package/es/Message/Message.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Message.vue2.js";
+/* empty css             */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const _Message = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2f248611"]]);
+export {
+  _Message as default
+};

package/es/Message/Message.vue2.js

@@ -0,0 +1,100 @@
+import { defineComponent, toRefs, watch, onMounted, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, createElementVNode, createBlock, resolveDynamicComponent, toDisplayString, createVNode } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { isUndefined } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import { TYPE_ICON_MAP } from "../_shared/constants/index.js";
+import IconButton from "../_shared/components/IconButton.vue.js";
+/* empty css                                         */
+import { useTimeoutFn } from "../node_modules/@vueuse/shared/index.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "yc-message-icon"
+};
+const _hoisted_2 = { class: "yc-message-content" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Message"
+  },
+  __name: "Message",
+  props: {
+    type: { default: "info" },
+    content: { type: [String, Array, Function], default: "" },
+    id: { default: "" },
+    icon: { type: Function, default: void 0 },
+    showIcon: { type: Boolean, default: true },
+    closable: { type: Boolean, default: false },
+    duration: { default: 3e3 },
+    isReset: { type: Boolean, default: false },
+    onClose: { type: Function, default: void 0 },
+    onDestory: { type: Function, default: void 0 },
+    resetOnHover: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const { type, id, duration, resetOnHover, isReset } = toRefs(props);
+    const { onClose, onDestory } = props;
+    const { start, stop } = useTimeoutFn(
+      () => {
+        onDestory == null ? void 0 : onDestory(id.value);
+        onClose == null ? void 0 : onClose(id.value);
+      },
+      () => duration.value,
+      {
+        immediate: false
+      }
+    );
+    const handleClose = () => {
+      stop();
+      onDestory == null ? void 0 : onDestory(id.value);
+      onClose == null ? void 0 : onClose(id.value);
+    };
+    const handleMouseenter = () => {
+      if (!resetOnHover.value || duration.value <= 0) return;
+      stop();
+    };
+    const handleMouseleave = () => {
+      if (!resetOnHover.value || duration.value <= 0) return;
+      start();
+    };
+    watch(
+      () => isReset.value,
+      (val) => {
+        if (duration.value <= 0 || !val) return;
+        stop();
+        start();
+      }
+    );
+    onMounted(() => {
+      if (duration.value <= 0) return;
+      start();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("li", {
+        role: "alert",
+        class: normalizeClass(["yc-message", `yc-message-${unref(type)}`]),
+        onMouseenter: handleMouseenter,
+        onMouseleave: handleMouseleave
+      }, [
+        (unref(type) != "normal" || !unref(isUndefined)(_ctx.icon)) && _ctx.showIcon ? (openBlock(), createElementBlock("span", _hoisted_1, [
+          (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon ?? unref(TYPE_ICON_MAP)[unref(type)]), {
+            spin: unref(type) == "loading"
+          }, null, 8, ["spin"]))
+        ])) : createCommentVNode("", true),
+        createElementVNode("span", _hoisted_2, toDisplayString(_ctx.content), 1),
+        _ctx.closable ? (openBlock(), createElementBlock("span", {
+          key: 1,
+          class: "yc-message-close-btn",
+          onClick: handleClose
+        }, [
+          createVNode(unref(IconButton))
+        ])) : createCommentVNode("", true)
+      ], 34);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};