@antsoo-lib/components 0.0.1

package/dist/src/menu/src/Menu.d.ts

@@ -0,0 +1,228 @@
+import { ExtractPropTypes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { FocusEventHandler, MouseEventHandler } from '../../_util/EventInterface';
+import { CSSMotionProps } from '../../_util/transition';
+import { CustomSlotsType, Key, VueNode } from '../../_util/type';
+import { ItemType } from './hooks/useItems';
+import { BuiltinPlacements, MenuClickEventHandler, MenuMode, MenuTheme, SelectEventHandler, TriggerSubMenuAction } from './interface';
+export declare const menuProps: () => {
+    id: StringConstructor;
+    prefixCls: StringConstructor;
+    items: PropType<ItemType[]>;
+    disabled: BooleanConstructor;
+    inlineCollapsed: BooleanConstructor;
+    disabledOverflow: BooleanConstructor;
+    forceSubMenuRender: BooleanConstructor;
+    openKeys: PropType<Key[]>;
+    selectedKeys: PropType<Key[]>;
+    activeKey: StringConstructor;
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabindex: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    motion: PropType<CSSMotionProps>;
+    role: StringConstructor;
+    theme: {
+        type: PropType<MenuTheme>;
+        default: string;
+    };
+    mode: {
+        type: PropType<MenuMode>;
+        default: string;
+    };
+    inlineIndent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuOpenDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuCloseDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    builtinPlacements: {
+        type: PropType<BuiltinPlacements>;
+    };
+    triggerSubMenuAction: {
+        type: PropType<TriggerSubMenuAction>;
+        default: string;
+    };
+    getPopupContainer: PropType<(node: HTMLElement) => HTMLElement>;
+    expandIcon: PropType<(p?: {
+        isOpen: boolean;
+        [key: string]: any;
+    }) => any>;
+    onOpenChange: PropType<(keys: Key[]) => void>;
+    onSelect: PropType<SelectEventHandler>;
+    onDeselect: PropType<SelectEventHandler>;
+    onClick: PropType<MenuClickEventHandler>;
+    onFocus: PropType<FocusEventHandler>;
+    onBlur: PropType<FocusEventHandler>;
+    onMousedown: PropType<MouseEventHandler>;
+    'onUpdate:openKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:selectedKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:activeKey': PropType<(key: Key) => void>;
+};
+export type MenuProps = Partial<ExtractPropTypes<ReturnType<typeof menuProps>>>;
+declare const _default: DefineComponent<ExtractPropTypes<{
+    id: StringConstructor;
+    prefixCls: StringConstructor;
+    items: PropType<ItemType[]>;
+    disabled: BooleanConstructor;
+    inlineCollapsed: BooleanConstructor;
+    disabledOverflow: BooleanConstructor;
+    forceSubMenuRender: BooleanConstructor;
+    openKeys: PropType<Key[]>;
+    selectedKeys: PropType<Key[]>;
+    activeKey: StringConstructor;
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabindex: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    motion: PropType<CSSMotionProps>;
+    role: StringConstructor;
+    theme: {
+        type: PropType<MenuTheme>;
+        default: string;
+    };
+    mode: {
+        type: PropType<MenuMode>;
+        default: string;
+    };
+    inlineIndent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuOpenDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuCloseDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    builtinPlacements: {
+        type: PropType<BuiltinPlacements>;
+    };
+    triggerSubMenuAction: {
+        type: PropType<TriggerSubMenuAction>;
+        default: string;
+    };
+    getPopupContainer: PropType<(node: HTMLElement) => HTMLElement>;
+    expandIcon: PropType<(p?: {
+        isOpen: boolean;
+        [key: string]: any;
+    }) => any>;
+    onOpenChange: PropType<(keys: Key[]) => void>;
+    onSelect: PropType<SelectEventHandler>;
+    onDeselect: PropType<SelectEventHandler>;
+    onClick: PropType<MenuClickEventHandler>;
+    onFocus: PropType<FocusEventHandler>;
+    onBlur: PropType<FocusEventHandler>;
+    onMousedown: PropType<MouseEventHandler>;
+    'onUpdate:openKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:selectedKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:activeKey': PropType<(key: Key) => void>;
+}>, () => VueNode, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    id: StringConstructor;
+    prefixCls: StringConstructor;
+    items: PropType<ItemType[]>;
+    disabled: BooleanConstructor;
+    inlineCollapsed: BooleanConstructor;
+    disabledOverflow: BooleanConstructor;
+    forceSubMenuRender: BooleanConstructor;
+    openKeys: PropType<Key[]>;
+    selectedKeys: PropType<Key[]>;
+    activeKey: StringConstructor;
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tabindex: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    motion: PropType<CSSMotionProps>;
+    role: StringConstructor;
+    theme: {
+        type: PropType<MenuTheme>;
+        default: string;
+    };
+    mode: {
+        type: PropType<MenuMode>;
+        default: string;
+    };
+    inlineIndent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuOpenDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    subMenuCloseDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    builtinPlacements: {
+        type: PropType<BuiltinPlacements>;
+    };
+    triggerSubMenuAction: {
+        type: PropType<TriggerSubMenuAction>;
+        default: string;
+    };
+    getPopupContainer: PropType<(node: HTMLElement) => HTMLElement>;
+    expandIcon: PropType<(p?: {
+        isOpen: boolean;
+        [key: string]: any;
+    }) => any>;
+    onOpenChange: PropType<(keys: Key[]) => void>;
+    onSelect: PropType<SelectEventHandler>;
+    onDeselect: PropType<SelectEventHandler>;
+    onClick: PropType<MenuClickEventHandler>;
+    onFocus: PropType<FocusEventHandler>;
+    onBlur: PropType<FocusEventHandler>;
+    onMousedown: PropType<MouseEventHandler>;
+    'onUpdate:openKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:selectedKeys': PropType<(keys: Key[]) => void>;
+    'onUpdate:activeKey': PropType<(key: Key) => void>;
+}>> & Readonly<{}>, {
+    multiple: boolean;
+    disabled: boolean;
+    mode: MenuMode;
+    theme: MenuTheme;
+    selectable: boolean;
+    inlineIndent: number;
+    inlineCollapsed: boolean;
+    subMenuOpenDelay: number;
+    subMenuCloseDelay: number;
+    triggerSubMenuAction: TriggerSubMenuAction;
+    forceSubMenuRender: boolean;
+    disabledOverflow: boolean;
+}, CustomSlotsType<{
+    expandIcon?: {
+        isOpen: boolean;
+        [key: string]: any;
+    };
+    overflowedIndicator?: any;
+    default: any;
+}>, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/menu/src/OverrideContext.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { MenuProps } from './Menu';
+export interface OverrideContextProps {
+    prefixCls?: ComputedRef<string>;
+    mode?: ComputedRef<MenuProps['mode']>;
+    selectable?: ComputedRef<boolean>;
+    validator?: (menuProps: Pick<MenuProps, 'mode'>) => void;
+    onClick?: () => void;
+    expandIcon?: ComputedRef<any>;
+}
+export declare const OverrideContextKey: InjectionKey<OverrideContextProps>;
+export declare const useInjectOverride: () => OverrideContextProps | undefined;
+export declare const useProvideOverride: (props: OverrideContextProps) => void;

