ropav 0.0.9 → 0.0.11

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

@@ -1,4 +1,4 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types';
+import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types.js';
 export declare const DEFAULT_PLACEMENT: DropdownMenuPlacement;
 export declare const DEFAULT_FOCUS_TARGET: DropdownMenuFocusTarget;
 export type ItemPath = DropdownMenuItemPath;

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

@@ -1,8 +1,8 @@
-import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSlotProps } from './types';
+import { DropdownMenuItem, DropdownMenuItemSlotProps, 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;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -13,7 +13,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);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -1,3 +1,55 @@
-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';
+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 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';

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 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 };

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 } 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,136 @@ 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;
+    /** @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 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;
+    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' | 'placement'> {
+    placement?: DropdownMenuPlacement;
 }

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

@@ -1,32 +1,41 @@
-import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types';
+import { DropdownMenuContentProps, 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;
 }): {
     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>;
     visibleItems: import('vue').ComputedRef<DropdownMenuItem[]>;
-    renderedItems: import('vue').ComputedRef<import('./types').DropdownMenuRenderedItem[]>;
+    renderedItems: import('vue').ComputedRef<import('./types.js').DropdownMenuRenderedItem[]>;
+    renderContext: import('./useDropdownMenuRenderItems.js').DropdownMenuRenderContext;
     focusedIndex: import('vue').ComputedRef<number>;
-    focusedPath: import('vue').Ref<number[], number[] | import('./types').DropdownMenuItemPath>;
+    focusedPath: import('vue').Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     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>;
+    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').DropdownMenuOpenOptions | import('./types').DropdownMenuFocusTarget) => void;
-    close: (options?: import('./types').DropdownMenuCloseOptions) => void;
+    open: (options?: import('./types.js').DropdownMenuOpenOptions | import('./types.js').DropdownMenuFocusTarget) => void;
+    close: (options?: import('./types.js').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;
+    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;
     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;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemSlotProps;
 };

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

@@ -1,14 +1,16 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, 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;
     };
     rootRef: Ref<HTMLElement | null>;
+    menuRef: Ref<HTMLElement | null>;
+    targetRef: Readonly<Ref<Element | null>>;
     uncontrolledOpen: Ref<boolean>;
     isDisabled: BooleanSource;
     isOpen: BooleanSource;
@@ -21,7 +23,7 @@ type UseDropdownMenuDisclosureOptions = {
     focusMenu: () => void;
     focusTrigger: () => void;
 };
-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, }: UseDropdownMenuDisclosureOptions): {
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions) => void;
     toggle: () => void;

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

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuPlacement } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuPlacement } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type StringSource = {
     readonly value: string;
 };
@@ -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/useDropdownMenuHoverIntent.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuItem } from './types';
-import { ItemPath, PointerPoint } from './dropdown-menu-utils';
+import { DropdownMenuItem } from './types.js';
+import { ItemPath, PointerPoint } from './dropdown-menu-utils.js';
 export type SafeTriangle = [PointerPoint, PointerPoint, PointerPoint];
 type GetSafeTriangleOptions = {
     itemRect: DOMRect | null;

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

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
-import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils';
+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 = {
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
@@ -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/useDropdownMenuNavigation.d.ts

@@ -1,10 +1,10 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuFocusTarget, DropdownMenuItem } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };
 export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource): {
-    focusedPath: import('vue').Ref<number[], number[] | import('./types').DropdownMenuItemPath>;
+    focusedPath: import('vue').Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     focusedIndex: import('vue').ComputedRef<number>;
     getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;

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: Ref<DropdownMenuPlacement, DropdownMenuPlacement>;
+    arrowStyle: Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>;
+    contentStyle: Ref<import('vue').CSSProperties, import('vue').CSSProperties>;
+};
+export {};

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

@@ -1,13 +1,18 @@
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+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;
@@ -17,9 +22,24 @@ type UseDropdownMenuRenderItemsOptions = {
     closeSubmenu: (path: ItemPath) => void;
     close: (options?: DropdownMenuCloseOptions) => void;
 };
-export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
+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({ props, actualPlacement, items, getItemId, getSubmenuId, getMenuActiveDescendant, getItemElement, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
     renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;
-    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemProps;
-    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemSlotProps;
+    renderContext: DropdownMenuRenderContext;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemSlotProps;
 };
 export {};

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

@@ -1,13 +1,13 @@
 import { Ref } from 'vue';
-import { DropdownMenuItem } from './types';
-import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils';
+import { DropdownMenuItem } from './types.js';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils.js';
 type UseDropdownSubmenusOptions = {
     focusedPath: Ref<ItemPath>;
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
     focusItem: (target: Exclude<SubmenuFocusTarget, false>, menuPath?: ItemPath) => boolean;
 };
 export declare function useDropdownSubmenus({ focusedPath, getItemAtPath, focusItem, }: UseDropdownSubmenusOptions): {
-    openSubmenuPath: Ref<number[], number[] | import('./types').DropdownMenuItemPath>;
+    openSubmenuPath: Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     resetSubmenus: () => void;
     isSubmenuOpen: (path: ItemPath) => boolean;
     closeSubmenusAfter: (menuPath: ItemPath) => void;

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

@@ -1,4 +1,4 @@
-import { FieldProps } from './types';
+import { FieldProps } 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<FieldProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -15,7 +15,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             invalid: true | undefined;
             labelledby: string | undefined;
             describedby: string | undefined;
-            controlProps: import('./types').FieldControlProps;
+            controlProps: import('./types.js').FieldControlProps;
         }) => any;
     } & {
         description?: (props: {}) => any;

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

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

package/dist/components/field/index.js

@@ -1,2 +1,2 @@
-import { t as field_default } from "../../field.js";
-export { field_default as Field };
+import { n as field_default, t as fieldParts } from "../../field.js";
+export { field_default as Field, fieldParts };

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

@@ -1,3 +1,4 @@
+import { StylesApiProps } from '../../styles-api.js';
 export interface FieldControlProps {
     id: string;
     disabled?: boolean;
@@ -9,7 +10,7 @@ export interface FieldControlProps {
 export interface FieldSlotProps extends FieldControlProps {
     controlProps: FieldControlProps;
 }
-export interface FieldProps {
+export interface FieldProps extends StylesApiProps<FieldPart> {
     id?: string;
     label?: string;
     description?: string;
@@ -17,3 +18,5 @@ export interface FieldProps {
     required?: boolean;
     invalid?: boolean;
 }
+export declare const fieldParts: readonly ["root", "label", "required", "control", "description"];
+export type FieldPart = (typeof fieldParts)[number];

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

@@ -1,4 +1,4 @@
-import { FieldControlProps, FieldProps } from './types';
+import { FieldControlProps, FieldProps } from './types.js';
 export declare function useField(props: Readonly<FieldProps>): {
     controlId: import('vue').ComputedRef<string>;
     labelId: import('vue').ComputedRef<string>;

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

@@ -0,0 +1 @@
+export type { FloatingAlignment, FloatingCollisionPadding, FloatingOffset, FloatingOffsetOptions, FloatingPlacement, FloatingPositionProps, FloatingReference, FloatingSide, FloatingStrategy, FloatingTarget, FloatingVirtualElement, TeleportProps, TeleportTarget, TeleportTargetValue, } from './types.js';

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

@@ -0,0 +1,31 @@
+import { VirtualElement } from '@floating-ui/dom';
+import { Ref } from 'vue';
+export type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
+export type FloatingAlignment = 'start' | 'end';
+export type FloatingPlacement = FloatingSide | `${FloatingSide}-${FloatingAlignment}`;
+export type FloatingStrategy = 'absolute' | 'fixed';
+export interface FloatingOffsetOptions {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+export type FloatingOffset = number | FloatingOffsetOptions;
+export type FloatingCollisionPadding = number | Partial<Record<FloatingSide, number>>;
+export type FloatingReference = Element | VirtualElement;
+export type FloatingTarget = string | FloatingReference | Ref<FloatingReference | null | undefined>;
+export interface FloatingPositionProps<TPlacement extends FloatingPlacement = FloatingPlacement> extends TeleportProps {
+    target?: FloatingTarget | null;
+    placement?: TPlacement;
+    strategy?: FloatingStrategy;
+    offset?: FloatingOffset;
+    flip?: boolean;
+    shift?: boolean;
+    collisionPadding?: FloatingCollisionPadding;
+    arrow?: boolean;
+}
+export type TeleportTargetValue = string | Element;
+export type TeleportTarget = TeleportTargetValue | Ref<TeleportTargetValue | null | undefined>;
+export interface TeleportProps {
+    teleport?: boolean;
+    teleportTo?: TeleportTarget | null;
+}
+export type FloatingVirtualElement = VirtualElement;