ropav 0.1.4 → 0.1.6

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

@@ -14,6 +14,7 @@ export interface BadgeProps extends StylesApiProps<BadgePart> {
     variant?: BadgeVariant;
     color?: BadgeColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: BadgeSize;
     radius?: BadgeRadius;
     ariaLabel?: string;

package/dist/components/badge/useBadgeColor.d.ts

@@ -1,3 +1,3 @@
 import { CSSProperties } from 'vue';
 import { BadgeColor, BadgeVariant } from './types.js';
-export declare function getBadgeColorStyle(color: BadgeColor | undefined, variant: BadgeVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;
+export declare function getBadgeColorStyle(color: BadgeColor | undefined, variant: BadgeVariant | undefined, autoContrast: boolean | undefined, contrastColor?: string): CSSProperties | undefined;

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

@@ -10,6 +10,7 @@ export interface ButtonProps extends StylesApiProps<ButtonPart> {
     variant?: ButtonVariant;
     color?: ButtonColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: ButtonSize;
     radius?: ButtonRadius;
     type?: 'button' | 'submit' | 'reset';

package/dist/components/button/useButtonColor.d.ts

@@ -1,3 +1,3 @@
 import { CSSProperties } from 'vue';
 import { ButtonColor, ButtonVariant } from './types.js';
-export declare function getButtonColorStyle(color: ButtonColor | undefined, variant: ButtonVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;
+export declare function getButtonColorStyle(color: ButtonColor | undefined, variant: ButtonVariant | undefined, autoContrast: boolean | undefined, contrastColor?: string): CSSProperties | undefined;

package/dist/components/button-link/types.d.ts

@@ -16,6 +16,7 @@ export interface ButtonLinkProps extends StylesApiProps<ButtonLinkPart> {
     variant?: ButtonLinkVariant;
     color?: ButtonLinkColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: ButtonLinkSize;
     radius?: ButtonLinkRadius;
     disabled?: boolean;

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

@@ -17,6 +17,7 @@ export interface CheckboxProps extends StylesApiProps<CheckboxPart> {
     variant?: CheckboxVariant;
     color?: CheckboxColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: CheckboxSize;
     radius?: CheckboxRadius;
     disabled?: boolean;

package/dist/components/checkbox/useCheckbox.d.ts

@@ -2,7 +2,7 @@ import { CSSProperties } from 'vue';
 import { CheckboxProps } from './types.js';
 export declare function useCheckbox(props: Readonly<CheckboxProps>, emitUpdate: (value: boolean) => void, getValue?: () => boolean): {
     inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
     onChange: (e: Event) => void;

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

@@ -1,8 +1,8 @@
 import { ColorInputProps } 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<ColorInputProps & {
-        "onUpdate:open"?: ((value: boolean) => any) | undefined;
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -16,7 +16,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     } & {
         'eye-dropper-icon'?: (props: {}) => any;
     };
-    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: string) => void);
+    emit: ((evt: "update:modelValue", value: string) => void) & ((evt: "update:open", value: boolean) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/components/color-input/useColorInput.d.ts

@@ -20,7 +20,7 @@ export declare function useColorInput(props: Readonly<ColorInputProps>, emit: Us
     hasInvalidColor: import('vue').ComputedRef<boolean | undefined>;
     isInvalid: import('vue').ComputedRef<boolean | undefined>;
     colorValidationMessage: import('vue').ComputedRef<string | undefined>;
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     popoverDisabled: import('vue').ComputedRef<boolean>;
 };

package/dist/components/dialog/dialog-core.d.ts

@@ -1,5 +1,5 @@
 import { ComponentPublicInstance, ComputedRef, InjectionKey, Ref, VaporComponentInstance } from 'vue';
-import { OverlayLayerContext } from '../../composables/useOverlayLayer.js';
+import { OverlayLayerContext } from '../../internal/composables/useOverlayLayer.js';
 import { DialogCloseReason } from './types.js';
 export interface DialogRootContext {
     isOpen: ComputedRef<boolean>;

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

@@ -5,8 +5,8 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             originalEvent: KeyboardEvent;
         }>) => any) | undefined;
         onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
-        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -21,7 +21,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     };
     emit: ((evt: "escapeKeyDown", event: CustomEvent<{
         originalEvent: KeyboardEvent;
-    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -1,5 +1,5 @@
 import { ComponentPublicInstance, ComputedRef, InjectionKey, Ref, VaporComponentInstance } from 'vue';
-import { OverlayLayerContext } from '../../composables/useOverlayLayer.js';
+import { OverlayLayerContext } from '../../internal/composables/useOverlayLayer.js';
 import { FloatingReference } from '../floating/types.js';
 import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuInteractOutsideEvent, DropdownMenuItemPrimitiveProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuPoint, DropdownMenuSelectEvent, DropdownMenuVirtualAnchor } from './types.js';
 export type ElementReference = FloatingReference;
@@ -8,6 +8,7 @@ export type ComponentRefValue = Element | ComponentPublicInstance | VaporCompone
 export interface MenuItemRegistration {
     id: string;
     element: () => HTMLElement | null;
+    textValue: () => string;
     disabled: () => boolean;
     activate: (event: Event) => void;
     submenu?: DropdownMenuSubContext;

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

@@ -5,8 +5,8 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             originalEvent: KeyboardEvent;
         }>) => any) | undefined;
         onPointerDownOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
-        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
         onInteractOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
+        onFocusOutside?: ((event: DropdownMenuInteractOutsideEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -21,7 +21,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     };
     emit: ((evt: "escapeKeyDown", event: CustomEvent<{
         originalEvent: KeyboardEvent;
-    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void);
+    }>) => void) & ((evt: "pointerDownOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "interactOutside", event: DropdownMenuInteractOutsideEvent) => void) & ((evt: "focusOutside", event: DropdownMenuInteractOutsideEvent) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

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

@@ -19,5 +19,3 @@ export declare function normalizePath(indexOrPath: number | ItemPath): ItemPath;
 export declare function getEventPoint(event: MouseEvent): PointerPoint;
 export declare function hasMeasuredRect(rect: DOMRect): boolean;
 export declare function isPointInRect(point: PointerPoint, rect: DOMRect, padding?: number): boolean;
-export declare function getEnabledIndexes(items: DropdownMenuItem[]): number[];
-export declare function getNextEnabledIndex(items: DropdownMenuItem[], index: number, direction: 1 | -1): number | undefined;

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

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

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

@@ -13,6 +13,7 @@ export declare const DropdownMenuItem: (__VLS_props: NonNullable<Awaited<typeof
         id?: string | undefined;
         as?: import('./types.js').DropdownMenuAs | undefined;
         value?: import('./types.js').DropdownMenuItemValue | undefined;
+        textValue?: string | undefined;
         disabled?: boolean | undefined;
         destructive?: boolean | undefined;
         closeOnSelect?: boolean | undefined;

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

@@ -190,6 +190,8 @@ export interface DropdownMenuItemPrimitiveProps {
     id?: string;
     as?: DropdownMenuAs;
     value?: DropdownMenuItemValue;
+    /** Text used for keyboard typeahead. Falls back to the rendered text content. */
+    textValue?: string;
     disabled?: boolean;
     destructive?: boolean;
     closeOnSelect?: boolean;
@@ -234,6 +236,8 @@ export interface DropdownMenuSubPrimitiveProps {
 export interface DropdownMenuSubTriggerPrimitiveProps {
     id?: string;
     as?: DropdownMenuAs;
+    /** Text used for keyboard typeahead. Falls back to the rendered text content. */
+    textValue?: string;
     disabled?: boolean;
 }
 export interface DropdownMenuSubContentPrimitiveProps extends Omit<DropdownMenuContentPrimitiveProps, 'arrow' | 'ignore' | 'placement'> {

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

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

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

@@ -31,12 +31,13 @@ type UseDropdownMenuInteractionsOptions = {
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
     focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
     moveFocus: (direction: 1 | -1) => ItemPath | undefined;
+    handleTypeahead: (event: KeyboardEvent) => boolean;
     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): {
+export declare function useDropdownMenuInteractions({ props, emit, isDisabled, focusedPath, openSubmenuPath, getItemAtPath, focusItem, moveFocus, handleTypeahead, submenus, hoverIntent, disclosure, isSubmenuOpeningLeft, }: UseDropdownMenuInteractionsOptions): {
     activateItem: (item: DropdownMenuItem, path: ItemPath, event?: MouseEvent | KeyboardEvent) => void;
     selectItem: (item: DropdownMenuItem, originalEvent?: Event) => void;
     openSubmenu: (path: ItemPath, focus?: SubmenuFocusTarget, point?: PointerPoint) => boolean;

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

@@ -10,6 +10,7 @@ export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
     focusItem: (target: DropdownMenuFocusTarget, menuPath?: ItemPath) => boolean;
     resetFocus: () => void;
+    setFocusedIndex: (index: number, menuPath?: ItemPath) => boolean;
     isItemFocused: (indexOrPath: number | ItemPath) => boolean;
     moveFocus: (direction: 1 | -1) => number[] | undefined;
 };

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

@@ -11,6 +11,7 @@ export interface IconButtonProps extends StylesApiProps<IconButtonPart> {
     variant?: IconButtonVariant;
     color?: IconButtonColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: IconButtonSize;
     radius?: IconButtonRadius;
     type?: 'button' | 'submit' | 'reset';

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

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

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

@@ -15,7 +15,7 @@ export declare function normalizeNumberInputControlsPosition(position: NumberInp
 export declare function normalizeNumberInputTextAlign(textAlign: NumberInputTextAlign | undefined): NumberInputTextAlign;
 export declare function getModelInputValue(value: NumberInputValue): string;
 export declare function useNumberInput(props: Readonly<NumberInputProps>, emitUpdate: (value: NumberInputValue) => void, getValue?: () => NumberInputValue): {
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     bounds: import('vue').ComputedRef<NumberInputBounds>;
     nativeStep: import('vue').ComputedRef<number>;

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

@@ -0,0 +1,4 @@
+export { default as Pagination } from './pagination.js';
+export { paginationColors, paginationParts, paginationRadiuses, paginationSizes } from './types.js';
+export type { PaginationColor, PaginationControl, PaginationControlSlotProps, PaginationEllipsisItem, PaginationGetPageAriaLabel, PaginationItem, PaginationPageItem, PaginationPageSlotProps, PaginationPart, PaginationProps, PaginationRadius, PaginationSize, } from './types.js';
+export { getPaginationItems, normalizePaginationPage, normalizePaginationTotal, usePagination, } from './usePagination.js';

package/dist/components/pagination/index.js

@@ -0,0 +1,2 @@
+import { a as pagination_default, c as normalizePaginationTotal, i as paginationSizes, l as usePagination, n as paginationParts, o as getPaginationItems, r as paginationRadiuses, s as normalizePaginationPage, t as paginationColors } from "../../pagination.js";
+export { pagination_default as Pagination, getPaginationItems, normalizePaginationPage, normalizePaginationTotal, paginationColors, paginationParts, paginationRadiuses, paginationSizes, usePagination };

package/dist/components/pagination/pagination.d.ts

@@ -0,0 +1,49 @@
+import { PaginationProps } 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<PaginationProps & {
+        "onUpdate:modelValue"?: ((page: number) => any) | undefined;
+        onChange?: ((page: number) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        first?: (props: {
+            page: number;
+            disabled: boolean;
+        }) => any;
+    } & {
+        previous?: (props: {
+            page: number;
+            disabled: boolean;
+        }) => any;
+    } & {
+        page?: (props: {
+            page: number;
+            active: boolean;
+        }) => any;
+    } & {
+        ellipsis?: (props: {}) => any;
+    } & {
+        next?: (props: {
+            page: number;
+            disabled: boolean;
+        }) => any;
+    } & {
+        last?: (props: {
+            page: number;
+            disabled: boolean;
+        }) => any;
+    };
+    emit: ((evt: "update:modelValue", page: number) => void) & ((evt: "change", page: number) => 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/pagination/types.d.ts

@@ -0,0 +1,54 @@
+import { ComponentColorValue } from '../../utils/componentColors.js';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const paginationParts: readonly ["root", "items", "control", "page", "ellipsis"];
+export type PaginationPart = (typeof paginationParts)[number];
+export declare const paginationColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
+export declare const paginationSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const paginationRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export type PaginationColor = ComponentColorValue;
+export type PaginationSize = (typeof paginationSizes)[number];
+export type PaginationRadius = (typeof paginationRadiuses)[number];
+export type PaginationControl = 'first' | 'previous' | 'next' | 'last';
+export type PaginationGetPageAriaLabel = (page: number, active: boolean) => string;
+export interface PaginationPageItem {
+    type: 'page';
+    key: string;
+    page: number;
+}
+export interface PaginationEllipsisItem {
+    type: 'ellipsis';
+    key: string;
+}
+export type PaginationItem = PaginationPageItem | PaginationEllipsisItem;
+export interface PaginationPageSlotProps {
+    page: number;
+    active: boolean;
+}
+export interface PaginationControlSlotProps {
+    page: number;
+    disabled: boolean;
+}
+export interface PaginationProps extends StylesApiProps<PaginationPart> {
+    id?: string;
+    modelValue?: number;
+    defaultValue?: number;
+    total: number;
+    siblings?: number;
+    boundaries?: number;
+    withControls?: boolean;
+    withEdges?: boolean;
+    disabled?: boolean;
+    color?: PaginationColor;
+    autoContrast?: boolean;
+    contrastColor?: string;
+    size?: PaginationSize;
+    radius?: PaginationRadius;
+    ariaLabel?: string;
+    labelledby?: string;
+    describedby?: string;
+    firstLabel?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+    lastLabel?: string;
+    getPageAriaLabel?: PaginationGetPageAriaLabel;
+}

package/dist/components/pagination/usePagination.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'vue';
+import { PaginationItem, PaginationProps } from './types.js';
+export declare function normalizePaginationTotal(total: number): number;
+export declare function normalizePaginationPage(page: number, total: number): number;
+export declare function getPaginationItems(total: number, page: number, siblings?: number, boundaries?: number): PaginationItem[];
+export declare function usePagination(props: Readonly<PaginationProps>, getCurrentValue: () => number, onChange: (page: number) => void): {
+    totalPages: import('vue').ComputedRef<number>;
+    currentPage: import('vue').ComputedRef<number>;
+    items: import('vue').ComputedRef<PaginationItem[]>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    firstPage: import('vue').ComputedRef<number>;
+    previousPage: import('vue').ComputedRef<number>;
+    nextPage: import('vue').ComputedRef<number>;
+    lastPage: import('vue').ComputedRef<number>;
+    isFirstDisabled: import('vue').ComputedRef<boolean>;
+    isLastDisabled: import('vue').ComputedRef<boolean>;
+    selectPage: (page: number) => boolean;
+};

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

@@ -13,7 +13,7 @@ export declare function normalizeProgressBounds(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.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     rootStyle: import('vue').ComputedRef<CSSProperties>;
     isIndeterminate: import('vue').ComputedRef<boolean>;

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

@@ -18,6 +18,7 @@ export interface RadioProps extends StylesApiProps<RadioPart> {
     variant?: RadioVariant;
     color?: RadioColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: RadioSize;
     disabled?: boolean;
     required?: boolean;
@@ -37,6 +38,7 @@ export interface RadioGroupProps extends StylesApiProps<RadioGroupPart> {
     variant?: RadioVariant;
     color?: RadioColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: RadioSize;
     orientation?: RadioGroupOrientation;
     disabled?: boolean;
@@ -65,6 +67,7 @@ export interface RadioGroupContext {
     variant?: RadioVariant;
     color?: RadioColor;
     autoContrast?: boolean;
+    contrastColor?: string;
     size?: RadioSize;
     inputAttrs: InputHTMLAttributes | undefined;
     select: (value: string | number) => void;

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

@@ -2,7 +2,7 @@ import { CSSProperties } from 'vue';
 import { RadioGroupProps, RadioProps } from './types.js';
 export declare function useRadio(props: Readonly<RadioProps>, emitChange: (event: Event) => void): {
     inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     name: import('vue').ComputedRef<string | undefined>;
     form: import('vue').ComputedRef<string | undefined>;
     groupInputAttrs: import('vue').ComputedRef<import('vue').InputHTMLAttributes | undefined>;
@@ -16,7 +16,7 @@ export declare function useRadio(props: Readonly<RadioProps>, emitChange: (event
     focus: (options?: FocusOptions) => void;
 };
 export declare function useRadioGroup(props: Readonly<RadioGroupProps>, emitUpdate: (value: string | number | null) => void): {
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     value: import('vue').ComputedRef<string | number | null>;
 };

package/dist/components/scroll-area/scrollAreaCore.d.ts

@@ -1,6 +1,8 @@
 import { ScrollAreaScrollbars, ScrollAreaType } from './types.js';
 export type ScrollAxis = 'x' | 'y';
+export type ScrollDirection = 'ltr' | 'rtl';
 export interface ScrollAreaMetrics {
+    direction: ScrollDirection;
     clientWidth: number;
     clientHeight: number;
     scrollWidth: number;
@@ -15,6 +17,9 @@ export interface ScrollAreaMetrics {
     verticalThumbOffset: number;
 }
 export declare function clamp(value: number, min: number, max: number): number;
+export declare function getScrollDirection(viewport: HTMLElement): ScrollDirection;
+export declare function getLogicalHorizontalPosition(scrollLeft: number, maxPosition: number, direction: ScrollDirection): number;
+export declare function getRawHorizontalPosition(position: number, maxPosition: number, direction: ScrollDirection): number;
 export declare function isAxisEnabled(scrollbars: ScrollAreaScrollbars | false | undefined, axis: ScrollAxis): boolean;
 export declare function isScrollbarActive(type: ScrollAreaType, enabled: boolean, overflowing: boolean): boolean;
 export declare function getThumbGeometry(trackSize: number, viewportSize: number, scrollSize: number): {

package/dist/components/scroll-area/types.d.ts

@@ -8,14 +8,18 @@ export declare const scrollAreaScrollbars: readonly ["x", "y", "both"];
 export type ScrollAreaScrollbars = (typeof scrollAreaScrollbars)[number];
 export type ScrollAreaOrientation = 'horizontal' | 'vertical';
 export interface ScrollAreaPosition {
+    /** Logical horizontal offset: zero at inline-start and increasing toward inline-end. */
     x: number;
+    /** Vertical offset from the top edge. */
     y: number;
 }
 export interface ScrollAreaSlotProps {
     position: ScrollAreaPosition;
     overflowX: boolean;
     overflowY: boolean;
+    /** Uses the native `Element.scrollTo()` coordinate semantics. */
     scrollTo: (options: ScrollToOptions) => void;
+    /** Uses the native `Element.scrollBy()` coordinate semantics. */
     scrollBy: (options: ScrollToOptions) => void;
     update: () => void;
 }

package/dist/components/scroll-area/useScrollArea.d.ts

@@ -35,6 +35,7 @@ export declare function useScrollArea(options: UseScrollAreaOptions): {
     horizontalScrollbarRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     verticalScrollbarRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     metrics: {
+        direction: import('./scrollAreaCore.js').ScrollDirection;
         clientWidth: number;
         clientHeight: number;
         scrollWidth: number;

package/dist/components/scroll-area/useScrollAreaMetrics.d.ts

@@ -11,6 +11,7 @@ interface UseScrollAreaMetricsOptions {
 }
 export declare function useScrollAreaMetrics(options: UseScrollAreaMetricsOptions): {
     metrics: {
+        direction: import('./scrollAreaCore.js').ScrollDirection;
         clientWidth: number;
         clientHeight: number;
         scrollWidth: number;
@@ -26,7 +27,9 @@ export declare function useScrollAreaMetrics(options: UseScrollAreaMetricsOption
     };
     position: import('vue').ComputedRef<ScrollAreaPosition>;
     update: () => void;
+    updatePosition: (viewport?: HTMLElement | null) => void;
     scheduleUpdate: () => void;
+    schedulePositionUpdate: () => void;
     getPosition: (axis: ScrollAxis) => number;
     getMaxPosition: (axis: ScrollAxis) => number;
     getOverflow: (axis: ScrollAxis) => boolean;

package/dist/components/scroll-area/useScrollAreaPresentation.d.ts

@@ -16,6 +16,7 @@ export declare function useScrollAreaPresentation(props: Readonly<ScrollAreaProp
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
+        'data-direction': import('./scrollAreaCore.js').ScrollDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
@@ -32,6 +33,7 @@ export declare function useScrollAreaPresentation(props: Readonly<ScrollAreaProp
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
+        'data-direction': import('./scrollAreaCore.js').ScrollDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
@@ -41,6 +43,7 @@ export declare function useScrollAreaPresentation(props: Readonly<ScrollAreaProp
     verticalThumbAttrs: import('vue').ComputedRef<Pick<HTMLAttributes, "class" | "style">>;
     cornerAttrs: import('vue').ComputedRef<{
         'aria-hidden': boolean;
+        'data-direction': import('./scrollAreaCore.js').ScrollDirection;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
         style?: import('vue').StyleValue;

package/dist/components/select/useSelect.d.ts

@@ -7,10 +7,11 @@ export declare function useSelect(props: Readonly<SelectBehaviorProps>, emitUpda
     triggerRef: Ref<HTMLElement | null, HTMLElement | null>;
     isOpen: Ref<boolean, boolean>;
     selectId: string;
+    popupId: string;
     listboxId: string;
-    control: import('../../composables/useControlState.js').ControlState;
+    control: import('../../internal/composables/useControlState.js').ControlState;
     visibleOptions: import('vue').ComputedRef<SelectOption[]>;
-    focusedIndex: Ref<number, number>;
+    focusedIndex: import('vue').ComputedRef<number>;
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     hasValue: import('vue').ComputedRef<boolean>;

package/dist/components/select/useSelectNativeValue.d.ts

@@ -2,13 +2,7 @@ import { SelectProps } from './types.js';
 export type SelectValue = string | number | null;
 export declare function useSelectNativeValue(props: Readonly<SelectProps>, emitUpdate: (value: SelectValue) => void): {
     nativeSelectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
-    controllable: {
-        initialValue: SelectValue;
-        isControlled: import('vue').ComputedRef<boolean>;
-        value: import('vue').ComputedRef<SelectValue>;
-        setValue: (nextValue: SelectValue) => void;
-        resetValue: (nextValue?: SelectValue) => void;
-    };
+    controllable: import('../../composables/useControllableValue.js').UseControllableValueReturn<SelectValue>;
     getNativeValue: (select: HTMLSelectElement) => string | number | null;
     syncNativeSelection: (value: SelectValue) => void;
     requestValueUpdate: (value: SelectValue) => void;