ropav 0.1.6 → 0.1.7

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

@@ -1,4 +1,4 @@
-import { OpenFocusTarget } from './dropdown-menu-primitive-core.js';
+import { OpenFocusTarget } from './dropdownMenuContext.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 & {

package/dist/components/dropdown-menu/{dropdown-menu-primitive-core.d.ts → dropdownMenuContext.d.ts}

@@ -1,42 +1,47 @@
-import { ComponentPublicInstance, ComputedRef, InjectionKey, Ref, VaporComponentInstance } from 'vue';
+import { ComputedRef, InjectionKey, Ref } from 'vue';
 import { OverlayLayerContext } from '../../internal/composables/useOverlayLayer.js';
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
 import { FloatingReference } from '../floating/types.js';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuItemPrimitiveProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuSelectEvent, DropdownMenuVirtualAnchor } from './types.js';
+import { DropdownMenuInteractionFocusTarget, DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItemPrimitiveProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuSelectEvent, DropdownMenuVirtualAnchor } from './types.js';
 export type ElementReference = FloatingReference;
-export type OpenFocusTarget = DropdownMenuFocusTarget | false;
-export type ComponentRefValue = Element | ComponentPublicInstance | VaporComponentInstance | null;
+export type OpenFocusTarget = DropdownMenuInteractionFocusTarget;
 export interface MenuItemRegistration {
     id: string;
     element: () => HTMLElement | null;
     textValue: () => string;
     disabled: () => boolean;
-    activate: (event: Event) => void;
+    activate: (event: Event) => DropdownMenuSelectEvent | undefined;
+    closeOnSelect?: () => boolean;
     submenu?: DropdownMenuSubContext;
 }
 export interface DropdownMenuContext {
     root: DropdownMenuRootContext;
+    id: string;
     element: Ref<HTMLElement | null>;
-    activeId: Ref<string | null>;
+    activeId: ComputedRef<string | null>;
     actualPlacement: Ref<DropdownMenuPlacement>;
     parentSub?: DropdownMenuSubContext;
     registerItem: (item: MenuItemRegistration) => void;
     unregisterItem: (id: string) => void;
-    registerSub: (sub: DropdownMenuSubContext) => void;
-    unregisterSub: (sub: DropdownMenuSubContext) => void;
     closeSubmenus: (except?: DropdownMenuSubContext) => void;
     setActive: (id: string) => void;
     isActive: (id: string) => boolean;
     focus: (target?: DropdownMenuFocusTarget) => boolean;
     focusElement: () => void;
+    activate: (id: string, event?: Event) => void;
+    hover: (id: string, openSubmenu?: boolean) => void;
     onKeydown: (event: KeyboardEvent) => void;
 }
 export interface DropdownMenuSubContext {
+    menuId: string;
     isOpen: ComputedRef<boolean>;
     trigger: Ref<HTMLElement | null>;
     contentId: Ref<string | undefined>;
     actualPlacement: Ref<DropdownMenuPlacement>;
     pendingFocus: Ref<OpenFocusTarget>;
     menu: DropdownMenuContext | null;
+    setOpen: (open: boolean) => void;
     open: (focus?: OpenFocusTarget) => void;
     close: (focusParent?: boolean) => void;
 }
