ropav 0.0.10 → 0.0.12

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, 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) => 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) => 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

@@ -1,3 +1,34 @@
+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: (__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 { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuRenderedItem, DropdownMenuSlotProps, DropdownMenuSubmenuProps, DropdownMenuTriggerProps, } 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 { n as useDropdownMenu, t as dropdown_menu_default } from "../../dropdown-menu.js";
-export { dropdown_menu_default as DropdownMenu, 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,4 +1,12 @@
-export type DropdownMenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+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';
+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';
+export type DropdownMenuTarget = FloatingTarget;
+export type DropdownMenuStrategy = FloatingStrategy;
+export type DropdownMenuCollisionPadding = FloatingCollisionPadding;
 export type DropdownMenuItemValue = string | number;
 export type DropdownMenuFocusTarget = 'first' | 'last';
 export type DropdownMenuItemPath = number[];
@@ -21,6 +29,10 @@ export interface DropdownMenuTriggerProps {
     'aria-expanded'?: boolean;
     'aria-haspopup': 'menu';
     disabled?: boolean;
+    class?: HTMLAttributes['class'];
+    style?: HTMLAttributes['style'];
+    'data-state'?: 'open' | 'closed';
+    'data-disabled'?: '';
     onClick: (event: MouseEvent) => void;
     onKeydown: (event: KeyboardEvent) => void;
 }
@@ -65,9 +77,9 @@ export interface DropdownMenuItemProps {
     'aria-expanded'?: boolean;
     'aria-haspopup'?: 'menu';
     'aria-disabled'?: true;
-    'data-disabled'?: true;
-    'data-focused'?: true;
-    'data-submenu'?: true;
+    'data-disabled'?: '';
+    'data-highlighted'?: '';
+    'data-submenu'?: '';
     onClick: (event: MouseEvent) => void;
     onMouseenter: (event: MouseEvent) => void;
 }
@@ -93,12 +105,139 @@ export interface DropdownMenuRenderedItem {
     slotProps: DropdownMenuItemSlotProps;
     children: DropdownMenuRenderedItem[];
 }
-export interface DropdownMenuProps {
+export interface DropdownMenuProps extends FloatingPositionProps<DropdownMenuPlacement>, StylesApiProps<DropdownMenuPart> {
     id?: string;
     items?: DropdownMenuItem[];
-    placement?: DropdownMenuPlacement;
     open?: boolean;
     disabled?: boolean;
     closeOnSelect?: boolean;
     ariaLabel?: string;
+    modal?: boolean;
+    ignore?: readonly DropdownMenuInteractOutsideTarget[];
+    /** @deprecated Use `teleport` instead. */
+    portal?: boolean;
+    /** @deprecated Use `teleportTo` instead. */
+    portalTo?: string | HTMLElement;
+}
+export type DropdownMenuAs = string | Component;
+export type DropdownMenuCheckedState = boolean | 'indeterminate';
+export interface DropdownMenuPoint {
+    x: number;
+    y: number;
+}
+export type DropdownMenuVirtualAnchor = FloatingVirtualElement;
+export interface DropdownMenuSelectDetail {
+    originalEvent: Event;
+    value?: DropdownMenuItemValue;
+}
+export type DropdownMenuSelectEvent = CustomEvent<DropdownMenuSelectDetail>;
+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 {
+    id?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    modal?: boolean;
+    target?: FloatingTarget | null;
+    virtualAnchor?: DropdownMenuVirtualAnchor | null;
+}
+export interface DropdownMenuRootSlotProps {
+    isOpen: boolean;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+    openAt: (point: DropdownMenuPoint, options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+}
+export interface DropdownMenuTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+}
+export interface DropdownMenuContextTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+    longPressDelay?: number;
+    longPressTolerance?: number;
+}
+export interface DropdownMenuPortalPrimitiveProps extends TeleportProps {
+    to?: string | HTMLElement;
+    disabled?: boolean;
+}
+export interface DropdownMenuContentPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    placement?: DropdownMenuPlacement;
+    offset?: DropdownMenuOffset;
+    strategy?: FloatingStrategy;
+    flip?: boolean;
+    shift?: boolean;
+    collisionPadding?: FloatingCollisionPadding;
+    arrow?: boolean;
+    /** @deprecated Use `flip` and `shift` instead. */
+    avoidCollisions?: boolean;
+    forceMount?: boolean;
+    ignore?: readonly DropdownMenuInteractOutsideTarget[];
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+}
+export interface DropdownMenuItemPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    value?: DropdownMenuItemValue;
+    disabled?: boolean;
+    destructive?: boolean;
+    closeOnSelect?: boolean;
+}
+export interface DropdownMenuItemPrimitiveSlotProps {
+    focused: boolean;
+    disabled: boolean;
+    select: () => void;
+}
+export interface DropdownMenuSeparatorPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    orientation?: 'horizontal' | 'vertical';
+}
+export interface DropdownMenuLabelPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+}
+export interface DropdownMenuCheckboxItemPrimitiveProps extends Omit<DropdownMenuItemPrimitiveProps, 'value'> {
+    modelValue?: DropdownMenuCheckedState;
+    defaultValue?: DropdownMenuCheckedState;
+}
+export interface DropdownMenuRadioGroupPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    modelValue?: DropdownMenuItemValue | null;
+    defaultValue?: DropdownMenuItemValue | null;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+}
+export interface DropdownMenuRadioItemPrimitiveProps extends Omit<DropdownMenuItemPrimitiveProps, 'value'> {
+    value: DropdownMenuItemValue;
+}
+export interface DropdownMenuItemIndicatorPrimitiveProps {
+    as?: DropdownMenuAs;
+    forceMount?: boolean;
+}
+export interface DropdownMenuSubPrimitiveProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+}
+export interface DropdownMenuSubTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+}
+export interface DropdownMenuSubContentPrimitiveProps extends Omit<DropdownMenuContentPrimitiveProps, 'arrow' | 'ignore' | 'placement'> {
+    placement?: DropdownMenuPlacement;
 }

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

