una-nuxt-module 2.1.2 → 2.1.3

package/dist/runtime/components/ui/alert-dialog/AlertDialogDescription.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from "vue";
+import { type AlertDialogDescriptionProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogDescriptionProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogDescriptionProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialogFooter.vue

@@ -0,0 +1,17 @@
+<script setup>
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="alert-dialog-footer"
+    :class="
+  cn('flex flex-col-reverse gap-2 sm:flex-row sm:justify-end', props.class)
+"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/alert-dialog/AlertDialogFooter.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from "vue";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialogHeader.vue

@@ -0,0 +1,15 @@
+<script setup>
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="alert-dialog-header"
+    :class="cn('flex flex-col gap-2 text-center sm:text-left', props.class)"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/alert-dialog/AlertDialogHeader.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from "vue";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialogTitle.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { AlertDialogTitle } from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <AlertDialogTitle
+    data-slot="alert-dialog-title"
+    v-bind="delegatedProps"
+    :class="cn('text-lg font-semibold', props.class)"
+  >
+    <slot />
+  </AlertDialogTitle>
+</template>

package/dist/runtime/components/ui/alert-dialog/AlertDialogTitle.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from "vue";
+import { type AlertDialogTitleProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogTitleProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogTitleProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/AlertDialogTrigger.vue

@@ -0,0 +1,13 @@
+<script setup>
+import { AlertDialogTrigger } from "reka-ui";
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false }
+});
+</script>
+
+<template>
+  <AlertDialogTrigger data-slot="alert-dialog-trigger" v-bind="props">
+    <slot />
+  </AlertDialogTrigger>
+</template>

package/dist/runtime/components/ui/alert-dialog/AlertDialogTrigger.vue.d.ts

@@ -0,0 +1,26 @@
+import { type AlertDialogTriggerProps } from 'reka-ui';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogTriggerProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogTriggerProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert-dialog/index.d.ts

@@ -0,0 +1,9 @@
+export { default as AlertDialog } from './AlertDialog.vue.js';
+export { default as AlertDialogAction } from './AlertDialogAction.vue.js';
+export { default as AlertDialogCancel } from './AlertDialogCancel.vue.js';
+export { default as AlertDialogContent } from './AlertDialogContent.vue.js';
+export { default as AlertDialogDescription } from './AlertDialogDescription.vue.js';
+export { default as AlertDialogFooter } from './AlertDialogFooter.vue.js';
+export { default as AlertDialogHeader } from './AlertDialogHeader.vue.js';
+export { default as AlertDialogTitle } from './AlertDialogTitle.vue.js';
+export { default as AlertDialogTrigger } from './AlertDialogTrigger.vue.js';

package/dist/runtime/components/ui/alert-dialog/index.js

@@ -0,0 +1,9 @@
+export { default as AlertDialog } from "./AlertDialog.vue";
+export { default as AlertDialogAction } from "./AlertDialogAction.vue";
+export { default as AlertDialogCancel } from "./AlertDialogCancel.vue";
+export { default as AlertDialogContent } from "./AlertDialogContent.vue";
+export { default as AlertDialogDescription } from "./AlertDialogDescription.vue";
+export { default as AlertDialogFooter } from "./AlertDialogFooter.vue";
+export { default as AlertDialogHeader } from "./AlertDialogHeader.vue";
+export { default as AlertDialogTitle } from "./AlertDialogTitle.vue";
+export { default as AlertDialogTrigger } from "./AlertDialogTrigger.vue";

package/dist/runtime/components/ui/aspect-ratio/AspectRatio.vue

@@ -0,0 +1,17 @@
+<script setup>
+import { AspectRatio } from "reka-ui";
+const props = defineProps({
+  ratio: { type: Number, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false }
+});
+</script>
+
+<template>
+  <AspectRatio
+    data-slot="aspect-ratio"
+    v-bind="props"
+  >
+    <slot />
+  </AspectRatio>
+</template>

