@uniform-ts/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1592 @@
+import * as z from 'zod/v4/core';
+import * as React3 from 'react';
+import { useMemo, useRef, useEffect, useCallback, useState } from 'react';
+import { useFormState, useWatch, useForm, useFieldArray, Controller } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/introspection/deriveLabel.ts
+function deriveLabel(name) {
+  const segment = name.split(".").pop() ?? name;
+  if (!segment) return "";
+  return segment.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function extractMeta(schema) {
+  return z.globalRegistry.get(schema) ?? {};
+}
+var WRAPPER_KINDS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "default",
+  "prefault",
+  "pipe"
+  // ZodPipe — .transform() returns ZodPipe<Source, ZodTransform>
+]);
+function unwrap(schema) {
+  let inner = schema;
+  let required = true;
+  let meta = extractMeta(inner);
+  let kind = inner._zod.def.type;
+  while (WRAPPER_KINDS.has(kind)) {
+    if (kind === "optional" || kind === "nullable") {
+      required = false;
+    }
+    if (kind === "pipe") {
+      inner = inner._zod.def.in;
+    } else {
+      inner = inner._zod.def.innerType;
+    }
+    meta = { ...extractMeta(inner), ...meta };
+    kind = inner._zod.def.type;
+  }
+  return { schema: inner, required, meta };
+}
+
+// src/introspection/introspect.ts
+function introspectSchema(schema, name = "", parentPath = "") {
+  const path = parentPath && name ? `${parentPath}.${name}` : name || parentPath;
+  const { schema: unwrappedSchema, required, meta } = unwrap(schema);
+  const inner = unwrappedSchema;
+  const def = inner._zod.def;
+  const kind = def.type;
+  const mergedMeta = { ...meta };
+  const label = typeof mergedMeta.label === "string" ? mergedMeta.label : deriveLabel(name);
+  let type = "unknown";
+  let options;
+  let children;
+  let itemConfig;
+  let unionVariants;
+  let discriminatorKey;
+  let minItems;
+  let maxItems;
+  try {
+    if (kind === "string") {
+      type = "string";
+      const defFormat = def.format;
+      if (defFormat === "email") {
+        mergedMeta["inputType"] = "email";
+      } else if (defFormat === "url") {
+        mergedMeta["inputType"] = "url";
+      } else if (defFormat === "uuid") {
+        mergedMeta["inputType"] = "uuid";
+      } else {
+        const checks = def.checks ?? [];
+        const hasFormat = (fmt) => checks.some(
+          (c) => c._zod.def.check === "string_format" && c._zod.def.format === fmt
+        );
+        if (hasFormat("email")) {
+          mergedMeta["inputType"] = "email";
+        } else if (hasFormat("url")) {
+          mergedMeta["inputType"] = "url";
+        } else if (hasFormat("uuid")) {
+          mergedMeta["inputType"] = "uuid";
+        }
+      }
+    } else if (kind === "number") {
+      type = "number";
+      mergedMeta["inputType"] = "number";
+    } else if (kind === "boolean") {
+      type = "boolean";
+    } else if (kind === "date") {
+      type = "date";
+      mergedMeta["inputType"] = "date";
+    } else if (kind === "enum") {
+      type = "select";
+      options = Object.entries(def.entries).filter(([key]) => isNaN(Number(key))).map(([key, value]) => ({
+        label: typeof value === "string" ? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase() : key.charAt(0).toUpperCase() + key.slice(1).toLowerCase(),
+        value
+      }));
+    } else if (kind === "object") {
+      type = "object";
+      children = Object.entries(def.shape).map(
+        ([key, fieldSchema]) => introspectSchema(fieldSchema, key, path)
+      );
+    } else if (kind === "array") {
+      type = "array";
+      const elementSchema = def.element;
+      itemConfig = introspectSchema(elementSchema, "", "");
+      const checks = def.checks ?? [];
+      for (const check of checks) {
+        const checkDef = check._zod.def;
+        if (checkDef.check === "min_length" && typeof checkDef.minimum === "number") {
+          minItems = checkDef.minimum;
+        }
+        if (checkDef.check === "max_length" && typeof checkDef.maximum === "number") {
+          maxItems = checkDef.maximum;
+        }
+      }
+    } else if (def.type === "union") {
+      type = "union";
+      const unionDef = def;
+      if ("discriminator" in unionDef) {
+        discriminatorKey = unionDef.discriminator;
+      }
+      const variants = unionDef.options;
+      unionVariants = variants.map(
+        (variant, i) => introspectSchema(variant, String(i), path)
+      );
+    }
+  } catch {
+    type = "unknown";
+  }
+  return {
+    name: path,
+    type,
+    label,
+    required,
+    meta: mergedMeta,
+    ...options !== void 0 && { options },
+    ...children !== void 0 && { children },
+    ...itemConfig !== void 0 && { itemConfig },
+    ...unionVariants !== void 0 && { unionVariants },
+    ...discriminatorKey !== void 0 && { discriminatorKey },
+    ...minItems !== void 0 && { minItems },
+    ...maxItems !== void 0 && { maxItems }
+  };
+}
+function introspectObjectSchema(schema) {
+  return Object.entries(schema._zod.def.shape).map(
+    ([key, fieldSchema]) => introspectSchema(fieldSchema, key, "")
+  );
+}
+
+// src/introspection/discriminatedUnion.ts
+function parseDiscriminatedUnionMeta(schema) {
+  const def = schema._zod.def;
+  const discriminatorKey = def.discriminator;
+  const variants = def.options;
+  const variantMap = /* @__PURE__ */ new Map();
+  const discriminatorOptions = [];
+  for (const variant of variants) {
+    const shape = variant._zod.def.shape;
+    const litDef = shape[discriminatorKey]._zod.def;
+    const value = String(litDef.values[0]);
+    variantMap.set(value, variant);
+    discriminatorOptions.push({
+      label: value.charAt(0).toUpperCase() + value.slice(1),
+      value
+    });
+  }
+  const discriminatorField = {
+    name: discriminatorKey,
+    type: "select",
+    label: deriveLabel(discriminatorKey),
+    required: true,
+    meta: {},
+    options: discriminatorOptions
+  };
+  return {
+    discriminatorKey,
+    variantMap,
+    discriminatorField,
+    firstVariant: variants[0]
+  };
+}
+
+// src/registry/mergeRegistries.ts
+function mergeRegistries(base, overrides) {
+  if (!overrides) return base;
+  return { ...base, ...overrides };
+}
+function resolveInputType(props) {
+  const metaType = props.meta.inputType;
+  if (typeof metaType === "string") return metaType;
+  if (props.meta.component === "date") return "date";
+  return "text";
+}
+function formatValue(value) {
+  if (value instanceof Date) {
+    if (isNaN(value.getTime())) return "";
+    return value.toISOString().split("T")[0];
+  }
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+function DefaultInput(props) {
+  const { name, value, onChange, onBlur, ref, required, disabled, meta } = props;
+  const inputType = resolveInputType(props);
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      id: name,
+      name,
+      type: inputType,
+      value: formatValue(value),
+      onChange: (e) => onChange(e.target.value),
+      onBlur,
+      ref,
+      required,
+      disabled,
+      "aria-required": required,
+      "aria-disabled": disabled,
+      placeholder: meta.placeholder,
+      "data-input-type": inputType,
+      "data-required": required || void 0,
+      "data-disabled": disabled || void 0
+    }
+  );
+}
+function DefaultCheckbox(props) {
+  const { name, value, onChange, onBlur, ref, required, disabled, label } = props;
+  const checked = Boolean(value);
+  return /* @__PURE__ */ jsxs("label", { htmlFor: name, "data-disabled": disabled || void 0, children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id: name,
+        name,
+        type: "checkbox",
+        checked,
+        onChange: (e) => onChange(e.target.checked),
+        onBlur,
+        ref,
+        required,
+        disabled,
+        "aria-required": required,
+        "aria-disabled": disabled,
+        "data-required": required || void 0,
+        "data-disabled": disabled || void 0,
+        "data-checked": checked || void 0
+      }
+    ),
+    label
+  ] });
+}
+function DefaultSelect(props) {
+  const {
+    name,
+    value,
+    onChange,
+    onBlur,
+    ref,
+    required,
+    disabled,
+    options = []
+  } = props;
+  return /* @__PURE__ */ jsx(
+    "select",
+    {
+      id: name,
+      name,
+      value: String(value ?? ""),
+      onChange: (e) => onChange(e.target.value),
+      onBlur,
+      ref,
+      required,
+      disabled,
+      "aria-required": required,
+      "aria-disabled": disabled,
+      "data-required": required || void 0,
+      "data-disabled": disabled || void 0,
+      children: options.map((opt) => /* @__PURE__ */ jsx("option", { value: String(opt.value), children: opt.label }, String(opt.value)))
+    }
+  );
+}
+
+// src/registry/defaultRegistry.ts
+var defaultRegistry = {
+  string: DefaultInput,
+  number: DefaultInput,
+  date: DefaultInput,
+  boolean: DefaultCheckbox,
+  select: DefaultSelect
+};
+var AutoFormContext = React3.createContext(null);
+function useAutoFormContext() {
+  const ctx = React3.useContext(AutoFormContext);
+  if (!ctx) {
+    throw new Error(
+      "[UniForm] useAutoFormContext must be used inside an <AutoForm> component."
+    );
+  }
+  return ctx;
+}
+var AutoFormContextProvider = AutoFormContext.Provider;
+function DefaultFieldWrapper({
+  children,
+  field,
+  error,
+  span,
+  index = 0,
+  depth = 0
+}) {
+  const { classNames, disabled: contextDisabled } = useAutoFormContext();
+  const isDisabled = field.meta.disabled || contextDisabled;
+  const hasError = Boolean(error);
+  const hasDescription = Boolean(field.meta.description);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames.fieldWrapper,
+      style: {
+        "--field-span": span ?? field.meta.span ?? 1,
+        "--field-index": index,
+        "--field-depth": depth
+      },
+      "data-field-name": field.name,
+      "data-field-type": field.type,
+      "data-required": field.required || void 0,
+      "data-disabled": isDisabled || void 0,
+      "data-has-error": hasError || void 0,
+      "data-has-description": hasDescription || void 0,
+      children: [
+        /* @__PURE__ */ jsxs("label", { htmlFor: field.name, className: classNames.label, children: [
+          field.label,
+          field.required && " *"
+        ] }),
+        children,
+        hasDescription && /* @__PURE__ */ jsx("p", { className: classNames.description, children: String(field.meta.description) }),
+        error && /* @__PURE__ */ jsx("span", { role: "alert", className: classNames.error, children: error })
+      ]
+    }
+  );
+}
+function DefaultSubmitButton({
+  isSubmitting
+}) {
+  const { labels } = useAutoFormContext();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "submit",
+      disabled: isSubmitting,
+      "data-submitting": isSubmitting || void 0,
+      children: labels.submit ?? "Submit"
+    }
+  );
+}
+function DefaultFormWrapper({ children }) {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function DefaultSectionWrapper({
+  children,
+  title
+}) {
+  return /* @__PURE__ */ jsxs("fieldset", { children: [
+    /* @__PURE__ */ jsx("legend", { children: title }),
+    children
+  ] });
+}
+function DefaultArrayRowLayout({
+  children,
+  buttons
+}) {
+  return /* @__PURE__ */ jsxs("div", { children: [
+    buttons.collapse,
+    children,
+    /* @__PURE__ */ jsxs("div", { children: [
+      buttons.moveUp,
+      buttons.moveDown,
+      buttons.duplicate,
+      buttons.remove
+    ] })
+  ] });
+}
+
+// src/utils/resolveErrorMessage.ts
+function resolveErrorMessage(fieldName, error, messages) {
+  if (!error) return void 0;
+  const originalMessage = error.message;
+  if (!messages) return originalMessage;
+  const fieldMessage = messages[fieldName];
+  if (fieldMessage !== void 0) {
+    if (typeof fieldMessage === "string") return fieldMessage;
+    if (typeof fieldMessage === "object" && error.type) {
+      const coded = fieldMessage[error.type];
+      if (coded) return coded;
+    }
+  }
+  if (messages.required && isRequiredError(error)) {
+    return messages.required;
+  }
+  return originalMessage;
+}
+function isRequiredError(error) {
+  return error.type === "too_small" || error.type === "invalid_type";
+}
+
+// src/components/resolveComponent.ts
+function resolveComponent(field, registry) {
+  if (field.meta.component && typeof field.meta.component === "function") {
+    return field.meta.component;
+  }
+  if (typeof field.meta.component === "string" && registry[field.meta.component]) {
+    return registry[field.meta.component];
+  }
+  if (registry[field.type]) {
+    return registry[field.type];
+  }
+  if (defaultRegistry[field.type]) {
+    return defaultRegistry[field.type];
+  }
+  console.warn(
+    `[UniForm] No component found for field type "${field.type}"${field.meta.component ? ` with meta.component "${String(field.meta.component)}"` : ""}. Rendering null.`
+  );
+  return null;
+}
+
+// src/coercion/coerce.ts
+var defaultCoercionMap = {
+  number: (value) => {
+    if (value === "" || value === null || value === void 0) return void 0;
+    const num = Number(value);
+    return isNaN(num) ? value : num;
+  },
+  date: (value) => {
+    if (value === "" || value === null || value === void 0) return void 0;
+    const d = new Date(String(value));
+    return isNaN(d.getTime()) ? value : d;
+  },
+  boolean: (value) => Boolean(value),
+  string: (value) => value == null || value == void 0 ? "" : String(value)
+};
+function coerceValue(type, value, customCoercions) {
+  const coercionFn = customCoercions?.[type] ?? defaultCoercionMap[type];
+  if (!coercionFn) return value;
+  return coercionFn(value);
+}
+function ScalarField({
+  field,
+  control,
+  effectiveName,
+  shouldUnregister
+}) {
+  const {
+    registry,
+    disabled: contextDisabled,
+    coercions,
+    formMethods
+  } = useAutoFormContext();
+  const Component = resolveComponent(field, registry);
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      name: effectiveName,
+      control,
+      shouldUnregister,
+      render: ({ field: rhfField, fieldState }) => /* @__PURE__ */ jsx(
+        Component,
+        {
+          name: effectiveName,
+          value: rhfField.value ?? "",
+          onChange: (value) => {
+            const coerced = coerceValue(field.type, value, coercions);
+            rhfField.onChange(coerced);
+            field.meta.onChange?.(coerced, formMethods);
+          },
+          onBlur: rhfField.onBlur,
+          ref: rhfField.ref,
+          label: field.label,
+          placeholder: field.meta.placeholder,
+          description: field.meta.description,
+          error: fieldState.error?.message,
+          required: field.required,
+          disabled: field.meta.disabled || contextDisabled,
+          meta: field.meta
+        }
+      )
+    }
+  );
+}
+function BooleanField({
+  field,
+  control,
+  effectiveName,
+  shouldUnregister
+}) {
+  const {
+    registry,
+    disabled: contextDisabled,
+    formMethods
+  } = useAutoFormContext();
+  const Component = resolveComponent(field, registry);
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      name: effectiveName,
+      control,
+      shouldUnregister,
+      render: ({ field: rhfField, fieldState }) => /* @__PURE__ */ jsx(
+        Component,
+        {
+          name: effectiveName,
+          value: rhfField.value ?? false,
+          onChange: (value) => {
+            rhfField.onChange(value);
+            field.meta.onChange?.(value, formMethods);
+          },
+          onBlur: rhfField.onBlur,
+          ref: rhfField.ref,
+          label: field.label,
+          placeholder: field.meta.placeholder,
+          description: field.meta.description,
+          error: fieldState.error?.message,
+          required: field.required,
+          disabled: field.meta.disabled || rhfField.disabled || contextDisabled,
+          meta: field.meta
+        }
+      )
+    }
+  );
+}
+function SelectField({
+  field,
+  control,
+  effectiveName,
+  shouldUnregister
+}) {
+  const {
+    registry,
+    disabled: contextDisabled,
+    formMethods
+  } = useAutoFormContext();
+  const Component = resolveComponent(field, registry);
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx(
+    Controller,
+    {
+      name: effectiveName,
+      control,
+      shouldUnregister,
+      render: ({ field: rhfField, fieldState }) => /* @__PURE__ */ jsx(
+        Component,
+        {
+          name: effectiveName,
+          value: rhfField.value ?? "",
+          onChange: (value) => {
+            rhfField.onChange(value);
+            field.meta.onChange?.(value, formMethods);
+          },
+          onBlur: rhfField.onBlur,
+          ref: rhfField.ref,
+          label: field.label,
+          placeholder: field.meta.placeholder,
+          description: field.meta.description,
+          error: fieldState.error?.message,
+          required: field.required,
+          disabled: field.meta.disabled || contextDisabled,
+          options: field.options,
+          meta: field.meta
+        }
+      )
+    }
+  );
+}
+function ObjectField({
+  field,
+  control,
+  namePrefix,
+  depth = 0,
+  shouldUnregister
+}) {
+  const children = field.children;
+  const content = children.map((child, idx) => /* @__PURE__ */ jsx(
+    FieldRenderer,
+    {
+      field: child,
+      control,
+      namePrefix,
+      index: idx,
+      depth: depth + 1,
+      shouldUnregister
+    },
+    child.name
+  ));
+  if (field.meta.section) {
+    return /* @__PURE__ */ jsx(Fragment, { children: content });
+  }
+  return /* @__PURE__ */ jsxs("fieldset", { children: [
+    field.label && /* @__PURE__ */ jsx("legend", { children: field.label }),
+    content
+  ] });
+}
+
+// src/components/fields/getDefaultValue.ts
+function getDefaultValue(field) {
+  switch (field.type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "date":
+      return /* @__PURE__ */ new Date();
+    case "select":
+      return field.options?.[0]?.value ?? "";
+    case "object": {
+      const result = {};
+      for (const child of field.children ?? []) {
+        const key = child.name.split(".").pop() ?? child.name;
+        result[key] = getDefaultValue(child);
+      }
+      return result;
+    }
+    case "array":
+      return [];
+    default:
+      return void 0;
+  }
+}
+function getRowSummary(row, itemConfig, index) {
+  if (itemConfig.type === "object") {
+    for (const child of itemConfig.children) {
+      const key = child.name.split(".").pop() ?? child.name;
+      const val = row[key];
+      if ((child.type === "string" || child.type === "number") && val != null && val !== "") {
+        return String(val);
+      }
+    }
+  }
+  return `Item ${index + 1}`;
+}
+function ArrayField({ field, control, effectiveName }) {
+  const { classNames, layout, labels } = useAutoFormContext();
+  const {
+    fields: rows,
+    append,
+    remove,
+    move,
+    insert
+  } = useFieldArray({
+    control,
+    name: effectiveName
+  });
+  const [collapsed, setCollapsed] = useState(() => /* @__PURE__ */ new Set());
+  const itemConfig = field.itemConfig;
+  const isObjectItems = itemConfig.type === "object";
+  const minItems = field.minItems;
+  const maxItems = field.maxItems;
+  const atMin = minItems != null && rows.length <= minItems;
+  const atMax = maxItems != null && rows.length >= maxItems;
+  const showMove = field.meta.movable === true;
+  const showDuplicate = field.meta.duplicable === true;
+  const showCollapse = field.meta.collapsible === true && isObjectItems;
+  const toggleCollapse = (index) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(index)) {
+        next.delete(index);
+      } else {
+        next.add(index);
+      }
+      return next;
+    });
+  };
+  const effectiveItemConfig = field.meta.section && !itemConfig.meta.section ? {
+    ...itemConfig,
+    meta: { ...itemConfig.meta, section: field.meta.section }
+  } : itemConfig;
+  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    rows.map((row, index) => {
+      const isCollapsed = showCollapse && collapsed.has(index);
+      const collapseButton = showCollapse ? /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          className: classNames.arrayCollapse,
+          onClick: () => toggleCollapse(index),
+          "aria-label": isCollapsed ? `Expand item ${index + 1}` : `Collapse item ${index + 1}`,
+          children: [
+            isCollapsed ? labels.arrayExpand ?? "\u25BC" : labels.arrayCollapse ?? "\u25B6",
+            " ",
+            /* @__PURE__ */ jsx(
+              CollapseSummary,
+              {
+                control,
+                effectiveName,
+                index,
+                itemConfig,
+                isCollapsed
+              }
+            )
+          ]
+        }
+      ) : null;
+      const moveUpButton = showMove && rows.length > 1 ? /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames.arrayMove,
+          onClick: () => move(index, index - 1),
+          disabled: index === 0,
+          "aria-label": `Move item ${index + 1} up`,
+          children: labels.arrayMoveUp ?? "\u2191"
+        }
+      ) : null;
+      const moveDownButton = showMove && rows.length > 1 ? /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames.arrayMove,
+          onClick: () => move(index, index + 1),
+          disabled: index === rows.length - 1,
+          "aria-label": `Move item ${index + 1} down`,
+          children: labels.arrayMoveDown ?? "\u2193"
+        }
+      ) : null;
+      const duplicateButton = showDuplicate && !atMax ? /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames.arrayDuplicate,
+          onClick: () => {
+            const values = Object.fromEntries(
+              Object.entries(row).filter(([k]) => k !== "id")
+            );
+            insert(index + 1, values);
+          },
+          "aria-label": `Duplicate item ${index + 1}`,
+          children: labels.arrayDuplicate ?? "Duplicate"
+        }
+      ) : null;
+      const removeButton = /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames.arrayRemove,
+          onClick: () => remove(index),
+          disabled: atMin,
+          "aria-label": `Remove item ${index + 1}`,
+          children: labels.arrayRemove ?? "Remove"
+        }
+      );
+      const fieldContent = !isCollapsed ? /* @__PURE__ */ jsx(
+        FieldRenderer,
+        {
+          field: effectiveItemConfig,
+          control,
+          namePrefix: `${effectiveName}.${index}`
+        }
+      ) : null;
+      const RowLayout = layout.arrayRowLayout;
+      return /* @__PURE__ */ jsx(
+        RowLayout,
+        {
+          buttons: {
+            moveUp: moveUpButton,
+            moveDown: moveDownButton,
+            duplicate: duplicateButton,
+            remove: removeButton,
+            collapse: collapseButton
+          },
+          index,
+          rowCount: rows.length,
+          children: fieldContent
+        },
+        row.id
+      );
+    }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: classNames.arrayAdd,
+        disabled: atMax,
+        onClick: () => append(getDefaultValue(itemConfig)),
+        children: labels.arrayAdd ?? "Add"
+      }
+    )
+  ] });
+  if (field.meta.section) {
+    return content;
+  }
+  return /* @__PURE__ */ jsxs("fieldset", { children: [
+    field.label && /* @__PURE__ */ jsx("legend", { children: field.label }),
+    content
+  ] });
+}
+function CollapseSummary({
+  control,
+  effectiveName,
+  index,
+  itemConfig,
+  isCollapsed
+}) {
+  const rowValues = useWatch({ control, name: `${effectiveName}.${index}` });
+  const summary = useMemo(() => {
+    if (!isCollapsed) return `Item ${index + 1}`;
+    if (!rowValues) return `Item ${index + 1}`;
+    return getRowSummary(rowValues, itemConfig, index);
+  }, [isCollapsed, rowValues, itemConfig, index]);
+  return /* @__PURE__ */ jsx(Fragment, { children: isCollapsed ? summary : `Item ${index + 1}` });
+}
+function getEffectiveName(field, namePrefix) {
+  if (!namePrefix) return field.name;
+  if (!field.name) return namePrefix;
+  return `${namePrefix}.${field.name}`;
+}
+function getFieldError(errors, name) {
+  const parts = name.split(".");
+  let current = errors;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  if (current && typeof current === "object" && "message" in current) {
+    return current;
+  }
+  return void 0;
+}
+function FieldRenderer({
+  field,
+  control,
+  namePrefix,
+  index = 0,
+  depth = 0,
+  shouldUnregister
+}) {
+  const effectiveShouldUnregister = shouldUnregister ?? typeof field.meta.condition === "function";
+  const { fieldWrapper: FieldWrapper, messages } = useAutoFormContext();
+  const { errors } = useFormState({ control });
+  const effectiveName = getEffectiveName(field, namePrefix);
+  const hasDirectComponent = typeof field.meta.component === "function";
+  if (field.type === "object" && !hasDirectComponent) {
+    const objectField = effectiveName !== field.name ? { ...field, name: effectiveName } : field;
+    return /* @__PURE__ */ jsx(
+      ObjectField,
+      {
+        field: objectField,
+        control,
+        namePrefix,
+        depth,
+        shouldUnregister: effectiveShouldUnregister
+      }
+    );
+  }
+  if (field.type === "array" && !hasDirectComponent) {
+    const arrayField = effectiveName !== field.name ? { ...field, name: effectiveName } : field;
+    return /* @__PURE__ */ jsx(
+      ArrayField,
+      {
+        field: arrayField,
+        control,
+        effectiveName
+      }
+    );
+  }
+  const effectiveField = effectiveName !== field.name ? { ...field, name: effectiveName } : field;
+  const rawError = getFieldError(
+    errors,
+    effectiveName
+  );
+  const error = resolveErrorMessage(effectiveName, rawError, messages);
+  const renderField = () => {
+    if (field.type === "boolean") {
+      return /* @__PURE__ */ jsx(
+        BooleanField,
+        {
+          field: effectiveField,
+          control,
+          effectiveName,
+          shouldUnregister: effectiveShouldUnregister
+        }
+      );
+    }
+    if (field.type === "select") {
+      return /* @__PURE__ */ jsx(
+        SelectField,
+        {
+          field: effectiveField,
+          control,
+          effectiveName,
+          shouldUnregister: effectiveShouldUnregister
+        }
+      );
+    }
+    if (field.type === "string" || field.type === "number" || field.type === "date" || // array/object with a direct meta.component — let ScalarField render it
+    hasDirectComponent) {
+      return /* @__PURE__ */ jsx(
+        ScalarField,
+        {
+          field: effectiveField,
+          control,
+          effectiveName,
+          shouldUnregister: effectiveShouldUnregister
+        }
+      );
+    }
+    console.warn(
+      `[UniForm] Unsupported field type: "${field.type}". Rendering null.`
+    );
+    return null;
+  };
+  const rendered = renderField();
+  if (rendered === null) return null;
+  return /* @__PURE__ */ jsx(
+    FieldWrapper,
+    {
+      field: effectiveField,
+      error,
+      span: field.meta.span,
+      index,
+      depth,
+      children: rendered
+    }
+  );
+}
+function useConditionalFields(fields, control) {
+  const values = useWatch({ control });
+  return useMemo(() => {
+    return fields.filter((field) => {
+      if (field.meta.hidden) return false;
+      if (typeof field.meta.condition === "function") {
+        return field.meta.condition(values);
+      }
+      return true;
+    }).sort((a, b) => {
+      const orderA = typeof a.meta.order === "number" ? a.meta.order : Infinity;
+      const orderB = typeof b.meta.order === "number" ? b.meta.order : Infinity;
+      return orderA - orderB;
+    });
+  }, [fields, values]);
+}
+function useSectionGrouping(fields) {
+  return useMemo(() => {
+    const ungrouped = [];
+    const sectionMap = /* @__PURE__ */ new Map();
+    const sectionOrder = [];
+    for (const field of fields) {
+      const section = field.meta.section;
+      if (typeof section !== "string") {
+        ungrouped.push(field);
+      } else {
+        if (!sectionMap.has(section)) {
+          sectionMap.set(section, []);
+          sectionOrder.push(section);
+        }
+        sectionMap.get(section).push(field);
+      }
+    }
+    const groups = [];
+    if (ungrouped.length > 0) {
+      groups.push({ title: null, fields: ungrouped });
+    }
+    for (const title of sectionOrder) {
+      groups.push({ title, fields: sectionMap.get(title) });
+    }
+    return groups;
+  }, [fields]);
+}
+var defaultStorage = typeof window !== "undefined" ? {
+  getItem: (key) => sessionStorage.getItem(key),
+  setItem: (key, value) => sessionStorage.setItem(key, value),
+  removeItem: (key) => sessionStorage.removeItem(key)
+} : void 0;
+function useFormPersistence(options) {
+  const {
+    control,
+    key,
+    debounceMs,
+    storage: customStorage,
+    reset,
+    defaultValues
+  } = options;
+  const storage = customStorage ?? defaultStorage;
+  const timerRef = useRef(null);
+  const restoredRef = useRef(false);
+  useEffect(() => {
+    if (!key || !storage || restoredRef.current) return;
+    restoredRef.current = true;
+    try {
+      const raw = storage.getItem(key);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        reset({ ...defaultValues, ...parsed });
+      }
+    } catch {
+    }
+  }, [key, storage, reset, defaultValues]);
+  const values = useWatch({ control });
+  useEffect(() => {
+    if (!key || !storage) return;
+    if (!restoredRef.current) return;
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(() => {
+      try {
+        storage.setItem(key, JSON.stringify(values));
+      } catch {
+      }
+    }, debounceMs);
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, [key, storage, values, debounceMs]);
+  const clearPersistedData = useCallback(() => {
+    if (!key || !storage) return;
+    try {
+      storage.removeItem(key);
+    } catch {
+    }
+  }, [key, storage]);
+  return { clearPersistedData };
+}
+function useLatestRef(value) {
+  const ref = React3.useRef(value);
+  React3.useLayoutEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// src/utils/fieldPipeline.ts
+function applyFieldOverrides(fields, overrides) {
+  return fields.map((field) => {
+    const override = overrides[field.name];
+    const updated = override ? { ...field, meta: { ...field.meta, ...override } } : field;
+    if (updated.type === "object") {
+      const newChildren = applyFieldOverrides(updated.children, overrides);
+      if (newChildren !== updated.children)
+        return { ...updated, children: newChildren };
+    }
+    if (updated.type === "array" && updated.itemConfig.type === "object") {
+      const prefix = `${updated.name}.`;
+      const strippedOverrides = {};
+      for (const [key, value] of Object.entries(overrides)) {
+        if (key.startsWith(prefix))
+          strippedOverrides[key.slice(prefix.length)] = value;
+      }
+      const newItemChildren = applyFieldOverrides(
+        updated.itemConfig.children,
+        strippedOverrides
+      );
+      if (newItemChildren !== updated.itemConfig.children) {
+        return {
+          ...updated,
+          itemConfig: { ...updated.itemConfig, children: newItemChildren }
+        };
+      }
+    }
+    return updated;
+  });
+}
+function injectOnChangeHandlers(fields, uniForm, ctx, handlerKeys = new Set(uniForm._getWatchedFields())) {
+  if (!handlerKeys.size) return fields;
+  return fields.map((field) => {
+    let updated = field;
+    if (handlerKeys.has(field.name)) {
+      const existingOnChange = field.meta.onChange;
+      updated = {
+        ...field,
+        meta: {
+          ...field.meta,
+          onChange: (value, formMethods) => {
+            void existingOnChange?.(value, formMethods);
+            void uniForm._fireHandler(field.name, value, ctx);
+          }
+        }
+      };
+    }
+    if (updated.type === "object") {
+      const newChildren = injectOnChangeHandlers(
+        updated.children,
+        uniForm,
+        ctx,
+        handlerKeys
+      );
+      if (newChildren !== updated.children)
+        updated = { ...updated, children: newChildren };
+    } else if (updated.type === "array") {
+      const prefix = field.name + ".";
+      const itemKeys = /* @__PURE__ */ new Set();
+      for (const key of handlerKeys) {
+        if (key.startsWith(prefix)) itemKeys.add(key.slice(prefix.length));
+      }
+      if (itemKeys.size) {
+        const remappedUniForm = {
+          _getWatchedFields: () => Array.from(itemKeys),
+          _fireHandlers: (name, value, c) => uniForm._fireHandler(`${field.name}.${name}`, value, c)
+        };
+        const newItemConfig = injectOnChangeHandlers(
+          [updated.itemConfig],
+          remappedUniForm,
+          ctx,
+          itemKeys
+        )[0];
+        if (newItemConfig !== updated.itemConfig)
+          updated = { ...updated, itemConfig: newItemConfig };
+      }
+    }
+    return updated;
+  });
+}
+function injectConditions(fields, conditions) {
+  if (!conditions.size) return fields;
+  return fields.map((field) => {
+    const condition = conditions.get(field.name);
+    let updated = condition ? { ...field, meta: { ...field.meta, condition } } : field;
+    if (updated.type === "object") {
+      const newChildren = injectConditions(updated.children, conditions);
+      if (newChildren !== updated.children)
+        updated = { ...updated, children: newChildren };
+    } else if (updated.type === "array") {
+      const prefix = field.name + ".";
+      const itemConditions = /* @__PURE__ */ new Map();
+      for (const [key, cond] of conditions) {
+        if (key.startsWith(prefix))
+          itemConditions.set(key.slice(prefix.length), cond);
+      }
+      if (itemConditions.size) {
+        const newItemConfig = injectConditions(
+          [updated.itemConfig],
+          itemConditions
+        )[0];
+        if (newItemConfig !== updated.itemConfig)
+          updated = { ...updated, itemConfig: newItemConfig };
+      }
+    }
+    return updated;
+  });
+}
+function applyDynamicMeta(fields, overrides) {
+  if (!Object.keys(overrides).length) return fields;
+  return fields.map((field) => {
+    const override = overrides[field.name];
+    if (!override) return field;
+    const { options, label, ...metaOverrides } = override;
+    return {
+      ...field,
+      ...label !== void 0 ? { label } : {},
+      ...options !== void 0 ? { options } : {},
+      meta: { ...field.meta, ...metaOverrides }
+    };
+  });
+}
+function buildDefaults(fields) {
+  const result = {};
+  for (const field of fields) {
+    const key = field.name;
+    switch (field.type) {
+      case "string":
+        result[key] = "";
+        break;
+      case "number":
+        result[key] = "";
+        break;
+      case "boolean":
+        result[key] = false;
+        break;
+      case "select":
+        result[key] = field.options?.[0]?.value ?? "";
+        break;
+      case "array":
+        result[key] = [];
+        break;
+      case "object":
+        result[key] = {};
+        break;
+    }
+  }
+  return result;
+}
+function AutoForm(props) {
+  const {
+    form: uniForm,
+    onSubmit,
+    defaultValues,
+    components,
+    fields: fieldOverridesProp = {},
+    fieldWrapper,
+    layout,
+    classNames = {},
+    disabled = false,
+    coercions,
+    messages,
+    persistKey,
+    persistDebounce = 300,
+    persistStorage,
+    onValuesChange,
+    labels = {},
+    ref
+  } = props;
+  const schema = uniForm.schema;
+  const unionInfo = React3.useMemo(() => {
+    const def = schema._zod.def;
+    if (def.type !== "union") return null;
+    return parseDiscriminatedUnionMeta(
+      schema
+    );
+  }, [schema]);
+  const rawFields = React3.useMemo(() => {
+    if (!unionInfo) return introspectObjectSchema(schema);
+    const firstVariantFields = introspectObjectSchema(
+      unionInfo.firstVariant
+    ).filter((f) => f.name !== unionInfo.discriminatorKey);
+    return [unionInfo.discriminatorField, ...firstVariantFields];
+  }, [schema, unionInfo]);
+  const registry = React3.useMemo(
+    () => mergeRegistries(defaultRegistry, components),
+    [components]
+  );
+  const generatedDefaults = React3.useMemo(
+    () => buildDefaults(rawFields),
+    [rawFields]
+  );
+  const computedDefaults = React3.useMemo(() => {
+    const base = {
+      ...generatedDefaults,
+      ...typeof defaultValues === "function" ? {} : defaultValues
+    };
+    const conditions = new Map(
+      uniForm._getConditions()
+    );
+    for (const [name, override] of Object.entries(
+      fieldOverridesProp
+    )) {
+      if (typeof override.condition === "function" && !conditions.has(name)) {
+        conditions.set(name, override.condition);
+      }
+    }
+    for (const [name, condition] of conditions) {
+      if (!condition(base)) {
+        delete base[name];
+      }
+    }
+    return base;
+  }, [generatedDefaults, defaultValues, uniForm, fieldOverridesProp]);
+  const isAsyncDefaults = typeof defaultValues === "function";
+  const [isLoadingDefaults, setIsLoadingDefaults] = React3.useState(isAsyncDefaults);
+  const rhf = useForm({
+    resolver: zodResolver(schema),
+    defaultValues: computedDefaults
+  });
+  const {
+    control,
+    formState,
+    clearErrors,
+    getValues,
+    handleSubmit,
+    reset,
+    resetField,
+    setValue,
+    setError,
+    setFocus,
+    watch
+  } = rhf;
+  const discriminatorValue = useWatch({
+    control,
+    name: unionInfo?.discriminatorKey ?? "",
+    disabled: !unionInfo?.discriminatorKey
+  });
+  const activeFields = React3.useMemo(() => {
+    if (!unionInfo) return rawFields;
+    const variant = unionInfo.variantMap.get(
+      discriminatorValue
+    );
+    if (!variant) return [unionInfo.discriminatorField];
+    const variantFields = introspectObjectSchema(variant).filter(
+      (f) => f.name !== unionInfo.discriminatorKey
+    );
+    return [unionInfo.discriminatorField, ...variantFields];
+  }, [unionInfo, discriminatorValue, rawFields]);
+  const mergedFields = React3.useMemo(
+    () => applyFieldOverrides(
+      activeFields,
+      fieldOverridesProp
+    ),
+    [activeFields, fieldOverridesProp]
+  );
+  const { clearPersistedData } = useFormPersistence({
+    control,
+    key: persistKey,
+    debounceMs: persistDebounce,
+    storage: persistStorage,
+    reset: rhf.reset,
+    defaultValues: computedDefaults
+  });
+  const [dynamicMeta, setDynamicMeta] = React3.useState({});
+  const onSubmitRef = useLatestRef(onSubmit);
+  const onValuesChangeRef = useLatestRef(onValuesChange);
+  const generatedDefaultsRef = useLatestRef(generatedDefaults);
+  React3.useEffect(() => {
+    if (!isAsyncDefaults) return;
+    let cancelled = false;
+    void defaultValues().then(
+      (vals) => {
+        if (cancelled) return;
+        rhf.reset({ ...generatedDefaultsRef.current, ...vals });
+        setIsLoadingDefaults(false);
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const formMethods = React3.useMemo(
+    () => ({
+      setValue: (name, value) => setValue(name, value, {
+        shouldValidate: true,
+        shouldDirty: true
+      }),
+      setValues: (values) => {
+        for (const [key, val] of Object.entries(values)) {
+          setValue(key, val, { shouldValidate: true, shouldDirty: true });
+        }
+      },
+      getValues: () => getValues(),
+      resetField: (name) => resetField(name),
+      reset: (values) => {
+        if (values) {
+          reset({ ...getValues(), ...values });
+        } else {
+          reset();
+        }
+        setDynamicMeta({});
+      },
+      setError: (name, message) => setError(name, { type: "manual", message }),
+      setErrors: (errors) => {
+        for (const [key, message] of Object.entries(errors)) {
+          setError(key, { type: "manual", message });
+        }
+      },
+      clearErrors: (names) => clearErrors(names),
+      submit: () => {
+        void handleSubmit(
+          (values) => onSubmitRef.current(values)
+        )();
+      },
+      focus: (fieldName) => setFocus(fieldName),
+      watch
+    }),
+    [
+      clearErrors,
+      getValues,
+      handleSubmit,
+      reset,
+      resetField,
+      setValue,
+      setError,
+      setFocus,
+      watch,
+      onSubmitRef
+    ]
+  );
+  React3.useImperativeHandle(
+    ref,
+    () => ({ ...formMethods, isSubmitting: formState.isSubmitting }),
+    [formMethods, formState.isSubmitting]
+  );
+  const setFieldMeta = React3.useCallback(
+    (field, meta) => {
+      if (Object.keys(meta).length) {
+        setDynamicMeta((prev) => ({
+          ...prev,
+          [field]: { ...prev[field], ...meta }
+        }));
+      }
+    },
+    []
+  );
+  const uniFormCtx = React3.useMemo(
+    () => ({ ...formMethods, setFieldMeta }),
+    [formMethods, setFieldMeta]
+  );
+  const fieldsWithHandlers = React3.useMemo(
+    () => injectOnChangeHandlers(
+      mergedFields,
+      uniForm,
+      uniFormCtx
+    ),
+    [mergedFields, uniForm, uniFormCtx]
+  );
+  const fieldsWithConditions = React3.useMemo(
+    () => injectConditions(
+      fieldsWithHandlers,
+      uniForm._getConditions()
+    ),
+    [fieldsWithHandlers, uniForm]
+  );
+  const fieldsWithDynamic = React3.useMemo(
+    () => applyDynamicMeta(fieldsWithConditions, dynamicMeta),
+    [fieldsWithConditions, dynamicMeta]
+  );
+  const allValues = useWatch({ control });
+  React3.useEffect(() => {
+    onValuesChangeRef.current?.(allValues);
+  }, [onValuesChangeRef, allValues]);
+  const visibleFields = useConditionalFields(fieldsWithDynamic, control);
+  const sections = useSectionGrouping(visibleFields);
+  const resolvedLayout = React3.useMemo(
+    () => ({
+      formWrapper: layout?.formWrapper ?? DefaultFormWrapper,
+      sectionWrapper: layout?.sectionWrapper ?? DefaultSectionWrapper,
+      submitButton: layout?.submitButton ?? DefaultSubmitButton,
+      arrayRowLayout: layout?.arrayRowLayout ?? DefaultArrayRowLayout,
+      loadingFallback: layout?.loadingFallback ?? /* @__PURE__ */ jsx("p", { children: "Loading\u2026" })
+    }),
+    [
+      layout?.formWrapper,
+      layout?.sectionWrapper,
+      layout?.submitButton,
+      layout?.arrayRowLayout,
+      layout?.loadingFallback
+    ]
+  );
+  const resolvedFieldWrapper = fieldWrapper ?? DefaultFieldWrapper;
+  const FormWrapper = resolvedLayout.formWrapper;
+  const SectionWrapper = resolvedLayout.sectionWrapper;
+  const SubmitButton = resolvedLayout.submitButton;
+  const contextValue = React3.useMemo(
+    () => ({
+      registry,
+      fieldOverrides: fieldOverridesProp,
+      fieldWrapper: resolvedFieldWrapper,
+      layout: resolvedLayout,
+      classNames,
+      disabled,
+      coercions,
+      messages,
+      labels,
+      formMethods
+    }),
+    [
+      registry,
+      fieldOverridesProp,
+      resolvedFieldWrapper,
+      resolvedLayout,
+      classNames,
+      disabled,
+      coercions,
+      messages,
+      labels,
+      formMethods
+    ]
+  );
+  if (isLoadingDefaults) {
+    return /* @__PURE__ */ jsx(Fragment, { children: resolvedLayout.loadingFallback });
+  }
+  return /* @__PURE__ */ jsx(AutoFormContextProvider, { value: contextValue, children: /* @__PURE__ */ jsx(
+    "form",
+    {
+      noValidate: true,
+      className: classNames.form,
+      onSubmit: (e) => {
+        void handleSubmit(async (values) => {
+          await onSubmit(values);
+          clearPersistedData();
+        })(e);
+      },
+      children: /* @__PURE__ */ jsxs(FormWrapper, { children: [
+        sections.map((section) => {
+          const renderedFields = section.fields.map((field, idx) => /* @__PURE__ */ jsx(
+            FieldRenderer,
+            {
+              field,
+              control,
+              index: idx,
+              depth: 0
+            },
+            field.name
+          ));
+          if (section.title === null) {
+            return /* @__PURE__ */ jsx(React3.Fragment, { children: renderedFields }, "__ungrouped");
+          }
+          return /* @__PURE__ */ jsx(SectionWrapper, { title: section.title, children: renderedFields }, section.title);
+        }),
+        /* @__PURE__ */ jsx(
+          SubmitButton,
+          {
+            isSubmitting: formState.isSubmitting,
+            label: labels.submit ?? "Submit"
+          }
+        )
+      ] })
+    }
+  ) });
+}
+function createAutoForm(config) {
+  function ConfiguredAutoForm(props) {
+    const mergedComponents = React3.useMemo(
+      () => mergeRegistries(config.components ?? {}, props.components),
+      [props.components]
+    );
+    const mergedLayout = React3.useMemo(
+      () => ({ ...config.layout, ...props.layout }),
+      [props.layout]
+    );
+    const mergedClassNames = React3.useMemo(
+      () => ({ ...config.classNames, ...props.classNames }),
+      [props.classNames]
+    );
+    const mergedCoercions = React3.useMemo(
+      () => props.coercions || config.coercions ? { ...config.coercions, ...props.coercions } : void 0,
+      [props.coercions]
+    );
+    const mergedMessages = React3.useMemo(
+      () => props.messages || config.messages ? { ...config.messages, ...props.messages } : void 0,
+      [props.messages]
+    );
+    const mergedLabels = React3.useMemo(
+      () => props.labels || config.labels ? { ...config.labels, ...props.labels } : void 0,
+      [props.labels]
+    );
+    return /* @__PURE__ */ jsx(
+      AutoForm,
+      {
+        ...props,
+        ref: props.ref,
+        components: mergedComponents,
+        fieldWrapper: props.fieldWrapper ?? config.fieldWrapper,
+        layout: mergedLayout,
+        classNames: mergedClassNames,
+        disabled: props.disabled || config.disabled || false,
+        coercions: mergedCoercions,
+        messages: mergedMessages,
+        labels: mergedLabels ?? {}
+      }
+    );
+  }
+  ConfiguredAutoForm.displayName = "AutoForm(configured)";
+  return ConfiguredAutoForm;
+}
+
+// src/UniForm.ts
+var UniForm = class {
+  constructor(schema) {
+    this.schema = schema;
+    this._handlers = /* @__PURE__ */ new Map();
+    this._conditions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set the typed onChange handler for a specific field.
+   * Replaces any previously registered handler for that field — only one
+   * handler per field is kept. This prevents accidental handler accumulation
+   * when called inside a React render cycle.
+   * Returns `this` for fluent chaining.
+   */
+  setOnChange(field, handler) {
+    this._handlers.set(field, handler);
+    return this;
+  }
+  /**
+   * Attach a typed condition for a specific field.
+   * The field is shown when the predicate returns `true`, hidden when `false`.
+   * Composes with any `condition` set via the `fields` prop (UniForm takes precedence).
+   * Returns `this` for fluent chaining.
+   */
+  setCondition(field, predicate) {
+    this._conditions.set(field, predicate);
+    return this;
+  }
+  /** @internal Called by AutoForm to fire the handler registered for a field. */
+  _fireHandler(field, value, ctx) {
+    return this._handlers.get(field)?.(value, ctx);
+  }
+  /** @internal Returns all field names that have registered onChange handlers. */
+  _getWatchedFields() {
+    return Array.from(this._handlers.keys());
+  }
+  /** @internal Returns a copy of the conditions map for AutoForm to inject into field meta. */
+  _getConditions() {
+    return new Map(this._conditions);
+  }
+};
+function createForm(schema) {
+  return new UniForm(schema);
+}
+
+export { AutoForm, DefaultCheckbox, DefaultFieldWrapper, DefaultInput, DefaultSelect, DefaultSubmitButton, FieldRenderer, UniForm, coerceValue, createAutoForm, createForm, defaultCoercionMap, defaultRegistry, introspectObjectSchema, introspectSchema, mergeRegistries, useAutoFormContext, useConditionalFields, useFormPersistence, useSectionGrouping };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map