ropav 0.0.11 → 0.0.13

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

@@ -0,0 +1,25 @@
+import { DropdownMenuItemValue, DropdownMenuRadioGroupPrimitiveProps } from './types.js';
+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<DropdownMenuRadioGroupPrimitiveProps & {
+        "onUpdate:modelValue"?: ((value: DropdownMenuItemValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: {
+            value: DropdownMenuItemValue | null;
+        }): unknown;
+    };
+    emit: (evt: "update:modelValue", value: DropdownMenuItemValue) => 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/dropdown-menu-radio-item.d.ts

@@ -0,0 +1,23 @@
+import { DropdownMenuItemPrimitiveSlotProps, DropdownMenuRadioItemPrimitiveProps, DropdownMenuSelectEvent } from './types.js';
+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<DropdownMenuRadioItemPrimitiveProps & {
+        onSelect?: ((event: DropdownMenuSelectEvent) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: DropdownMenuItemPrimitiveSlotProps): unknown;
+    };
+    emit: (evt: "select", event: DropdownMenuSelectEvent) => 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/dropdown-menu-root.d.ts

@@ -0,0 +1,30 @@
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuOpenOptions, DropdownMenuPoint, DropdownMenuRootPrimitiveProps, DropdownMenuRootSlotProps } from './types.js';
+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<DropdownMenuRootPrimitiveProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+        close: (options?: DropdownMenuCloseOptions & {
+            returnFocus?: boolean;
+        }) => void;
+        toggle: () => void;
+        openAt: (point: DropdownMenuPoint, options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?(props: DropdownMenuRootSlotProps): unknown;
+    };
+    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/dropdown-menu/dropdown-menu-separator.d.ts

@@ -0,0 +1,19 @@
+import { DropdownMenuSeparatorPrimitiveProps } from './types.js';
+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<DropdownMenuSeparatorPrimitiveProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    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/dropdown-menu/dropdown-menu-sub-content.d.ts

@@ -0,0 +1,34 @@
+import { DropdownMenuInteractOutsideEvent, DropdownMenuPlacement, DropdownMenuSubContentPrimitiveProps } from './types.js';
+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<DropdownMenuSubContentPrimitiveProps & {
+        onEscapeKeyDown?: ((event: CustomEvent<{
+            originalEvent: KeyboardEvent;
+        }>) => any) | undefined;
+        onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: {
+            isOpen: boolean;
+            placement: DropdownMenuPlacement;
+            close: () => void;
+        }): unknown;
+    };
+    emit: ((evt: "escapeKeyDown", event: CustomEvent<{
+        originalEvent: KeyboardEvent;
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => 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/dropdown-menu-sub-trigger.d.ts

@@ -0,0 +1,28 @@
+import { OpenFocusTarget } from './dropdown-menu-primitive-core.js';
+import { DropdownMenuSubTriggerPrimitiveProps } from './types.js';
+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<DropdownMenuSubTriggerPrimitiveProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: {
+            focused: boolean;
+            disabled: boolean;
+            isOpen: boolean;
+            open: (focus?: OpenFocusTarget) => void;
+            close: (focusParent?: boolean) => void;
+        }): unknown;
+    };
+    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/dropdown-menu/dropdown-menu-sub.d.ts

@@ -0,0 +1,28 @@
+import { OpenFocusTarget } from './dropdown-menu-primitive-core.js';
+import { DropdownMenuSubPrimitiveProps } from './types.js';
+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<DropdownMenuSubPrimitiveProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: {
+            isOpen: boolean;
+            open: (focus?: OpenFocusTarget) => void;
+            close: (focusParent?: boolean) => void;
+        }): unknown;
+    };
+    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/dropdown-menu/dropdown-menu-trigger.d.ts

@@ -0,0 +1,23 @@
+import { DropdownMenuTriggerPrimitiveProps } from './types.js';
+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<DropdownMenuTriggerPrimitiveProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: {
+            isOpen: boolean;
+        }): unknown;
+    };
+    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/dropdown-menu/dropdown-menu.d.ts

