ropav 0.1.5 → 0.1.7

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

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+import { DropdownMenuInteractionRuntime } from './dropdownMenuInteraction.js';
+import { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
+interface UseDropdownMenuPresentationOptions {
+    props: Readonly<DropdownMenuProps>;
+    rootMenuId: string;
+    menuId: Readonly<Ref<string>>;
+    isDisabled: Readonly<Ref<boolean>>;
+    isVisible: Readonly<Ref<boolean>>;
+    isExplicitTarget: Readonly<Ref<boolean>>;
+    actualPlacement: Readonly<Ref<DropdownMenuPlacement>>;
+    contentHasSubmenu: Readonly<Ref<boolean>>;
+    activeDescendantId: Readonly<Ref<string | undefined>>;
+    interaction: DropdownMenuInteractionRuntime;
+    resetHoverIntent: () => void;
+    onMenuMousemove: (event: MouseEvent) => void;
+    open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;
+    close: (options?: DropdownMenuCloseOptions) => void;
+    toggle: () => void;
+}
+export declare function useDropdownMenuPresentation({ props, rootMenuId, menuId, isDisabled, isVisible, isExplicitTarget, actualPlacement, contentHasSubmenu, activeDescendantId, interaction, resetHoverIntent, onMenuMousemove, open, close, toggle, }: UseDropdownMenuPresentationOptions): {
+    rootClass: import('vue').ComputedRef<string[]>;
+    contentClass: import('vue').ComputedRef<string[]>;
+    triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
+    contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
+    slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
+    onMenuKeydown: (event: KeyboardEvent) => void;
+};
+export {};

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

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+export type HoverDisclosureInteractionPart = 'trigger' | 'content';
+export interface HoverDisclosureInteractionState {
+    contentFocused: boolean;
+    contentHovered: boolean;
+    touchClickPending: boolean;
+    touchPinned: boolean;
+    touchPointerActive: boolean;
+    triggerFocused: boolean;
+    triggerHovered: boolean;
+}
+export type HoverDisclosureInteractionAction = {
+    type: 'hover';
+    part: HoverDisclosureInteractionPart;
+    active: boolean;
+} | {
+    type: 'focus';
+    part: HoverDisclosureInteractionPart;
+    active: boolean;
+} | {
+    type: 'pointer-down';
+    touch: boolean;
+} | {
+    type: 'pointer-up';
+    touch: boolean;
+} | {
+    type: 'pointer-cancel';
+} | {
+    type: 'consume-touch-click';
+} | {
+    type: 'set-touch-pinned';
+    pinned: boolean;
+} | {
+    type: 'reset';
+    part: HoverDisclosureInteractionPart | 'all';
+};
+export interface HoverDisclosureInteractionModel {
+    read: () => Readonly<HoverDisclosureInteractionState>;
+    send: (action: HoverDisclosureInteractionAction) => Readonly<HoverDisclosureInteractionState>;
+}
+export declare function createHoverDisclosureInteractionModel(): HoverDisclosureInteractionModel;
+export declare function hasActiveHoverDisclosureInteraction(state: Readonly<HoverDisclosureInteractionState>): boolean;
+export declare function reduceHoverDisclosureInteraction(state: Readonly<HoverDisclosureInteractionState>, action: HoverDisclosureInteractionAction): HoverDisclosureInteractionState;

package/dist/components/floating/index.js

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

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

@@ -3,7 +3,6 @@ import { FloatingReference, FloatingTarget, UseFloatingPositionOptions, UseFloat
 type Source<T> = () => T;
 export declare function readFloatingTarget(target: FloatingTarget | null | undefined): string | FloatingReference | null | undefined;
 export declare function isVirtualReference(value: unknown): value is FloatingReference;
-export declare function isElementReference(value: unknown): value is Element;
 export declare function resolveFloatingTarget(target: string | FloatingReference | null | undefined): FloatingReference | null;
 export declare function useFloatingTarget(getTarget: Source<FloatingTarget | null | undefined>, fallback: Readonly<Ref<Element | null>>): {
     isExplicitTarget: import('vue').ComputedRef<boolean>;

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

@@ -0,0 +1,32 @@
+import { ComputedRef } from 'vue';
+import { HoverDisclosureInteractionModel, HoverDisclosureInteractionPart } from './hoverDisclosureInteractionModel.js';
+import { HoverDisclosureChangeRequest } from './useHoverDisclosureOpenState.js';
+import { HoverDisclosureTargetState } from './useHoverDisclosureTargetBinding.js';
+import { HoverDisclosureContentProps, HoverDisclosureState, HoverDisclosureTriggerProps, UseHoverDisclosureOptions } from './types.js';
+interface HoverDisclosureInteractionCommands {
+    cancelScheduledClose: () => void;
+    isDisabled: ComputedRef<boolean>;
+    isOpen: ComputedRef<boolean>;
+    isRequestedOpen: () => boolean;
+    request: (change: HoverDisclosureChangeRequest) => void;
+}
+interface UseHoverDisclosureInteractionsOptions {
+    commands: HoverDisclosureInteractionCommands;
+    interaction: HoverDisclosureInteractionModel;
+    options: Readonly<UseHoverDisclosureOptions>;
+    state: ComputedRef<HoverDisclosureState>;
+    targets: HoverDisclosureTargetState;
+}
+export declare function useHoverDisclosureInteractions({ commands, interaction, options, state, targets, }: UseHoverDisclosureInteractionsOptions): {
+    bindingAdapter: {
+        contentListeners: readonly [readonly ["pointerenter", EventListener], readonly ["pointerleave", EventListener], readonly ["pointerdown", EventListener], readonly ["focusin", EventListener], readonly ["focusout", EventListener], readonly ["keydown", EventListener]];
+        isOutsideDismissalActive: () => boolean;
+        onDocumentKeydown: (event: KeyboardEvent) => void;
+        onOutsidePointerdown: (event: PointerEvent) => void;
+        onTargetDetached: (part: HoverDisclosureInteractionPart) => void;
+        triggerListeners: readonly [readonly ["pointerenter", EventListener], readonly ["pointerleave", EventListener], readonly ["pointerdown", EventListener], readonly ["pointerup", EventListener], readonly ["pointercancel", EventListener], readonly ["click", EventListener], readonly ["focusin", EventListener], readonly ["focusout", EventListener], readonly ["keydown", EventListener]];
+    };
+    contentProps: ComputedRef<HoverDisclosureContentProps>;
+    triggerProps: ComputedRef<HoverDisclosureTriggerProps>;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { HoverDisclosureInteractionModel } from './hoverDisclosureInteractionModel.js';
+import { HoverDisclosureOpenChangeReason, HoverDisclosureState, UseHoverDisclosureOptions } from './types.js';
+export interface HoverDisclosureChangeRequest {
+    event?: Event;
+    open: boolean;
+    reason: HoverDisclosureOpenChangeReason;
+    timing: 'delayed' | 'immediate';
+}
+interface UseHoverDisclosureOpenStateOptions {
+    interaction: HoverDisclosureInteractionModel;
+    onContentClosed: () => void;
+    options: Readonly<UseHoverDisclosureOptions>;
+}
+export declare function useHoverDisclosureOpenState({ interaction, onContentClosed, options, }: UseHoverDisclosureOpenStateOptions): {
+    cancelScheduledClose: () => void;
+    close: () => void;
+    isDisabled: import('vue').ComputedRef<boolean>;
+    isOpen: import('vue').ComputedRef<boolean>;
+    isRequestedOpen: () => boolean;
+    open: () => void;
+    request: (change: HoverDisclosureChangeRequest) => void;
+    state: import('vue').ComputedRef<HoverDisclosureState>;
+    toggle: () => void;
+};
+export {};

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

@@ -0,0 +1,27 @@
+import { shallowRef, ComputedRef } from 'vue';
+import { UseHoverDisclosureOptions } from './types.js';
+import { HoverDisclosureInteractionPart } from './hoverDisclosureInteractionModel.js';
+export type HoverDisclosureTargetListener = readonly [type: string, listener: EventListener];
+export interface HoverDisclosureTargetState {
+    contentElement: Element | null;
+    resolvedContentTarget: ReturnType<typeof shallowRef<Element | null>>;
+    resolvedInteractionTarget: ReturnType<typeof shallowRef<Element | null>>;
+    triggerElement: Element | null;
+}
+interface HoverDisclosureBindingAdapter {
+    contentListeners: readonly HoverDisclosureTargetListener[];
+    isOutsideDismissalActive: () => boolean;
+    onDocumentKeydown: (event: KeyboardEvent) => void;
+    onOutsidePointerdown: (event: PointerEvent) => void;
+    onTargetDetached: (part: HoverDisclosureInteractionPart) => void;
+    triggerListeners: readonly HoverDisclosureTargetListener[];
+}
+interface UseHoverDisclosureTargetBindingOptions {
+    adapter: HoverDisclosureBindingAdapter;
+    isOpen: ComputedRef<boolean>;
+    options: Readonly<UseHoverDisclosureOptions>;
+    targets: HoverDisclosureTargetState;
+}
+export declare function createHoverDisclosureTargetState(): HoverDisclosureTargetState;
+export declare function useHoverDisclosureTargetBinding({ adapter, isOpen, options, targets, }: UseHoverDisclosureTargetBindingOptions): void;
+export {};

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/numberInputModel.d.ts

@@ -0,0 +1,15 @@
+import { NumberInputControlsPosition, NumberInputTextAlign, NumberInputValue } from './types.js';
+export interface NumberInputBounds {
+    min: number | undefined;
+    max: number | undefined;
+}
+export type NumberInputControl = 'decrement' | 'increment';
+export type NumberInputStepDirection = -1 | 1;
+export declare function normalizeNumberInputBounds(min: number | undefined, max: number | undefined): NumberInputBounds;
+export declare function normalizeNumberInputStep(step: number | undefined): number;
+export declare function clampNumberInputValue(value: number, bounds: NumberInputBounds): number;
+export declare function stepNumberInputValue(value: NumberInputValue, direction: NumberInputStepDirection, step: number, bounds: NumberInputBounds): number;
+export declare function parseNumberInputValue(value: string): NumberInputValue;
+export declare function normalizeNumberInputControlsPosition(position: NumberInputControlsPosition | undefined): NumberInputControlsPosition;
+export declare function normalizeNumberInputTextAlign(textAlign: NumberInputTextAlign | undefined): NumberInputTextAlign;
+export declare function getModelInputValue(value: NumberInputValue): string;

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

@@ -1,23 +1,10 @@
 import { InputHTMLAttributes } from 'vue';
-import { NumberInputControlsPosition, NumberInputProps, NumberInputTextAlign, NumberInputValue } from './types.js';
-export interface NumberInputBounds {
-    min: number | undefined;
-    max: number | undefined;
-}
-type StepDirection = -1 | 1;
-export type NumberInputControl = 'decrement' | 'increment';
-export declare function normalizeNumberInputBounds(min: number | undefined, max: number | undefined): NumberInputBounds;
-export declare function normalizeNumberInputStep(step: number | undefined): number;
-export declare function clampNumberInputValue(value: number, bounds: NumberInputBounds): number;
-export declare function stepNumberInputValue(value: NumberInputValue, direction: StepDirection, step: number, bounds: NumberInputBounds): number;
-export declare function parseNumberInputValue(value: string): NumberInputValue;
-export declare function normalizeNumberInputControlsPosition(position: NumberInputControlsPosition | undefined): NumberInputControlsPosition;
-export declare function normalizeNumberInputTextAlign(textAlign: NumberInputTextAlign | undefined): NumberInputTextAlign;
-export declare function getModelInputValue(value: NumberInputValue): string;
+import { NumberInputControl } from './numberInputModel.js';
+import { NumberInputProps, NumberInputValue } from './types.js';
 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>;
+    bounds: import('vue').ComputedRef<import('./numberInputModel.js').NumberInputBounds>;
     nativeStep: import('vue').ComputedRef<number>;
     nativeInputAttrs: import('vue').ComputedRef<InputHTMLAttributes>;
     modelInputValue: import('vue').ComputedRef<string>;
@@ -29,4 +16,3 @@ export declare function useNumberInput(props: Readonly<NumberInputProps>, emitUp
     decrement: () => boolean;
     onInputUpdate: (value: string) => void;
 };
-export {};

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

@@ -1,4 +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 type { PaginationColor, PaginationControl, PaginationControlSlotProps, PaginationEllipsisItem, PaginationGetPageAriaLabel, PaginationItem, PaginationPageItem, PaginationPageSlotProps, PaginationPart, PaginationProps, PaginationRadius, PaginationSize, UsePaginationReturn, } from './types.js';
 export { getPaginationItems, normalizePaginationPage, normalizePaginationTotal, usePagination, } from './usePagination.js';

package/dist/components/pagination/index.js

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

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

@@ -0,0 +1,4 @@
+import { PaginationItem } 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[];

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

@@ -1,5 +1,6 @@
 import { ComponentColorValue } from '../../utils/componentColors.js';
 import { StylesApiProps } from '../../styles-api.js';
+import { ComputedRef, CSSProperties } from 'vue';
 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"];
@@ -52,3 +53,17 @@ export interface PaginationProps extends StylesApiProps<PaginationPart> {
     lastLabel?: string;
     getPageAriaLabel?: PaginationGetPageAriaLabel;
 }
+export interface UsePaginationReturn {
+    totalPages: ComputedRef<number>;
+    currentPage: ComputedRef<number>;
+    items: ComputedRef<PaginationItem[]>;
+    rootClass: ComputedRef<string[]>;
+    rootStyle: ComputedRef<CSSProperties | undefined>;
+    firstPage: ComputedRef<number>;
+    previousPage: ComputedRef<number>;
+    nextPage: ComputedRef<number>;
+    lastPage: ComputedRef<number>;
+    isFirstDisabled: ComputedRef<boolean>;
+    isLastDisabled: ComputedRef<boolean>;
+    selectPage: (page: number) => boolean;
+}

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

@@ -1,19 +1,3 @@
-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;
-};
+import { PaginationProps, UsePaginationReturn } from './types.js';
+export { getPaginationItems, normalizePaginationPage, normalizePaginationTotal, } from './paginationModel.js';
+export declare function usePagination(props: Readonly<PaginationProps>, getCurrentValue: () => number, onChange: (page: number) => void): UsePaginationReturn;

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

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { PopoverRole } from './types.js';
+interface UsePopoverBindingsOptions {
+    isExplicitTarget: Readonly<Ref<boolean>>;
+    targetElement: Readonly<Ref<Element | null>>;
+    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 {};

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

@@ -0,0 +1,8 @@
+import { ProgressProps } from './types.js';
+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 formatProgressValue(value: number, percent: number, formatter: ProgressProps['formatValue']): string | number;
+export declare function getProgressAriaValueText(value: number, percent: number, ariaValueText: ProgressProps['ariaValueText'], formatter: ProgressProps['formatValue']): string | undefined;

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

@@ -6,14 +6,8 @@ type ProgressStateProps = Readonly<ProgressProps & {
     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.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/useRadio.d.ts

@@ -1,8 +1,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>;
@@ -11,12 +10,12 @@ export declare function useRadio(props: Readonly<RadioProps>, emitChange: (event
     isRequired: import('vue').ComputedRef<boolean>;
     isInvalid: import('vue').ComputedRef<boolean>;
     rootClass: import('vue').ComputedRef<string[]>;
-    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    rootStyle: import('vue').ComputedRef<Record<string, string> | undefined>;
     onSelect: (event: Event) => void;
     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/scroll-area.d.ts

@@ -16,7 +16,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             default: string;
         };
         scrollbarSize: {
-            type: (StringConstructor | NumberConstructor)[];
+            type: (NumberConstructor | StringConstructor)[];
             default: number;
         };
         scrollHideDelay: {

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

@@ -0,0 +1,64 @@
+import { CSSProperties } from 'vue';
+import { ScrollAxis, ScrollDirection } from '../../utils/dom/scroll.js';
+import { ScrollAreaPosition, ScrollAreaScrollbars, ScrollAreaType } from './types.js';
+export type ScrollBoundary = 'top' | 'bottom' | 'left' | 'right';
+export interface ScrollAreaMetrics {
+    direction: ScrollDirection;
+    clientWidth: number;
+    clientHeight: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    x: number;
+    y: number;
+    overflowX: boolean;
+    overflowY: boolean;
+    horizontalThumbSize: number;
+    horizontalThumbOffset: number;
+    verticalThumbSize: number;
+    verticalThumbOffset: number;
+}
+export interface ScrollAreaAxisState {
+    direction: ScrollDirection;
+    maxPosition: number;
+    overflow: boolean;
+    position: number;
+}
+interface ScrollbarVisibilityOptions {
+    active: boolean;
+    axis: ScrollAxis;
+    draggingAxis: ScrollAxis | null;
+    focusWithin: boolean;
+    hovered: boolean;
+    scrolling: boolean;
+    type: ScrollAreaType;
+}
+interface TrackPositionOptions {
+    axis: ScrollAxis;
+    coordinate: number;
+    direction: ScrollDirection;
+    maxPosition: number;
+    thumbSize: number;
+    trackSize: number;
+    trackStart: number;
+}
+interface DragPositionOptions {
+    coordinate: number;
+    coordinateDirection: 1 | -1;
+    maxPosition: number;
+    startCoordinate: number;
+    startPosition: number;
+    travel: number;
+}
+export declare function createScrollAreaMetrics(): ScrollAreaMetrics;
+export declare function isScrollAreaAxisEnabled(scrollbars: ScrollAreaScrollbars | false | undefined, axis: ScrollAxis): boolean;
+export declare function isScrollAreaScrollbarActive(type: ScrollAreaType, enabled: boolean, overflowing: boolean): boolean;
+export declare function isScrollAreaScrollbarVisible({ active, axis, draggingAxis, focusWithin, hovered, scrolling, type, }: ScrollbarVisibilityOptions): boolean;
+export declare function getScrollAreaAxisPosition(metrics: ScrollAreaMetrics, axis: ScrollAxis): number;
+export declare function getScrollAreaMaxPosition(metrics: ScrollAreaMetrics, axis: ScrollAxis): number;
+export declare function getScrollAreaOverflow(metrics: ScrollAreaMetrics, axis: ScrollAxis): boolean;
+export declare function getScrollAreaAxisState(metrics: ScrollAreaMetrics, axis: ScrollAxis): ScrollAreaAxisState;
+export declare function getReachedScrollAreaBoundaries(position: ScrollAreaPosition, previousPosition: ScrollAreaPosition, metrics: ScrollAreaMetrics): ScrollBoundary[];
+export declare function getScrollAreaTrackPosition({ axis, coordinate, direction, maxPosition, thumbSize, trackSize, trackStart, }: TrackPositionOptions): number | undefined;
+export declare function getScrollAreaDragPosition({ coordinate, coordinateDirection, maxPosition, startCoordinate, startPosition, travel, }: DragPositionOptions): number;
+export declare function getScrollAreaRootStyle(scrollbarSize: number | string | undefined): CSSProperties;
+export {};

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;
 }