ropav 0.1.6 → 0.1.8

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

@@ -0,0 +1,35 @@
+import { Ref } from 'vue';
+import { ScrollAxis } from '../../utils/dom/scroll.js';
+interface ScrollAreaMeasurementElements {
+    content: Ref<HTMLElement | null>;
+    horizontalScrollbar: Ref<HTMLElement | null>;
+    verticalScrollbar: Ref<HTMLElement | null>;
+    viewport: Ref<HTMLElement | null>;
+}
+interface UseScrollAreaMeasurementOptions {
+    elements: ScrollAreaMeasurementElements;
+    isAxisEnabled: (axis: ScrollAxis) => boolean;
+    minimumThumbSize: number;
+}
+export declare function useScrollAreaMeasurement({ elements, isAxisEnabled, minimumThumbSize, }: UseScrollAreaMeasurementOptions): {
+    metrics: {
+        direction: import('../../utils/dom/scroll.js').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;
+    };
+    schedulePositionUpdate: () => void;
+    scheduleUpdate: () => void;
+    update: () => void;
+    updatePosition: (viewport?: HTMLElement | null) => void;
+};
+export {};

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

@@ -1,17 +1,19 @@
 import { Ref } from 'vue';
-import { ScrollAxis } from './scrollAreaCore.js';
-import { ScrollAreaControlsController } from './useScrollAreaControls.js';
-import { ScrollAreaMetricsController } from './useScrollAreaMetrics.js';
+import { ScrollAxis } from '../../utils/dom/scroll.js';
+import { ScrollAreaAxisState } from './scrollAreaModel.js';
+interface ScrollAreaPointerElements {
+    horizontalScrollbar: Ref<HTMLElement | null>;
+    verticalScrollbar: Ref<HTMLElement | null>;
+}
 interface UseScrollAreaPointerOptions {
-    horizontalScrollbarRef: Ref<HTMLElement | null>;
-    verticalScrollbarRef: Ref<HTMLElement | null>;
-    metrics: ScrollAreaMetricsController;
-    controls: ScrollAreaControlsController;
+    elements: ScrollAreaPointerElements;
+    isEmbedded: () => boolean;
+    refreshAxis: (axis: ScrollAxis) => ScrollAreaAxisState;
     setDraggingAxis: (axis: ScrollAxis | null) => void;
-    shouldFocusScrollbar: () => boolean;
+    writeAxisPosition: (axis: ScrollAxis, position: number) => void;
 }
 export declare function useScrollAreaPointer(options: UseScrollAreaPointerOptions): {
     onScrollbarPointerdown: (axis: ScrollAxis, event: PointerEvent) => void;
-    onThumbPointerdown: (axis: ScrollAxis, event: PointerEvent) => void;
+    onThumbPointerdown: (axis: ScrollAxis, event: PointerEvent) => boolean;
 };
 export {};

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

@@ -1,27 +1,22 @@
 import { Ref } from 'vue';
-import { ScrollAxis } from './scrollAreaCore.js';
-import { ScrollAreaProps } from './types.js';
+import { ScrollAxis } from '../../utils/dom/scroll.js';
+import { ScrollAreaType } from './types.js';
 interface UseScrollAreaVisibilityOptions {
-    props: Readonly<ScrollAreaProps>;
-    rootRef: Ref<HTMLElement | null>;
-    horizontalEnabled: Readonly<Ref<boolean>>;
-    verticalEnabled: Readonly<Ref<boolean>>;
-    overflowX: () => boolean;
-    overflowY: () => boolean;
+    getHideDelay: () => number | undefined;
+    getType: () => ScrollAreaType;
+    isScrollbarActive: (axis: ScrollAxis) => boolean;
+    root: Ref<HTMLElement | null>;
 }
 export declare function useScrollAreaVisibility(options: UseScrollAreaVisibilityOptions): {
-    renderHorizontalScrollbar: import('vue').ComputedRef<boolean>;
-    renderVerticalScrollbar: import('vue').ComputedRef<boolean>;
-    horizontalScrollbarActive: import('vue').ComputedRef<boolean>;
-    verticalScrollbarActive: import('vue').ComputedRef<boolean>;
-    horizontalScrollbarVisible: import('vue').ComputedRef<boolean>;
-    verticalScrollbarVisible: import('vue').ComputedRef<boolean>;
-    showDuringScroll: () => void;
+    horizontalVisible: import('vue').ComputedRef<boolean>;
+    rootHandlers: {
+        onPointerenter(): void;
+        onPointerleave(): void;
+        onFocusin(): void;
+        onFocusout(event: FocusEvent): void;
+    };
     setDraggingAxis: (axis: ScrollAxis | null) => void;
-    onPointerenter: () => void;
-    onPointerleave: () => void;
-    onFocusin: () => void;
-    onFocusout: (event: FocusEvent) => void;
+    showDuringScroll: () => void;
+    verticalVisible: import('vue').ComputedRef<boolean>;
 };
