ropav 0.1.6 → 0.1.8

package/dist/components/date-picker/useDatePickerValueState.d.ts

@@ -0,0 +1,21 @@
+import { DatePickerProps } from './types.js';
+export type DatePickerValueStateProps = Pick<DatePickerProps, 'id' | 'form' | 'modelValue' | 'defaultValue' | 'locale' | 'dateFormat' | 'formatDate' | 'parseDate' | 'min' | 'max' | 'disabledDates' | 'allowInput' | 'clearable' | 'disabled' | 'readonly' | 'required' | 'invalid' | 'valid' | 'describedby' | 'labelledby' | 'validationMessage' | 'invalidDateMessage'>;
+interface DatePickerValueStateOptions {
+    props: Readonly<DatePickerValueStateProps>;
+    getInput: () => HTMLInputElement | null;
+    onChange: (value: Date | null) => void;
+}
+export declare function useDatePickerValueState(options: Readonly<DatePickerValueStateOptions>): {
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    selectedDate: import('vue').ComputedRef<Date | null>;
+    inputValue: import('vue').ShallowRef<string, string>;
+    isInputEditable: import('vue').ComputedRef<boolean>;
+    isInvalid: import('vue').ComputedRef<boolean>;
+    validationMessage: import('vue').ComputedRef<string | undefined>;
+    canClear: import('vue').ComputedRef<boolean>;
+    updateInput: (value: string) => void;
+    blurInput: () => void;
+    selectDate: (value: Date) => boolean;
+    clear: () => boolean;
+};
+export {};

package/dist/components/dialog/{dialog-core.d.ts → dialogContext.d.ts}

