@sfxcode/nuxt-ui-formkit 1.2.0 → 1.2.2

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 };
+}

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

@@ -0,0 +1,11 @@
+import type { ErrorMessages } from '@formkit/core';
+export declare function useFormKitForm(id: string): {
+    submit: (handler?: () => unknown | Promise<unknown>) => void;
+    reset: (resetTo?: unknown) => void;
+    setErrors: (localErrors: ErrorMessages, childErrors?: ErrorMessages) => void;
+    clearErrors: (clearChildren?: boolean) => void;
+    isValid: import("vue").ComputedRef<boolean>;
+    isSubmitted: import("vue").ComputedRef<boolean>;
+    hasErrors: import("vue").ComputedRef<boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+};

package/dist/runtime/composables/useFormKitForm.js

@@ -0,0 +1,38 @@
+import { clearErrors, reset, setErrors, submitForm } from "@formkit/core";
+import { useFormKitContextById } from "@formkit/vue";
+import { computed, ref } from "vue";
+export function useFormKitForm(id) {
+  const context = useFormKitContextById(id);
+  const isLoading = ref(false);
+  const isValid = computed(() => context.value?.state.valid ?? false);
+  const isSubmitted = computed(() => context.value?.state.submitted ?? false);
+  const hasErrors = computed(() => context.value?.state.errors ?? false);
+  function submit(handler) {
+    submitForm(id);
+    if (!handler)
+      return;
+    isLoading.value = true;
+    void Promise.resolve(handler()).finally(() => {
+      isLoading.value = false;
+    });
+  }
+  function resetForm(resetTo) {
+    reset(id, resetTo);
+  }
+  function setFormErrors(localErrors, childErrors) {
+    setErrors(id, localErrors, childErrors);
+  }
+  function clearFormErrors(clearChildren) {
+    clearErrors(id, clearChildren);
+  }
+  return {
+    submit,
+    reset: resetForm,
+    setErrors: setFormErrors,
+    clearErrors: clearFormErrors,
+    isValid,
+    isSubmitted,
+    hasErrors,
+    isLoading
+  };
+}

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

@@ -0,0 +1,5 @@
+import type { FormKitNode } from '@formkit/core';
+export declare function useFormKitMultiStep(): {
+    addMultiStepHandler: (node: FormKitNode) => void;
+    addStepHandler: (node: FormKitNode) => void;
+};

package/dist/runtime/composables/useFormKitMultiStep.js

