reka-ui 0.0.0 → 0.0.2

package/dist/Listbox/ListboxItemIndicator.d.ts

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

@@ -0,0 +1,231 @@
+import { EventHook } from '@vueuse/core';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { AcceptableValue, DataOrientation, Direction } from '../shared/types';
+
+type ListboxRootContext<T> = {
+    modelValue: Ref<T | Array<T> | undefined>;
+    onValueChange: (val: T) => void;
+    multiple: Ref<boolean>;
+    orientation: Ref<DataOrientation>;
+    dir: Ref<Direction>;
+    disabled: Ref<boolean>;
+    highlightOnHover: Ref<boolean>;
+    highlightedElement: Ref<HTMLElement | null>;
+    isVirtual: Ref<boolean>;
+    virtualFocusHook: EventHook<Event | null>;
+    virtualKeydownHook: EventHook<KeyboardEvent>;
+    virtualHighlightHook: EventHook<any>;
+    by?: string | ((a: T, b: T) => boolean);
+    firstValue?: Ref<T | undefined>;
+    selectionBehavior?: Ref<'toggle' | 'replace'>;
+    focusable: Ref<boolean>;
+    onLeave: (event: Event) => void;
+    onEnter: (event: Event) => void;
+    changeHighlight: (el: HTMLElement) => void;
+    onKeydownNavigation: (event: KeyboardEvent) => void;
+    onKeydownEnter: (event: KeyboardEvent) => void;
+    onKeydownTypeAhead: (event: KeyboardEvent) => void;
+    highlightFirstItem: (event: InputEvent) => void;
+};
+export declare const injectListboxRootContext: <T extends ListboxRootContext<AcceptableValue> | null | undefined = ListboxRootContext<AcceptableValue>>(fallback?: T | undefined) => T extends null ? ListboxRootContext<AcceptableValue> | null : ListboxRootContext<AcceptableValue>, provideListboxRootContext: (contextValue: ListboxRootContext<AcceptableValue>) => ListboxRootContext<AcceptableValue>;
+export interface ListboxRootProps<T = AcceptableValue> extends PrimitiveProps {
+    /** The controlled value of the listbox. Can be binded-with with `v-model`. */
+    modelValue?: T | Array<T>;
+    /** The value of the listbox when initially rendered. Use when you do not need to control the state of the Listbox */
+    defaultValue?: T | Array<T>;
+    /** Whether multiple options can be selected or not. */
+    multiple?: boolean;
+    /** The orientation of the listbox. <br>Mainly so arrow navigation is done accordingly (left & right vs. up & down) */
+    orientation?: DataOrientation;
+    /** The reading direction of the listbox when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** When `true`, prevents the user from interacting with listbox */
+    disabled?: boolean;
+    /**
+     * How multiple selection should behave in the collection.
+     * @defaultValue 'toggle'
+     */
+    selectionBehavior?: 'toggle' | 'replace';
+    /** When `true`, hover over item will trigger highlight */
+    highlightOnHover?: boolean;
+    /** Use this to compare objects by a particular field, or pass your own comparison function for complete control over how objects are compared. */
+    by?: string | ((a: T, b: T) => boolean);
+    /** The name of the listbox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /** When `true`, indicates that the user must set the value before the owning form can be submitted. */
+    required?: boolean;
+}
+export type ListboxRootEmits<T = AcceptableValue> = {
+    /** Event handler called when the value changes. */
+    'update:modelValue': [value: T];
+    /** Event handler when highlighted element changes. */
+    'highlight': [payload: {
+        ref: HTMLElement;
+        value: T;
+    } | undefined];
+    /** Event handler called when container is being focused. Can be prevented. */
+    'entryFocus': [event: CustomEvent];
+    /** Event handler called when the mouse leave the container */
+    'leave': [event: Event];
+};
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    defaultValue?: AcceptableValue | AcceptableValue[] | undefined;
+    dir?: Direction | undefined;
+    disabled?: boolean | undefined;
+    multiple?: boolean | undefined;
+    name?: string | undefined;
+    selectionBehavior?: "replace" | "toggle" | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    required?: boolean | undefined;
+    modelValue?: AcceptableValue | AcceptableValue[] | undefined;
+    orientation?: DataOrientation | undefined;
+    "onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
+    onEntryFocus?: ((event: CustomEvent<any>) => any) | undefined;
+    by?: string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined;
+    highlightOnHover?: boolean | undefined;
+    onHighlight?: ((payload: {
+        ref: HTMLElement;
+        value: AcceptableValue;
+    } | undefined) => any) | undefined;
+    onLeave?: ((event: Event) => any) | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: Readonly<{
+        default: (props: {
+            /** Current active value */
+            modelValue: T | T[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: T | T[] | undefined;
+        }) => any;
+    };
+    attrs: any;
+    emit: ((evt: "leave", event: Event) => void) & ((evt: "update:modelValue", value: AcceptableValue) => void) & ((evt: "entryFocus", event: CustomEvent<any>) => void) & ((evt: "highlight", payload: {
+        ref: HTMLElement;
+        value: AcceptableValue;
+    } | undefined) => void);
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{
+    highlightedElement: Ref<HTMLElement | null>;
+    highlightItem: (value: T) => void;
+    highlightFirstItem: () => void;
+    highlightSelected: (event?: Event) => Promise<void>;
+    getItems: (includeDisabledItem?: boolean) => ({
+        ref: HTMLElement;
+        value?: any;
+    } & {
+        value: T;
+    })[];
+}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        defaultValue?: AcceptableValue | AcceptableValue[] | undefined;
+        dir?: Direction | undefined;
+        disabled?: boolean | undefined;
+        multiple?: boolean | undefined;
+        name?: string | undefined;
+        selectionBehavior?: "replace" | "toggle" | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        required?: boolean | undefined;
+        modelValue?: AcceptableValue | AcceptableValue[] | undefined;
+        orientation?: DataOrientation | undefined;
+        "onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
+        onEntryFocus?: ((event: CustomEvent<any>) => any) | undefined;
+        by?: string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined;
+        highlightOnHover?: boolean | undefined;
+        onHighlight?: ((payload: {
+            ref: HTMLElement;
+            value: AcceptableValue;
+        } | undefined) => any) | undefined;
+        onLeave?: ((event: Event) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        highlightedElement: Ref<HTMLElement | null>;
+        highlightItem: (value: T) => void;
+        highlightFirstItem: () => void;
+        highlightSelected: (event?: Event) => Promise<void>;
+        getItems: (includeDisabledItem?: boolean) => ({
+            ref: HTMLElement;
+            value?: any;
+        } & {
+            value: T;
+        })[];
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (props: {
+            /** Current active value */
+            modelValue: T | T[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: T | T[] | undefined;
+        }) => any;
+    };
+    emit: ((evt: "leave", event: Event) => void) & ((evt: "update:modelValue", value: AcceptableValue) => void) & ((evt: "entryFocus", event: CustomEvent<any>) => void) & ((evt: "highlight", payload: {
+        ref: HTMLElement;
+        value: AcceptableValue;
+    } | undefined) => void);
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            defaultValue?: AcceptableValue | AcceptableValue[] | undefined;
+            dir?: Direction | undefined;
+            disabled?: boolean | undefined;
+            multiple?: boolean | undefined;
+            name?: string | undefined;
+            selectionBehavior?: "replace" | "toggle" | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+            required?: boolean | undefined;
+            modelValue?: AcceptableValue | AcceptableValue[] | undefined;
+            orientation?: DataOrientation | undefined;
+            "onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
+            onEntryFocus?: ((event: CustomEvent<any>) => any) | undefined;
+            by?: string | ((a: AcceptableValue, b: AcceptableValue) => boolean) | undefined;
+            highlightOnHover?: boolean | undefined;
+            onHighlight?: ((payload: {
+                ref: HTMLElement;
+                value: AcceptableValue;
+            } | undefined) => any) | undefined;
+            onLeave?: ((event: Event) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{
+            highlightedElement: Ref<HTMLElement | null>;
+            highlightItem: (value: T) => void;
+            highlightFirstItem: () => void;
+            highlightSelected: (event?: Event) => Promise<void>;
+            getItems: (includeDisabledItem?: boolean) => ({
+                ref: HTMLElement;
+                value?: any;
+            } & {
+                value: T;
+            })[];
+        }>): void;
+        attrs: any;
+        slots: Readonly<{
+            default: (props: {
+                /** Current active value */
+                modelValue: T | T[] | undefined;
+            }) => any;
+        }> & {
+            default: (props: {
+                /** Current active value */
+                modelValue: T | T[] | undefined;
+            }) => any;
+        };
+        emit: ((evt: "leave", event: Event) => void) & ((evt: "update:modelValue", value: AcceptableValue) => void) & ((evt: "entryFocus", event: CustomEvent<any>) => void) & ((evt: "highlight", payload: {
+            ref: HTMLElement;
+            value: AcceptableValue;
+        } | undefined) => void);
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/Listbox/ListboxVirtualizer.d.ts

@@ -0,0 +1,68 @@
+import { AcceptableValue } from '../shared/types';
+
+export interface ListboxVirtualizerProps<T extends AcceptableValue = AcceptableValue> {
+    /** List of items */
+    options: T[];
+    /** Estimated size (in px) of each item */
+    estimateSize?: number;
+    /** text content for each item to achieve type-ahead feature */
+    textContent?: (option: T) => string;
+}
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    textContent?: ((option: T) => string) | undefined;
+    options: T[];
+    estimateSize?: number | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: Readonly<{
+        default: (props: {
+            option: T;
+        }) => any;
+    }> & {
+        default: (props: {
+            option: T;
+        }) => any;
+    };
+    attrs: any;
+    emit: any;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        textContent?: ((option: T) => string) | undefined;
+        options: T[];
+        estimateSize?: number | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (props: {
+            option: T;
+        }) => any;
+    }> & {
+        default: (props: {
+            option: T;
+        }) => any;
+    };
+    emit: any;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            textContent?: ((option: T) => string) | undefined;
+            options: T[];
+            estimateSize?: number | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default: (props: {
+                option: T;
+            }) => any;
+        }> & {
+            default: (props: {
+                option: T;
+            }) => any;
+        };
+        emit: any;
+    } | undefined;
+};
+export default _default;

