ropav 0.0.10 → 0.0.11

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

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

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

@@ -1,3 +1,55 @@
+import { DropdownMenuItem as DropdownMenuDataItem } from './types.js';
 export { default as DropdownMenu } from './dropdown-menu.js';
+export { dropdownMenuParts } from './types.js';
+export { DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContextTrigger, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from './dropdown-menu-primitives.js';
+export declare const DropdownMenuItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: StringConstructor;
+    as: {
+        type: import('vue').PropType<import('./types.js').DropdownMenuAs>;
+        default: string;
+    };
+    value: import('vue').PropType<import('./types.js').DropdownMenuItemValue>;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    destructive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "select"[], "select", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: StringConstructor;
+    as: {
+        type: import('vue').PropType<import('./types.js').DropdownMenuAs>;
+        default: string;
+    };
+    value: import('vue').PropType<import('./types.js').DropdownMenuItemValue>;
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    destructive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    as: import('./types.js').DropdownMenuAs;
+    closeOnSelect: boolean;
+    destructive: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export type DropdownMenuItem = DropdownMenuDataItem;
 export { useDropdownMenu } from './useDropdownMenu.js';
-export type { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuRenderedItem, DropdownMenuSlotProps, DropdownMenuSubmenuProps, DropdownMenuTriggerProps, } from './types.js';
+export type { DropdownMenuAs, DropdownMenuCheckedState, DropdownMenuCollisionPadding, DropdownMenuCheckboxItemPrimitiveProps, DropdownMenuCloseOptions, DropdownMenuContentPrimitiveProps, DropdownMenuContentProps, DropdownMenuContextTriggerPrimitiveProps, DropdownMenuFocusTarget, DropdownMenuInteractOutsideDetail, DropdownMenuInteractOutsideEvent, DropdownMenuItemIndicatorPrimitiveProps, DropdownMenuItemPath, DropdownMenuItemPrimitiveProps, DropdownMenuItemPrimitiveSlotProps, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuLabelPrimitiveProps, DropdownMenuOffset, DropdownMenuOffsetOptions, DropdownMenuOpenOptions, DropdownMenuPart, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuPortalPrimitiveProps, DropdownMenuProps, DropdownMenuRadioGroupPrimitiveProps, DropdownMenuRadioItemPrimitiveProps, DropdownMenuRenderedItem, DropdownMenuRootPrimitiveProps, DropdownMenuRootSlotProps, DropdownMenuSelectDetail, DropdownMenuSelectEvent, DropdownMenuSeparatorPrimitiveProps, DropdownMenuSlotProps, DropdownMenuSubContentPrimitiveProps, DropdownMenuSubPrimitiveProps, DropdownMenuSubmenuProps, DropdownMenuSubTriggerPrimitiveProps, DropdownMenuStrategy, DropdownMenuTarget, DropdownMenuTriggerPrimitiveProps, DropdownMenuTriggerProps, DropdownMenuVirtualAnchor, } from './types.js';

package/dist/components/dropdown-menu/index.js

@@ -1,2 +1,2 @@
-import { n as useDropdownMenu, t as dropdown_menu_default } from "../../dropdown-menu.js";
-export { dropdown_menu_default as DropdownMenu, useDropdownMenu };
+import { _ as DropdownMenuSubTrigger, a as DropdownMenuCheckboxItem, c as DropdownMenuItemIndicator, d as DropdownMenuRadioGroup, f as DropdownMenuRadioItem, g as DropdownMenuSubContent, h as DropdownMenuSub, i as useDropdownMenu, l as DropdownMenuLabel, m as DropdownMenuSeparator, n as dropdownMenuParts, o as DropdownMenuContent, p as DropdownMenuRoot, r as dropdown_menu_default, s as DropdownMenuContextTrigger, t as DropdownMenuItem, u as DropdownMenuPortal, v as DropdownMenuTrigger } from "../../dropdown-menu.js";
+export { dropdown_menu_default as DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuContextTrigger, DropdownMenuItem, DropdownMenuItemIndicator, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuRoot, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, dropdownMenuParts, useDropdownMenu };

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

@@ -1,4 +1,12 @@
-export type DropdownMenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+import { Component, HTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+import { FloatingCollisionPadding, FloatingOffset, FloatingOffsetOptions, FloatingPositionProps, FloatingStrategy, FloatingTarget, FloatingVirtualElement, TeleportProps } from '../floating/types.js';
+export declare const dropdownMenuParts: readonly ["root", "trigger", "content", "item", "label", "shortcut", "submenu", "submenuIndicator", "empty"];
+export type DropdownMenuPart = (typeof dropdownMenuParts)[number];
+export type DropdownMenuPlacement = 'top-start' | 'top' | 'top-end' | 'right-start' | 'right' | 'right-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end';
+export type DropdownMenuTarget = FloatingTarget;
+export type DropdownMenuStrategy = FloatingStrategy;
+export type DropdownMenuCollisionPadding = FloatingCollisionPadding;
 export type DropdownMenuItemValue = string | number;
 export type DropdownMenuFocusTarget = 'first' | 'last';
 export type DropdownMenuItemPath = number[];
@@ -21,6 +29,10 @@ export interface DropdownMenuTriggerProps {
     'aria-expanded'?: boolean;
     'aria-haspopup': 'menu';
     disabled?: boolean;
+    class?: HTMLAttributes['class'];
+    style?: HTMLAttributes['style'];
+    'data-state'?: 'open' | 'closed';
+    'data-disabled'?: '';
     onClick: (event: MouseEvent) => void;
     onKeydown: (event: KeyboardEvent) => void;
 }
@@ -65,9 +77,9 @@ export interface DropdownMenuItemProps {
     'aria-expanded'?: boolean;
     'aria-haspopup'?: 'menu';
     'aria-disabled'?: true;
-    'data-disabled'?: true;
-    'data-focused'?: true;
-    'data-submenu'?: true;
+    'data-disabled'?: '';
+    'data-highlighted'?: '';
+    'data-submenu'?: '';
     onClick: (event: MouseEvent) => void;
     onMouseenter: (event: MouseEvent) => void;
 }
@@ -93,12 +105,136 @@ export interface DropdownMenuRenderedItem {
     slotProps: DropdownMenuItemSlotProps;
     children: DropdownMenuRenderedItem[];
 }
-export interface DropdownMenuProps {
+export interface DropdownMenuProps extends FloatingPositionProps<DropdownMenuPlacement>, StylesApiProps<DropdownMenuPart> {
     id?: string;
     items?: DropdownMenuItem[];
-    placement?: DropdownMenuPlacement;
     open?: boolean;
     disabled?: boolean;
     closeOnSelect?: boolean;
     ariaLabel?: string;
+    modal?: boolean;
+    /** @deprecated Use `teleport` instead. */
+    portal?: boolean;
+    /** @deprecated Use `teleportTo` instead. */
+    portalTo?: string | HTMLElement;
+}
+export type DropdownMenuAs = string | Component;
+export type DropdownMenuCheckedState = boolean | 'indeterminate';
+export interface DropdownMenuPoint {
+    x: number;
+    y: number;
+}
+export type DropdownMenuVirtualAnchor = FloatingVirtualElement;
+export interface DropdownMenuSelectDetail {
+    originalEvent: Event;
+    value?: DropdownMenuItemValue;
+}
+export type DropdownMenuSelectEvent = CustomEvent<DropdownMenuSelectDetail>;
+export interface DropdownMenuInteractOutsideDetail {
+    originalEvent: Event;
+}
+export type DropdownMenuInteractOutsideEvent = CustomEvent<DropdownMenuInteractOutsideDetail>;
+export type DropdownMenuOffsetOptions = FloatingOffsetOptions;
+export type DropdownMenuOffset = FloatingOffset;
+export interface DropdownMenuRootPrimitiveProps {
+    id?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    modal?: boolean;
+    target?: FloatingTarget | null;
+    virtualAnchor?: DropdownMenuVirtualAnchor | null;
+}
+export interface DropdownMenuRootSlotProps {
+    isOpen: boolean;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+    openAt: (point: DropdownMenuPoint, options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+}
+export interface DropdownMenuTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+}
+export interface DropdownMenuContextTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+    longPressDelay?: number;
+    longPressTolerance?: number;
+}
+export interface DropdownMenuPortalPrimitiveProps extends TeleportProps {
+    to?: string | HTMLElement;
+    disabled?: boolean;
+}
+export interface DropdownMenuContentPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    placement?: DropdownMenuPlacement;
+    offset?: DropdownMenuOffset;
+    strategy?: FloatingStrategy;
+    flip?: boolean;
+    shift?: boolean;
+    collisionPadding?: FloatingCollisionPadding;
+    arrow?: boolean;
+    /** @deprecated Use `flip` and `shift` instead. */
+    avoidCollisions?: boolean;
+    forceMount?: boolean;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+}
+export interface DropdownMenuItemPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    value?: DropdownMenuItemValue;
+    disabled?: boolean;
+    destructive?: boolean;
+    closeOnSelect?: boolean;
+}
+export interface DropdownMenuItemPrimitiveSlotProps {
+    focused: boolean;
+    disabled: boolean;
+    select: () => void;
+}
+export interface DropdownMenuSeparatorPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    orientation?: 'horizontal' | 'vertical';
+}
+export interface DropdownMenuLabelPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+}
+export interface DropdownMenuCheckboxItemPrimitiveProps extends Omit<DropdownMenuItemPrimitiveProps, 'value'> {
+    modelValue?: DropdownMenuCheckedState;
+    defaultValue?: DropdownMenuCheckedState;
+}
+export interface DropdownMenuRadioGroupPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    modelValue?: DropdownMenuItemValue | null;
+    defaultValue?: DropdownMenuItemValue | null;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+}
+export interface DropdownMenuRadioItemPrimitiveProps extends Omit<DropdownMenuItemPrimitiveProps, 'value'> {
+    value: DropdownMenuItemValue;
+}
+export interface DropdownMenuItemIndicatorPrimitiveProps {
+    as?: DropdownMenuAs;
+    forceMount?: boolean;
+}
+export interface DropdownMenuSubPrimitiveProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+}
+export interface DropdownMenuSubTriggerPrimitiveProps {
+    id?: string;
+    as?: DropdownMenuAs;
+    disabled?: boolean;
+}
+export interface DropdownMenuSubContentPrimitiveProps extends Omit<DropdownMenuContentPrimitiveProps, 'arrow' | 'placement'> {
+    placement?: DropdownMenuPlacement;
 }

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

