@nuxt/ui 3.1.2 → 3.2.0

package/dist/runtime/components/OverlayProvider.vue

@@ -1,11 +1,11 @@
 <script setup>
 import { computed } from "vue";
 import { useOverlay } from "../composables/useOverlay";
-const { overlays, unMount, close } = useOverlay();
+const { overlays, unmount, close } = useOverlay();
 const mountedOverlays = computed(() => overlays.filter((overlay) => overlay.isMounted));
 const onAfterLeave = (id) => {
   close(id);
-  unMount(id);
+  unmount(id);
 };
 const onClose = (id, value) => {
   close(id, value);

package/dist/runtime/components/Pagination.vue

@@ -22,7 +22,7 @@ const props = defineProps({
   activeColor: { type: null, required: false, default: "primary" },
   activeVariant: { type: null, required: false, default: "solid" },
   showControls: { type: Boolean, required: false, default: true },
-  size: { type: null, required: false, default: "md" },
+  size: { type: null, required: false },
   to: { type: Function, required: false },
   class: { type: null, required: false },
   ui: { type: null, required: false },

package/dist/runtime/components/Pagination.vue.d.ts

@@ -100,7 +100,6 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Pagination
 }, string, import("vue").PublicProps, Readonly<PaginationProps> & Readonly<{
     "onUpdate:page"?: ((value: number) => any) | undefined;
 }>, {
-    size: "xs" | "sm" | "md" | "lg" | "xl";
     color: "error" | "info" | "primary" | "secondary" | "success" | "warning" | "neutral";
     activeColor: "error" | "info" | "primary" | "secondary" | "success" | "warning" | "neutral";
     variant: "link" | "solid" | "outline" | "soft" | "subtle" | "ghost";

package/dist/runtime/components/PinInput.vue

@@ -25,16 +25,16 @@ const props = defineProps({
   disabled: { type: Boolean, required: false },
   id: { type: String, required: false },
   mask: { type: Boolean, required: false },
-  modelValue: { type: [Array, null], required: false },
+  modelValue: { type: null, required: false },
   name: { type: String, required: false },
   otp: { type: Boolean, required: false },
   placeholder: { type: String, required: false },
   required: { type: Boolean, required: false },
-  type: { type: String, required: false, default: "text" }
+  type: { type: null, required: false, default: "text" }
 });
 const emits = defineEmits(["update:modelValue", "complete", "change", "blur"]);
 const appConfig = useAppConfig();
-const rootProps = useForwardPropsEmits(reactivePick(props, "defaultValue", "disabled", "id", "mask", "modelValue", "name", "otp", "placeholder", "required", "type"), emits);
+const rootProps = useForwardPropsEmits(reactivePick(props, "defaultValue", "disabled", "id", "mask", "modelValue", "name", "otp", "required", "type"), emits);
 const { emitFormInput, emitFormFocus, emitFormChange, emitFormBlur, size, color, id, name, highlight, disabled, ariaAttrs } = useFormField(props);
 const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.pinInput || {} })({
   color: color.value,
@@ -75,6 +75,7 @@ defineExpose({
     v-bind="{ ...rootProps, ...ariaAttrs }"
     :id="id"
     :name="name"
+    :placeholder="placeholder"
     :class="ui.root({ class: [props.ui?.root, props.class] })"
     @update:model-value="emitFormInput()"
     @complete="onComplete"

package/dist/runtime/components/PinInput.vue.d.ts

@@ -4,7 +4,8 @@ import type { AppConfig } from '@nuxt/schema';
 import theme from '#build/ui/pin-input';
 import type { ComponentConfig } from '../types/utils';
 type PinInput = ComponentConfig<typeof theme, AppConfig, 'pinInput'>;
-export interface PinInputProps extends Pick<PinInputRootProps, 'defaultValue' | 'disabled' | 'id' | 'mask' | 'modelValue' | 'name' | 'otp' | 'placeholder' | 'required' | 'type'> {
+type PinInputType = 'text' | 'number';
+export interface PinInputProps<T extends PinInputType = 'text'> extends Pick<PinInputRootProps<T>, 'defaultValue' | 'disabled' | 'id' | 'mask' | 'modelValue' | 'name' | 'otp' | 'placeholder' | 'required' | 'type'> {
     /**
      * The element or component this component should render as.
      * @defaultValue 'div'
@@ -33,25 +34,27 @@ export interface PinInputProps extends Pick<PinInputRootProps, 'defaultValue' |
     class?: any;
     ui?: PinInput['slots'];
 }
-export type PinInputEmits = PinInputRootEmits & {
+export type PinInputEmits<T extends PinInputType = 'text'> = PinInputRootEmits<T> & {
     change: [payload: Event];
     blur: [payload: Event];
 };
-declare const _default: import("vue").DefineComponent<PinInputProps, {
-    inputsRef: import("vue").Ref<ComponentPublicInstance[], ComponentPublicInstance[]>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur: (payload: Event) => any;
-    complete: (value: string[]) => any;
-    change: (payload: Event) => any;
-    "update:modelValue": (value: string[]) => any;
-}, string, import("vue").PublicProps, Readonly<PinInputProps> & Readonly<{
-    onBlur?: ((payload: Event) => any) | undefined;
-    onComplete?: ((value: string[]) => any) | undefined;
-    onChange?: ((payload: Event) => any) | undefined;
-    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
-}>, {
-    length: number | string;
-    type: "text" | "number";
-    autofocusDelay: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: <T extends PinInputType = "text">(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onBlur?: ((payload: Event) => any) | undefined;
+        readonly onComplete?: ((value: T extends "number" ? number[] : string[]) => any) | undefined;
+        readonly onChange?: ((payload: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: T extends "number" ? number[] : string[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onBlur" | "onChange" | "onUpdate:modelValue" | "onComplete"> & PinInputProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        inputsRef: import("vue").Ref<ComponentPublicInstance[], ComponentPublicInstance[]>;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "blur", payload: Event) => void) & ((evt: "complete", value: T extends "number" ? number[] : string[]) => void) & ((evt: "change", payload: Event) => void) & ((evt: "update:modelValue", value: T extends "number" ? number[] : string[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
 export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/Popover.vue

@@ -58,6 +58,10 @@ const Component = computed(() => props.mode === "hover" ? HoverCard : Popover);
       <slot :open="open" />
     </Component.Trigger>
 
+    <Component.Anchor v-if="'Anchor' in Component && !!slots.anchor" as-child>
+      <slot name="anchor" />
+    </Component.Anchor>
+
     <Component.Portal v-bind="portalProps">
       <Component.Content v-bind="contentProps" :class="ui.content({ class: [!slots.default && props.class, props.ui?.content] })" v-on="contentEvents">
         <slot name="content" />

package/dist/runtime/components/Popover.vue.d.ts

@@ -41,6 +41,7 @@ export interface PopoverSlots {
         open: boolean;
     }): any;
     content(props?: {}): any;
+    anchor(props?: {}): any;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<PopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/runtime/components/Progress.vue

@@ -21,13 +21,14 @@ const props = defineProps({
   class: { type: null, required: false },
   ui: { type: null, required: false },
   getValueLabel: { type: Function, required: false },
+  getValueText: { type: Function, required: false },
   modelValue: { type: [Number, null], required: false, default: null }
 });
 const emits = defineEmits(["update:modelValue", "update:max"]);
 const slots = defineSlots();
 const { dir } = useLocale();
 const appConfig = useAppConfig();
-const rootProps = useForwardPropsEmits(reactivePick(props, "getValueLabel", "modelValue"), emits);
+const rootProps = useForwardPropsEmits(reactivePick(props, "getValueLabel", "getValueText", "modelValue"), emits);
 const isIndeterminate = computed(() => rootProps.value.modelValue === null);
 const hasSteps = computed(() => Array.isArray(props.max));
 const realMax = computed(() => {

package/dist/runtime/components/Progress.vue.d.ts

@@ -3,7 +3,7 @@ import type { AppConfig } from '@nuxt/schema';
 import theme from '#build/ui/progress';
 import type { ComponentConfig } from '../types/utils';
 type Progress = ComponentConfig<typeof theme, AppConfig, 'progress'>;
-export interface ProgressProps extends Pick<ProgressRootProps, 'getValueLabel' | 'modelValue'> {
+export interface ProgressProps extends Pick<ProgressRootProps, 'getValueLabel' | 'getValueText' | 'modelValue'> {
     /**
      * The element or component this component should render as.
      * @defaultValue 'div'

package/dist/runtime/components/RadioGroup.vue

@@ -24,10 +24,10 @@ const props = defineProps({
   indicator: { type: null, required: false },
   class: { type: null, required: false },
   ui: { type: null, required: false },
-  defaultValue: { type: [String, Number, Object, null], required: false },
+  defaultValue: { type: null, required: false },
   disabled: { type: Boolean, required: false },
   loop: { type: Boolean, required: false },
-  modelValue: { type: [String, Number, Object, null], required: false },
+  modelValue: { type: null, required: false },
   name: { type: String, required: false },
   required: { type: Boolean, required: false }
 });

package/dist/runtime/components/Select.vue

@@ -3,8 +3,8 @@ import theme from "#build/ui/select";
 </script>
 
 <script setup>
-import { computed, toRef } from "vue";
-import { SelectRoot, SelectArrow, SelectTrigger, SelectPortal, SelectContent, SelectViewport, SelectLabel, SelectGroup, SelectItem, SelectItemIndicator, SelectItemText, SelectSeparator, useForwardPropsEmits } from "reka-ui";
+import { ref, computed, onMounted, toRef } from "vue";
+import { SelectRoot, SelectArrow, SelectTrigger, SelectPortal, SelectContent, SelectLabel, SelectGroup, SelectItem, SelectItemIndicator, SelectItemText, SelectSeparator, useForwardPropsEmits } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick } from "@vueuse/core";
 import { useAppConfig } from "#imports";
@@ -36,6 +36,8 @@ const props = defineProps({
   modelValue: { type: null, required: false },
   multiple: { type: Boolean, required: false },
   highlight: { type: Boolean, required: false },
+  autofocus: { type: Boolean, required: false },
+  autofocusDelay: { type: Number, required: false, default: 0 },
   class: { type: null, required: false },
   ui: { type: null, required: false },
   open: { type: Boolean, required: false },
@@ -79,11 +81,25 @@ const groups = computed(
 const items = computed(() => groups.value.flatMap((group) => group));
 function displayValue(value) {
   if (props.multiple && Array.isArray(value)) {
-    return value.map((v) => displayValue(v)).filter(Boolean).join(", ");
+    const values = value.map((v) => displayValue(v)).filter(Boolean);
+    return values?.length ? values.join(", ") : void 0;
   }
   const item = items.value.find((item2) => compare(typeof item2 === "object" ? get(item2, props.valueKey) : item2, value));
   return item && (typeof item === "object" ? get(item, props.labelKey) : item);
 }
+const triggerRef = ref(null);
+function autoFocus() {
+  if (props.autofocus) {
+    triggerRef.value?.$el?.focus({
+      focusVisible: true
+    });
+  }
+}
+onMounted(() => {
+  setTimeout(() => {
+    autoFocus();
+  }, props.autofocusDelay);
+});
 function onUpdate(value) {
   const event = new Event("change", { target: { value } });
   emits("change", event);
@@ -104,6 +120,9 @@ function onUpdateOpen(value) {
 function isSelectItem(item) {
   return typeof item === "object" && item !== null;
 }
+defineExpose({
+  triggerRef
+});
 </script>
 
 <template>
@@ -118,7 +137,7 @@ function isSelectItem(item) {
     @update:model-value="onUpdate"
     @update:open="onUpdateOpen"
   >
-    <SelectTrigger :id="id" :class="ui.base({ class: [props.ui?.base, props.class] })" v-bind="{ ...$attrs, ...ariaAttrs }">
+    <SelectTrigger :id="id" ref="triggerRef" :class="ui.base({ class: [props.ui?.base, props.class] })" v-bind="{ ...$attrs, ...ariaAttrs }">
       <span v-if="isLeading || !!avatar || !!slots.leading" :class="ui.leading({ class: props.ui?.leading })">
         <slot name="leading" :model-value="modelValue" :open="open" :ui="ui">
           <UIcon v-if="isLeading && leadingIconName" :name="leadingIconName" :class="ui.leadingIcon({ class: props.ui?.leadingIcon })" />
@@ -128,7 +147,7 @@ function isSelectItem(item) {
 
       <slot :model-value="modelValue" :open="open">
         <template v-for="displayedModelValue in [displayValue(modelValue)]" :key="displayedModelValue">
-          <span v-if="displayedModelValue" :class="ui.value({ class: props.ui?.value })">
+          <span v-if="displayedModelValue !== void 0 && displayedModelValue !== null" :class="ui.value({ class: props.ui?.value })">
             {{ displayedModelValue }}
           </span>
           <span v-else :class="ui.placeholder({ class: props.ui?.placeholder })">
@@ -148,7 +167,7 @@ function isSelectItem(item) {
       <SelectContent :class="ui.content({ class: props.ui?.content })" v-bind="contentProps">
         <slot name="content-top" />
 
-        <SelectViewport :class="ui.viewport({ class: props.ui?.viewport })">
+        <div role="presentation" :class="ui.viewport({ class: props.ui?.viewport })">
           <SelectGroup v-for="(group, groupIndex) in groups" :key="`group-${groupIndex}`" :class="ui.group({ class: props.ui?.group })">
             <template v-for="(item, index) in group" :key="`group-${groupIndex}-${index}`">
               <SelectLabel v-if="isSelectItem(item) && item.type === 'label'" :class="ui.label({ class: [props.ui?.label, item.ui?.label, item.class] })">
@@ -195,7 +214,7 @@ function isSelectItem(item) {
               </SelectItem>
             </template>
           </SelectGroup>
-        </SelectViewport>
+        </div>
 
         <slot name="content-bottom" />
 

package/dist/runtime/components/Select.vue.d.ts

@@ -88,6 +88,8 @@ export interface SelectProps<T extends ArrayOrNested<SelectItem> = ArrayOrNested
     multiple?: M & boolean;
     /** Highlight the ring color like a focus state. */
     highlight?: boolean;
+    autofocus?: boolean;
+    autofocusDelay?: number;
     class?: any;
     ui?: Select['slots'];
 }
@@ -134,7 +136,111 @@ declare const _default: <T extends ArrayOrNested<SelectItem>, VK extends GetItem
         readonly "onUpdate:open"?: ((value: boolean) => any) | undefined;
         readonly "onUpdate:modelValue"?: ((payload: GetModelValue<T, VK, M>) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onUpdate:open" | "onUpdate:modelValue"> & SelectProps<T, VK, M> & Partial<{}>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        triggerRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly reference?: import("reka-ui").ReferenceElement | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").SelectTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").SelectTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly reference?: import("reka-ui").ReferenceElement | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").SelectTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").SelectTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>;
+    }>): void;
     attrs: any;
     slots: SelectSlots<T, VK, M, NestedItem<T>>;
     emit: ((evt: "blur", payload: FocusEvent) => void) & ((evt: "change", payload: Event) => void) & ((evt: "focus", payload: FocusEvent) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", payload: GetModelValue<T, VK, M>) => void);

package/dist/runtime/components/SelectMenu.vue

@@ -3,8 +3,8 @@ import theme from "#build/ui/select-menu";
 </script>
 
 <script setup>
-import { computed, toRef, toRaw } from "vue";
-import { ComboboxRoot, ComboboxArrow, ComboboxAnchor, ComboboxInput, ComboboxTrigger, ComboboxPortal, ComboboxContent, ComboboxViewport, ComboboxEmpty, ComboboxGroup, ComboboxLabel, ComboboxSeparator, ComboboxItem, ComboboxItemIndicator, FocusScope, useForwardPropsEmits, useFilter } from "reka-ui";
+import { ref, computed, onMounted, toRef, toRaw } from "vue";
+import { ComboboxRoot, ComboboxArrow, ComboboxAnchor, ComboboxInput, ComboboxTrigger, ComboboxPortal, ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxLabel, ComboboxSeparator, ComboboxItem, ComboboxItemIndicator, FocusScope, useForwardPropsEmits, useFilter } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick, createReusableTemplate } from "@vueuse/core";
 import { useAppConfig } from "#imports";
@@ -43,6 +43,8 @@ const props = defineProps({
   createItem: { type: [Boolean, String, Object], required: false },
   filterFields: { type: Array, required: false },
   ignoreFilter: { type: Boolean, required: false },
+  autofocus: { type: Boolean, required: false },
+  autofocusDelay: { type: Number, required: false, default: 0 },
   class: { type: null, required: false },
   ui: { type: null, required: false },
   open: { type: Boolean, required: false },
@@ -88,7 +90,8 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.selectMenu ||
 }));
 function displayValue(value) {
   if (props.multiple && Array.isArray(value)) {
-    return value.map((v) => displayValue(v)).filter(Boolean).join(", ");
+    const values = value.map((v) => displayValue(v)).filter(Boolean);
+    return values?.length ? values.join(", ") : void 0;
   }
   if (!props.valueKey) {
     return value && (typeof value === "object" ? get(value, props.labelKey) : value);
@@ -129,6 +132,19 @@ const createItem = computed(() => {
   return !filteredItems.value.length;
 });
 const createItemPosition = computed(() => typeof props.createItem === "object" ? props.createItem.position : "bottom");
+const triggerRef = ref(null);
+function autoFocus() {
+  if (props.autofocus) {
+    triggerRef.value?.$el?.focus({
+      focusVisible: true
+    });
+  }
+}
+onMounted(() => {
+  setTimeout(() => {
+    autoFocus();
+  }, props.autofocusDelay);
+});
 function onUpdate(value) {
   if (toRaw(props.modelValue) === value) {
     return;
@@ -173,6 +189,9 @@ function onSelect(e, item) {
 function isSelectItem(item) {
   return typeof item === "object" && item !== null;
 }
+defineExpose({
+  triggerRef
+});
 </script>
 
 <template>
@@ -204,7 +223,7 @@ function isSelectItem(item) {
     @update:open="onUpdateOpen"
   >
     <ComboboxAnchor as-child>
-      <ComboboxTrigger :class="ui.base({ class: [props.ui?.base, props.class] })" tabindex="0">
+      <ComboboxTrigger ref="triggerRef" :class="ui.base({ class: [props.ui?.base, props.class] })" tabindex="0">
         <span v-if="isLeading || !!avatar || !!slots.leading" :class="ui.leading({ class: props.ui?.leading })">
           <slot name="leading" :model-value="modelValue" :open="open" :ui="ui">
             <UIcon v-if="isLeading && leadingIconName" :name="leadingIconName" :class="ui.leadingIcon({ class: props.ui?.leadingIcon })" />
@@ -214,7 +233,7 @@ function isSelectItem(item) {
 
         <slot :model-value="modelValue" :open="open">
           <template v-for="displayedModelValue in [displayValue(modelValue)]" :key="displayedModelValue">
-            <span v-if="displayedModelValue" :class="ui.value({ class: props.ui?.value })">
+            <span v-if="displayedModelValue !== void 0 && displayedModelValue !== null" :class="ui.value({ class: props.ui?.value })">
               {{ displayedModelValue }}
             </span>
             <span v-else :class="ui.placeholder({ class: props.ui?.placeholder })">
@@ -237,7 +256,7 @@ function isSelectItem(item) {
           <slot name="content-top" />
 
           <ComboboxInput v-if="!!searchInput" v-model="searchTerm" :display-value="() => searchTerm" as-child>
-            <UInput autofocus autocomplete="off" v-bind="searchInputProps" :class="ui.input({ class: props.ui?.input })" />
+            <UInput autofocus autocomplete="off" :size="size" v-bind="searchInputProps" :class="ui.input({ class: props.ui?.input })" />
           </ComboboxInput>
 
           <ComboboxEmpty :class="ui.empty({ class: props.ui?.empty })">
@@ -246,7 +265,7 @@ function isSelectItem(item) {
             </slot>
           </ComboboxEmpty>
 
-          <ComboboxViewport :class="ui.viewport({ class: props.ui?.viewport })">
+          <div role="presentation" :class="ui.viewport({ class: props.ui?.viewport })">
             <ReuseCreateItemTemplate v-if="createItem && createItemPosition === 'top'" />
 
             <ComboboxGroup v-for="(group, groupIndex) in filteredGroups" :key="`group-${groupIndex}`" :class="ui.group({ class: props.ui?.group })">
@@ -297,7 +316,7 @@ function isSelectItem(item) {
             </ComboboxGroup>
 
             <ReuseCreateItemTemplate v-if="createItem && createItemPosition === 'bottom'" />
-          </ComboboxViewport>
+          </div>
 
           <slot name="content-bottom" />
         </FocusScope>

package/dist/runtime/components/SelectMenu.vue.d.ts

@@ -114,6 +114,8 @@ export interface SelectMenuProps<T extends ArrayOrNested<SelectMenuItem> = Array
      * @defaultValue false
      */
     ignoreFilter?: boolean;
+    autofocus?: boolean;
+    autofocusDelay?: number;
     class?: any;
     ui?: SelectMenu['slots'];
 }
@@ -182,7 +184,109 @@ declare const _default: <T extends ArrayOrNested<SelectMenuItem>, VK extends Get
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onUpdate:open" | "onUpdate:modelValue" | "onHighlight" | "onUpdate:searchTerm" | "onCreate"> & (SelectMenuProps<T, VK, M> & {
         searchTerm?: string;
     }) & Partial<{}>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        triggerRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly asChild?: boolean | undefined;
+                readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            as: import("reka-ui").AsTag | import("vue").Component;
+        }> & Omit<Readonly<import("reka-ui").ComboboxTriggerProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>;
+    }>): void;
     attrs: any;
     slots: SelectMenuSlots<T, VK, M, NestedItem<T>>;
     emit: (((evt: "blur", payload: FocusEvent) => void) & ((evt: "change", payload: Event) => void) & ((evt: "focus", payload: FocusEvent) => void) & ((evt: "create", item: string) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", payload: GetModelValue<T, VK, M>) => void) & ((evt: "highlight", payload: {