@byyuurin/ui 0.1.0 → 0.3.0

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

@@ -1,9 +1,11 @@
 import type { VariantProps } from '@byyuurin/ui-kit';
-import type { SelectArrowProps, SelectContentEmits, SelectContentProps, SelectRootEmits, SelectRootProps } from 'reka-ui';
+import type { ComboboxArrowProps, ComboboxContentEmits, ComboboxContentProps, ComboboxRootEmits, ComboboxRootProps } from 'reka-ui';
 import theme from '#build/ui/select';
 import type { UseComponentIconsProps } from '../composables/useComponentIcons';
-import type { AvatarProps, ChipProps, ComponentBaseProps, ComponentStyler, ComponentUIProps, IconProps } from '../types';
-import type { AcceptableValue, ArrayOrNested, EmitsToProps, GetItemKeys, GetModelValue, GetModelValueEmits, MaybeNull, NestedItem, StaticSlot } from '../types/utils';
+import type { AvatarProps, ButtonProps, ChipProps, ComponentBaseProps, ComponentStyler, ComponentUIProps, IconProps, InputProps, LinkPropsKeys } from '../types';
+import type { ButtonHTMLAttributes } from '../types/html';
+import type { ModelModifiers } from '../types/input';
+import type { AcceptableValue, ArrayOrNested, EmitsToProps, GetItemKeys, GetModelValue, GetModelValueEmits, MaybeNull, NestedItem, Nullable, StaticSlot } from '../types/utils';
 export type SelectValue = Exclude<AcceptableValue, boolean>;
 export type SelectItem = SelectValue | {
     label?: string;
@@ -24,10 +26,22 @@ export type SelectItem = SelectValue | {
     [key: string]: any;
 };
 type ThemeVariants = VariantProps<typeof theme>;
-export interface SelectProps<T extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>, VK extends GetItemKeys<T> = 'value', M extends boolean = false> extends ComponentBaseProps, UseComponentIconsProps, Omit<SelectRootProps<T>, 'dir' | 'multiple' | 'modelValue' | 'defaultValue' | 'by'> {
+export interface SelectProps<T extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>, VK extends Nullable<GetItemKeys<T>> = 'value', M extends boolean = false> extends ComponentBaseProps, UseComponentIconsProps, Pick<ComboboxRootProps, 'open' | 'defaultOpen' | 'disabled' | 'name' | 'resetSearchTermOnBlur' | 'resetSearchTermOnSelect' | 'resetModelValueOnClear' | 'highlightOnHover'>, /** @vue-ignore */ Omit<ButtonHTMLAttributes, 'type' | 'disabled' | 'value' | 'name'> {
     id?: string;
     /** The placeholder text when the select is empty. */
     placeholder?: string;
+    /**
+     * Whether to display the search input or not.
+     *
+     * Can be an object to pass additional props to the input.
+     *
+     * `{ placeholder: "Search...", variant: "none" }`
+     *
+     * @default false
+     */
+    searchInput?: boolean | InputProps;
+    searchTerm?: string;
+    required?: boolean;
     /** @default "outline" */
     variant?: ThemeVariants['variant'];
     /** @default "md" */
@@ -44,16 +58,27 @@ export interface SelectProps<T extends ArrayOrNested<SelectItem> = ArrayOrNested
      * @default app.icons.check
      */
     selectedIcon?: IconProps['name'];
+    /**
+     * Display a clear button to reset the model value.
+     * Can be an object to pass additional props to the Button.
+     * @default false
+     */
+    clear?: boolean | Partial<Omit<ButtonProps, LinkPropsKeys>>;
+    /**
+     * The icon displayed in the clear button.
+     * @default app.icons.close
+     */
+    clearIcon?: IconProps['name'];
     /**
      * The content of the menu.
      * @default { side: 'bottom', sideOffset: 8, collisionPadding: 8, position: 'popper' }
      */
-    content?: Omit<SelectContentProps, 'as' | 'asChild' | 'forceMount'> & Partial<EmitsToProps<SelectContentEmits>>;
+    content?: Omit<ComboboxContentProps, 'as' | 'asChild' | 'forceMount'> & Partial<EmitsToProps<ComboboxContentEmits>>;
     /**
      * Display an arrow alongside the menu.
      * @default false
      */
-    arrow?: boolean | Omit<SelectArrowProps, 'as' | 'asChild'>;
+    arrow?: boolean | Omit<ComboboxArrowProps, 'as' | 'asChild'>;
     /**
      * Render the menu in a portal.
      * @default true
@@ -79,20 +104,49 @@ export interface SelectProps<T extends ArrayOrNested<SelectItem> = ArrayOrNested
     defaultValue?: MaybeNull<GetModelValue<T, VK, M>>;
     /** The controlled value of the Select. Can be bind as `v-model`. */
     modelValue?: MaybeNull<GetModelValue<T, VK, M>>;
+    modelModifiers?: Omit<ModelModifiers<GetModelValue<T, VK, M>>, 'lazy'>;
     /** Whether multiple options can be selected or not. */
     multiple?: M & boolean;
     /** Highlight the ring color like a focus state. */
     highlight?: boolean;
+    /**
+     * Determines if custom user input that does not exist in options can be added.
+     * @default false
+     */
+    createItem?: boolean | 'always' | {
+        position?: 'top' | 'bottom';
+        when?: 'empty' | 'always';
+    };
+    /**
+     * Fields to filter items by.
+     * @default [labelKey]
+     */
+    filterFields?: string[];
+    /**
+     * When `true`, disable the default filters, useful for custom filtering (useAsyncData, useFetch, etc.).
+     * @default false
+     */
+    ignoreFilter?: boolean;
     autofocus?: boolean;
     autofocusDelay?: number;
     ui?: ComponentUIProps<typeof theme>;
 }
-export type SelectEmits<A extends ArrayOrNested<SelectItem>, VK extends GetItemKeys<A> | undefined, M extends boolean> = Omit<SelectRootEmits, 'update:modelValue'> & {
-    change: [event: Event];
-    blur: [event: FocusEvent];
-    focus: [event: FocusEvent];
+export type SelectEmits<A extends ArrayOrNested<SelectItem>, VK extends Nullable<GetItemKeys<A>>, M extends boolean> = Omit<ComboboxRootEmits, 'update:modelValue'> & {
+    'change': [event: Event];
+    'blur': [event: FocusEvent];
+    'focus': [event: FocusEvent];
+    'create': [item: string];
+    'clear': [];
+    /** Event handler when highlighted element changes. */
+    'highlight': [
+        payload: {
+            ref: HTMLElement;
+            value: GetModelValue<A, VK, M>;
+        } | undefined
+    ];
+    'update:searchTerm': [value: string];
 } & GetModelValueEmits<A, VK, M>;
-export interface SelectSlots<A extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>, VK extends GetItemKeys<A> | undefined = undefined, M extends boolean = false, T extends NestedItem<A> = NestedItem<A>> {
+export interface SelectSlots<A extends ArrayOrNested<SelectItem> = ArrayOrNested<SelectItem>, VK extends Nullable<GetItemKeys<A>> = undefined, M extends boolean = false, T extends NestedItem<A> = NestedItem<A>> {
     'leading': StaticSlot<{
         modelValue?: MaybeNull<GetModelValue<A, VK, M>>;
         open: boolean;
@@ -108,6 +162,9 @@ export interface SelectSlots<A extends ArrayOrNested<SelectItem> = ArrayOrNested
         open: boolean;
         ui: ComponentStyler<typeof theme>;
     }>;
+    'empty': StaticSlot<{
+        searchTerm?: string;
+    }>;
     'item': StaticSlot<{
         item: T;
         index: number;
@@ -133,128 +190,51 @@ export interface SelectSlots<A extends ArrayOrNested<SelectItem> = ArrayOrNested
     }>;
     'content-top': StaticSlot;
     'content-bottom': StaticSlot;
+    'create-item-label': StaticSlot<{
+        item: string;
+    }>;
 }
-declare const __VLS_export: <T extends ArrayOrNested<SelectItem>, VK extends GetItemKeys<T> = "value", M extends boolean = false>(__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<SelectProps<T, VK, M> & {
-        onChange?: ((event: Event) => any) | undefined;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends ArrayOrNested<SelectItem>, VK extends Nullable<GetItemKeys<T>> = "value", M extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(SelectProps<T, VK, M> & {
+        searchTerm?: string;
+    }) & {
         onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
         onFocus?: ((event: FocusEvent) => any) | undefined;
+        onHighlight?: ((...args: (({
+            ref: HTMLElement;
+            value: import("reka-ui").AcceptableValue;
+        } & {
+            ref: HTMLElement;
+            value: GetModelValue<T, VK, M>;
+        }) | undefined)[]) => any) | undefined;
+        onCreate?: ((item: string) => any) | undefined;
+        onClear?: (() => any) | undefined;
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
         "onUpdate:modelValue"?: ((value: GetModelValue<T, VK, M>) => any) | undefined;
-    }> & import("vue").PublicProps;
+        "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
     expose: (exposed: import("vue").ShallowUnwrapRef<{
-        triggerRef: import("vue").ShallowRef<MaybeNull<{
-            $: 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?: (props: {}) => any;
-            };
-        }>, MaybeNull<{
-            $: 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?: (props: {}) => any;
-            };
-        }>>;
+        triggerRef: Readonly<import("vue").Ref<HTMLButtonElement, HTMLButtonElement>>;
     }>) => void;
     attrs: any;
     slots: SelectSlots<T, VK, M, NestedItem<T>>;
-    emit: ((evt: "change", event: Event) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: GetModelValue<T, VK, M>) => void);
+    emit: (((evt: "blur", event: FocusEvent) => void) & ((evt: "change", event: Event) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "highlight", ...args: [payload: {
+        ref: HTMLElement;
+        value: import("reka-ui").AcceptableValue;
+    } | undefined] & [payload: {
+        ref: HTMLElement;
+        value: GetModelValue<T, VK, M>;
+    } | undefined]) => void) & ((evt: "create", item: string) => void) & ((evt: "clear") => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: GetModelValue<T, VK, M>) => void) & ((evt: "update:searchTerm", value: string) => void)) & ((evt: "update:searchTerm", value: string) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = {
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
     [K in keyof T as K]: T[K];
-} & {};
+}) & {};

