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

package/dist/mapEachMetadataItem-CZmoxEoA.js

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