package/dist/runtime/components/ui/aspect-ratio/AspectRatio.vue.d.ts

@@ -0,0 +1,26 @@
+import { type AspectRatioProps } from 'reka-ui';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AspectRatioProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AspectRatioProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/aspect-ratio/index.d.ts

@@ -0,0 +1 @@
+export { default as AspectRatio } from './AspectRatio.vue.js';

package/dist/runtime/components/ui/aspect-ratio/index.js

@@ -0,0 +1 @@
+export { default as AspectRatio } from "./AspectRatio.vue";

package/dist/runtime/components/ui/auto-form/AutoForm.vue

@@ -0,0 +1,90 @@
+<script setup>
+import { Form } from "~/src/runtime/components/ui/form";
+import { toTypedSchema } from "@vee-validate/zod";
+import { computed, toRefs } from "vue";
+import AutoFormField from "./AutoFormField.vue";
+import { provideDependencies } from "./dependencies";
+import { getBaseSchema, getBaseType, getDefaultValueInZodStack, getObjectFormSchema } from "./utils";
+const props = defineProps({
+  schema: { type: null, required: true },
+  form: { type: Object, required: false },
+  fieldConfig: { type: null, required: false },
+  dependencies: { type: Array, required: false }
+});
+const emits = defineEmits(["submit"]);
+const { dependencies } = toRefs(props);
+provideDependencies(dependencies);
+const shapes = computed(() => {
+  const val = {};
+  const baseSchema = getObjectFormSchema(props.schema);
+  const shape = baseSchema.shape;
+  Object.keys(shape).forEach((name) => {
+    const item = shape[name];
+    const baseItem = getBaseSchema(item);
+    let options = baseItem && "values" in baseItem._def ? baseItem._def.values : void 0;
+    if (!Array.isArray(options) && typeof options === "object")
+      options = Object.values(options);
+    val[name] = {
+      type: getBaseType(item),
+      default: getDefaultValueInZodStack(item),
+      options,
+      required: !["ZodOptional", "ZodNullable"].includes(item._def.typeName),
+      schema: baseItem
+    };
+  });
+  return val;
+});
+const fields = computed(() => {
+  const val = {};
+  for (const key in shapes.value) {
+    const shape = shapes.value[key];
+    val[key] = {
+      shape,
+      config: props.fieldConfig?.[key],
+      fieldName: key
+    };
+  }
+  return val;
+});
+const formComponent = computed(() => props.form ? "form" : Form);
+const formComponentProps = computed(() => {
+  if (props.form) {
+    return {
+      onSubmit: props.form.handleSubmit((val) => emits("submit", val))
+    };
+  } else {
+    const formSchema = toTypedSchema(props.schema);
+    return {
+      keepValues: true,
+      validationSchema: formSchema,
+      onSubmit: (val) => emits("submit", val)
+    };
+  }
+});
+</script>
+
+<template>
+  <component
+    :is="formComponent"
+    v-bind="formComponentProps"
+  >
+    <slot name="customAutoForm" :fields="fields">
+      <template v-for="(shape, key) of shapes" :key="key">
+        <slot
+          :shape="shape"
+          :name="key.toString()"
+          :field-name="key.toString()"
+          :config="fieldConfig?.[key]"
+        >
+          <AutoFormField
+            :config="fieldConfig?.[key]"
+            :field-name="key.toString()"
+            :shape="shape"
+          />
+        </slot>
+      </template>
+    </slot>
+
+    <slot :shapes="shapes" />
+  </component>
+</template>

package/dist/runtime/components/ui/auto-form/AutoForm.vue.d.ts