@@ -1,4 +1,4 @@
-import { ComponentPublicInstance, ComputedRef, InjectionKey, Ref, VaporComponentInstance } from 'vue';
+import { ComputedRef, InjectionKey, Ref } from 'vue';
 import { OverlayLayerContext } from '../../internal/composables/useOverlayLayer.js';
 import { DialogCloseReason } from './types.js';
 export interface DialogRootContext {
@@ -22,8 +22,4 @@ export interface DialogRootContext {
     registerDescription: (id: string) => () => void;
 }
 export declare const dialogRootKey: InjectionKey<DialogRootContext>;
-export type DialogElementRefValue = Element | ComponentPublicInstance | VaporComponentInstance | null;
 export declare function resolveDialogCloseReason(reason: unknown): DialogCloseReason;
-export declare function toDialogHTMLElement(value: DialogElementRefValue): HTMLElement | null;
-export declare function resolveDialogHTMLElementRef(value: DialogElementRefValue, fallbackId: string, resolve: (element: HTMLElement | null) => void): void;
-export declare function createDialogEvent<T>(type: string, detail: T, originalEvent: Event): CustomEvent<T>;

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

@@ -0,0 +1,18 @@
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { DialogRootContext } from './dialogContext.js';
+import { DialogContentProps, DialogFocusTrapOptions, DialogInteractOutsideEvent } from './types.js';
+type DialogContentInteractionProps = Readonly<DialogContentProps & {
+    focusTrapOptions: DialogFocusTrapOptions;
+}>;
+interface DialogContentInteractionEvents {
+    escapeKeyDown: (event: CustomEvent<{
+        originalEvent: KeyboardEvent;
+    }>) => void;
+    pointerDownOutside: (event: DialogInteractOutsideEvent) => void;
+    interactOutside: (event: DialogInteractOutsideEvent) => void;
+}
+export declare function useDialogContentInteractions(root: DialogRootContext, props: DialogContentInteractionProps, events: Readonly<DialogContentInteractionEvents>): {
+    id: import('vue').ComputedRef<string>;
+    setElement: (value: ComponentElementRef) => void;
+};
+export {};

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;
-        onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onInteractOutside?: ((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: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/components/dropdown-menu/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;
-        onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onInteractOutside?: ((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: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/components/dropdown-menu/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

@@ -4,8 +4,8 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
         onSelect?: ((item: DropdownMenuItem, event: DropdownMenuSelectEvent) => any) | undefined;
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
         onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
-        onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onInteractOutside?: ((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: "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);
+    emit: ((evt: "select", item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -1,42 +1,37 @@
-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 { DropdownMenuInteraction, DropdownMenuInteractionFocusTarget, DropdownMenuInteractionItem, DropdownMenuInteractionMenu, DropdownMenuInteractionSubmenu } 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>;
     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;
-    onKeydown: (event: KeyboardEvent) => void;
+    interaction: DropdownMenuInteractionMenu;
+    connectItem: (item: MenuItemRegistration) => DropdownMenuInteractionItem;
 }
 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;
+    interaction: DropdownMenuInteractionSubmenu;
     open: (focus?: OpenFocusTarget) => void;
     close: (focusParent?: boolean) => void;
 }
@@ -49,8 +44,9 @@ export interface DropdownMenuRootContext {
     triggerId: Ref<string | undefined>;
     contentId: Ref<string | undefined>;
     reference: ComputedRef<ElementReference | null>;
-    pendingFocus: Ref<OpenFocusTarget>;
+    interactionRootMenuId: string;
     layer: OverlayLayerContext;
+    interaction: DropdownMenuInteraction;
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions & {
         returnFocus?: boolean;
@@ -60,9 +56,7 @@ export interface DropdownMenuRootContext {
     setTrigger: (element: HTMLElement | null, id?: string) => void;
     setReference: (reference: ElementReference | null) => void;
     setReturnFocus: (element: HTMLElement | null) => void;
-    registerInside: (element: HTMLElement) => void;
-    unregisterInside: (element: HTMLElement) => void;
-    isInside: (event: Event) => boolean;
+    connectInside: (element: HTMLElement) => () => void;
 }
 export interface DropdownMenuRadioGroupContext {
     value: ComputedRef<DropdownMenuItemValue | null>;
@@ -77,21 +71,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 +93,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 { DropdownMenuInteraction, DropdownMenuInteractionHost } from './dropdownMenuInteractionTypes.js';
+export type { DropdownMenuInteractionDismissalRegistration, DropdownMenuInteraction, DropdownMenuInteractionFocusTarget, DropdownMenuInteractionHost, DropdownMenuInteractionItem, DropdownMenuInteractionItemOptions, DropdownMenuInteractionMenu, DropdownMenuInteractionMenuOptions, DropdownMenuInteractionSubmenu, DropdownMenuInteractionSubmenuOptions, } from './dropdownMenuInteractionTypes.js';
+export declare function useDropdownMenuInteraction(host: DropdownMenuInteractionHost): DropdownMenuInteraction;

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,114 @@
+import { ComputedRef, Ref } from 'vue';
+import { OverlayLayerInteraction, OverlayLayerInteractionConnection } from '../../internal/composables/useOverlayLayer.js';
+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;
+    connectLayerInteraction: (interaction: OverlayLayerInteraction) => OverlayLayerInteractionConnection;
+    focusTrigger: () => void;
+    beforeOpen?: () => void;
+    beforeClose?: () => void;
+}
+export interface DropdownMenuInteractionMenuOptions {
+    element: () => HTMLElement | null;
+    focusTarget?: () => HTMLElement | null;
+    placement: () => DropdownMenuPlacement;
+    stopKeyPropagation?: boolean;
+    onEscape?: (event: KeyboardEvent) => boolean;
+}
+export interface DropdownMenuInteractionItemOptions {
+    id: string;
+    element: () => HTMLElement | null;
+    textValue: () => string;
+    disabled: () => boolean;
+    order?: () => number;
+    submenu?: DropdownMenuInteractionSubmenu;
+    submenuDirection?: () => 'left' | 'right';
+    select?: (originalEvent: Event) => DropdownMenuSelectEvent | undefined;
+    closeOnSelect?: () => boolean;
+}
+export interface DropdownMenuInteractionItem {
+    active: ComputedRef<boolean>;
+    submenuOpen: ComputedRef<boolean>;
+    setActive: (focusElement?: boolean) => boolean;
+    openSubmenu: (focus?: DropdownMenuInteractionFocusTarget) => boolean;
+    closeSubmenu: (focusParent?: boolean) => boolean;
+    select: (originalEvent?: Event) => void;
+    activate: (originalEvent?: Event) => void;
+    hover: (openSubmenu?: boolean) => boolean;
+    dispose: () => void;
+}
+export interface DropdownMenuInteractionMenu {
+    activeId: ComputedRef<string | null>;
+    connectItem: (registration: DropdownMenuInteractionItemOptions) => DropdownMenuInteractionItem;
+    clearActive: () => void;
+    focusPending: () => boolean;
+    onKeydown: (event: KeyboardEvent) => void;
+    dispose: () => void;
+}
+export interface DropdownMenuInteractionSubmenu {
+    id: string;
+    open: (focus?: DropdownMenuInteractionFocusTarget) => boolean;
+    close: (focusParent?: boolean) => boolean;
+    connectContent: (options: DropdownMenuInteractionMenuOptions) => DropdownMenuInteractionMenu;
+    dispose: () => void;
+}
+export interface DropdownMenuInteractionSubmenuOptions {
+    id: string;
+    parentItemId: () => string | undefined;
+    isOpen: () => boolean;
+    setOpen: (open: boolean) => void;
+}
+export interface DropdownMenuInteraction {
+    activeItemId: Readonly<Ref<string | null>>;
+    connectRootMenu: (options: DropdownMenuInteractionMenuOptions) => DropdownMenuInteractionMenu;
+    connectSubmenu: (options: DropdownMenuInteractionSubmenuOptions) => DropdownMenuInteractionSubmenu;
+    connectInside: (element: Element) => () => void;
+    connectDismissal: (registration: DropdownMenuInteractionDismissalRegistration) => () => void;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions & {
+        returnFocus?: boolean;
+    }) => void;
+    toggle: () => void;
+    onTriggerClick: (beforeToggle?: () => void) => void;
+    onTriggerKeydown: (event: KeyboardEvent, beforeOpen?: () => void) => void;
+    onMenuKeydown: (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,35 @@
+import { Ref } from 'vue';
+import { Point } from '../../utils/geometry.js';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-model.js';
+import { DropdownMenuInteraction, DropdownMenuInteractionMenu } 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: DropdownMenuInteraction;
+    rootMenu: DropdownMenuInteractionMenu;
+    onSelect?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
+}
+export declare function useDropdownMenuDataController({ props, items, rootMenuId, menuId, menuRef, actualPlacement, interaction, rootMenu, 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 {};