ropav 0.1.7 → 0.1.8

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

@@ -0,0 +1,43 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export interface ComboboxOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export type ComboboxFilter = (option: ComboboxOption, searchValue: string) => boolean;
+export type ComboboxRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type ComboboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface ComboboxOptionSlotProps {
+    option: ComboboxOption;
+    selected: boolean;
+    highlighted: boolean;
+}
+export interface ComboboxEmptySlotProps {
+    searchValue: string;
+}
+export interface ComboboxProps extends StylesApiProps<ComboboxPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: string | number | null;
+    defaultValue?: string | number | null;
+    options?: ComboboxOption[];
+    filter?: ComboboxFilter | false;
+    size?: ComboboxSize;
+    radius?: ComboboxRadius;
+    placeholder?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    toggleLabel?: string;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}
+export declare const comboboxParts: readonly ["root", "input", "indicator", "clear", "toggle", "content", "option", "empty"];
+export type ComboboxPart = (typeof comboboxParts)[number];

package/dist/components/combobox/useCombobox.d.ts

@@ -0,0 +1,45 @@
+import { CSSProperties, ComputedRef, Ref, SelectHTMLAttributes } from 'vue';
+import { ControlState } from '../../internal/composables/useControlState.js';
+import { FlatOptionState } from '../../internal/composables/useFlatOptionCollection.js';
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { FloatingPlacement, FloatingSide } from '../floating/types.js';
+import { ComboboxValue } from './comboboxModel.js';
+import { ComboboxOption, ComboboxProps } from './types.js';
+export interface ComboboxControl {
+    templateRefs: {
+        root: Ref<HTMLElement | null>;
+        input: Ref<HTMLInputElement | null>;
+        native: Ref<HTMLSelectElement | null>;
+    };
+    nativeSelectAttrs: ComputedRef<SelectHTMLAttributes>;
+    isOpen: Ref<boolean>;
+    popupId: string;
+    listboxId: string;
+    control: ControlState;
+    visibleOptions: ComputedRef<ComboboxOption[]>;
+    renderedOptions: ComputedRef<readonly FlatOptionState<ComboboxOption>[]>;
+    activeDescendantId: ComputedRef<string | undefined>;
+    rootClass: ComputedRef<string[]>;
+    floatingStyle: Readonly<Ref<CSSProperties>>;
+    actualPlacement: Readonly<Ref<FloatingPlacement>>;
+    placementSide: ComputedRef<FloatingSide>;
+    searchValue: Ref<string>;
+    displayLabel: ComputedRef<string>;
+    canClear: ComputedRef<boolean>;
+    setDropdownElement: (elementRef: ComponentElementRef) => void;
+    toggle: () => void;
+    selectOption: (option: ComboboxOption) => void;
+    clearSelection: () => void;
+    onOptionMouseenter: (option: ComboboxOption) => void;
+    onFocusout: (event: FocusEvent) => void;
+    onInput: (event: Event) => void;
+    onInputFocus: () => void;
+    onInputClick: () => void;
+    onInputKeydown: (event: KeyboardEvent) => void;
+}
+interface ComboboxCallbacks {
+    valueChange: (value: ComboboxValue) => void;
+    search: (searchValue: string) => void;
+}
+export declare function useCombobox(props: Readonly<ComboboxProps>, callbacks: ComboboxCallbacks): ComboboxControl;
+export {};

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

@@ -0,0 +1,33 @@
+import { DatePickerDaySlotProps, DatePickerProps } 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<DatePickerProps & {
+        "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onChange?: ((value: Date | null) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').ComputedRef<HTMLInputElement | null>;
+        focus: () => void | undefined;
+        open: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        day?(props: DatePickerDaySlotProps): unknown;
+        'clear-icon'?(): unknown;
+        'calendar-icon'?(): unknown;
+        'previous-icon'?(): unknown;
+        'next-icon'?(): unknown;
+    };
+    emit: ((evt: "update:modelValue", value: Date | null) => void) & ((evt: "update:open", open: boolean) => void) & ((evt: "change", value: Date | null) => void);
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,10 @@
+export declare const defaultDatePickerFormat: Intl.DateTimeFormatOptions;
+export declare function formatDatePickerValue(value: Date | null, locale?: string, format?: Intl.DateTimeFormatOptions): string;
+/**
+ * Parses ISO date keys or supported locale values produced by `formatDatePickerValue`.
+ *
+ * Locale parsing supports Gregorian, ISO 8601, and Buddhist date-only formats.
+ * Two-digit years resolve to the corresponding Gregorian year from 2000 through 2099.
+ */
+export declare function parseDatePickerValue(value: string, locale?: string, format?: Intl.DateTimeFormatOptions): Date | null;
+export declare function normalizeDatePickerValue(value: Date | null | undefined): Date | null;

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

@@ -0,0 +1,4 @@
+export { default as DatePicker } from './date-picker.js';
+export { datePickerParts } from './types.js';
+export type { DatePickerDaySlotProps, DatePickerFormat, DatePickerParse, DatePickerPart, DatePickerProps, } from './types.js';
+export { defaultDatePickerFormat, formatDatePickerValue, normalizeDatePickerValue, parseDatePickerValue, } from './datePickerModel.js';

