ropav 0.1.7 → 0.1.8

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 { t as useFloatingPosition } from "../../useFloatingPosition.js";
-import { t as useHoverDisclosure } from "../../floating.js";
+import { t as useHoverDisclosure } from "../../useHoverDisclosure.js";
 export { useFloatingPosition, useHoverDisclosure };

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

@@ -1,14 +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 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 };

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

@@ -0,0 +1,30 @@
+import { MultiSelectEmptySlotProps, MultiSelectOptionSlotProps, MultiSelectPillSlotProps, MultiSelectProps, MultiSelectValue } 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<MultiSelectProps & {
+        onSearch?: ((searchValue: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: MultiSelectValue[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        inputElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?(props: MultiSelectOptionSlotProps): unknown;
+        pill?(props: MultiSelectPillSlotProps): unknown;
+        empty?(props: MultiSelectEmptySlotProps): unknown;
+    };
+    emit: ((evt: "search", searchValue: string) => void) & ((evt: "update:modelValue", value: MultiSelectValue[]) => 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/multi-select/multiSelectModel.d.ts

@@ -0,0 +1,3 @@
+import { MultiSelectOption, MultiSelectValue } from './types.js';
+export declare function getMultiSelectSelectedOptions(options: readonly MultiSelectOption[] | undefined, values: readonly MultiSelectValue[]): MultiSelectOption[];
+export declare function toggleMultiSelectValue(values: readonly MultiSelectValue[], value: MultiSelectValue, maxValues?: number): MultiSelectValue[];

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

@@ -0,0 +1,49 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export type MultiSelectValue = string | number;
+export interface MultiSelectOption {
+    label: string;
+    value: MultiSelectValue;
+    disabled?: boolean;
+}
+export type MultiSelectFilter = (option: MultiSelectOption, searchValue: string) => boolean;
+export type MultiSelectRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type MultiSelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface MultiSelectOptionSlotProps {
+    option: MultiSelectOption;
+    selected: boolean;
+    highlighted: boolean;
+}
+export interface MultiSelectPillSlotProps {
+    option: MultiSelectOption;
+}
+export interface MultiSelectEmptySlotProps {
+    searchValue: string;
+}
+export interface MultiSelectProps extends StylesApiProps<MultiSelectPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: MultiSelectValue[];
+    defaultValue?: MultiSelectValue[];
+    options?: MultiSelectOption[];
+    filter?: MultiSelectFilter | false;
+    maxValues?: number;
+    size?: MultiSelectSize;
+    radius?: MultiSelectRadius;
+    placeholder?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    removeLabel?: string;
+    toggleLabel?: string;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}
+export declare const multiSelectParts: readonly ["root", "pills", "pill", "pillLabel", "pillRemove", "input", "indicator", "clear", "toggle", "content", "option", "empty"];
+export type MultiSelectPart = (typeof multiSelectParts)[number];

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

@@ -0,0 +1,46 @@
+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 { MultiSelectOption, MultiSelectProps, MultiSelectValue } from './types.js';
+export interface MultiSelectControl {
+    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<MultiSelectOption[]>;
+    renderedOptions: ComputedRef<readonly FlatOptionState<MultiSelectOption>[]>;
+    selectedOptions: ComputedRef<MultiSelectOption[]>;
+    activeDescendantId: ComputedRef<string | undefined>;
+    rootClass: ComputedRef<string[]>;
+    floatingStyle: Readonly<Ref<CSSProperties>>;
+    actualPlacement: Readonly<Ref<FloatingPlacement>>;
+    placementSide: ComputedRef<FloatingSide>;
+    searchValue: Ref<string>;
+    canClear: ComputedRef<boolean>;
+    setDropdownElement: (elementRef: ComponentElementRef) => void;
+    toggle: () => void;
+    selectOption: (option: MultiSelectOption) => void;
+    removeOption: (option: MultiSelectOption) => void;
+    clearSelection: () => void;
+    onOptionMouseenter: (option: MultiSelectOption) => void;
+    onRootMousedown: (event: MouseEvent) => void;
+    onFocusout: (event: FocusEvent) => void;
+    onInput: (event: Event) => void;
+    onInputFocus: () => void;
+    onInputClick: () => void;
+    onInputKeydown: (event: KeyboardEvent) => void;
+}
+interface MultiSelectCallbacks {
+    valueChange: (value: MultiSelectValue[]) => void;
+    search: (searchValue: string) => void;
+}
+export declare function useMultiSelect(props: Readonly<MultiSelectProps>, callbacks: MultiSelectCallbacks): MultiSelectControl;
+export {};

package/dist/components/number-input/useNumberInput.d.ts

@@ -1,11 +1,9 @@
 import { InputHTMLAttributes } from 'vue';
 import { NumberInputControl } from './numberInputModel.js';
 import { NumberInputProps, NumberInputValue } from './types.js';
-export declare function useNumberInput(props: Readonly<NumberInputProps>, emitUpdate: (value: NumberInputValue) => void, getValue?: () => NumberInputValue): {
+export declare function useNumberInput(props: Readonly<NumberInputProps>, onUpdate: (value: NumberInputValue) => void): {
     control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
-    bounds: import('vue').ComputedRef<import('./numberInputModel.js').NumberInputBounds>;
-    nativeStep: import('vue').ComputedRef<number>;
     nativeInputAttrs: import('vue').ComputedRef<InputHTMLAttributes>;
     modelInputValue: import('vue').ComputedRef<string>;
     leftControls: import('vue').ComputedRef<NumberInputControl[]>;

package/dist/components/popover/usePopoverBindings.d.ts

@@ -1,16 +1,13 @@
 import { Ref } from 'vue';
+import { FloatingTargetLifecycle } from '../floating/useFloatingTargetLifecycle.js';
 import { PopoverRole } from './types.js';
 interface UsePopoverBindingsOptions {
-    isExplicitTarget: Readonly<Ref<boolean>>;
-    targetElement: Readonly<Ref<Element | null>>;
+    targetLifecycle: FloatingTargetLifecycle;
     popoverId: Readonly<Ref<string>>;
     popoverRole: Readonly<Ref<PopoverRole>>;
     isVisible: Readonly<Ref<boolean>>;
     isDisabled: Readonly<Ref<boolean>>;
     onTriggerClick: () => void;
-    onDocumentClick: (event: MouseEvent) => void;
-    onDocumentPointerDown: (event: MouseEvent | TouchEvent) => void;
-    onDocumentKeydown: (event: KeyboardEvent) => void;
 }
-export declare function usePopoverBindings({ isExplicitTarget, targetElement, popoverId, popoverRole, isVisible, isDisabled, onTriggerClick, onDocumentClick, onDocumentPointerDown, onDocumentKeydown, }: UsePopoverBindingsOptions): void;
+export declare function usePopoverBindings({ targetLifecycle, popoverId, popoverRole, isVisible, isDisabled, onTriggerClick, }: UsePopoverBindingsOptions): void;
 export {};