@@ -1,8 +1,11 @@
-import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps } from './types.js';
+import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuInteractOutsideEvent, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps } from './types.js';
 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 & {
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
         onSelect?: ((item: DropdownMenuItem, event: DropdownMenuSelectEvent) => any) | undefined;
+        onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -13,7 +16,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
         item?(props: DropdownMenuItemSlotProps): unknown;
         empty?(): unknown;
     };
-    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "select", item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void);
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "select", item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -2,54 +2,33 @@ import { DropdownMenuItem as DropdownMenuDataItem } from './types.js';
 export { default as DropdownMenu } from './dropdown-menu.js';
 export { dropdownMenuParts } from './types.js';
 export { DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContextTrigger, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from './dropdown-menu-primitives.js';
-export declare const DropdownMenuItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    id: StringConstructor;
-    as: {
-        type: import('vue').PropType<import('./types.js').DropdownMenuAs>;
-        default: string;
-    };
-    value: import('vue').PropType<import('./types.js').DropdownMenuItemValue>;
-    disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    destructive: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    closeOnSelect: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "select"[], "select", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    id: StringConstructor;
-    as: {
-        type: import('vue').PropType<import('./types.js').DropdownMenuAs>;
-        default: string;
-    };
-    value: import('vue').PropType<import('./types.js').DropdownMenuItemValue>;
-    disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    destructive: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    closeOnSelect: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-}>> & Readonly<{
-    onSelect?: ((...args: any[]) => any) | undefined;
-}>, {
-    disabled: boolean;
-    as: import('./types.js').DropdownMenuAs;
-    closeOnSelect: boolean;
-    destructive: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare const DropdownMenuItem: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "select", event: import('./types.js').DropdownMenuSelectEvent) => void;
+    slots: {
+        default?(props: import('./types.js').DropdownMenuItemPrimitiveSlotProps): unknown;
+    };
+}, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & {
+        id?: string | undefined;
+        as?: import('./types.js').DropdownMenuAs | undefined;
+        value?: import('./types.js').DropdownMenuItemValue | undefined;
+        disabled?: boolean | undefined;
+        destructive?: boolean | undefined;
+        closeOnSelect?: boolean | undefined;
+        onSelect?: ((event: import('./types.js').DropdownMenuSelectEvent) => any) | undefined;
+    } & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: import('./types.js').DropdownMenuItemPrimitiveSlotProps): unknown;
+    };
+    emit: (evt: "select", event: import('./types.js').DropdownMenuSelectEvent) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
 export type DropdownMenuItem = DropdownMenuDataItem;
 export { useDropdownMenu } from './useDropdownMenu.js';
-export type { DropdownMenuAs, DropdownMenuCheckedState, DropdownMenuCollisionPadding, DropdownMenuCheckboxItemPrimitiveProps, DropdownMenuCloseOptions, DropdownMenuContentPrimitiveProps, DropdownMenuContentProps, DropdownMenuContextTriggerPrimitiveProps, DropdownMenuFocusTarget, DropdownMenuInteractOutsideDetail, DropdownMenuInteractOutsideEvent, DropdownMenuItemIndicatorPrimitiveProps, DropdownMenuItemPath, DropdownMenuItemPrimitiveProps, DropdownMenuItemPrimitiveSlotProps, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuLabelPrimitiveProps, DropdownMenuOffset, DropdownMenuOffsetOptions, DropdownMenuOpenOptions, DropdownMenuPart, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuPortalPrimitiveProps, DropdownMenuProps, DropdownMenuRadioGroupPrimitiveProps, DropdownMenuRadioItemPrimitiveProps, DropdownMenuRenderedItem, DropdownMenuRootPrimitiveProps, DropdownMenuRootSlotProps, DropdownMenuSelectDetail, DropdownMenuSelectEvent, DropdownMenuSeparatorPrimitiveProps, DropdownMenuSlotProps, DropdownMenuSubContentPrimitiveProps, DropdownMenuSubPrimitiveProps, DropdownMenuSubmenuProps, DropdownMenuSubTriggerPrimitiveProps, DropdownMenuStrategy, DropdownMenuTarget, DropdownMenuTriggerPrimitiveProps, DropdownMenuTriggerProps, DropdownMenuVirtualAnchor, } from './types.js';
+export type { DropdownMenuAs, DropdownMenuCheckedState, DropdownMenuCollisionPadding, DropdownMenuCheckboxItemPrimitiveProps, DropdownMenuCloseOptions, DropdownMenuContentPrimitiveProps, DropdownMenuContentProps, DropdownMenuContextTriggerPrimitiveProps, DropdownMenuFocusTarget, DropdownMenuInteractOutsideDetail, DropdownMenuInteractOutsideEvent, DropdownMenuInteractOutsideTarget, DropdownMenuItemIndicatorPrimitiveProps, DropdownMenuItemPath, DropdownMenuItemPrimitiveProps, DropdownMenuItemPrimitiveSlotProps, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuLabelPrimitiveProps, DropdownMenuOffset, DropdownMenuOffsetOptions, DropdownMenuOpenOptions, DropdownMenuPart, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuPortalPrimitiveProps, DropdownMenuProps, DropdownMenuRadioGroupPrimitiveProps, DropdownMenuRadioItemPrimitiveProps, DropdownMenuRenderedItem, DropdownMenuRootPrimitiveProps, DropdownMenuRootSlotProps, DropdownMenuSelectDetail, DropdownMenuSelectEvent, DropdownMenuSeparatorPrimitiveProps, DropdownMenuSlotProps, DropdownMenuSubContentPrimitiveProps, DropdownMenuSubPrimitiveProps, DropdownMenuSubmenuProps, DropdownMenuSubTriggerPrimitiveProps, DropdownMenuStrategy, DropdownMenuTarget, DropdownMenuTriggerPrimitiveProps, DropdownMenuTriggerProps, DropdownMenuVirtualAnchor, } from './types.js';

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