package/dist/src/menu/src/PopupTrigger.d.ts

@@ -0,0 +1,29 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { CustomSlotsType } from '../../_util/type';
+import { MenuMode } from './interface';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    mode: PropType<MenuMode>;
+    visible: BooleanConstructor;
+    popupClassName: StringConstructor;
+    popupOffset: PropType<number[]>;
+    disabled: BooleanConstructor;
+    onVisibleChange: PropType<(visible: boolean) => void>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "visibleChange"[], "visibleChange", PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    mode: PropType<MenuMode>;
+    visible: BooleanConstructor;
+    popupClassName: StringConstructor;
+    popupOffset: PropType<number[]>;
+    disabled: BooleanConstructor;
+    onVisibleChange: PropType<(visible: boolean) => void>;
+}>> & Readonly<{
+    onVisibleChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    visible: boolean;
+    disabled: boolean;
+}, CustomSlotsType<{
+    default?: any;
+    popup?: any;
+}>, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/menu/src/SubMenuList.d.ts

@@ -0,0 +1,3 @@
+import { FunctionalComponent } from 'vue';
+declare const InternalSubMenuList: FunctionalComponent<any>;
+export default InternalSubMenuList;

package/dist/src/menu/src/hooks/useDirectionStyle.d.ts

@@ -0,0 +1,2 @@
+import { CSSProperties, ComputedRef } from 'vue';
+export default function useDirectionStyle(level: ComputedRef<number>): ComputedRef<CSSProperties>;

package/dist/src/menu/src/hooks/useItems.d.ts

