ropav 0.1.6 → 0.1.8

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

@@ -0,0 +1,24 @@
+import { Ref } from 'vue';
+import { DropdownMenuDataIndex } from './dropdownMenuDataModel.js';
+import { DropdownMenuInteraction, DropdownMenuInteractionItem, DropdownMenuInteractionMenu } from './dropdownMenuInteraction.js';
+import { DropdownMenuItem, DropdownMenuProps, DropdownMenuSelectEvent } from './types.js';
+import { ItemPath } from './dropdown-menu-model.js';
+interface UseDropdownMenuDataRegistrationOptions {
+    props: Readonly<DropdownMenuProps>;
+    items: Readonly<Ref<DropdownMenuItem[]>>;
+    rootMenuId: string;
+    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, 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/useDropdownMenuHoverIntent.d.ts

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

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

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

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

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

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

@@ -10,7 +10,6 @@ export declare function useDropdownMenuPortalPosition(options: {
     arrowRef: Ref<HTMLElement | null>;
     isVisible: BooleanSource;
     placement: PlacementSource;
-    restartKey: () => unknown;
 }): {
     actualPlacement: Readonly<Ref<import('../floating/index.js').FloatingPlacement, import('../floating/index.js').FloatingPlacement>>;
     arrowStyle: Readonly<Ref<import('vue').CSSProperties | undefined, import('vue').CSSProperties | undefined>>;

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

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { DropdownMenuInteraction } from './dropdownMenuInteraction.js';
+import { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+interface UseDropdownMenuPresentationOptions {
+    props: Readonly<DropdownMenuProps>;
+    menuId: Readonly<Ref<string>>;
+    isDisabled: Readonly<Ref<boolean>>;
+    isVisible: Readonly<Ref<boolean>>;
+    isExplicitTarget: Readonly<Ref<boolean>>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
+    contentHasSubmenu: Readonly<Ref<boolean>>;
+    activeDescendantId: Readonly<Ref<string | undefined>>;
+    interaction: DropdownMenuInteraction;
+    resetHoverIntent: () => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+}
+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>;
+    contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
+    slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+};
+export {};

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

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

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

@@ -1,7 +1,7 @@
 import { Ref } from 'vue';
 import { StylesApiPartOptions } from '../../styles-api.js';
 import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuPlacement, DropdownMenuPart, DropdownMenuProps, DropdownMenuSubmenuProps } from './types.js';
-import { ItemPath } from './dropdown-menu-utils.js';
+import { ItemPath } from './dropdown-menu-model.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };

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

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

package/dist/components/dropzone/dropzone.d.ts

@@ -0,0 +1,31 @@
+import { DropzoneFileRejection, DropzoneProps, DropzoneSelection, DropzoneSlotProps } 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<DropzoneProps & {
+        "onUpdate:modelValue"?: ((files: File[]) => any) | undefined;
+        onDrop?: ((selection: DropzoneSelection) => any) | undefined;
+        onReject?: ((rejections: DropzoneFileRejection[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        rootElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        open: () => void;
+        clear: () => void;
+        focus: (options?: FocusOptions) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?(props: DropzoneSlotProps): unknown;
+    };
+    emit: ((evt: "update:modelValue", files: File[]) => void) & ((evt: "drop", selection: DropzoneSelection) => void) & ((evt: "reject", rejections: DropzoneFileRejection[]) => 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/dropzone/dropzoneModel.d.ts

@@ -0,0 +1,16 @@
+import { DropzoneSelection } from './types.js';
+interface DropzonePolicyOptions {
+    accept?: string;
+    multiple: boolean;
+    maxFiles?: number;
+    maxSize?: number;
+}
+interface DropzoneDragItem {
+    kind: string;
+    type: string;
+}
+export declare function createDropzonePolicy(options: Readonly<DropzonePolicyOptions>): {
+    preview(items: Iterable<DropzoneDragItem>): "accept" | "reject";
+    commit(files: Iterable<File>): DropzoneSelection;
+};
+export {};

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

@@ -0,0 +1,3 @@
+export { default as Dropzone } from './dropzone.js';
+export { dropzoneErrorCodes, dropzoneParts, dropzoneStatuses } from './types.js';
+export type { DropzoneErrorCode, DropzoneFileError, DropzoneFileRejection, DropzonePart, DropzoneProps, DropzoneRadius, DropzoneSelection, DropzoneSize, DropzoneSlotProps, DropzoneStatus, } from './types.js';

package/dist/components/dropzone/index.js

@@ -0,0 +1,2 @@
+import { i as dropzone_default, n as dropzoneParts, r as dropzoneStatuses, t as dropzoneErrorCodes } from "../../dropzone.js";
+export { dropzone_default as Dropzone, dropzoneErrorCodes, dropzoneParts, dropzoneStatuses };

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

@@ -0,0 +1,56 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const dropzoneParts: readonly ["root", "input", "content", "label", "description"];
+export declare const dropzoneStatuses: readonly ["idle", "accept", "reject"];
+export declare const dropzoneErrorCodes: readonly ["file-invalid-type", "file-too-large", "too-many-files"];
+export type DropzonePart = (typeof dropzoneParts)[number];
+export type DropzoneStatus = (typeof dropzoneStatuses)[number];
+export type DropzoneErrorCode = (typeof dropzoneErrorCodes)[number];
+export type DropzoneSize = 'sm' | 'md' | 'lg';
+export type DropzoneRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface DropzoneFileError {
+    code: DropzoneErrorCode;
+    message: string;
+}
+export interface DropzoneFileRejection {
+    file: File;
+    errors: DropzoneFileError[];
+}
+export interface DropzoneSelection {
+    acceptedFiles: File[];
+    rejections: DropzoneFileRejection[];
+}
+export interface DropzoneSlotProps {
+    files: File[];
+    rejections: DropzoneFileRejection[];
+    status: DropzoneStatus;
+    dragging: boolean;
+    open: () => void;
+    clear: () => void;
+}
+export interface DropzoneProps extends StylesApiProps<DropzonePart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: File[];
+    accept?: string;
+    capture?: boolean | 'user' | 'environment';
+    multiple?: boolean;
+    maxFiles?: number;
+    maxSize?: number;
+    size?: DropzoneSize;
+    radius?: DropzoneRadius;
+    label?: string;
+    description?: string;
+    activateOnClick?: boolean;
+    activateOnKeyboard?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}

package/dist/components/dropzone/useDropzone.d.ts

@@ -0,0 +1,25 @@
+import { DropzoneFileRejection, DropzoneProps, DropzoneSelection } from './types.js';
+interface DropzoneCallbacks {
+    onUpdate: (files: File[]) => void;
+    onDrop: (selection: DropzoneSelection) => void;
+    onReject: (rejections: DropzoneFileRejection[]) => void;
+}
+export declare function useDropzone(props: Readonly<DropzoneProps>, callbacks: DropzoneCallbacks): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    files: import('vue').ComputedRef<File[]>;
+    rejections: import('vue').ComputedRef<DropzoneFileRejection[]>;
+    status: import('vue').ComputedRef<"accept" | "idle" | "reject">;
+    rootClass: import('vue').ComputedRef<string[]>;
+    onDragenter: (event: DragEvent) => void;
+    onDragover: (event: DragEvent) => void;
+    onDragleave: () => void;
+    onDrop: (event: DragEvent) => void;
+    onChange: (event: Event) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+    open: () => void;
+    clear: () => void;
+    focus: (options?: FocusOptions) => void;
+};
+export {};

package/dist/components/file-input/file-input.d.ts

@@ -0,0 +1,29 @@
+import { FileInputProps, FileInputTriggerSlotProps, FileInputValueSlotProps } 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<FileInputProps & {
+        "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        clear: () => void;
+        focus: (options?: FocusOptions) => void;
+        open: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        trigger?(props: FileInputTriggerSlotProps): unknown;
+        value?(props: FileInputValueSlotProps): unknown;
+    };
+    emit: (evt: "update:modelValue", value: File[]) => 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/file-input/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FileInput } from './file-input.js';
+export { fileInputParts } from './types.js';
+export type { FileInputPart, FileInputProps, FileInputRadius, FileInputSize, FileInputTriggerSlotProps, FileInputValueSlotProps, } from './types.js';

package/dist/components/file-input/index.js

@@ -0,0 +1,2 @@
+import { n as file_input_default, t as fileInputParts } from "../../file-input.js";
+export { file_input_default as FileInput, fileInputParts };

package/dist/components/file-input/types.d.ts

@@ -0,0 +1,37 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const fileInputParts: readonly ["root", "input", "trigger", "value"];
+export type FileInputPart = (typeof fileInputParts)[number];
+export type FileInputRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type FileInputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface FileInputTriggerSlotProps {
+    files: File[];
+    multiple: boolean;
+}
+export interface FileInputValueSlotProps {
+    files: File[];
+    fileNames: string[];
+    hasFiles: boolean;
+}
+export interface FileInputProps extends StylesApiProps<FileInputPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: File[];
+    accept?: string;
+    capture?: boolean | 'user' | 'environment';
+    multiple?: boolean;
+    size?: FileInputSize;
+    radius?: FileInputRadius;
+    buttonLabel?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}

package/dist/components/file-input/useFileInput.d.ts

@@ -0,0 +1,15 @@
+import { FileInputProps } from './types.js';
+export declare function useFileInput(props: Readonly<FileInputProps>, emitUpdate: (value: File[]) => void): {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    files: import('vue').ComputedRef<File[]>;
+    fileNames: import('vue').ComputedRef<string[]>;
+    hasFiles: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    buttonText: import('vue').ComputedRef<string>;
+    displayValue: import('vue').ComputedRef<string>;
+    onChange: (event: Event) => void;
+    clear: () => void;
+    focus: (options?: FocusOptions) => void;
+    open: () => void;
+};

package/dist/components/floating/index.js

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

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

@@ -1,15 +1,2 @@
-import { Ref } from 'vue';
-import { FloatingReference, FloatingTarget, UseFloatingPositionOptions, UseFloatingPositionReturn } from './types.js';
-type Source<T> = () => T;
-export declare function readFloatingTarget(target: FloatingTarget | null | undefined): string | FloatingReference | null | undefined;
-export declare function isVirtualReference(value: unknown): value is FloatingReference;
-export declare function isElementReference(value: unknown): value is Element;
-export declare function resolveFloatingTarget(target: string | FloatingReference | null | undefined): FloatingReference | null;
-export declare function useFloatingTarget(getTarget: Source<FloatingTarget | null | undefined>, fallback: Readonly<Ref<Element | null>>): {
-    isExplicitTarget: import('vue').ComputedRef<boolean>;
-    reference: import('vue').ComputedRef<FloatingReference | null>;
-    resolvedTarget: import('vue').ShallowRef<FloatingReference | null, FloatingReference | null>;
-    syncTarget: () => void;
-};
+import { UseFloatingPositionOptions, UseFloatingPositionReturn } from './types.js';
 export declare function useFloatingPosition(options: UseFloatingPositionOptions): UseFloatingPositionReturn;
-export {};

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

@@ -0,0 +1,32 @@
+import { ComputedRef, Ref } from 'vue';
+import { AttributeSnapshot } from '../../utils/dom/attributes.js';
+import { FloatingReference, FloatingTarget } from './types.js';
+type Source<T> = () => T;
+export type FloatingTargetListener = readonly [
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+];
+export interface FloatingTargetAttributeAdapter<AttributeName extends string> {
+    names: readonly AttributeName[];
+    isActive?: Source<boolean>;
+    apply: (target: Element, snapshot: AttributeSnapshot<AttributeName>) => void;
+}
+export interface FloatingTargetBindingAdapter<AttributeName extends string = never> {
+    connect?: (target: Element) => void | (() => void);
+    listeners?: readonly FloatingTargetListener[];
+    attributes?: FloatingTargetAttributeAdapter<AttributeName>;
+}
+export interface FloatingTargetLifecycle {
+    bindTarget: <AttributeName extends string = never>(adapter: FloatingTargetBindingAdapter<AttributeName>) => void;
+    isExplicitTarget: ComputedRef<boolean>;
+    reference: ComputedRef<FloatingReference | null>;
+    targetElement: ComputedRef<Element | null>;
+}
+interface UseFloatingTargetLifecycleOptions {
+    target: Source<FloatingTarget | null | undefined>;
+    fallback: Readonly<Ref<Element | null>>;
+    getTargetElement?: (reference: FloatingReference) => Element | null;
+}
+export declare function useFloatingTargetLifecycle({ target, fallback, getTargetElement, }: UseFloatingTargetLifecycleOptions): FloatingTargetLifecycle;
+export {};

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

@@ -1,2 +1,12 @@
 import { UseHoverDisclosureOptions, UseHoverDisclosureReturn } from './types.js';
+interface HoverDisclosureDismissalHandlers {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: PointerEvent) => void;
+}
+interface HoverDisclosureWithExternalDismissal {
+    disclosure: UseHoverDisclosureReturn;
+    dismissalHandlers: HoverDisclosureDismissalHandlers;
+}
 export declare function useHoverDisclosure(options?: Readonly<UseHoverDisclosureOptions>): UseHoverDisclosureReturn;
