@bach.software/vue-dynamic-form 0.5.0 → 0.6.0

package/dist/mapEachMetadataItem-Dvf3R5jd.js

@@ -0,0 +1,1159 @@
+import { computed as u, defineComponent as Ae, inject as Me, ref as G, watch as fe, watchEffect as Ze, createElementBlock as R, openBlock as A, Fragment as te, withDirectives as et, createCommentVNode as be, createBlock as D, unref as W, createElementVNode as tt, toDisplayString as rt, isRef as at, vShow as it, resolveDynamicComponent as Fe, withCtx as Ce, renderList as pe, getCurrentInstance as Ft, createVNode as Ct, onMounted as At, onBeforeUnmount as Vt, toValue as wt, resolveComponent as It, mergeProps as oe, provide as Mt, useSlots as St, useAttrs as Ut, renderSlot as xe, normalizeProps as ge } from "vue";
+import { useFieldArray as Pt, defineRule as z, validate as Ne, useValidateField as $t, useField as Pe, useSubmitCount as nt, useFormContext as ut, useFieldValue as lt, FormContextKey as De, useForm as Et } from "vee-validate";
+function ct(e) {
+  const { fields: a, ...t } = Pt(e), l = u(() => a.value.map(({ value: o }) => o));
+  return {
+    fields: a,
+    values: l,
+    ...t
+  };
+}
+const Se = /* @__PURE__ */ Symbol("dynamicFormSettings");
+function Ue(e, a) {
+  return Array.isArray(e) ? e[0] : e[a];
+}
+function Ve(e) {
+  return !!(e == null || e === "" || Array.isArray(e) && e.length === 0);
+}
+const ot = (e, a) => {
+  if (Ve(e))
+    return !0;
+  const t = Ue(a, "length");
+  return Array.isArray(e) ? e.every((l) => ot(l, { length: t })) : [...String(e)].length <= Number(t);
+}, st = (e, a) => {
+  if (Ve(e))
+    return !0;
+  const t = Ue(a, "max");
+  return Array.isArray(e) ? e.length > 0 && e.every((l) => st(l, { max: t })) : Number(e) <= Number(t);
+}, dt = (e, a) => {
+  if (Ve(e))
+    return !0;
+  const t = Ue(a, "length");
+  return Array.isArray(e) ? e.every((l) => dt(l, { length: t })) : [...String(e)].length >= Number(t);
+}, mt = (e, a) => {
+  if (Ve(e))
+    return !0;
+  const t = Ue(a, "min");
+  return Array.isArray(e) ? e.length > 0 && e.every((l) => mt(l, { min: t })) : Number(e) >= Number(t);
+}, vt = (e, a) => Ve(e) ? !0 : Array.isArray(e) ? e.every((t) => vt(t, a)) : Array.from(a).some((t) => t == e), ft = (e, a) => {
+  if (Ve(e))
+    return !0;
+  let t = Ue(a, "regex");
+  return typeof t == "string" && (t = new RegExp(t)), Array.isArray(e) ? e.every((l) => ft(l, { regex: t })) : t.test(String(e));
+};
+function ee(e) {
+  return e == null ? !1 : Array.isArray(e) ? e.some((a) => ee(a)) : typeof e == "object" ? Object.values(e).some((a) => ee(a)) : !0;
+}
+function Bt(e, a, t) {
+  return typeof e == "function" ? e(a) : e.replace(/\{(\w+)\}/g, (l, o) => {
+    if (o in a)
+      return String(a[o]);
+    if (t && !Array.isArray(t) && o in t)
+      return String(t[o]);
+    const n = Number(o);
+    return Number.isNaN(n) ? a.rule?.params && !Array.isArray(a.rule.params) ? String(a.rule.params[o] ?? `{${o}}`) : `{${o}}` : Array.isArray(t) && t[n] !== void 0 ? String(t[n]) : String(a.rule?.params?.[n] ?? `{${o}}`);
+  });
+}
+z("xsd_required", (e) => e != null && e !== "");
+z("xsd_minOccurs", (e, [a]) => Array.isArray(e) ? e.filter(ee).length >= Number(a) : Number(a) <= 0);
+z("xsd_maxOccurs", (e, [a]) => Array.isArray(e) ? e.length <= Number(a) : !0);
+const We = () => !1;
+z("xsd_choiceMinOccurs", We);
+z("xsd_choiceMaxOccurs", We);
+z("vdf_maxOccursTotal", We);
+z("xsd_minLength", dt);
+z("xsd_maxLength", ot);
+z("xsd_length", (e, [a]) => e == null || e === "" ? !0 : String(e).length === Number(a));
+z("xsd_pattern", ft);
+z("xsd_minInclusive", mt);
+z("xsd_maxInclusive", st);
+z("xsd_minExclusive", (e, [a]) => e == null || e === "" ? !0 : Number(e) > Number(a));
+z("xsd_maxExclusive", (e, [a]) => e == null || e === "" ? !0 : Number(e) < Number(a));
+z("xsd_enumeration", vt);
+z("xsd_whiteSpace", (e, [a]) => {
+  if (e == null || e === "")
+    return !0;
+  const t = String(e);
+  return a === "replace" ? !/[\t\n\r]/.test(t) : a === "collapse" ? t === t.trim() && !/\s{2,}/.test(t) : !0;
+});
+z("xsd_fractionDigits", (e, [a]) => {
+  if (e == null || e === "")
+    return !0;
+  const t = String(e).indexOf(".");
+  return t === -1 ? !0 : String(e).length - t - 1 <= Number(a);
+});
+z("xsd_totalDigits", (e, [a]) => e == null || e === "" ? !0 : (String(e).replace(/^-/, "").replace(".", "").replace(/^0+/, "") || "0").length <= Number(a));
+const kt = {
+  xsd_minOccurs: "min",
+  xsd_maxOccurs: "max",
+  xsd_choiceMinOccurs: "min",
+  xsd_choiceMaxOccurs: "max",
+  vdf_maxOccursTotal: "max",
+  xsd_minLength: "length",
+  xsd_maxLength: "length",
+  xsd_length: "length",
+  xsd_pattern: "pattern",
+  xsd_minInclusive: "min",
+  xsd_maxInclusive: "max",
+  xsd_minExclusive: "min",
+  xsd_maxExclusive: "max",
+  xsd_whiteSpace: "mode",
+  xsd_fractionDigits: "digits",
+  xsd_totalDigits: "digits"
+};
+function Ke(e) {
+  return e.label ?? e.field ?? e.name ?? "";
+}
+const Xe = /* @__PURE__ */ new Map();
+function T(e, a, t) {
+  let l = Xe.get(e);
+  l || Xe.set(e, l = /* @__PURE__ */ new Map());
+  let o = l.get(a);
+  o || l.set(a, o = /* @__PURE__ */ new Map());
+  let n = o.get(t);
+  return n || o.set(t, n = Tt(e, a, t)), n;
+}
+function Tt(e, a, t) {
+  const l = kt[e], o = a !== void 0 ? { 0: a, ...l ? { [l]: a } : {} } : {};
+  return async (n, s) => {
+    const h = Ke(s), g = h ? { name: h } : void 0, x = h && s.field !== h ? { ...s, field: h } : s, B = await Ne(
+      n,
+      a !== void 0 ? { [e]: a } : e,
+      g
+    );
+    return B.valid ? !0 : t ? Bt(t, x, o) : B.errors[0];
+  };
+}
+function Ie(e) {
+  return e?.replaceAll(/\[[`'"](.*?)[`'"]\]/g, ".$1") ?? "";
+}
+function se(e, a) {
+  if (!e || !a)
+    return e;
+  const t = a.split(".") ?? [], l = e.split(".") ?? [];
+  for (let o = 0; o < t.length; o++)
+    l[o] = t[o];
+  return l.join(".");
+}
+function Le(e) {
+  return e ? typeof e == "function" ? [e] : Array.isArray(e) ? e.flatMap(Le) : typeof e == "string" ? e.split("|").map((a) => async (t, l) => {
+    const o = Ke(l), n = await Ne(t, a, o ? { name: o } : void 0);
+    return n.valid ? !0 : n.errors[0];
+  }) : Object.entries(e).map(([a, t]) => async (l, o) => {
+    const n = Ke(o), s = await Ne(l, { [a]: t }, n ? { name: n } : void 0);
+    return s.valid ? !0 : s.errors[0];
+  }) : [];
+}
+const zt = { key: 0 }, jt = ["data-testid"], Dt = /* @__PURE__ */ Ae({
+  __name: "DynamicFormItemArray",
+  props: {
+    template: { type: [Object, Function] },
+    fieldMetadata: {},
+    pathOverride: {},
+    minOccursOverride: {},
+    maxOccursOverride: {},
+    partOfArrayField: { type: Boolean },
+    partOfAttributeField: { type: Boolean },
+    attributeOwnerHasValue: { type: Function },
+    partOfChoiceField: { type: Boolean },
+    isArrayOverride: {},
+    branchKey: {},
+    globalIndex: {},
+    insertionOrder: {},
+    index: {},
+    canAddItems: { type: Boolean },
+    canRemoveItems: { type: Boolean },
+    addItem: { type: Function },
+    removeItem: { type: Function },
+    slotProps: {}
+  },
+  emits: ["update:modelValue", "update:computedField"],
+  setup(e, { emit: a }) {
+    const t = e, l = a, o = Me(Se);
+    let n = 0;
+    const s = u(() => t.fieldMetadata), h = u(() => s.value?.path ? se(s.value.path, t.pathOverride) : ""), g = u(() => Ie(h.value)), x = $t(g), { remove: B, push: N, fields: w, update: U, values: V, replace: $ } = ct(g), y = u(
+      () => t.minOccursOverride !== void 0 ? t.minOccursOverride : s.value?.minOccurs ?? 1
+    ), b = u(
+      () => t.maxOccursOverride !== void 0 ? t.maxOccursOverride : s.value?.maxOccurs ?? 1
+    ), re = u(() => b.value === 0), X = u(() => y.value >= 1 && !re.value), ue = u(
+      () => b.value === 0 ? 0 : 1
+    ), E = u(() => b.value > w.value?.length), L = u(() => t.partOfChoiceField || s.value?.autoAddMinOccurs === !1 ? w.value?.length > 0 : w.value?.length > y.value && w.value?.length > 1), I = u(() => {
+      const f = [], O = o?.value?.messages;
+      return X.value && f.push(T("xsd_minOccurs", y.value, O?.minOccurs)), !re.value && b.value >= y.value && f.push(T("xsd_maxOccurs", b.value, O?.maxOccurs)), s.value?.validation && f.push(...Le(s.value?.validation)), f;
+    }), { label: Q, errors: de, errorMessage: le, handleBlur: q } = Pe(g, I, {
+      ...s.value?.fieldOptions ?? {},
+      validateOnValueUpdate: !1
+      // validation timing is owned by this component
+    }), ae = { label: Q, errors: de, errorMessage: le, value: V }, M = nt(), k = G(!1), Y = u(() => {
+      if (!k.value)
+        return;
+      const f = o?.value?.validateOnValueUpdateAfterSubmit === !0 ? M.value > 0 && o?.value?.validateOnValueUpdateAfterSubmit : void 0, O = o?.value?.validateWhenInError && ae?.errors.value?.length > 0 ? !0 : void 0;
+      return s.value?.fieldOptions?.validateOnValueUpdate ?? O ?? f ?? o?.value?.validateOnValueUpdate;
+    });
+    fe(
+      V,
+      (f) => {
+        Y.value && x(), l("update:modelValue", f);
+      },
+      { immediate: !0 }
+    ), Ze(() => {
+      t.partOfChoiceField || s.value?.autoAddMinOccurs !== !1 && (w.value?.length < 1 || w.value?.length < y.value) && K();
+    });
+    function K() {
+      N(null), l("update:modelValue", V.value);
+    }
+    function Z(f) {
+      L.value ? B(f ?? w.value.length - 1) : $(V.value?.map((O, P) => P === f ? null : O)), l("update:modelValue", V.value);
+    }
+    function H(f, O) {
+      k.value || (k.value = !0, Y.value && x()), f === void 0 && O >= 0 && U(O, void 0), l("update:modelValue", V.value);
+    }
+    return (f, O) => (A(), R(te, null, [
+      W(o)?.analytics ? et((A(), R("div", zt, [
+        tt("span", {
+          "data-testid": `${h.value}-analytics-render-count`
+        }, rt(at(n) ? ++n.value : ++n), 9, jt)
+      ], 512)), [
+        [it, !1]
+      ]) : be("", !0),
+      (A(), D(Fe(e.template), {
+        type: `${e.fieldMetadata.type}-array`,
+        "field-metadata": e.fieldMetadata,
+        "field-context": ae,
+        "slot-props": e.slotProps,
+        settings: W(o),
+        required: X.value,
+        disabled: re.value,
+        index: e.index,
+        "can-add-items": E.value,
+        "can-remove-items": L.value,
+        "add-item": K,
+        "remove-item": Z
+      }, {
+        default: Ce((P) => [
+          (A(!0), R(te, null, pe(W(w) ?? [], ({ key: S }, j) => (A(), D(Oe, {
+            key: S,
+            "field-metadata": e.fieldMetadata,
+            "path-override": `${h.value}[${j}]`,
+            index: j,
+            template: e.template,
+            "slot-props": P,
+            "max-occurs-override": ue.value,
+            "can-add-items": E.value,
+            "can-remove-items": L.value,
+            "add-item": K,
+            "remove-item": () => Z(j),
+            "part-of-array-field": "",
+            "is-array-override": "single",
+            "onUpdate:modelValue": (J) => H(J, j),
+            "onUpdate:computedField": O[0] || (O[0] = (J) => l("update:computedField", J)),
+            onBlur: W(q)
+          }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "max-occurs-override", "can-add-items", "can-remove-items", "remove-item", "onUpdate:modelValue", "onBlur"]))), 128))
+        ]),
+        _: 1
+      }, 8, ["type", "field-metadata", "slot-props", "settings", "required", "disabled", "index", "can-add-items", "can-remove-items"]))
+    ], 64));
+  }
+});
+function _e(e) {
+  if (e === null || typeof e != "object")
+    return e;
+  if (e instanceof Date)
+    return new Date(e);
+  if (Array.isArray(e))
+    return e.map((t) => _e(t));
+  const a = {};
+  for (const t of Object.keys(e))
+    a[t] = _e(e[t]);
+  return a;
+}
+const Nt = /* @__PURE__ */ Ae({
+  __name: "DynamicFormItemChoice",
+  props: {
+    template: { type: [Object, Function] },
+    fieldMetadata: {},
+    pathOverride: {},
+    minOccursOverride: {},
+    maxOccursOverride: {},
+    partOfArrayField: { type: Boolean },
+    partOfAttributeField: { type: Boolean },
+    attributeOwnerHasValue: { type: Function },
+    partOfChoiceField: { type: Boolean },
+    isArrayOverride: {},
+    branchKey: {},
+    globalIndex: {},
+    insertionOrder: {},
+    index: {},
+    canAddItems: { type: Boolean },
+    canRemoveItems: { type: Boolean },
+    addItem: { type: Function },
+    removeItem: { type: Function },
+    slotProps: {}
+  },
+  emits: ["update:modelValue", "update:computedField"],
+  setup(e, { emit: a }) {
+    const t = e, l = a, o = Me(Se), n = u(() => t.fieldMetadata), s = u(() => se(n.value.path ?? "", t.pathOverride)), h = u(() => Ie(s.value)), g = t.fieldMetadata?.explicitChoiceSelection === !0, x = u(() => n.value?.preserveOnSwitch === !0), B = u(() => n.value?.displayOrder === "added"), N = u(() => n.value?.preserveOrder === !0), w = (n.value?.choice ?? []).every((r) => (r.children?.length ?? 0) > 0), U = u(() => N.value && w), V = ut(), $ = G(null), y = G({}), b = G(/* @__PURE__ */ new Map());
+    let re = 0;
+    const X = (n.value?.choice ?? []).map(
+      (r) => lt(() => r.path ? se(r.path, t.pathOverride) : "")
+    ), ue = (n.value?.choice ?? []).map((r) => u(() => r.path ? Ie(se(r.path, t.pathOverride)) : "")), E = ue.map((r) => ct(r)), L = u(
+      () => t.minOccursOverride !== void 0 ? t.minOccursOverride : n.value?.minOccurs ?? 1
+    ), I = u(
+      () => t.maxOccursOverride !== void 0 ? t.maxOccursOverride : n.value?.maxOccurs ?? 1
+    ), Q = u(() => I.value === 0), de = u(() => L.value >= 1 && !Q.value), le = u(
+      () => L.value === 0 ? 0 : void 0
+    ), q = u(
+      () => I.value === 0 ? 0 : void 0
+    ), ae = u(() => n.value?.maxOccurs > 1 ? "array" : void 0), M = u(() => `${n.value?.type}${n.value?.maxOccurs > 1 ? "-choice-array" : "-choice"}`), k = G({}), Y = u(() => Object.values(k.value).map((r) => r.value)), K = u(
+      () => !g && n.value?.choice?.length === 1 ? n.value?.choice[0] : void 0
+    ), Z = u(() => {
+      if (q.value === 0)
+        return 0;
+      const r = K.value;
+      return r?.maxOccursTotal === void 0 ? q.value : Math.min(r.maxOccursTotal, r.maxOccurs ?? 1);
+    }), H = u(() => {
+      const r = {};
+      n.value?.choice?.forEach((c, m) => {
+        r[m] = {
+          childValuesCount: 0,
+          childOccurrences: 0,
+          childMaxOccurrences: 1,
+          choiceValuesCount: 0,
+          choiceOccurrences: 0,
+          overrideChildMaxOccurrences: void 0,
+          overrideChildMinOccurrences: 0,
+          // children are optional by default inside a choice
+          maxOccursTotal: c.maxOccursTotal
+        };
+      });
+      const i = I.value ?? 1;
+      if (i === 0)
+        return n.value?.choice?.forEach((c, m) => {
+          r[m].overrideChildMaxOccurrences = 0, r[m].overrideChildMinOccurrences = 0;
+        }), r;
+      for (const [c, m] of Object.entries(k.value ?? {})) {
+        let C = Math.ceil(m.occurrences / m.maxOccurrences);
+        const _ = Math.ceil(m.valuesCount / m.maxOccurrences);
+        i * m.maxOccurrences === 1 && (C = _), r[c] = {
+          childValuesCount: m.valuesCount,
+          childOccurrences: m.occurrences,
+          childMaxOccurrences: m.maxOccurrences,
+          choiceOccurrences: C,
+          choiceValuesCount: _,
+          overrideChildMinOccurrences: m.valuesCount === 0 ? 0 : void 0,
+          // optional when empty
+          overrideChildMaxOccurrences: void 0,
+          // calculated in pass 2
+          maxOccursTotal: n.value?.choice?.[Number(c)]?.maxOccursTotal
+        };
+      }
+      const p = Object.values(r).reduce(
+        (c, m) => c + m.choiceOccurrences,
+        0
+      );
+      return Object.values(r).forEach((c) => {
+        const C = (p - c.choiceOccurrences) * c.childMaxOccurrences, _ = i * c.childMaxOccurrences;
+        let ne = Math.max(
+          _ - C,
+          c.childValuesCount
+        );
+        c.maxOccursTotal !== void 0 && (ne = Math.min(ne, c.maxOccursTotal)), c.overrideChildMaxOccurrences = ne;
+      }), r;
+    }), f = u(
+      () => Object.values(H.value).reduce(
+        (r, i) => r + i.choiceValuesCount,
+        0
+      )
+    ), O = u(() => {
+      const r = [];
+      return n.value?.choice?.forEach((i, p) => {
+        if (g && I.value > 1) {
+          (E[p]?.fields.value ?? []).forEach((_, ne) => {
+            r.push({ branchKey: i.name, index: ne });
+          });
+          return;
+        }
+        const c = ee(X[p]?.value), m = g && $.value === i.name;
+        (c || m) && r.push({ branchKey: i.name, index: 0 });
+      }), r;
+    }), P = u(() => {
+      if (!B.value)
+        return O.value;
+      function r(i) {
+        return U.value ? Te(i)?.order : b.value.get(he(i));
+      }
+      return O.value.map((i) => ({ occurrence: i, sortKey: r(i) })).sort((i, p) => {
+        const c = i.sortKey !== void 0, m = p.sortKey !== void 0;
+        return c !== m ? c ? 1 : -1 : c ? i.sortKey - p.sortKey : 0;
+      }).map((i) => i.occurrence);
+    }), S = u(() => Q.value ? 0 : g && I.value > 1 ? E.reduce((r, i, p) => {
+      const c = n.value.choice[p].maxOccurs;
+      return r + Math.ceil(i.fields.value.length / c);
+    }, 0) : g ? O.value.length : f.value), j = u(() => g && I.value === 1 ? Math.max(f.value, $.value ? 1 : 0) : g && I.value > 1 ? Math.max(f.value, S.value) : f.value), J = u(
+      () => Object.values(H.value).find((r) => r.maxOccursTotal !== void 0 && r.childOccurrences > r.maxOccursTotal)?.maxOccursTotal
+    ), ce = u(() => {
+      if (K.value || Q.value)
+        return;
+      const r = o?.value?.messages, i = [];
+      return j.value < L.value && i.push(T("xsd_choiceMinOccurs", L.value, r?.choiceMinOccurs)), S.value > I.value && i.push(T("xsd_choiceMaxOccurs", I.value, r?.choiceMaxOccurs)), J.value !== void 0 && i.push(T("vdf_maxOccursTotal", J.value, r?.maxOccursTotal)), i.length ? i : void 0;
+    }), { errors: me, errorMessage: $e } = Pe(h, ce, n.value?.fieldOptions), v = { label: n.value?.fieldOptions?.label, errors: me, errorMessage: $e, value: Y };
+    fe(n, (r) => {
+      r && r.choice?.forEach((i, p) => {
+        p in k.value || d(void 0, p, i.maxOccurs);
+      });
+    }, { immediate: !0 }), g && fe(
+      () => E.map((r) => r.values.value),
+      (r) => {
+        I.value <= 1 || r.forEach((i, p) => {
+          const c = n.value.choice[p].maxOccurs;
+          d(i, p, c);
+        });
+      },
+      { immediate: !0 }
+    );
+    function d(r, i, p = 1, c = !1) {
+      if (c) {
+        l("update:modelValue", Y.value);
+        return;
+      }
+      if (i === void 0)
+        return;
+      let m = Array.isArray(r) ? r : [r];
+      (I.value ?? 1) * p === 1 && (m = m.filter((je) => je !== void 0));
+      const ne = m.length, bt = m.filter((je) => ee(je)).length, we = k.value[i] ?? {};
+      we.value = r, we.occurrences = ne, we.valuesCount = bt, we.maxOccurrences = p, k.value[i] || (k.value[i] = we), l("update:modelValue", Y.value);
+    }
+    function F(r) {
+      return n.value?.choice?.findIndex((i) => i.name === r) ?? -1;
+    }
+    function ve(r) {
+      if (q.value === 0)
+        return 0;
+      const i = ie(r);
+      return i?.maxOccursTotal === void 0 ? q.value : Math.min(i.maxOccursTotal, i.maxOccurs ?? 1);
+    }
+    function ie(r) {
+      const i = F(r);
+      return i >= 0 ? n.value?.choice?.[i] : void 0;
+    }
+    function ye(r, i = {}) {
+      const p = F(r);
+      if (p < 0)
+        return;
+      const c = n.value?.choice?.[p], m = c?.path ? se(c.path, t.pathOverride) : void 0;
+      i.stash ? y.value[r] = _e(X[p]?.value ?? void 0) : r in y.value && delete y.value[r], m && V?.setFieldValue(m, void 0, !1);
+      const C = k.value[p];
+      C && (C.value = void 0, C.occurrences = 0, C.valuesCount = 0);
+    }
+    function ht(r) {
+      if (!x.value || !(r in y.value))
+        return;
+      const i = F(r), p = se(n.value.choice[i].path, t.pathOverride);
+      V?.setFieldValue(p, y.value[r], !1);
+    }
+    function qe(r) {
+      if (!Ee(r))
+        return;
+      const i = F(r);
+      if (I.value > 1) {
+        const p = E[i]?.fields.value.length ?? 0, c = O.value.length;
+        U.value ? E[i]?.push({ order: c + 1 }) : E[i]?.push(null), b.value.set(he({ branchKey: r, index: p }), ++re);
+        return;
+      }
+      if ($.value !== r) {
+        for (const p of O.value)
+          p.branchKey !== r && ye(p.branchKey, { stash: x.value });
+        ht(r), $.value = r;
+      }
+    }
+    function Je(r, i) {
+      const p = F(r);
+      if (p < 0)
+        return;
+      if (I.value > 1) {
+        const m = E[p]?.fields.value.length ?? 0, C = i ?? m - 1;
+        if (C < 0 || C >= m)
+          return;
+        const _ = he({ branchKey: r, index: C });
+        E[p]?.remove(C), b.value.delete(_), U.value && He();
+        return;
+      }
+      O.value.some((m) => m.branchKey === r) && (ye(r), $.value === r && ($.value = null));
+    }
+    function Ee(r) {
+      if (Q.value)
+        return !1;
+      const i = F(r);
+      if (i < 0)
+        return !1;
+      if (I.value <= 1)
+        return !0;
+      const p = E[i].fields.value.length, c = H.value[i]?.overrideChildMaxOccurrences;
+      return c === void 0 || p < c;
+    }
+    function Be(r) {
+      return E[F(r)];
+    }
+    function Re(r) {
+      return Be(r.branchKey).fields.value[r.index].key;
+    }
+    function he(r) {
+      return `${r.branchKey}:${Re(r)}`;
+    }
+    function ke(r) {
+      return `${ue[F(r.branchKey)].value}[${r.index}]`;
+    }
+    function Te(r) {
+      return Be(r.branchKey).fields.value[r.index].value;
+    }
+    function He() {
+      const r = O.value, i = r.length;
+      r.map((c, m) => {
+        const C = Te(c)?.order, _ = b.value.get(he(c)), ne = C ?? (_ !== void 0 ? i + _ : m + 1);
+        return { occurrence: c, currentOrder: C, sortKey: ne };
+      }).sort((c, m) => c.sortKey - m.sortKey).forEach(({ occurrence: c, currentOrder: m }, C) => {
+        const _ = C + 1;
+        m !== _ && V?.setFieldValue(`${ke(c)}.order`, _, !1);
+      });
+    }
+    function Ot() {
+      O.value.forEach((r) => {
+        const i = Te(r);
+        i && typeof i == "object" && "order" in i && V?.setFieldValue(`${ke(r)}.order`, void 0, !1);
+      });
+    }
+    const ze = /* @__PURE__ */ new Map();
+    function yt(r) {
+      const i = he(r), p = ze.get(i);
+      if (p)
+        return p;
+      const c = Re(r), m = () => {
+        const C = Be(r.branchKey).fields.value.findIndex((_) => _.key === c);
+        C >= 0 && Je(r.branchKey, C), ze.delete(i);
+      };
+      return ze.set(i, m), m;
+    }
+    const Ge = /* @__PURE__ */ new Map();
+    function xt(r) {
+      let i = Ge.get(r);
+      return i || (i = () => qe(r), Ge.set(r, i)), i;
+    }
+    const gt = u(() => U.value && g && I.value > 1);
+    return fe(gt, (r) => {
+      r && He();
+    }, { immediate: !0 }), fe(U, (r, i) => {
+      !g || I.value <= 1 || !r && i && Ot();
+    }), (r, i) => (A(), D(Fe(e.template), {
+      type: M.value,
+      "field-metadata": e.fieldMetadata,
+      "field-context": v,
+      "slot-props": e.slotProps,
+      settings: W(o),
+      required: de.value,
+      index: e.index,
+      disabled: Q.value,
+      "can-add-items": e.canAddItems,
+      "can-remove-items": e.canRemoveItems,
+      "add-item": e.addItem,
+      "remove-item": e.removeItem,
+      "add-choice-occurrence": qe,
+      "remove-choice-occurrence": Je,
+      "can-add-choice-occurrence": Ee,
+      "active-choice-occurrences": O.value,
+      "used-choice-occurrences": S.value
+    }, {
+      default: Ce((p) => [
+        K.value ? (A(), D(Oe, {
+          key: 0,
+          "field-metadata": K.value,
+          "path-override": e.pathOverride,
+          template: e.template,
+          "slot-props": p,
+          "min-occurs-override": le.value,
+          "max-occurs-override": Z.value,
+          "part-of-choice-field": "",
+          "onUpdate:modelValue": i[0] || (i[0] = (c) => d(c, 0, K.value.maxOccurs, !0)),
+          "onUpdate:computedField": i[1] || (i[1] = (c) => l("update:computedField", c))
+        }, null, 8, ["field-metadata", "path-override", "template", "slot-props", "min-occurs-override", "max-occurs-override"])) : g && I.value === 1 ? (A(!0), R(te, { key: 1 }, pe(O.value, (c) => (A(), D(Oe, {
+          key: c.branchKey,
+          "field-metadata": ie(c.branchKey),
+          "path-override": e.pathOverride,
+          index: F(c.branchKey),
+          template: e.template,
+          "slot-props": p,
+          "min-occurs-override": le.value,
+          "max-occurs-override": ve(c.branchKey),
+          "is-array-override": ae.value,
+          "part-of-choice-field": "",
+          "onUpdate:modelValue": (m) => d(m, F(c.branchKey), ie(c.branchKey).maxOccurs),
+          "onUpdate:computedField": i[2] || (i[2] = (m) => l("update:computedField", m))
+        }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "min-occurs-override", "max-occurs-override", "is-array-override", "onUpdate:modelValue"]))), 128)) : g ? (A(!0), R(te, { key: 2 }, pe(P.value, (c, m) => (A(), D(Oe, {
+          key: he(c),
+          "field-metadata": ie(c.branchKey),
+          "path-override": ke(c),
+          index: c.index,
+          template: e.template,
+          "slot-props": p,
+          "max-occurs-override": 1,
+          "is-array-override": "single",
+          "part-of-array-field": "",
+          "part-of-choice-field": "",
+          "branch-key": c.branchKey,
+          "global-index": m,
+          "insertion-order": b.value.get(he(c)),
+          "can-add-items": Ee(c.branchKey),
+          "add-item": xt(c.branchKey),
+          "can-remove-items": !0,
+          "remove-item": yt(c),
+          "onUpdate:computedField": i[3] || (i[3] = (C) => l("update:computedField", C))
+        }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "branch-key", "global-index", "insertion-order", "can-add-items", "add-item", "remove-item"]))), 128)) : (A(!0), R(te, { key: 3 }, pe(n.value.choice, (c, m) => (A(), D(Oe, {
+          key: c.name,
+          "field-metadata": c,
+          "path-override": e.pathOverride,
+          index: m,
+          template: e.template,
+          "slot-props": p,
+          "min-occurs-override": H.value[m]?.overrideChildMinOccurrences,
+          "max-occurs-override": H.value[m]?.overrideChildMaxOccurrences,
+          "is-array-override": ae.value,
+          "part-of-choice-field": "",
+          "onUpdate:modelValue": (C) => d(C, m, c.maxOccurs),
+          "onUpdate:computedField": i[4] || (i[4] = (C) => l("update:computedField", C))
+        }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "min-occurs-override", "max-occurs-override", "is-array-override", "onUpdate:modelValue"]))), 128))
+      ]),
+      _: 1
+    }, 8, ["type", "field-metadata", "slot-props", "settings", "required", "index", "disabled", "can-add-items", "can-remove-items", "add-item", "remove-item", "active-choice-occurrences", "used-choice-occurrences"]));
+  }
+});
+function Kt() {
+  const a = Ft()?.provides;
+  return a && De in a ? a[De] : Me(De);
+}
+function pt() {
+  const e = Kt();
+  async function a(t) {
+    const l = e.getAllPathStates().map((h) => h.path).filter((h) => h === t || h.startsWith(`${t}.`) || h.startsWith(`${t}[`)), o = await Promise.all(
+      l.map(async (h) => ({
+        path: h,
+        result: await e.validateField(h)
+      }))
+    ), n = Object.fromEntries(
+      o.map(({ path: h, result: g }) => [h, g])
+    ), s = Object.fromEntries(
+      o.filter(({ result: h }) => !h.valid).map(({ path: h, result: g }) => [h, g.errors[0] ?? ""])
+    );
+    return {
+      valid: o.every(({ result: h }) => h.valid),
+      results: n,
+      errors: s,
+      source: "fields"
+    };
+  }
+  return { validateSection: a };
+}
+const _t = /* @__PURE__ */ Ae({
+  __name: "DynamicFormItemWizard",
+  props: {
+    template: { type: [Object, Function] },
+    fieldMetadata: {},
+    pathOverride: {},
+    minOccursOverride: {},
+    maxOccursOverride: {},
+    partOfArrayField: { type: Boolean },
+    partOfAttributeField: { type: Boolean },
+    attributeOwnerHasValue: { type: Function },
+    partOfChoiceField: { type: Boolean },
+    isArrayOverride: {},
+    branchKey: {},
+    globalIndex: {},
+    insertionOrder: {},
+    index: {},
+    canAddItems: { type: Boolean },
+    canRemoveItems: { type: Boolean },
+    addItem: { type: Function },
+    removeItem: { type: Function },
+    slotProps: {}
+  },
+  emits: ["update:modelValue", "update:computedField"],
+  setup(e, { emit: a }) {
+    const t = e, l = a, o = Me(Se), { validateSection: n } = pt(), s = u(() => t.fieldMetadata), h = u(() => se(s.value?.path ?? "", t.pathOverride)), g = u(() => Ie(h.value)), { errors: x, errorMessage: B, value: N } = Pe(g, void 0, s.value?.fieldOptions), w = { label: s.value?.fieldOptions?.label, errors: x, errorMessage: B, value: u(() => {
+    }) };
+    (s.value?.maxOccurs ?? 1) > 1 && console.warn(`[DynamicFormItemWizard] "${s.value.path}": "maxOccurs" is ignored on a wizard node; wizard pages come from "children" only.`);
+    const U = u(() => s.value?.children ?? []), V = u(() => U.value.length), $ = (() => {
+      const f = t.fieldMetadata?.wizard, O = typeof f == "object" && f !== null ? f : {};
+      return {
+        allowForwardJump: O.allowForwardJump === !0,
+        // Defaults on: forward movement runs validation so page errors surface. `false` opts into a
+        // silent jump. Only meaningful when the move does not block (non-linear mode or a jump);
+        // linear `next` always validates because it needs the result to decide whether to block.
+        validateOnJump: O.validateOnJump !== !1
+      };
+    })(), y = G(0), b = G(!1), re = u(() => y.value === 0), X = u(() => V.value === 0 ? !0 : y.value === V.value - 1), ue = u(() => t.minOccursOverride !== void 0 ? t.minOccursOverride : s.value?.minOccurs ?? 1), E = u(() => t.maxOccursOverride !== void 0 ? t.maxOccursOverride : s.value?.maxOccurs ?? 1), L = u(() => E.value === 0), I = u(() => ue.value >= 1 && !L.value), Q = u(() => {
+      if (t.minOccursOverride === 0)
+        return 0;
+      if (!(ue.value > 0))
+        return ee(N.value) ? void 0 : 0;
+    }), de = u(
+      () => E.value === 0 ? 0 : void 0
+    );
+    function le() {
+      const f = U.value[y.value];
+      return f?.path ? se(f.path, t.pathOverride) : void 0;
+    }
+    async function q() {
+      const f = le();
+      if (!f)
+        return !0;
+      b.value = !0;
+      try {
+        return (await n(f)).valid;
+      } finally {
+        b.value = !1;
+      }
+    }
+    async function ae() {
+      if (V.value === 0 || X.value)
+        return;
+      if ($.allowForwardJump)
+        return k(y.value + 1);
+      const f = y.value;
+      await q() && y.value === f && (y.value = f + 1);
+    }
+    function M() {
+      V.value === 0 || y.value === 0 || y.value--;
+    }
+    async function k(f, O) {
+      if (V.value === 0)
+        return;
+      const P = Math.min(Math.max(f, 0), V.value - 1), S = y.value;
+      P !== S && (P > S && (!(O?.allowForwardJump ?? $.allowForwardJump) || (O?.validateOnJump ?? $.validateOnJump) && (await q(), y.value !== S)) || (y.value = P));
+    }
+    function Y(f) {
+      l("update:computedField", f);
+    }
+    const K = /* @__PURE__ */ new Map();
+    function Z(f, O) {
+      const P = O ?? {}, S = K.get(f);
+      return S && H(S, P) ? S : (K.set(f, P), P);
+    }
+    function H(f, O) {
+      const P = Object.keys(f), S = Object.keys(O);
+      return P.length === S.length && P.every((j) => Object.is(f[j], O[j]));
+    }
+    return (f, O) => (A(), D(Fe(e.template), {
+      type: `${e.fieldMetadata.type}-wizard`,
+      "field-metadata": e.fieldMetadata,
+      "field-context": w,
+      "slot-props": e.slotProps,
+      settings: W(o),
+      required: I.value,
+      disabled: L.value,
+      index: e.index,
+      "can-add-items": e.canAddItems,
+      "can-remove-items": e.canRemoveItems,
+      "add-item": e.addItem,
+      "remove-item": e.removeItem,
+      "current-step-index": y.value,
+      pages: U.value,
+      "page-count": V.value,
+      "is-first": re.value,
+      "is-last": X.value,
+      "is-validating": b.value,
+      "wizard-config": W($),
+      next: ae,
+      prev: M,
+      "goto-step": k
+    }, {
+      default: Ce((P) => [
+        (A(!0), R(te, null, pe(U.value, (S, j) => (A(), D(Fe(e.template), {
+          key: S.path,
+          type: `${S.type}-wizard-page`,
+          "field-metadata": S,
+          "field-context": w,
+          "slot-props": Z("wizard", P),
+          settings: W(o),
+          required: !1,
+          disabled: !1,
+          index: j,
+          "is-current": j === y.value,
+          "page-index": j,
+          "current-step-index": y.value,
+          "is-first": re.value,
+          "is-last": X.value,
+          "wizard-config": W($),
+          next: ae,
+          prev: M,
+          "goto-step": k
+        }, {
+          default: Ce((J) => [
+            Ct(Oe, {
+              "field-metadata": S,
+              "path-override": e.pathOverride,
+              index: j,
+              template: e.template,
+              "slot-props": Z(`page:${S.path}`, J),
+              "min-occurs-override": Q.value,
+              "max-occurs-override": de.value,
+              "onUpdate:modelValue": O[0] || (O[0] = (ce) => l("update:modelValue", ce)),
+              "onUpdate:computedField": Y
+            }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "min-occurs-override", "max-occurs-override"])
+          ]),
+          _: 2
+        }, 1032, ["type", "field-metadata", "slot-props", "settings", "index", "is-current", "page-index", "current-step-index", "is-first", "is-last", "wizard-config"]))), 128))
+      ]),
+      _: 1
+    }, 8, ["type", "field-metadata", "slot-props", "settings", "required", "disabled", "index", "can-add-items", "can-remove-items", "add-item", "remove-item", "current-step-index", "pages", "page-count", "is-first", "is-last", "is-validating", "wizard-config"]));
+  }
+});
+function Wt(e) {
+  const {
+    name: a,
+    path: t,
+    children: l,
+    choice: o,
+    attributes: n,
+    fieldOptions: s,
+    computedProps: h,
+    maxOccurs: g,
+    _hash: x,
+    parent: B,
+    isComplexType: N,
+    computeOnChildValueChange: w,
+    ...U
+  } = e, V = Object.fromEntries(
+    Object.entries(U).sort(([$], [y]) => $.localeCompare(y))
+  );
+  return JSON.stringify(V);
+}
+const Lt = { key: 0 }, qt = ["data-testid"], Qe = 100, Oe = /* @__PURE__ */ Ae({
+  __name: "DynamicFormItem",
+  props: {
+    template: { type: [Object, Function] },
+    fieldMetadata: {},
+    pathOverride: {},
+    minOccursOverride: {},
+    maxOccursOverride: {},
+    partOfArrayField: { type: Boolean },
+    partOfAttributeField: { type: Boolean },
+    attributeOwnerHasValue: { type: Function },
+    partOfChoiceField: { type: Boolean },
+    isArrayOverride: {},
+    branchKey: {},
+    globalIndex: {},
+    insertionOrder: {},
+    index: {},
+    canAddItems: { type: Boolean },
+    canRemoveItems: { type: Boolean },
+    addItem: { type: Function },
+    removeItem: { type: Function },
+    slotProps: {}
+  },
+  emits: ["update:modelValue", "blur", "update:computedField"],
+  setup(e, { emit: a }) {
+    const t = e, l = a, o = Me(Se);
+    let n = 0, s = 0, h;
+    function g(v) {
+      if (s++, h == null && (h = setTimeout(() => {
+        s = 0, h = void 0;
+      }, 0)), s > Qe)
+        throw new Error(
+          `[DynamicFormItem] Possible infinite loop detected in computedProps for field "${v}". computedProps recomputed more than ${Qe} times without the event loop turning. Ensure value writes inside computedProps are idempotent (the same input always produces the same output).`
+        );
+    }
+    const x = u(() => t.fieldMetadata), B = u(() => x.value?.path ? se(x.value.path, t.pathOverride) : ""), N = u(() => x.value?.isComplexType || x.value?.attributes?.length), w = u(() => {
+      let v = B.value;
+      if (N.value && v) {
+        const d = o?.value?.complexTypeValueProperty ?? "value";
+        v = `${v}['${d}']`;
+      }
+      return v;
+    }), U = u(() => Ie(w.value)), V = u(() => t.isArrayOverride === "array" ? !0 : t.isArrayOverride === "single" ? !1 : (x.value?.maxOccurs ?? 1) > 1), $ = G([]), y = V.value ? { value: G(void 0) } : Pe(U, $, {
+      ...x.value?.fieldOptions ?? {},
+      validateOnValueUpdate: !1
+      // validation timing is owned by this component
+    }), b = y.value, re = ut();
+    y.hasValue = u(() => ee(b.value));
+    const X = y.handleBlur;
+    y.handleBlur = function(v, d) {
+      d = d ?? o?.value?.validateOnBlur, X(v, d), l("blur", v, d);
+    };
+    const ue = y.handleChange;
+    y.handleChange = function(v, d) {
+      ue(v, d === !0);
+    };
+    const E = u(() => !!x.value?.wizard), L = u(() => !!x.value?.children?.length), I = u(() => !!x.value?.choice?.length), Q = u(() => !V.value && !I.value && !L.value && !E.value), de = G(!0), le = G(0), q = G({}), ae = u(() => Object.values(q.value)), M = u(() => {
+      g(B.value), x.value?.computeOnChildValueChange === !0 && le.value;
+      const d = (x.value?.computedProps ?? []).reduce(
+        (F, ve) => (ve(F, b, ae), F),
+        { ...x.value, path: B.value }
+      );
+      return d.path = B.value, d.explicitChoiceSelection = x.value?.explicitChoiceSelection, d.preserveOnSwitch = x.value?.preserveOnSwitch, d.wizard = x.value?.wizard, d._hash = Wt(d), d;
+    }), k = u(() => t.minOccursOverride !== void 0 ? t.minOccursOverride : t.partOfArrayField ? 0 : M.value?.minOccurs ?? 1), Y = u(
+      () => t.maxOccursOverride !== void 0 ? t.maxOccursOverride : M.value?.maxOccurs ?? 1
+    ), K = u(() => Y.value === 0), Z = u(() => k.value >= 1 && !K.value), H = u(() => {
+      if (t.minOccursOverride === 0)
+        return t.minOccursOverride;
+      if (!(k.value > 0) && !ee(b.value))
+        return 0;
+    }), f = u(
+      () => Y.value === 0 ? 0 : void 0
+    ), O = u(() => t.partOfArrayField && ee(b.value) ? !0 : t.canRemoveItems), P = nt(), S = u(() => {
+      const v = o?.value?.validateOnValueUpdateAfterSubmit === !0 ? P.value > 0 && o?.value?.validateOnValueUpdateAfterSubmit : void 0, d = o?.value?.validateWhenInError && y?.errors.value?.length > 0 ? !0 : void 0;
+      return x.value?.fieldOptions?.validateOnValueUpdate ?? d ?? v ?? o?.value?.validateOnValueUpdate;
+    }), j = u(
+      () => x.value?.attributes?.length && ee(b.value)
+    );
+    Ze(() => {
+      const v = [], d = x.value.restriction ?? {}, F = o?.value?.messages;
+      Z.value && v.push(T("xsd_required", void 0, F?.required)), d.minLength != null && v.push(T("xsd_minLength", d.minLength, F?.minLength)), d.maxLength != null && v.push(T("xsd_maxLength", d.maxLength, F?.maxLength)), d.length != null && v.push(T("xsd_length", d.length, F?.length)), d.pattern != null && v.push(T("xsd_pattern", d.pattern, F?.pattern)), d.minInclusive != null && v.push(T("xsd_minInclusive", d.minInclusive, F?.minInclusive)), d.maxInclusive != null && v.push(T("xsd_maxInclusive", d.maxInclusive, F?.maxInclusive)), d.minExclusive != null && v.push(T("xsd_minExclusive", d.minExclusive, F?.minExclusive)), d.maxExclusive != null && v.push(T("xsd_maxExclusive", d.maxExclusive, F?.maxExclusive)), d.enumeration != null && v.push(T("xsd_enumeration", d.enumeration, F?.enumeration)), d.whiteSpace != null && v.push(T("xsd_whiteSpace", d.whiteSpace, F?.whiteSpace)), d.fractionDigits != null && v.push(T("xsd_fractionDigits", d.fractionDigits, F?.fractionDigits)), d.totalDigits != null && v.push(T("xsd_totalDigits", d.totalDigits, F?.totalDigits)), x.value?.validation && v.push(...Le(x.value?.validation)), $.value = v;
+    });
+    let J = !1;
+    fe(b, (v) => {
+      J || (J = !0, v === "" && (b.value = t.partOfArrayField ? null : void 0), J = !1);
+    }, {
+      flush: "sync"
+    }), fe(
+      b,
+      (v) => {
+        Q.value && ((!de.value || v) && (me(), S.value && y?.validate()), de.value = !1);
+      },
+      {
+        immediate: !0
+      }
+    ), At(() => {
+      l("update:computedField", M.value), fe(() => M.value._hash, (v, d) => {
+        v !== d && l("update:computedField", M.value);
+      });
+    }), Vt(() => {
+      h != null && clearTimeout(h), !(t.partOfArrayField || !(t.partOfAttributeField && !t.attributeOwnerHasValue?.()) && (x.value?.fieldOptions?.keepValueOnUnmount ?? wt(re?.keepValuesOnUnmount))) && b.value !== void 0 && (b.value = void 0, me());
+    });
+    function ce(v) {
+      !v.path || q.value[v.path]?._hash === v._hash || (q.value[v.path] = v);
+    }
+    function me() {
+      le.value++, l("update:modelValue", b.value);
+    }
+    function $e(v) {
+      b.value = v, l("update:modelValue", b.value);
+    }
+    return (v, d) => {
+      const F = It("DynamicFormItem", !0);
+      return A(), R(te, null, [
+        W(o)?.analytics ? et((A(), R("div", Lt, [
+          tt("span", {
+            "data-testid": `${B.value}-analytics-render-count`
+          }, rt(at(n) ? ++n.value : ++n), 9, qt)
+        ], 512)), [
+          [it, !1]
+        ]) : be("", !0),
+        E.value ? (A(), D(_t, oe({ key: 1 }, t, {
+          "field-metadata": M.value,
+          "onUpdate:modelValue": me,
+          "onUpdate:computedField": ce
+        }), null, 16, ["field-metadata"])) : I.value ? (A(), D(Nt, oe({ key: 2 }, t, {
+          "field-metadata": M.value,
+          "onUpdate:modelValue": me,
+          "onUpdate:computedField": ce
+        }), null, 16, ["field-metadata"])) : V.value ? (A(), D(Dt, oe({ key: 3 }, t, {
+          "part-of-choice-field": e.partOfChoiceField,
+          "field-metadata": M.value,
+          "onUpdate:modelValue": $e,
+          "onUpdate:computedField": ce
+        }), null, 16, ["part-of-choice-field", "field-metadata"])) : (A(), D(Fe(e.template), {
+          key: 4,
+          type: e.branchKey !== void 0 ? `${M.value.type}-choice-array-item` : e.partOfArrayField ? `${M.value.type}-array-item` : M.value.type,
+          "field-metadata": M.value,
+          "field-context": W(y),
+          "slot-props": e.slotProps,
+          settings: W(o),
+          required: Z.value,
+          disabled: K.value,
+          index: e.index,
+          "can-add-items": e.canAddItems,
+          "can-remove-items": O.value,
+          "add-item": e.addItem,
+          "remove-item": e.removeItem,
+          "branch-key": e.branchKey,
+          "global-index": e.globalIndex,
+          "insertion-order": e.insertionOrder
+        }, {
+          default: Ce((ve) => [
+            L.value ? (A(!0), R(te, { key: 0 }, pe(M.value.children, (ie, ye) => (A(), D(F, {
+              key: ie.path,
+              "field-metadata": ie,
+              "path-override": w.value,
+              index: ye,
+              template: e.template,
+              "slot-props": ve,
+              "min-occurs-override": H.value,
+              "max-occurs-override": f.value,
+              "onUpdate:modelValue": me,
+              "onUpdate:computedField": ce
+            }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "min-occurs-override", "max-occurs-override"]))), 128)) : be("", !0),
+            L.value ? be("", !0) : (A(), D(Fe(e.template), {
+              key: 1,
+              type: `${M.value.type}-input`,
+              "field-metadata": M.value,
+              "field-context": W(y),
+              "slot-props": ve,
+              settings: W(o),
+              required: Z.value,
+              disabled: K.value,
+              index: e.index,
+              "can-add-items": e.canAddItems,
+              "can-remove-items": O.value,
+              "add-item": e.addItem,
+              "remove-item": e.removeItem
+            }, null, 8, ["type", "field-metadata", "field-context", "slot-props", "settings", "required", "disabled", "index", "can-add-items", "can-remove-items", "add-item", "remove-item"]))
+          ]),
+          attributes: Ce((ve) => [
+            j.value ? (A(!0), R(te, { key: 0 }, pe(M.value.attributes, (ie, ye) => (A(), D(F, {
+              key: ie.path,
+              "field-metadata": ie,
+              "path-override": B.value,
+              index: ye,
+              template: e.template,
+              "slot-props": ve,
+              "min-occurs-override": H.value,
+              "max-occurs-override": f.value,
+              "part-of-attribute-field": !0,
+              "attribute-owner-has-value": () => W(ee)(W(b)),
+              "onUpdate:modelValue": me,
+              "onUpdate:computedField": ce
+            }, null, 8, ["field-metadata", "path-override", "index", "template", "slot-props", "min-occurs-override", "max-occurs-override", "attribute-owner-has-value"]))), 128)) : be("", !0)
+          ]),
+          _: 1
+        }, 8, ["type", "field-metadata", "field-context", "slot-props", "settings", "required", "disabled", "index", "can-add-items", "can-remove-items", "add-item", "remove-item", "branch-key", "global-index", "insertion-order"]))
+      ], 64);
+    };
+  }
+}), Qt = /* @__PURE__ */ Ae({
+  name: "DynamicForm",
+  inheritAttrs: !1,
+  __name: "DynamicForm",
+  props: {
+    metadata: {},
+    template: { type: [Object, Function] },
+    settings: {}
+  },
+  setup(e) {
+    const a = u(() => ({
+      validateOnValueUpdate: !0,
+      validateWhenInError: !0,
+      ...e.settings ?? {}
+    }));
+    Mt(Se, a);
+    const t = u(
+      () => Array.isArray(e.metadata) ? e.metadata : [e.metadata]
+    ), l = u(
+      () => t.value?.map((s, h) => n(s, h)) ?? []
+    ), o = u(
+      () => e.template
+    );
+    function n(s, h, g) {
+      if (!s)
+        return s;
+      const x = s.name ?? `field-${h}`, B = s.path ?? [g?.path, x].filter(Boolean).join("."), N = {
+        name: x,
+        path: B,
+        type: "text",
+        minOccurs: 1,
+        maxOccurs: 1,
+        ...s,
+        computedProps: [...s.computedProps ?? []],
+        parent: g
+      };
+      return N.children = (s.children ?? []).map(
+        (w, U) => n(w, U, N)
+      ), N.choice = (s.choice ?? []).map(
+        (w, U) => n(w, U, N)
+      ), N.attributes = (s.attributes ?? []).map(
+        (w, U) => n(w, U, N)
+      ), N;
+    }
+    return (s, h) => (A(!0), R(te, null, pe(l.value, (g) => (A(), D(Oe, {
+      key: g.name,
+      template: o.value,
+      "field-metadata": g
+    }, null, 8, ["template", "field-metadata"]))), 128));
+  }
+}), Jt = /-\w/g, Rt = Ht(
+  (e) => e.replace(Jt, (a) => a.slice(1).toUpperCase())
+);
+function Ht(e) {
+  const a = /* @__PURE__ */ Object.create(null);
+  return ((t) => a[t] || (a[t] = e(t)));
+}
+const Yt = /* @__PURE__ */ Ae({
+  name: "DynamicFormTemplate",
+  inheritAttrs: !1,
+  __name: "DynamicFormTemplate",
+  props: {
+    metadataConfiguration: {}
+  },
+  setup(e) {
+    const a = St(), t = Ut(), l = u(() => {
+      const n = {};
+      for (const [s, h] of Object.entries(t))
+        n[Rt(s)] = h;
+      return n;
+    }), o = u(() => {
+      const n = l.value.type;
+      if (n && a[n])
+        return n;
+      if (n?.endsWith("-input"))
+        return a["default-input"] ? "default-input" : "default";
+      if (n?.endsWith("-choice-array-item")) {
+        if (a["default-choice-array-item"])
+          return "default-choice-array-item";
+        const s = `${n.slice(0, -18)}-array-item`;
+        return a[s] ? s : a["default-array-item"] ? "default-array-item" : "default";
+      }
+      if (n?.endsWith("-choice-array")) {
+        if (a["default-choice-array"])
+          return "default-choice-array";
+        const s = `${n.slice(0, -13)}-choice`;
+        return a[s] ? s : a["default-choice"] ? "default-choice" : "default";
+      }
+      return n?.endsWith("-array") ? a["default-array"] ? "default-array" : "default" : n?.endsWith("-array-item") ? a["default-array-item"] ? "default-array-item" : "default" : n?.endsWith("-choice") ? a["default-choice"] ? "default-choice" : "default" : n?.endsWith("-wizard-page") ? a["default-wizard-page"] ? "default-wizard-page" : "default" : n?.endsWith("-wizard") && a["default-wizard"] ? "default-wizard" : "default";
+    });
+    return (n, s) => l.value.fieldMetadata ? (A(), R(te, { key: 0 }, [
+      l.value.type?.endsWith("-choice-array") ? xe(n.$slots, o.value, ge(oe({ key: 0 }, l.value))) : l.value.type?.endsWith("-array") ? xe(n.$slots, o.value, ge(oe({ key: 1 }, l.value))) : l.value.type?.endsWith("-choice") ? xe(n.$slots, o.value, ge(oe({ key: 2 }, l.value))) : l.value.type?.endsWith("-wizard-page") ? xe(n.$slots, o.value, ge(oe({ key: 3 }, l.value))) : l.value.type?.endsWith("-wizard") ? xe(n.$slots, o.value, ge(oe({ key: 4 }, l.value))) : xe(n.$slots, o.value, ge(oe({ key: 5 }, l.value)))
+    ], 64)) : be("", !0);
+  }
+});
+function Zt() {
+  return {
+    fieldTypes: Object.keys({}),
+    extendedProperties: {},
+    slotProperties: {},
+    extendedSettingsProperties: {},
+    valueTypes: {}
+  };
+}
+function er(e) {
+  const a = (o) => lt(o), t = Et(e), { validateSection: l } = pt();
+  return {
+    ...t,
+    useFieldValue: a,
+    validateSection: l
+  };
+}
+function Ye(e, a) {
+  return !e || !a || (e = a?.({ ...e }), e.children = e?.children?.map((t) => Ye(t, a)), e.choice = e?.choice?.map((t) => Ye(t, a))), e;
+}
+export {
+  Qt as _,
+  Oe as a,
+  Dt as b,
+  Nt as c,
+  _t as d,
+  Yt as e,
+  Zt as f,
+  pt as g,
+  Se as h,
+  ee as i,
+  Ye as m,
+  er as u
+};
+//# sourceMappingURL=mapEachMetadataItem-Dvf3R5jd.js.map