@@ -1,2 +1,2 @@
-import { _ as DropdownMenuSubTrigger, a as DropdownMenuCheckboxItem, c as DropdownMenuItemIndicator, d as DropdownMenuRadioGroup, f as DropdownMenuRadioItem, g as DropdownMenuSubContent, h as DropdownMenuSub, i as useDropdownMenu, l as DropdownMenuLabel, m as DropdownMenuSeparator, n as dropdownMenuParts, o as DropdownMenuContent, p as DropdownMenuRoot, r as dropdown_menu_default, s as DropdownMenuContextTrigger, t as DropdownMenuItem, u as DropdownMenuPortal, v as DropdownMenuTrigger } from "../../dropdown-menu.js";
-export { dropdown_menu_default as DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContextTrigger, DropdownMenuItem, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, dropdownMenuParts, useDropdownMenu };
+import { _ as dropdown_menu_content_default, a as dropdown_menu_trigger_default, c as dropdown_menu_sub_default, d as dropdown_menu_radio_item_default, f as dropdown_menu_radio_group_default, g as dropdown_menu_context_trigger_default, h as dropdown_menu_item_indicator_default, i as useDropdownMenu, l as dropdown_menu_separator_default, m as dropdown_menu_label_default, n as dropdownMenuParts, o as dropdown_menu_sub_trigger_default, p as dropdown_menu_portal_default, r as dropdown_menu_default, s as dropdown_menu_sub_content_default, t as DropdownMenuItem, u as dropdown_menu_root_default, v as dropdown_menu_checkbox_item_default } from "../../dropdown-menu.js";
+export { dropdown_menu_default as DropdownMenu, dropdown_menu_checkbox_item_default as DropdownMenuCheckboxItem, dropdown_menu_content_default as DropdownMenuContent, dropdown_menu_context_trigger_default as DropdownMenuContextTrigger, DropdownMenuItem, dropdown_menu_item_indicator_default as DropdownMenuItemIndicator, dropdown_menu_label_default as DropdownMenuLabel, dropdown_menu_portal_default as DropdownMenuPortal, dropdown_menu_radio_group_default as DropdownMenuRadioGroup, dropdown_menu_radio_item_default as DropdownMenuRadioItem, dropdown_menu_root_default as DropdownMenuRoot, dropdown_menu_separator_default as DropdownMenuSeparator, dropdown_menu_sub_default as DropdownMenuSub, dropdown_menu_sub_content_default as DropdownMenuSubContent, dropdown_menu_sub_trigger_default as DropdownMenuSubTrigger, dropdown_menu_trigger_default as DropdownMenuTrigger, dropdownMenuParts, useDropdownMenu };

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

