reka-ui 0.0.0 → 0.0.2

package/dist/Combobox/ComboboxRoot.d.ts

@@ -0,0 +1,217 @@
+import { EventHookOn } from '@vueuse/core';
+import { Ref } from 'vue';
+import { ListboxRootProps } from '../Listbox';
+import { AcceptableValue } from '../shared/types';
+
+type ComboboxRootContext<T> = {
+    modelValue: Ref<T | Array<T>>;
+    multiple: Ref<boolean>;
+    disabled: Ref<boolean>;
+    open: Ref<boolean>;
+    onOpenChange: (value: boolean) => void;
+    isUserInputted: Ref<boolean>;
+    isVirtual: Ref<boolean>;
+    contentId: string;
+    inputElement: Ref<HTMLInputElement | undefined>;
+    onInputElementChange: (el: HTMLInputElement) => void;
+    highlightedElement: Ref<HTMLElement | undefined>;
+    parentElement: Ref<HTMLElement | undefined>;
+    onResetSearchTerm: EventHookOn;
+    allItems: Ref<Map<string, string>>;
+    allGroups: Ref<Map<string, Set<string>>>;
+    filterState: {
+        search: string;
+        filtered: {
+            count: number;
+            items: Map<string, number>;
+            groups: Set<string>;
+        };
+    };
+    ignoreFilter: Ref<boolean>;
+};
+export declare const injectComboboxRootContext: <T extends ComboboxRootContext<AcceptableValue> | null | undefined = ComboboxRootContext<AcceptableValue>>(fallback?: T | undefined) => T extends null ? ComboboxRootContext<AcceptableValue> | null : ComboboxRootContext<AcceptableValue>, provideComboboxRootContext: (contextValue: ComboboxRootContext<AcceptableValue>) => ComboboxRootContext<AcceptableValue>;
+export type ComboboxRootEmits<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 the open state of the combobox changes. */
+    'update:open': [value: boolean];
+};
+export interface ComboboxRootProps<T = AcceptableValue> extends Omit<ListboxRootProps<T>, 'orientation' | 'selectionBehavior'> {
+    /** The controlled open state of the Combobox. Can be binded-with with `v-model:open`. */
+    open?: boolean;
+    /** The open state of the combobox when it is initially rendered. <br> Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+    /** The name of the combobox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /**
+     * Whether to reset the searchTerm when the Combobox input blurred
+     * @defaultValue `true`
+     */
+    resetSearchTermOnBlur?: boolean;
+    /**
+     * When `true`, disable the default filters
+     */
+    ignoreFilter?: boolean;
+}
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    defaultValue?: T | T[] | undefined;
+    dir?: import('../shared/types').Direction | undefined;
+    disabled?: boolean | undefined;
+    multiple?: boolean | undefined;
+    name?: string | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    defaultOpen?: boolean | undefined;
+    open?: boolean | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    required?: boolean | undefined;
+    modelValue?: T | T[] | undefined;
+    "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    by?: string | ((a: T, b: T) => boolean) | undefined;
+    highlightOnHover?: boolean | undefined;
+    onHighlight?: ((payload: {
+        ref: HTMLElement;
+        value: T;
+    } | undefined) => any) | undefined;
+    resetSearchTermOnBlur?: boolean | undefined;
+    ignoreFilter?: boolean | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: Readonly<{
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "highlight", payload: {
+        ref: HTMLElement;
+        value: T;
+    } | undefined) => void);
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{
+    highlightedElement: import('vue').ComputedRef<HTMLElement | undefined>;
+    highlightItem: ((value: AcceptableValue) => void) | undefined;
+    highlightFirstItem: (() => void) | undefined;
+    highlightSelected: ((event?: Event | undefined) => Promise<void>) | undefined;
+}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        defaultValue?: T | T[] | undefined;
+        dir?: import('../shared/types').Direction | undefined;
+        disabled?: boolean | undefined;
+        multiple?: boolean | undefined;
+        name?: string | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        defaultOpen?: boolean | undefined;
+        open?: boolean | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        required?: boolean | undefined;
+        modelValue?: T | T[] | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        by?: string | ((a: T, b: T) => boolean) | undefined;
+        highlightOnHover?: boolean | undefined;
+        onHighlight?: ((payload: {
+            ref: HTMLElement;
+            value: T;
+        } | undefined) => any) | undefined;
+        resetSearchTermOnBlur?: boolean | undefined;
+        ignoreFilter?: boolean | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        highlightedElement: import('vue').ComputedRef<HTMLElement | undefined>;
+        highlightItem: ((value: AcceptableValue) => void) | undefined;
+        highlightFirstItem: (() => void) | undefined;
+        highlightSelected: ((event?: Event | undefined) => Promise<void>) | undefined;
+    }>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    };
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "highlight", payload: {
+        ref: HTMLElement;
+        value: T;
+    } | undefined) => void);
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            defaultValue?: T | T[] | undefined;
+            dir?: import('../shared/types').Direction | undefined;
+            disabled?: boolean | undefined;
+            multiple?: boolean | undefined;
+            name?: string | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+            defaultOpen?: boolean | undefined;
+            open?: boolean | undefined;
+            "onUpdate:open"?: ((value: boolean) => any) | undefined;
+            required?: boolean | undefined;
+            modelValue?: T | T[] | undefined;
+            "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+            by?: string | ((a: T, b: T) => boolean) | undefined;
+            highlightOnHover?: boolean | undefined;
+            onHighlight?: ((payload: {
+                ref: HTMLElement;
+                value: T;
+            } | undefined) => any) | undefined;
+            resetSearchTermOnBlur?: boolean | undefined;
+            ignoreFilter?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{
+            highlightedElement: import('vue').ComputedRef<HTMLElement | undefined>;
+            highlightItem: ((value: AcceptableValue) => void) | undefined;
+            highlightFirstItem: (() => void) | undefined;
+            highlightSelected: ((event?: Event | undefined) => Promise<void>) | undefined;
+        }>): void;
+        attrs: any;
+        slots: Readonly<{
+            default: (props: {
+                /** Current open state */
+                open: boolean;
+                /** Current active value */
+                modelValue: T | T[];
+            }) => any;
+        }> & {
+            default: (props: {
+                /** Current open state */
+                open: boolean;
+                /** Current active value */
+                modelValue: T | T[];
+            }) => any;
+        };
+        emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "highlight", payload: {
+            ref: HTMLElement;
+            value: T;
+        } | undefined) => void);
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/Combobox/ComboboxSeparator.d.ts

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

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ComboboxTriggerProps extends PrimitiveProps {
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ComboboxTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ComboboxTriggerProps>, {
+    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/Combobox/ComboboxViewport.d.ts

@@ -0,0 +1,26 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ComboboxViewportProps extends PrimitiveProps {
+    /**
+     * Will add `nonce` attribute to the style tag which can be used by Content Security Policy. <br> If omitted, inherits globally from `ConfigProvider`.
+     */
+    nonce?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ComboboxViewportProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ComboboxViewportProps>>>, {}, {}>, {
+    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/Combobox/ComboboxVirtualizer.d.ts

@@ -0,0 +1,63 @@
+import { ListboxVirtualizerProps } from '../Listbox';
+import { AcceptableValue } from '../shared/types';
+
+export interface ComboboxVirtualizerProps<T extends AcceptableValue = AcceptableValue> extends ListboxVirtualizerProps<T> {
+}
+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/Combobox/index.d.ts

@@ -0,0 +1,16 @@
+export { default as ComboboxRoot, type ComboboxRootProps, type ComboboxRootEmits, } from './ComboboxRoot';
+export { default as ComboboxInput, type ComboboxInputProps, } from './ComboboxInput';
+export { default as ComboboxAnchor, type ComboboxAnchorProps, } from './ComboboxAnchor';
+export { default as ComboboxEmpty, type ComboboxEmptyProps, } from './ComboboxEmpty';
+export { default as ComboboxTrigger, type ComboboxTriggerProps, } from './ComboboxTrigger';
+export { default as ComboboxCancel, type ComboboxCancelProps, } from './ComboboxCancel';
+export { default as ComboboxGroup, type ComboboxGroupProps, } from './ComboboxGroup';
+export { default as ComboboxLabel, type ComboboxLabelProps, } from './ComboboxLabel';
+export { default as ComboboxContent, type ComboboxContentProps, type ComboboxContentEmits, } from './ComboboxContent';
+export { default as ComboboxViewport, type ComboboxViewportProps, } from './ComboboxViewport';
+export { default as ComboboxVirtualizer, type ComboboxVirtualizerProps, } from './ComboboxVirtualizer';
+export { default as ComboboxItem, type ComboboxItemProps, type ComboboxItemEmits, } from './ComboboxItem';
+export { default as ComboboxItemIndicator, type ComboboxItemIndicatorProps, } from './ComboboxItemIndicator';
+export { default as ComboboxSeparator, type ComboboxSeparatorProps, } from './ComboboxSeparator';
+export { default as ComboboxArrow, type ComboboxArrowProps, } from './ComboboxArrow';
+export { default as ComboboxPortal, type ComboboxPortalProps, } from './ComboboxPortal';

package/dist/ConfigProvider/ConfigProvider.d.ts

@@ -0,0 +1,81 @@
+import { Direction, ScrollBodyOption } from '../shared/types';
+import { Ref } from 'vue';
+
+interface ConfigProviderContextValue {
+    dir?: Ref<Direction>;
+    locale?: Ref<string>;
+    scrollBody?: Ref<boolean | ScrollBodyOption>;
+    nonce?: Ref<string | undefined>;
+    useId?: () => string;
+}
+export declare const injectConfigProviderContext: <T extends ConfigProviderContextValue | null | undefined = ConfigProviderContextValue>(fallback?: T | undefined) => T extends null ? ConfigProviderContextValue | null : ConfigProviderContextValue, provideConfigProviderContext: (contextValue: ConfigProviderContextValue) => ConfigProviderContextValue;
+export interface ConfigProviderProps {
+    /**
+     * The global reading direction of your application. This will be inherited by all primitives.
+     * @defaultValue 'ltr'
+     */
+    dir?: Direction;
+    /**
+     * The global locale of your application. This will be inherited by all primitives.
+     * @defaultValue 'en'
+     */
+    locale?: string;
+    /**
+     * The global scroll body behavior of your application. This will be inherited by the related primitives.
+     * @type boolean | ScrollBodyOption
+     */
+    scrollBody?: boolean | ScrollBodyOption;
+    /**
+     * The global `nonce` value of your application. This will be inherited by the related primitives.
+     * @type string
+     */
+    nonce?: string;
+    /**
+     * The global `useId` injection as a workaround for preventing hydration issue.
+     */
+    useId?: () => string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ConfigProviderProps>, {
+    dir: string;
+    locale: string;
+    scrollBody: boolean;
+    nonce: undefined;
+    useId: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ConfigProviderProps>, {
+    dir: string;
+    locale: string;
+    scrollBody: boolean;
+    nonce: undefined;
+    useId: undefined;
+}>>>, {
+    dir: Direction;
+    locale: string;
+    scrollBody: boolean | ScrollBodyOption;
+    nonce: string;
+    useId: () => string;
+}, {}>, {
+    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/ConfigProvider/index.d.ts

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

package/dist/ContextMenu/ContextMenuArrow.d.ts

@@ -0,0 +1,42 @@
+import { MenuArrowProps } from '../Menu';
+
+export interface ContextMenuArrowProps extends MenuArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuArrowProps>, {
+    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<ContextMenuArrowProps>, {
+    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/ContextMenu/ContextMenuCheckboxItem.d.ts

@@ -0,0 +1,29 @@
+import { MenuCheckboxItemEmits, MenuCheckboxItemProps } from '../Menu';
+
+export type ContextMenuCheckboxItemEmits = MenuCheckboxItemEmits;
+export interface ContextMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ContextMenuCheckboxItemProps>, {}, 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_TypePropsToRuntimeProps<ContextMenuCheckboxItemProps>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((payload: boolean) => 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/ContextMenu/ContextMenuContent.d.ts

@@ -0,0 +1,64 @@
+import { MenuContentEmits, MenuContentProps } from '../Menu';
+
+export type ContextMenuContentEmits = MenuContentEmits;
+export interface ContextMenuContentProps extends Omit<MenuContentProps, 'side' | 'sideOffset' | 'align' | 'arrowPadding' | 'updatePositionStrategy'> {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuContentProps>, {
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: string;
+    hideWhenDetached: 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;
+    closeAutoFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuContentProps>, {
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: string;
+    hideWhenDetached: 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;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}, {
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: Element | (Element | null)[] | null;
+    collisionPadding: number | Partial<Record<"right" | "left" | "top" | "bottom", number>>;
+    sticky: "partial" | "always";
+    hideWhenDetached: 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/ContextMenu/ContextMenuGroup.d.ts

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

@@ -0,0 +1,27 @@
+import { MenuItemEmits, MenuItemProps } from '../Menu';
+
+export type ContextMenuItemEmits = MenuItemEmits;
+export interface ContextMenuItemProps extends MenuItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<MenuItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MenuItemProps>>> & {
+    onSelect?: ((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;
+    };
+};