+export declare function useHoverDisclosureWithExternalDismissal(options: Readonly<UseHoverDisclosureOptions>): HoverDisclosureWithExternalDismissal;
+export {};

package/dist/components/hover-card/hover-card.d.ts

@@ -0,0 +1,25 @@
+import { HoverCardContentSlotProps, HoverCardProps, HoverCardSlotProps } 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<HoverCardProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        onOpenChange?: ((value: boolean, details: import('../floating/index.js').HoverDisclosureOpenChangeDetails) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?(props: HoverCardSlotProps): unknown;
+        content?(props: HoverCardContentSlotProps): unknown;
+    };
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "openChange", value: boolean, details: import('../floating/index.js').HoverDisclosureOpenChangeDetails) => 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/hover-card/index.d.ts

@@ -0,0 +1,3 @@
+export { default as HoverCard } from './hover-card.js';
+export { hoverCardParts, hoverCardPlacements } from './types.js';
+export type { HoverCardContentSlotProps, HoverCardOffset, HoverCardOffsetOptions, HoverCardOpenChangeDetails, HoverCardOpenChangeReason, HoverCardPart, HoverCardPlacement, HoverCardProps, HoverCardSlotProps, HoverCardTarget, HoverCardTouchBehavior, HoverCardTriggerProps, } from './types.js';

