ropav 0.0.5 → 0.0.7

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

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { DropdownMenuPlacement } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type StringSource = {
+    readonly value: string;
+};
+type PlacementSource = {
+    readonly value: DropdownMenuPlacement;
+};
+type UseDropdownMenuDomOptions = {
+    menuId: StringSource;
+    rootRef: Ref<HTMLElement | null>;
+    menuRef: Ref<HTMLElement | null>;
+    placement: PlacementSource;
+    focusedPath: Ref<ItemPath>;
+};
+export declare function useDropdownMenuDom({ menuId, rootRef, menuRef, placement, focusedPath, }: UseDropdownMenuDomOptions): {
+    activeDescendantId: import('vue').ComputedRef<string | undefined>;
+    focusMenu: () => void;
+    focusTrigger: () => void;
+    getItemId: (indexOrPath: number | ItemPath) => string;
+    getSubmenuId: (path: ItemPath) => string;
+    getItemElement: (path: ItemPath) => HTMLElement | null;
+    getSubmenuElement: (path: ItemPath) => HTMLElement | null;
+    isSubmenuOpeningLeft: (path: ItemPath) => boolean;
+    getMenuActiveDescendant: (menuPath: ItemPath) => string | undefined;
+};
+export {};

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

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

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

@@ -0,0 +1,51 @@
+import { Ref } from 'vue';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
+import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils';
+type BooleanSource = Readonly<Ref<boolean>>;
+type DisclosureControls = {
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+};
+type SubmenuControls = {
+    closeSubmenusAfter: (menuPath: ItemPath) => void;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    closeCurrentSubmenu: () => boolean;
+};
+type HoverIntentControls = {
+    clearPendingHover: () => void;
+    resetHoverIntent: () => void;
+    trackSubmenuOpen: (path: ItemPath, point?: PointerPoint) => void;
+    handleItemHover: (item: DropdownMenuItem, path: ItemPath, event: MouseEvent | undefined, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
+    handleMenuMousemove: (event: MouseEvent, commit: (item: DropdownMenuItem, path: ItemPath, point?: PointerPoint) => void) => void;
+};
+type UseDropdownMenuInteractionsOptions = {
+    props: Readonly<DropdownMenuProps>;
+    emit: {
+        select?: (item: DropdownMenuItem) => void;
+    };
+    isDisabled: BooleanSource;
+    focusedPath: Ref<ItemPath>;
+    openSubmenuPath: Ref<ItemPath>;
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
+    moveFocus: (direction: 1 | -1) => ItemPath | undefined;
+    submenus: SubmenuControls;
+    hoverIntent: HoverIntentControls;
+    disclosure: DisclosureControls;
+    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;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
+    onTriggerClick: () => void;
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    onMenuMouseleave: () => void;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { DropdownMenuFocusTarget, DropdownMenuItem } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type DropdownMenuItemsSource = {
+    readonly value: DropdownMenuItem[];
+};
+export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource): {
+    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    focusedIndex: import('vue').ComputedRef<number>;
+    getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
+    resetFocus: () => void;
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    moveFocus: (direction: 1 | -1) => number[] | undefined;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem } from './types';
+import { ItemPath } from './dropdown-menu-utils';
+type DropdownMenuItemsSource = {
+    readonly value: DropdownMenuItem[];
+};
+type UseDropdownMenuRenderItemsOptions = {
+    items: DropdownMenuItemsSource;
+    getItemId: (path: ItemPath) => string;
+    getSubmenuId: (path: ItemPath) => string;
+    getMenuActiveDescendant: (path: ItemPath) => string | undefined;
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent) => void;
+    focusHoveredItem: (item: DropdownMenuItem, indexOrPath: number | ItemPath, event?: MouseEvent) => void;
+    selectItem: (item: DropdownMenuItem) => void;
+    openSubmenu: (path: ItemPath, focus?: DropdownMenuFocusTarget) => void;
+    closeSubmenu: (path: ItemPath) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+};
+export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
+    renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemSlotProps;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { DropdownMenuItem } from './types';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils';
+type UseDropdownSubmenusOptions = {
+    focusedPath: Ref<ItemPath>;
+    getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
+    focusItem: (target: Exclude<SubmenuFocusTarget, false>, menuPath?: ItemPath) => boolean;
+};
+export declare function useDropdownSubmenus({ focusedPath, getItemAtPath, focusItem, }: UseDropdownSubmenusOptions): {
+    openSubmenuPath: Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    resetSubmenus: () => void;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    closeSubmenusAfter: (menuPath: ItemPath) => void;
+    openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget) => boolean;
+    closeSubmenu: (path: ItemPath) => boolean;
+    closeCurrentSubmenu: () => boolean;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { FieldControlProps, FieldProps } from './types';
+import { FieldProps } from './types';
 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<FieldProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -15,7 +15,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             invalid: true | undefined;
             labelledby: string | undefined;
             describedby: string | undefined;
