@sfxcode/nuxt-ui-formkit 1.2.1 → 1.2.2

package/README.md

@@ -43,6 +43,10 @@ FormKit Nuxt UI bridges the gap between [FormKit](https://formkit.com/)'s powerf
 🔁 **Repeater Component** - Dynamic repeatable form sections
 - `nuxtUIRepeater` - Create dynamic lists with add, remove, clone, and reorder functionality
 
+🧭 **Multi-Step Forms** - Wizard-style forms with tab navigation and validation gating
+- `nuxtUIMultiStep` - Tab-strip wizard container built on `@formkit/addons`' `createMultiStepPlugin`
+- `nuxtUIStep` - A single step's content, with Nuxt UI-styled previous/next actions
+
 📊 **6 Output Components** - Display-only components for read-only data
 - `nuxtUIOutputBoolean` - Boolean display with custom icons
 - `nuxtUIOutputDate` - Formatted date/time display
@@ -55,11 +59,19 @@ FormKit Nuxt UI bridges the gap between [FormKit](https://formkit.com/)'s powerf
 - `FUDataEdit` - Edit forms with schema-based configuration
 - `FUDataView` - Read-only data display with schema support
 - `FUDataDebug` - Development tool for form debugging
+- `FUAutoForm` - Schema-free forms: inputs inferred from your data's value shapes, or a Valibot/Zod schema, with an override map for fine-tuning
+
+⚙️ **Config Helper** - One-line `formkit.config.ts` setup
+- `createNuxtUiFormkitConfig` - Assembles all `nuxtUIXxx` inputs/outputs and this module's plugins into `{ inputs, plugins }` you spread into your own config
 
 🔧 **Composables & Utilities** - Reusable form logic
 - `useFormKitSchema` - Schema-based form generation with element builders
 - `useFormKitInput` - Input component utilities and prop handling
 - `useFormKitOutput` - Output component utilities and prop handling
+- `useFormKitRepeater` - Repeater insert/remove/clone/move/drag handlers
+- `useFormKitMultiStep` - Multi-step tab-item mapping and navigation bridging
+- `useFormKitForm` - Submit/reset/error-management wrapper for a form's imperative APIs, callable from outside the form
+- `useFormKitAutoForm` - Schema inference from data value shapes, Valibot, or Zod schemas (`inferFormSchema`/`inferFormSchemaFromValibot`/`inferFormSchemaFromZod`)
 - `colorConverter` - Color format conversion utilities
 - `durationConverter` - Duration format conversion utilities
 
@@ -321,6 +333,12 @@ The playground includes comprehensive examples for all components:
 - [Repeater](./playground/app/pages/form/repeater-sample.vue)
 - [Drag-and-Drop Repeater](./playground/app/pages/form/repeater-drag.vue)
 
+### Multi-Step
+- [Multi-Step Form](./playground/app/pages/form/multi-step.vue)
+
+### Form Composable
+- [useFormKitForm](./playground/app/pages/form/form-composable.vue)
+
 ## Development
 
 <details>

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=4.0.0"
   },
-  "version": "1.2.1",
+  "version": "1.2.2",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -15,7 +15,7 @@ const module$1 = defineNuxtModule({
     addPlugin(resolver.resolve("./runtime/plugin"));
     addImportsDir(resolver.resolve("./runtime/composables"));
     const NPM_PCK_FORMKIT_NUXT_UI = "@sfxcode/nuxt-ui-formkit";
-    const componentNames = ["FUDataView", "FUDataEdit", "FUDataDebug"];
+    const componentNames = ["FUDataView", "FUDataEdit", "FUDataDebug", "FUAutoForm"];
     componentNames.forEach(
       (name) => addComponent({
         name,

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

@@ -0,0 +1,65 @@
+import type { FormKitSchemaDefinition } from '@formkit/core';
+import type { PropType } from 'vue';
+import type { AutoFormOverrides, ValibotLikeSchema, ZodLikeSchema } from '../composables/useFormKitAutoForm.js';
+declare var __VLS_10: string, __VLS_11: any;
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_10>]?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    overrides: {
+        type: PropType<AutoFormOverrides>;
+        default: undefined;
+    };
+    valibotSchema: {
+        type: PropType<ValibotLikeSchema>;
+        default: undefined;
+    };
+    zodSchema: {
+        type: PropType<ZodLikeSchema>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<FormKitSchemaDefinition>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: FormKitSchemaDefinition | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    overrides: {
+        type: PropType<AutoFormOverrides>;
+        default: undefined;
+    };
+    valibotSchema: {
+        type: PropType<ValibotLikeSchema>;
+        default: undefined;
+    };
+    zodSchema: {
+        type: PropType<ZodLikeSchema>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<FormKitSchemaDefinition>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
+}>, {
+    data: Record<string, any>;
+    overrides: AutoFormOverrides;
+    valibotSchema: ValibotLikeSchema;
+    zodSchema: ZodLikeSchema;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/FUAutoForm.vue

@@ -0,0 +1,59 @@
+<script setup>
+import { ref, watch } from "vue";
+import { inferFormSchema, inferFormSchemaFromValibot, inferFormSchemaFromZod } from "../composables/useFormKitAutoForm";
+import FUDataEdit from "./FUDataEdit.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  data: {
+    type: Object,
+    default: null
+  },
+  overrides: {
+    type: Object,
+    default: void 0
+  },
+  valibotSchema: {
+    type: Object,
+    default: void 0
+  },
+  zodSchema: {
+    type: Object,
+    default: void 0
+  }
+});
+const formData = defineModel({ type: [Object, String, Array] });
+if (!formData.value && props.data) {
+  formData.value = props.data;
+}
+function buildSchema(data) {
+  if (props.valibotSchema) {
+    return inferFormSchemaFromValibot(props.valibotSchema, props.overrides);
+  }
+  if (props.zodSchema) {
+    return inferFormSchemaFromZod(props.zodSchema, props.overrides);
+  }
+  return inferFormSchema(data ?? formData.value ?? {}, props.overrides);
+}
+const formSchema = ref(buildSchema(props.data));
+watch([() => props.data, () => props.overrides, () => props.valibotSchema, () => props.zodSchema], ([data]) => {
+  formSchema.value = buildSchema(data);
+});
+</script>
+
+<template>
+  <FUDataEdit
+    v-bind="$attrs"
+    v-model="formData"
+    :schema="formSchema"
+  >
+    <template
+      v-for="(_, name) in $slots"
+      #[name]="slotProps"
+    >
+      <slot
+        :name="name"
+        v-bind="slotProps ?? {}"
+      />
+    </template>
+  </FUDataEdit>
+</template>

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

@@ -0,0 +1,65 @@
+import type { FormKitSchemaDefinition } from '@formkit/core';
+import type { PropType } from 'vue';
+import type { AutoFormOverrides, ValibotLikeSchema, ZodLikeSchema } from '../composables/useFormKitAutoForm.js';
+declare var __VLS_10: string, __VLS_11: any;
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_10>]?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    data: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    overrides: {
+        type: PropType<AutoFormOverrides>;
+        default: undefined;
+    };
+    valibotSchema: {
+        type: PropType<ValibotLikeSchema>;
+        default: undefined;
+    };
+    zodSchema: {
+        type: PropType<ZodLikeSchema>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<FormKitSchemaDefinition>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: FormKitSchemaDefinition | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: ObjectConstructor;
+        default: null;
+    };
+    overrides: {
+        type: PropType<AutoFormOverrides>;
+        default: undefined;
+    };
+    valibotSchema: {
+        type: PropType<ValibotLikeSchema>;
+        default: undefined;
+    };
+    zodSchema: {
+        type: PropType<ZodLikeSchema>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<FormKitSchemaDefinition>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
+}>, {
+    data: Record<string, any>;
+    overrides: AutoFormOverrides;
+    valibotSchema: ValibotLikeSchema;
+    zodSchema: ZodLikeSchema;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -149,9 +149,9 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
 }>, {
+    schema: FormKitSchemaDefinition;
     data: Record<string, any>;
     id: string;
-    schema: FormKitSchemaDefinition;
     formClass: string;
     actionsClass: string;
     submitSeverity: string;

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

@@ -149,9 +149,9 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
 }>, {
+    schema: FormKitSchemaDefinition;
     data: Record<string, any>;
     id: string;
-    schema: FormKitSchemaDefinition;
     formClass: string;
     actionsClass: string;
     submitSeverity: string;

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

@@ -57,8 +57,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
 }>, {
-    data: Record<string, any>;
     schema: FormKitSchemaDefinition;
+    data: Record<string, any>;
     formClass: string;
     debugData: boolean;
     debugSchema: boolean;

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

@@ -57,8 +57,8 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: FormKitSchemaDefinition | undefined) => any) | undefined;
 }>, {
-    data: Record<string, any>;
     schema: FormKitSchemaDefinition;
+    data: Record<string, any>;
     formClass: string;
     debugData: boolean;
     debugSchema: boolean;

package/dist/runtime/composables/useFormKitAutoForm.d.ts

@@ -0,0 +1,38 @@
+import type { FormKitSchemaNode } from '@formkit/core';
+export type AutoFormOverrides = Record<string, Record<string, unknown> | boolean>;
+export declare function inferFormSchema(data: Record<string, unknown>, overrides?: AutoFormOverrides): FormKitSchemaNode[];
+export interface ValibotLikePipeEntry {
+    kind: string;
+    type: string;
+    requirement?: unknown;
+}
+export interface ValibotLikeSchema {
+    kind: 'schema';
+    type: string;
+    entries?: Record<string, ValibotLikeSchema>;
+    item?: ValibotLikeSchema;
+    wrapped?: ValibotLikeSchema;
+    default?: unknown;
+    pipe?: readonly ValibotLikePipeEntry[];
+}
+export declare function inferFormSchemaFromValibot(schema: object, overrides?: AutoFormOverrides): FormKitSchemaNode[];
+export interface ZodLikeSchema {
+    type: string;
+    shape?: Record<string, ZodLikeSchema>;
+    element?: ZodLikeSchema;
+    minLength?: number | null;
+    maxLength?: number | null;
+    minValue?: number | null;
+    maxValue?: number | null;
+    format?: string | null;
+    unwrap?: () => ZodLikeSchema;
+    def?: {
+        defaultValue?: unknown;
+    };
+}
+export declare function inferFormSchemaFromZod(schema: object, overrides?: AutoFormOverrides): FormKitSchemaNode[];
+export declare function useFormKitAutoForm(): {
+    inferFormSchema: typeof inferFormSchema;
+    inferFormSchemaFromValibot: typeof inferFormSchemaFromValibot;
+    inferFormSchemaFromZod: typeof inferFormSchemaFromZod;
+};

package/dist/runtime/composables/useFormKitAutoForm.js

@@ -0,0 +1,349 @@
+import { isDateValue } from "../utils/dateValueConversion.js";
+const REPEATER_BUTTON_DEFAULTS = {
+  displayCloneButton: true,
+  displayDeleteButton: true,
+  buttonGroupClass: "flex gap-2 justify-end"
+};
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+function isIsoDateString(value) {
+  return ISO_DATE_PATTERN.test(value) && !Number.isNaN(Date.parse(value));
+}
+function humanizeKey(key) {
+  return key.replace(/[_-]+/g, " ").replace(/([a-z\d])([A-Z])/g, "$1 $2").split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function blankValue(value) {
+  if (typeof value === "boolean") {
+    return false;
+  }
+  if (typeof value === "number") {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return isIsoDateString(value) ? null : "";
+  }
+  if (Array.isArray(value)) {
+    return [];
+  }
+  if (isPlainObject(value)) {
+    return blankItem(value);
+  }
+  return null;
+}
+function blankItem(item) {
+  const blank = {};
+  for (const [key, value] of Object.entries(item)) {
+    blank[key] = blankValue(value);
+  }
+  return blank;
+}
+function inferNode(name, value, overrides, path) {
+  const label = humanizeKey(name);
+  if (typeof value === "boolean") {
+    return { $formkit: "nuxtUISwitch", name, label };
+  }
+  if (typeof value === "number") {
+    return { $formkit: "nuxtUIInputNumber", name, label };
+  }
+  if (value instanceof Date) {
+    return { $formkit: "nuxtUIInputDate", name, label, valueType: "date" };
+  }
+  if (isDateValue(value)) {
+    return { $formkit: "nuxtUIInputDate", name, label, valueType: "calendar" };
+  }
+  if (typeof value === "string") {
+    if (isIsoDateString(value)) {
+      return { $formkit: "nuxtUIInputDate", name, label, valueType: "iso" };
+    }
+    if (value.includes("\n")) {
+      return { $formkit: "nuxtUITextarea", name, label };
+    }
+    return { $formkit: "nuxtUIInput", name, label };
+  }
+  if (Array.isArray(value)) {
+    const [first] = value;
+    if (isPlainObject(first)) {
+      return {
+        $formkit: "nuxtUIRepeater",
+        name,
+        label,
+        newItem: blankItem(first),
+        children: inferNodes(first, overrides, path),
+        ...REPEATER_BUTTON_DEFAULTS
+      };
+    }
+    return { $formkit: "nuxtUIInputTags", name, label };
+  }
+  if (isPlainObject(value)) {
+    return { $formkit: "group", name, children: inferNodes(value, overrides, path) };
+  }
+  return void 0;
+}
+function isDirectChildPath(path, prefix) {
+  if (!prefix) {
+    return !path.includes(".");
+  }
+  return path.startsWith(`${prefix}.`) && !path.slice(prefix.length + 1).includes(".");
+}
+function buildNodes(source, inferEntry, overrides, pathPrefix = "") {
+  const nodes = [];
+  const consumedPaths = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(source)) {
+    const path = pathPrefix ? `${pathPrefix}.${key}` : key;
+    const override = overrides?.[path];
+    if (override !== void 0) {
+      consumedPaths.add(path);
+    }
+    if (override === false) {
+      continue;
+    }
+    const node = inferEntry(key, value, path);
+    if (override && override !== true) {
+      nodes.push({ $formkit: "nuxtUIInput", name: key, label: humanizeKey(key), ...node, ...override });
+    } else if (node) {
+      nodes.push(node);
+    }
+  }
+  if (overrides) {
+    for (const [path, override] of Object.entries(overrides)) {
+      if (typeof override === "boolean" || consumedPaths.has(path) || !isDirectChildPath(path, pathPrefix)) {
+        continue;
+      }
+      const key = pathPrefix ? path.slice(pathPrefix.length + 1) : path;
+      nodes.push({ $formkit: "nuxtUIInput", name: key, label: humanizeKey(key), ...override });
+    }
+  }
+  return nodes;
+}
+function inferNodes(data, overrides, pathPrefix = "") {
+  return buildNodes(data, (key, value, path) => inferNode(key, value, overrides, path), overrides, pathPrefix);
+}
+export function inferFormSchema(data, overrides) {
+  return inferNodes(data, overrides);
+}
+const OPTIONAL_WRAPPER_TYPES = /* @__PURE__ */ new Set(["optional", "nullable", "nullish", "exact_optional"]);
+function unwrapValibot(entry) {
+  let schema = entry;
+  let required = true;
+  while (OPTIONAL_WRAPPER_TYPES.has(schema.type) && schema.wrapped) {
+    required = false;
+    schema = schema.wrapped;
+  }
+  return { schema, required };
+}
+function deriveValibotValidation(schema, required) {
+  const rules = [];
+  if (required && schema.type !== "boolean") {
+    rules.push("required");
+  }
+  let minLength;
+  let maxLength;
+  for (const entry of schema.pipe ?? []) {
+    if (entry.kind !== "validation") {
+      continue;
+    }
+    if (entry.type === "email" || entry.type === "url") {
+      rules.push(entry.type);
+    } else if (entry.type === "min_length" && typeof entry.requirement === "number") {
+      minLength = entry.requirement;
+    } else if (entry.type === "max_length" && typeof entry.requirement === "number") {
+      maxLength = entry.requirement;
+    } else if (entry.type === "min_value" && typeof entry.requirement === "number") {
+      rules.push(`min:${entry.requirement}`);
+    } else if (entry.type === "max_value" && typeof entry.requirement === "number") {
+      rules.push(`max:${entry.requirement}`);
+    }
+  }
+  if (maxLength !== void 0) {
+    rules.push(`length:${minLength ?? 0},${maxLength}`);
+  } else if (minLength !== void 0) {
+    rules.push(`length:${minLength}`);
+  }
+  return rules.length ? rules.join("|") : void 0;
+}
+function blankValueFromValibot(entry) {
+  if (entry.default !== void 0) {
+    return entry.default;
+  }
+  const { schema } = unwrapValibot(entry);
+  switch (schema.type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return schema.entries ? blankItemFromValibot(schema.entries) : {};
+    default:
+      return null;
+  }
+}
+function blankItemFromValibot(entries) {
+  const blank = {};
+  for (const [key, entry] of Object.entries(entries)) {
+    blank[key] = blankValueFromValibot(entry);
+  }
+  return blank;
+}
+function inferValibotNode(name, entry, overrides, path) {
+  const { schema, required } = unwrapValibot(entry);
+  const label = humanizeKey(name);
+  const validation = deriveValibotValidation(schema, required);
+  const base = validation ? { name, label, validation } : { name, label };
+  switch (schema.type) {
+    case "string":
+      return { $formkit: "nuxtUIInput", ...base };
+    case "number":
+      return { $formkit: "nuxtUIInputNumber", ...base };
+    case "boolean":
+      return { $formkit: "nuxtUISwitch", ...base };
+    case "date":
+      return { $formkit: "nuxtUIInputDate", ...base, valueType: "date" };
+    case "array": {
+      const item = schema.item ? unwrapValibot(schema.item).schema : void 0;
+      if (item?.type === "object" && item.entries) {
+        return {
+          $formkit: "nuxtUIRepeater",
+          ...base,
+          newItem: blankItemFromValibot(item.entries),
+          children: inferValibotNodes(item.entries, overrides, path),
+          ...REPEATER_BUTTON_DEFAULTS
+        };
+      }
+      return { $formkit: "nuxtUIInputTags", ...base };
+    }
+    case "object":
+      return schema.entries ? { $formkit: "group", name, children: inferValibotNodes(schema.entries, overrides, path) } : void 0;
+    default:
+      return void 0;
+  }
+}
+function inferValibotNodes(entries, overrides, pathPrefix = "") {
+  return buildNodes(entries, (key, entry, path) => inferValibotNode(key, entry, overrides, path), overrides, pathPrefix);
+}
+export function inferFormSchemaFromValibot(schema, overrides) {
+  const root = schema;
+  if (root.kind !== "schema" || root.type !== "object" || !root.entries) {
+    return [];
+  }
+  return inferValibotNodes(root.entries, overrides);
+}
+const ZOD_UNWRAPPABLE_TYPES = /* @__PURE__ */ new Set(["optional", "nullable", "nullish", "default"]);
+function unwrapZod(entry) {
+  let schema = entry;
+  let required = true;
+  while (ZOD_UNWRAPPABLE_TYPES.has(schema.type) && typeof schema.unwrap === "function") {
+    required = false;
+    schema = schema.unwrap();
+  }
+  return { schema, required };
+}
+function deriveZodValidation(schema, required) {
+  const rules = [];
+  if (required && schema.type !== "boolean") {
+    rules.push("required");
+  }
+  if (schema.format === "email" || schema.format === "url") {
+    rules.push(schema.format);
+  }
+  if (Number.isFinite(schema.minValue)) {
+    rules.push(`min:${schema.minValue}`);
+  }
+  if (Number.isFinite(schema.maxValue)) {
+    rules.push(`max:${schema.maxValue}`);
+  }
+  if (typeof schema.maxLength === "number") {
+    rules.push(`length:${schema.minLength ?? 0},${schema.maxLength}`);
+  } else if (typeof schema.minLength === "number") {
+    rules.push(`length:${schema.minLength}`);
+  }
+  return rules.length ? rules.join("|") : void 0;
+}
+function blankValueFromZod(entry) {
+  let schema = entry;
+  while (true) {
+    if (schema.def?.defaultValue !== void 0) {
+      return schema.def.defaultValue;
+    }
+    if (!ZOD_UNWRAPPABLE_TYPES.has(schema.type) || typeof schema.unwrap !== "function") {
+      break;
+    }
+    schema = schema.unwrap();
+  }
+  switch (schema.type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return schema.shape ? blankItemFromZod(schema.shape) : {};
+    default:
+      return null;
+  }
+}
+function blankItemFromZod(shape) {
+  const blank = {};
+  for (const [key, entry] of Object.entries(shape)) {
+    blank[key] = blankValueFromZod(entry);
+  }
+  return blank;
+}
+function inferZodNode(name, entry, overrides, path) {
+  const { schema, required } = unwrapZod(entry);
+  const label = humanizeKey(name);
+  const validation = deriveZodValidation(schema, required);
+  const base = validation ? { name, label, validation } : { name, label };
+  switch (schema.type) {
+    case "string":
+      return { $formkit: "nuxtUIInput", ...base };
+    case "number":
+      return { $formkit: "nuxtUIInputNumber", ...base };
+    case "boolean":
+      return { $formkit: "nuxtUISwitch", ...base };
+    case "date":
+      return { $formkit: "nuxtUIInputDate", ...base, valueType: "date" };
+    case "array": {
+      const item = schema.element ? unwrapZod(schema.element).schema : void 0;
+      if (item?.type === "object" && item.shape) {
+        return {
+          $formkit: "nuxtUIRepeater",
+          ...base,
+          newItem: blankItemFromZod(item.shape),
+          children: inferZodNodes(item.shape, overrides, path),
+          ...REPEATER_BUTTON_DEFAULTS
+        };
+      }
+      return { $formkit: "nuxtUIInputTags", ...base };
+    }
+    case "object":
+      return schema.shape ? { $formkit: "group", name, children: inferZodNodes(schema.shape, overrides, path) } : void 0;
+    default:
+      return void 0;
+  }
+}
+function inferZodNodes(shape, overrides, pathPrefix = "") {
+  return buildNodes(shape, (key, entry, path) => inferZodNode(key, entry, overrides, path), overrides, pathPrefix);
+}
+export function inferFormSchemaFromZod(schema, overrides) {
+  const root = schema;
+  if (root.type !== "object" || !root.shape) {
+    return [];
+  }
+  return inferZodNodes(root.shape, overrides);
+}
+export function useFormKitAutoForm() {
+  return { inferFormSchema, inferFormSchemaFromValibot, inferFormSchemaFromZod };
+}