@nuxt/ui 3.1.3 → 3.2.0

package/dist/runtime/components/InputTags.vue

@@ -0,0 +1,159 @@
+<script>
+import theme from "#build/ui/input-tags";
+</script>
+
+<script setup>
+import { computed, ref, onMounted, toRaw } from "vue";
+import { TagsInputRoot, TagsInputItem, TagsInputItemText, TagsInputItemDelete, TagsInputInput, useForwardPropsEmits } from "reka-ui";
+import { reactivePick } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useButtonGroup } from "../composables/useButtonGroup";
+import { useComponentIcons } from "../composables/useComponentIcons";
+import { useFormField } from "../composables/useFormField";
+import { tv } from "../utils/tv";
+import UIcon from "./Icon.vue";
+import UAvatar from "./Avatar.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: null, required: false },
+  placeholder: { type: String, required: false },
+  color: { type: null, required: false },
+  variant: { type: null, required: false },
+  size: { type: null, required: false },
+  autofocus: { type: Boolean, required: false },
+  autofocusDelay: { type: Number, required: false, default: 0 },
+  deleteIcon: { type: String, required: false },
+  highlight: { type: Boolean, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false },
+  modelValue: { type: [Array, null], required: false },
+  defaultValue: { type: Array, required: false },
+  addOnPaste: { type: Boolean, required: false },
+  addOnTab: { type: Boolean, required: false },
+  addOnBlur: { type: Boolean, required: false },
+  duplicate: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  delimiter: { type: null, required: false },
+  max: { type: Number, required: false },
+  id: { type: String, required: false },
+  convertValue: { type: Function, required: false },
+  displayValue: { type: Function, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  icon: { type: String, required: false },
+  avatar: { type: Object, required: false },
+  leading: { type: Boolean, required: false },
+  leadingIcon: { type: String, required: false },
+  trailing: { type: Boolean, required: false },
+  trailingIcon: { type: String, required: false },
+  loading: { type: Boolean, required: false },
+  loadingIcon: { type: String, required: false }
+});
+const emits = defineEmits(["change", "blur", "focus", "update:modelValue", "invalid", "addTag", "removeTag"]);
+const slots = defineSlots();
+const appConfig = useAppConfig();
+const rootProps = useForwardPropsEmits(reactivePick(props, "as", "addOnPaste", "addOnTab", "addOnBlur", "duplicate", "delimiter", "max", "convertValue", "displayValue", "required"), emits);
+const { emitFormBlur, emitFormFocus, emitFormChange, emitFormInput, size: formGroupSize, color, id, name, highlight, disabled, ariaAttrs } = useFormField(props);
+const { orientation, size: buttonGroupSize } = useButtonGroup(props);
+const { isLeading, isTrailing, leadingIconName, trailingIconName } = useComponentIcons(props);
+const inputSize = computed(() => buttonGroupSize.value || formGroupSize.value);
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.inputTags || {} })({
+  color: color.value,
+  variant: props.variant,
+  size: inputSize?.value,
+  loading: props.loading,
+  highlight: highlight.value,
+  leading: isLeading.value || !!props.avatar || !!slots.leading,
+  trailing: isTrailing.value || !!slots.trailing,
+  buttonGroup: orientation.value
+}));
+const inputRef = ref(null);
+onMounted(() => {
+  setTimeout(() => {
+    autoFocus();
+  }, props.autofocusDelay);
+});
+function autoFocus() {
+  if (props.autofocus) {
+    inputRef.value?.$el?.focus();
+  }
+}
+function onUpdate(value) {
+  if (toRaw(props.modelValue) === value) {
+    return;
+  }
+  const event = new Event("change", { target: { value } });
+  emits("change", event);
+  emitFormChange();
+  emitFormInput();
+}
+function onBlur(event) {
+  emits("blur", event);
+  emitFormBlur();
+}
+function onFocus(event) {
+  emits("focus", event);
+  emitFormFocus();
+}
+defineExpose({
+  inputRef
+});
+</script>
+
+<template>
+  <TagsInputRoot
+    :id="id"
+    v-slot="{ modelValue: tags }"
+    :model-value="modelValue"
+    :default-value="defaultValue"
+    :class="ui.root({ class: [ui.base({ class: props.ui?.base }), props.ui?.root, props.class] })"
+    v-bind="rootProps"
+    :name="name"
+    :disabled="disabled"
+    @update:model-value="onUpdate"
+    @blur="onBlur"
+    @focus="onFocus"
+  >
+    <TagsInputItem
+      v-for="(item, index) in tags"
+      :key="index"
+      :value="item"
+      :class="ui.item({ class: [props.ui?.item] })"
+    >
+      <TagsInputItemText :class="ui.itemText({ class: [props.ui?.itemText] })">
+        <slot v-if="!!slots['item-text']" name="item-text" :item="item" :index="index" />
+      </TagsInputItemText>
+
+      <TagsInputItemDelete
+        :class="ui.itemDelete({ class: [props.ui?.itemDelete] })"
+        :disabled="disabled"
+      >
+        <slot name="item-delete" :item="item" :index="index">
+          <UIcon :name="deleteIcon || appConfig.ui.icons.close" :class="ui.itemDeleteIcon({ class: [props.ui?.itemDeleteIcon] })" />
+        </slot>
+      </TagsInputItemDelete>
+    </TagsInputItem>
+
+    <TagsInputInput
+      ref="inputRef"
+      v-bind="{ ...$attrs, ...ariaAttrs }"
+      :placeholder="placeholder"
+      :class="ui.input({ class: props.ui?.input })"
+    />
+
+    <slot />
+
+    <span v-if="isLeading || !!avatar || !!slots.leading" :class="ui.leading({ class: props.ui?.leading })">
+      <slot name="leading">
+        <UIcon v-if="isLeading && leadingIconName" :name="leadingIconName" :class="ui.leadingIcon({ class: props.ui?.leadingIcon })" />
+        <UAvatar v-else-if="!!avatar" :size="props.ui?.leadingAvatarSize || ui.leadingAvatarSize()" v-bind="avatar" :class="ui.leadingAvatar({ class: props.ui?.leadingAvatar })" />
+      </slot>
+    </span>
+
+    <span v-if="isTrailing || !!slots.trailing" :class="ui.trailing({ class: props.ui?.trailing })">
+      <slot name="trailing">
+        <UIcon v-if="trailingIconName" :name="trailingIconName" :class="ui.trailingIcon({ class: props.ui?.trailingIcon })" />
+      </slot>
+    </span>
+  </TagsInputRoot>
+</template>

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