package/dist/components/hover-card/index.js

@@ -0,0 +1,2 @@
+import { n as hoverCardPlacements, r as hover_card_default, t as hoverCardParts } from "../../hover-card.js";
+export { hover_card_default as HoverCard, hoverCardParts, hoverCardPlacements };

package/dist/components/hover-card/types.d.ts

@@ -0,0 +1,45 @@
+import { HTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+import { FloatingOffset, FloatingOffsetOptions, FloatingPositionProps, FloatingTarget, HoverDisclosureOpenChangeDetails, HoverDisclosureOpenChangeReason, HoverDisclosureState, HoverDisclosureTouchBehavior } from '../floating/types.js';
+export declare const hoverCardPlacements: readonly ["top-start", "top", "top-end", "right-start", "right", "right-end", "bottom-start", "bottom", "bottom-end", "left-start", "left", "left-end"];
+export declare const hoverCardParts: readonly ["root", "trigger", "content"];
+export type HoverCardPart = (typeof hoverCardParts)[number];
+export type HoverCardPlacement = (typeof hoverCardPlacements)[number];
+export type HoverCardTarget = FloatingTarget;
+export type HoverCardOffsetOptions = FloatingOffsetOptions;
+export type HoverCardOffset = FloatingOffset;
+export type HoverCardTouchBehavior = HoverDisclosureTouchBehavior;
+export type HoverCardOpenChangeReason = HoverDisclosureOpenChangeReason;
+export type HoverCardOpenChangeDetails = HoverDisclosureOpenChangeDetails;
+export interface HoverCardTriggerProps {
+    class?: HTMLAttributes['class'];
+    style?: HTMLAttributes['style'];
+    'data-state': HoverDisclosureState;
+    'data-disabled'?: '';
+}
+export interface HoverCardSlotProps {
+    triggerProps: HoverCardTriggerProps;
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface HoverCardContentSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface HoverCardProps extends FloatingPositionProps<HoverCardPlacement>, StylesApiProps<HoverCardPart> {
+    id?: string;
+    baseZIndex?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    openDelay?: number;
+    closeDelay?: number;
+    disabled?: boolean;
+    openOnFocus?: boolean;
+    closeOnEscape?: boolean;
+    touchBehavior?: HoverCardTouchBehavior;
+    keepMounted?: boolean;
+}

package/dist/components/hover-card/useHoverCard.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties } from 'vue';
+import { HoverCardContentSlotProps, HoverCardOpenChangeDetails, HoverCardProps } from './types.js';
+export declare function useHoverCard(props: Readonly<HoverCardProps>, onOpenChange?: (open: boolean, details: HoverCardOpenChangeDetails) => void): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    contentRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    arrowRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    hoverCardId: import('vue').ComputedRef<string>;
+    isDisabled: import('vue').ComputedRef<boolean>;
+    isVisible: import('vue').ComputedRef<boolean>;
+    isTargetMode: import('vue').ComputedRef<boolean>;
+    state: import('vue').ComputedRef<import('../floating/index.js').HoverDisclosureState>;
+    shouldRenderContent: import('vue').ComputedRef<boolean>;
+    shouldShowContent: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentStyle: import('vue').ComputedRef<CSSProperties>;
+    contentDirection: Readonly<import('vue').Ref<import('../../utils/dom/direction.js').ElementDirection, import('../../utils/dom/direction.js').ElementDirection>>;
+    contentSlotProps: import('vue').ComputedRef<HoverCardContentSlotProps>;
+    actualPlacement: Readonly<import('vue').Ref<import('../floating/index.js').FloatingPlacement, import('../floating/index.js').FloatingPlacement>>;
+    placementSide: import('vue').ComputedRef<string>;
+    arrowStyle: Readonly<import('vue').Ref<CSSProperties | undefined, CSSProperties | undefined>>;
+    teleportTo: import('vue').ComputedRef<import('../floating/index.js').TeleportTargetValue>;
+};

