ropav 0.0.8 → 0.0.10

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

@@ -1,4 +1,4 @@
-import { OverlayProps } from './types';
+import { OverlayProps } 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<OverlayProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

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

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

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

package/dist/components/popover/index.js

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

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

@@ -1,4 +1,4 @@
-import { PopoverProps } from './types';
+import { PopoverProps } 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<PopoverProps & {
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
@@ -9,7 +9,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
     attrs: any;
     slots: {
         default?: (props: {
-            triggerProps: import('./types').PopoverTriggerProps;
+            triggerProps: import('./types.js').PopoverTriggerProps;
             isOpen: boolean;
             open: () => void;
             close: () => void;

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

@@ -1,5 +1,6 @@
 import { Ref } from 'vue';
-export type PopoverPlacement = 'top' | 'right' | 'bottom' | 'left';
+export declare const popoverPlacements: readonly ["top-start", "top", "top-end", "right-start", "right", "right-end", "bottom-start", "bottom", "bottom-end", "left-start", "left", "left-end"];
+export type PopoverPlacement = (typeof popoverPlacements)[number];
 export type PopoverTarget = string | HTMLElement | Ref<HTMLElement | null | undefined>;
 export interface PopoverOffsetOptions {
     mainAxis?: number;
@@ -40,4 +41,5 @@ export interface PopoverProps {
     ariaDescribedby?: string;
     closeOnOutsideClick?: boolean;
     closeOnEscape?: boolean;
+    keepMounted?: boolean;
 }

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

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { PopoverContentSlotProps, PopoverProps, PopoverSlotProps, PopoverTriggerProps } from './types';
+import { PopoverContentSlotProps, PopoverProps, PopoverSlotProps, PopoverTriggerProps } from './types.js';
 export declare function usePopover(props: Readonly<PopoverProps>, emitOpenChange?: (open: boolean) => void): {
     rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     popoverId: import('vue').ComputedRef<string>;
@@ -11,6 +11,7 @@ export declare function usePopover(props: Readonly<PopoverProps>, emitOpenChange
     ariaLabelledby: import('vue').ComputedRef<string | undefined>;
     ariaDescribedby: import('vue').ComputedRef<string | undefined>;
     shouldRenderContent: import('vue').ComputedRef<boolean>;
+    shouldShowContent: import('vue').ComputedRef<boolean>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentStyle: import('vue').ComputedRef<CSSProperties | undefined>;
     triggerProps: import('vue').ComputedRef<PopoverTriggerProps>;

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

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

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

@@ -1,4 +1,4 @@
-import { ProgressProps } from './types';
+import { ProgressProps } 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<ProgressProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

@@ -1,5 +1,5 @@
-import { ComponentColorValue } from '../../utils/componentColors';
-export declare const progressColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+import { ComponentColorValue } from '../../utils/componentColors.js';
+export declare const progressColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
 export declare const progressSizes: readonly ["xs", "sm", "md", "lg", "xl"];
 export declare const progressRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
 export type ProgressColor = ComponentColorValue;

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

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { ProgressProps } from './types';
+import { ProgressProps } from './types.js';
 type ProgressStateProps = Readonly<ProgressProps & {
     min: number;
     max: number;
@@ -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').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     rootStyle: import('vue').ComputedRef<CSSProperties>;
     isIndeterminate: import('vue').ComputedRef<boolean>;

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

@@ -1,3 +1,3 @@
-export { default as Radio } from './radio';
-export { default as RadioGroup } from './radio-group';
-export type { RadioColor, RadioGroupProps, RadioProps, RadioSize, RadioVariant } from './types';
+export { default as Radio } from './radio.js';
+export { default as RadioGroup } from './radio-group.js';
+export type { RadioColor, RadioGroupProps, RadioProps, RadioSize, RadioVariant } from './types.js';

package/dist/components/radio/radio-group.d.ts

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

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

@@ -1,4 +1,4 @@
-import { RadioProps } from './types';
+import { RadioProps } 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<RadioProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

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

@@ -1,5 +1,5 @@
 import { InjectionKey } from 'vue';
-import { ComponentColorValue } from '../../utils/componentColors';
+import { ComponentColorValue } from '../../utils/componentColors.js';
 export type RadioColor = ComponentColorValue;
 export type RadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type RadioVariant = 'solid' | 'outline';
@@ -7,6 +7,7 @@ export interface RadioProps {
     value: string | number;
     variant?: RadioVariant;
     color?: RadioColor;
+    autoContrast?: boolean;
     size?: RadioSize;
     disabled?: boolean;
 }
@@ -16,6 +17,7 @@ export interface RadioGroupProps {
     modelValue: string | number | null;
     variant?: RadioVariant;
     color?: RadioColor;
+    autoContrast?: boolean;
     size?: RadioSize;
     disabled?: boolean;
     required?: boolean;
@@ -31,6 +33,7 @@ export interface RadioGroupContext {
     required: boolean;
     variant?: RadioVariant;
     color?: RadioColor;
+    autoContrast?: boolean;
     size?: RadioSize;
     select: (value: string | number) => void;
 }

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

@@ -1,16 +1,14 @@
-import { RadioGroupContext, RadioGroupProps, RadioProps } from './types';
+import { CSSProperties } from 'vue';
+import { RadioGroupContext, RadioGroupProps, RadioProps } from './types.js';
 export declare function useRadio(props: Readonly<RadioProps>): {
     group: RadioGroupContext;
     isChecked: import('vue').ComputedRef<boolean>;
     isDisabled: import('vue').ComputedRef<boolean>;
     rootClass: import('vue').ComputedRef<string[]>;
-    rootStyle: import('vue').ComputedRef<{
-        '--_rp-radio-custom-color': string & {};
-        '--_rp-radio-custom-on-color': string;
-    } | undefined>;
+    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
     onSelect: () => 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,2 @@
-export { default as Select } from './select';
-export type { SelectProps, SelectOption } from './types';
+export { default as Select } from './select.js';
+export type { SelectOption, SelectProps, SelectRadius, SelectSize } from './types.js';

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

@@ -4,14 +4,17 @@ export interface SelectOption {
     disabled?: boolean;
 }
 export type SelectRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type SelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export interface SelectProps {
     id?: string;
     name?: string;
     modelValue: string | number | null;
     options?: SelectOption[];
+    size?: SelectSize;
     radius?: SelectRadius;
     placeholder?: string;
     clearable?: boolean;
+    clearLabel?: string;
     disabled?: boolean;
     required?: boolean;
     invalid?: boolean;

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

@@ -1,4 +1,4 @@
-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): {
     selectRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
@@ -6,7 +6,7 @@ export declare function useSelect(props: Readonly<SelectProps>, emitUpdate: (val
     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,3 +1,4 @@
-export { default as Slider } from './slider';
-export { sliderColors, sliderOrientations, sliderSizes } from './types';
-export type { SliderColor, SliderMark, SliderMarkColor, SliderMarkInput, SliderOrientation, SliderProps, SliderPresetColor, SliderSize, SliderThumbStyle, SliderTooltip, SliderTooltipMode, SliderTooltipOptions, SliderValueFormatter, } from './types';
+export { default as Slider } from './slider.js';
+export { default as RangeSlider } from './range-slider.js';
+export { sliderColors, sliderOrientations, sliderSizes } from './types.js';
+export type { RangeSliderAriaValueText, RangeSliderEndpointValueText, RangeSliderProps, RangeSliderThumb, RangeSliderValue, SliderColor, SliderMark, SliderMarkColor, SliderMarkInput, SliderOrientation, SliderProps, SliderPresetColor, SliderSize, SliderThumbStyle, SliderTooltip, SliderTooltipMode, SliderTooltipOptions, SliderValueFormatter, } from './types.js';

package/dist/components/slider/index.js

@@ -1,2 +1,2 @@
-import { i as sliderSizes, n as sliderColors, r as sliderOrientations, t as slider_default } from "../../slider.js";
-export { slider_default as Slider, sliderColors, sliderOrientations, sliderSizes };
+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 };

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

@@ -0,0 +1,34 @@
+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;
+    } & {
+        "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

@@ -0,0 +1,37 @@
+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;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    } & {
+        value?: (props: {
+            value: import('./types.js').RangeSliderValue;
+            formattedValue: [string | number, string | number];
+            percent: import('./types.js').RangeSliderValue;
+        }) => any;
+    } & {
+        thumb?: (props: {
+            thumb: "lower" | "upper";
+            index: number;
+            value: number;
+            formattedValue: string | number;
+            percent: number;
+        }) => any;
+    };
+    emit: (evt: "update:modelValue", value: [number, 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/slider/slider.d.ts

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

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: `--_rp-${string}`;
+    border: `--_rp-${string}`;
+    padding: `--_rp-${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: `--_rp-${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,12 +1,17 @@
-import { TooltipProps } from '../tooltip/types';
-export declare const sliderColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+import { TooltipProps } from '../tooltip/types.js';
+import { ComponentColorValue } from '../../utils/componentColors.js';
+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"];
 export type SliderPresetColor = (typeof sliderColors)[number];
-export type SliderColor = SliderPresetColor | (string & {});
+export type SliderColor = ComponentColorValue;
 export type SliderSize = (typeof sliderSizes)[number];
 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 RangeSliderEndpointValueText = string | SliderValueFormatter;
+export type RangeSliderAriaValueText = RangeSliderEndpointValueText | [RangeSliderEndpointValueText, RangeSliderEndpointValueText];
 export type SliderTooltipMode = 'hover' | 'always';
 export type SliderTooltipOptions = Pick<TooltipProps, 'id' | 'placement' | 'color' | 'offset' | 'openDelay' | 'arrow'> & {
     mode?: SliderTooltipMode;
@@ -40,11 +45,15 @@ export interface SliderProps {
     size?: SliderSize;
     orientation?: SliderOrientation;
     disabled?: boolean;
-    required?: boolean;
-    invalid?: boolean;
-    valid?: boolean;
     ariaLabel?: string;
     ariaValueText?: string | SliderValueFormatter;
     describedby?: string;
     labelledby?: string;
 }
+export interface RangeSliderProps extends Omit<SliderProps, 'modelValue' | 'name' | 'ariaLabel' | 'ariaValueText'> {
+    modelValue: RangeSliderValue;
+    minRange?: number;
+    name?: string | [string, string];
+    ariaLabel?: [string, string];
+    ariaValueText?: RangeSliderAriaValueText;
+}

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

@@ -0,0 +1,57 @@
+import { CSSProperties } from 'vue';
+import { RangeSliderProps, RangeSliderThumb, RangeSliderValue } from './types.js';
+type RangeSliderStateProps = Readonly<RangeSliderProps & {
+    min: number;
+    max: number;
+    step: number | 'any';
+    minRange: number;
+    tooltip: NonNullable<RangeSliderProps['tooltip']>;
+    orientation: NonNullable<RangeSliderProps['orientation']>;
+    ariaLabel: [string, string];
+}>;
+export declare function normalizeRangeSliderMinRange(minRange: number, min: number, max: number): number;
+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.js').ControlState;
+    nativeMin: import('vue').ComputedRef<RangeSliderValue>;
+    nativeMax: import('vue').ComputedRef<RangeSliderValue>;
+    nativeStep: import('vue').ComputedRef<number | "any">;
+    nativeNames: import('vue').ComputedRef<[string | undefined, string | undefined]>;
+    nativeIds: import('vue').ComputedRef<[string | undefined, string | undefined]>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    normalizedValue: import('vue').ComputedRef<RangeSliderValue>;
+    valuePercent: import('vue').ComputedRef<RangeSliderValue>;
+    formattedValue: import('vue').ComputedRef<[string | number, string | number]>;
+    ariaLabels: import('vue').ComputedRef<[string, string]>;
+    ariaValueText: import('vue').ComputedRef<[string | undefined, string | undefined]>;
+    markItems: import('vue').ComputedRef<{
+        key: string;
+        value: number;
+        label: string | number | undefined;
+        hasLabel: boolean;
+        filled: boolean;
+        style: CSSProperties;
+    }[]>;
+    trackStyle: import('vue').ComputedRef<CSSProperties>;
+    activeThumb: import('vue').Ref<RangeSliderThumb | undefined, RangeSliderThumb | undefined>;
+    tooltipVisible: import('vue').ComputedRef<boolean>;
+    tooltipOpen: import('vue').ComputedRef<boolean>;
+    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.js').ComponentColorValue | undefined>;
+    tooltipOffset: import('vue').ComputedRef<import('../tooltip/index.js').TooltipOffset | undefined>;
+    tooltipOpenDelay: import('vue').ComputedRef<number>;
+    tooltipArrow: import('vue').ComputedRef<boolean>;
+    tooltipContent: import('vue').ComputedRef<[string, string]>;
+    mergedTooltipContent: import('vue').ComputedRef<string>;
+    onInput: (thumb: RangeSliderThumb, event: Event) => void;
+    onTrackPointerDown: (event: PointerEvent) => void;
+    onTooltipFocus: (thumb: RangeSliderThumb) => void;
+    onTooltipBlur: (thumb: RangeSliderThumb) => void;
+    onTooltipTrackMouseEnter: () => void;
+    onTooltipTrackMouseLeave: () => 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

@@ -0,0 +1,36 @@
+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 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('../tooltip/index.js').TooltipOffset | 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,2 @@
-export { default as Switch } from './switch';
-export type { SwitchColor, SwitchProps, SwitchSize } from './types';
+export { default as Switch } from './switch.js';
+export type { SwitchColor, SwitchProps, SwitchSize } from './types.js';

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

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