@@ -0,0 +1,183 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { TagsInputRootProps, TagsInputRootEmits, AcceptableInputValue } from 'reka-ui';
+import theme from '#build/ui/input-tags';
+import type { UseComponentIconsProps } from '../composables/useComponentIcons';
+import type { ComponentConfig } from '../types/utils';
+type InputTags = ComponentConfig<typeof theme, AppConfig, 'inputTags'>;
+export type InputTagItem = AcceptableInputValue;
+export interface InputTagsProps<T extends InputTagItem = InputTagItem> extends Pick<TagsInputRootProps<T>, 'modelValue' | 'defaultValue' | 'addOnPaste' | 'addOnTab' | 'addOnBlur' | 'duplicate' | 'disabled' | 'delimiter' | 'max' | 'id' | 'convertValue' | 'displayValue' | 'name' | 'required'>, UseComponentIconsProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /** The placeholder text when the input is empty. */
+    placeholder?: string;
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: InputTags['variants']['color'];
+    /**
+     * @defaultValue 'outline'
+     */
+    variant?: InputTags['variants']['variant'];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: InputTags['variants']['size'];
+    autofocus?: boolean;
+    autofocusDelay?: number;
+    /**
+     * The icon displayed to delete a tag.
+     * @defaultValue appConfig.ui.icons.close
+     * @IconifyIcon
+     */
+    deleteIcon?: string;
+    /** Highlight the ring color like a focus state. */
+    highlight?: boolean;
+    class?: any;
+    ui?: InputTags['slots'];
+}
+export interface InputTagsEmits<T extends InputTagItem> extends TagsInputRootEmits<T> {
+    change: [event: Event];
+    blur: [event: FocusEvent];
+    focus: [event: FocusEvent];
+}
+type SlotProps<T extends InputTagItem> = (props: {
+    item: T;
+    index: number;
+}) => any;
+export interface InputTagsSlots<T extends InputTagItem = InputTagItem> {
+    'leading'(props?: {}): any;
+    'default'(props?: {}): any;
+    'trailing'(props?: {}): any;
+    'item-text': SlotProps<T>;
+    'item-delete': SlotProps<T>;
+}
+declare const _default: <T extends InputTagItem>(__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 onFocus?: ((event: FocusEvent) => any) | undefined;
+        readonly onInvalid?: ((payload: T) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((payload: T[]) => any) | undefined;
+        readonly onRemoveTag?: ((payload: T) => any) | undefined;
+        readonly onAddTag?: ((payload: T) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onInvalid" | "onUpdate:modelValue" | "onRemoveTag" | "onAddTag"> & InputTagsProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        inputRef: import("vue").Ref<({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly placeholder?: string | undefined;
+                readonly autoFocus?: boolean | undefined;
+                readonly maxLength?: number | 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").TagsInputInputProps> & 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").TagsInputInputProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null, ({
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly placeholder?: string | undefined;
+                readonly autoFocus?: boolean | undefined;
+                readonly maxLength?: number | 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").TagsInputInputProps> & 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").TagsInputInputProps> & Readonly<{}>, "as"> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null>;
+    }>): void;
+    attrs: any;
+    slots: InputTagsSlots<T>;
+    emit: ((evt: "blur", event: FocusEvent) => void) & ((evt: "change", event: Event) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", payload: T) => void) & ((evt: "update:modelValue", payload: T[]) => void) & ((evt: "removeTag", payload: T) => void) & ((evt: "addTag", payload: T) => 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/Modal.vue

@@ -40,14 +40,14 @@ const contentEvents = computed(() => {
     closeAutoFocus: (e) => e.preventDefault()
   };
   if (!props.dismissible) {
-    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown", "closeAutoFocus"];
+    const events = ["pointerDownOutside", "interactOutside", "escapeKeyDown"];
     return events.reduce((acc, curr) => {
       acc[curr] = (e) => {
         e.preventDefault();
         emits("close:prevent");
       };
       return acc;
-    }, {});
+    }, defaultEvents);
   }
   return defaultEvents;
 });
