ropav 0.0.6 → 0.0.7

package/dist/components/accordion/accordion-item.d.ts

@@ -0,0 +1,40 @@
+import { AccordionItemProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionItemProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        trigger?: (props: {
+            triggerProps: import('./types').AccordionTriggerProps;
+            value: import('./types').AccordionItemValue;
+            isOpen: boolean;
+            disabled: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        title?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            value: import('./types').AccordionItemValue;
+            isOpen: boolean;
+            disabled: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/accordion/accordion.d.ts

@@ -0,0 +1,23 @@
+import { AccordionModelValue, AccordionProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<AccordionProps & {
+        "onUpdate:modelValue"?: ((value: AccordionModelValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: (evt: "update:modelValue", value: AccordionModelValue) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/accordion/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Accordion } from './accordion';
+export { default as AccordionItem } from './accordion-item';
+export { useAccordion, useAccordionItem } from './useAccordion';
+export type { AccordionContentProps, AccordionContext, AccordionItemProps, AccordionItemRootProps, AccordionItemSlotProps, AccordionItemTriggerSlotProps, AccordionItemValue, AccordionModelValue, AccordionOrientation, AccordionProps, AccordionRootProps, AccordionState, AccordionTriggerProps, UseAccordionItemReturn, UseAccordionReturn, } from './types';

package/dist/components/accordion/index.js

@@ -0,0 +1,2 @@
+import { i as useAccordionItem, n as accordion_default, r as useAccordion, t as accordion_item_default } from "../../accordion.js";
+export { accordion_default as Accordion, accordion_item_default as AccordionItem, useAccordion, useAccordionItem };

package/dist/components/accordion/types.d.ts

@@ -0,0 +1,100 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { CollapseContentProps, CollapseContentRole, CollapseTriggerProps } from '../collapse/types';
+export type AccordionItemValue = string | number;
+export type AccordionModelValue = AccordionItemValue | AccordionItemValue[] | null;
+export type AccordionOrientation = 'vertical' | 'horizontal';
+export type AccordionState = 'open' | 'closed';
+export interface AccordionProps {
+    id?: string;
+    modelValue?: AccordionModelValue;
+    defaultValue?: AccordionModelValue;
+    multiple?: boolean;
+    collapsible?: boolean;
+    disabled?: boolean;
+    unmountOnExit?: boolean;
+    orientation?: AccordionOrientation;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+}
+export interface AccordionItemProps {
+    id?: string;
+    value: AccordionItemValue;
+    title?: string;
+    disabled?: boolean;
+    unmountOnExit?: boolean;
+    role?: CollapseContentRole;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    ariaLabelledby?: string;
+}
+export interface AccordionRootProps {
+    id?: string;
+    class: string[];
+    'data-disabled'?: boolean;
+    'data-orientation': AccordionOrientation;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface AccordionItemRootProps {
+    id: string;
+    class: string[];
+    'data-state': AccordionState;
+    'data-disabled'?: boolean;
+}
+export interface AccordionTriggerProps extends CollapseTriggerProps {
+    id: string;
+    class: string;
+    'aria-disabled'?: boolean;
+}
+export interface AccordionContentProps extends CollapseContentProps {
+    class: string;
+}
+export interface AccordionItemSlotProps {
+    value: AccordionItemValue;
+    isOpen: boolean;
+    disabled: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface AccordionItemTriggerSlotProps extends AccordionItemSlotProps {
+    triggerProps: AccordionTriggerProps;
+}
+export interface AccordionContext {
+    multiple: boolean;
+    collapsible: boolean;
+    disabled: boolean;
+    unmountOnExit: boolean;
+    orientation: AccordionOrientation;
+    isItemOpen: (value: AccordionItemValue) => boolean;
+    setItemOpen: (value: AccordionItemValue, open: boolean) => void;
+}
+export interface UseAccordionReturn {
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<AccordionRootProps>;
+    openValues: ComputedRef<AccordionItemValue[]>;
+    setItemOpen: (value: AccordionItemValue, open: boolean) => void;
+}
+export interface UseAccordionItemReturn {
+    group: AccordionContext;
+    id: ComputedRef<string>;
+    triggerId: ComputedRef<string>;
+    contentId: ComputedRef<string>;
+    state: ComputedRef<AccordionState>;
+    isOpen: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    shouldRenderContent: ComputedRef<boolean>;
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<AccordionItemRootProps>;
+    triggerProps: ComputedRef<AccordionTriggerProps>;
+    contentProps: ComputedRef<AccordionContentProps>;
+    triggerSlotProps: ComputedRef<AccordionItemTriggerSlotProps>;
+    contentSlotProps: ComputedRef<AccordionItemSlotProps>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export declare const accordionKey: InjectionKey<AccordionContext>;

package/dist/components/accordion/useAccordion.d.ts

@@ -0,0 +1,3 @@
+import { AccordionItemProps, AccordionModelValue, AccordionProps, UseAccordionItemReturn, UseAccordionReturn } from './types';
+export declare function useAccordion(props: Readonly<AccordionProps>, emitUpdate: (value: AccordionModelValue) => void): UseAccordionReturn;
+export declare function useAccordionItem(props: Readonly<AccordionItemProps>): UseAccordionItemReturn;

package/dist/components/badge/badge.d.ts

@@ -0,0 +1,25 @@
+import { BadgeProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<BadgeProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        left?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        right?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/badge/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Badge } from './badge';
+export { badgeColors, badgeRadiuses, badgeSizes, badgeVariants } from './types';
+export type { BadgeColor, BadgeProps, BadgeRadius, BadgeSize, BadgeVariant } from './types';

package/dist/components/badge/index.js

@@ -0,0 +1,2 @@
+import { a as badge_default, i as badgeVariants, n as badgeRadiuses, r as badgeSizes, t as badgeColors } from "../../badge.js";
+export { badge_default as Badge, badgeColors, badgeRadiuses, badgeSizes, badgeVariants };

package/dist/components/badge/types.d.ts

@@ -0,0 +1,16 @@
+import { ComponentColorValue } from '../../utils/componentColors';
+export declare const badgeColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+export declare const badgeSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const badgeRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export declare const badgeVariants: readonly ["solid", "subtle", "surface", "outline"];
+export type BadgeColor = ComponentColorValue;
+export type BadgeSize = (typeof badgeSizes)[number];
+export type BadgeRadius = (typeof badgeRadiuses)[number];
+export type BadgeVariant = (typeof badgeVariants)[number];
+export interface BadgeProps {
+    variant?: BadgeVariant;
+    color?: BadgeColor;
+    size?: BadgeSize;
+    radius?: BadgeRadius;
+    ariaLabel?: string;
+}

package/dist/components/badge/useBadgeColor.d.ts

@@ -0,0 +1,8 @@
+import { BadgeColor } from './types';
+export declare function getBadgeColorStyle(color: BadgeColor | undefined): {
+    '--_rp-badge-custom-color': string & {};
+    '--_rp-badge-custom-fg': string & {};
+    '--_rp-badge-custom-on': string;
+    '--_rp-badge-custom-subtle-bg': string;
+    '--_rp-badge-custom-border': string;
+} | undefined;

package/dist/components/collapse/collapse.d.ts

@@ -0,0 +1,36 @@
+import { CollapseProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<CollapseProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        trigger?: (props: {
+            triggerProps: import('./types').CollapseTriggerProps;
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: (evt: "update:open", value: boolean) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/collapse/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Collapse } from './collapse';
+export { useCollapse } from './useCollapse';
+export type { CollapseContentProps, CollapseContentRole, CollapseOption, CollapseProps, CollapseRootProps, CollapseSlotProps, CollapseState, CollapseTriggerProps, CollapseTriggerSlotProps, UseCollapseOptions, UseCollapseReturn, } from './types';

package/dist/components/collapse/index.js

@@ -0,0 +1,3 @@
+import { t as useCollapse } from "../../useCollapse.js";
+import { t as collapse_default } from "../../collapse.js";
+export { collapse_default as Collapse, useCollapse };

package/dist/components/collapse/types.d.ts

@@ -0,0 +1,76 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+export type CollapseState = 'open' | 'closed';
+export type CollapseContentRole = 'region' | 'group';
+export type CollapseOption<T> = MaybeRefOrGetter<T>;
+export interface CollapseRootProps {
+    class: string[];
+    'data-state': CollapseState;
+    'data-disabled'?: boolean;
+}
+export interface CollapseTriggerProps {
+    type: 'button';
+    disabled?: boolean;
+    'aria-controls': string;
+    'aria-expanded': boolean;
+    'aria-disabled'?: boolean;
+    onClick: (event: MouseEvent) => void;
+}
+export interface CollapseContentProps {
+    class: string;
+    id: string;
+    role: CollapseContentRole;
+    'data-state': CollapseState;
+    'aria-hidden'?: 'true';
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+export interface CollapseSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface CollapseTriggerSlotProps extends CollapseSlotProps {
+    triggerProps: CollapseTriggerProps;
+}
+export interface CollapseProps {
+    id?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    unmountOnExit?: boolean;
+    role?: CollapseContentRole;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    ariaLabelledby?: string;
+}
+export interface UseCollapseOptions {
+    id?: CollapseOption<string | undefined>;
+    open?: CollapseOption<boolean | undefined>;
+    defaultOpen?: CollapseOption<boolean | undefined>;
+    disabled?: CollapseOption<boolean | undefined>;
+    unmountOnExit?: CollapseOption<boolean | undefined>;
+    role?: CollapseOption<CollapseContentRole | undefined>;
+    ariaLabel?: CollapseOption<string | undefined>;
+    ariaDescribedby?: CollapseOption<string | undefined>;
+    ariaLabelledby?: CollapseOption<string | undefined>;
+    onOpenChange?: (open: boolean) => void;
+}
+export interface UseCollapseReturn {
+    id: ComputedRef<string>;
+    state: ComputedRef<CollapseState>;
+    isDisabled: ComputedRef<boolean>;
+    isOpen: ComputedRef<boolean>;
+    shouldRenderContent: ComputedRef<boolean>;
+    rootClass: ComputedRef<string[]>;
+    rootProps: ComputedRef<CollapseRootProps>;
+    triggerProps: ComputedRef<CollapseTriggerProps>;
+    contentProps: ComputedRef<CollapseContentProps>;
+    triggerSlotProps: ComputedRef<CollapseTriggerSlotProps>;
+    contentSlotProps: ComputedRef<CollapseSlotProps>;
+    setOpen: (open: boolean) => void;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}

package/dist/components/collapse/useCollapse.d.ts

@@ -0,0 +1,2 @@
+import { UseCollapseOptions, UseCollapseReturn } from './types';
+export declare function useCollapse(options?: Readonly<UseCollapseOptions>, emitOpenChange?: (open: boolean) => void): UseCollapseReturn;

package/dist/components/dropdown-menu/dropdown-menu-items.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+import { DropdownMenuRenderedItem } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<DropdownMenuRenderedItem[]>;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<DropdownMenuRenderedItem[]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/dropdown-menu/dropdown-menu-utils.d.ts

@@ -0,0 +1,23 @@
+import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types';
+export declare const DEFAULT_PLACEMENT: DropdownMenuPlacement;
+export declare const DEFAULT_FOCUS_TARGET: DropdownMenuFocusTarget;
+export type ItemPath = DropdownMenuItemPath;
+export type SubmenuFocusTarget = DropdownMenuFocusTarget | false;
+export type PointerPoint = {
+    x: number;
+    y: number;
+};
+export declare function getOpenFocusTarget(options: DropdownMenuOpenOptions | DropdownMenuFocusTarget | undefined): DropdownMenuFocusTarget;
+export declare function getItemClass(item: DropdownMenuItem, focused: boolean, disabled: boolean, hasSubmenu: boolean, submenuOpen: boolean): string[];
+export declare function hasItemSubmenu(item: DropdownMenuItem): boolean;
+export declare function hasNestedItems(items: DropdownMenuItem[]): boolean;
+export declare function getPathKey(path: ItemPath): string;
+export declare function getParentPath(path: ItemPath): number[];
+export declare function arePathsEqual(a: ItemPath, b: ItemPath): boolean;
+export declare function isPathPrefix(prefix: ItemPath, path: ItemPath): boolean;
+export declare function normalizePath(indexOrPath: number | ItemPath): ItemPath;
+export declare function getEventPoint(event: MouseEvent): PointerPoint;
+export declare function hasMeasuredRect(rect: DOMRect): boolean;
+export declare function isPointInRect(point: PointerPoint, rect: DOMRect, padding?: number): boolean;
+export declare function getEnabledIndexes(items: DropdownMenuItem[]): number[];
+export declare function getNextEnabledIndex(items: DropdownMenuItem[], index: number, direction: 1 | -1): number | undefined;

package/dist/components/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,26 @@
+import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSlotProps } from './types';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<DropdownMenuProps & {
+        onSelect?: ((item: DropdownMenuItem) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: DropdownMenuSlotProps): unknown;
+        item?(props: DropdownMenuItemSlotProps): unknown;
+        empty?(): unknown;
+    };
+    emit: ((evt: "select", item: DropdownMenuItem) => void) & ((evt: "update:open", value: boolean) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/dropdown-menu/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DropdownMenu } from './dropdown-menu';
+export { useDropdownMenu } from './useDropdownMenu';
+export type { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuRenderedItem, DropdownMenuSlotProps, DropdownMenuSubmenuProps, DropdownMenuTriggerProps, } from './types';

package/dist/components/dropdown-menu/index.js

@@ -0,0 +1,2 @@
+import { n as useDropdownMenu, t as dropdown_menu_default } from "../../dropdown-menu.js";
+export { dropdown_menu_default as DropdownMenu, useDropdownMenu };

package/dist/components/dropdown-menu/types.d.ts

@@ -0,0 +1,104 @@
+export type DropdownMenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+export type DropdownMenuItemValue = string | number;
+export type DropdownMenuFocusTarget = 'first' | 'last';
+export type DropdownMenuItemPath = number[];
+export interface DropdownMenuOpenOptions {
+    focus?: DropdownMenuFocusTarget;
+}
+export interface DropdownMenuCloseOptions {
+    focusTrigger?: boolean;
+}
+export interface DropdownMenuItem {
+    label: string;
+    value: DropdownMenuItemValue;
+    disabled?: boolean;
+    destructive?: boolean;
+    shortcut?: string;
+    children?: DropdownMenuItem[];
+}
+export interface DropdownMenuTriggerProps {
+    'aria-controls'?: string;
+    'aria-expanded'?: boolean;
+    'aria-haspopup': 'menu';
+    disabled?: boolean;
+    onClick: (event: MouseEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface DropdownMenuContentProps {
+    id: string;
+    role: 'menu';
+    tabindex: -1;
+    'aria-label'?: string;
+    'aria-activedescendant'?: string;
+    onKeydown: (event: KeyboardEvent) => void;
+    onMousemove: (event: MouseEvent) => void;
+    onMouseleave: (event: MouseEvent) => void;
+}
+export interface DropdownMenuSlotProps {
+    triggerProps: DropdownMenuTriggerProps;
+    isOpen: boolean;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+}
+export interface DropdownMenuItemSlotProps {
+    item: DropdownMenuItem;
+    index: number;
+    path: DropdownMenuItemPath;
+    level: number;
+    focused: boolean;
+    disabled: boolean;
+    hasSubmenu: boolean;
+    isSubmenuOpen: boolean;
+    select: () => void;
+    openSubmenu: (focus?: DropdownMenuFocusTarget) => void;
+    closeSubmenu: () => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+}
+export interface DropdownMenuItemProps {
+    id: string;
+    type: 'button';
+    role: 'menuitem';
+    tabindex: -1;
+    class: string[];
+    'aria-controls'?: string;
+    'aria-expanded'?: boolean;
+    'aria-haspopup'?: 'menu';
+    'aria-disabled'?: true;
+    'data-disabled'?: true;
+    'data-focused'?: true;
+    'data-submenu'?: true;
+    onClick: (event: MouseEvent) => void;
+    onMouseenter: (event: MouseEvent) => void;
+}
+export interface DropdownMenuSubmenuProps {
+    id: string;
+    role: 'menu';
+    class: string[];
+    'aria-label'?: string;
+    'aria-activedescendant'?: string;
+}
+export interface DropdownMenuRenderedItem {
+    item: DropdownMenuItem;
+    index: number;
+    key: string;
+    path: DropdownMenuItemPath;
+    level: number;
+    focused: boolean;
+    disabled: boolean;
+    hasSubmenu: boolean;
+    submenuOpen: boolean;
+    props: DropdownMenuItemProps;
+    submenuProps?: DropdownMenuSubmenuProps;
+    slotProps: DropdownMenuItemSlotProps;
+    children: DropdownMenuRenderedItem[];
+}
+export interface DropdownMenuProps {
+    id?: string;
+    items?: DropdownMenuItem[];
+    placement?: DropdownMenuPlacement;
+    open?: boolean;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    ariaLabel?: string;
+}

package/dist/components/dropdown-menu/useDropdownMenu.d.ts

@@ -0,0 +1,32 @@
+import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types';
+export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit?: {
+    openChange?: (open: boolean) => void;
+    select?: (item: DropdownMenuItem) => void;
+}): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    menuRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    menuId: import('vue').ComputedRef<string>;
+    isVisible: import('vue').ComputedRef<boolean>;
+    isEmpty: import('vue').ComputedRef<boolean>;
+    visibleItems: import('vue').ComputedRef<DropdownMenuItem[]>;
+    renderedItems: import('vue').ComputedRef<import('./types').DropdownMenuRenderedItem[]>;
+    focusedIndex: import('vue').ComputedRef<number>;
+    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    activeDescendantId: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentClass: import('vue').ComputedRef<string[]>;
+    triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
+    contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
+    slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
+    open: (options?: import('./types').DropdownMenuOpenOptions | import('./types').DropdownMenuFocusTarget) => void;
+    close: (options?: import('./types').DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+    selectItem: (item: DropdownMenuItem) => void;
+    openSubmenu: (path: import('./dropdown-menu-utils').ItemPath, focus?: import('./dropdown-menu-utils').SubmenuFocusTarget, point?: import('./dropdown-menu-utils').PointerPoint) => boolean;
+    closeSubmenu: (path: import('./dropdown-menu-utils').ItemPath) => boolean;
+    onItemMouseenter: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, event?: MouseEvent) => void;
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, focused?: boolean, disabled?: boolean) => import('./types').DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, focused?: boolean, disabled?: boolean) => import('./types').DropdownMenuItemSlotProps;
+};

package/dist/components/dropdown-menu/useDropdownMenuDisclosure.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type BooleanSource = Readonly<Ref<boolean>>;
+type UseDropdownMenuDisclosureOptions = {
+    props: Readonly<DropdownMenuProps>;
+    emit: {
+        openChange?: (open: boolean) => void;
+        select?: (item: DropdownMenuItem) => void;
+    };
+    rootRef: Ref<HTMLElement | null>;
+    uncontrolledOpen: Ref<boolean>;
+    isDisabled: BooleanSource;
+    isOpen: BooleanSource;
+    isVisible: BooleanSource;
+    focusedPath: Ref<ItemPath>;
+    resetFocus: () => void;
+    resetSubmenus: () => void;
+    resetHoverIntent: () => void;
+    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
+    focusMenu: () => void;
+    focusTrigger: () => void;
+};
+export declare function useDropdownMenuDisclosure({ props, emit, rootRef, uncontrolledOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, }: UseDropdownMenuDisclosureOptions): {
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+    resetMenuFocus: () => void;
+};
+export {};

package/dist/components/dropdown-menu/useDropdownMenuDom.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { DropdownMenuPlacement } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type StringSource = {
+    readonly value: string;
+};
+type PlacementSource = {
+    readonly value: DropdownMenuPlacement;
+};
+type UseDropdownMenuDomOptions = {
+    menuId: StringSource;
+    rootRef: Ref<HTMLElement | null>;
+    menuRef: Ref<HTMLElement | null>;
+    placement: PlacementSource;
+    focusedPath: Ref<ItemPath>;
+};
+export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
+    activeDescendantId: import('vue').ComputedRef<string | undefined>;
+    focusMenu: () => void;
+    focusTrigger: () => void;
+    getItemId: (indexOrPath: number | ItemPath) => string;
+    getSubmenuId: (path: ItemPath) => string;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getSubmenuElement: (path: ItemPath) => HTMLElement | null;
+    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
+    getMenuActiveDescendant: (menuPath: ItemPath) => string | undefined;
+};
+export {};