@@ -0,0 +1,32 @@
+import { VNode, ShallowRef } from 'vue';
+import { Key } from '../../../_util/type';
+import { MenuProps } from '../Menu';
+import { MenuDividerType as VcMenuDividerType, MenuItemGroupType as VcMenuItemGroupType, MenuItemType as VcMenuItemType, SubMenuType as VcSubMenuType } from '../interface';
+import { StoreMenuInfo } from './useMenuContext';
+export interface MenuItemType extends VcMenuItemType {
+    danger?: boolean;
+    icon?: VNode | ((item: MenuItemType) => VNode);
+    title?: string;
+}
+export interface SubMenuType extends Omit<VcSubMenuType, 'children'> {
+    icon?: VNode | ((item: SubMenuType) => VNode);
+    children: ItemType[];
+}
+export interface MenuItemGroupType extends Omit<VcMenuItemGroupType, 'children'> {
+    children?: MenuItemType[];
+    key?: Key;
+}
+export interface MenuDividerType extends VcMenuDividerType {
+    dashed?: boolean;
+    key?: Key;
+}
+export type ItemType = MenuItemType | SubMenuType | MenuItemGroupType | MenuDividerType | null;
+/**
+ * We simply convert `items` to VueNode for reuse origin component logic. But we need move all the
+ * logic from component into this hooks when in v4
+ */
+export default function useItems(props: MenuProps): {
+    itemsNodes: ShallowRef<never[], never[]>;
+    store: ShallowRef<Map<string, StoreMenuInfo>, Map<string, StoreMenuInfo>>;
+    hasItmes: ShallowRef<boolean, boolean>;
+};

package/dist/src/menu/src/hooks/useKeyPath.d.ts