@@ -58,7 +58,7 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.modal || {} }
 </script>
 
 <template>
-  <DialogRoot v-slot="{ open }" v-bind="rootProps">
+  <DialogRoot v-slot="{ open, close }" v-bind="rootProps">
     <DialogTrigger v-if="!!slots.default" as-child :class="props.class">
       <slot :open="open" />
     </DialogTrigger>
@@ -81,9 +81,9 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.modal || {} }
           </DialogDescription>
         </VisuallyHidden>
 
-        <slot name="content">
-          <div v-if="!!slots.header || (title || !!slots.title) || (description || !!slots.description) || (close || !!slots.close)" :class="ui.header({ class: props.ui?.header })">
-            <slot name="header">
+        <slot name="content" :close="close">
+          <div v-if="!!slots.header || (title || !!slots.title) || (description || !!slots.description) || (props.close || !!slots.close)" :class="ui.header({ class: props.ui?.header })">
+            <slot name="header" :close="close">
               <div :class="ui.wrapper({ class: props.ui?.wrapper })">
                 <DialogTitle v-if="title || !!slots.title" :class="ui.title({ class: props.ui?.title })">
                   <slot name="title">
@@ -98,16 +98,17 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.modal || {} }
                 </DialogDescription>
               </div>
 
-              <DialogClose v-if="close || !!slots.close" as-child>
-                <slot name="close" :ui="ui">
+              <slot name="actions" />
+
+              <DialogClose v-if="props.close || !!slots.close" as-child>
+                <slot name="close" :close="close" :ui="ui">
                   <UButton