package/dist/components/date-picker/index.js

@@ -0,0 +1,2 @@
+import { a as normalizeDatePickerValue, i as formatDatePickerValue, n as date_picker_default, o as parseDatePickerValue, r as defaultDatePickerFormat, t as datePickerParts } from "../../date-picker.js";
+export { date_picker_default as DatePicker, datePickerParts, defaultDatePickerFormat, formatDatePickerValue, normalizeDatePickerValue, parseDatePickerValue };

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

@@ -0,0 +1,57 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+import { CalendarDaySlotProps, CalendarDisabledDates, CalendarRadius, CalendarSize, CalendarWeekdayFormat } from '../calendar/types.js';
+import { InputRadius, InputSize } from '../input/types.js';
+import { PopoverPlacement } from '../popover/types.js';
+export declare const datePickerParts: readonly ["root", "control", "input", "clear", "indicator", "content", "calendar", "calendarHeader", "calendarControl", "calendarMonthLabel", "calendarWeekdays", "calendarWeekday", "calendarGrid", "calendarWeek", "calendarDayCell", "calendarDay"];
+export type DatePickerPart = (typeof datePickerParts)[number];
+export type DatePickerFormat = (date: Date) => string;
+export type DatePickerParse = (value: string) => Date | null;
+export type DatePickerDaySlotProps = CalendarDaySlotProps;
+export interface DatePickerProps extends StylesApiProps<DatePickerPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: Date | null;
+    defaultValue?: Date | null;
+    defaultMonth?: Date;
+    open?: boolean;
+    locale?: string;
+    dateFormat?: Intl.DateTimeFormatOptions;
+    formatDate?: DatePickerFormat;
+    parseDate?: DatePickerParse;
+    firstDayOfWeek?: number;
+    weekdayFormat?: CalendarWeekdayFormat;
+    min?: Date;
+    max?: Date;
+    disabledDates?: CalendarDisabledDates;
+    fixedWeeks?: boolean;
+    hideOutsideDates?: boolean;
+    allowInput?: boolean;
+    clearable?: boolean;
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    size?: InputSize;
+    radius?: InputRadius;
+    calendarSize?: CalendarSize;
+    calendarRadius?: CalendarRadius;
+    placeholder?: string;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+    invalidDateMessage?: string;
+    clearLabel?: string;
+    toggleLabel?: string;
+    calendarAriaLabel?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+    placement?: PopoverPlacement;
+    keepMounted?: boolean;
+    popoverId?: string;
+}

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

@@ -0,0 +1,29 @@
+import { InputHTMLAttributes } from 'vue';
+import { DatePickerProps } from './types.js';
+interface DatePickerEmitters {
+    value: (value: Date | null) => void;
+    change: (value: Date | null) => void;
+    open: (open: boolean) => void;
+}
+interface DatePickerElements {
+    getInput: () => HTMLInputElement | null;
+    focusCalendar: () => void;
+}
+export declare function useDatePicker(props: Readonly<DatePickerProps>, emit: DatePickerEmitters, elements: DatePickerElements): {
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    selectedDate: import('vue').ComputedRef<Date | null>;
+    inputValue: import('vue').ShallowRef<string, string>;
+    isInvalid: import('vue').ComputedRef<boolean>;
+    effectiveValidationMessage: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    canClear: import('vue').ComputedRef<boolean>;
+    getInputTriggerAttrs: (slotProps: unknown) => InputHTMLAttributes;
+    onInputUpdate: (value: string) => void;
+    onCalendarKeydown: (event: KeyboardEvent) => void;
+    onFocusOut: (event: FocusEvent) => void;
+    clearFromControl: (event: MouseEvent) => void;
+    selectCalendarDate: (value: Date) => void;
+    openDatePicker: () => void;
+    onOpenUpdate: (open: boolean) => void;
+};
+export {};

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