@@ -0,0 +1,21 @@
+import { ComputedRef, InjectionKey, DefineComponent, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { Key } from '../../../_util/type';
+import { StoreMenuInfo } from './useMenuContext';
+export declare const OVERFLOW_KEY = "$$__vc-menu-more__key";
+declare const KeyPathContext: InjectionKey<{
+    parentEventKeys: ComputedRef<string[]>;
+    parentKeys: ComputedRef<Key[]>;
+    parentInfo: StoreMenuInfo;
+}>;
+declare const useInjectKeyPath: () => {
+    parentEventKeys: ComputedRef<string[]>;
+    parentKeys: ComputedRef<Key[]>;
+    parentInfo: StoreMenuInfo;
+};
+declare const useProvideKeyPath: (eventKey: string, key: Key, menuInfo: StoreMenuInfo) => ComputedRef<Key[]>;
+export declare const PathContext: DefineComponent<{}, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export declare const useMeasure: () => boolean;
+export { KeyPathContext, useInjectKeyPath, useProvideKeyPath };
+export default useProvideKeyPath;

package/dist/src/menu/src/hooks/useMenuContext.d.ts

@@ -0,0 +1,81 @@
+import { ComputedRef, InjectionKey, PropType, Ref, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { CSSMotionProps } from '../../../_util/transition';
+import { Key } from '../../../_util/type';
+import { BuiltinPlacements, MenuClickEventHandler, MenuMode, MenuTheme, TriggerSubMenuAction } from '../interface';
+export interface StoreMenuInfo {
+    eventKey: string;
+    key: Key;
+    parentEventKeys: Ref<string[]>;
+    childrenEventKeys?: Ref<string[]>;
+    isLeaf?: boolean;
+    parentKeys: Ref<Key[]>;
+}
+export interface MenuContextProps {
+    rootClassName: Ref<string>;
+    registerMenuInfo: (key: string, info: StoreMenuInfo) => void;
+    unRegisterMenuInfo: (key: string) => void;
+    prefixCls: ComputedRef<string>;
+    openKeys: Ref<Key[]>;
+    selectedKeys: Ref<Key[]>;
+    selectedSubMenuKeys: Ref<Array<number | string>>;
+    rtl?: ComputedRef<boolean>;
+    inlineCollapsed: Ref<boolean>;
+    theme?: ComputedRef<MenuTheme>;
+    siderCollapsed?: Ref<boolean>;
+    mode: Ref<MenuMode>;
+    disabled?: ComputedRef<boolean>;
+    overflowDisabled?: Ref<boolean>;
+    activeKeys: Ref<Key[]>;
+    changeActiveKeys: (keys: Key[]) => void;
+    inlineIndent: ComputedRef<number>;
+    motion?: ComputedRef<CSSMotionProps | null>;
+    defaultMotions?: ComputedRef<Partial<{
+        [key in MenuMode | 'other']: CSSMotionProps | ((name?: string) => CSSMotionProps);
+    }> | null>;
+    subMenuOpenDelay: ComputedRef<number>;
+    subMenuCloseDelay: ComputedRef<number>;
+    forceSubMenuRender: ComputedRef<boolean>;
+    builtinPlacements?: ComputedRef<BuiltinPlacements>;
+    triggerSubMenuAction?: ComputedRef<TriggerSubMenuAction>;
+    expandIcon?: ComputedRef<(p?: {
+        isOpen: boolean;
+        [key: string]: any;
+    }) => any>;
+    onItemClick: MenuClickEventHandler;
+    onOpenChange: (key: Key, open: boolean) => void;
+    getPopupContainer: ComputedRef<(node: HTMLElement) => HTMLElement>;
+}
+declare const MenuContextKey: InjectionKey<MenuContextProps>;
+declare const useProvideMenu: (props: MenuContextProps) => void;
+declare const useInjectMenu: () => MenuContextProps | undefined;
+export declare const useProvideForceRender: (forceRender: boolean) => void;
+export declare const useInjectForceRender: () => boolean;
+declare const MenuFirstLevelContextKey: InjectionKey<boolean>;
+declare const useProvideFirstLevel: (firstLevel: boolean) => void;
+declare const useInjectFirstLevel: () => boolean;
+declare const MenuContextProvider: DefineComponent<ExtractPropTypes<{
+    mode: {
+        type: PropType<MenuMode>;
+        default: undefined;
+    };
+    overflowDisabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    mode: {
+        type: PropType<MenuMode>;
+        default: undefined;
+    };
+    overflowDisabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    mode: MenuMode;
+    overflowDisabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export { MenuContextKey, MenuContextProvider, MenuFirstLevelContextKey, useInjectFirstLevel, useInjectMenu, useProvideFirstLevel, useProvideMenu, };
+export default useProvideMenu;

package/dist/src/menu/src/interface.d.ts

@@ -0,0 +1,78 @@
+import { CSSProperties } from 'vue';
+import { Key } from '../../_util/type';
+import { MenuItemProps } from './MenuItem';
+interface ItemSharedProps {
+    style?: CSSProperties;
+    class?: string;
+}
+export interface SubMenuType extends ItemSharedProps {
+    label?: any;
+    children: ItemType[];
+    disabled?: boolean;
+    key: Key;
+    theme?: MenuTheme;
+    rootClassName?: string;
+    itemIcon?: RenderIconType;
+    expandIcon?: RenderIconType;
+    onMouseenter?: MenuHoverEventHandler;
+    onMouseleave?: MenuHoverEventHandler;
+    popupClassName?: string;
+    popupOffset?: number[];
+    onClick?: MenuClickEventHandler;
+    onTitleClick?: (info: MenuTitleInfo) => void;
+    onTitleMouseenter?: MenuHoverEventHandler;
+    onTitleMouseleave?: MenuHoverEventHandler;
+}
+export interface MenuItemType extends ItemSharedProps {
+    label?: any;
+    disabled?: boolean;
+    itemIcon?: RenderIconType;
+    key: Key;
+    onMouseenter?: MenuHoverEventHandler;
+    onMouseleave?: MenuHoverEventHandler;
+    onClick?: MenuClickEventHandler;
+}
+export interface MenuItemGroupType extends ItemSharedProps {
+    type: 'group';
+    label?: any;
+    children?: ItemType[];
+}
+export interface MenuDividerType extends ItemSharedProps {
+    type: 'divider';
+}
+export type ItemType = SubMenuType | MenuItemType | MenuItemGroupType | MenuDividerType | null;
+export type MenuTheme = 'light' | 'dark';
+export type MenuMode = 'horizontal' | 'vertical' | 'inline';
+export type BuiltinPlacements = Record<string, any>;
+export type TriggerSubMenuAction = 'click' | 'hover';
+export interface RenderIconInfo {
+    isSelected?: boolean;
+    isOpen?: boolean;
+    isSubMenu?: boolean;
+    disabled?: boolean;
+}
+export type RenderIconType = (props: RenderIconInfo) => any;
+export interface MenuInfo {
+    key: Key;
+    eventKey: string;
+    keyPath?: Key[];
+    eventKeyPath: string[];
+    domEvent: MouseEvent | KeyboardEvent;
+    item: MenuItemProps & {
+        [key: string]: any;
+    };
+}
+export interface MenuTitleInfo {
+    key: Key;
+    domEvent: MouseEvent | KeyboardEvent;
+}
+export type MenuHoverEventHandler = (info: {
+    key: Key;
+    domEvent: MouseEvent;
+}) => void;
+export interface SelectInfo extends MenuInfo {
+    selectedKeys: Key[];
+}
+export type SelectEventHandler = (info: SelectInfo) => void;
+export type MenuClickEventHandler = (info: MenuInfo) => void;
+export {};

package/dist/src/menu/src/placements.d.ts

@@ -0,0 +1,69 @@
+export declare const placements: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    leftTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    rightTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+};
+export declare const placementsRtl: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    rightTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+    leftTop: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+    };
+};
+export default placements;