@@ -0,0 +1,65 @@
+import { ref, watchEffect } from "vue";
+export function useFormKitMultiStep() {
+  function buildTabItems(node) {
+    const steps = Array.isArray(node.props.steps) ? node.props.steps : [];
+    const validStepIcon = typeof node.props.validStepIcon === "string" ? node.props.validStepIcon : "i-lucide-check";
+    const allowIncomplete = node.props.allowIncomplete !== false;
+    const activeIndex = steps.findIndex((step) => step.node?.name === node.props.activeStep);
+    const activeStepInvalid = activeIndex >= 0 && steps[activeIndex]?.isValid === false;
+    return steps.map((step, index) => {
+      const totalErrorCount = (step.errorCount ?? 0) + (step.blockingCount ?? 0);
+      const item = {
+        label: step.stepName,
+        value: step.node?.name,
+        // Jumping ahead to a step you haven't visited yet while the current
+        // step is invalid would just be silently blocked by the addon's own
+        // `isTargetStepAllowed` gating on click - disable it proactively
+        // instead so it's not clickable-but-inert. Steps already visited
+        // (including the active one) stay enabled, matching the addon's own
+        // "moving backward is always allowed" rule.
+        disabled: !allowIncomplete && !step.hasBeenVisited && index > activeIndex && activeStepInvalid
+      };
+      const isActive = index === activeIndex;
+      if (step.showStepErrors && totalErrorCount > 0)
+        item.badge = { label: totalErrorCount, color: "error", variant: isActive ? "solid" : void 0 };
+      else if (step.isValid && step.hasBeenVisited)
+        item.badge = { icon: validStepIcon, color: "success", variant: isActive ? "solid" : void 0 };
+      return item;
+    });
+  }
+  function addMultiStepHandler(node) {
+    const structuralVersion = ref(0);
+    const bumpStructuralVersion = () => {
+      structuralVersion.value++;
+    };
+    node.on("child", bumpStructuralVersion);
+    node.on("childRemoved", bumpStructuralVersion);
+    node.on("prop:steps", bumpStructuralVersion);
+    node.on("prop:activeStep", bumpStructuralVersion);
+    node.on("created", () => {
+      if (!node.context)
+        return;
+      watchEffect(() => {
+        void structuralVersion.value;
+        if (node.context)
+          node.context.tabItems = buildTabItems(node);
+      });
+      node.context.handleTabChange = (value) => {
+        node.goTo(value);
+      };
+    });
+  }
+  function addStepHandler(node) {
+    node.on("created", () => {
+      if (!node.context)
+        return;
+      node.context.internalStepActionsClass = node.context.stepActionsClass ? `formkit-step-actions ${node.context.stepActionsClass}` : "formkit-step-actions flex gap-2 pt-2";
+      watchEffect(() => {
+        const allowIncomplete = node.parent?.props.allowIncomplete !== false;
+        if (node.context)
+          node.context.nextDisabled = !allowIncomplete && node.context.isValid === false;
+      });
+    });
+  }
+  return { addMultiStepHandler, addStepHandler };
+}

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

@@ -0,0 +1,4 @@
+import type { FormKitNode } from '@formkit/core';
+export declare function useFormKitRepeater(): {
+    addRepeaterHandler: (node: FormKitNode) => void;
+};

package/dist/runtime/composables/useFormKitRepeater.js

