reka-ui 0.0.0 → 0.0.2

package/dist/FocusScope/FocusScope.d.ts

@@ -0,0 +1,69 @@
+import { PrimitiveProps } from '../Primitive';
+
+export type FocusScopeEmits = {
+    /**
+     * Event handler called when auto-focusing on mount.
+     * Can be prevented.
+     */
+    mountAutoFocus: [event: Event];
+    /**
+     * Event handler called when auto-focusing on unmount.
+     * Can be prevented.
+     */
+    unmountAutoFocus: [event: Event];
+};
+export interface FocusScopeProps extends PrimitiveProps {
+    /**
+     * When `true`, tabbing from last item will focus first tabbable
+     * and shift+tab from first item will focus last tababble.
+     * @defaultValue false
+     */
+    loop?: boolean;
+    /**
+     * When `true`, focus cannot escape the focus scope via keyboard,
+     * pointer, or a programmatic focus.
+     * @defaultValue false
+     */
+    trapped?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FocusScopeProps>, {
+    loop: boolean;
+    trapped: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    mountAutoFocus: (event: Event) => void;
+    unmountAutoFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<FocusScopeProps>, {
+    loop: boolean;
+    trapped: boolean;
+}>>> & {
+    onMountAutoFocus?: ((event: Event) => any) | undefined;
+    onUnmountAutoFocus?: ((event: Event) => any) | undefined;
+}, {
+    loop: boolean;
+    trapped: 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/FocusScope/index.d.ts

@@ -0,0 +1 @@
+export { default as FocusScope, type FocusScopeEmits, type FocusScopeProps, } from './FocusScope';

package/dist/FocusScope/stack.d.ts

@@ -0,0 +1,12 @@
+interface FocusScopeAPI {
+    paused: boolean;
+    pause: () => void;
+    resume: () => void;
+}
+export declare function createFocusScopesStack(): {
+    add(focusScope: FocusScopeAPI): void;
+    remove(focusScope: FocusScopeAPI): void;
+};
+export declare function arrayRemove<T>(array: T[], item: T): T[];
+export declare function removeLinks(items: HTMLElement[]): HTMLElement[];
+export {};

package/dist/FocusScope/utils.d.ts

@@ -0,0 +1,46 @@
+export declare const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
+export declare const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
+export declare const EVENT_OPTIONS: {
+    bubbles: boolean;
+    cancelable: boolean;
+};
+type FocusableTarget = HTMLElement | {
+    focus: () => void;
+};
+/**
+ * Attempts focusing the first element in a list of candidates.
+ * Stops when focus has actually moved.
+ */
+export declare function focusFirst(candidates: HTMLElement[], { select }?: {
+    select?: boolean | undefined;
+}): true | undefined;
+/**
+ * Returns the first and last tabbable elements inside a container.
+ */
+export declare function getTabbableEdges(container: HTMLElement): readonly [HTMLElement | undefined, HTMLElement | undefined];
+/**
+ * Returns a list of potential tabbable candidates.
+ *
+ * NOTE: This is only a close approximation. For example it doesn't take into account cases like when
+ * elements are not visible. This cannot be worked out easily by just reading a property, but rather
+ * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.
+ *
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
+ * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
+ */
+export declare function getTabbableCandidates(container: HTMLElement): HTMLElement[];
+/**
+ * Returns the first visible element in a list.
+ * NOTE: Only checks visibility up to the `container`.
+ */
+export declare function findVisible(elements: HTMLElement[], container: HTMLElement): HTMLElement | undefined;
+export declare function isHidden(node: HTMLElement, { upTo }: {
+    upTo?: HTMLElement;
+}): boolean;
+export declare function isSelectableInput(element: any): element is FocusableTarget & {
+    select: () => void;
+};
+export declare function focus(element?: FocusableTarget | null, { select }?: {
+    select?: boolean | undefined;
+}): void;
+export {};

package/dist/HoverCard/HoverCardArrow.d.ts

@@ -0,0 +1,42 @@
+import { PopperArrowProps } from '../Popper';
+
+export interface HoverCardArrowProps extends PopperArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HoverCardArrowProps>, {
+    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<HoverCardArrowProps>, {
+    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/HoverCard/HoverCardContent.d.ts

@@ -0,0 +1,38 @@
+import { HoverCardContentImplEmits, HoverCardContentImplProps } from './HoverCardContentImpl';
+
+export type HoverCardContentEmits = HoverCardContentImplEmits;
+export interface HoverCardContentProps extends HoverCardContentImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<HoverCardContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<HoverCardContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+}, {}, {}>, {
+    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/HoverCard/HoverCardContentImpl.d.ts

@@ -0,0 +1,34 @@
+import { PopperContentProps } from '../Popper';
+import { DismissableLayerEmits } from '../DismissableLayer';
+
+export type HoverCardContentImplEmits = DismissableLayerEmits;
+export interface HoverCardContentImplProps extends PopperContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<HoverCardContentImplProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<HoverCardContentImplProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+}, {}, {}>, {
+    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/HoverCard/HoverCardPortal.d.ts

@@ -0,0 +1,22 @@
+import { TeleportProps } from '../Teleport';
+
+export interface HoverCardPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<HoverCardPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<HoverCardPortalProps>>>, {}, {}>, {
+    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/HoverCard/HoverCardRoot.d.ts

@@ -0,0 +1,81 @@
+import { Ref } from 'vue';
+
+export interface HoverCardRootProps {
+    /** The open state of the hover card when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: false;
+    /** The controlled open state of the hover card. Can be binded as `v-model:open`. */
+    open?: boolean;
+    /** The duration from when the mouse enters the trigger until the hover card opens. */
+    openDelay?: number;
+    /** The duration from when the mouse leaves the trigger or content until the hover card closes. */
+    closeDelay?: number;
+}
+export type HoverCardRootEmits = {
+    /** Event handler called when the open state of the hover card changes. */
+    'update:open': [value: boolean];
+};
+export interface HoverCardRootContext {
+    open: Ref<boolean>;
+    onOpenChange: (open: boolean) => void;
+    onOpen: () => void;
+    onClose: () => void;
+    onDismiss: () => void;
+    hasSelectionRef: Ref<boolean>;
+    isPointerDownOnContentRef: Ref<boolean>;
+    isPointerInTransitRef: Ref<boolean>;
+    triggerElement: Ref<HTMLElement | undefined>;
+}
+export declare const injectHoverCardRootContext: <T extends HoverCardRootContext | null | undefined = HoverCardRootContext>(fallback?: T | undefined) => T extends null ? HoverCardRootContext | null : HoverCardRootContext, provideHoverCardRootContext: (contextValue: HoverCardRootContext) => HoverCardRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HoverCardRootProps>, {
+    defaultOpen: boolean;
+    open: undefined;
+    openDelay: number;
+    closeDelay: number;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HoverCardRootProps>, {
+    defaultOpen: boolean;
+    open: undefined;
+    openDelay: number;
+    closeDelay: number;
+}>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {
+    defaultOpen: false;
+    open: boolean;
+    openDelay: number;
+    closeDelay: number;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: 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/HoverCard/HoverCardTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PopperAnchorProps } from '../Popper';
+
+export interface HoverCardTriggerProps extends PopperAnchorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HoverCardTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<HoverCardTriggerProps>, {
+    as: string;
+}>>>, {
+    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/HoverCard/index.d.ts

@@ -0,0 +1,5 @@
+export { default as HoverCardRoot, type HoverCardRootProps, type HoverCardRootEmits, } from './HoverCardRoot';
+export { default as HoverCardTrigger, type HoverCardTriggerProps, } from './HoverCardTrigger';
+export { default as HoverCardPortal, type HoverCardPortalProps, } from './HoverCardPortal';
+export { default as HoverCardContent, type HoverCardContentProps, } from './HoverCardContent';
+export { default as HoverCardArrow, type HoverCardArrowProps, } from './HoverCardArrow';

package/dist/HoverCard/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function excludeTouch(eventHandler: () => void): (event: PointerEvent) => void;
+/**
+ * Returns a list of nodes that can be in the tab sequence.
+ * @see: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
+ */
+export declare function getTabbableNodes(container: HTMLElement): HTMLElement[];

package/dist/Label/Label.d.ts

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface LabelProps extends PrimitiveProps {
+    /** The id of the element the label is associated with. */
+    for?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LabelProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<LabelProps>, {
+    as: string;
+}>>>, {
+    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/Label/index.d.ts

@@ -0,0 +1 @@
+export { default as Label, type LabelProps } from './Label';

package/dist/Listbox/ListboxContent.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '..';
+
+export interface ListboxContentProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ListboxContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ListboxContentProps>>>, {}, {}>, {
+    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/Listbox/ListboxFilter.d.ts

@@ -0,0 +1,57 @@
+import { PrimitiveProps } from '..';
+
+export interface ListboxFilterProps extends PrimitiveProps {
+    /** The controlled value of the filter. Can be binded-with with v-model. */
+    modelValue?: string;
+    /** Focus on element when mounted. */
+    autoFocus?: boolean;
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+}
+export type ListboxFilterEmits = {
+    'update:modelValue': [string];
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ListboxFilterProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (args_0: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ListboxFilterProps>, {
+    as: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+}, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current input values */
+        modelValue: string | undefined;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current input values */
+        modelValue: string | undefined;
+    }) => 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/Listbox/ListboxGroup.d.ts

@@ -0,0 +1,26 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ListboxGroupProps extends PrimitiveProps {
+}
+interface ListboxGroupContext {
+    id: string;
+}
+export declare const injectListboxGroupContext: <T extends ListboxGroupContext | null | undefined = ListboxGroupContext>(fallback?: T | undefined) => T extends null ? ListboxGroupContext | null : ListboxGroupContext, provideListboxGroupContext: (contextValue: ListboxGroupContext) => ListboxGroupContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ListboxGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ListboxGroupProps>>>, {}, {}>, {
+    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/Listbox/ListboxGroupLabel.d.ts

@@ -0,0 +1,37 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ListboxGroupLabelProps extends PrimitiveProps {
+    for?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ListboxGroupLabelProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ListboxGroupLabelProps>, {
+    as: string;
+}>>>, {
+    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/Listbox/ListboxItem.d.ts

@@ -0,0 +1,71 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '..';
+import { AcceptableValue } from '../shared/types';
+
+export interface ListboxItemProps<T = AcceptableValue> extends PrimitiveProps {
+    /** The value given as data when submitted with a `name`. */
+    value: T;
+    /** When `true`, prevents the user from interacting with the item. */
+    disabled?: boolean;
+}
+export type SelectEvent<T> = CustomEvent<{
+    originalEvent: PointerEvent;
+    value?: T;
+}>;
+export type ListboxItemEmits<T = AcceptableValue> = {
+    /** Event handler called when the selecting item. <br> It can be prevented by calling `event.preventDefault`. */
+    select: [event: SelectEvent<T>];
+};
+interface ListboxItemContext {
+    isSelected: Ref<boolean>;
+}
+export declare const injectListboxItemContext: <T extends ListboxItemContext | null | undefined = ListboxItemContext>(fallback?: T | undefined) => T extends null ? ListboxItemContext | null : ListboxItemContext, provideListboxItemContext: (contextValue: ListboxItemContext) => ListboxItemContext;
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    disabled?: boolean | undefined;
+    value: T;
+    onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive/Primitive').AsTag | import('vue').Component | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: {
+        default?(_: {}): any;
+    };
+    attrs: any;
+    emit: (evt: "select", event: SelectEvent<T>) => void;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        disabled?: boolean | undefined;
+        value: T;
+        onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive/Primitive').AsTag | import('vue').Component | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (evt: "select", event: SelectEvent<T>) => void;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            disabled?: boolean | undefined;
+            value: T;
+            onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive/Primitive').AsTag | import('vue').Component | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {}): any;
+        };
+        emit: (evt: "select", event: SelectEvent<T>) => void;
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};