-                    v-if="close"
+                    v-if="props.close"
                     :icon="closeIcon || appConfig.ui.icons.close"
-                    size="md"
                     color="neutral"
                     variant="ghost"
                     :aria-label="t('modal.close')"
-                    v-bind="typeof close === 'object' ? close : {}"
+                    v-bind="typeof props.close === 'object' ? props.close : {}"
                     :class="ui.close({ class: props.ui?.close })"
                   />
                 </slot>
@@ -116,11 +117,11 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.modal || {} }
           </div>
 
           <div v-if="!!slots.body" :class="ui.body({ class: props.ui?.body })">
-            <slot name="body" />
+            <slot name="body" :close="close" />
           </div>
 
           <div v-if="!!slots.footer" :class="ui.footer({ class: props.ui?.footer })">
-            <slot name="footer" />
+            <slot name="footer" :close="close" />
           </div>
         </slot>
       </DialogContent>

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

@@ -58,17 +58,27 @@ export interface ModalSlots {
     default(props: {
         open: boolean;
     }): any;
-    content(props?: {}): any;
-    header(props?: {}): any;
+    content(props: {
+        close: () => void;
+    }): any;
+    header(props: {
+        close: () => void;
+    }): any;
     title(props?: {}): any;
     description(props?: {}): any;
+    actions(props?: {}): any;
     close(props: {
+        close: () => void;
         ui: {
             [K in keyof Required<Modal['slots']>]: (props?: Record<string, any>) => string;
         };
     }): any;
-    body(props?: {}): any;
-    footer(props?: {}): any;
+    body(props: {
+        close: () => void;
+    }): any;
+    footer(props: {
+        close: () => void;
+    }): any;
 }
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ModalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;

package/dist/runtime/components/NavigationMenu.vue

@@ -88,19 +88,13 @@ const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.navigationMen
 const lists = computed(
   () => props.items?.length ? isArrayOfArray(props.items) ? props.items : [props.items] : []
 );
-function getAccordionDefaultValue(list) {
-  function findItemsWithDefaultOpen(items, level = 0) {
-    return items.reduce((acc, item, index) => {
-      if (item.defaultOpen || item.open) {
-        acc.push(item.value || (level > 0 ? `item-${level}-${index}` : `item-${index}`));
-      }
-      if (item.children?.length) {
-        acc.push(...findItemsWithDefaultOpen(item.children, level + 1));
-      }
-      return acc;
-    }, []);
-  }
-  const indexes = findItemsWithDefaultOpen(list);
+function getAccordionDefaultValue(list, level = 0) {
+  const indexes = list.reduce((acc, item, index) => {
+    if (item.defaultOpen || item.open) {
+      acc.push(item.value || (level > 0 ? `item-${level}-${index}` : `item-${index}`));
+    }
+    return acc;
+  }, []);
   return props.type === "single" ? indexes[0] : indexes;
 }
 </script>
@@ -228,7 +222,14 @@ function getAccordionDefaultValue(list) {
       </ULink>
 
       <AccordionContent v-if="orientation === 'vertical' && item.children?.length && !collapsed" :class="ui.content({ class: [props.ui?.content, item.ui?.content] })">
-        <ul :class="ui.childList({ class: props.ui?.childList })">
+        <AccordionRoot
+          v-bind="{
+  ...accordionProps,
+  defaultValue: getAccordionDefaultValue(item.children, level + 1)
+}"
+          as="ul"
+          :class="ui.childList({ class: props.ui?.childList })"
+        >
           <ReuseItemTemplate
             v-for="(childItem, childIndex) in item.children"
             :key="childIndex"
@@ -237,7 +238,7 @@ function getAccordionDefaultValue(list) {
             :level="level + 1"
             :class="ui.childItem({ class: [props.ui?.childItem, childItem.ui?.childItem] })"
           />
-        </ul>
+        </AccordionRoot>
       </AccordionContent>
     </component>
   </DefineItemTemplate>

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/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(() => {