reka-ui 0.0.0 → 0.0.2

package/dist/shared/component/Arrow.d.ts

@@ -0,0 +1,60 @@
+import { PrimitiveProps } from '../../Primitive';
+
+export interface ArrowProps extends PrimitiveProps {
+    /**
+     * The width of the arrow in pixels.
+     *
+     * @defaultValue 10
+     */
+    width?: number;
+    /**
+     * The height of the arrow in pixels.
+     *
+     * @defaultValue 5
+     */
+    height?: number;
+    /**
+     * When `true`, render the rounded version of arrow. Do not work with `as`/`asChild`
+     *
+     * @defaultValue false
+     */
+    rounded?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>>>, {
+    width: number;
+    height: number;
+    as: import('../../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    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/shared/component/BaseSeparator.d.ts

@@ -0,0 +1,48 @@
+import { DataOrientation } from '../types';
+import { PrimitiveProps } from '../../Primitive';
+
+export interface BaseSeparatorProps extends PrimitiveProps {
+    /**
+     * Orientation of the component.
+     *
+     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
+     */
+    orientation?: DataOrientation;
+    /**
+     * Whether or not the component is purely decorative. <br>When `true`, accessibility-related attributes
+     * are updated so that that the rendered element is removed from the accessibility tree.
+     */
+    decorative?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BaseSeparatorProps>, {
+    orientation: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BaseSeparatorProps>, {
+    orientation: string;
+}>>>, {
+    orientation: DataOrientation;
+}, {}>, {
+    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/shared/component/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Arrow } from './Arrow';
+export { default as BaseSeparator } from './BaseSeparator';

package/dist/shared/constant/countryList.d.ts

@@ -0,0 +1 @@
+export declare const countryList: string[];

package/dist/shared/constant/index.d.ts

@@ -0,0 +1 @@
+export * from './countryList';

package/dist/shared/createContext.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param providerComponentName - The name(s) of the component(s) providing the context.
+ *
+ * There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+ *
+ * @param contextName The description for injection key symbol.
+ */
+export declare function createContext<ContextValue>(providerComponentName: string | string[], contextName?: string): readonly [<T extends ContextValue | null | undefined = ContextValue>(fallback?: T) => T extends null ? ContextValue | null : ContextValue, (contextValue: ContextValue) => ContextValue];

package/dist/shared/date/comparators.d.ts

@@ -0,0 +1,20 @@
+import { DateValue } from '@internationalized/date';
+
+export type Granularity = 'day' | 'hour' | 'minute' | 'second';
+type GetDefaultDateProps = {
+    defaultValue?: DateValue | DateValue[] | undefined;
+    defaultPlaceholder?: DateValue | undefined;
+    granularity?: Granularity;
+};
+/**
+ * A helper function used throughout the various date builders
+ * to generate a default `DateValue` using the `defaultValue`,
+ * `defaultPlaceholder`, and `granularity` props.
+ *
+ * It's important to match the `DateValue` type being used
+ * elsewhere in the builder, so they behave according to the
+ * behavior the user expects based on the props they've provided.
+ *
+ */
+export declare function getDefaultDate(props: GetDefaultDateProps): DateValue;
+export {};

package/dist/shared/date/index.d.ts

@@ -0,0 +1,5 @@
+export { type Granularity, getDefaultDate, } from './comparators';
+export type { DateRange, DayOfWeek, HourCycle, DayPeriod, DateSegmentObj, TimeSegmentObj, DateAndTimeSegmentObj, SegmentValueObj, SegmentContentObj, SegmentPart, AnyExceptLiteral, DateSegmentPart, TimeSegmentPart, } from './types';
+export { getPlaceholder, type SupportedLocale } from './placeholders';
+export { DATE_SEGMENT_PARTS, TIME_SEGMENT_PARTS, NON_EDITABLE_SEGMENT_PARTS, EDITABLE_SEGMENT_PARTS, ALL_SEGMENT_PARTS, ALL_EXCEPT_LITERAL_PARTS, isAnySegmentPart, isSegmentPart, isDateSegmentPart, } from './parts';
+export { getOptsByGranularity, handleCalendarInitialFocus } from './utils';

package/dist/shared/date/parts.d.ts

@@ -0,0 +1,11 @@
+import { DateSegmentPart, EditableSegmentPart, SegmentPart } from './types';
+
+export declare const DATE_SEGMENT_PARTS: readonly ["day", "month", "year"];
+export declare const TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
+export declare const NON_EDITABLE_SEGMENT_PARTS: readonly ["literal", "timeZoneName"];
+export declare const EDITABLE_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod"];
+export declare const ALL_SEGMENT_PARTS: readonly ["day", "month", "year", "hour", "minute", "second", "dayPeriod", "literal", "timeZoneName"];
+export declare const ALL_EXCEPT_LITERAL_PARTS: ("day" | "hour" | "minute" | "second" | "month" | "year" | "dayPeriod" | "literal" | "timeZoneName")[];
+export declare function isDateSegmentPart(part: unknown): part is DateSegmentPart;
+export declare function isSegmentPart(part: string): part is EditableSegmentPart;
+export declare function isAnySegmentPart(part: unknown): part is SegmentPart;

package/dist/shared/date/placeholders.d.ts

@@ -0,0 +1,8 @@
+declare const supportedLocales: readonly ["ach", "af", "am", "an", "ar", "ast", "az", "be", "bg", "bn", "br", "bs", "ca", "cak", "ckb", "cs", "cy", "da", "de", "dsb", "el", "en", "eo", "es", "et", "eu", "fa", "ff", "fi", "fr", "fy", "ga", "gd", "gl", "he", "hr", "hsb", "hu", "ia", "id", "it", "ja", "ka", "kk", "kn", "ko", "lb", "lo", "lt", "lv", "meh", "ml", "ms", "nl", "nn", "no", "oc", "pl", "pt", "rm", "ro", "ru", "sc", "scn", "sk", "sl", "sr", "sv", "szl", "tg", "th", "tr", "uk", "zh-CN", "zh-TW"];
+declare const placeholderFields: readonly ["year", "month", "day"];
+type PlaceholderField = (typeof placeholderFields)[number];
+export type SupportedLocale = (typeof supportedLocales)[number];
+export type PlaceholderMap = Record<SupportedLocale, Record<PlaceholderField, string>>;
+type Field = 'era' | 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'dayPeriod';
+export declare function getPlaceholder(field: Field, value: string, locale: SupportedLocale | (string & {})): string;
+export {};

package/dist/shared/date/types.d.ts

@@ -0,0 +1,29 @@
+import { DateValue } from '@internationalized/date';
+import { DATE_SEGMENT_PARTS, EDITABLE_SEGMENT_PARTS, NON_EDITABLE_SEGMENT_PARTS, TIME_SEGMENT_PARTS } from './parts';
+
+declare const daysOfWeek: readonly [0, 1, 2, 3, 4, 5, 6];
+export type DayOfWeek = {
+    daysOfWeek: (typeof daysOfWeek)[number][];
+};
+export type DateRange = {
+    start: DateValue | undefined;
+    end: DateValue | undefined;
+};
+export type HourCycle = 12 | 24 | undefined;
+export type DateSegmentPart = (typeof DATE_SEGMENT_PARTS)[number];
+export type TimeSegmentPart = (typeof TIME_SEGMENT_PARTS)[number];
+export type EditableSegmentPart = (typeof EDITABLE_SEGMENT_PARTS)[number];
+export type NonEditableSegmentPart = (typeof NON_EDITABLE_SEGMENT_PARTS)[number];
+export type SegmentPart = EditableSegmentPart | NonEditableSegmentPart;
+export type AnyExceptLiteral = Exclude<SegmentPart, 'literal'>;
+export type DayPeriod = 'AM' | 'PM' | null;
+export type DateSegmentObj = {
+    [K in DateSegmentPart]: number | null;
+};
+export type TimeSegmentObj = {
+    [K in TimeSegmentPart]: K extends 'dayPeriod' ? DayPeriod : number | null;
+};
+export type DateAndTimeSegmentObj = DateSegmentObj & TimeSegmentObj;
+export type SegmentValueObj = DateSegmentObj | DateAndTimeSegmentObj;
+export type SegmentContentObj = Record<EditableSegmentPart, string>;
+export {};

package/dist/shared/date/utils.d.ts

@@ -0,0 +1,5 @@
+import { Granularity } from './comparators';
+import { HourCycle } from './types';
+
+export declare function getOptsByGranularity(granularity: Granularity, hourCycle: HourCycle): Intl.DateTimeFormatOptions;
+export declare function handleCalendarInitialFocus(calendar: HTMLElement): void;

package/dist/shared/handleAndDispatchCustomEvent.d.ts

@@ -0,0 +1,3 @@
+export declare function handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(name: string, handler: ((event: E) => void) | undefined, detail: {
+    originalEvent: OriginalEvent;
+} & (E extends CustomEvent<infer D> ? D : never)): void;

package/dist/shared/index.d.ts

@@ -0,0 +1,35 @@
+export { createContext } from './createContext';
+export { handleAndDispatchCustomEvent } from './handleAndDispatchCustomEvent';
+export { isValidVNodeElement } from './isValidVNodeElement';
+export { isValueEqualOrExist } from './isValueEqualOrExist';
+export * from './clamp';
+export * from './arrays';
+export * from './browser';
+export * from './object';
+export * from './nullish';
+export { type DateRange } from './date';
+export { onFocusOutside } from './onFocusOutside';
+export { renderSlotFragments } from './renderSlotFragments';
+export { trapFocus } from './trap-focus';
+export { useArrowNavigation } from './useArrowNavigation';
+export { useBodyScrollLock } from './useBodyScrollLock';
+export { useDateFormatter, type Formatter } from './useDateFormatter';
+export { useDirection } from './useDirection';
+export { useEmitAsProps } from './useEmitAsProps';
+export { useFilter } from './useFilter';
+export { useFocusGuards } from './useFocusGuards';
+export { useFormControl } from './useFormControl';
+export { useForwardProps } from './useForwardProps';
+export { useForwardPropsEmits } from './useForwardPropsEmits';
+export { useForwardExpose } from './useForwardExpose';
+export { useForwardRef } from './useForwardRef';
+export { useGraceArea } from './useGraceArea';
+export { useHideOthers } from './useHideOthers';
+export { useId } from './useId';
+export { useLocale } from './useLocale';
+export { useSelectionBehavior } from './useSelectionBehavior';
+export { useSize } from './useSize';
+export { useStateMachine } from './useStateMachine';
+export { useTypeahead } from './useTypeahead';
+export { withDefault } from './withDefault';
+export { useKbd, useTestKbd } from './useKbd';

package/dist/shared/isValidVNodeElement.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks whether a given VNode is a render-vialble element.
+ */
+export declare function isValidVNodeElement(input: any): boolean;

package/dist/shared/isValueEqualOrExist.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The function `isValueEqualOrExist` checks if a value is equal to or exists in another value or
+ * array.
+ * @param {T | T[] | undefined} base - It represents the base value that you want to compare with the `current` value.
+ * @param {T | T[] | undefined} current - The `current` parameter represents the current value that you want to compare with the `base` value or values.
+ * @returns The `isValueEqualOrExist` function returns a boolean value. It checks if the `base` value
+ * is equal to the `current` value or if the `current` value exists within the `base` value. The
+ * function handles cases where `base` can be a single value, an array of values, or undefined.
+ */
+export declare function isValueEqualOrExist<T>(base: T | T[] | undefined, current: T | T[] | undefined): boolean;

package/dist/shared/nullish.d.ts

@@ -0,0 +1 @@
+export declare function isNullish(value: any): boolean;

package/dist/shared/object.d.ts

@@ -0,0 +1,2 @@
+export declare function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
+export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;

package/dist/shared/onFocusOutside.d.ts

@@ -0,0 +1,3 @@
+import { MaybeElementRef } from '@vueuse/core';
+
+export declare function onFocusOutside(element: MaybeElementRef, handler: (event: FocusEvent) => void): void;

package/dist/shared/renderSlotFragments.d.ts

@@ -0,0 +1,3 @@
+import { VNode } from 'vue';
+
+export declare function renderSlotFragments(children?: VNode[]): VNode[];

package/dist/shared/trap-focus.d.ts

@@ -0,0 +1 @@
+export declare function trapFocus(element: HTMLElement): HTMLElement | undefined;

package/dist/shared/types.d.ts

@@ -0,0 +1,41 @@
+import { DefineComponent } from 'vue';
+type DataOrientation = 'vertical' | 'horizontal';
+type Direction = 'ltr' | 'rtl';
+/**
+ * @deprecated Use `AccordionType` instead
+ */
+type Type = 'single' | 'multiple';
+type SingleOrMultipleType = 'single' | 'multiple';
+interface SingleOrMultipleProps<ValidValue = AcceptableValue | AcceptableValue[], ExplicitType = SingleOrMultipleType> {
+    /**
+     * Determines whether a "single" or "multiple" items can be pressed at a time.
+     *
+     * This prop will be ignored if any of `v-model` or `defaultValue` is defined, as the type will be inferred from the value.
+     */
+    type?: ValidValue extends string ? 'single' : ValidValue extends string[] ? 'multiple' : ExplicitType extends 'single' ? 'single' : ExplicitType extends 'multiple' ? 'multiple' : never;
+    /**
+     * The controlled value of the active item(s).
+     *
+     * Use this when you need to control the state of the items. Can be binded with `v-model`
+     */
+    modelValue?: ValidValue;
+    /**
+     * The default active value of the item(s).
+     *
+     * Use when you do not need to control the state of the item(s).
+     */
+    defaultValue?: ValidValue;
+}
+type ScrollBodyOption = {
+    padding?: boolean | number;
+    margin?: boolean | number;
+};
+type AcceptableValue = string | number | Record<string, any>;
+type ArrayOrWrapped<T> = T extends any[] ? T : Array<T>;
+type StringOrNumber = string | number;
+type GenericComponentInstance<T> = T extends new (...args: any[]) => infer R ? R : T extends (...args: any[]) => infer R ? R extends {
+    __ctx?: infer K;
+} ? Exclude<K, void> extends {
+    expose: (...args: infer Y) => void;
+} ? Y[0] & InstanceType<DefineComponent> : any : any : any;
+export type { AcceptableValue, ArrayOrWrapped, DataOrientation, Direction, Type, SingleOrMultipleProps, SingleOrMultipleType, ScrollBodyOption, StringOrNumber, GenericComponentInstance };

package/dist/shared/useArrowNavigation.d.ts

@@ -0,0 +1,66 @@
+import { Direction } from './types';
+
+type ArrowKeyOptions = 'horizontal' | 'vertical' | 'both';
+interface ArrowNavigationOptions {
+    /**
+     * The arrow key options to allow navigation
+     *
+     * @defaultValue "both"
+     */
+    arrowKeyOptions?: ArrowKeyOptions;
+    /**
+     * The attribute name to find the collection items in the parent element.
+     *
+     * @defaultValue "data-reka-collection-item"
+     */
+    attributeName?: string;
+    /**
+     * The parent element where contains all the collection items, this will collect every item to be used when nav
+     * It will be ignored if attributeName is provided
+     *
+     * @defaultValue []
+     */
+    itemsArray?: HTMLElement[];
+    /**
+     * Allow loop navigation. If false, it will stop at the first and last element
+     *
+     * @defaultValue true
+     */
+    loop?: boolean;
+    /**
+     * The orientation of the collection
+     *
+     * @defaultValue "ltr"
+     */
+    dir?: Direction;
+    /**
+     * Prevent the scroll when navigating. This happens when the direction of the
+     * key matches the scroll direction of any ancestor scrollable elements.
+     *
+     * @defaultValue true
+     */
+    preventScroll?: boolean;
+    /**
+     * By default all currentElement would trigger navigation. If `true`, currentElement nodeName in the ignore list will return null
+     *
+     * @defaultValue false
+     */
+    enableIgnoredElement?: boolean;
+    /**
+     * Focus the element after navigation
+     *
+     * @defaultValue false
+     */
+    focus?: boolean;
+}
+/**
+ * Allow arrow navigation for every html element with data-reka-collection-item tag
+ *
+ * @param e               Keyboard event
+ * @param currentElement  Event initiator element or any element that wants to handle the navigation
+ * @param parentElement   Parent element where contains all the collection items, this will collect every item to be used when nav
+ * @param options         further options
+ * @returns               the navigated html element or null if none
+ */
+export declare function useArrowNavigation(e: KeyboardEvent, currentElement: HTMLElement, parentElement: HTMLElement | undefined, options?: ArrowNavigationOptions): HTMLElement | null;
+export {};

package/dist/shared/useBodyScrollLock.d.ts

@@ -0,0 +1 @@
+export declare function useBodyScrollLock(initialState?: boolean | undefined): import('vue').WritableComputedRef<boolean>;

package/dist/shared/useDateFormatter.d.ts

@@ -0,0 +1,31 @@
+import { DateValue } from '@internationalized/date';
+
+export interface DateFormatterOptions extends Intl.DateTimeFormatOptions {
+    calendar?: string;
+}
+export type Formatter = {
+    getLocale: () => string;
+    setLocale: (newLocale: string) => void;
+    custom: (date: Date, options: DateFormatterOptions) => string;
+    selectedDate: (date: DateValue, includeTime?: boolean) => string;
+    dayOfWeek: (date: Date, length?: DateFormatterOptions['weekday']) => string;
+    fullMonthAndYear: (date: Date, options?: DateFormatterOptions) => string;
+    fullMonth: (date: Date, options?: DateFormatterOptions) => string;
+    fullYear: (date: Date, options?: DateFormatterOptions) => string;
+    dayPeriod: (date: Date) => string;
+    part: (dateObj: DateValue, type: Intl.DateTimeFormatPartTypes, options?: DateFormatterOptions) => string;
+    toParts: (date: DateValue, options?: DateFormatterOptions) => Intl.DateTimeFormatPart[];
+    getMonths: () => {
+        label: string;
+        value: number;
+    }[];
+};
+/**
+ * Creates a wrapper around the `DateFormatter`, which is
+ * an improved version of the {@link Intl.DateTimeFormat} API,
+ * that is used internally by the various date builders to
+ * easily format dates in a consistent way.
+ *
+ * @see [DateFormatter](https://react-spectrum.adobe.com/internationalized/date/DateFormatter.html)
+ */
+export declare function useDateFormatter(initialLocale: string): Formatter;

package/dist/shared/useDirection.d.ts

@@ -0,0 +1,4 @@
+import { Direction } from './types';
+import { Ref } from 'vue';
+
+export declare function useDirection(dir?: Ref<Direction | undefined>): import('vue').ComputedRef<Direction>;

package/dist/shared/useEmitAsProps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `useEmitAsProps` function is a TypeScript utility that converts emitted events into props for a
+ * Vue component.
+ * @param emit - The `emit` parameter is a function that is used to emit events from a component. It
+ * takes two parameters: `name` which is the name of the event to be emitted, and `...args` which are
+ * the arguments to be passed along with the event.
+ * @returns The function `useEmitAsProps` returns an object that maps event names to functions that
+ * call the `emit` function with the corresponding event name and arguments.
+ */
+export declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args: any[]) => void): Record<string, any>;

package/dist/shared/useFilter.d.ts

@@ -0,0 +1,7 @@
+import { MaybeRef } from 'vue';
+
+export declare function useFilter(options?: MaybeRef<Intl.CollatorOptions>): {
+    startsWith: (string: string, substring: string) => boolean;
+    endsWith: (string: string, substring: string) => boolean;
+    contains: (string: string, substring: string) => boolean;
+};

package/dist/shared/useFocusGuards.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Injects a pair of focus guards at the edges of the whole DOM tree
+ * to ensure `focusin` & `focusout` events can be caught consistently.
+ */
+export declare function useFocusGuards(): void;

package/dist/shared/useFormControl.d.ts

@@ -0,0 +1,3 @@
+import { MaybeElementRef } from '@vueuse/core';
+
+export declare function useFormControl(el: MaybeElementRef): import('vue').ComputedRef<boolean>;

package/dist/shared/useForwardExpose.d.ts

@@ -0,0 +1,7 @@
+import { ComponentPublicInstance } from 'vue';
+
+export declare function useForwardExpose<T extends ComponentPublicInstance>(): {
+    forwardRef: (ref: Element | T | null) => void;
+    currentRef: import('vue').Ref<Element | T | null | undefined>;
+    currentElement: import('vue').ComputedRef<HTMLElement>;
+};

package/dist/shared/useForwardProps.d.ts

@@ -0,0 +1,10 @@
+import { MaybeRefOrGetter } from 'vue';
+
+/**
+ * The `useForwardProps` function in TypeScript takes in a set of props and returns a computed value
+ * that combines default props with assigned props from the current instance.
+ * @param {T} props - The `props` parameter is an object that represents the props passed to a
+ * component.
+ * @returns computed value that combines the default props, preserved props, and assigned props.
+ */
+export declare function useForwardProps<T extends Record<string, any>>(props: MaybeRefOrGetter<T>): import('vue').ComputedRef<T>;

package/dist/shared/useForwardPropsEmits.d.ts

@@ -0,0 +1,15 @@
+import { MaybeRefOrGetter } from 'vue';
+
+/**
+ * The function `useForwardPropsEmits` takes in props and an optional emit function, and returns a
+ * computed object that combines the parsed props and emits as props.
+ * @param {T} props - The `props` parameter is of type `T`, which is a generic type that extends the
+ * parameters of the `useForwardProps` function. It represents the props object that is passed to the
+ * `useForwardProps` function.
+ * @param [emit] - The `emit` parameter is a function that can be used to emit events. It takes two
+ * arguments: `name`, which is the name of the event to be emitted, and `args`, which are the arguments
+ * to be passed along with the event.
+ * @returns a computed property that combines the parsed
+ * props and emits as props.
+ */
+export declare function useForwardPropsEmits<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit?: (name: Name, ...args: any[]) => void): import('vue').ComputedRef<T & Record<string, any>>;

package/dist/shared/useForwardRef.d.ts

@@ -0,0 +1,3 @@
+import { ComponentPublicInstance } from 'vue';
+
+export declare function useForwardRef(): (ref: Element | ComponentPublicInstance | null) => void;

package/dist/shared/useGraceArea.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+
+export declare function useGraceArea(triggerElement: Ref<HTMLElement | undefined>, containerElement: Ref<HTMLElement | undefined>): {
+    isPointerInTransit: Ref<boolean>;
+    onPointerExit: import('@vueuse/shared').EventHookOn<void>;
+};

package/dist/shared/useHideOthers.d.ts

@@ -0,0 +1,10 @@
+import { MaybeElementRef } from '@vueuse/core';
+
+/**
+ * The `useHideOthers` function is a TypeScript function that takes a target element reference and
+ * hides all other elements in ARIA when the target element is present, and restores the visibility of the
+ * hidden elements when the target element is removed.
+ * @param {MaybeElementRef} target - The `target` parameter is a reference to the element that you want
+ * to hide other elements when it is clicked or focused.
+ */
+export declare function useHideOthers(target: MaybeElementRef): void;

package/dist/shared/useId.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `useId` function generates a unique identifier using a provided deterministic ID or a default
+ * one prefixed with "reka-", or the provided one via `useId` props from `<ConfigProvider>`.
+ * @param {string | null | undefined} [deterministicId] - The `useId` function you provided takes an
+ * optional parameter `deterministicId`, which can be a string, null, or undefined. If
+ * `deterministicId` is provided, the function will return it. Otherwise, it will generate an id using
+ * the `useId` function obtained
+ * @returns The `useId` function is being returned. If a `deterministicId` is provided, it will be
+ * returned. Otherwise, the `useId` function from the `injectConfigProviderContext` is called to
+ * generate an id in the format `reka-` and returned.
+ */
+export declare function useId(deterministicId?: string | null | undefined, prefix?: string): string;

package/dist/shared/useKbd.d.ts

@@ -0,0 +1,78 @@
+export declare function useKbd(): {
+    ALT: string;
+    ARROW_DOWN: string;
+    ARROW_LEFT: string;
+    ARROW_RIGHT: string;
+    ARROW_UP: string;
+    BACKSPACE: string;
+    CAPS_LOCK: string;
+    CONTROL: string;
+    DELETE: string;
+    END: string;
+    ENTER: string;
+    ESCAPE: string;
+    F1: string;
+    F10: string;
+    F11: string;
+    F12: string;
+    F2: string;
+    F3: string;
+    F4: string;
+    F5: string;
+    F6: string;
+    F7: string;
+    F8: string;
+    F9: string;
+    HOME: string;
+    META: string;
+    PAGE_DOWN: string;
+    PAGE_UP: string;
+    SHIFT: string;
+    SPACE: string;
+    TAB: string;
+    CTRL: string;
+    ASTERISK: string;
+    SPACE_CODE: string;
+};
+/**
+ * A wrapper around the internal kbd object to make it easier to use in tests
+ * which require the key names to be wrapped in curly braces.
+ */
+export type KbdKeys = keyof ReturnType<typeof useKbd>;
+export declare function useTestKbd(): {
+    SHIFT_TAB: string;
+    F1: string;
+    F10: string;
+    F11: string;
+    F12: string;
+    F2: string;
+    F3: string;
+    F4: string;
+    F5: string;
+    F6: string;
+    F7: string;
+    F8: string;
+    F9: string;
+    ALT: string;
+    ARROW_DOWN: string;
+    ARROW_LEFT: string;
+    ARROW_RIGHT: string;
+    ARROW_UP: string;
+    BACKSPACE: string;
+    CAPS_LOCK: string;
+    CONTROL: string;
+    DELETE: string;
+    END: string;
+    ENTER: string;
+    ESCAPE: string;
+    HOME: string;
+    META: string;
+    PAGE_DOWN: string;
+    PAGE_UP: string;
+    SHIFT: string;
+    SPACE: string;
+    TAB: string;
+    CTRL: string;
+    ASTERISK: string;
+    SPACE_CODE: string;
+};

package/dist/shared/useLocale.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+
+export declare function useLocale(locale?: Ref<string | undefined>): import('vue').ComputedRef<string>;