@@ -1,10 +1,11 @@
-import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
 export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit?: {
     openChange?: (open: boolean) => void;
-    select?: (item: DropdownMenuItem) => void;
+    select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
 }): {
     rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     menuRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    arrowRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     menuId: import('vue').ComputedRef<string>;
     isVisible: import('vue').ComputedRef<boolean>;
     isEmpty: import('vue').ComputedRef<boolean>;
@@ -16,13 +17,20 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentClass: import('vue').ComputedRef<string[]>;
+    contentStyle: import('vue').Ref<import('vue').CSSProperties, import('vue').CSSProperties>;
+    arrowStyle: import('vue').Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>;
+    actualPlacement: import('vue').Ref<import('./types.js').DropdownMenuPlacement, import('./types.js').DropdownMenuPlacement>;
+    placementSide: import('vue').ComputedRef<string>;
+    isTargetMode: import('vue').ComputedRef<boolean>;
+    teleportTo: import('vue').ComputedRef<import('../floating/index.js').TeleportTargetValue>;
+    shouldTeleport: import('vue').ComputedRef<boolean>;
     triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
     contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
     slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
     open: (options?: import('./types.js').DropdownMenuOpenOptions | import('./types.js').DropdownMenuFocusTarget) => void;
     close: (options?: import('./types.js').DropdownMenuCloseOptions) => void;
     toggle: () => void;
-    selectItem: (item: DropdownMenuItem) => 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;

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

@@ -1,14 +1,16 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 import { ItemPath } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type UseDropdownMenuDisclosureOptions = {
     props: Readonly<DropdownMenuProps>;
     emit: {
         openChange?: (open: boolean) => void;
-        select?: (item: DropdownMenuItem) => void;
+        select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
     };
     rootRef: Ref<HTMLElement | null>;
+    menuRef: Ref<HTMLElement | null>;
+    targetRef: Readonly<Ref<Element | null>>;
     uncontrolledOpen: Ref<boolean>;
     isDisabled: BooleanSource;
     isOpen: BooleanSource;
@@ -21,7 +23,7 @@ type UseDropdownMenuDisclosureOptions = {
     focusMenu: () => void;
     focusTrigger: () => void;
 };
-export declare function useDropdownMenuDisclosure({ props, emit, rootRef, uncontrolledOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, }: UseDropdownMenuDisclosureOptions): {
+export declare function useDropdownMenuDisclosure({ props, emit, rootRef, menuRef, targetRef, uncontrolledOpen, isDisabled, isOpen, isVisible, focusedPath, resetFocus, resetSubmenus, resetHoverIntent, focusItem, focusMenu, focusTrigger, }: UseDropdownMenuDisclosureOptions): {
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
     close: (options?: DropdownMenuCloseOptions) => void;
     toggle: () => void;

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

@@ -11,10 +11,11 @@ type UseDropdownMenuDomOptions = {
     menuId: StringSource;
     rootRef: Ref<HTMLElement | null>;
     menuRef: Ref<HTMLElement | null>;
+    targetRef: Readonly<Ref<Element | null>>;
     placement: PlacementSource;
     focusedPath: Ref<ItemPath>;
 };
-export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
+export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, targetRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     focusMenu: () => void;
     focusTrigger: () => void;

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

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
 import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type DisclosureControls = {
@@ -23,7 +23,7 @@ type HoverIntentControls = {
 type UseDropdownMenuInteractionsOptions = {
     props: Readonly<DropdownMenuProps>;
     emit: {
-        select?: (item: DropdownMenuItem) => void;
+        select?: (item: DropdownMenuItem, event: DropdownMenuSelectEvent) => void;
     };
     isDisabled: BooleanSource;
     focusedPath: Ref<ItemPath>;
@@ -37,8 +37,8 @@ type UseDropdownMenuInteractionsOptions = {
     isSubmenuOpeningLeft: (path: ItemPath) => boolean;
 };
 export declare function useDropdownMenuInteractions({ props, emit, isDisabled, focusedPath, openSubmenuPath, getItemAtPath, focusItem, moveFocus, submenus, hoverIntent, disclosure, isSubmenuOpeningLeft, }: UseDropdownMenuInteractionsOptions): {
-    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
-    selectItem: (item: DropdownMenuItem) => void;
+    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent | KeyboardEvent) => void;
+    selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
     openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;
     closeSubmenu: (path: ItemPath) => boolean;
     focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;

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

@@ -0,0 +1,19 @@
+import { Ref } from 'vue';
+import { FloatingReference } from '../floating/types.js';
+import { DropdownMenuPlacement, DropdownMenuProps } from './types.js';
+type BooleanSource = Readonly<Ref<boolean>>;
+type PlacementSource = Readonly<Ref<DropdownMenuPlacement>>;
+export declare function useDropdownMenuPortalPosition(options: {
+    props: Readonly<DropdownMenuProps>;
+    reference: Readonly<Ref<FloatingReference | null>>;
+    menuRef: Ref<HTMLElement | null>;
+    arrowRef: Ref<HTMLElement | null>;
+    isVisible: BooleanSource;
+    placement: PlacementSource;
+    restartKey: () => unknown;
+}): {
+    actualPlacement: Ref<DropdownMenuPlacement, DropdownMenuPlacement>;
+    arrowStyle: Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>;
+    contentStyle: Ref<import('vue').CSSProperties, import('vue').CSSProperties>;
+};
+export {};

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

@@ -1,13 +1,18 @@
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuSubmenuProps } from './types.js';
+import { Ref } from 'vue';
+import { StylesApiPartOptions } from '../../styles-api.js';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuPlacement, DropdownMenuPart, DropdownMenuProps, DropdownMenuSubmenuProps } from './types.js';
 import { ItemPath } from './dropdown-menu-utils.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };
 type UseDropdownMenuRenderItemsOptions = {
+    props: Readonly<DropdownMenuProps>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
     items: DropdownMenuItemsSource;
     getItemId: (path: ItemPath) => string;
     getSubmenuId: (path: ItemPath) => string;
     getMenuActiveDescendant: (path: ItemPath) => string | undefined;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
     isItemFocused: (indexOrPath: number | ItemPath) => boolean;
     isSubmenuOpen: (path: ItemPath) => boolean;
     activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
@@ -18,13 +23,20 @@ type UseDropdownMenuRenderItemsOptions = {
     close: (options?: DropdownMenuCloseOptions) => void;
 };
 export interface DropdownMenuRenderContext {
+    getPublicPartAttrs?: (part: DropdownMenuPart, options?: StylesApiPartOptions) => object;
     isItemFocused: (indexOrPath: number | ItemPath) => boolean;
     isSubmenuOpen: (path: ItemPath) => boolean;
     getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;
     getSubmenuProps: (item: DropdownMenuItem, path: ItemPath, submenuOpen?: boolean) => DropdownMenuSubmenuProps;
     getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemSlotProps;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getSubmenuPlacement: () => DropdownMenuPlacement;
+    getStrategy: () => NonNullable<DropdownMenuProps['strategy']>;
+    getFlip: () => boolean;
+    getShift: () => boolean;
+    getCollisionPadding: () => NonNullable<DropdownMenuProps['collisionPadding']>;
 }
-export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
+export declare function useDropdownMenuRenderItems({ props, actualPlacement, items, getItemId, getSubmenuId, getMenuActiveDescendant, getItemElement, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
     renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;
     renderContext: DropdownMenuRenderContext;
     getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;

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

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

package/dist/components/field/index.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { CSSProperties, Ref } from 'vue';
+import { FloatingCollisionPadding, FloatingOffset, FloatingPlacement, FloatingReference, FloatingStrategy, FloatingTarget } from './types.js';
+type Source<T> = () => T;
+export interface UseFloatingPositionOptions<TPlacement extends FloatingPlacement> {
+    reference: Readonly<Ref<FloatingReference | null>>;
+    floating: Ref<HTMLElement | null>;
+    arrow?: Ref<HTMLElement | null>;
+    open: Readonly<Ref<boolean>>;
+    placement: Source<TPlacement>;
+    strategy: Source<FloatingStrategy>;
+    offset: Source<FloatingOffset | undefined>;
+    flip: Source<boolean>;
+    shift: Source<boolean>;
+    collisionPadding: Source<FloatingCollisionPadding>;
+    arrowEnabled: Source<boolean>;
+    restartKey?: Source<unknown>;
+}
+export interface UseFloatingPositionReturn<TPlacement extends FloatingPlacement> {
+    actualPlacement: Ref<TPlacement>;
+    arrowStyle: Ref<CSSProperties | undefined>;
+    floatingStyle: Ref<CSSProperties>;
+    isPositioned: Ref<boolean>;
+    start: () => void;
+    stop: () => void;
+    update: () => Promise<void>;
+}
+export declare function readFloatingTarget(target: FloatingTarget | null | undefined): string | FloatingReference | null | undefined;
+export declare function isVirtualReference(value: unknown): value is FloatingReference;
+export declare function isElementReference(value: unknown): value is Element;
+export declare function resolveFloatingTarget(target: string | FloatingReference | null | undefined): FloatingReference | null;
+export declare function useFloatingTarget(getTarget: Source<FloatingTarget | null | undefined>, fallback: Readonly<Ref<Element | null>>): {
+    isExplicitTarget: import('vue').ComputedRef<boolean>;
+    reference: import('vue').ComputedRef<FloatingReference | null>;
+    resolvedTarget: import('vue').ShallowRef<FloatingReference | null, FloatingReference | null>;
+    syncTarget: () => void;
+};
+export declare function useFloatingPosition<TPlacement extends FloatingPlacement>(options: UseFloatingPositionOptions<TPlacement>): UseFloatingPositionReturn<TPlacement>;
+export {};

package/dist/components/focus-trap/focus-trap.d.ts

@@ -0,0 +1,31 @@
+import { FocusTrapPauseOptions, FocusTrapProps, FocusTrapUnpauseOptions } 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<FocusTrapProps & {
+        "onUpdate:active"?: ((value: boolean) => any) | undefined;
+        "onUpdate:paused"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            active: boolean;
+            paused: boolean;
+            activate: (options?: import('./types.js').FocusTrapActivateOptions) => void;
+            deactivate: (options?: import('./types.js').FocusTrapDeactivateOptions) => void;
+            pause: (options?: FocusTrapPauseOptions) => void;
+            unpause: (options?: FocusTrapUnpauseOptions) => void;
+        }) => any;
+    };
+    emit: ((evt: "update:active", value: boolean) => void) & ((evt: "update:paused", value: boolean) => 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/focus-trap/index.d.ts

@@ -0,0 +1,4 @@
+export { default as FocusTrap } from './focus-trap.js';
+export { focusTrapParts } from './types.js';
+export { useFocusTrap } from './useFocusTrap.js';
+export type { FocusTrapActivateOptions, FocusTrapContainer, FocusTrapContainers, FocusTrapDeactivateOptions, FocusTrapInitialFocus, FocusTrapOptions, FocusTrapPauseOptions, FocusTrapPart, FocusTrapProps, FocusTrapSlotProps, FocusTrapTarget, FocusTrapUnpauseOptions, UseFocusTrapOptions, UseFocusTrapReturn, } from './types.js';

package/dist/components/focus-trap/index.js

@@ -0,0 +1,3 @@
+import { t as useFocusTrap } from "../../useFocusTrap.js";
+import { n as focus_trap_default, t as focusTrapParts } from "../../focus-trap.js";
+export { focus_trap_default as FocusTrap, focusTrapParts, useFocusTrap };

package/dist/components/focus-trap/types.d.ts

@@ -0,0 +1,41 @@
+import { FocusTrap as FocusTrapInstance, FocusTargetValueOrFalse, Options as FocusTrapOptions } from 'focus-trap';
+import { MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const focusTrapParts: readonly ["root"];
+export type FocusTrapPart = (typeof focusTrapParts)[number];
+export type { FocusTrapOptions };
+export type FocusTrapContainer = HTMLElement | SVGElement | string;
+export type FocusTrapContainers = FocusTrapContainer | FocusTrapContainer[];
+export type FocusTrapTarget = MaybeRefOrGetter<FocusTrapContainers | null | undefined>;
+export type FocusTrapInitialFocus = NonNullable<FocusTrapOptions['initialFocus']> | Ref<FocusTargetValueOrFalse | null | undefined>;
+export type FocusTrapActivateOptions = Parameters<FocusTrapInstance['activate']>[0];
+export type FocusTrapDeactivateOptions = Parameters<FocusTrapInstance['deactivate']>[0];
+export type FocusTrapPauseOptions = Parameters<FocusTrapInstance['pause']>[0];
+export type FocusTrapUnpauseOptions = Parameters<FocusTrapInstance['unpause']>[0];
+export interface UseFocusTrapOptions extends FocusTrapOptions {
+    immediate?: boolean;
+}
+export interface FocusTrapProps extends StylesApiProps<FocusTrapPart> {
+    active?: boolean;
+    paused?: boolean;
+    as?: keyof HTMLElementTagNameMap;
+    options?: FocusTrapOptions;
+}
+export interface FocusTrapSlotProps {
+    active: boolean;
+    paused: boolean;
+    activate: (options?: FocusTrapActivateOptions) => void;
+    deactivate: (options?: FocusTrapDeactivateOptions) => void;
+    pause: (options?: FocusTrapPauseOptions) => void;
+    unpause: (options?: FocusTrapUnpauseOptions) => void;
+}
+export interface UseFocusTrapReturn {
+    focusTrap: ShallowRef<FocusTrapInstance | null>;
+    isActive: Readonly<Ref<boolean>>;
+    isPaused: Readonly<Ref<boolean>>;
+    activate: (options?: FocusTrapActivateOptions) => void;
+    deactivate: (options?: FocusTrapDeactivateOptions) => void;
+    pause: (options?: FocusTrapPauseOptions) => void;
+    unpause: (options?: FocusTrapUnpauseOptions) => void;
+    updateContainerElements: (containers: FocusTrapContainers) => void;
+}

package/dist/components/focus-trap/useFocusTrap.d.ts

@@ -0,0 +1,2 @@
+import { FocusTrapTarget, UseFocusTrapOptions, UseFocusTrapReturn } from './types.js';
+export declare function useFocusTrap(target: FocusTrapTarget, options?: Readonly<UseFocusTrapOptions>): UseFocusTrapReturn;

package/dist/components/icon-button/index.d.ts

@@ -1,2 +1,3 @@
 export { default as IconButton } from './icon-button.js';
-export type { IconButtonColor, IconButtonProps, IconButtonRadius, IconButtonSize, IconButtonVariant, } from './types.js';
+export { iconButtonParts } from './types.js';
+export type { IconButtonColor, IconButtonPart, IconButtonProps, IconButtonRadius, IconButtonSize, IconButtonVariant, } from './types.js';