ropav 0.1.5 → 0.1.7

package/dist/components/dialog/useDialogRootState.d.ts

@@ -0,0 +1,19 @@
+import { DialogRootContext } from './dialogContext.js';
+import { DialogCloseReason, DialogRootProps, DialogRootSlotProps } from './types.js';
+type DialogRootStateProps = Readonly<DialogRootProps & {
+    defaultOpen: boolean;
+    modal: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsideClick: boolean;
+    preventScroll: boolean;
+    returnFocus: boolean;
+}>;
+interface DialogRootStateEvents {
+    openChange: (open: boolean) => void;
+    close: (reason: DialogCloseReason) => void;
+}
+export declare function useDialogRootState(props: DialogRootStateProps, events: Readonly<DialogRootStateEvents>): {
+    context: DialogRootContext;
+    slotProps: import('vue').ComputedRef<DialogRootSlotProps>;
+};
+export {};

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

@@ -5,8 +5,8 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             originalEvent: KeyboardEvent;
         }>) => any) | undefined;
         onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
-        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -21,7 +21,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     };
     emit: ((evt: "escapeKeyDown", event: CustomEvent<{
         originalEvent: KeyboardEvent;
-    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -1,4 +1,4 @@
-import { ItemPath } from './dropdown-menu-utils.js';
+import { ItemPath } from './dropdown-menu-model.js';
 import { DropdownMenuItem, DropdownMenuItemSlotProps } from './types.js';
 import { DropdownMenuRenderContext } from './useDropdownMenuRenderItems.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<{

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

@@ -1,4 +1,4 @@
-import { ItemPath } from './dropdown-menu-utils.js';
+import { ItemPath } from './dropdown-menu-model.js';
 import { DropdownMenuItem, DropdownMenuItemSlotProps } from './types.js';
 import { DropdownMenuRenderContext } from './useDropdownMenuRenderItems.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<{

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

@@ -0,0 +1,8 @@
+import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuPlacement } from './types.js';
+export declare const DEFAULT_PLACEMENT: DropdownMenuPlacement;
+export declare const DEFAULT_FOCUS_TARGET: DropdownMenuFocusTarget;
+export type ItemPath = DropdownMenuItemPath;
+export type SubmenuFocusTarget = DropdownMenuFocusTarget | false;
+export declare function getItemClass(item: DropdownMenuItem, focused: boolean, disabled: boolean, hasSubmenu: boolean, submenuOpen: boolean): string[];
+export declare function hasItemSubmenu(item: DropdownMenuItem): boolean;
+export declare function hasNestedItems(items: DropdownMenuItem[]): boolean;

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

@@ -1,4 +1,4 @@
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuOpenOptions, DropdownMenuPoint, DropdownMenuRootPrimitiveProps, DropdownMenuRootSlotProps } from './types.js';
+import { 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;
@@ -7,7 +7,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     } ? P : {});
     expose: (exposed: import('vue').ShallowUnwrapRef<{
         open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
-        close: (options?: DropdownMenuCloseOptions & {
+        close: (options?: import('./types.js').DropdownMenuCloseOptions & {
             returnFocus?: boolean;
         }) => void;
         toggle: () => void;

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

@@ -5,8 +5,8 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             originalEvent: KeyboardEvent;
         }>) => any) | undefined;
         onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
-        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -21,7 +21,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     };
     emit: ((evt: "escapeKeyDown", event: CustomEvent<{
         originalEvent: KeyboardEvent;
-    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

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

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.d.ts

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

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 { OverlayLayerContext } from '../../composables/useOverlayLayer.js';
+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>>;