@@ -1,6 +1,6 @@
-import { Component, HTMLAttributes } from 'vue';
+import { Component, HTMLAttributes, Ref } from 'vue';
 import { StylesApiProps } from '../../styles-api.js';
-import { FloatingCollisionPadding, FloatingOffset, FloatingOffsetOptions, FloatingPositionProps, FloatingStrategy, FloatingTarget, FloatingVirtualElement, TeleportProps } from '../floating/types.js';
+import { FloatingAutoUpdateOptions, FloatingCollisionPadding, FloatingFlipOptions, FloatingOffset, FloatingOffsetOptions, FloatingPositionProps, FloatingStrategy, FloatingTarget, FloatingVirtualElement, TeleportProps } from '../floating/types.js';
 export declare const dropdownMenuParts: readonly ["root", "trigger", "content", "item", "label", "shortcut", "submenu", "submenuIndicator", "empty"];
 export type DropdownMenuPart = (typeof dropdownMenuParts)[number];
 export type DropdownMenuPlacement = 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
@@ -113,6 +113,7 @@ export interface DropdownMenuProps extends FloatingPositionProps<DropdownMenuPla
     closeOnSelect?: boolean;
     ariaLabel?: string;
     modal?: boolean;
+    ignore?: readonly DropdownMenuInteractOutsideTarget[];
     /** @deprecated Use `teleport` instead. */
     portal?: boolean;
     /** @deprecated Use `teleportTo` instead. */
@@ -134,6 +135,7 @@ export interface DropdownMenuInteractOutsideDetail {
     originalEvent: Event;
 }
 export type DropdownMenuInteractOutsideEvent = CustomEvent<DropdownMenuInteractOutsideDetail>;