@@ -0,0 +1,35 @@
+import type { FormContext, GenericObject } from 'vee-validate';
+import type { z } from 'zod';
+import type { Config, ConfigItem, Dependency } from './interface.js';
+import { type ZodObjectOrWrapped } from './utils.js';
+declare const _default: <T extends ZodObjectOrWrapped>(__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<any & {
+        schema: T;
+        form?: FormContext<GenericObject>;
+        fieldConfig?: Config<z.infer<T>>;
+        dependencies?: Dependency<z.infer<T>>[];
+    }> & (import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps);
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<NonNullable<keyof z.TypeOf<T>>, (_: {
+        shape: any;
+        fieldName: any;
+        config: ConfigItem;
+    }) => any>> & {
+        customAutoForm?(_: {
+            fields: any;
+        }): any;
+        default?(_: {
+            shapes: any;
+        }): any;
+    };
+    emit: (evt: "submit", event: z.TypeOf<T>) => void;
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/ui/auto-form/AutoFormField.vue

@@ -0,0 +1,35 @@
+<script setup>
+import { computed } from "vue";
+import { DEFAULT_ZOD_HANDLERS, INPUT_COMPONENTS } from "./constant";
+import useDependencies from "./dependencies";
+const props = defineProps({
+  fieldName: { type: String, required: true },
+  shape: { type: Object, required: true },
+  config: { type: null, required: false }
+});
+function isValidConfig(config) {
+  return !!config?.component;
+}
+const delegatedProps = computed(() => {
+  if (["ZodObject", "ZodArray"].includes(props.shape?.type))
+    return { schema: props.shape?.schema };
+  return void 0;
+});
+const { isDisabled, isHidden, isRequired, overrideOptions } = useDependencies(props.fieldName);
+</script>
+
+<template>
+  <component
+    :is="isValidConfig(config) ? typeof config.component === 'string' ? INPUT_COMPONENTS[config.component] : config.component : INPUT_COMPONENTS[DEFAULT_ZOD_HANDLERS[shape.type]]"
+    v-if="!isHidden"
+    :field-name="fieldName"
+    :label="shape.schema?.description"
+    :required="isRequired || shape.required"
+    :options="overrideOptions || shape.options"
+    :disabled="isDisabled"
+    :config="config"
+    v-bind="delegatedProps"
+  >
+    <slot />
+  </component>
+</template>

package/dist/runtime/components/ui/auto-form/AutoFormField.vue.d.ts

@@ -0,0 +1,23 @@
+import type { ZodAny } from 'zod';
+import type { Config, ConfigItem, Shape } from './interface.js';
+declare const _default: <U extends ZodAny>(__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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        fieldName: string;
+        shape: Shape;
+        config?: ConfigItem | Config<U>;
+    }> & (import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps);
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: {};
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/ui/auto-form/AutoFormFieldArray.vue

@@ -0,0 +1,92 @@
+<script setup>
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from "~/src/runtime/components/ui/accordion";
+import { Button } from "~/src/runtime/components/ui/button";
+import { FormItem, FormMessage } from "~/src/runtime/components/ui/form";
+import { Separator } from "~/src/runtime/components/ui/separator";
+import { PlusIcon, TrashIcon } from "lucide-vue-next";
+import { FieldArray, FieldContextKey, useField } from "vee-validate";
+import { computed, provide } from "vue";
+import * as z from "zod";
+import AutoFormField from "./AutoFormField.vue";
+import AutoFormLabel from "./AutoFormLabel.vue";
+import { beautifyObjectName, getBaseType } from "./utils";
+const props = defineProps({
+  fieldName: { type: String, required: true },
+  required: { type: Boolean, required: false },
+  config: { type: null, required: false },
+  schema: { type: null, required: false },
+  disabled: { type: Boolean, required: false }
+});
+function isZodArray(item) {
+  return item instanceof z.ZodArray;
+}
+function isZodDefault(item) {
+  return item instanceof z.ZodDefault;
+}
+const itemShape = computed(() => {
+  if (!props.schema)
+    return;
+  const schema = isZodArray(props.schema) ? props.schema._def.type : isZodDefault(props.schema) ? props.schema._def.innerType._def.type : null;
+  return {
+    type: getBaseType(schema),
+    schema
+  };
+});
+const fieldContext = useField(props.fieldName);
+provide(FieldContextKey, fieldContext);
+</script>
+
+<template>
+  <FieldArray v-slot="{ fields, remove, push }" as="section" :name="fieldName">
+    <slot v-bind="props">
+      <Accordion type="multiple" class="w-full" collapsible :disabled="disabled" as-child>
+        <FormItem>
+          <AccordionItem :value="fieldName" class="border-none">
+            <AccordionTrigger>
+              <AutoFormLabel class="text-base" :required="required">
+                {{ schema?.description || beautifyObjectName(fieldName) }}
+              </AutoFormLabel>
+            </AccordionTrigger>
+
+            <AccordionContent>
+              <template v-for="(field, index) of fields" :key="field.key">
+                <div class="mb-4 p-1">
+                  <AutoFormField
+                    :field-name="`${fieldName}[${index}]`"
+                    :label="fieldName"
+                    :shape="itemShape"
+                    :config="config"
+                  />
+
+                  <div class="!my-4 flex justify-end">
+                    <Button
+                      type="button"
+                      size="icon"
+                      variant="secondary"
+                      @click="remove(index)"
+                    >
+                      <TrashIcon :size="16" />
+                    </Button>
+                  </div>
+                  <Separator v-if="!field.isLast" />
+                </div>
+              </template>
+
+              <Button
+                type="button"
+                variant="secondary"
+                class="mt-4 flex items-center"
+                @click="push(null)"
+              >
+                <PlusIcon class="mr-2" :size="16" />
+                Add
+              </Button>
+            </AccordionContent>
+
+            <FormMessage />
+          </AccordionItem>
+        </FormItem>
+      </Accordion>
+    </slot>
+  </FieldArray>
+</template>

package/dist/runtime/components/ui/auto-form/AutoFormFieldBoolean.vue

@@ -0,0 +1,44 @@
+<script setup>
+import { Checkbox } from "~/src/runtime/components/ui/checkbox";
+import { FormControl, FormDescription, FormField, FormItem, FormMessage } from "~/src/runtime/components/ui/form";
+import { Switch } from "~/src/runtime/components/ui/switch";
+import { computed } from "vue";
+import AutoFormLabel from "./AutoFormLabel.vue";
+import { beautifyObjectName, maybeBooleanishToBoolean } from "./utils";
+const props = defineProps({
+  fieldName: { type: String, required: true },
+  label: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  config: { type: Object, required: false },
+  disabled: { type: Boolean, required: false }
+});
+const booleanComponent = computed(() => props.config?.component === "switch" ? Switch : Checkbox);
+</script>
+
+<template>
+  <FormField v-slot="slotProps" :name="fieldName">
+    <FormItem>
+      <div class="space-y-0 mb-3 flex items-center gap-3">
+        <FormControl>
+          <slot v-bind="slotProps">
+            <component
+              :is="booleanComponent"
+              :disabled="maybeBooleanishToBoolean(config?.inputProps?.disabled) ?? disabled"
+              :name="slotProps.componentField.name"
+              :model-value="slotProps.componentField.modelValue"
+              @update:model-value="slotProps.componentField['onUpdate:modelValue']"
+            />
+          </slot>
+        </FormControl>
+        <AutoFormLabel v-if="!config?.hideLabel" :required="required">
+          {{ config?.label || beautifyObjectName(label ?? fieldName) }}
+        </AutoFormLabel>
+      </div>
+
+      <FormDescription v-if="config?.description">
+        {{ config.description }}
+      </FormDescription>
+      <FormMessage />
+    </FormItem>
+  </FormField>
+</template>

package/dist/runtime/components/ui/auto-form/AutoFormFieldBoolean.vue.d.ts

@@ -0,0 +1,26 @@
+import type { FieldProps } from './interface.js';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: any): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<FieldProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<FieldProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};