@@ -0,0 +1,138 @@
+export function useFormKitRepeater() {
+  function addRepeaterHandler(node) {
+    const swapElements = (array, index1, index2) => {
+      const [element] = array.splice(index1, 1);
+      if (element !== void 0) {
+        array.splice(index2, 0, element);
+      }
+      return array;
+    };
+    const uuid = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2);
+    const syncOuterValue = (value) => {
+      node.input(value, false);
+    };
+    node.on("created", () => {
+      if (node.context) {
+        let dragStartIndex = null;
+        let dragOverIndex = null;
+        const newItem = node.context.newItem || {};
+        node.context.listName = node.name;
+        node.context.renderButtons = !node.context.hideButtonGroup;
+        node.context.insertButtonSize = node.context.insertButtonSize ? node.context.insertButtonSize : "md";
+        node.context.buttonSize = node.context.buttonSize ? node.context.buttonSize : "md";
+        node.context.renderMoveButtons = !node.context.hideMoveButtons;
+        node.context.draggable = !!node.context.draggable;
+        node.context.renderDragHandle = !!node.context.displayDragHandle;
+        node.context.dragHandleIconName = node.context.dragHandleIconName || "i-lucide-grip-vertical";
+        node.context.internalDragHandleClass = node.context.dragHandleClass ? `formkit-repeater-drag-handle ${node.context.dragHandleClass}` : "formkit-repeater-drag-handle";
+        node.context.internalListClass = node.context.listClass ? `formkit-items ${node.context.listClass}` : "formkit-items";
+        node.context.internalListItemClass = node.context.listItemClass ? `formkit-item ${node.context.listItemClass}` : "formkit-item";
+        node.context.internalListId = `formkit-items-${uuid}`;
+        node.context.minItems = node.context.minItems !== void 0 ? node.context.minItems : 0;
+        node.context.maxItems = node.context.maxItems !== void 0 ? node.context.maxItems : Number.POSITIVE_INFINITY;
+        node.context.repeaterValidation = [["length", node.context.minItems, node.context.maxItems]];
+        node.context.getListItemClass = (index) => {
+          if (dragOverIndex === index && dragStartIndex !== index)
+            return `${node.context?.internalListItemClass} formkit-repeater-drop-target`;
+          return node.context?.internalListItemClass?.toString() ?? "";
+        };
+        node.context.getListItemId = (index) => {
+          return `formkit-item-${index}-${uuid}`;
+        };
+        node.context.insertNode = (parentNode) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            const newArray = [{ ...newItem }, ...parentNode.value];
+            parentNode.input(newArray, false);
+            syncOuterValue(newArray);
+          }
+        };
+        node.context.removeNode = (parentNode, index) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            const newArray = parentNode._value.filter((_, i) => i !== index);
+            parentNode.input(newArray, false);
+            syncOuterValue(newArray);
+          }
+        };
+        node.context.addNode = (parentNode, index) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            const array = parentNode.value;
+            array.splice(index + 1, 0, { ...newItem });
+            parentNode.input(array, false);
+            syncOuterValue(array);
+          }
+        };
+        node.context.cloneNode = (parentNode, index) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            const item = parentNode.value[index];
+            const array = parentNode.value;
+            array.splice(index + 1, 0, { ...item });
+            parentNode.input(array, false);
+            syncOuterValue(array);
+          }
+        };
+        node.context.moveNodeUp = (parentNode, index) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            if (index > 0) {
+              const newArray = swapElements(parentNode.value, index - 1, index);
+              parentNode.input(newArray, false);
+              syncOuterValue(newArray);
+            }
+          }
+        };
+        node.context.moveNodeDown = (parentNode, index) => () => {
+          if (parentNode && Array.isArray(parentNode._value)) {
+            if (index < parentNode.value.length - 1) {
+              const newArray = swapElements(parentNode.value, index, index + 1);
+              parentNode.input(newArray, false);
+              syncOuterValue(newArray);
+            }
+          }
+        };
+        node.context.dragNodeStart = (_parentNode, index) => (event) => {
+          dragStartIndex = index;
+          if (event?.dataTransfer) {
+            event.dataTransfer.effectAllowed = "move";
+            event.dataTransfer.setData("text/plain", String(index));
+          }
+        };
+        node.context.dragNodeOver = (targetIndex) => (event) => {
+          event?.preventDefault();
+          dragOverIndex = targetIndex;
+          if (event?.dataTransfer)
+            event.dataTransfer.dropEffect = "move";
+        };
+        node.context.dragNodeLeave = (targetIndex) => () => {
+          if (dragOverIndex === targetIndex)
+            dragOverIndex = null;
+        };
+        node.context.dropNode = (parentNode, targetIndex) => (event) => {
+          event?.preventDefault();
+          if (!parentNode || !Array.isArray(parentNode._value)) {
+            dragOverIndex = null;
+            return;
+          }
+          const sourceFromEvent = Number.parseInt(event?.dataTransfer?.getData("text/plain") || "", 10);
+          const sourceIndex = Number.isInteger(sourceFromEvent) ? sourceFromEvent : dragStartIndex;
+          if (sourceIndex === null || sourceIndex === targetIndex) {
+            dragOverIndex = null;
+            return;
+          }
+          if (sourceIndex < 0 || sourceIndex >= parentNode.value.length) {
+            dragOverIndex = null;
+            return;
+          }
+          const newArray = swapElements(parentNode.value, sourceIndex, targetIndex);
+          parentNode.input(newArray, false);
+          syncOuterValue(newArray);
+          dragStartIndex = null;
+          dragOverIndex = null;
+        };
+        node.context.dragNodeEnd = () => {
+          dragStartIndex = null;
+          dragOverIndex = null;
+        };
+      }
+    });
+  }
+  return { addRepeaterHandler };
+}

package/dist/runtime/formkit/createNuxtUiFormkitConfig.d.ts

