ropav 0.1.6 → 0.1.7

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/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>;
@@ -57,4 +50,3 @@ export declare function useRangeSlider(props: RangeSliderStateProps, emitUpdate:
     onTooltipTrackMouseLeave: () => void;
     onTooltipKeydown: (thumb: RangeSliderThumb, event: KeyboardEvent) => void;
 };
-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/teleport-provider/index.js

@@ -1,3 +1,3 @@
-import { r as useTeleportTarget } from "../../useTeleportTarget.js";
+import { n as useTeleportTarget } from "../../useTeleportTarget.js";
 import { t as teleport_provider_default } from "../../teleport-provider.js";
 export { teleport_provider_default as TeleportProvider, useTeleportTarget };

package/dist/components/teleport-provider/useTeleportTarget.d.ts

@@ -1,6 +1,5 @@
 import { ComputedRef, MaybeRefOrGetter } from 'vue';
 import { TeleportTarget, TeleportTargetValue } from '../floating/types.js';
 import { TeleportProviderProps } from './types.js';
-export declare function provideTeleportTarget(props: Readonly<TeleportProviderProps>, positioningKey?: MaybeRefOrGetter<unknown>): ComputedRef<TeleportTargetValue>;
+export declare function provideTeleportTarget(props: Readonly<TeleportProviderProps>): ComputedRef<TeleportTargetValue>;
 export declare function useTeleportTarget(target?: MaybeRefOrGetter<TeleportTarget | null | undefined>): ComputedRef<TeleportTargetValue>;
-export declare function useTeleportPositioningKey(): ComputedRef<unknown>;

package/dist/components/toast/useToastLifecycle.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from 'vue';
+import { ToastCloseReason } from './types.js';
+interface UseToastLifecycleOptions {
+    isOpen: MaybeRefOrGetter<boolean>;
+    duration: MaybeRefOrGetter<number>;
+    pauseOnHover: MaybeRefOrGetter<boolean>;
+    pauseOnFocus: MaybeRefOrGetter<boolean>;
+    requestClose: (reason: ToastCloseReason) => void;
+}
+export declare function useToastLifecycle(options: Readonly<UseToastLifecycleOptions>): {
+    close: (reason: ToastCloseReason) => void;
+    rootEvents: {
+        onMouseenter: () => void;
+        onMouseleave: () => void;
+        onFocusin: () => void;
+        onFocusout: (event: FocusEvent) => void;
+    };
+};
+export {};

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

@@ -1,7 +1,6 @@
 import { CSSProperties } from 'vue';
-import { TooltipOffset, TooltipProps, TooltipTriggerProps } from './types.js';
+import { TooltipProps, TooltipTriggerProps } from './types.js';
 type TooltipBehaviorProps = Omit<TooltipProps, 'classNames' | 'styles'>;
-export declare function resolveTooltipOffsetStyle(offset: TooltipOffset | undefined): CSSProperties | undefined;
 export declare function resolveTooltipColorStyleWithContrast(color: TooltipProps['color'], autoContrast: TooltipProps['autoContrast'], contrastColor?: TooltipProps['contrastColor']): CSSProperties | undefined;
 export declare function useTooltip(props: Readonly<TooltipBehaviorProps>, emitOpenChange?: (open: boolean) => void): {
     rootRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;

package/dist/css.js

@@ -0,0 +1,12 @@
+//#region src/utils/css.ts
+function toCssLength(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? `${value}px` : void 0;
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function toPositiveCssLength(value) {
+	if (typeof value === "number" && value <= 0) return void 0;
+	return toCssLength(value);
+}
+//#endregion
+export { toPositiveCssLength as n, toCssLength as t };