ropav 0.1.7 → 0.1.9

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

@@ -32,7 +32,7 @@ export declare function useScrollArea(props: Readonly<ScrollAreaProps>, emit: Sc
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
@@ -49,7 +49,7 @@ export declare function useScrollArea(props: Readonly<ScrollAreaProps>, emit: Sc
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
@@ -59,7 +59,7 @@ export declare function useScrollArea(props: Readonly<ScrollAreaProps>, emit: Sc
     verticalThumbAttrs: import('vue').ComputedRef<Pick<import('vue').HTMLAttributes, "class" | "style">>;
     cornerAttrs: import('vue').ComputedRef<{
         'aria-hidden': boolean;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
         style?: import('vue').StyleValue;
@@ -68,7 +68,7 @@ export declare function useScrollArea(props: Readonly<ScrollAreaProps>, emit: Sc
     onScrollbarKeydown: (axis: ScrollAxis, event: KeyboardEvent) => void;
     onScrollbarWheel: (axis: ScrollAxis, event: WheelEvent) => void;
     onScrollbarPointerdown: (axis: ScrollAxis, event: PointerEvent) => void;
-    onThumbPointerdown: (axis: ScrollAxis, event: PointerEvent) => void;
+    onThumbPointerdown: (axis: ScrollAxis, event: PointerEvent) => boolean;
     scrollTo: (scrollOptions: ScrollToOptions) => void;
     scrollBy: (scrollOptions: ScrollToOptions) => void;
     update: () => void;

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

@@ -25,7 +25,7 @@ export declare function useScrollAreaAttributes({ metrics, onViewportScroll, pro
     contentAttrs: import('vue').ComputedRef<HTMLAttributes>;
     cornerAttrs: import('vue').ComputedRef<{
         'aria-hidden': boolean;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
         style?: import('vue').StyleValue;
@@ -41,7 +41,7 @@ export declare function useScrollAreaAttributes({ metrics, onViewportScroll, pro
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;
@@ -60,7 +60,7 @@ export declare function useScrollAreaAttributes({ metrics, onViewportScroll, pro
         'aria-disabled': true | undefined;
         'aria-hidden': true | undefined;
         'data-orientation': string;
-        'data-direction': import('../../utils/dom/scroll.js').ScrollDirection;
+        'data-direction': import('../../utils/dom/direction.js').ElementDirection;
         'data-active': "" | undefined;
         'data-visible': "" | undefined;
         class?: import('vue').ClassValue;

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

@@ -14,6 +14,6 @@ interface UseScrollAreaPointerOptions {
 }
 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/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/useRangeSlider.d.ts

@@ -43,7 +43,7 @@ export declare function useRangeSlider(props: RangeSliderStateProps, onChange: (
     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;

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

@@ -42,7 +42,7 @@ export declare function useSlider(props: SliderStateProps, onChange: (value: num
     tooltipFormattedValue: import('vue').ComputedRef<string | number>;
     tooltipContent: import('vue').ComputedRef<string>;
     onInput: (event: Event) => void;
-    onTooltipPointerDown: (event: PointerEvent) => void;
+    onTrackPointerDown: (event: PointerEvent) => boolean;
     onTooltipPointerMove: (event: PointerEvent) => void;
     onTooltipTrackEnter: (event: PointerEvent) => void;
     onTooltipTrackLeave: () => void;

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

@@ -0,0 +1,15 @@
+import { ComputedRef, Ref } from 'vue';
+import { SliderBounds } from './sliderModel.js';
+import { SliderOrientation } from './types.js';
+interface UseSliderPointerOptions {
+    bounds: ComputedRef<SliderBounds>;
+    disabled: () => boolean;
+    inputRef: Ref<HTMLInputElement | null>;
+    orientation: () => SliderOrientation;
+    step: ComputedRef<number | 'any'>;
+    updateValue: (value: number) => void;
+}
+export declare function useSliderPointer(options: UseSliderPointerOptions): {
+    onPointerDown: (event: PointerEvent) => boolean;
+};
+export {};

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

@@ -30,4 +30,5 @@ export declare function useSliderValueState(props: SliderStateProps, onChange: (
     hasMarkLabels: import('vue').ComputedRef<boolean>;
     trackSlotProps: import('vue').ComputedRef<SliderTrackSlotProps>;
     onInput: (event: Event) => void;
+    updateValue: (value: number) => 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;
+};

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

@@ -0,0 +1,37 @@
+import { InputHTMLAttributes } from 'vue';
+import { StylesApiProps } from '../../styles-api.js';
+export type TagsInputValueValidator = (value: string) => boolean;
+export type TagsInputRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type TagsInputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface TagsInputTagSlotProps {
+    value: string;
+}
+export interface TagsInputProps extends StylesApiProps<TagsInputPart> {
+    id?: string;
+    name?: string;
+    form?: string;
+    modelValue?: string[];
+    defaultValue?: string[];
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    splitChars?: string[];
+    acceptValueOnBlur?: boolean;
+    validate?: TagsInputValueValidator;
+    size?: TagsInputSize;
+    radius?: TagsInputRadius;
+    placeholder?: string;
+    clearable?: boolean;
+    clearLabel?: string;
+    removeLabel?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+}
+export declare const tagsInputParts: readonly ["root", "tags", "tag", "tagLabel", "tagRemove", "input", "clear"];
+export type TagsInputPart = (typeof tagsInputParts)[number];

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

@@ -0,0 +1,23 @@
+import { ComputedRef, Ref, SelectHTMLAttributes } from 'vue';
+import { ControlState } from '../../internal/composables/useControlState.js';
+import { TagsInputProps } from './types.js';
+export interface TagsInputControl {
+    templateRefs: {
+        root: Ref<HTMLElement | null>;
+        input: Ref<HTMLInputElement | null>;
+        native: Ref<HTMLSelectElement | null>;
+    };
+    nativeSelectAttrs: ComputedRef<SelectHTMLAttributes>;
+    control: ControlState;
+    rootClass: ComputedRef<string[]>;
+    values: ComputedRef<string[]>;
+    searchValue: Ref<string>;
+    canClear: ComputedRef<boolean>;
+    removeTag: (index: number) => void;
+    clear: () => void;
+    focusInput: (event?: MouseEvent) => void;
+    onInput: (event: Event) => void;
+    onInputBlur: (event: FocusEvent) => void;
+    onInputKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useTagsInput(props: Readonly<TagsInputProps>, emitUpdate: (value: string[]) => void): TagsInputControl;

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

@@ -0,0 +1,3 @@
+export { default as Toolbar } from './toolbar.js';
+export { toolbarOrientations, toolbarParts } from './types.js';
+export type { ToolbarOrientation, ToolbarPart, ToolbarProps } from './types.js';

package/dist/components/toolbar/index.js

@@ -0,0 +1,2 @@
+import { n as toolbarParts, r as toolbar_default, t as toolbarOrientations } from "../../toolbar.js";
+export { toolbar_default as Toolbar, toolbarOrientations, toolbarParts };

package/dist/components/toolbar/toolbar.d.ts

@@ -0,0 +1,24 @@
+import { ToolbarProps } 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<ToolbarProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        nativeElement: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
+        focus: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => 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/toolbar/types.d.ts

@@ -0,0 +1,12 @@
+import { StylesApiProps } from '../../styles-api.js';
+export declare const toolbarParts: readonly ["root"];
+export declare const toolbarOrientations: readonly ["horizontal", "vertical"];
+export type ToolbarPart = (typeof toolbarParts)[number];
+export type ToolbarOrientation = (typeof toolbarOrientations)[number];
+export interface ToolbarProps extends StylesApiProps<ToolbarPart> {
+    id?: string;
+    orientation?: ToolbarOrientation;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+}

package/dist/components/toolbar/useToolbar.d.ts

@@ -0,0 +1,7 @@
+import { ShallowRef } from 'vue';
+import { ToolbarOrientation } from './types.js';
+export declare function useToolbar(root: ShallowRef<HTMLElement | null>, getOrientation: () => ToolbarOrientation): {
+    focus: () => void;
+    onFocusin: (event: FocusEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+};

package/dist/components/tooltip/useTooltipTargetBindings.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { FloatingTargetLifecycle } from '../floating/useFloatingTargetLifecycle.js';
+interface UseTooltipTargetBindingsOptions {
+    targetLifecycle: FloatingTargetLifecycle;
+    shouldDescribeContent: Readonly<Ref<boolean>>;
+    tooltipId: Readonly<Ref<string>>;
+    openTooltip: () => void;
+    closeTooltip: () => void;
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export declare function useTooltipTargetBindings({ targetLifecycle, shouldDescribeContent, tooltipId, openTooltip, closeTooltip, onKeydown, }: UseTooltipTargetBindingsOptions): void;
+export {};

package/dist/date-picker.css

@@ -0,0 +1,49 @@
+@layer ropav.components {
+.rp-date-picker[data-v-4508ba14] {
+    display: inline-flex;
+    max-width: 100%;
+    font-family: var(--rp-font-family);
+    vertical-align: middle;
+}
+.rp-date-picker[data-v-4508ba14] .rp-input {
+    width: 100%;
+    min-width: 180px;
+}
+.rp-date-picker__clear[data-v-4508ba14], .rp-date-picker__indicator[data-v-4508ba14] {
+    padding: 0;
+    font: inherit;
+    background: none;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    border-radius: var(--rp-radius-xs);
+    color: var(--rp-color-control-icon);
+    transition: color var(--rp-transition-fast), opacity var(--rp-transition-fast);
+}
+.rp-date-picker__clear[data-v-4508ba14]:hover:not(:disabled), .rp-date-picker__indicator[data-v-4508ba14]:hover:not(:disabled) {
+    color: var(--rp-color-control-fg);
+}
+.rp-date-picker__clear[data-v-4508ba14]:focus-visible, .rp-date-picker__indicator[data-v-4508ba14]:focus-visible {
+    outline: var(--rp-border-width-medium) solid var(--rp-color-focus-ring);
+    outline-offset: 2px;
+}
+.rp-date-picker__clear[data-v-4508ba14]:disabled, .rp-date-picker__indicator[data-v-4508ba14]:disabled {
+    cursor: not-allowed;
+    opacity: var(--rp-opacity-disabled);
+}
+.rp-date-picker__clear[data-v-4508ba14] >  svg, .rp-date-picker__indicator[data-v-4508ba14] >  svg {
+    width: 1em;
+    height: 1em;
+}
+.rp-date-picker__clear--hidden[data-v-4508ba14] {
+    visibility: hidden;
+    pointer-events: none;
+}
+.rp-popover__content.rp-date-picker__popover {
+    min-width: auto;
+    padding: var(--rp-spacing-3);
+}
+}