reka-ui 0.0.0 → 0.0.2

package/dist/RangeCalendar/RangeCalendarRoot.d.ts

@@ -0,0 +1,217 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Formatter } from '../shared';
+import { Grid, Matcher, WeekDayFormat } from '../date';
+import { DateRange } from '../shared/date';
+import { Direction } from '../shared/types';
+
+type RangeCalendarRootContext = {
+    modelValue: Ref<DateRange>;
+    startValue: Ref<DateValue | undefined>;
+    endValue: Ref<DateValue | undefined>;
+    locale: Ref<string>;
+    placeholder: Ref<DateValue>;
+    pagedNavigation: Ref<boolean>;
+    preventDeselect: Ref<boolean>;
+    weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    weekdayFormat: Ref<WeekDayFormat>;
+    fixedWeeks: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    initialFocus: Ref<boolean>;
+    onPlaceholderChange: (date: DateValue) => void;
+    fullCalendarLabel: Ref<string>;
+    parentElement: Ref<HTMLElement | undefined>;
+    headingValue: Ref<string>;
+    isInvalid: Ref<boolean>;
+    isDateDisabled: Matcher;
+    isDateUnavailable?: Matcher;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    highlightedRange: Ref<{
+        start: DateValue;
+        end: DateValue;
+    } | null>;
+    focusedValue: Ref<DateValue | undefined>;
+    lastPressedDateValue: Ref<DateValue | undefined>;
+    isSelected: (date: DateValue) => boolean;
+    isSelectionEnd: (date: DateValue) => boolean;
+    isSelectionStart: (date: DateValue) => boolean;
+    isHighlightedStart: (date: DateValue) => boolean;
+    isHighlightedEnd: (date: DateValue) => boolean;
+    prevPage: (prevPageFunc?: (date: DateValue) => DateValue) => void;
+    nextPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (prevPageFunc?: (date: DateValue) => DateValue) => boolean;
+    formatter: Formatter;
+    dir: Ref<Direction>;
+};
+export interface RangeCalendarRootProps extends PrimitiveProps {
+    /** The default placeholder date */
+    defaultPlaceholder?: DateValue;
+    /** The default value for the calendar */
+    defaultValue?: DateRange;
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateRange;
+    /** The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view */
+    placeholder?: DateValue;
+    /** This property causes the previous and next buttons to navigate by the number of months displayed at once, rather than one month */
+    pagedNavigation?: boolean;
+    /** Whether or not to prevent the user from deselecting a date without selecting another date first */
+    preventDeselect?: boolean;
+    /** The day of the week to start the calendar on */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** The format to use for the weekday strings provided via the weekdays slot prop */
+    weekdayFormat?: WeekDayFormat;
+    /** The accessible label for the calendar */
+    calendarLabel?: string;
+    /** Whether or not to always display 6 weeks in the calendar */
+    fixedWeeks?: boolean;
+    /** The maximum date that can be selected */
+    maxValue?: DateValue;
+    /** The minimum date that can be selected */
+    minValue?: DateValue;
+    /** The locale to use for formatting dates */
+    locale?: string;
+    /** The number of months to display at once */
+    numberOfMonths?: number;
+    /** Whether or not the calendar is disabled */
+    disabled?: boolean;
+    /** Whether or not the calendar is readonly */
+    readonly?: boolean;
+    /** If true, the calendar will focus the selected day, today, or the first day of the month depending on what is visible when the calendar is mounted */
+    initialFocus?: boolean;
+    /** A function that returns whether or not a date is disabled */
+    isDateDisabled?: Matcher;
+    /** A function that returns whether or not a date is unavailable */
+    isDateUnavailable?: Matcher;
+    /** The reading direction of the calendar when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** A function that returns the next page of the calendar. It receives the current placeholder as an argument inside the component. */
+    nextPage?: (placeholder: DateValue) => DateValue;
+    /** A function that returns the previous page of the calendar. It receives the current placeholder as an argument inside the component. */
+    prevPage?: (placeholder: DateValue) => DateValue;
+}
+export type RangeCalendarRootEmits = {
+    /** Event handler called whenever the model value changes */
+    'update:modelValue': [date: DateRange];
+    /** Event handler called whenever the placeholder value changes */
+    'update:placeholder': [date: DateValue];
+    /** Event handler called whenever the start value changes */
+    'update:startValue': [date: DateValue | undefined];
+};
+export declare const injectRangeCalendarRootContext: <T extends RangeCalendarRootContext | null | undefined = RangeCalendarRootContext>(fallback?: T | undefined) => T extends null ? RangeCalendarRootContext | null : RangeCalendarRootContext, provideRangeCalendarRootContext: (contextValue: RangeCalendarRootContext) => RangeCalendarRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RangeCalendarRootProps>, {
+    defaultValue: () => {
+        start: undefined;
+        end: undefined;
+    };
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (date: DateRange) => void;
+    "update:placeholder": (date: DateValue) => void;
+    "update:startValue": (date: DateValue | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RangeCalendarRootProps>, {
+    defaultValue: () => {
+        start: undefined;
+        end: undefined;
+    };
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((date: DateRange) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+    "onUpdate:startValue"?: ((date: DateValue | undefined) => any) | undefined;
+}, {
+    defaultValue: DateRange;
+    disabled: boolean;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    initialFocus: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+}, {}>, Readonly<{
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/RangeCalendar/index.d.ts

@@ -0,0 +1,12 @@
+export { default as RangeCalendarRoot, type RangeCalendarRootProps, type RangeCalendarRootEmits } from './RangeCalendarRoot';
+export { default as RangeCalendarHeader, type RangeCalendarHeaderProps } from './RangeCalendarHeader';
+export { default as RangeCalendarHeading, type RangeCalendarHeadingProps } from './RangeCalendarHeading';
+export { default as RangeCalendarGrid, type RangeCalendarGridProps } from './RangeCalendarGrid';
+export { default as RangeCalendarCell, type RangeCalendarCellProps } from './RangeCalendarCell';
+export { default as RangeCalendarHeadCell, type RangeCalendarHeadCellProps } from './RangeCalendarHeadCell';
+export { default as RangeCalendarNext, type RangeCalendarNextProps } from './RangeCalendarNext';
+export { default as RangeCalendarPrev, type RangeCalendarPrevProps } from './RangeCalendarPrev';
+export { default as RangeCalendarGridHead, type RangeCalendarGridHeadProps } from './RangeCalendarGridHead';
+export { default as RangeCalendarGridBody, type RangeCalendarGridBodyProps } from './RangeCalendarGridBody';
+export { default as RangeCalendarGridRow, type RangeCalendarGridRowProps } from './RangeCalendarGridRow';
+export { default as RangeCalendarCellTrigger, type RangeCalendarCellTriggerProps } from './RangeCalendarCellTrigger';

package/dist/RangeCalendar/useRangeCalendar.d.ts

@@ -0,0 +1,23 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { Matcher } from '../date';
+
+export type UseRangeCalendarProps = {
+    start: Ref<DateValue | undefined>;
+    end: Ref<DateValue | undefined>;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+    focusedValue: Ref<DateValue | undefined>;
+};
+export declare function useRangeCalendarState(props: UseRangeCalendarProps): {
+    isInvalid: import('vue').ComputedRef<boolean>;
+    isSelected: (date: DateValue) => boolean;
+    highlightedRange: import('vue').ComputedRef<{
+        start: DateValue;
+        end: DateValue;
+    } | null>;
+    isSelectionStart: (date: DateValue) => boolean;
+    isSelectionEnd: (date: DateValue) => boolean;
+    isHighlightedStart: (date: DateValue) => boolean;
+    isHighlightedEnd: (date: DateValue) => boolean;
+};

package/dist/RovingFocus/RovingFocusGroup.d.ts

@@ -0,0 +1,87 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Direction, Orientation } from './utils';
+
+export interface RovingFocusGroupProps extends PrimitiveProps {
+    /**
+     * The orientation of the group.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     */
+    orientation?: Orientation;
+    /**
+     * The direction of navigation between items.
+     */
+    dir?: Direction;
+    /**
+     * Whether keyboard navigation should loop around
+     * @defaultValue false
+     */
+    loop?: boolean;
+    currentTabStopId?: string | null;
+    defaultCurrentTabStopId?: string;
+    preventScrollOnEntryFocus?: boolean;
+}
+export type RovingFocusGroupEmits = {
+    'entryFocus': [event: Event];
+    'update:currentTabStopId': [value: string | null | undefined];
+};
+interface RovingContext {
+    orientation: Ref<Orientation | undefined>;
+    dir: Ref<Direction>;
+    loop: Ref<boolean>;
+    currentTabStopId: Ref<string | null | undefined>;
+    onItemFocus: (tabStopId: string) => void;
+    onItemShiftTab: () => void;
+    onFocusableItemAdd: () => void;
+    onFocusableItemRemove: () => void;
+}
+export declare const injectRovingFocusGroupContext: <T extends RovingContext | null | undefined = RovingContext>(fallback?: T | undefined) => T extends null ? RovingContext | null : RovingContext, provideRovingFocusGroupContext: (contextValue: RovingContext) => RovingContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RovingFocusGroupProps>, {
+    loop: boolean;
+    orientation: undefined;
+    preventScrollOnEntryFocus: boolean;
+}>, {
+    getItems: (includeDisabledItem?: boolean) => {
+        ref: HTMLElement;
+        value?: any;
+    }[];
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    entryFocus: (event: Event) => void;
+    "update:currentTabStopId": (value: string | null | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RovingFocusGroupProps>, {
+    loop: boolean;
+    orientation: undefined;
+    preventScrollOnEntryFocus: boolean;
+}>>> & {
+    onEntryFocus?: ((event: Event) => any) | undefined;
+    "onUpdate:currentTabStopId"?: ((value: string | null | undefined) => any) | undefined;
+}, {
+    loop: boolean;
+    orientation: Orientation;
+    preventScrollOnEntryFocus: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/RovingFocus/RovingFocusItem.d.ts

@@ -0,0 +1,46 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface RovingFocusItemProps extends PrimitiveProps {
+    tabStopId?: string;
+    focusable?: boolean;
+    active?: boolean;
+    allowShiftKey?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RovingFocusItemProps>, {
+    focusable: boolean;
+    active: boolean;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RovingFocusItemProps>, {
+    focusable: boolean;
+    active: boolean;
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    focusable: boolean;
+    active: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/RovingFocus/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RovingFocusGroup, type RovingFocusGroupProps, type RovingFocusGroupEmits, } from './RovingFocusGroup';
+export { default as RovingFocusItem, type RovingFocusItemProps, } from './RovingFocusItem';

package/dist/RovingFocus/utils.d.ts

@@ -0,0 +1,18 @@
+export type Orientation = 'horizontal' | 'vertical';
+export type Direction = 'ltr' | 'rtl';
+export declare const ENTRY_FOCUS = "rovingFocusGroup.onEntryFocus";
+export declare const EVENT_OPTIONS: {
+    bubbles: boolean;
+    cancelable: boolean;
+};
+export declare const MAP_KEY_TO_FOCUS_INTENT: Record<string, FocusIntent>;
+export declare function getDirectionAwareKey(key: string, dir?: Direction): string;
+type FocusIntent = 'first' | 'last' | 'prev' | 'next';
+export declare function getFocusIntent(event: KeyboardEvent, orientation?: Orientation, dir?: Direction): FocusIntent | undefined;
+export declare function focusFirst(candidates: HTMLElement[], preventScroll?: boolean): void;
+/**
+ * Wraps an array around itself at a given start index
+ * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
+ */
+export declare function wrapArray<T>(array: T[], startIndex: number): T[];
+export {};

package/dist/ScrollArea/ScrollAreaCorner.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ScrollAreaCornerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ScrollAreaCornerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ScrollAreaCornerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ScrollArea/ScrollAreaCornerImpl.d.ts

@@ -0,0 +1,9 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ScrollArea/ScrollAreaRoot.d.ts

@@ -0,0 +1,82 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Direction, ScrollType } from './types';
+
+export interface ScrollAreaRootContext {
+    type: Ref<ScrollType>;
+    dir: Ref<Direction>;
+    scrollHideDelay: Ref<number>;
+    scrollArea: Ref<HTMLElement | undefined>;
+    viewport: Ref<HTMLElement | undefined>;
+    onViewportChange: (viewport: HTMLElement | null) => void;
+    content: Ref<HTMLElement | undefined>;
+    onContentChange: (content: HTMLElement) => void;
+    scrollbarX: Ref<HTMLElement | undefined>;
+    onScrollbarXChange: (scrollbar: HTMLElement | null) => void;
+    scrollbarXEnabled: Ref<boolean>;
+    onScrollbarXEnabledChange: (rendered: boolean) => void;
+    scrollbarY: Ref<HTMLElement | undefined>;
+    onScrollbarYChange: (scrollbar: HTMLElement | null) => void;
+    scrollbarYEnabled: Ref<boolean>;
+    onScrollbarYEnabledChange: (rendered: boolean) => void;
+    onCornerWidthChange: (width: number) => void;
+    onCornerHeightChange: (height: number) => void;
+}
+export declare const injectScrollAreaRootContext: <T extends ScrollAreaRootContext | null | undefined = ScrollAreaRootContext>(fallback?: T | undefined) => T extends null ? ScrollAreaRootContext | null : ScrollAreaRootContext, provideScrollAreaRootContext: (contextValue: ScrollAreaRootContext) => ScrollAreaRootContext;
+export interface ScrollAreaRootProps extends PrimitiveProps {
+    /**
+     * Describes the nature of scrollbar visibility, similar to how the scrollbar preferences in MacOS control visibility of native scrollbars.
+     *
+     * `auto` - means that scrollbars are visible when content is overflowing on the corresponding orientation. <br>
+     * `always` - means that scrollbars are always visible regardless of whether the content is overflowing.<br>
+     * `scroll` - means that scrollbars are visible when the user is scrolling along its corresponding orientation.<br>
+     * `hover` - when the user is scrolling along its corresponding orientation and when the user is hovering over the scroll area.
+     */
+    type?: ScrollType;
+    /** The reading direction of the combobox when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** If type is set to either `scroll` or `hover`, this prop determines the length of time, in milliseconds, <br> before the scrollbars are hidden after the user stops interacting with scrollbars. */
+    scrollHideDelay?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ScrollAreaRootProps>, {
+    type: string;
+    scrollHideDelay: number;
+}>, {
+    /** Viewport element within ScrollArea */
+    viewport: Ref<HTMLElement | undefined>;
+    /** Scroll viewport to top */
+    scrollTop: () => void;
+    /** Scroll viewport to top-left */
+    scrollTopLeft: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ScrollAreaRootProps>, {
+    type: string;
+    scrollHideDelay: number;
+}>>>, {
+    type: ScrollType;
+    scrollHideDelay: number;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ScrollArea/ScrollAreaScrollbar.d.ts

@@ -0,0 +1,55 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+export interface ScrollAreaScrollbarProps extends PrimitiveProps {
+    /** The orientation of the scrollbar */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+export interface ScrollAreaScollbarContext {
+    as: Ref<PrimitiveProps['as']>;
+    orientation: Ref<'vertical' | 'horizontal'>;
+    forceMount?: Ref<boolean>;
+    isHorizontal: Ref<boolean>;
+    asChild: Ref<boolean>;
+}
+export declare const injectScrollAreaScrollbarContext: <T extends ScrollAreaScollbarContext | null | undefined = ScrollAreaScollbarContext>(fallback?: T | undefined) => T extends null ? ScrollAreaScollbarContext | null : ScrollAreaScollbarContext, provideScrollAreaScrollbarContext: (contextValue: ScrollAreaScollbarContext) => ScrollAreaScollbarContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarProps>, {
+    orientation: string;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarProps>, {
+    orientation: string;
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    orientation: "vertical" | "horizontal";
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ScrollArea/ScrollAreaScrollbarAuto.d.ts

@@ -0,0 +1,21 @@
+export interface ScrollAreaScrollbarAutoProps {
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarAutoProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarAutoProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ScrollArea/ScrollAreaScrollbarHover.d.ts

@@ -0,0 +1,22 @@
+import { ScrollAreaScrollbarAutoProps } from './ScrollAreaScrollbarAuto';
+
+export interface ScrollAreaScrollbarHoverProps extends ScrollAreaScrollbarAutoProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarHoverProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ScrollAreaScrollbarHoverProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};