package/dist/Listbox/index.d.ts

@@ -0,0 +1,8 @@
+export { default as ListboxRoot, type ListboxRootProps, type ListboxRootEmits, } from './ListboxRoot';
+export { default as ListboxContent, type ListboxContentProps, } from './ListboxContent';
+export { default as ListboxFilter, type ListboxFilterProps, type ListboxFilterEmits, } from './ListboxFilter';
+export { default as ListboxItem, type ListboxItemProps, type ListboxItemEmits, } from './ListboxItem';
+export { default as ListboxItemIndicator, type ListboxItemIndicatorProps, } from './ListboxItemIndicator';
+export { default as ListboxVirtualizer, type ListboxVirtualizerProps, } from './ListboxVirtualizer';
+export { default as ListboxGroup, type ListboxGroupProps, } from './ListboxGroup';
+export { default as ListboxGroupLabel, type ListboxGroupLabelProps, } from './ListboxGroupLabel';

package/dist/Listbox/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function queryCheckedElement(parentEl: HTMLElement | null): HTMLElement | null;
+export declare function valueComparator<T>(value: T | T[] | undefined, currentValue: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+export declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;

package/dist/Menu/MenuAnchor.d.ts

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

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

@@ -0,0 +1,57 @@
+import { CheckedState } from './utils';
+import { MenuItemEmits, MenuItemProps } from './MenuItem';
+
+export type MenuCheckboxItemEmits = MenuItemEmits & {
+    /** Event handler called when the checked state changes. */
+    'update:modelValue': [payload: boolean];
+};
+export interface MenuCheckboxItemProps extends MenuItemProps {
+    /** The controlled checked state of the item. Can be used as `v-model`. */
+    modelValue?: CheckedState;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MenuCheckboxItemProps>, {
+    modelValue: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+    "update:modelValue": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MenuCheckboxItemProps>, {
+    modelValue: boolean;
+}>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((payload: boolean) => any) | undefined;
+}, {
+    modelValue: CheckedState;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current modelValue state */
+        modelValue: CheckedState;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current modelValue state */
+        modelValue: CheckedState;
+    }) => 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/Menu/MenuContent.d.ts

@@ -0,0 +1,44 @@
+import { MenuContentImplEmits, MenuRootContentTypeProps } from './MenuContentImpl';
+
+export type MenuContentEmits = Omit<MenuContentImplEmits, 'entryFocus' | 'openAutoFocus'>;
+export interface MenuContentProps extends MenuRootContentTypeProps {
+    /**
+     * 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<MenuContentProps>, {}, 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;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+    entryFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MenuContentProps>>> & {
+    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;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => 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/Menu/MenuContentImpl.d.ts

@@ -0,0 +1,137 @@
+import { Ref } from 'vue';
+import { GraceIntent } from './utils';
+import { FocusScopeProps } from '../FocusScope';
+import { RovingFocusGroupEmits } from '../RovingFocus';
+import { DismissableLayerEmits, DismissableLayerProps } from '../DismissableLayer';
+import { PopperContentProps } from '../Popper';
+
+export interface MenuContentContext {
+    onItemEnter: (event: PointerEvent) => boolean;
+    onItemLeave: (event: PointerEvent) => void;
+    onTriggerLeave: (event: PointerEvent) => boolean;
+    searchRef: Ref<string>;
+    pointerGraceTimerRef: Ref<number>;
+    onPointerGraceIntentChange: (intent: GraceIntent | null) => void;
+}
+export declare const injectMenuContentContext: <T extends MenuContentContext | null | undefined = MenuContentContext>(fallback?: T | undefined) => T extends null ? MenuContentContext | null : MenuContentContext, provideMenuContentContext: (contextValue: MenuContentContext) => MenuContentContext;
+export interface MenuContentImplPrivateProps {
+    /**
+     * When `true`, hover/focus/click interactions will be disabled on elements outside
+     * the `DismissableLayer`. Users will need to click twice on outside elements to
+     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
+     */
+    disableOutsidePointerEvents?: DismissableLayerProps['disableOutsidePointerEvents'];
+    /**
+     * Whether scrolling outside the `MenuContent` should be prevented
+     * @defaultValue false
+     */
+    disableOutsideScroll?: boolean;
+    /**
+     * Whether focus should be trapped within the `MenuContent`
+     * @defaultValue also
+     */
+    trapFocus?: FocusScopeProps['trapped'];
+}
+export type MenuContentImplEmits = DismissableLayerEmits & Omit<RovingFocusGroupEmits, 'update:currentTabStopId'> & {
+    openAutoFocus: [event: Event];
+    /**
+     * Event handler called when auto-focusing on close.
+     * Can be prevented.
+     */
+    closeAutoFocus: [event: Event];
+};
+export interface MenuContentImplProps extends MenuContentImplPrivateProps, Omit<PopperContentProps, 'dir'> {
+    /**
+     * When `true`, keyboard navigation will loop from last item to first, and vice versa.
+     * @defaultValue false
+     */
+    loop?: boolean;
+}
+export interface MenuRootContentTypeProps extends Omit<MenuContentImplProps, 'disableOutsidePointerEvents' | 'disableOutsideScroll' | 'trapFocus'> {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MenuContentImplProps>, {
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    align: "center" | "end" | "start";
+    alignOffset: number;
+    arrowPadding: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: boolean;
+}>, {}, 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;
+    dismiss: () => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+    entryFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MenuContentImplProps>, {
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    align: "center" | "end" | "start";
+    alignOffset: number;
+    arrowPadding: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: boolean;
+}>>> & {
+    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;
+    onDismiss?: (() => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => any) | undefined;
+}, {
+    side: "right" | "left" | "top" | "bottom";
+    align: "center" | "end" | "start";
+    sideOffset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: Element | (Element | null)[] | null;
+    collisionPadding: number | Partial<Record<"right" | "left" | "top" | "bottom", number>>;
+    arrowPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: 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/Menu/MenuGroup.d.ts

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