ropav 0.0.9 → 0.0.11

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

@@ -1,17 +1,32 @@
-import { InjectionKey } from 'vue';
-import { ComponentColorValue } from '../../utils/componentColors';
+import { InjectionKey, InputHTMLAttributes } from 'vue';
+import { ComponentColorValue } from '../../utils/componentColors.js';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const radioParts: readonly ["root", "input", "indicator", "label"];
+export declare const radioGroupParts: readonly ["root"];
+export type RadioPart = (typeof radioParts)[number];
+export type RadioGroupPart = (typeof radioGroupParts)[number];
 export type RadioColor = ComponentColorValue;
 export type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type RadioVariant = 'solid' | 'outline';
-export interface RadioProps {
+export type RadioGroupOrientation = 'horizontal' | 'vertical';
+export interface RadioProps extends StylesApiProps<RadioPart> {
+    id?: string;
+    name?: string;
     value: string | number;
+    checked?: boolean;
     variant?: RadioVariant;
     color?: RadioColor;
     autoContrast?: boolean;
     size?: RadioSize;
     disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
 }
-export interface RadioGroupProps {
+export interface RadioGroupProps extends StylesApiProps<RadioGroupPart> {
     id?: string;
     name?: string;
     modelValue: string | number | null;
@@ -19,6 +34,7 @@ export interface RadioGroupProps {
     color?: RadioColor;
     autoContrast?: boolean;
     size?: RadioSize;
+    orientation?: RadioGroupOrientation;
     disabled?: boolean;
     required?: boolean;
     invalid?: boolean;
@@ -31,6 +47,7 @@ export interface RadioGroupContext {
     name: string;
     disabled: boolean;
     required: boolean;
+    invalid: boolean;
     variant?: RadioVariant;
     color?: RadioColor;
     autoContrast?: boolean;

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

@@ -1,14 +1,19 @@
 import { CSSProperties } from 'vue';
-import { RadioGroupContext, RadioGroupProps, RadioProps } from './types';
-export declare function useRadio(props: Readonly<RadioProps>): {
-    group: RadioGroupContext;
+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;
+    name: import('vue').ComputedRef<string | undefined>;
     isChecked: import('vue').ComputedRef<boolean>;
     isDisabled: import('vue').ComputedRef<boolean>;
+    isRequired: import('vue').ComputedRef<boolean>;
+    isInvalid: import('vue').ComputedRef<boolean>;
     rootClass: import('vue').ComputedRef<string[]>;
     rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
-    onSelect: () => void;
+    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').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
 };

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

@@ -1,2 +1,3 @@
-export { default as Select } from './select';
-export type { SelectOption, SelectProps, SelectRadius, SelectSize } from './types';
+export { default as Select } from './select.js';
+export { selectParts } from './types.js';
+export type { SelectOption, SelectPart, SelectProps, SelectRadius, SelectSize } from './types.js';

package/dist/components/select/index.js

@@ -1,2 +1,2 @@
-import { t as select_default } from "../../select.js";
-export { select_default as Select };
+import { n as select_default, t as selectParts } from "../../select.js";
+export { select_default as Select, selectParts };

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

@@ -1,4 +1,4 @@
-import { SelectProps } from './types';
+import { SelectProps } 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<SelectProps & {
         "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;

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

@@ -1,3 +1,4 @@
+import { StylesApiProps } from '../../styles-api.js';
 export interface SelectOption {
     label: string;
     value: string | number;
@@ -5,7 +6,7 @@ export interface SelectOption {
 }
 export type SelectRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type SelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-export interface SelectProps {
+export interface SelectProps extends StylesApiProps<SelectPart> {
     id?: string;
     name?: string;
     modelValue: string | number | null;
@@ -22,3 +23,5 @@ export interface SelectProps {
     describedby?: string;
     labelledby?: string;
 }
+export declare const selectParts: readonly ["root", "trigger", "value", "indicator", "clear", "content", "option", "empty"];
+export type SelectPart = (typeof selectParts)[number];

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

@@ -1,12 +1,13 @@
-import { SelectOption, SelectProps } from './types';
+import { SelectOption, SelectProps } from './types.js';
 type SelectValue = string | number | null;
-export declare function useSelect(props: Readonly<SelectProps>, emitUpdate: (value: SelectValue) => void): {
+type SelectBehaviorProps = Omit<SelectProps, 'classNames' | 'styles'>;
+export declare function useSelect(props: Readonly<SelectBehaviorProps>, emitUpdate: (value: SelectValue) => void): {
     selectRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     triggerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     isOpen: import('vue').Ref<boolean, boolean>;
     selectId: string;
     listboxId: string;
-    control: import('../../composables/useControlState').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     visibleOptions: import('vue').ComputedRef<SelectOption[]>;
     focusedIndex: import('vue').Ref<number, number>;
     activeDescendantId: import('vue').ComputedRef<string | undefined>;

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

@@ -1,4 +1,4 @@
-export { default as Slider } from './slider';
-export { default as RangeSlider } from './range-slider';
-export { sliderColors, sliderOrientations, sliderSizes } from './types';
-export type { RangeSliderAriaValueText, RangeSliderEndpointValueText, RangeSliderProps, RangeSliderThumb, RangeSliderValue, SliderColor, SliderMark, SliderMarkColor, SliderMarkInput, SliderOrientation, SliderProps, SliderPresetColor, SliderSize, SliderThumbStyle, SliderTooltip, SliderTooltipMode, SliderTooltipOptions, SliderValueFormatter, } from './types';
+export { default as Slider } from './slider.js';
+export { default as RangeSlider } from './range-slider.js';
+export { rangeSliderParts, sliderColors, sliderOrientations, sliderParts, sliderSizes, } from './types.js';
+export type { RangeSliderAriaValueText, RangeSliderEndpointValueText, RangeSliderInputAttrs, RangeSliderPart, RangeSliderProps, RangeSliderThumb, RangeSliderValue, SliderColor, SliderInputAttrs, SliderMark, SliderMarkColor, SliderMarkInput, SliderOrientation, SliderPart, SliderProps, SliderPresetColor, SliderSize, SliderThumbStyle, SliderTooltip, SliderTooltipMode, SliderTooltipOptions, SliderValueFormatter, } from './types.js';

package/dist/components/slider/index.js

@@ -1,2 +1,2 @@
-import { a as slider_default, i as range_slider_default, n as sliderOrientations, r as sliderSizes, t as sliderColors } from "../../slider.js";
-export { range_slider_default as RangeSlider, slider_default as Slider, sliderColors, sliderOrientations, sliderSizes };
+import { a as sliderSizes, i as sliderParts, n as sliderColors, o as range_slider_default, r as sliderOrientations, s as slider_default, t as rangeSliderParts } from "../../slider.js";
+export { range_slider_default as RangeSlider, slider_default as Slider, rangeSliderParts, sliderColors, sliderOrientations, sliderParts, sliderSizes };

package/dist/components/slider/range-slider-tooltip.d.ts

@@ -0,0 +1,37 @@
+import { HTMLAttributes } from 'vue';
+import { TooltipColor, TooltipOffset, TooltipPlacement } from '../tooltip/types.js';
+import { RangeSliderValue, SliderOrientation } 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<{
+        arrow?: boolean;
+        color?: TooltipColor;
+        content: [string, string];
+        ids: [string | undefined, string | undefined];
+        mergedContent: string;
+        mergedId?: string;
+        offset?: TooltipOffset;
+        open: boolean;
+        orientation: SliderOrientation;
+        placement: TooltipPlacement;
+        valuePercent: RangeSliderValue;
+        tooltipClass?: HTMLAttributes["class"];
+        tooltipStyle?: HTMLAttributes["style"];
+    } & {
+        "onUpdate:overlapping"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:overlapping", 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/slider/range-slider.d.ts

@@ -1,31 +1,26 @@
-import { RangeSliderProps } from './types';
+import { RangeSliderProps } 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<RangeSliderProps & {
         "onUpdate:modelValue"?: ((value: [number, number]) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: {}) => void;
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElements: import('vue').ComputedRef<[HTMLInputElement | null, HTMLInputElement | null]>;
+        focus: (options?: FocusOptions) => void;
+    }>) => void;
     attrs: any;
     slots: {
         default?: (props: {}) => any;
     } & {
         value?: (props: {
-            value: import('./types').RangeSliderValue;
+            value: import('./types.js').RangeSliderValue;
             formattedValue: [string | number, string | number];
-            percent: import('./types').RangeSliderValue;
+            percent: import('./types.js').RangeSliderValue;
         }) => any;
     } & {
         thumb?: (props: {
-            thumb: string;
-            index: number;
-            value: number;
-            formattedValue: string | number;
-            percent: number;
-        }) => any;
-    } & {
-        thumb?: (props: {
-            thumb: string;
+            thumb: "lower" | "upper";
             index: number;
             value: number;
             formattedValue: string | number;

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

@@ -1,11 +1,14 @@
-import { SliderProps } from './types';
+import { SliderProps } 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<SliderProps & {
         "onUpdate:modelValue"?: ((value: number) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: {}) => void;
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: (options?: FocusOptions) => void;
+    }>) => void;
     attrs: any;
     slots: {
         default?: (props: {}) => any;

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

@@ -0,0 +1,35 @@
+import { CSSProperties } from 'vue';
+import { SliderMarkInput, SliderProps, SliderThumbStyle, SliderTooltipMode, SliderTooltipOptions } from './types.js';
+export interface SliderBounds {
+    min: number;
+    max: number;
+}
+interface SliderMarkStyleProperties {
+    position: `--_rp-${string}`;
+    colors: readonly `--_rp-${string}`[];
+}
+interface SliderThumbStyleProperties {
+    size: `--${string}`;
+    border: `--${string}`;
+    padding: `--${string}`;
+    borderColor: `--_rp-${string}`;
+}
+export declare function normalizeSliderBounds(min: number, max: number): SliderBounds;
+export declare function normalizeSliderStep(step: number | 'any'): number | "any";
+export declare function normalizeSliderValue(value: number, min: number, max: number, step: number | 'any'): number;
+export declare function getSliderValuePercent(value: number, min: number, max: number): number;
+export declare function setSliderStyleValue(style: CSSProperties, property: `--${string}`, value: string | undefined): void;
+export declare function applySliderThumbStyle(style: CSSProperties, thumbStyle: SliderThumbStyle | undefined, properties: SliderThumbStyleProperties): void;
+export declare function createSliderMarkItems(marks: SliderMarkInput[] | undefined, min: number, max: number, isFilled: (value: number, percent: number) => boolean, properties: SliderMarkStyleProperties): {
+    key: string;
+    value: number;
+    label: string | number | undefined;
+    hasLabel: boolean;
+    filled: boolean;
+    style: CSSProperties;
+}[];
+export declare function getFormattedSliderValue(value: number, formatter: SliderProps['formatValue']): string | number;
+export declare function getSliderAriaValueText(value: number, ariaValueText: string | SliderProps['formatValue'] | undefined, formatter: SliderProps['formatValue']): string | undefined;
+export declare function getSliderTooltipOptions(tooltip: NonNullable<SliderProps['tooltip']>): SliderTooltipOptions;
+export declare function getSliderTooltipMode(tooltip: NonNullable<SliderProps['tooltip']>): SliderTooltipMode | false;
+export {};

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

@@ -1,5 +1,11 @@
-import { TooltipProps } from '../tooltip/types';
-import { ComponentColorValue } from '../../utils/componentColors';
+import { InputHTMLAttributes } from 'vue';
+import { TooltipProps } from '../tooltip/types.js';
+import { ComponentColorValue } from '../../utils/componentColors.js';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const sliderParts: readonly ["root", "label", "value", "track", "range", "input", "thumb", "mark", "markLabel", "tooltip"];
+export declare const rangeSliderParts: readonly ["root", "label", "value", "track", "range", "input", "thumb", "mark", "markLabel", "tooltip"];
+export type SliderPart = (typeof sliderParts)[number];
+export type RangeSliderPart = (typeof rangeSliderParts)[number];
 export declare const sliderColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
 export declare const sliderSizes: readonly ["xs", "sm", "md", "lg", "xl"];
 export declare const sliderOrientations: readonly ["horizontal", "vertical"];
@@ -10,6 +16,8 @@ export type SliderOrientation = (typeof sliderOrientations)[number];
 export type SliderValueFormatter = (value: number) => string | number;
 export type RangeSliderValue = [number, number];
 export type RangeSliderThumb = 'lower' | 'upper';
+export type SliderInputAttrs = InputHTMLAttributes;
+export type RangeSliderInputAttrs = SliderInputAttrs | [SliderInputAttrs | undefined, SliderInputAttrs | undefined];
 export type RangeSliderEndpointValueText = string | SliderValueFormatter;
 export type RangeSliderAriaValueText = RangeSliderEndpointValueText | [RangeSliderEndpointValueText, RangeSliderEndpointValueText];
 export type SliderTooltipMode = 'hover' | 'always';
@@ -30,7 +38,7 @@ export interface SliderThumbStyle {
     border?: number | string;
     padding?: number | string;
 }
-export interface SliderProps {
+export interface SliderProps extends StylesApiProps<SliderPart> {
     id?: string;
     name?: string;
     modelValue: number;
@@ -45,18 +53,17 @@ export interface SliderProps {
     size?: SliderSize;
     orientation?: SliderOrientation;
     disabled?: boolean;
-    required?: boolean;
-    invalid?: boolean;
-    valid?: boolean;
     ariaLabel?: string;
     ariaValueText?: string | SliderValueFormatter;
     describedby?: string;
     labelledby?: string;
+    inputAttrs?: SliderInputAttrs;
 }
-export interface RangeSliderProps extends Omit<SliderProps, 'modelValue' | 'name' | 'ariaLabel' | 'ariaValueText'> {
+export interface RangeSliderProps extends Omit<SliderProps, 'modelValue' | 'name' | 'ariaLabel' | 'ariaValueText' | 'inputAttrs' | 'classNames' | 'styles'>, StylesApiProps<RangeSliderPart> {
     modelValue: RangeSliderValue;
     minRange?: number;
     name?: string | [string, string];
     ariaLabel?: [string, string];
     ariaValueText?: RangeSliderAriaValueText;
+    inputAttrs?: RangeSliderInputAttrs;
 }

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

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { RangeSliderProps, RangeSliderThumb, RangeSliderValue } from './types';
+import { RangeSliderProps, RangeSliderThumb, RangeSliderValue } from './types.js';
 type RangeSliderStateProps = Readonly<RangeSliderProps & {
     min: number;
     max: number;
@@ -13,7 +13,7 @@ export declare function normalizeRangeSliderMinRange(minRange: number, min: numb
 export declare function normalizeRangeSliderValue(value: RangeSliderValue, min: number, max: number, step: number | 'any', minRange?: number): RangeSliderValue;
 export declare function getClosestRangeSliderThumb(value: number, range: RangeSliderValue, activeThumb?: RangeSliderThumb): RangeSliderThumb;
 export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate: (value: RangeSliderValue) => void): {
-    control: import('../../composables/useControlState').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     nativeMin: import('vue').ComputedRef<RangeSliderValue>;
     nativeMax: import('vue').ComputedRef<RangeSliderValue>;
     nativeStep: import('vue').ComputedRef<number | "any">;
@@ -37,11 +37,11 @@ export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate:
     activeThumb: import('vue').Ref<RangeSliderThumb | undefined, RangeSliderThumb | undefined>;
     tooltipVisible: import('vue').ComputedRef<boolean>;
     tooltipOpen: import('vue').ComputedRef<boolean>;
-    tooltipPlacement: import('vue').ComputedRef<import('../tooltip').TooltipPlacement>;
+    tooltipPlacement: import('vue').ComputedRef<import('../tooltip/index.js').TooltipPlacement>;
     tooltipIds: import('vue').ComputedRef<[string | undefined, string | undefined]>;
     mergedTooltipId: import('vue').ComputedRef<string | undefined>;
-    tooltipColor: import('vue').ComputedRef<import('../../utils/componentColors').ComponentColorValue | undefined>;
-    tooltipOffset: import('vue').ComputedRef<import('../tooltip').TooltipOffset | undefined>;
+    tooltipColor: import('vue').ComputedRef<import('../../utils/componentColors.js').ComponentColorValue | undefined>;
+    tooltipOffset: import('vue').ComputedRef<import('../floating/index.js').FloatingOffset | undefined>;
     tooltipOpenDelay: import('vue').ComputedRef<number>;
     tooltipArrow: import('vue').ComputedRef<boolean>;
     tooltipContent: import('vue').ComputedRef<[string, string]>;
@@ -52,8 +52,6 @@ export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate:
     onTooltipBlur: (thumb: RangeSliderThumb) => void;
     onTooltipTrackMouseEnter: () => void;
     onTooltipTrackMouseLeave: () => void;
-    openTooltip: (thumb: RangeSliderThumb) => void;
-    closeTooltip: (thumb?: RangeSliderThumb) => void;
     onTooltipKeydown: (thumb: RangeSliderThumb, event: KeyboardEvent) => void;
 };
 export {};

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

@@ -0,0 +1,19 @@
+import { RangeSliderThumb } from './types.js';
+interface UseRangeSliderPointerOptions<TGeometry> {
+    disabled: () => boolean;
+    getPointerGeometry: (track: HTMLElement) => TGeometry | undefined;
+    getPointerValue: (event: PointerEvent, geometry: TGeometry) => number | undefined;
+    getThumb: (event: PointerEvent, value: number) => RangeSliderThumb;
+    getAnchorValue: (thumb: RangeSliderThumb) => number;
+    setActiveThumb: (thumb: RangeSliderThumb) => void;
+    focusThumb: (track: HTMLElement, thumb: RangeSliderThumb) => void;
+    updateThumb: (thumb: RangeSliderThumb, value: number, anchorValue: number) => RangeSliderThumb;
+    transferFocusedThumb: (track: HTMLElement, from: RangeSliderThumb, to: RangeSliderThumb) => void;
+    startDrag: (thumb: RangeSliderThumb) => void;
+    endDrag: (thumb: RangeSliderThumb) => void;
+    transferDrag: (from: RangeSliderThumb, to: RangeSliderThumb) => void;
+}
+export declare function useRangeSliderPointer<TGeometry>(options: UseRangeSliderPointerOptions<TGeometry>): {
+    onTrackPointerDown: (event: PointerEvent) => void;
+};
+export {};

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

@@ -1,7 +1,36 @@
-import { Ref } from 'vue';
+import { Ref, WatchSource } from 'vue';
+import { TooltipPlacement } from '../tooltip/types.js';
+import { RangeSliderValue, SliderOrientation } from './types.js';
 type TooltipRect = Pick<DOMRect, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width'>;
+export interface RangeSliderTooltipSize {
+    width: number;
+    height: number;
+}
+export interface RangeSliderTooltipCollisionLayout {
+    gap?: number;
+    lowerPercent: number;
+    lowerSize: RangeSliderTooltipSize;
+    orientation: SliderOrientation;
+    placement: TooltipPlacement;
+    trackLength: number;
+    upperPercent: number;
+    upperSize: RangeSliderTooltipSize;
+}
+interface UseRangeSliderTooltipCollisionOptions {
+    enabled: Ref<boolean>;
+    lower: Ref<HTMLElement | null>;
+    orientation: Ref<SliderOrientation>;
+    placement: Ref<TooltipPlacement>;
+    root: Ref<HTMLElement | null>;
+    sizeDependencies?: readonly WatchSource[];
+    upper: Ref<HTMLElement | null>;
+    valuePercent: Ref<RangeSliderValue>;
+}
 export declare function areRangeSliderTooltipRectsOverlapping(lower: TooltipRect, upper: TooltipRect, gap?: number): boolean;
-export declare function useRangeSliderTooltipCollision(root: Ref<HTMLElement | null>): {
+export declare function areRangeSliderTooltipLayoutsOverlapping({ gap, lowerPercent, lowerSize, orientation, placement, trackLength, upperPercent, upperSize, }: RangeSliderTooltipCollisionLayout): boolean;
+export declare function useRangeSliderTooltipCollision({ enabled, lower, orientation, placement, root, sizeDependencies, upper, valuePercent, }: UseRangeSliderTooltipCollisionOptions): {
     tooltipsOverlapping: Ref<boolean, boolean>;
+    mergedArrowOffset: import('vue').ComputedRef<number>;
+    mergedMinSize: import('vue').ComputedRef<number>;
 };
 export {};

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

@@ -0,0 +1,23 @@
+import { ComputedRef } from 'vue';
+import { RangeSliderThumb, SliderTooltipMode } from './types.js';
+export type RangeSliderTooltipInteractionReason = 'focus' | 'drag';
+interface UseRangeSliderTooltipStateOptions {
+    mode: ComputedRef<SliderTooltipMode | false>;
+    openDelay: ComputedRef<number>;
+    disabled: () => boolean;
+    setActiveThumb: (thumb: RangeSliderThumb) => void;
+}
+export declare function useRangeSliderTooltipState(options: UseRangeSliderTooltipStateOptions): {
+    visible: ComputedRef<boolean>;
+    alwaysVisible: ComputedRef<boolean>;
+    open: ComputedRef<boolean>;
+    startInteraction: (thumb: RangeSliderThumb, reason: RangeSliderTooltipInteractionReason) => void;
+    endInteraction: (thumb: RangeSliderThumb, reason: RangeSliderTooltipInteractionReason) => void;
+    transferInteraction: (from: RangeSliderThumb, to: RangeSliderThumb, reason: RangeSliderTooltipInteractionReason) => void;
+    onFocus: (thumb: RangeSliderThumb) => void;
+    onBlur: (thumb: RangeSliderThumb) => void;
+    onTrackMouseEnter: () => void;
+    onTrackMouseLeave: () => void;
+    onKeydown: (thumb: RangeSliderThumb, event: KeyboardEvent) => boolean;
+};
+export {};

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

@@ -1,5 +1,6 @@
 import { CSSProperties } from 'vue';
-import { SliderProps } from './types';
+import { SliderProps } from './types.js';
+export { getSliderValuePercent, normalizeSliderBounds, normalizeSliderStep, normalizeSliderValue, } from './sliderCore.js';
 type SliderStateProps = Readonly<SliderProps & {
     min: number;
     max: number;
@@ -7,15 +8,8 @@ type SliderStateProps = Readonly<SliderProps & {
     tooltip: NonNullable<SliderProps['tooltip']>;
     orientation: NonNullable<SliderProps['orientation']>;
 }>;
-export declare function normalizeSliderValue(value: number, min: number, max: number, step: number | 'any'): number;
-export declare function normalizeSliderBounds(min: number, max: number): {
-    min: number;
-    max: number;
-};
-export declare function normalizeSliderStep(step: number | 'any'): number | "any";
-export declare function getSliderValuePercent(value: number, min: number, max: number): number;
 export declare function useSlider(props: SliderStateProps, emitUpdate: (value: number) => void): {
-    control: import('../../composables/useControlState').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     nativeMin: import('vue').ComputedRef<number>;
     nativeMax: import('vue').ComputedRef<number>;
     nativeStep: import('vue').ComputedRef<number | "any">;
@@ -35,16 +29,18 @@ export declare function useSlider(props: SliderStateProps, emitUpdate: (value: n
     trackStyle: import('vue').ComputedRef<CSSProperties>;
     tooltipVisible: import('vue').ComputedRef<boolean>;
     tooltipOpen: import('vue').ComputedRef<boolean>;
-    tooltipPlacement: import('vue').ComputedRef<import('../tooltip').TooltipPlacement>;
+    tooltipPlacement: import('vue').ComputedRef<import('../tooltip/index.js').TooltipPlacement>;
     tooltipId: import('vue').ComputedRef<string | undefined>;
-    tooltipColor: import('vue').ComputedRef<import('../../utils/componentColors').ComponentColorValue | undefined>;
-    tooltipOffset: import('vue').ComputedRef<import('../tooltip').TooltipOffset | undefined>;
+    tooltipColor: import('vue').ComputedRef<import('../../utils/componentColors.js').ComponentColorValue | undefined>;
+    tooltipOffset: import('vue').ComputedRef<import('../floating/index.js').FloatingOffset | undefined>;
     tooltipOpenDelay: import('vue').ComputedRef<number>;
     tooltipArrow: import('vue').ComputedRef<boolean>;
     tooltipContent: import('vue').ComputedRef<string>;
     onInput: (e: Event) => void;
-    openTooltip: () => void;
-    closeTooltip: () => void;
+    onTooltipPointerDown: (event: PointerEvent) => void;
+    onTooltipMouseEnter: () => void;
+    onTooltipMouseLeave: () => void;
+    onTooltipFocusIn: () => void;
+    onTooltipFocusOut: () => void;
     onTooltipKeydown: (event: KeyboardEvent) => void;
 };
-export {};

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

@@ -1,2 +1,3 @@
-export { default as Switch } from './switch';
-export type { SwitchColor, SwitchProps, SwitchSize } from './types';
+export { default as Switch } from './switch.js';
+export { switchParts } from './types.js';
+export type { SwitchColor, SwitchPart, SwitchProps, SwitchSize } from './types.js';

package/dist/components/switch/index.js

@@ -1,2 +1,2 @@
-import { t as switch_default } from "../../switch.js";
-export { switch_default as Switch };
+import { n as switch_default, t as switchParts } from "../../switch.js";
+export { switch_default as Switch, switchParts };

package/dist/components/switch/switch.d.ts

@@ -1,11 +1,14 @@
-import { SwitchProps } from './types';
+import { SwitchProps } 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<SwitchProps & {
         "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: {}) => void;
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: (options?: FocusOptions) => void;
+    }>) => void;
     attrs: any;
     slots: {
         default?: (props: {}) => any;

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

@@ -1,7 +1,11 @@
-import { ComponentColorValue } from '../../utils/componentColors';
+import { InputHTMLAttributes } from 'vue';
+import { ComponentColorValue } from '../../utils/componentColors.js';
+import { StylesApiProps } from '../../styles-api.js';
+export declare const switchParts: readonly ["root", "input", "track", "thumb", "label"];
+export type SwitchPart = (typeof switchParts)[number];
 export type SwitchColor = ComponentColorValue;
 export type SwitchSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-export interface SwitchProps {
+export interface SwitchProps extends StylesApiProps<SwitchPart> {
     id?: string;
     name?: string;
     modelValue: boolean;
@@ -13,4 +17,5 @@ export interface SwitchProps {
     ariaLabel?: string;
     describedby?: string;
     labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
 }

package/dist/components/switch/useSwitch.d.ts

@@ -1,8 +1,10 @@
 import { CSSProperties } from 'vue';
-import { SwitchProps } from './types';
+import { SwitchProps } from './types.js';
 export declare function useSwitch(props: Readonly<SwitchProps>, emitUpdate: (value: boolean) => void): {
-    control: import('../../composables/useControlState').ControlState;
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    control: import('../../composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
     onChange: (e: Event) => void;
+    focus: (options?: FocusOptions) => void;
 };

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

@@ -1,6 +1,7 @@
-export { default as Tabs } from './tabs';
-export { default as TabsContent } from './tabs-content';
-export { default as TabsList } from './tabs-list';
-export { default as TabsTrigger } from './tabs-trigger';
-export { useTabs, useTabsContent, useTabsList, useTabsTrigger } from './useTabs';
-export type { TabsActivationMode, TabsContentProps, TabsContentRootProps, TabsContentSlotProps, TabsListProps, TabsListRootProps, TabsListSlotProps, TabsOrientation, TabsPlacement, TabsProps, TabsRootProps, TabsSlotProps, TabsState, TabsSize, TabsTriggerAlign, TabsTriggerProps, TabsTriggerRootProps, TabsTriggerSlotProps, TabsValue, TabsVariant, UseTabsContentReturn, UseTabsListReturn, UseTabsReturn, UseTabsTriggerReturn, } from './types';
+export { default as Tabs } from './tabs.js';
+export { default as TabsContent } from './tabs-content.js';
+export { default as TabsList } from './tabs-list.js';
+export { default as TabsTrigger } from './tabs-trigger.js';
+export { useTabs, useTabsContent, useTabsList, useTabsTrigger } from './useTabs.js';
+export { tabsContentParts, tabsListParts, tabsParts, tabsTriggerParts } from './types.js';
+export type { TabsActivationMode, TabsContentProps, TabsContentPart, TabsContentRootProps, TabsContentSlotProps, TabsListProps, TabsListPart, TabsListRootProps, TabsListSlotProps, TabsOrientation, TabsPart, TabsPlacement, TabsProps, TabsRootProps, TabsSlotProps, TabsState, TabsSize, TabsTriggerAlign, TabsTriggerPart, TabsTriggerProps, TabsTriggerRootProps, TabsTriggerSlotProps, TabsValue, TabsVariant, UseTabsContentReturn, UseTabsListReturn, UseTabsReturn, UseTabsTriggerReturn, } from './types.js';

package/dist/components/tabs/index.js

@@ -1,2 +1,2 @@
-import { a as useTabs, c as useTabsTrigger, i as tabs_default, n as tabs_list_default, o as useTabsContent, r as tabs_content_default, s as useTabsList, t as tabs_trigger_default } from "../../tabs.js";
-export { tabs_default as Tabs, tabs_content_default as TabsContent, tabs_list_default as TabsList, tabs_trigger_default as TabsTrigger, useTabs, useTabsContent, useTabsList, useTabsTrigger };
+import { a as tabs_trigger_default, c as tabs_default, d as useTabsList, f as useTabsTrigger, i as tabsTriggerParts, l as useTabs, n as tabsListParts, o as tabs_list_default, r as tabsParts, s as tabs_content_default, t as tabsContentParts, u as useTabsContent } from "../../tabs.js";
+export { tabs_default as Tabs, tabs_content_default as TabsContent, tabs_list_default as TabsList, tabs_trigger_default as TabsTrigger, tabsContentParts, tabsListParts, tabsParts, tabsTriggerParts, useTabs, useTabsContent, useTabsList, useTabsTrigger };

package/dist/components/tabs/tabs-content.d.ts

@@ -1,4 +1,4 @@
-import { TabsContentProps } from './types';
+import { TabsContentProps } 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<TabsContentProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -7,7 +7,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     attrs: any;
     slots: {
         default?: (props: {
-            value: import('./types').TabsValue;
+            value: import('./types.js').TabsValue;
             selected: boolean;
         }) => any;
     };