@nuxt/ui 3.1.1 → 3.1.3

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

@@ -2,7 +2,7 @@ import type { InputHTMLAttributes } from 'vue';
 import type { AppConfig } from '@nuxt/schema';
 import theme from '#build/ui/input';
 import type { UseComponentIconsProps } from '../composables/useComponentIcons';
-import type { ComponentConfig } from '../types/utils';
+import type { AcceptableValue, ComponentConfig } from '../types/utils';
 type Input = ComponentConfig<typeof theme, AppConfig, 'input'>;
 export interface InputProps extends UseComponentIconsProps {
     /**
@@ -34,11 +34,18 @@ export interface InputProps extends UseComponentIconsProps {
     disabled?: boolean;
     /** Highlight the ring color like a focus state. */
     highlight?: boolean;
+    modelModifiers?: {
+        string?: boolean;
+        number?: boolean;
+        trim?: boolean;
+        lazy?: boolean;
+        nullify?: boolean;
+    };
     class?: any;
     ui?: Input['slots'];
 }
-export interface InputEmits {
-    (e: 'update:modelValue', payload: string | number): void;
+export interface InputEmits<T extends AcceptableValue = AcceptableValue> {
+    (e: 'update:modelValue', payload: T): void;
     (e: 'blur', event: FocusEvent): void;
     (e: 'change', event: Event): void;
 }
@@ -47,30 +54,24 @@ export interface InputSlots {
     default(props?: {}): any;
     trailing(props?: {}): any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputProps & {
-    modelValue?: string | number | null;
-}, {
-    inputRef: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string | number | null | undefined) => any;
-} & {
-    blur: (event: FocusEvent) => any;
-    change: (event: Event) => any;
-    "update:modelValue": (payload: string | number) => any;
-}, string, import("vue").PublicProps, Readonly<InputProps & {
-    modelValue?: string | number | null;
-}> & Readonly<{
-    onBlur?: ((event: FocusEvent) => any) | undefined;
-    onChange?: ((event: Event) => any) | undefined;
-    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
-}>, {
-    type: import("vue").InputTypeHTMLAttribute;
-    autocomplete: string;
-    autofocusDelay: number;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, InputSlots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
+declare const _default: <T extends AcceptableValue>(__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?: ((event: FocusEvent) => any) | undefined;
+        readonly onChange?: ((event: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((payload: T) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onBlur" | "onChange" | "onUpdate:modelValue"> & (InputProps & {
+        modelValue?: T;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        inputRef: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    }>): void;
+    attrs: any;
+    slots: InputSlots;
+    emit: InputEmits<T> & ((evt: "update:modelValue", value: T | undefined) => 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/InputMenu.vue

@@ -4,7 +4,7 @@ import theme from "#build/ui/input-menu";
 
 <script setup>
 import { computed, ref, toRef, onMounted, toRaw } from "vue";
-import { ComboboxRoot, ComboboxArrow, ComboboxAnchor, ComboboxInput, ComboboxTrigger, ComboboxPortal, ComboboxContent, ComboboxViewport, ComboboxEmpty, ComboboxGroup, ComboboxLabel, ComboboxSeparator, ComboboxItem, ComboboxItemIndicator, TagsInputRoot, TagsInputItem, TagsInputItemText, TagsInputItemDelete, TagsInputInput, useForwardPropsEmits, useFilter } from "reka-ui";
+import { ComboboxRoot, ComboboxArrow, ComboboxAnchor, ComboboxInput, ComboboxTrigger, ComboboxPortal, ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxLabel, ComboboxSeparator, ComboboxItem, ComboboxItemIndicator, TagsInputRoot, TagsInputItem, TagsInputItemText, TagsInputItemDelete, TagsInputInput, useForwardPropsEmits, useFilter } from "reka-ui";
 import { defu } from "defu";
 import { isEqual } from "ohash/utils";
 import { reactivePick, createReusableTemplate } from "@vueuse/core";
@@ -216,7 +216,7 @@ defineExpose({
       >
         <span :class="ui.itemLabel({ class: props.ui?.itemLabel })">
           <slot name="create-item-label" :item="searchTerm">
-            {{ t('inputMenu.create', { label: searchTerm }) }}
+            {{ t("inputMenu.create", { label: searchTerm }) }}
           </slot>
         </span>
       </ComboboxItem>
@@ -229,7 +229,7 @@ defineExpose({
     v-bind="rootProps"
     :name="name"
     :disabled="disabled"
-    :class="ui.root({ class: [props.class, props.ui?.root] })"
+    :class="ui.root({ class: [props.ui?.root, props.class] })"
     :as-child="!!multiple"
     ignore-filter
     @update:model-value="onUpdate"
@@ -249,16 +249,16 @@ defineExpose({
         @focus="onFocus"
         @remove-tag="onRemoveTag"
       >
-        <TagsInputItem v-for="(item, index) in tags" :key="index" :value="item" :class="ui.tagsItem({ class: props.ui?.tagsItem })">
-          <TagsInputItemText :class="ui.tagsItemText({ class: props.ui?.tagsItemText })">
+        <TagsInputItem v-for="(item, index) in tags" :key="index" :value="item" :class="ui.tagsItem({ class: [props.ui?.tagsItem, isInputItem(item) && item.ui?.tagsItem] })">
+          <TagsInputItemText :class="ui.tagsItemText({ class: [props.ui?.tagsItemText, isInputItem(item) && item.ui?.tagsItemText] })">
             <slot name="tags-item-text" :item="item" :index="index">
               {{ displayValue(item) }}
             </slot>
           </TagsInputItemText>
 
-          <TagsInputItemDelete :class="ui.tagsItemDelete({ class: props.ui?.tagsItemDelete })" :disabled="disabled">
+          <TagsInputItemDelete :class="ui.tagsItemDelete({ class: [props.ui?.tagsItemDelete, isInputItem(item) && item.ui?.tagsItemDelete] })" :disabled="disabled">
             <slot name="tags-item-delete" :item="item" :index="index">
-              <UIcon :name="deleteIcon || appConfig.ui.icons.close" :class="ui.tagsItemDeleteIcon({ class: props.ui?.tagsItemDeleteIcon })" />
+              <UIcon :name="deleteIcon || appConfig.ui.icons.close" :class="ui.tagsItemDeleteIcon({ class: [props.ui?.tagsItemDeleteIcon, isInputItem(item) && item.ui?.tagsItemDeleteIcon] })" />
             </slot>
           </TagsInputItemDelete>
         </TagsInputItem>
@@ -307,53 +307,53 @@ defineExpose({
 
         <ComboboxEmpty :class="ui.empty({ class: props.ui?.empty })">
           <slot name="empty" :search-term="searchTerm">
-            {{ searchTerm ? t('inputMenu.noMatch', { searchTerm }) : t('inputMenu.noData') }}
+            {{ searchTerm ? t("inputMenu.noMatch", { searchTerm }) : t("inputMenu.noData") }}
           </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 })">
             <template v-for="(item, index) in group" :key="`group-${groupIndex}-${index}`">
-              <ComboboxLabel v-if="isInputItem(item) && item.type === 'label'" :class="ui.label({ class: props.ui?.label })">
+              <ComboboxLabel v-if="isInputItem(item) && item.type === 'label'" :class="ui.label({ class: [props.ui?.label, item.ui?.label, item.class] })">
                 {{ get(item, props.labelKey) }}
               </ComboboxLabel>
 
-              <ComboboxSeparator v-else-if="isInputItem(item) && item.type === 'separator'" :class="ui.separator({ class: props.ui?.separator })" />
+              <ComboboxSeparator v-else-if="isInputItem(item) && item.type === 'separator'" :class="ui.separator({ class: [props.ui?.separator, item.ui?.separator, item.class] })" />
 
               <ComboboxItem
                 v-else
-                :class="ui.item({ class: props.ui?.item })"
+                :class="ui.item({ class: [props.ui?.item, isInputItem(item) && item.ui?.item, isInputItem(item) && item.class] })"
                 :disabled="isInputItem(item) && item.disabled"
                 :value="props.valueKey && isInputItem(item) ? get(item, props.valueKey) : item"
                 @select="onSelect($event, item)"
               >
                 <slot name="item" :item="item" :index="index">
                   <slot name="item-leading" :item="item" :index="index">
-                    <UIcon v-if="isInputItem(item) && item.icon" :name="item.icon" :class="ui.itemLeadingIcon({ class: props.ui?.itemLeadingIcon })" />
-                    <UAvatar v-else-if="isInputItem(item) && item.avatar" :size="props.ui?.itemLeadingAvatarSize || ui.itemLeadingAvatarSize()" v-bind="item.avatar" :class="ui.itemLeadingAvatar({ class: props.ui?.itemLeadingAvatar })" />
+                    <UIcon v-if="isInputItem(item) && item.icon" :name="item.icon" :class="ui.itemLeadingIcon({ class: [props.ui?.itemLeadingIcon, item.ui?.itemLeadingIcon] })" />
+                    <UAvatar v-else-if="isInputItem(item) && item.avatar" :size="item.ui?.itemLeadingAvatarSize || props.ui?.itemLeadingAvatarSize || ui.itemLeadingAvatarSize()" v-bind="item.avatar" :class="ui.itemLeadingAvatar({ class: [props.ui?.itemLeadingAvatar, item.ui?.itemLeadingAvatar] })" />
                     <UChip
                       v-else-if="isInputItem(item) && item.chip"
-                      :size="props.ui?.itemLeadingChipSize || ui.itemLeadingChipSize()"
+                      :size="item.ui?.itemLeadingChipSize || props.ui?.itemLeadingChipSize || ui.itemLeadingChipSize()"
                       inset
                       standalone
                       v-bind="item.chip"
-                      :class="ui.itemLeadingChip({ class: props.ui?.itemLeadingChip })"
+                      :class="ui.itemLeadingChip({ class: [props.ui?.itemLeadingChip, item.ui?.itemLeadingChip] })"
                     />
                   </slot>
 
-                  <span :class="ui.itemLabel({ class: props.ui?.itemLabel })">
+                  <span :class="ui.itemLabel({ class: [props.ui?.itemLabel, isInputItem(item) && item.ui?.itemLabel] })">
                     <slot name="item-label" :item="item" :index="index">
                       {{ isInputItem(item) ? get(item, props.labelKey) : item }}
                     </slot>
                   </span>
 
-                  <span :class="ui.itemTrailing({ class: props.ui?.itemTrailing })">
+                  <span :class="ui.itemTrailing({ class: [props.ui?.itemTrailing, isInputItem(item) && item.ui?.itemTrailing] })">
                     <slot name="item-trailing" :item="item" :index="index" />
 
                     <ComboboxItemIndicator as-child>
-                      <UIcon :name="selectedIcon || appConfig.ui.icons.check" :class="ui.itemTrailingIcon({ class: props.ui?.itemTrailingIcon })" />
+                      <UIcon :name="selectedIcon || appConfig.ui.icons.check" :class="ui.itemTrailingIcon({ class: [props.ui?.itemTrailingIcon, isInputItem(item) && item.ui?.itemTrailingIcon] })" />
                     </ComboboxItemIndicator>
                   </span>
                 </slot>
@@ -362,7 +362,7 @@ defineExpose({
           </ComboboxGroup>
 
           <ReuseCreateItemTemplate v-if="createItem && createItemPosition === 'bottom'" />
-        </ComboboxViewport>
+        </div>
 
         <slot name="content-bottom" />
 

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

@@ -21,6 +21,8 @@ interface _InputMenuItem {
     type?: 'label' | 'separator' | 'item';
     disabled?: boolean;
     onSelect?(e?: Event): void;
+    class?: any;
+    ui?: Pick<InputMenu['slots'], 'tagsItem' | 'tagsItemText' | 'tagsItemDelete' | 'tagsItemDeleteIcon' | 'label' | 'separator' | 'item' | 'itemLeadingIcon' | 'itemLeadingAvatarSize' | 'itemLeadingAvatar' | 'itemLeadingChip' | 'itemLeadingChipSize' | 'itemLabel' | 'itemTrailing' | 'itemTrailingIcon'>;
     [key: string]: any;
 }
 export type InputMenuItem = _InputMenuItem | AcceptableValue | boolean;
@@ -204,6 +206,110 @@ declare const _default: <T extends ArrayOrNested<InputMenuItem>, VK extends GetI
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                primitiveElement: ({
+                    $: import("vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly modelValue?: string | undefined;
+                        readonly autoFocus?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                        readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+                        readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }> | null;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("vue").Slot<any> | undefined;
+                    }>;
+                    $root: import("vue").ComponentPublicInstance | null;
+                    $parent: import("vue").ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "update:modelValue", args_0: string) => void;
+                    $el: any;
+                    $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        "update:modelValue": (args_0: string) => any;
+                    }, 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").ListboxFilterProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                }>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        default: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    }> & {
+                        default: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    };
+                }) | null;
             };
             $slots: Readonly<{
                 [name: string]: import("vue").Slot<any> | undefined;
@@ -264,6 +370,110 @@ declare const _default: <T extends ArrayOrNested<InputMenuItem>, VK extends GetI
             };
             $refs: {
                 [x: string]: unknown;
+            } & {
+                primitiveElement: ({
+                    $: import("vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: {
+                        readonly modelValue?: string | undefined;
+                        readonly autoFocus?: boolean | undefined;
+                        readonly disabled?: boolean | undefined;
+                        readonly asChild?: boolean | undefined;
+                        readonly as?: (import("reka-ui").AsTag | import("vue").Component) | undefined;
+                        readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import("vue").ExtractPropTypes<{
+                            asChild: {
+                                type: BooleanConstructor;
+                                default: boolean;
+                            };
+                            as: {
+                                type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                                default: string;
+                            };
+                        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                            [key: string]: any;
+                        }>, {}, {}, {}, {
+                            asChild: boolean;
+                            as: import("reka-ui").AsTag | import("vue").Component;
+                        }> | null;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("vue").Slot<any> | undefined;
+                    }>;
+                    $root: import("vue").ComponentPublicInstance | null;
+                    $parent: import("vue").ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "update:modelValue", args_0: string) => void;
+                    $el: any;
+                    $options: import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ListboxFilterProps> & Readonly<{
+                        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        "update:modelValue": (args_0: string) => any;
+                    }, 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").ListboxFilterProps> & Readonly<{
+                    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+                }>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        default: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    }> & {
+                        default: (props: {
+                            modelValue: string | undefined;
+                        }) => any;
+                    };
+                }) | null;
             };
             $slots: Readonly<{
                 [name: string]: import("vue").Slot<any> | undefined;

package/dist/runtime/components/InputNumber.vue

@@ -7,6 +7,7 @@ import { onMounted, ref, computed } from "vue";
 import { NumberFieldRoot, NumberFieldInput, NumberFieldDecrement, NumberFieldIncrement, useForwardPropsEmits } from "reka-ui";
 import { reactivePick } from "@vueuse/core";
 import { useAppConfig } from "#imports";
+import { useButtonGroup } from "../composables/useButtonGroup";
 import { useFormField } from "../composables/useFormField";
 import { useLocale } from "../composables/useLocale";
 import { tv } from "../utils/tv";
@@ -22,8 +23,10 @@ const props = defineProps({
   orientation: { type: String, required: false, default: "horizontal" },
   increment: { type: Object, required: false },
   incrementIcon: { type: String, required: false },
+  incrementDisabled: { type: Boolean, required: false },
   decrement: { type: Object, required: false },
   decrementIcon: { type: String, required: false },
+  decrementDisabled: { type: Boolean, required: false },
   autofocus: { type: Boolean, required: false },
   autofocusDelay: { type: Number, required: false },
   locale: { type: String, required: false },
@@ -44,17 +47,20 @@ const props = defineProps({
 });
 const emits = defineEmits(["update:modelValue", "blur", "change"]);
 defineSlots();
+const { t, code: codeLocale } = useLocale();
 const appConfig = useAppConfig();
 const rootProps = useForwardPropsEmits(reactivePick(props, "as", "modelValue", "defaultValue", "min", "max", "step", "stepSnapping", "formatOptions", "disableWheelChange"), emits);
-const { emitFormBlur, emitFormFocus, emitFormChange, emitFormInput, id, color, size, name, highlight, disabled, ariaAttrs } = useFormField(props);
-const { t, code: codeLocale } = useLocale();
+const { emitFormBlur, emitFormFocus, emitFormChange, emitFormInput, id, color, size: formGroupSize, name, highlight, disabled, ariaAttrs } = useFormField(props);
+const { orientation, size: buttonGroupSize } = useButtonGroup(props);
 const locale = computed(() => props.locale || codeLocale.value);
+const inputSize = computed(() => buttonGroupSize.value || formGroupSize.value);
 const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.inputNumber || {} })({
   color: color.value,
   variant: props.variant,
-  size: size.value,
+  size: inputSize.value,
   highlight: highlight.value,
-  orientation: props.orientation
+  orientation: props.orientation,
+  buttonGroup: orientation.value
 }));
 const incrementIcon = computed(() => props.incrementIcon || (props.orientation === "horizontal" ? appConfig.ui.icons.plus : appConfig.ui.icons.chevronUp));
 const decrementIcon = computed(() => props.decrementIcon || (props.orientation === "horizontal" ? appConfig.ui.icons.minus : appConfig.ui.icons.chevronDown));
@@ -88,7 +94,7 @@ defineExpose({
   <NumberFieldRoot
     v-bind="rootProps"
     :id="id"
-    :class="ui.root({ class: [props.class, props.ui?.root] })"
+    :class="ui.root({ class: [props.ui?.root, props.class] })"
     :name="name"
     :disabled="disabled"
     :locale="locale"
@@ -105,7 +111,7 @@ defineExpose({
     />
 
     <div :class="ui.increment({ class: props.ui?.increment })">
-      <NumberFieldIncrement as-child :disabled="disabled">
+      <NumberFieldIncrement as-child :disabled="disabled || incrementDisabled">
         <slot name="increment">
           <UButton
             :icon="incrementIcon"
@@ -120,7 +126,7 @@ defineExpose({
     </div>
 
     <div :class="ui.decrement({ class: props.ui?.decrement })">
-      <NumberFieldDecrement as-child :disabled="disabled">
+      <NumberFieldDecrement as-child :disabled="disabled || decrementDisabled">
         <slot name="decrement">
           <UButton
             :icon="decrementIcon"

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

@@ -33,6 +33,8 @@ export interface InputNumberProps extends Pick<NumberFieldRootProps, 'modelValue
      * @IconifyIcon
      */
     incrementIcon?: string;
+    /** Disable the increment button. */
+    incrementDisabled?: boolean;
     /**
      * Configure the decrement button. The `color` and `size` are inherited.
      * @defaultValue { variant: 'link' }
@@ -44,6 +46,8 @@ export interface InputNumberProps extends Pick<NumberFieldRootProps, 'modelValue
      * @IconifyIcon
      */
     decrementIcon?: string;
+    /** Disable the decrement button. */
+    decrementDisabled?: boolean;
     autofocus?: boolean;
     autofocusDelay?: number;
     /**
@@ -76,6 +80,43 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputNumbe
         };
         $refs: {
             [x: string]: unknown;
+        } & {
+            primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }> | null;
         };
         $slots: Readonly<{
             [name: string]: import("vue").Slot<any> | undefined;
@@ -125,6 +166,43 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<InputNumbe
         };
         $refs: {
             [x: string]: unknown;
+        } & {
+            primitiveElement: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                asChild: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                as: {
+                    type: import("vue").PropType<import("reka-ui").AsTag | import("vue").Component>;
+                    default: string;
+                };
+            }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, {}, {}, {}, {
+                asChild: boolean;
+                as: import("reka-ui").AsTag | import("vue").Component;
+            }> | null;
         };
         $slots: Readonly<{
             [name: string]: import("vue").Slot<any> | undefined;