@@ -2,7 +2,7 @@ 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 { DropdownMenuInteractionFocusTarget, DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.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 = DropdownMenuInteractionFocusTarget;
@@ -19,19 +19,10 @@ export interface DropdownMenuContext {
     root: DropdownMenuRootContext;
     id: string;
     element: Ref<HTMLElement | null>;
-    activeId: ComputedRef<string | null>;
     actualPlacement: Ref<DropdownMenuPlacement>;
     parentSub?: DropdownMenuSubContext;
-    registerItem: (item: MenuItemRegistration) => void;
-    unregisterItem: (id: string) => 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;
+    interaction: DropdownMenuInteractionMenu;
+    connectItem: (item: MenuItemRegistration) => DropdownMenuInteractionItem;
 }
 export interface DropdownMenuSubContext {
     menuId: string;
@@ -39,9 +30,8 @@ export interface DropdownMenuSubContext {
     trigger: Ref<HTMLElement | null>;
     contentId: Ref<string | undefined>;
     actualPlacement: Ref<DropdownMenuPlacement>;
-    pendingFocus: Ref<OpenFocusTarget>;
     menu: DropdownMenuContext | null;
-    setOpen: (open: boolean) => void;
+    interaction: DropdownMenuInteractionSubmenu;
     open: (focus?: OpenFocusTarget) => void;
     close: (focusParent?: boolean) => void;
 }
@@ -54,9 +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: DropdownMenuInteractionRuntime;
+    interaction: DropdownMenuInteraction;
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions & {
         returnFocus?: boolean;
@@ -66,8 +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;
+    connectInside: (element: HTMLElement) => () => void;
 }
 export interface DropdownMenuRadioGroupContext {
     value: ComputedRef<DropdownMenuItemValue | null>;

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

@@ -1,3 +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;
+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/dropdownMenuInteractionTypes.d.ts

@@ -1,4 +1,5 @@
 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 {
@@ -41,45 +42,73 @@ export interface DropdownMenuInteractionHost {
     disabled: Readonly<Ref<boolean>>;
     modal: Readonly<Ref<boolean>>;
     setOpen: (open: boolean) => void;
-    isTopLayer: () => boolean;
+    connectLayerInteraction: (interaction: OverlayLayerInteraction) => OverlayLayerInteractionConnection;
     focusTrigger: () => void;
     beforeOpen?: () => void;
     beforeClose?: () => void;
 }
-export interface DropdownMenuInteractionRuntime {
-    rootMenuId: string;
+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>>;
-    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;
+    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;
-    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;
+    onMenuKeydown: (event: KeyboardEvent) => void;
 }

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

@@ -1,7 +1,7 @@
 import { Ref } from 'vue';
 import { Point } from '../../utils/geometry.js';
 import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-model.js';
-import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuInteraction, DropdownMenuInteractionMenu } from './dropdownMenuInteraction.js';
 import { DropdownMenuItem, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 interface UseDropdownMenuDataControllerOptions {
     props: Readonly<DropdownMenuProps>;
@@ -10,10 +10,11 @@ interface UseDropdownMenuDataControllerOptions {
     menuId: Readonly<Ref<string>>;
     menuRef: Readonly<Ref<HTMLElement | null>>;
     actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
-    interaction: DropdownMenuInteractionRuntime;
+    interaction: DropdownMenuInteraction;
+    rootMenu: DropdownMenuInteractionMenu;
     onSelect?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
 }
-export declare function useDropdownMenuDataController({ props, items, rootMenuId, menuId, menuRef, actualPlacement, interaction, onSelect, }: UseDropdownMenuDataControllerOptions): {
+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>;

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

@@ -1,22 +1,24 @@
 import { Ref } from 'vue';
 import { DropdownMenuDataIndex } from './dropdownMenuDataModel.js';
-import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuInteraction, DropdownMenuInteractionItem, DropdownMenuInteractionMenu } 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;
+    interaction: DropdownMenuInteraction;
+    rootMenu: DropdownMenuInteractionMenu;
     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): {
+export declare function useDropdownMenuDataRegistration({ props, items, rootMenuId, interaction, rootMenu, 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>;
+    getItemInteraction: (id: string) => DropdownMenuInteractionItem | undefined;
+    getMenuInteraction: (id: string) => DropdownMenuInteractionMenu | undefined;
 };
 export {};

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

@@ -1,9 +1,8 @@
 import { Ref } from 'vue';
-import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuInteraction } 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>>;
@@ -11,14 +10,14 @@ interface UseDropdownMenuPresentationOptions {
     actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
     contentHasSubmenu: Readonly<Ref<boolean>>;
     activeDescendantId: Readonly<Ref<string | undefined>>;
-    interaction: DropdownMenuInteractionRuntime;
+    interaction: DropdownMenuInteraction;
     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): {
+export declare function useDropdownMenuPresentation({ props, 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>;

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

@@ -1,12 +1,12 @@
 import { Ref } from 'vue';
+import { FloatingTargetLifecycle } from '../floating/useFloatingTargetLifecycle.js';
 import { DropdownMenuInteractOutsideEvent, DropdownMenuInteractOutsideTarget } from './types.js';
-import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuInteraction } from './dropdownMenuInteraction.js';
 interface UseDropdownMenuTargetBindingsOptions {
-    interaction: DropdownMenuInteractionRuntime;
+    interaction: DropdownMenuInteraction;
     rootRef: Readonly<Ref<HTMLElement | null>>;
     menuRef: Readonly<Ref<HTMLElement | null>>;
-    targetElement: Readonly<Ref<Element | null>>;
-    isExplicitTarget: Readonly<Ref<boolean>>;
+    targetLifecycle: FloatingTargetLifecycle;
     menuId: Readonly<Ref<string>>;
     isVisible: Readonly<Ref<boolean>>;
     isDisabled: Readonly<Ref<boolean>>;
@@ -15,5 +15,5 @@ interface UseDropdownMenuTargetBindingsOptions {
     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 declare function useDropdownMenuTargetBindings({ interaction, rootRef, menuRef, targetLifecycle, menuId, isVisible, isDisabled, ignoredTargets, pointerDownOutside, focusOutside, interactOutside, }: UseDropdownMenuTargetBindingsOptions): void;
 export {};