@@ -0,0 +1,19 @@
+import type { DefaultConfigOptions } from '@formkit/vue';
+export interface CreateNuxtUiFormkitConfigOptions {
+    /**
+     * Registers `createMultiStepPlugin()` so `nuxtUIMultiStep`/`nuxtUIStep`
+     * actually work. The input type registrations themselves are always
+     * included below regardless of this flag - they're inert for forms that
+     * don't use them, but the plugin has real runtime behavior (it hooks
+     * every node to check its type), so it's opt-in.
+     */
+    multiStep?: boolean;
+}
+/**
+ * Assembles the `inputs`/`plugins` this module needs into a plain object a
+ * consumer spreads into their own `defaultConfig({ ...createNuxtUiFormkitConfig(), ... })`
+ * call inside `formkit.config.ts` - it doesn't call `defaultConfig` itself,
+ * so it stays composable with whatever else that config already does
+ * (locales, `iconLoader`, other plugins like `createAutoAnimatePlugin`).
+ */
+export declare function createNuxtUiFormkitConfig(options?: CreateNuxtUiFormkitConfigOptions): Pick<DefaultConfigOptions, 'inputs' | 'plugins'>;

package/dist/runtime/formkit/createNuxtUiFormkitConfig.js

@@ -0,0 +1,12 @@
+import { createMultiStepPlugin } from "@formkit/addons";
+import { nuxtUIInputs, nuxtUIOutputs } from "./definitions/index.js";
+import { addNuxtAsteriskPlugin } from "./plugins/index.js";
+export function createNuxtUiFormkitConfig(options = {}) {
+  const plugins = [addNuxtAsteriskPlugin];
+  if (options.multiStep)
+    plugins.push(createMultiStepPlugin());
+  return {
+    inputs: { ...nuxtUIInputs, ...nuxtUIOutputs },
+    plugins
+  };
+}

package/dist/runtime/formkit/createNuxtUiFormkitConfig.mjs

@@ -0,0 +1,12 @@
+import { createMultiStepPlugin } from "@formkit/addons";
+import { nuxtUIInputs, nuxtUIOutputs } from "./definitions/index.mjs";
+import { addNuxtAsteriskPlugin } from "./plugins/index.mjs";
+export function createNuxtUiFormkitConfig(options = {}) {
+  const plugins = [addNuxtAsteriskPlugin];
+  if (options.multiStep)
+    plugins.push(createMultiStepPlugin());
+  return {
+    inputs: { ...nuxtUIInputs, ...nuxtUIOutputs },
+    plugins
+  };
+}

package/dist/runtime/formkit/definitions/index.d.ts

@@ -1,4 +1,5 @@
 export * from './input.js';
+export * from './multiStep.js';
 export * from './output.js';
 export declare const nuxtUIInputs: {
     nuxtUICalendar: import("@formkit/core").FormKitTypeDefinition;
@@ -14,11 +15,13 @@ export declare const nuxtUIInputs: {
     nuxtUIInputTags: import("@formkit/core").FormKitTypeDefinition;
     nuxtUIInputTime: import("@formkit/core").FormKitTypeDefinition;
     nuxtUIListbox: import("@formkit/core").FormKitTypeDefinition;
+    nuxtUIMultiStep: import("@formkit/core").FormKitTypeDefinition;
     nuxtUIPinInput: import("@formkit/core").FormKitTypeDefinition;
     nuxtUIRadioGroup: import("@formkit/core").FormKitTypeDefinition;
     nuxtUISelect: import("@formkit/core").FormKitTypeDefinition;
     nuxtUISelectMenu: import("@formkit/core").FormKitTypeDefinition;
     nuxtUISlider: import("@formkit/core").FormKitTypeDefinition;
+    nuxtUIStep: import("@formkit/core").FormKitTypeDefinition;
     nuxtUISwitch: import("@formkit/core").FormKitTypeDefinition;
     nuxtUITextarea: import("@formkit/core").FormKitTypeDefinition;
     nuxtUIRepeater: import("@formkit/core").FormKitTypeDefinition;