package/dist/components/hover-card/useHoverCardDisclosure.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+import { UseHoverDisclosureOptions } from '../floating/types.js';
+interface HoverCardDisclosureLayerOptions {
+    baseZIndex: MaybeRefOrGetter<number>;
+    element: Ref<HTMLElement | null>;
+    inside: MaybeRefOrGetter<readonly (Element | null | undefined)[]>;
+}
+export declare function useHoverCardDisclosure(options: Readonly<UseHoverDisclosureOptions>, layerOptions: HoverCardDisclosureLayerOptions): {
+    zIndex: Readonly<Ref<number, number>>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    isDisabled: import('vue').ComputedRef<boolean>;
+    state: import('vue').ComputedRef<import('../floating/index.js').HoverDisclosureState>;
+    triggerProps: import('vue').ComputedRef<import('../floating/index.js').HoverDisclosureTriggerProps>;
+    contentProps: import('vue').ComputedRef<import('../floating/index.js').HoverDisclosureContentProps>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+export {};

package/dist/components/multi-select/index.d.ts

@@ -0,0 +1,3 @@
+export { default as MultiSelect } from './multi-select.js';
+export { multiSelectParts } from './types.js';
+export type { MultiSelectEmptySlotProps, MultiSelectFilter, MultiSelectOption, MultiSelectOptionSlotProps, MultiSelectPart, MultiSelectPillSlotProps, MultiSelectProps, MultiSelectRadius, MultiSelectSize, MultiSelectValue, } from './types.js';

package/dist/components/multi-select/index.js

@@ -0,0 +1,2 @@
+import { n as multi_select_default, t as multiSelectParts } from "../../multi-select.js";
+export { multi_select_default as MultiSelect, multiSelectParts };