package/dist/runtime/components/Separator.vue

@@ -34,34 +34,34 @@ const ui = computed(() => {
 </script>
 
 <template>
-  <Separator v-bind="rootProps" :class="ui.root({ class: [props.ui?.root, props.class] })" data-part="root">
-    <div :class="ui.border({ class: props.ui?.border, start: props.align === 'start' })" data-part="border"></div>
-
-    <template v-if="props.label || props.icon || props.avatar || !!slots.default">
-      <div :class="ui.container({ class: props.ui?.container })" data-part="container">
-        <slot :ui="ui">
-          <span
-            v-if="props.label"
-            :class="ui.label({ class: props.ui?.label })"
-            data-part="label"
-          >{{ props.label }}</span>
-          <Icon
-            v-else-if="props.icon"
-            :name="props.icon"
-            :class="ui.icon({ class: props.ui?.icon })"
-            data-part="icon"
-          />
-          <Avatar
-            v-else-if="props.avatar"
-            :size="props.ui?.avatarSize || ui.avatarSize()"
-            v-bind="props.avatar"
-            :class="ui.avatar({ class: props.ui?.avatar })"
-            data-part="avatar"
-          />
-        </slot>
-      </div>
-
-      <div :class="ui.border({ class: props.ui?.border, end: props.align === 'end' })" data-part="border"></div>
-    </template>
-  </Separator>
+  <Separator v-bind="rootProps" :class="ui.root({ class: [props.ui?.root, props.class] })" data-part="root">
+    <div :class="ui.border({ class: props.ui?.border, start: props.align === 'start' })" data-part="border"></div>
+
+    <template v-if="props.label || props.icon || props.avatar || !!slots.default">
+      <div :class="ui.container({ class: props.ui?.container })" data-part="container">
+        <slot :ui="ui">
+          <span
+            v-if="props.label"
+            :class="ui.label({ class: props.ui?.label })"
+            data-part="label"
+          >{{ props.label }}</span>
+          <Icon
+            v-else-if="props.icon"
+            :name="props.icon"
+            :class="ui.icon({ class: props.ui?.icon })"
+            data-part="icon"
+          />
+          <Avatar
+            v-else-if="props.avatar"
+            :size="props.ui?.avatarSize || ui.avatarSize()"
+            v-bind="props.avatar"
+            :class="ui.avatar({ class: props.ui?.avatar })"
+            data-part="avatar"
+          />
+        </slot>
+      </div>
+
+      <div :class="ui.border({ class: props.ui?.border, end: props.align === 'end' })" data-part="border"></div>
+    </template>
+  </Separator>
 </template>

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

@@ -35,12 +35,12 @@ export interface SeparatorSlots {
         ui: ComponentStyler<typeof theme>;
     }>;
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
     orientation: "horizontal" | "vertical";
     align: "start" | "end" | "center";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SeparatorSlots>;
-declare const _default: typeof __VLS_export;
-export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/runtime/components/Skeleton.vue

@@ -19,15 +19,15 @@ const ui = computed(() => {
 </script>
 
 <template>
-  <Primitive
-    :as="props.as"
-    aria-busy="true"
-    aria-label="loading"
-    aria-live="polite"
-    role="alert"
-    :class="ui.base({ class: props.class })"
-    data-part="base"
-  >
-    <slot></slot>
-  </Primitive>
+  <Primitive
+    :as="props.as"
+    aria-busy="true"
+    aria-label="loading"
+    aria-live="polite"
+    role="alert"
+    :class="ui.base({ class: props.class })"
+    data-part="base"
+  >
+    <slot></slot>
+  </Primitive>
 </template>

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

@@ -7,11 +7,11 @@ export interface SkeletonProps extends ComponentBaseProps {
      */
     as?: PrimitiveProps['as'];
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;
-declare const _default: typeof __VLS_export;
-export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/runtime/components/Slider.vue

@@ -66,29 +66,29 @@ function onChange(value) {
 </script>
 
 <template>
-  <SliderRoot
-    v-bind="{ ...rootProps, ...ariaAttrs, id, name, disabled }"
-    v-model="sliderValue"
-    :default-value="defaultSliderValue"
-    :class="ui.root({ class: [props.ui?.root, props.class] })"
-    :data-steps="thumbs"
-    data-part="root"
-    @update:model-value="emitFormInput()"
-    @value-commit="onChange"
-  >
-    <SliderTrack :class="ui.track({ class: props.ui?.track })" data-part="track">
-      <SliderRange :class="ui.range({ class: props.ui?.range })" data-part="range" />
-    </SliderTrack>
-
-    <Tooltip
-      v-for="thumb in thumbs"
-      :key="thumb"
-      v-bind="typeof props.tooltip === 'object' ? props.tooltip : {}"
-      :text="String(thumbs > 1 ? sliderValue?.[thumb - 1] : sliderValue)"
-      :disabled="!props.tooltip"
-      disable-closing-trigger
-    >
-      <SliderThumb :class="ui.thumb({ class: props.ui?.thumb })" data-part="thumb" />
-    </Tooltip>
-  </SliderRoot>
+  <SliderRoot
+    v-bind="{ ...rootProps, ...ariaAttrs, id, name, disabled }"
+    v-model="sliderValue"
+    :default-value="defaultSliderValue"
+    :class="ui.root({ class: [props.ui?.root, props.class] })"
+    :data-steps="thumbs"
+    data-part="root"
+    @update:model-value="emitFormInput()"
+    @value-commit="onChange"
+  >
+    <SliderTrack :class="ui.track({ class: props.ui?.track })" data-part="track">
+      <SliderRange :class="ui.range({ class: props.ui?.range })" data-part="range" />
+    </SliderTrack>
+
+    <Tooltip
+      v-for="thumb in thumbs"
+      :key="thumb"
+      v-bind="typeof props.tooltip === 'object' ? props.tooltip : {}"
+      :text="String(thumbs > 1 ? sliderValue?.[thumb - 1] : sliderValue)"
+      :disabled="!props.tooltip"
+      disable-closing-trigger
+    >
+      <SliderThumb :class="ui.thumb({ class: props.ui?.thumb })" data-part="thumb" :aria-label="thumbs === 1 ? 'Thumb' : `Thumb ${thumb} of ${thumbs}`" />
+    </Tooltip>
+  </SliderRoot>
 </template>

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

@@ -33,11 +33,15 @@ export interface SliderEmits<T extends MaybeArray<number>> {
     'update:modelValue': [value: T];
     'change': [event: Event];
 }
-declare const __VLS_export: <T extends MaybeArray<number>>(__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<SliderProps<T> & {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends MaybeArray<number>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<SliderProps<T> & {
         onChange?: ((event: Event) => any) | undefined;
         "onUpdate:modelValue"?: ((value: T) => any) | undefined;
-    }> & import("vue").PublicProps;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {};
@@ -45,8 +49,8 @@ declare const __VLS_export: <T extends MaybeArray<number>>(__VLS_props: NonNulla
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = {
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
     [K in keyof T as K]: T[K];
-} & {};
+}) & {};

package/dist/runtime/components/Stepper.vue

@@ -0,0 +1,116 @@
+<script>
+import theme from "#build/ui/stepper";
+</script>
+
+<script setup>
+import { reactivePick } from "@vueuse/core";
+import { StepperDescription, StepperIndicator, StepperItem, StepperRoot, StepperSeparator, StepperTitle, StepperTrigger, useForwardProps } from "reka-ui";
+import { computed } from "vue";
+import { useAppConfig } from "#imports";
+import { cv, merge } from "../utils/style";
+import Icon from "./Icon.vue";
+const props = defineProps({
+  as: { type: null, required: false },
+  items: { type: Array, required: false },
+  size: { type: null, required: false },
+  color: { type: null, required: false },
+  orientation: { type: null, required: false, default: "horizontal" },
+  defaultValue: { type: [String, Number], required: false },
+  modelValue: { type: [String, Number], required: false },
+  disabled: { type: Boolean, required: false },
+  ui: { type: null, required: false },
+  class: { type: [Object, String, Number, Boolean, null, Array], required: false, skipCheck: true },
+  linear: { type: Boolean, required: false, default: true }
+});
+const emit = defineEmits(["next", "prev"]);
+const slots = defineSlots();
+const modelValue = defineModel({ type: [String, Number] });
+const appConfig = useAppConfig();
+const ui = computed(() => {
+  const styler = cv(merge(theme, appConfig.ui.stepper));
+  return styler(props);
+});
+const rootProps = useForwardProps(reactivePick(props, "as", "orientation", "linear"));
+const currentStepIndex = computed({
+  get() {
+    const value = modelValue.value ?? props.defaultValue;
+    return (typeof value === "string" ? props.items?.findIndex((item) => item.value === value) : value) ?? 0;
+  },
+  set(value) {
+    modelValue.value = props.items?.[value]?.value ?? value;
+  }
+});
+const currentStep = computed(() => props.items?.[currentStepIndex.value]);
+const hasNext = computed(() => currentStepIndex.value < (props.items?.length ?? 0) - 1);
+const hasPrev = computed(() => currentStepIndex.value > 0);
+defineExpose({
+  next() {
+    if (!props.disabled && hasNext.value) {
+      currentStepIndex.value += 1;
+      emit("next", currentStep.value);
+    }
+  },
+  prev() {
+    if (!props.disabled && hasPrev.value) {
+      currentStepIndex.value -= 1;
+      emit("prev", currentStep.value);
+    }
+  },
+  hasNext,
+  hasPrev
+});
+</script>
+
+<template>
+  <StepperRoot v-bind="rootProps" v-model="currentStepIndex" :class="ui.root({ class: [props.ui?.root, props.class] })" data-part="root">
+    <div :class="ui.header({ class: props.ui?.header })" data-part="header">
+      <StepperItem
+        v-for="(item, count) in props.items"
+        :key="item.value ?? count"
+        :step="count"
+        :disabled="item.disabled || props.disabled"
+        :class="ui.item({ class: [props.ui?.item, item.ui?.item, item.class] })"
+        data-part="item"
+      >
+        <div :class="ui.container({ class: [props.ui?.container, item.ui?.container] })" data-part="container">
+          <StepperTrigger :class="ui.trigger({ class: [props.ui?.trigger, item.ui?.trigger] })" data-part="trigger">
+            <StepperIndicator :class="ui.indicator({ class: [props.ui?.indicator, item.ui?.indicator] })" data-part="indicator">
+              <slot name="indicator" :item="item" :ui="ui">
+                <Icon v-if="item.icon" :name="item.icon" :class="ui.icon({ class: [props.ui?.icon, item.ui?.icon] })" data-part="icon" />
+                <template v-else>
+                  {{ count + 1 }}
+                </template>
+              </slot>
+            </StepperIndicator>
+          </StepperTrigger>
+
+          <StepperSeparator
+            v-if="count < props.items.length - 1"
+            :class="ui.separator({ class: [props.ui?.separator, item.ui?.separator] })"
+            data-part="separator"
+          />
+        </div>
+
+        <div :class="ui.wrapper({ class: [props.ui?.wrapper, item.ui?.wrapper] })" data-part="wrapper">
+          <StepperTitle as="div" :class="ui.title({ class: [props.ui?.title, item.ui?.title] })" data-part="title">
+            <slot name="title" :item="item">
+              {{ item.title }}
+            </slot>
+          </StepperTitle>
+
+          <StepperDescription as="div" :class="ui.description({ class: [props.ui?.description, item.ui?.description] })" data-part="description">
+            <slot name="description" :item="item">
+              {{ item.description }}
+            </slot>
+          </StepperDescription>
+        </div>
+      </StepperItem>
+    </div>
+
+    <div v-if="currentStep?.content || !!slots.content || currentStep?.slot" :class="ui.content({ class: props.ui?.content })" data-part="content">
+      <slot :name="currentStep?.slot || 'content'" :item="currentStep">
+        {{ currentStep?.content }}
+      </slot>
+    </div>
+  </StepperRoot>
+</template>