package/dist/src/menu/style/horizontal.d.ts

@@ -0,0 +1,4 @@
+import { MenuToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const getHorizontalStyle: GenerateStyle<MenuToken>;
+export default getHorizontalStyle;

package/dist/src/menu/style/index.d.ts

@@ -0,0 +1,42 @@
+import { Ref } from 'vue';
+import { FullToken, UseComponentStyleResult } from '../../theme/internal';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+    dropdownWidth: number;
+    zIndexPopup: number;
+    colorGroupTitle: string;
+    radiusItem: number;
+    radiusSubMenuItem: number;
+    colorItemText: string;
+    colorItemTextHover: string;
+    colorItemTextHoverHorizontal: string;
+    colorItemTextSelected: string;
+    colorItemTextSelectedHorizontal: string;
+    colorItemTextDisabled: string;
+    colorDangerItemText: string;
+    colorDangerItemTextHover: string;
+    colorDangerItemTextSelected: string;
+    colorDangerItemBgActive: string;
+    colorDangerItemBgSelected: string;
+    colorItemBg: string;
+    colorItemBgHover: string;
+    colorSubItemBg: string;
+    colorItemBgActive: string;
+    colorItemBgSelected: string;
+    colorItemBgSelectedHorizontal: string;
+    colorActiveBarWidth: number;
+    colorActiveBarHeight: number;
+    colorActiveBarBorderSize: number;
+    itemMarginInline: number;
+}
+export interface MenuToken extends FullToken<'Menu'> {
+    menuItemHeight: number;
+    menuHorizontalHeight: number;
+    menuItemPaddingInline: number;
+    menuArrowSize: number;
+    menuArrowOffset: string;
+    menuPanelMaskInset: number;
+    menuSubMenuBg: string;
+}
+declare const _default: (prefixCls: Ref<string>, injectStyle?: Ref<boolean>) => UseComponentStyleResult;
+export default _default;

package/dist/src/menu/style/rtl.d.ts

@@ -0,0 +1,4 @@
+import { MenuToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const getRTLStyle: GenerateStyle<MenuToken>;
+export default getRTLStyle;

package/dist/src/menu/style/theme.d.ts

@@ -0,0 +1,4 @@
+import { MenuToken } from '.';
+import { CSSInterpolation } from '../../_util/cssinjs';
+declare const getThemeStyle: (token: MenuToken, themeSuffix: string) => CSSInterpolation;
+export default getThemeStyle;

package/dist/src/menu/style/vertical.d.ts

@@ -0,0 +1,4 @@
+import { MenuToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const getVerticalStyle: GenerateStyle<MenuToken>;
+export default getVerticalStyle;

package/dist/src/message/PurePanel.d.ts

@@ -0,0 +1,22 @@
+import { VueNode } from '../_util/type';
+import { NoticeProps } from '../vc-notification/Notice';
+import { NoticeType } from './interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export declare const TypeIcon: {
+    info: import("vue/jsx-runtime").JSX.Element;
+    success: import("vue/jsx-runtime").JSX.Element;
+    error: import("vue/jsx-runtime").JSX.Element;
+    warning: import("vue/jsx-runtime").JSX.Element;
+    loading: import("vue/jsx-runtime").JSX.Element;
+};
+export interface PureContentProps {
+    prefixCls: string;
+    type?: NoticeType;
+    icon?: VueNode;
+}
+export declare const PureContent: DefineComponent<PureContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PureContentProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export interface PurePanelProps extends Omit<NoticeProps, 'prefixCls' | 'eventKey'>, Omit<PureContentProps, 'prefixCls'> {
+    prefixCls?: string;
+}
+declare const _default: DefineComponent<PurePanelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PurePanelProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;