@byyuurin/ui 0.2.0 → 0.4.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

@@ -7,6 +7,7 @@ import { reactivePick } from "@vueuse/core";
 import { Separator, useForwardProps } from "reka-ui";
 import { computed } from "vue";
 import { useAppConfig } from "#imports";
+import { pick } from "../utils";
 import { cv, merge } from "../utils/style";
 import Avatar from "./Avatar.vue";
 import Icon from "./Icon.vue";
@@ -29,7 +30,7 @@ const rootProps = useForwardProps(reactivePick(props, "as", "decorative", "orien
 const appConfig = useAppConfig();
 const ui = computed(() => {
   const styler = cv(merge(theme, appConfig.ui.separator));
-  return styler(props);
+  return styler(pick(props, ["color", "orientation", "size", "type"]));
 });
 </script>
 

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

@@ -6,6 +6,7 @@ import { useAppConfig } from "#imports";
 import { Primitive } from "reka-ui";
 import { computed } from "vue";
 import theme from "#build/ui/skeleton";
+import { pick } from "../utils";
 import { cv, merge } from "../utils/style";
 const props = defineProps({
   as: { type: null, required: false },
@@ -14,7 +15,7 @@ const props = defineProps({
 const appConfig = useAppConfig();
 const ui = computed(() => {
   const styler = cv(merge(theme, appConfig.ui.skeleton));
-  return styler(props);
+  return styler(pick(props, []));
 });
 </script>
 

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

@@ -8,6 +8,7 @@ import { SliderRange, SliderRoot, SliderThumb, SliderTrack, useForwardPropsEmits
 import { computed } from "vue";
 import { useAppConfig } from "#imports";
 import { useFormField } from "../composables/useFormField";
+import { pick } from "../utils";
 import { cv, merge } from "../utils/style";
 import Tooltip from "./Tooltip.vue";
 const props = defineProps({
@@ -52,7 +53,7 @@ const appConfig = useAppConfig();
 const ui = computed(() => {
   const styler = cv(merge(theme, appConfig.ui.slider));
   return styler({
-    ...props,
+    ...pick(props, ["orientation"]),
     size: size.value,
     color: color.value,
     disabled: disabled.value

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,117 @@
+<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 { pick } from "../utils";
+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(pick(props, ["orientation", "size", "color"]));
+});
+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>

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

@@ -0,0 +1,83 @@
+import type { VariantProps } from '@byyuurin/ui-kit';
+import type { StepperRootEmits, StepperRootProps } from 'reka-ui';
+import theme from '#build/ui/stepper';
+import type { ComponentBaseProps, ComponentStyler, ComponentUIProps, IconProps } from '../types';
+import type { DynamicSlots, StaticSlot } from '../types/utils';
+export interface StepperItem extends ComponentBaseProps {
+    slot?: string;
+    value?: string | number;
+    title?: string;
+    description?: string;
+    icon?: IconProps['name'];
+    content?: string;
+    disabled?: boolean;
+    ui?: Pick<ComponentUIProps<typeof theme>, 'item' | 'container' | 'trigger' | 'indicator' | 'icon' | 'separator' | 'wrapper' | 'title' | 'description'>;
+    [key: string]: any;
+}
+type ThemeVariants = VariantProps<typeof theme>;
+export interface StepperProps<T extends StepperItem = StepperItem> extends ComponentBaseProps, Pick<StepperRootProps, 'linear'> {
+    /**
+     * The element or component this component should render as.
+     * @default "div"
+     */
+    as?: StepperRootProps['as'];
+    items?: T[];
+    /** @default "md" */
+    size?: ThemeVariants['size'];
+    /** @default "primary" */
+    color?: ThemeVariants['color'];
+    /** @default "horizontal" */
+    orientation?: ThemeVariants['orientation'];
+    defaultValue?: string | number;
+    modelValue?: string | number;
+    disabled?: boolean;
+    ui?: ComponentUIProps<typeof theme>;
+}
+export type StepperEmits<T extends StepperItem = StepperItem> = Omit<StepperRootEmits, 'update:modelValue'> & {
+    next: [value: T];
+    prev: [value: T];
+};
+export type StepperSlots<T extends StepperItem = StepperItem> = {
+    indicator: StaticSlot<{
+        item: T;
+        ui: ComponentStyler<typeof theme>;
+    }>;
+    title: StaticSlot<{
+        item: T;
+    }>;
+    description: StaticSlot<{
+        item: T;
+    }>;
+    content: StaticSlot<{
+        item: T;
+    }>;
+} & DynamicSlots<T>;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends StepperItem>(__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<(StepperProps<T> & {
+        modelValue?: string | number;
+    }) & {
+        onPrev?: ((value: T) => any) | undefined;
+        onNext?: ((value: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        next(): void;
+        prev(): void;
+        hasNext: import("vue").ComputedRef<boolean>;
+        hasPrev: import("vue").ComputedRef<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: StepperSlots<T>;
+    emit: (((evt: "prev", value: T) => void) & ((evt: "next", value: T) => void)) & ((evt: "update:modelValue", value: string | number | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+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/Switch.vue

@@ -8,6 +8,7 @@ import { Label, Primitive, SwitchRoot, SwitchThumb, useForwardProps } from "reka
 import { computed, useId } from "vue";
 import { useAppConfig } from "#imports";
 import { useFormField } from "../composables/useFormField";
+import { pick } from "../utils";
 import { cv, merge } from "../utils/style";
 import Icon from "./Icon.vue";
 defineOptions({ inheritAttrs: false });
@@ -41,12 +42,10 @@ const appConfig = useAppConfig();
 const ui = computed(() => {
   const styler = cv(merge(theme, appConfig.ui.switch));
   return styler({
-    ...props,
+    ...pick(props, ["required", "loading"]),
     size: size.value,
     color: color.value,
-    disabled: disabled.value || props.loading,
-    checked: false,
-    unchecked: false
+    disabled: disabled.value || props.loading
   });
 });
 function onUpdate(value) {