+export type DropdownMenuInteractOutsideTarget = string | Element | null | undefined | Readonly<Ref<Element | null | undefined>>;
 export type DropdownMenuOffsetOptions = FloatingOffsetOptions;
 export type DropdownMenuOffset = FloatingOffset;
 export interface DropdownMenuRootPrimitiveProps {
@@ -175,12 +177,15 @@ export interface DropdownMenuContentPrimitiveProps {
     offset?: DropdownMenuOffset;
     strategy?: FloatingStrategy;
     flip?: boolean;
+    flipOptions?: FloatingFlipOptions;
     shift?: boolean;
     collisionPadding?: FloatingCollisionPadding;
+    autoUpdateOptions?: FloatingAutoUpdateOptions;
     arrow?: boolean;
     /** @deprecated Use `flip` and `shift` instead. */
     avoidCollisions?: boolean;
     forceMount?: boolean;
+    ignore?: readonly DropdownMenuInteractOutsideTarget[];
     ariaLabel?: string;
     ariaLabelledby?: string;
     ariaDescribedby?: string;
@@ -235,6 +240,6 @@ export interface DropdownMenuSubTriggerPrimitiveProps {
     as?: DropdownMenuAs;
     disabled?: boolean;
 }
-export interface DropdownMenuSubContentPrimitiveProps extends Omit<DropdownMenuContentPrimitiveProps, 'arrow' | 'placement'> {
+export interface DropdownMenuSubContentPrimitiveProps extends Omit<DropdownMenuContentPrimitiveProps, 'arrow' | 'ignore' | 'placement'> {
     placement?: DropdownMenuPlacement;
 }

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

@@ -1,7 +1,11 @@
-import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+import { CSSProperties } from 'vue';
+import { DropdownMenuContentProps, DropdownMenuInteractOutsideEvent, DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
 export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit?: {
     openChange?: (open: boolean) => void;
     select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
+    pointerDownOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    focusOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    interactOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
 }): {
     rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     menuRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
@@ -17,9 +21,9 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentClass: import('vue').ComputedRef<string[]>;
-    contentStyle: import('vue').Ref<import('vue').CSSProperties, import('vue').CSSProperties>;
-    arrowStyle: import('vue').Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>;
-    actualPlacement: import('vue').Ref<import('./types.js').DropdownMenuPlacement, import('./types.js').DropdownMenuPlacement>;
+    contentStyle: import('vue').ComputedRef<CSSProperties>;
+    arrowStyle: Readonly<import('vue').Ref<CSSProperties | undefined, CSSProperties | undefined>>;
+    actualPlacement: Readonly<import('vue').Ref<import('../floating/index.js').FloatingPlacement, import('../floating/index.js').FloatingPlacement>>;
     placementSide: import('vue').ComputedRef<string>;
     isTargetMode: import('vue').ComputedRef<boolean>;
     teleportTo: import('vue').ComputedRef<import('../floating/index.js').TeleportTargetValue>;

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

@@ -1,5 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
+import { OverlayLayerContext } from '../../composables/useOverlayLayer.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 import { ItemPath } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type UseDropdownMenuDisclosureOptions = {
@@ -7,6 +8,9 @@ type UseDropdownMenuDisclosureOptions = {
     emit: {
         openChange?: (open: boolean) => void;
         select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
+        pointerDownOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+        focusOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+        interactOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
     };
     rootRef: Ref<HTMLElement | null>;
     menuRef: Ref<HTMLElement | null>;
@@ -22,8 +26,9 @@ type UseDropdownMenuDisclosureOptions = {
     focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
     focusMenu: () => void;
     focusTrigger: () => void;
+    layer: OverlayLayerContext;
 };
-export declare function useDropdownMenuDisclosure({ props, emit, rootRef, menuRef, targetRef, uncontrolledOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, }: UseDropdownMenuDisclosureOptions): {
+export declare function useDropdownMenuDisclosure({ props, emit, rootRef, menuRef, targetRef, uncontrolledOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, layer, }: UseDropdownMenuDisclosureOptions): {
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions) => void;
     toggle: () => void;

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

@@ -12,8 +12,8 @@ export declare function useDropdownMenuPortalPosition(options: {
     placement: PlacementSource;
     restartKey: () => unknown;
 }): {
-    actualPlacement: Ref<DropdownMenuPlacement, DropdownMenuPlacement>;
-    arrowStyle: Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>;
-    contentStyle: Ref<import('vue').CSSProperties, import('vue').CSSProperties>;
+    actualPlacement: Readonly<Ref<import('../floating/index.js').FloatingPlacement, import('../floating/index.js').FloatingPlacement>>;
+    arrowStyle: Readonly<Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>>;
+    contentStyle: Readonly<Ref<import('vue').CSSProperties, import('vue').CSSProperties>>;
 };
 export {};

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

@@ -0,0 +1,27 @@
+import { ComponentRefValue } from './dropdown-menu-primitive-core.js';
+import { DropdownMenuContentPrimitiveProps, DropdownMenuInteractOutsideEvent, DropdownMenuPlacement } from './types.js';
+type ContentProps = Readonly<DropdownMenuContentPrimitiveProps>;
+type ContentEvents = {
+    escapeKeyDown: (event: CustomEvent<{
+        originalEvent: KeyboardEvent;
+    }>) => void;
+    pointerDownOutside: (event: DropdownMenuInteractOutsideEvent) => void;
+    focusOutside: (event: DropdownMenuInteractOutsideEvent) => void;
+    interactOutside: (event: DropdownMenuInteractOutsideEvent) => void;
+};
+export declare function useDropdownMenuPrimitiveContent(props: ContentProps, attrs: Record<string, unknown>, events: ContentEvents, submenu: boolean): {
+    id: import('vue').ComputedRef<string>;
+    element: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    arrowElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    actualPlacement: import('vue').Ref<DropdownMenuPlacement, DropdownMenuPlacement>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    shouldRender: import('vue').ComputedRef<boolean>;
+    placementSide: import('vue').ComputedRef<string>;
+    rootAttrs: import('vue').ComputedRef<{
+        [x: string]: unknown;
+    }>;
+    floating: import('../floating/index.js').UseFloatingPositionReturn;
+    setElement: (value: ComponentRefValue) => void;
+    close: () => void;
+};
+export {};

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

@@ -33,8 +33,10 @@ export interface DropdownMenuRenderContext {
     getSubmenuPlacement: () => DropdownMenuPlacement;
     getStrategy: () => NonNullable<DropdownMenuProps['strategy']>;
     getFlip: () => boolean;
+    getFlipOptions: () => DropdownMenuProps['flipOptions'];
     getShift: () => boolean;
     getCollisionPadding: () => NonNullable<DropdownMenuProps['collisionPadding']>;
+    getAutoUpdateOptions: () => DropdownMenuProps['autoUpdateOptions'];
 }
 export declare function useDropdownMenuRenderItems({ props, actualPlacement, items, getItemId, getSubmenuId, getMenuActiveDescendant, getItemElement, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
     renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;

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

@@ -1 +1,3 @@
-export type { FloatingAlignment, FloatingCollisionPadding, FloatingOffset, FloatingOffsetOptions, FloatingPlacement, FloatingPositionProps, FloatingReference, FloatingSide, FloatingStrategy, FloatingTarget, FloatingVirtualElement, TeleportProps, TeleportTarget, TeleportTargetValue, } from './types.js';
+export { useHoverDisclosure } from './useHoverDisclosure.js';
+export { useFloatingPosition } from './useFloatingPosition.js';
+export type { FloatingAlignment, FloatingAutoUpdateOptions, FloatingCollisionPadding, FloatingFlipFallbackStrategy, FloatingFlipOptions, FloatingOffset, FloatingOffsetOptions, FloatingPlacement, FloatingPositionProps, FloatingReference, FloatingSide, FloatingStrategy, FloatingTarget, FloatingVirtualElement, HoverDisclosureContentProps, HoverDisclosureContentTarget, HoverDisclosureInteractionTarget, HoverDisclosureOpenChangeDetails, HoverDisclosureOpenChangeReason, HoverDisclosureOption, HoverDisclosureState, HoverDisclosureTouchBehavior, HoverDisclosureTriggerProps, TeleportProps, TeleportTarget, TeleportTargetValue, UseHoverDisclosureOptions, UseHoverDisclosureReturn, UseFloatingPositionOptions, UseFloatingPositionReturn, } from './types.js';

package/dist/components/floating/index.js

@@ -0,0 +1,3 @@
+import { n as useFloatingPosition } from "../../useFloatingPosition.js";
+import { t as useHoverDisclosure } from "../../floating.js";
+export { useFloatingPosition, useHoverDisclosure };

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

@@ -1,5 +1,5 @@
 import { VirtualElement } from '@floating-ui/dom';
-import { Ref } from 'vue';
+import { ComputedRef, CSSProperties, MaybeRefOrGetter, Ref } from 'vue';
 export type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
 export type FloatingAlignment = 'start' | 'end';
 export type FloatingPlacement = FloatingSide | `${FloatingSide}-${FloatingAlignment}`;
@@ -10,6 +10,13 @@ export interface FloatingOffsetOptions {
 }
 export type FloatingOffset = number | FloatingOffsetOptions;
 export type FloatingCollisionPadding = number | Partial<Record<FloatingSide, number>>;
+export type FloatingFlipFallbackStrategy = 'bestFit' | 'initialPlacement';
+export interface FloatingFlipOptions {
+    fallbackStrategy?: FloatingFlipFallbackStrategy;
+}
+export interface FloatingAutoUpdateOptions {
+    animationFrame?: boolean;
+}
 export type FloatingReference = Element | VirtualElement;
 export type FloatingTarget = string | FloatingReference | Ref<FloatingReference | null | undefined>;
 export interface FloatingPositionProps<TPlacement extends FloatingPlacement = FloatingPlacement> extends TeleportProps {
@@ -18,10 +25,34 @@ export interface FloatingPositionProps<TPlacement extends FloatingPlacement = Fl
     strategy?: FloatingStrategy;
     offset?: FloatingOffset;
     flip?: boolean;
+    flipOptions?: FloatingFlipOptions;
     shift?: boolean;
     collisionPadding?: FloatingCollisionPadding;
+    autoUpdateOptions?: FloatingAutoUpdateOptions;
     arrow?: boolean;
 }
+export interface UseFloatingPositionOptions {
+    reference: MaybeRefOrGetter<FloatingReference | null | undefined>;
+    floating: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    arrow?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    open?: MaybeRefOrGetter<boolean | undefined>;
+    placement?: MaybeRefOrGetter<FloatingPlacement | undefined>;
+    strategy?: MaybeRefOrGetter<FloatingStrategy | undefined>;
+    offset?: MaybeRefOrGetter<FloatingOffset | undefined>;
+    flip?: MaybeRefOrGetter<boolean | undefined>;
+    flipOptions?: MaybeRefOrGetter<FloatingFlipOptions | undefined>;
+    shift?: MaybeRefOrGetter<boolean | undefined>;
+    collisionPadding?: MaybeRefOrGetter<FloatingCollisionPadding | undefined>;
+    autoUpdateOptions?: MaybeRefOrGetter<FloatingAutoUpdateOptions | undefined>;
+    restartKey?: MaybeRefOrGetter<unknown>;
+}
+export interface UseFloatingPositionReturn {
+    actualPlacement: Readonly<Ref<FloatingPlacement>>;
+    arrowStyle: Readonly<Ref<CSSProperties | undefined>>;
+    floatingStyle: Readonly<Ref<CSSProperties>>;
+    isPositioned: Readonly<Ref<boolean>>;
+    update: () => Promise<void>;
+}
 export type TeleportTargetValue = string | Element;
 export type TeleportTarget = TeleportTargetValue | Ref<TeleportTargetValue | null | undefined>;
 export interface TeleportProps {
@@ -29,3 +60,57 @@ export interface TeleportProps {
     teleportTo?: TeleportTarget | null;
 }
 export type FloatingVirtualElement = VirtualElement;
+export type HoverDisclosureState = 'open' | 'closed';
+export type HoverDisclosureTouchBehavior = 'none' | 'toggle';
+export type HoverDisclosureOpenChangeReason = 'hover' | 'focus' | 'touch' | 'escape' | 'outside' | 'disabled' | 'programmatic';
+export type HoverDisclosureOption<T> = MaybeRefOrGetter<T>;
+export type HoverDisclosureInteractionTarget = string | FloatingReference;
+export type HoverDisclosureContentTarget = string | Element;
+export interface HoverDisclosureOpenChangeDetails {
+    reason: HoverDisclosureOpenChangeReason;
+    event?: Event;
+}
+export interface HoverDisclosureTriggerProps {
+    'data-state': HoverDisclosureState;
+    onPointerenter: (event: PointerEvent) => void;
+    onPointerleave: (event: PointerEvent) => void;
+    onPointerdown: (event: PointerEvent) => void;
+    onPointerup: (event: PointerEvent) => void;
+    onPointercancel: (event: PointerEvent) => void;
+    onClick: (event: MouseEvent) => void;
+    onFocusin: (event: FocusEvent) => void;
+    onFocusout: (event: FocusEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface HoverDisclosureContentProps {
+    'data-state': HoverDisclosureState;
+    onPointerenter: (event: PointerEvent) => void;
+    onPointerleave: (event: PointerEvent) => void;
+    onPointerdown: (event: PointerEvent) => void;
+    onFocusin: (event: FocusEvent) => void;
+    onFocusout: (event: FocusEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface UseHoverDisclosureOptions {
+    open?: HoverDisclosureOption<boolean | undefined>;
+    defaultOpen?: boolean;
+    openDelay?: HoverDisclosureOption<number | undefined>;
+    closeDelay?: HoverDisclosureOption<number | undefined>;
+    disabled?: HoverDisclosureOption<boolean | undefined>;
+    openOnFocus?: HoverDisclosureOption<boolean | undefined>;
+    closeOnEscape?: HoverDisclosureOption<boolean | undefined>;
+    touchBehavior?: HoverDisclosureOption<HoverDisclosureTouchBehavior | undefined>;
+    interactionTarget?: HoverDisclosureOption<HoverDisclosureInteractionTarget | null | undefined>;
+    contentTarget?: HoverDisclosureOption<HoverDisclosureContentTarget | null | undefined>;
+    onOpenChange?: (open: boolean, details: HoverDisclosureOpenChangeDetails) => void;
+}
+export interface UseHoverDisclosureReturn {
+    isOpen: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    state: ComputedRef<HoverDisclosureState>;
+    triggerProps: ComputedRef<HoverDisclosureTriggerProps>;
+    contentProps: ComputedRef<HoverDisclosureContentProps>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}