@@ -1,10 +1,15 @@
-import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, 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) => 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>;
+    arrowRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     menuId: import('vue').ComputedRef<string>;
     isVisible: import('vue').ComputedRef<boolean>;
     isEmpty: import('vue').ComputedRef<boolean>;
@@ -16,13 +21,20 @@ 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').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>;
+    shouldTeleport: import('vue').ComputedRef<boolean>;
     triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
     contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
     slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
     open: (options?: import('./types.js').DropdownMenuOpenOptions | import('./types.js').DropdownMenuFocusTarget) => void;
     close: (options?: import('./types.js').DropdownMenuCloseOptions) => void;
     toggle: () => void;
-    selectItem: (item: DropdownMenuItem) => void;
+    selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
     openSubmenu: (path: import('./dropdown-menu-utils.js').ItemPath, focus?: import('./dropdown-menu-utils.js').SubmenuFocusTarget, point?: import('./dropdown-menu-utils.js').PointerPoint) => boolean;
     closeSubmenu: (path: import('./dropdown-menu-utils.js').ItemPath) => boolean;
     onItemMouseenter: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, event?: MouseEvent) => void;

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

@@ -1,14 +1,20 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } 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 = {
     props: Readonly<DropdownMenuProps>;
     emit: {
         openChange?: (open: boolean) => void;
-        select?: (item: DropdownMenuItem) => 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>;
+    targetRef: Readonly<Ref<Element | null>>;
     uncontrolledOpen: Ref<boolean>;
     isDisabled: BooleanSource;
     isOpen: BooleanSource;
@@ -20,8 +26,9 @@ type UseDropdownMenuDisclosureOptions = {
     focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
     focusMenu: () => void;
     focusTrigger: () => void;
+    layer: OverlayLayerContext;
 };
-export declare function useDropdownMenuDisclosure({ props, emit, rootRef, 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/useDropdownMenuDom.d.ts

@@ -11,10 +11,11 @@ type UseDropdownMenuDomOptions = {
     menuId: StringSource;
     rootRef: Ref<HTMLElement | null>;
     menuRef: Ref<HTMLElement | null>;
+    targetRef: Readonly<Ref<Element | null>>;
     placement: PlacementSource;
     focusedPath: Ref<ItemPath>;
 };
-export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
+export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, targetRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     focusMenu: () => void;
     focusTrigger: () => void;

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

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type DisclosureControls = {
@@ -23,7 +23,7 @@ type HoverIntentControls = {
 type UseDropdownMenuInteractionsOptions = {
     props: Readonly<DropdownMenuProps>;
     emit: {
-        select?: (item: DropdownMenuItem) => void;
+        select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
     };
     isDisabled: BooleanSource;
     focusedPath: Ref<ItemPath>;
@@ -37,8 +37,8 @@ type UseDropdownMenuInteractionsOptions = {
     isSubmenuOpeningLeft: (path: ItemPath) => boolean;
 };
 export declare function useDropdownMenuInteractions({ props, emit, isDisabled, focusedPath, openSubmenuPath, getItemAtPath, focusItem, moveFocus, submenus, hoverIntent, disclosure, isSubmenuOpeningLeft, }: UseDropdownMenuInteractionsOptions): {
-    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
-    selectItem: (item: DropdownMenuItem) => void;
+    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent | KeyboardEvent) => void;
+    selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
     openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;
     closeSubmenu: (path: ItemPath) => boolean;
     focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;

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

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { FloatingReference } from '../floating/types.js';
+import { DropdownMenuPlacement, DropdownMenuProps } from './types.js';
+type BooleanSource = Readonly<Ref<boolean>>;
+type PlacementSource = Readonly<Ref<DropdownMenuPlacement>>;
+export declare function useDropdownMenuPortalPosition(options: {
+    props: Readonly<DropdownMenuProps>;
+    reference: Readonly<Ref<FloatingReference | null>>;
+    menuRef: Ref<HTMLElement | null>;
+    arrowRef: Ref<HTMLElement | null>;
+    isVisible: BooleanSource;
+    placement: PlacementSource;
+    restartKey: () => unknown;
+}): {
+    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

@@ -1,13 +1,18 @@
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuSubmenuProps } from './types.js';
+import { Ref } from 'vue';
+import { StylesApiPartOptions } from '../../styles-api.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuPlacement, DropdownMenuPart, DropdownMenuProps, DropdownMenuSubmenuProps } from './types.js';
 import { ItemPath } from './dropdown-menu-utils.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };
 type UseDropdownMenuRenderItemsOptions = {
+    props: Readonly<DropdownMenuProps>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
     items: DropdownMenuItemsSource;
     getItemId: (path: ItemPath) => string;
     getSubmenuId: (path: ItemPath) => string;
     getMenuActiveDescendant: (path: ItemPath) => string | undefined;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
     isItemFocused: (indexOrPath: number | ItemPath) => boolean;
     isSubmenuOpen: (path: ItemPath) => boolean;
     activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
@@ -18,13 +23,20 @@ type UseDropdownMenuRenderItemsOptions = {
     close: (options?: DropdownMenuCloseOptions) => void;
 };
 export interface DropdownMenuRenderContext {
+    getPublicPartAttrs?: (part: DropdownMenuPart, options?: StylesApiPartOptions) => object;
     isItemFocused: (indexOrPath: number | ItemPath) => boolean;
     isSubmenuOpen: (path: ItemPath) => boolean;
     getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;
     getSubmenuProps: (item: DropdownMenuItem, path: ItemPath, submenuOpen?: boolean) => DropdownMenuSubmenuProps;
     getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemSlotProps;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getSubmenuPlacement: () => DropdownMenuPlacement;
+    getStrategy: () => NonNullable<DropdownMenuProps['strategy']>;
+    getFlip: () => boolean;
+    getShift: () => boolean;
+    getCollisionPadding: () => NonNullable<DropdownMenuProps['collisionPadding']>;
 }
-export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
+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[]>;
     renderContext: DropdownMenuRenderContext;
     getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;

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

@@ -1,2 +1,3 @@
 export { default as Field } from './field.js';
-export type { FieldControlProps, FieldProps, FieldSlotProps } from './types.js';
+export { fieldParts } from './types.js';
+export type { FieldControlProps, FieldPart, FieldProps, FieldSlotProps } from './types.js';