-export type ScrollAreaVisibilityController = ReturnType<typeof useScrollAreaVisibility>;
 export {};

package/dist/components/segmented-control/index.d.ts

@@ -0,0 +1,3 @@
+export { default as SegmentedControl } from './segmented-control.js';
+export { segmentedControlColors, segmentedControlOrientations, segmentedControlParts, segmentedControlRadiuses, segmentedControlSizes, } from './types.js';
+export type { SegmentedControlColor, SegmentedControlOption, SegmentedControlOptionSlotProps, SegmentedControlOrientation, SegmentedControlPart, SegmentedControlProps, SegmentedControlRadius, SegmentedControlSize, SegmentedControlValue, } from './types.js';

package/dist/components/segmented-control/index.js

@@ -0,0 +1,2 @@
+import { a as segmentedControlSizes, i as segmentedControlRadiuses, n as segmentedControlOrientations, o as segmented_control_default, r as segmentedControlParts, t as segmentedControlColors } from "../../segmented-control.js";
+export { segmented_control_default as SegmentedControl, segmentedControlColors, segmentedControlOrientations, segmentedControlParts, segmentedControlRadiuses, segmentedControlSizes };

package/dist/components/segmented-control/segmented-control.d.ts

@@ -0,0 +1,26 @@
+import { SegmentedControlOptionSlotProps, SegmentedControlProps, SegmentedControlValue } 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<SegmentedControlProps & {
+        "onUpdate:modelValue"?: ((value: SegmentedControlValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElements: import('vue').ComputedRef<(HTMLInputElement | null)[]>;
+        focus: (options?: FocusOptions) => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?(props: SegmentedControlOptionSlotProps): unknown;
+    };
+    emit: (evt: "update:modelValue", value: SegmentedControlValue) => 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/segmented-control/types.d.ts

@@ -0,0 +1,47 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+import { ComponentColorValue } from '../../utils/componentColors.js';
+export declare const segmentedControlParts: readonly ["root", "control", "input", "indicator", "label"];
+export declare const segmentedControlColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
+export declare const segmentedControlSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const segmentedControlRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export declare const segmentedControlOrientations: readonly ["horizontal", "vertical"];
+export type SegmentedControlPart = (typeof segmentedControlParts)[number];
+export type SegmentedControlColor = ComponentColorValue;
+export type SegmentedControlSize = (typeof segmentedControlSizes)[number];
+export type SegmentedControlRadius = (typeof segmentedControlRadiuses)[number];
+export type SegmentedControlOrientation = (typeof segmentedControlOrientations)[number];
+export type SegmentedControlValue = string | number;
+export interface SegmentedControlOption {
+    label: string;
+    value: SegmentedControlValue;
+    disabled?: boolean;
+}
+export interface SegmentedControlOptionSlotProps {
+    option: SegmentedControlOption;
+    selected: boolean;
+    disabled: boolean;
+}
+export interface SegmentedControlProps extends StylesApiProps<SegmentedControlPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: SegmentedControlValue | null;
+    defaultValue?: SegmentedControlValue | null;
+    options?: SegmentedControlOption[];
+    color?: SegmentedControlColor;
+    autoContrast?: boolean;
+    contrastColor?: string;
+    size?: SegmentedControlSize;
+    radius?: SegmentedControlRadius;
+    orientation?: SegmentedControlOrientation;
+    fullWidth?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}

package/dist/components/segmented-control/useSegmentedControl.d.ts

@@ -0,0 +1,15 @@
+import { SegmentedControlOption, SegmentedControlProps, SegmentedControlValue } from './types.js';
+export declare function useSegmentedControl(props: Readonly<SegmentedControlProps>, emitUpdate: (value: SegmentedControlValue) => void): {
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    inputRefs: import('vue').ComputedRef<(HTMLInputElement | null)[]>;
+    selectedValue: import('vue').ComputedRef<SegmentedControlValue | null>;
+    rootClass: import('vue').ComputedRef<string[]>;
+    rootStyle: import('vue').ComputedRef<Record<string, string> | undefined>;
+    groupName: import('vue').ComputedRef<string>;
+    createInputRef: (value: SegmentedControlValue) => (element: unknown) => void;
+    isSelected: (option: SegmentedControlOption) => boolean;
+    isOptionDisabled: (option: SegmentedControlOption) => boolean;
+    selectOption: (option: SegmentedControlOption) => void;
+    getInputId: (index: number) => string;
+    focus: (options?: FocusOptions) => void;
+};

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

@@ -1,28 +1,40 @@
-import { Ref } from 'vue';
+import { CSSProperties, ComputedRef, Ref, SelectHTMLAttributes } from 'vue';
+import { ControlState } from '../../internal/composables/useControlState.js';
+import { FlatOptionState } from '../../internal/composables/useFlatOptionCollection.js';
+import { ComponentElementRef } from '../../utils/dom/componentRef.js';
+import { FloatingPlacement, FloatingSide } from '../floating/types.js';
 import { SelectOption, SelectProps } from './types.js';
 type SelectValue = string | number | null;
-type SelectBehaviorProps = Omit<SelectProps, 'classNames' | 'styles' | 'inputAttrs'>;
-export declare function useSelect(props: Readonly<SelectBehaviorProps>, emitUpdate: (value: SelectValue) => void, getValue?: () => SelectValue, triggerRef?: Ref<HTMLElement | null>): {
-    selectRef: Ref<HTMLElement | null, HTMLElement | null>;
-    triggerRef: Ref<HTMLElement | null, HTMLElement | null>;
-    isOpen: Ref<boolean, boolean>;
-    selectId: string;
+export interface SelectControl {
+    templateRefs: {
+        select: Ref<HTMLElement | null>;
+        trigger: Ref<HTMLElement | null>;
+        native: Ref<HTMLSelectElement | null>;
+    };
+    nativeInputAttrs: ComputedRef<SelectHTMLAttributes>;
+    isOpen: Ref<boolean>;
     popupId: string;
     listboxId: string;
-    control: import('../../internal/composables/useControlState.js').ControlState;
-    visibleOptions: import('vue').ComputedRef<SelectOption[]>;
-    focusedIndex: import('vue').ComputedRef<number>;
-    activeDescendantId: import('vue').ComputedRef<string | undefined>;
-    rootClass: import('vue').ComputedRef<string[]>;
-    hasValue: import('vue').ComputedRef<boolean>;
-    displayLabel: import('vue').ComputedRef<string>;
-    value: import('vue').ComputedRef<SelectValue>;
-    canClear: import('vue').ComputedRef<boolean>;
+    control: ControlState;
+    visibleOptions: ComputedRef<SelectOption[]>;
+    renderedOptions: ComputedRef<readonly FlatOptionState<SelectOption>[]>;
+    focusedIndex: ComputedRef<number>;
+    activeDescendantId: ComputedRef<string | undefined>;
+    rootClass: ComputedRef<string[]>;
+    floatingStyle: Readonly<Ref<CSSProperties>>;
+    actualPlacement: Readonly<Ref<FloatingPlacement>>;
+    placementSide: ComputedRef<FloatingSide>;
+    hasValue: ComputedRef<boolean>;
+    displayLabel: ComputedRef<string>;
+    selectedValue: ComputedRef<SelectValue>;
+    canClear: ComputedRef<boolean>;
+    setDropdownElement: (value: ComponentElementRef) => void;
     toggle: () => void;
     selectOption: (option: SelectOption) => void;
     clearSelection: () => void;
-    onOptionMouseenter: (option: SelectOption, index: number) => void;
+    onOptionMouseenter: (option: SelectOption) => void;
     onFocusout: (event: FocusEvent) => void;
-    onTriggerKeydown: (e: KeyboardEvent) => void;
-};
+    onTriggerKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useSelect(props: Readonly<SelectProps>, emitUpdate: (value: SelectValue) => void): SelectControl;
 export {};

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

@@ -0,0 +1,41 @@
+import { RangeSliderProps, RangeSliderThumb, RangeSliderValue } from './types.js';
+import { SliderBounds } from './sliderModel.js';
+export interface RangeSliderPointerGeometry {
+    length: number;
+    start: number;
+    vertical: boolean;
+}
+export interface RangeSliderPointerCoordinates {
+    clientX: number;
+    clientY: number;
+}
+interface RangeSliderThumbUpdateOptions {
+    thumb: RangeSliderThumb;
+    value: number;
+    currentValue: RangeSliderValue;
+    bounds: SliderBounds;
+    step: number | 'any';
+    minRange: number;
+    nativeMin: RangeSliderValue;
+    nativeMax: RangeSliderValue;
+    anchorValue?: number;
+}
+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 getRangeSliderNativeStep(bounds: SliderBounds, step: number | 'any'): number | "any";
+export declare function getRangeSliderNativeLimits(value: RangeSliderValue, bounds: SliderBounds, step: number | 'any', minRange: number): {
+    min: RangeSliderValue;
+    max: RangeSliderValue;
+};
+export declare function getRangeSliderThumbUpdate({ thumb, value, currentValue, bounds, step, minRange, nativeMin, nativeMax, anchorValue, }: RangeSliderThumbUpdateOptions): {
+    thumb: RangeSliderThumb;
+    value: RangeSliderValue;
+};
+export declare function getFormattedRangeSliderValue(value: RangeSliderValue, formatter: RangeSliderProps['formatValue']): [string | number, string | number];
+export declare function getRangeSliderAriaValueText(value: RangeSliderValue, ariaValueText: RangeSliderProps['ariaValueText'], formatter: RangeSliderProps['formatValue']): [string | undefined, string | undefined];
+export declare function getRangeSliderThumbIndex(thumb: RangeSliderThumb): 0 | 1;
+export declare function getOppositeRangeSliderThumb(thumb: RangeSliderThumb): RangeSliderThumb;
+export declare function getRangeSliderKeyboardValue(key: string, currentValue: number, step: number, min: number, max: number): number | undefined;
+export declare function getRangeSliderPointerValue(pointer: RangeSliderPointerCoordinates, geometry: RangeSliderPointerGeometry, bounds: SliderBounds): number;
+export {};

package/dist/components/slider/{sliderCore.d.ts → sliderModel.d.ts}

@@ -18,7 +18,6 @@ interface SliderThumbStyleProperties {
 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, thumb: RangeSliderThumbOptions | undefined, properties: SliderThumbStyleProperties): void;
 export declare function getSliderThumbOptions(thumb: SliderThumb): SliderThumbOptions;

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

@@ -1,18 +1,11 @@
 import { CSSProperties } from 'vue';
-import { RangeSliderProps, RangeSliderTrackSlotProps, 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, getValue?: () => RangeSliderValue): {
+import { RangeSliderThumb, RangeSliderValue } from './types.js';
+import { RangeSliderStateProps } from './useRangeSliderValueState.js';
+export { getClosestRangeSliderThumb, normalizeRangeSliderMinRange, normalizeRangeSliderValue, } from './rangeSliderModel.js';
+export declare function useRangeSlider(props: RangeSliderStateProps, onChange: (value: RangeSliderValue) => void): {
+    nativeElements: import('vue').ComputedRef<[HTMLInputElement | null, HTMLInputElement | null]>;
+    setInputRef: (index: number, element: unknown) => void;
+    focus: (options?: FocusOptions) => void;
     control: import('../../internal/composables/useControlState.js').ControlState;
     nativeMin: import('vue').ComputedRef<RangeSliderValue>;
     nativeMax: import('vue').ComputedRef<RangeSliderValue>;
@@ -33,7 +26,7 @@ export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate:
         filled: boolean;
         style: CSSProperties;
     }[]>;
-    trackSlotProps: import('vue').ComputedRef<RangeSliderTrackSlotProps>;
+    trackSlotProps: import('vue').ComputedRef<import('./types.js').RangeSliderTrackSlotProps>;
     trackStyle: import('vue').ComputedRef<CSSProperties>;
     activeThumb: import('vue').Ref<RangeSliderThumb | undefined, RangeSliderThumb | undefined>;
     tooltipVisible: import('vue').ComputedRef<boolean>;
@@ -50,11 +43,10 @@ export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate:
     tooltipContent: import('vue').ComputedRef<[string, string]>;
     mergedTooltipContent: import('vue').ComputedRef<string>;
     onInput: (thumb: RangeSliderThumb, event: Event) => void;
-    onTrackPointerDown: (event: PointerEvent) => void;
+    onTrackPointerDown: (event: PointerEvent) => boolean;
     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

@@ -14,6 +14,6 @@ interface UseRangeSliderPointerOptions<TGeometry> {
     transferDrag: (from: RangeSliderThumb, to: RangeSliderThumb) => void;
 }
 export declare function useRangeSliderPointer<TGeometry>(options: UseRangeSliderPointerOptions<TGeometry>): {
-    onTrackPointerDown: (event: PointerEvent) => void;
+    onTrackPointerDown: (event: PointerEvent) => boolean;
 };
 export {};

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

@@ -0,0 +1,40 @@
+import { RangeSliderProps, RangeSliderThumb, RangeSliderTrackSlotProps, RangeSliderValue } from './types.js';
+export 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 useRangeSliderValueState(props: RangeSliderStateProps, onChange: (value: RangeSliderValue) => void, setActiveThumb: (thumb: RangeSliderThumb) => void): {
+    nativeElements: import('vue').ComputedRef<[HTMLInputElement | null, HTMLInputElement | null]>;
+    setInputRef: (index: number, element: unknown) => void;
+    focus: (options?: FocusOptions) => void;
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    bounds: import('vue').ComputedRef<import('./sliderModel.js').SliderBounds>;
+    valueStep: import('vue').ComputedRef<number | "any">;
+    hasManualNativeKeyboard: import('vue').ComputedRef<boolean>;
+    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]>;
+    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: import('vue').CSSProperties;
+    }[]>;
+    hasMarkLabels: import('vue').ComputedRef<boolean>;
+    trackSlotProps: import('vue').ComputedRef<RangeSliderTrackSlotProps>;
+    updateThumb: (thumb: RangeSliderThumb, value: number, anchorValue?: number) => RangeSliderThumb;
+};

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

@@ -1,15 +1,9 @@
 import { CSSProperties } from 'vue';
-import { SliderProps, SliderTrackSlotProps } from './types.js';
-export { getSliderValuePercent, normalizeSliderBounds, normalizeSliderStep, normalizeSliderValue, } from './sliderCore.js';
-type SliderStateProps = Readonly<SliderProps & {
-    min: number;
-    max: number;
-    step: number | 'any';
-    tooltip: NonNullable<SliderProps['tooltip']>;
-    thumb: NonNullable<SliderProps['thumb']>;
-    orientation: NonNullable<SliderProps['orientation']>;
-}>;
-export declare function useSlider(props: SliderStateProps, emitUpdate: (value: number) => void, getValue?: () => number): {
+import { SliderStateProps } from './useSliderValueState.js';
+export { normalizeSliderBounds, normalizeSliderStep, normalizeSliderValue } from './sliderModel.js';
+export declare function useSlider(props: SliderStateProps, onChange: (value: number) => void): {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    focus: (options?: FocusOptions) => void;
     control: import('../../internal/composables/useControlState.js').ControlState;
     nativeMin: import('vue').ComputedRef<number>;
     nativeMax: import('vue').ComputedRef<number>;
@@ -28,7 +22,7 @@ export declare function useSlider(props: SliderStateProps, emitUpdate: (value: n
         style: CSSProperties;
     }[]>;
     thumbMode: import('vue').ComputedRef<false | import('./types.js').SliderThumbMode>;
-    trackSlotProps: import('vue').ComputedRef<SliderTrackSlotProps>;
+    trackSlotProps: import('vue').ComputedRef<import('./types.js').SliderTrackSlotProps>;
     trackStyle: import('vue').ComputedRef<CSSProperties>;
     trackHovered: import('vue').Ref<boolean, boolean>;
     dragging: import('vue').Ref<boolean, boolean>;
@@ -47,7 +41,7 @@ export declare function useSlider(props: SliderStateProps, emitUpdate: (value: n
     tooltipPercent: import('vue').ComputedRef<number>;
     tooltipFormattedValue: import('vue').ComputedRef<string | number>;
     tooltipContent: import('vue').ComputedRef<string>;
-    onInput: (e: Event) => void;
+    onInput: (event: Event) => void;
     onTooltipPointerDown: (event: PointerEvent) => void;
     onTooltipPointerMove: (event: PointerEvent) => void;
     onTooltipTrackEnter: (event: PointerEvent) => void;

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

@@ -0,0 +1,22 @@
+import { ComputedRef } from 'vue';
+import { SliderBounds } from './sliderModel.js';
+import { SliderOrientation } from './types.js';
+interface UseSliderPointerPreviewOptions {
+    enabled: () => boolean;
+    disabled: () => boolean;
+    orientation: () => SliderOrientation;
+    bounds: ComputedRef<SliderBounds>;
+    step: ComputedRef<number | 'any'>;
+    initialValue: number;
+    onStateChange: () => void;
+}
+export declare function useSliderPointerPreview(options: UseSliderPointerPreviewOptions): {
+    dragging: import('vue').Ref<boolean, boolean>;
+    previewAvailable: import('vue').Ref<boolean, boolean>;
+    previewValue: import('vue').Ref<number, number>;
+    onPointerDown: (event: PointerEvent) => boolean;
+    onPointerMove: (event: PointerEvent) => void;
+    onTrackEnter: (event: PointerEvent) => void;
+    onTrackLeave: () => void;
+};
+export {};

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

@@ -0,0 +1,40 @@
+import { ComputedRef } from 'vue';
+import { SliderBounds } from './sliderModel.js';
+import { SliderOrientation, SliderProps, SliderTooltip } from './types.js';
+interface UseSliderTooltipStateOptions {
+    tooltip: () => SliderTooltip;
+    orientation: () => SliderOrientation;
+    disabled: () => boolean;
+    value: ComputedRef<number>;
+    bounds: ComputedRef<SliderBounds>;
+    step: ComputedRef<number | 'any'>;
+    formatValue: () => SliderProps['formatValue'];
+}
+export declare function useSliderTooltipState(options: UseSliderTooltipStateOptions): {
+    trackHovered: import('vue').Ref<boolean, boolean>;
+    dragging: import('vue').Ref<boolean, boolean>;
+    tooltipVisible: ComputedRef<boolean>;
+    tooltipOpen: ComputedRef<boolean>;
+    tooltipAlwaysVisible: ComputedRef<boolean>;
+    tooltipAnchor: ComputedRef<import('./types.js').SliderTooltipAnchor>;
+    tooltipPlacement: ComputedRef<import('../tooltip/index.js').TooltipPlacement>;
+    tooltipId: ComputedRef<string | undefined>;
+    tooltipColor: ComputedRef<import('../../utils/componentColors.js').ComponentColorValue | undefined>;
+    tooltipAutoContrast: ComputedRef<boolean | undefined>;
+    tooltipContrastColor: ComputedRef<string | undefined>;
+    tooltipOffset: ComputedRef<import('../floating/index.js').FloatingOffset | undefined>;
+    tooltipOpenDelay: ComputedRef<number>;
+    tooltipArrow: ComputedRef<boolean>;
+    tooltipValue: ComputedRef<number>;
+    tooltipPercent: ComputedRef<number>;
+    tooltipFormattedValue: ComputedRef<string | number>;
+    tooltipContent: ComputedRef<string>;
+    onTooltipPointerDown: (event: PointerEvent) => void;
+    onTooltipPointerMove: (event: PointerEvent) => void;
+    onTooltipTrackEnter: (event: PointerEvent) => void;
+    onTooltipTrackLeave: () => void;
+    onTooltipFocusIn: () => void;
+    onTooltipFocusOut: () => void;
+    onTooltipKeydown: (event: KeyboardEvent) => void;
+};
+export {};

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

@@ -0,0 +1,33 @@
+import { SliderProps, SliderTrackSlotProps } from './types.js';
+export type SliderStateProps = Readonly<SliderProps & {
+    min: number;
+    max: number;
+    step: number | 'any';
+    tooltip: NonNullable<SliderProps['tooltip']>;
+    thumb: NonNullable<SliderProps['thumb']>;
+    orientation: NonNullable<SliderProps['orientation']>;
+}>;
+export declare function useSliderValueState(props: SliderStateProps, onChange: (value: number) => void): {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    focus: (options?: FocusOptions) => void;
+    control: import('../../internal/composables/useControlState.js').ControlState;
+    bounds: import('vue').ComputedRef<import('./sliderModel.js').SliderBounds>;
+    nativeMin: import('vue').ComputedRef<number>;
+    nativeMax: import('vue').ComputedRef<number>;
+    nativeStep: import('vue').ComputedRef<number | "any">;
+    normalizedValue: import('vue').ComputedRef<number>;
+    valuePercent: import('vue').ComputedRef<number>;
+    formattedValue: import('vue').ComputedRef<string | number>;
+    ariaValueText: import('vue').ComputedRef<string | undefined>;
+    markItems: import('vue').ComputedRef<{
+        key: string;
+        value: number;
+        label: string | number | undefined;
+        hasLabel: boolean;
+        filled: boolean;
+        style: import('vue').CSSProperties;
+    }[]>;
+    hasMarkLabels: import('vue').ComputedRef<boolean>;
+    trackSlotProps: import('vue').ComputedRef<SliderTrackSlotProps>;
+    onInput: (event: Event) => void;
+};

package/dist/components/tags-input/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TagsInput } from './tags-input.js';
+export { tagsInputParts } from './types.js';
+export type { TagsInputPart, TagsInputProps, TagsInputRadius, TagsInputSize, TagsInputTagSlotProps, TagsInputValueValidator, } from './types.js';

package/dist/components/tags-input/index.js

@@ -0,0 +1,2 @@
+import { n as tags_input_default, t as tagsInputParts } from "../../tags-input.js";
+export { tags_input_default as TagsInput, tagsInputParts };

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

@@ -0,0 +1,27 @@
+import { TagsInputProps, TagsInputTagSlotProps } 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<TagsInputProps & {
+        "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        inputElement: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        focus: () => void | undefined;
+    }>) => void;
+    attrs: any;
+    slots: {
+        tag?(props: TagsInputTagSlotProps): unknown;
+    };
+    emit: (evt: "update:modelValue", value: string[]) => 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/tags-input/tagsInputModel.d.ts

@@ -0,0 +1,12 @@
+import { TagsInputValueValidator } from './types.js';
+export interface AddTagsInputValuesOptions {
+    allowDuplicates: boolean;
+    maxTags?: number;
+    validate?: TagsInputValueValidator;
+}
+export declare function normalizeTagsInputValue(value: string): string;
+export declare function addTagsInputValues(values: readonly string[], candidates: readonly string[], options: AddTagsInputValuesOptions): string[];
+export declare function splitTagsInputValue(value: string, splitChars: readonly string[]): {
+    tags: string[];
+    remainder: string;
+};