-            controlProps: FieldControlProps;
+            controlProps: import('./types').FieldControlProps;
         }) => any;
     } & {
         description?: (props: {}) => any;

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

@@ -0,0 +1,16 @@
+import { FieldControlProps, FieldProps } from './types';
+export declare function useField(props: Readonly<FieldProps>): {
+    controlId: import('vue').ComputedRef<string>;
+    labelId: import('vue').ComputedRef<string>;
+    descriptionId: import('vue').ComputedRef<string>;
+    messageId: import('vue').ComputedRef<string>;
+    isInvalid: import('vue').ComputedRef<boolean>;
+    messageText: import('vue').ComputedRef<string | undefined>;
+    hasLabel: import('vue').ComputedRef<boolean>;
+    hasDescription: import('vue').ComputedRef<boolean>;
+    hasMessage: import('vue').ComputedRef<boolean>;
+    controlLabelledby: import('vue').ComputedRef<string | undefined>;
+    controlDescribedby: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    controlProps: import('vue').ComputedRef<FieldControlProps>;
+};

package/dist/components/input/useInput.d.ts

@@ -0,0 +1,8 @@
+import { InputProps } from './types';
+export declare function useInput(props: Readonly<InputProps>, emitUpdate: (value: string) => void): {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    control: import('../../composables/useControlState').ControlState;
+    rootClass: import('vue').ComputedRef<string[]>;
+    onInput: (e: Event) => void;
+    focusInput: (e: MouseEvent) => void;
+};

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

@@ -0,0 +1,2 @@
+export { default as Modal } from './modal';
+export type { ModalInitialFocus, ModalPresetSize, ModalProps, ModalRole, ModalSize, ModalSlotProps, } from './types';

package/dist/components/modal/index.js

@@ -0,0 +1,2 @@
+import { t as modal_default } from "../../modal.js";
+export { modal_default as Modal };

package/dist/components/modal/modal.d.ts

@@ -0,0 +1,42 @@
+import { ModalProps } from './types';
+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<ModalProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        footer?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: (evt: "update:open", 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/modal/types.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from 'vue';
+import { OverlayProps } from '../overlay/types';
+export type ModalPresetSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export type ModalSize = ModalPresetSize | (string & {});
+export type ModalRole = 'dialog' | 'alertdialog';
+export type ModalInitialFocus = string | HTMLElement | Ref<HTMLElement | null | undefined>;
+export type ModalOverlayProps = Pick<OverlayProps, 'color' | 'opacity' | 'gradient' | 'blur'>;
+export interface ModalSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface ModalProps {
+    id?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    title?: string;
+    description?: string;
+    ariaLabel?: string;
+    closeLabel?: string;
+    role?: ModalRole;
+    size?: ModalSize;
+    initialFocus?: ModalInitialFocus | null;
+    closeOnOverlayClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    overlayProps?: ModalOverlayProps;
+    preventScroll?: boolean;
+    returnFocus?: boolean;
+    keepMounted?: boolean;
+}

package/dist/components/modal/useModal.d.ts

@@ -0,0 +1,29 @@
+import { CSSProperties } from 'vue';
+import { ModalProps, ModalRole, ModalSlotProps } from './types';
+export declare function useModal(props: Readonly<ModalProps>, emitOpenChange?: (open: boolean) => void): {
+    panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    modalId: import('vue').ComputedRef<string>;
+    titleId: import('vue').ComputedRef<string>;
+    descriptionId: import('vue').ComputedRef<string>;
+    role: import('vue').ComputedRef<ModalRole>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    shouldRender: import('vue').ComputedRef<boolean>;
+    hasHeader: import('vue').ComputedRef<boolean>;
+    hasFooter: import('vue').ComputedRef<boolean>;
+    showCloseButton: import('vue').ComputedRef<boolean | undefined>;
+    headerId: import('vue').ComputedRef<string | undefined>;
+    ariaLabelledby: import('vue').ComputedRef<string | undefined>;
+    ariaDescribedby: import('vue').ComputedRef<string | undefined>;
+    ariaLabel: import('vue').ComputedRef<string | undefined>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    stateClass: import('vue').ComputedRef<{
+        'rp-modal--closable': boolean | undefined;
+        'rp-modal--headerless': boolean;
+    }>;
+    slotProps: import('vue').ComputedRef<ModalSlotProps>;
+    openModal: () => void;
+    closeModal: () => void;
+    toggleModal: () => void;
+    onOverlayClick: (event: MouseEvent) => void;
+};

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

@@ -0,0 +1,2 @@
+export { default as Overlay } from './overlay';
+export type { OverlayBlur, OverlayProps, OverlayZIndex } from './types';

package/dist/components/overlay/index.js

@@ -0,0 +1,2 @@
+import { t as overlay_default } from "../../overlay.js";
+export { overlay_default as Overlay };

package/dist/components/overlay/overlay.d.ts

@@ -0,0 +1,19 @@
+import { OverlayProps } from './types';
+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<OverlayProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => 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/overlay/types.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'vue';
+export type OverlayZIndex = CSSProperties['zIndex'];
+export type OverlayBlur = number | string;
+export interface OverlayProps {
+    color?: string;
+    opacity?: number;
+    gradient?: string;
+    blur?: OverlayBlur;
+    zIndex?: OverlayZIndex;
+    interactive?: boolean;
+    disabled?: boolean;
+}

package/dist/components/overlay/useOverlay.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties } from 'vue';
+import { OverlayProps } from './types';
+export declare function useOverlay(props: Readonly<OverlayProps>): {
+    isRendered: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties>;
+};

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

@@ -0,0 +1,2 @@
+export { default as Popover } from './popover';
+export type { PopoverContentSlotProps, PopoverOffset, PopoverOffsetOptions, PopoverPlacement, PopoverProps, PopoverRole, PopoverSlotProps, PopoverTarget, PopoverTriggerProps, } from './types';

package/dist/components/popover/index.js

@@ -0,0 +1,2 @@
+import { t as popover_default } from "../../popover.js";
+export { popover_default as Popover };

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

@@ -0,0 +1,43 @@
+import { PopoverProps } from './types';
+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<PopoverProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            triggerProps: import('./types').PopoverTriggerProps;
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        content?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    } & {
+        default?: (props: {
+            isOpen: boolean;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }) => any;
+    };
+    emit: (evt: "update:open", 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/popover/types.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+export type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type PopoverTarget = string | HTMLElement | Ref<HTMLElement | null | undefined>;
+export interface PopoverOffsetOptions {
+    mainAxis?: number;
+    crossAxis?: number;
+}
+export type PopoverOffset = number | PopoverOffsetOptions;
+export type PopoverRole = 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid';
+export interface PopoverTriggerProps {
+    'aria-controls'?: string;
+    'aria-expanded'?: boolean;
+    'aria-haspopup'?: PopoverRole;
+    onClick: (event: MouseEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface PopoverSlotProps {
+    triggerProps: PopoverTriggerProps;
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface PopoverContentSlotProps {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+}
+export interface PopoverProps {
+    id?: string;
+    target?: PopoverTarget | null;
+    placement?: PopoverPlacement;
+    offset?: PopoverOffset;
+    open?: boolean;
+    disabled?: boolean;
+    role?: PopoverRole;
+    closeOnOutsideClick?: boolean;
+    closeOnEscape?: boolean;
+}

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

@@ -0,0 +1,20 @@
+import { CSSProperties } from 'vue';
+import { PopoverContentSlotProps, PopoverProps, PopoverRole, PopoverSlotProps, PopoverTriggerProps } from './types';
+export declare function usePopover(props: Readonly<PopoverProps>, emitOpenChange?: (open: boolean) => void): {
+    rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    popoverId: import('vue').ComputedRef<string>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    isVisible: import('vue').ComputedRef<boolean>;
+    isTargetMode: import('vue').ComputedRef<boolean>;
+    popoverRole: import('vue').ComputedRef<PopoverRole>;
+    shouldRenderContent: import('vue').ComputedRef<boolean>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    triggerProps: import('vue').ComputedRef<PopoverTriggerProps>;
+    slotProps: import('vue').ComputedRef<PopoverSlotProps>;
+    contentSlotProps: import('vue').ComputedRef<PopoverContentSlotProps>;
+    openPopover: () => void;
+    closePopover: () => void;
+    togglePopover: () => void;
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+};

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

@@ -0,0 +1,3 @@
+export { default as Progress } from './progress';
+export { progressColors, progressRadiuses, progressSizes } from './types';
+export type { ProgressColor, ProgressProps, ProgressRadius, ProgressSize, ProgressValueFormatter, } from './types';

package/dist/components/progress/index.js

@@ -0,0 +1,2 @@
+import { i as progress_default, n as progressRadiuses, r as progressSizes, t as progressColors } from "../../progress.js";
+export { progress_default as Progress, progressColors, progressRadiuses, progressSizes };

package/dist/components/progress/progress.d.ts

@@ -0,0 +1,27 @@
+import { ProgressProps } from './types';
+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<ProgressProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        value?: (props: {
+            value: number;
+            formattedValue: string | number;
+            percent: number;
+        }) => any;
+    };
+    emit: {};
+}>) => 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/progress/types.d.ts

@@ -0,0 +1,24 @@
+import { ComponentColorValue } from '../../utils/componentColors';
+export declare const progressColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+export declare const progressSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const progressRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export type ProgressColor = ComponentColorValue;
+export type ProgressSize = (typeof progressSizes)[number];
+export type ProgressRadius = (typeof progressRadiuses)[number];
+export type ProgressValueFormatter = (value: number, percent: number) => string | number;
+export interface ProgressProps {
+    id?: string;
+    value?: number | null;
+    min?: number;
+    max?: number;
+    color?: ProgressColor;
+    size?: ProgressSize;
+    radius?: ProgressRadius;
+    indeterminate?: boolean;
+    showValue?: boolean;
+    formatValue?: ProgressValueFormatter;
+    ariaLabel?: string;
+    ariaValueText?: string | ProgressValueFormatter;
+    describedby?: string;
+    labelledby?: string;
+}

package/dist/components/progress/useProgress.d.ts

@@ -0,0 +1,28 @@
+import { CSSProperties } from 'vue';
+import { ProgressProps } from './types';
+type ProgressStateProps = Readonly<ProgressProps & {
+    min: number;
+    max: number;
+    indeterminate: boolean;
+    showValue: boolean;
+}>;
+export declare function normalizeProgressBounds(min: number, max: number): {
+    min: number;
+    max: number;
+};
+export declare function normalizeProgressValue(value: number | null | undefined, min: number, max: number): number;
+export declare function getProgressValuePercent(value: number, min: number, max: number): number;
+export declare function useProgress(props: ProgressStateProps): {
+    control: import('../../composables/useControlState').ControlState;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties>;
+    isIndeterminate: import('vue').ComputedRef<boolean>;
+    normalizedValue: import('vue').ComputedRef<number>;
+    valuePercent: import('vue').ComputedRef<number>;
+    formattedValue: import('vue').ComputedRef<string | number>;
+    ariaValueText: import('vue').ComputedRef<string | undefined>;
+    ariaValueMin: import('vue').ComputedRef<number | undefined>;
+    ariaValueMax: import('vue').ComputedRef<number | undefined>;
+    ariaValueNow: import('vue').ComputedRef<number | undefined>;
+};
+export {};

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

@@ -1,5 +1,6 @@
 import { InjectionKey } from 'vue';
-export type RadioColor = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info' | 'neutral';
+import { ComponentColorValue } from '../../utils/componentColors';
+export type RadioColor = ComponentColorValue;
 export type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type RadioVariant = 'solid' | 'outline';
 export interface RadioProps {

package/dist/components/radio/useRadio.d.ts

@@ -4,6 +4,10 @@ export declare function useRadio(props: Readonly<RadioProps>): {
     isChecked: import('vue').ComputedRef<boolean>;
     isDisabled: import('vue').ComputedRef<boolean>;
     rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<{
+        '--_rp-radio-custom-color': string & {};
+        '--_rp-radio-custom-on-color': string;
+    } | undefined>;
     onSelect: () => void;
 };
 export declare function useRadioGroup(props: Readonly<RadioGroupProps>, emitUpdate: (value: string | number | null) => void): {

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

@@ -0,0 +1,3 @@
+export { default as Slider } from './slider';
+export { sliderColors, sliderOrientations, sliderSizes } from './types';
+export type { SliderColor, SliderMark, SliderMarkColor, SliderMarkInput, SliderOrientation, SliderProps, SliderPresetColor, SliderSize, SliderThumbStyle, SliderTooltip, SliderTooltipMode, SliderTooltipOptions, SliderValueFormatter, } from './types';

package/dist/components/slider/index.js

@@ -0,0 +1,2 @@
+import { i as sliderSizes, n as sliderColors, r as sliderOrientations, t as slider_default } from "../../slider.js";
+export { slider_default as Slider, sliderColors, sliderOrientations, sliderSizes };