reka-ui 0.0.0 → 0.0.2

package/dist/NavigationMenu/NavigationMenuContentImpl.d.ts

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

@@ -0,0 +1,27 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface NavigationMenuIndicatorProps extends PrimitiveProps {
+    /**
+     * 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<NavigationMenuIndicatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<NavigationMenuIndicatorProps>>>, {}, {}>, {
+    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/NavigationMenu/NavigationMenuItem.d.ts

@@ -0,0 +1,55 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+export interface NavigationMenuItemProps extends PrimitiveProps {
+    /**
+     * A unique value that associates the item with an active value when the navigation menu is controlled.
+     *
+     *  This prop is managed automatically when uncontrolled.
+     */
+    value?: string;
+}
+export type NavigationMenuItemContext = {
+    value: string;
+    contentId: string;
+    triggerRef: Ref<HTMLElement | undefined>;
+    focusProxyRef: Ref<HTMLElement | undefined>;
+    wasEscapeCloseRef: Ref<boolean>;
+    onEntryKeyDown: () => void;
+    onFocusProxyEnter: (side: 'start' | 'end') => void;
+    onContentFocusOutside: () => void;
+    onRootContentClose: () => void;
+};
+export declare const injectNavigationMenuItemContext: <T extends NavigationMenuItemContext | null | undefined = NavigationMenuItemContext>(fallback?: T | undefined) => T extends null ? NavigationMenuItemContext | null : NavigationMenuItemContext, provideNavigationMenuItemContext: (contextValue: NavigationMenuItemContext) => NavigationMenuItemContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuItemProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuItemProps>, {
+    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/NavigationMenu/NavigationMenuLink.d.ts

@@ -0,0 +1,50 @@
+import { PrimitiveProps } from '../Primitive';
+
+export type NavigationMenuLinkEmits = {
+    /**
+     * Event handler called when the user selects a link (via mouse or keyboard).
+     *
+     * Calling `event.preventDefault` in this handler will prevent the navigation menu from closing when selecting that link.
+     */
+    select: [payload: MouseEvent];
+};
+export interface NavigationMenuLinkProps extends PrimitiveProps {
+    /** Used to identify the link as the currently active page. */
+    active?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuLinkProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (payload: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuLinkProps>, {
+    as: string;
+}>>> & {
+    onSelect?: ((payload: MouseEvent) => any) | undefined;
+}, {
+    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/NavigationMenu/NavigationMenuList.d.ts

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

@@ -0,0 +1,141 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Direction, Orientation } from './utils';
+
+export interface NavigationMenuRootProps extends PrimitiveProps {
+    /** The controlled value of the menu item to activate. Can be used as `v-model`. */
+    modelValue?: string;
+    /**
+     * The value of the menu item that should be active when initially rendered.
+     *
+     * Use when you do not need to control the value state.
+     */
+    defaultValue?: string;
+    /**
+     * The reading direction of the combobox when applicable.
+     *
+     *  If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode.
+     */
+    dir?: Direction;
+    /** The orientation of the menu. */
+    orientation?: Orientation;
+    /**
+     * The duration from when the pointer enters the trigger until the tooltip gets opened.
+     * @defaultValue 200
+     */
+    delayDuration?: number;
+    /**
+     * How much time a user has to enter another trigger without incurring a delay again.
+     * @defaultValue 300
+     */
+    skipDelayDuration?: number;
+    /**
+     * If `true`, menu cannot be open by click on trigger
+     * @defaultValue false
+     */
+    disableClickTrigger?: boolean;
+    /**
+     * If `true`, menu cannot be open by hover on trigger
+     * @defaultValue false
+     */
+    disableHoverTrigger?: boolean;
+    /**
+     * When `true`, the element will be unmounted on closed state.
+     *
+     * @defaultValue `true`
+     */
+    unmountOnHide?: boolean;
+}
+export type NavigationMenuRootEmits = {
+    /** Event handler called when the value changes. */
+    'update:modelValue': [value: string];
+};
+export interface NavigationMenuContext {
+    isRootMenu: boolean;
+    modelValue: Ref<string>;
+    previousValue: Ref<string>;
+    baseId: string;
+    dir: Ref<Direction>;
+    orientation: Orientation;
+    disableClickTrigger: Ref<boolean>;
+    disableHoverTrigger: Ref<boolean>;
+    unmountOnHide: Ref<boolean>;
+    rootNavigationMenu: Ref<HTMLElement | undefined>;
+    activeTrigger: Ref<HTMLElement | undefined>;
+    indicatorTrack: Ref<HTMLElement | undefined>;
+    onIndicatorTrackChange: (indicatorTrack: HTMLElement | undefined) => void;
+    viewport: Ref<HTMLElement | undefined>;
+    onViewportChange: (viewport: HTMLElement | undefined) => void;
+    onTriggerEnter: (itemValue: string) => void;
+    onTriggerLeave: () => void;
+    onContentEnter: (itemValue: string) => void;
+    onContentLeave: () => void;
+    onItemSelect: (itemValue: string) => void;
+    onItemDismiss: () => void;
+}
+export declare const injectNavigationMenuContext: <T extends NavigationMenuContext | null | undefined = NavigationMenuContext>(fallback?: T | undefined) => T extends null ? NavigationMenuContext | null : NavigationMenuContext, provideNavigationMenuContext: (contextValue: NavigationMenuContext) => NavigationMenuContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuRootProps>, {
+    modelValue: undefined;
+    delayDuration: number;
+    skipDelayDuration: number;
+    orientation: string;
+    disableClickTrigger: boolean;
+    disableHoverTrigger: boolean;
+    unmountOnHide: boolean;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuRootProps>, {
+    modelValue: undefined;
+    delayDuration: number;
+    skipDelayDuration: number;
+    orientation: string;
+    disableClickTrigger: boolean;
+    disableHoverTrigger: boolean;
+    unmountOnHide: boolean;
+    as: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    unmountOnHide: boolean;
+    modelValue: string;
+    orientation: Orientation;
+    delayDuration: number;
+    skipDelayDuration: number;
+    disableClickTrigger: boolean;
+    disableHoverTrigger: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current input values */
+        modelValue: string;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current input values */
+        modelValue: string;
+    }) => 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/NavigationMenu/NavigationMenuSub.d.ts

@@ -0,0 +1,63 @@
+import { Orientation } from './utils';
+import { PrimitiveProps } from '../Primitive';
+
+export type NavigationMenuSubEmits = {
+    /** Event handler called when the value changes. */
+    'update:modelValue': [value: string];
+};
+export interface NavigationMenuSubProps extends PrimitiveProps {
+    /** The controlled value of the sub menu item to activate. Can be used as `v-model`. */
+    modelValue?: string;
+    /**
+     * The value of the menu item that should be active when initially rendered.
+     *
+     * Use when you do not need to control the value state.
+     */
+    defaultValue?: string;
+    /** The orientation of the menu. */
+    orientation?: Orientation;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuSubProps>, {
+    orientation: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuSubProps>, {
+    orientation: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}, {
+    orientation: Orientation;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current input values */
+        modelValue: string;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current input values */
+        modelValue: string;
+    }) => 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/NavigationMenu/NavigationMenuTrigger.d.ts

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface NavigationMenuTriggerProps 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<NavigationMenuTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuTriggerProps>, {
+    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/NavigationMenu/NavigationMenuViewport.d.ts

@@ -0,0 +1,46 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface NavigationMenuViewportProps extends PrimitiveProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+    /**
+     * Placement of the viewport for css variables `(--reka-navigation-menu-viewport-left, --reka-navigation-menu-viewport-top)`.
+     * @defaultValue 'center'
+     */
+    align?: 'start' | 'center' | 'end';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuViewportProps>, {
+    align: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NavigationMenuViewportProps>, {
+    align: string;
+}>>>, {
+    align: "center" | "end" | "start";
+}, {}>, {
+    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/NavigationMenu/index.d.ts

@@ -0,0 +1,9 @@
+export { default as NavigationMenuContent, type NavigationMenuContentProps, type NavigationMenuContentEmits, } from './NavigationMenuContent';
+export { default as NavigationMenuIndicator, type NavigationMenuIndicatorProps, } from './NavigationMenuIndicator';
+export { default as NavigationMenuItem, type NavigationMenuItemProps, } from './NavigationMenuItem';
+export { default as NavigationMenuLink, type NavigationMenuLinkProps, type NavigationMenuLinkEmits, } from './NavigationMenuLink';
+export { default as NavigationMenuList, type NavigationMenuListProps, } from './NavigationMenuList';
+export { default as NavigationMenuRoot, type NavigationMenuRootProps, type NavigationMenuRootEmits, } from './NavigationMenuRoot';
+export { default as NavigationMenuSub, type NavigationMenuSubProps, type NavigationMenuSubEmits, } from './NavigationMenuSub';
+export { default as NavigationMenuTrigger, type NavigationMenuTriggerProps, } from './NavigationMenuTrigger';
+export { default as NavigationMenuViewport, type NavigationMenuViewportProps, } from './NavigationMenuViewport';

package/dist/NavigationMenu/utils.d.ts

@@ -0,0 +1,20 @@
+export type Orientation = 'vertical' | 'horizontal';
+export type Direction = 'ltr' | 'rtl';
+export declare function getOpenState(open: boolean): "open" | "closed";
+export declare function makeTriggerId(baseId: string, value: string): string;
+export declare function makeContentId(baseId: string, value: string): string;
+export declare const EVENT_ROOT_CONTENT_DISMISS = "navigationMenu.rootContentDismiss";
+/**
+ * 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[];
+export declare function focusFirst(candidates: HTMLElement[]): boolean;
+export declare function removeFromTabOrder(candidates: HTMLElement[]): () => void;
+export declare function whenMouse<E extends PointerEvent>(handler: (event?: E) => void): (event: E) => void;

package/dist/NumberField/NumberFieldDecrement.d.ts

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

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

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