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

package/dist/mapEachMetadataItem-DxEO1PDs.js

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