@@ -51,6 +56,7 @@ export interface DropdownMenuRootContext {
     reference: ComputedRef<ElementReference | null>;
     pendingFocus: Ref<OpenFocusTarget>;
     layer: OverlayLayerContext;
+    interaction: DropdownMenuInteractionRuntime;
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions & {
         returnFocus?: boolean;
@@ -62,7 +68,6 @@ export interface DropdownMenuRootContext {
     setReturnFocus: (element: HTMLElement | null) => void;
     registerInside: (element: HTMLElement) => void;
     unregisterInside: (element: HTMLElement) => void;
-    isInside: (event: Event) => boolean;
 }
 export interface DropdownMenuRadioGroupContext {
     value: ComputedRef<DropdownMenuItemValue | null>;
@@ -77,21 +82,14 @@ export declare const menuKey: InjectionKey<DropdownMenuContext>;
 export declare const subKey: InjectionKey<DropdownMenuSubContext>;
 export declare const radioGroupKey: InjectionKey<DropdownMenuRadioGroupContext>;
 export declare const checkedKey: InjectionKey<DropdownMenuCheckedContext>;
-export declare function optionalAttr<T extends boolean | string | undefined>(value: T): T | undefined;
-export declare function getFocusTarget(options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget): DropdownMenuFocusTarget;
-export declare function toHTMLElement(value: ComponentRefValue, fallbackId?: string): HTMLElement | null;
-export declare function resolveHTMLElementRef(value: ComponentRefValue, fallbackId: string, resolve: (element: HTMLElement | null) => void): void;
 export declare function createVirtualAnchor(point: DropdownMenuPoint): DropdownMenuVirtualAnchor;
-export declare function createCustomEvent<T>(type: string, detail: T, originalEvent: Event): CustomEvent<T>;
 export declare function createSelectEvent(originalEvent: Event, value?: DropdownMenuItemValue): DropdownMenuSelectEvent;
-export declare function createOutsideEvent(originalEvent: Event): DropdownMenuInteractOutsideEvent;
-export declare function blockNextDocumentClick(): void;
 export declare function createMenuContext(options: {
     root: DropdownMenuRootContext;
     element: Ref<HTMLElement | null>;
     actualPlacement: Ref<DropdownMenuPlacement>;
     parentSub?: DropdownMenuSubContext;
-    onEscape: (event: KeyboardEvent) => void;
+    onEscape: (event: KeyboardEvent) => boolean;
 }): DropdownMenuContext;
 export declare function usePrimitiveItem(componentName: string, props: Readonly<DropdownMenuItemPrimitiveProps>, emitSelect: (event: DropdownMenuSelectEvent) => void, options: {
     checked?: ComputedRef<boolean | 'mixed'>;
@@ -106,6 +104,6 @@ export declare function usePrimitiveItem(componentName: string, props: Readonly<
     checked: ComputedRef<boolean | "mixed"> | undefined;
     activate: (originalEvent: Event) => void;
     select: () => void;
-    setElement: (value: ComponentRefValue) => void;
+    setElement: (value: ComponentElementRef) => void;
     onPointerenter: () => void;
 };

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

@@ -0,0 +1,20 @@
+import { ItemPath } from './dropdown-menu-model.js';
+import { DropdownMenuItem } from './types.js';
+export interface DropdownMenuDataEntry {
+    item: DropdownMenuItem;
+    path: ItemPath;
+    itemId: string;
+    ownerMenuId: string;
+    order: number;
+    submenuMenuId: string | undefined;
+}
+export interface DropdownMenuDataIndex {
+    entries: readonly DropdownMenuDataEntry[];
+    itemIdByPath: ReadonlyMap<string, string>;
+    pathByItemId: ReadonlyMap<string, ItemPath>;
+    menuIdByPath: ReadonlyMap<string, string>;
+    pathByMenuId: ReadonlyMap<string, ItemPath>;
+    primaryItemId: WeakMap<DropdownMenuItem, string>;
+}
+export declare function buildDropdownMenuDataIndex(items: readonly DropdownMenuItem[], rootMenuId: string, getStableItemId: (item: DropdownMenuItem) => string): DropdownMenuDataIndex;
+export declare function getDropdownMenuDataCollectionState(items: readonly DropdownMenuItem[]): unknown[];

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

@@ -0,0 +1,3 @@
+import { DropdownMenuInteractionHost, DropdownMenuInteractionRuntime } from './dropdownMenuInteractionTypes.js';
+export type { DropdownMenuInteractionDismissalRegistration, DropdownMenuInteractionFocusTarget, DropdownMenuInteractionHost, DropdownMenuInteractionItemRegistration, DropdownMenuInteractionMenuRegistration, DropdownMenuInteractionMenuStateRegistration, DropdownMenuInteractionRuntime, } from './dropdownMenuInteractionTypes.js';
+export declare function useDropdownMenuInteraction(host: DropdownMenuInteractionHost): DropdownMenuInteractionRuntime;

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

@@ -0,0 +1,24 @@
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget } from './types.js';
+import { DropdownMenuInteractionRegistry } from './dropdownMenuInteractionRegistry.js';
+import { DropdownMenuInteractionFocusTarget, DropdownMenuInteractionHost } from './dropdownMenuInteractionTypes.js';
+interface CreateDropdownMenuInteractionNavigationOptions {
+    host: DropdownMenuInteractionHost;
+    registry: DropdownMenuInteractionRegistry;
+    closeRoot: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+}
+export declare function createDropdownMenuInteractionNavigation({ host, registry, closeRoot, }: CreateDropdownMenuInteractionNavigationOptions): {
+    closeMenu: (menuId: string, focusParent?: boolean) => boolean;
+    closeSubmenus: (menuId: string, exceptMenuId?: string) => void;
+    closeAllSubmenus: () => void;
+    focusMenu: (menuId: string, target?: DropdownMenuFocusTarget) => boolean;
+    openMenu: (menuId: string, focus?: DropdownMenuInteractionFocusTarget) => boolean;
+    selectItem: (id: string, originalEvent?: Event) => void;
+    activateItem: (id: string, originalEvent?: Event) => void;
+    hoverItem: (id: string, openSubmenu?: boolean) => void;
+    reconcile: (menuId?: string) => void;
+    reconcileOpenSubmenus: () => void;
+};
+export type DropdownMenuInteractionNavigation = ReturnType<typeof createDropdownMenuInteractionNavigation>;
+export {};

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

@@ -0,0 +1,42 @@
+import { DropdownMenuFocusTarget } from './types.js';
+import { DropdownMenuInteractionFocusTarget, DropdownMenuInteractionHost, DropdownMenuInteractionItemRegistration, DropdownMenuInteractionMenuRegistration, DropdownMenuInteractionMenuStateRegistration } from './dropdownMenuInteractionTypes.js';
+export interface DropdownMenuInteractionRegistryNavigation {
+    closeMenu: (menuId: string, focusParent?: boolean) => boolean;
+    closeSubmenus: (menuId: string, exceptMenuId?: string) => void;
+    focusMenu: (menuId: string, target?: DropdownMenuFocusTarget) => boolean;
+    reconcile: (menuId?: string) => void;
+    reconcileOpenSubmenus: () => void;
+}
+export declare function createDropdownMenuInteractionRegistry(host: DropdownMenuInteractionHost, navigation: DropdownMenuInteractionRegistryNavigation): {
+    activeItemId: import('vue').Ref<string | null, string | null>;
+    activeMenuId: import('vue').Ref<string, string>;
+    pendingRootFocus: import('vue').Ref<DropdownMenuInteractionFocusTarget, DropdownMenuInteractionFocusTarget>;
+    registerMenu: (registration: DropdownMenuInteractionMenuRegistration) => () => void;
+    unregisterMenu: (id: string) => void;
+    registerMenuState: (registration: DropdownMenuInteractionMenuStateRegistration) => () => void;
+    registerItem: (registration: DropdownMenuInteractionItemRegistration) => () => void;
+    unregisterItem: (id: string) => void;
+    getActiveId: (menuId: string) => import('vue').ComputedRef<string | null>;
+    getItem: (id: string) => DropdownMenuInteractionItemRegistration | undefined;
+    getMenu: (id: string) => DropdownMenuInteractionMenuRegistration | undefined;
+    isActive: (id: string) => boolean;
+    isMenuOpen: (menuId: string) => boolean;
+    setActive: (id: string | null, focusElement?: boolean) => boolean;
+    focusMenuElement: (menuId: string) => void;
+    state: {
+        getMenuState: (id: string) => DropdownMenuInteractionMenuStateRegistration | undefined;
+        getItems: (menuId: string) => DropdownMenuInteractionItemRegistration[];
+        getEnabledItems: (menuId: string) => DropdownMenuInteractionItemRegistration[];
+        getActiveIdValue: (menuId: string) => string | null;
+        clearMenuState: (menuId: string) => void;
+        getParentItem: (menuId: string) => DropdownMenuInteractionItemRegistration | undefined;
+        setMenuOpen: (menuId: string, open: boolean) => void;
+        chooseNeighbor: (menuId: string, previousIndex: number) => void;
+        getMenuIds: () => Set<string>;
+        getRegisteredMenuIds: () => string[];
+        getPendingMenuFocus: (menuId: string) => DropdownMenuInteractionFocusTarget | undefined;
+        setPendingMenuFocus: (menuId: string, focus: DropdownMenuInteractionFocusTarget) => Map<string, DropdownMenuInteractionFocusTarget>;
+        clearPendingMenuFocus: (menuId: string) => boolean;
+    };
+};
+export type DropdownMenuInteractionRegistry = ReturnType<typeof createDropdownMenuInteractionRegistry>;

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

@@ -0,0 +1,85 @@
+import { ComputedRef, Ref } from 'vue';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuInteractOutsideTarget, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuSelectEvent } from './types.js';
+export type DropdownMenuInteractionFocusTarget = DropdownMenuFocusTarget | false;
+export interface DropdownMenuInteractionMenuRegistration {
+    id: string;
+    parentItemId?: () => string | undefined;
+    element: () => HTMLElement | null;
+    focusTarget?: () => HTMLElement | null;
+    placement: () => DropdownMenuPlacement;
+    isOpen: () => boolean;
+    setOpen?: (open: boolean) => void;
+    stopKeyPropagation?: boolean;
+    onEscape?: (event: KeyboardEvent) => boolean;
+}
+export interface DropdownMenuInteractionMenuStateRegistration {
+    id: string;
+    isOpen: () => boolean;
+    setOpen: (open: boolean) => void;
+}
+export interface DropdownMenuInteractionItemRegistration {
+    id: string;
+    menuId: string;
+    element: () => HTMLElement | null;
+    textValue: () => string;
+    disabled: () => boolean;
+    order?: () => number;
+    submenuId?: () => string | undefined;
+    submenuDirection?: () => 'left' | 'right';
+    select?: (originalEvent: Event) => DropdownMenuSelectEvent | undefined;
+    closeOnSelect?: () => boolean;
+}
+export interface DropdownMenuInteractionDismissalRegistration {
+    ignoredTargets: () => readonly DropdownMenuInteractOutsideTarget[];
+    pointerDownOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    focusOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    interactOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+}
+export interface DropdownMenuInteractionHost {
+    rootMenuId: string;
+    isOpen: Readonly<Ref<boolean>>;
+    disabled: Readonly<Ref<boolean>>;
+    modal: Readonly<Ref<boolean>>;
+    setOpen: (open: boolean) => void;
+    isTopLayer: () => boolean;
+    focusTrigger: () => void;
+    beforeOpen?: () => void;
+    beforeClose?: () => void;
+}
+export interface DropdownMenuInteractionRuntime {
+    rootMenuId: string;
+    activeItemId: Readonly<Ref<string | null>>;
+    activeMenuId: Readonly<Ref<string>>;
+    pendingRootFocus: Ref<DropdownMenuInteractionFocusTarget>;
+    registerMenu: (registration: DropdownMenuInteractionMenuRegistration) => () => void;
+    unregisterMenu: (id: string) => void;
+    registerMenuState: (registration: DropdownMenuInteractionMenuStateRegistration) => () => void;
+    registerItem: (registration: DropdownMenuInteractionItemRegistration) => () => void;
+    unregisterItem: (id: string) => void;
+    registerInside: (element: Element) => void;
+    unregisterInside: (element: Element) => void;
+    registerDismissal: (registration: DropdownMenuInteractionDismissalRegistration) => () => void;
+    getActiveId: (menuId: string) => ComputedRef<string | null>;
+    getItem: (id: string) => DropdownMenuInteractionItemRegistration | undefined;
+    getMenu: (id: string) => DropdownMenuInteractionMenuRegistration | undefined;
+    isActive: (id: string) => boolean;
+    isMenuOpen: (menuId: string) => boolean;
+    setActive: (id: string | null, focusElement?: boolean) => boolean;
+    focusMenu: (menuId: string, target?: DropdownMenuFocusTarget) => boolean;
+    focusMenuElement: (menuId: string) => void;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+    toggle: () => void;
+    openMenu: (menuId: string, focus?: DropdownMenuInteractionFocusTarget) => boolean;
+    closeMenu: (menuId: string, focusParent?: boolean) => boolean;
+    closeSubmenus: (menuId: string, exceptMenuId?: string) => void;
+    selectItem: (id: string, originalEvent?: Event) => void;
+    activateItem: (id: string, originalEvent?: Event) => void;
+    hoverItem: (id: string, openSubmenu?: boolean) => void;
+    reconcile: (menuId?: string) => void;
+    onTriggerClick: (beforeToggle?: () => void) => void;
+    onTriggerKeydown: (event: KeyboardEvent, beforeOpen?: () => void) => void;
+    onMenuKeydown: (menuId: string, event: KeyboardEvent) => void;
+}

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

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { DropdownMenuContentProps, DropdownMenuInteractOutsideEvent, DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+import { DropdownMenuCloseOptions, DropdownMenuInteractOutsideEvent, DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit?: {
     openChange?: (open: boolean) => void;
     select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
@@ -17,7 +17,7 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     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.js').DropdownMenuItemPath>;
+    focusedPath: import('vue').Ref<import('./types.js').DropdownMenuItemPath, import('./types.js').DropdownMenuItemPath>;
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentClass: import('vue').ComputedRef<string[]>;
@@ -28,18 +28,18 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     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>;
+    triggerProps: import('vue').ComputedRef<import('./types.js').DropdownMenuTriggerProps>;
+    contentProps: import('vue').ComputedRef<import('./types.js').DropdownMenuContentProps>;
+    slotProps: import('vue').ComputedRef<import('./types.js').DropdownMenuSlotProps>;
     open: (options?: import('./types.js').DropdownMenuOpenOptions | import('./types.js').DropdownMenuFocusTarget) => void;
-    close: (options?: import('./types.js').DropdownMenuCloseOptions) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
     toggle: () => 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;
+    openSubmenu: (path: import('./dropdown-menu-model.js').ItemPath, focus?: import('./dropdown-menu-model.js').SubmenuFocusTarget, point?: import('../../utils/geometry.js').Point) => boolean;
+    closeSubmenu: (path: import('./dropdown-menu-model.js').ItemPath) => boolean;
+    onItemMouseenter: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-model.js').ItemPath, event?: MouseEvent) => void;
     onTriggerKeydown: (event: KeyboardEvent) => void;
     onMenuKeydown: (event: KeyboardEvent) => void;
-    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;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-model.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-model.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemSlotProps;
 };

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

@@ -0,0 +1,9 @@
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { DropdownMenuContextTriggerPrimitiveProps } from './types.js';
+export declare function useDropdownMenuContextTrigger(props: Readonly<DropdownMenuContextTriggerPrimitiveProps>): {
+    isOpen: import('vue').ComputedRef<boolean>;
+    rootAttrs: import('vue').ComputedRef<{
+        [x: string]: unknown;
+    }>;
+    setElement: (value: ComponentElementRef) => void;
+};

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

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+import { Point } from '../../utils/geometry.js';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-model.js';
+import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuItem, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
+interface UseDropdownMenuDataControllerOptions {
+    props: Readonly<DropdownMenuProps>;
+    items: Readonly<Ref<DropdownMenuItem[]>>;
+    rootMenuId: string;
+    menuId: Readonly<Ref<string>>;
+    menuRef: Readonly<Ref<HTMLElement | null>>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
+    interaction: DropdownMenuInteractionRuntime;
+    onSelect?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
+}
+export declare function useDropdownMenuDataController({ props, items, rootMenuId, menuId, menuRef, actualPlacement, interaction, onSelect, }: UseDropdownMenuDataControllerOptions): {
+    focusedPath: Ref<import('./types.js').DropdownMenuItemPath, import('./types.js').DropdownMenuItemPath>;
+    focusedIndex: import('vue').ComputedRef<number>;
+    activeDescendantId: import('vue').ComputedRef<string | undefined>;
+    getItemId: (path: ItemPath) => string;
+    getSubmenuId: (path: ItemPath) => string;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getMenuActiveDescendant: (path: ItemPath) => string | undefined;
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: Point) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    resetHoverIntent: () => void;
+    selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
+    activateItem: (_item: DropdownMenuItem, path: ItemPath, event?: MouseEvent | KeyboardEvent) => void;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+import { DropdownMenuDataIndex } from './dropdownMenuDataModel.js';
+import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
+import { ItemPath } from './dropdown-menu-model.js';
+type DropdownMenuDataInteraction = Pick<DropdownMenuInteractionRuntime, 'reconcile' | 'registerItem' | 'registerMenu' | 'unregisterItem' | 'unregisterMenu'>;
+interface UseDropdownMenuDataRegistrationOptions {
+    props: Readonly<DropdownMenuProps>;
+    items: Readonly<Ref<DropdownMenuItem[]>>;
+    rootMenuId: string;
+    interaction: DropdownMenuDataInteraction;
+    menuRef: Readonly<Ref<HTMLElement | null>>;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getSubmenuElement: (path: ItemPath) => HTMLElement | null;
+    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
+    onSelect?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
+}
+export declare function useDropdownMenuDataRegistration({ props, items, rootMenuId, interaction, menuRef, getItemElement, getSubmenuElement, isSubmenuOpeningLeft, onSelect, }: UseDropdownMenuDataRegistrationOptions): {
+    openMenuIds: Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    registrationIndex: import('vue').ShallowRef<DropdownMenuDataIndex, DropdownMenuDataIndex>;
+};
+export {};

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

@@ -1,13 +1,14 @@
 import { Ref } from 'vue';
+import { Point, Triangle } from '../../utils/geometry.js';
+import { ItemPath } from './dropdown-menu-model.js';
 import { DropdownMenuItem } from './types.js';
-import { ItemPath, PointerPoint } from './dropdown-menu-utils.js';
-export type SafeTriangle = [PointerPoint, PointerPoint, PointerPoint];
+export type SafeTriangle = Triangle;
 type GetSafeTriangleOptions = {
     itemRect: DOMRect | null;
     submenuRect: DOMRect;
-    origin: PointerPoint;
+    origin: Point;
 };
-type HoverCommit = (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void;
+type HoverCommit = (item: DropdownMenuItem, path: ItemPath, point?: Point) => void;
 type UseDropdownMenuHoverIntentOptions = {
     openSubmenuPath: Ref<ItemPath>;
     getItemElement: (path: ItemPath) => HTMLElement | null;
@@ -17,7 +18,7 @@ export declare function getDropdownMenuSafeTriangle({ itemRect, submenuRect, ori
 export declare function useDropdownMenuHoverIntent({ openSubmenuPath, getItemElement, getSubmenuElement, }: UseDropdownMenuHoverIntentOptions): {
     clearPendingHover: () => void;
     resetHoverIntent: () => void;
-    trackSubmenuOpen: (path: ItemPath, point?: PointerPoint) => void;
+    trackSubmenuOpen: (path: ItemPath, point?: Point) => void;
     handleItemHover: (item: DropdownMenuItem, path: ItemPath, event: MouseEvent | undefined, commit: HoverCommit) => void;
     handleMenuMousemove: (event: MouseEvent, commit: HoverCommit) => void;
 };

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

@@ -0,0 +1,17 @@
+import { DropdownMenuCloseOptions } from './types.js';
+import { DropdownMenuInteractionRegistry } from './dropdownMenuInteractionRegistry.js';
+import { DropdownMenuInteractionDismissalRegistration, DropdownMenuInteractionHost } from './dropdownMenuInteractionTypes.js';
+type DropdownMenuDismissalRegistry = Pick<DropdownMenuInteractionRegistry, 'activeMenuId' | 'focusMenuElement'>;
+interface UseDropdownMenuInteractionDismissalOptions {
+    host: DropdownMenuInteractionHost;
+    registry: DropdownMenuDismissalRegistry;
+    closeRoot: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+}
+export declare function useDropdownMenuInteractionDismissal({ host, registry, closeRoot, }: UseDropdownMenuInteractionDismissalOptions): {
+    registerInside: (element: Element) => void;
+    unregisterInside: (element: Element) => void;
+    registerDismissal: (registration: DropdownMenuInteractionDismissalRegistration) => () => void;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuOpenOptions } from './types.js';
+import { DropdownMenuInteractionNavigation } from './dropdownMenuInteractionNavigation.js';
+import { DropdownMenuInteractionRegistry } from './dropdownMenuInteractionRegistry.js';
+import { DropdownMenuInteractionHost } from './dropdownMenuInteractionTypes.js';
+interface UseDropdownMenuInteractionKeyboardOptions {
+    host: DropdownMenuInteractionHost;
+    registry: DropdownMenuInteractionRegistry;
+    navigation: DropdownMenuInteractionNavigation;
+    openRoot: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    closeRoot: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+}
+export declare function useDropdownMenuInteractionKeyboard({ host, registry, navigation, openRoot, closeRoot, }: UseDropdownMenuInteractionKeyboardOptions): {
+    onMenuKeydown: (menuId: string, event: KeyboardEvent) => void;
+    onTriggerKeydown: (event: KeyboardEvent, beforeOpen?: () => void) => void;
+    resetTypeahead: () => void;
+};
+export {};

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

@@ -10,7 +10,6 @@ export declare function useDropdownMenuPortalPosition(options: {
     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>>;

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

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+interface UseDropdownMenuPresentationOptions {
+    props: Readonly<DropdownMenuProps>;
+    rootMenuId: string;
+    menuId: Readonly<Ref<string>>;
+    isDisabled: Readonly<Ref<boolean>>;
+    isVisible: Readonly<Ref<boolean>>;
+    isExplicitTarget: Readonly<Ref<boolean>>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
+    contentHasSubmenu: Readonly<Ref<boolean>>;
+    activeDescendantId: Readonly<Ref<string | undefined>>;
+    interaction: DropdownMenuInteractionRuntime;
+    resetHoverIntent: () => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+}
+export declare function useDropdownMenuPresentation({ props, rootMenuId, menuId, isDisabled, isVisible, isExplicitTarget, actualPlacement, contentHasSubmenu, activeDescendantId, interaction, resetHoverIntent, onMenuMousemove, open, close, toggle, }: UseDropdownMenuPresentationOptions): {
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentClass: import('vue').ComputedRef<string[]>;
+    triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
+    contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
+    slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { ComponentRefValue } from './dropdown-menu-primitive-core.js';
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
 import { DropdownMenuContentPrimitiveProps, DropdownMenuInteractOutsideEvent, DropdownMenuPlacement } from './types.js';
 type ContentProps = Readonly<DropdownMenuContentPrimitiveProps>;
 type ContentEvents = {
@@ -21,7 +21,7 @@ export declare function useDropdownMenuPrimitiveContent(props: ContentProps, att
         [x: string]: unknown;
     }>;
     floating: import('../floating/index.js').UseFloatingPositionReturn;
-    setElement: (value: ComponentRefValue) => void;
+    setElement: (value: ComponentElementRef) => void;
     close: () => void;
 };
 export {};

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

@@ -1,7 +1,7 @@
 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';
+import { ItemPath } from './dropdown-menu-model.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };

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

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { DropdownMenuInteractOutsideEvent, DropdownMenuInteractOutsideTarget } from './types.js';
+import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+interface UseDropdownMenuTargetBindingsOptions {
+    interaction: DropdownMenuInteractionRuntime;
+    rootRef: Readonly<Ref<HTMLElement | null>>;
+    menuRef: Readonly<Ref<HTMLElement | null>>;
+    targetElement: Readonly<Ref<Element | null>>;
+    isExplicitTarget: Readonly<Ref<boolean>>;
+    menuId: Readonly<Ref<string>>;
+    isVisible: Readonly<Ref<boolean>>;
+    isDisabled: Readonly<Ref<boolean>>;
+    ignoredTargets: () => readonly DropdownMenuInteractOutsideTarget[];
+    pointerDownOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    focusOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+    interactOutside?: (event: DropdownMenuInteractOutsideEvent) => void;
+}
+export declare function useDropdownMenuTargetBindings({ interaction, rootRef, menuRef, targetElement, isExplicitTarget, menuId, isVisible, isDisabled, ignoredTargets, pointerDownOutside, focusOutside, interactOutside, }: UseDropdownMenuTargetBindingsOptions): void;
+export {};

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

@@ -0,0 +1,42 @@
+export type HoverDisclosureInteractionPart = 'trigger' | 'content';
+export interface HoverDisclosureInteractionState {
+    contentFocused: boolean;
+    contentHovered: boolean;
+    touchClickPending: boolean;
+    touchPinned: boolean;
+    touchPointerActive: boolean;
+    triggerFocused: boolean;
+    triggerHovered: boolean;
+}
+export type HoverDisclosureInteractionAction = {
+    type: 'hover';
+    part: HoverDisclosureInteractionPart;
+    active: boolean;
+} | {
+    type: 'focus';
+    part: HoverDisclosureInteractionPart;
+    active: boolean;
+} | {
+    type: 'pointer-down';
+    touch: boolean;
+} | {
+    type: 'pointer-up';
+    touch: boolean;
+} | {
+    type: 'pointer-cancel';
+} | {
+    type: 'consume-touch-click';
+} | {
+    type: 'set-touch-pinned';
+    pinned: boolean;
+} | {
+    type: 'reset';
+    part: HoverDisclosureInteractionPart | 'all';
+};
+export interface HoverDisclosureInteractionModel {
+    read: () => Readonly<HoverDisclosureInteractionState>;
+    send: (action: HoverDisclosureInteractionAction) => Readonly<HoverDisclosureInteractionState>;
+}
+export declare function createHoverDisclosureInteractionModel(): HoverDisclosureInteractionModel;
+export declare function hasActiveHoverDisclosureInteraction(state: Readonly<HoverDisclosureInteractionState>): boolean;
+export declare function reduceHoverDisclosureInteraction(state: Readonly<HoverDisclosureInteractionState>, action: HoverDisclosureInteractionAction): HoverDisclosureInteractionState;

package/dist/components/floating/index.js

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

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

@@ -3,7 +3,6 @@ import { FloatingReference, FloatingTarget, UseFloatingPositionOptions, UseFloat
 type Source<T> = () => T;
 export declare function readFloatingTarget(target: FloatingTarget | null | undefined): string | FloatingReference | null | undefined;
 export declare function isVirtualReference(value: unknown): value is FloatingReference;
-export declare function isElementReference(value: unknown): value is Element;
 export declare function resolveFloatingTarget(target: string | FloatingReference | null | undefined): FloatingReference | null;
 export declare function useFloatingTarget(getTarget: Source<FloatingTarget | null | undefined>, fallback: Readonly<Ref<Element | null>>): {
     isExplicitTarget: import('vue').ComputedRef<boolean>;