@golemui/gui-shared 0.0.2 → 0.12.0

package/index.js

@@ -1,179 +1,2438 @@
-class a {
-  create(e) {
+const h = {
+  INPUTS: "INPUTS",
+  ACTIONS: "ACTIONS",
+  LAYOUTS: "LAYOUTS",
+  DISPLAYS: "DISPLAYS"
+};
+function se(e, t, n) {
+  if (typeof t == "function") {
+    const i = t;
+    return {
+      items: [{ key: e, def: (l) => ({ type: "text", ...i(l) }) }],
+      type: "ITEMS",
+      itemType: h.INPUTS,
+      tags: n ?? []
+    };
+  }
+  const s = { type: "text", ...t };
+  return {
+    items: [{ key: e, def: s }],
+    type: "ITEMS",
+    itemType: h.INPUTS,
+    tags: n ?? []
+  };
+}
+function ie(e, t, n) {
+  if (typeof t == "function") {
+    const i = t;
+    return {
+      items: [{ key: e, def: (l) => ({ type: "number", ...i(l) }) }],
+      type: "ITEMS",
+      itemType: h.INPUTS,
+      tags: n ?? []
+    };
+  }
+  const s = { type: "number", ...t };
+  return {
+    items: [{ key: e, def: s }],
+    type: "ITEMS",
+    itemType: h.INPUTS,
+    tags: n ?? []
+  };
+}
+function re(e, t, n) {
+  if (typeof t == "function") {
+    const i = t;
+    return {
+      items: [{ key: e, def: (l) => ({ type: "boolean", ...i(l) }) }],
+      type: "ITEMS",
+      itemType: h.INPUTS,
+      tags: n ?? []
+    };
+  }
+  const s = { type: "boolean", ...t };
+  return {
+    items: [{ key: e, def: s }],
+    type: "ITEMS",
+    itemType: h.INPUTS,
+    tags: n ?? []
+  };
+}
+function le(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "SELECT", items: [{ key: e, def: (a) => ({ type: "select", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "select", ...t };
+  return { type: "ITEMS", itemType: "SELECT", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function ae(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "DROPDOWN", items: [{ key: e, def: (a) => ({
+      type: "dropdown",
+      ...r(a)
+    }) }], tags: n ?? [] };
+  }
+  const s = { type: "dropdown", ...t };
+  return { type: "ITEMS", itemType: "DROPDOWN", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function oe(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "RADIOGROUP", items: [{ key: e, def: (a) => ({ type: "radiogroup", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "radiogroup", ...t };
+  return { type: "ITEMS", itemType: "RADIOGROUP", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function ue(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "CHECKBOX", items: [{ key: e, def: (a) => ({ type: "checkbox", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "checkbox", ...t };
+  return { type: "ITEMS", itemType: "CHECKBOX", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function ce(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "TEXTAREA", items: [{ key: e, def: (a) => ({ type: "textarea", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "textarea", ...t };
+  return { type: "ITEMS", itemType: "TEXTAREA", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function pe(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "PASSWORD", items: [{ key: e, def: (a) => ({ type: "password", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "password", ...t };
+  return { type: "ITEMS", itemType: "PASSWORD", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function de(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "CURRENCY", items: [{ key: e, def: (a) => ({ type: "currency", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "currency", ...t };
+  return { type: "ITEMS", itemType: "CURRENCY", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function ye(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "MARKDOWN", items: [{ key: e, def: (a) => ({ type: "markdown", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "markdown", ...t };
+  return { type: "ITEMS", itemType: "MARKDOWN", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function me(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "LIST", items: [{ key: e, def: (a) => ({ type: "list", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "list", ...t };
+  return { type: "ITEMS", itemType: "LIST", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function ge(e, t, n) {
+  if (typeof t == "function") {
+    const i = t;
+    return {
+      items: [(l) => ({
+        type: "calendar",
+        path: e,
+        ...i(l)
+      })],
+      type: "ITEMS",
+      itemType: "CALENDAR",
+      tags: n ?? []
+    };
+  }
+  return {
+    items: [{ type: "calendar", path: e, ...t }],
+    type: "ITEMS",
+    itemType: "CALENDAR",
+    tags: n ?? []
+  };
+}
+function be(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "DATE_INPUT", items: [{ key: e, def: (a) => ({ type: "dateInput", ...r(a) }) }], tags: n ?? [] };
+  }
+  const s = { type: "dateInput", ...t };
+  return { type: "ITEMS", itemType: "DATE_INPUT", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function fe(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "DATE_PICKER", items: [{ key: e, def: (a) => ({
+      type: "datePicker",
+      ...r(a)
+    }) }], tags: n ?? [] };
+  }
+  const s = { type: "datePicker", ...t };
+  return { type: "ITEMS", itemType: "DATE_PICKER", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function he(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "RANGE_CALENDAR", items: [{ key: e, def: (a) => ({
+      type: "rangeCalendar",
+      ...r(a)
+    }) }], tags: n ?? [] };
+  }
+  const s = { type: "rangeCalendar", ...t };
+  return { type: "ITEMS", itemType: "RANGE_CALENDAR", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function Te(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "RANGE_DATE_INPUT", items: [{ key: e, def: (a) => ({
+      type: "rangeDateInput",
+      ...r(a)
+    }) }], tags: n ?? [] };
+  }
+  const s = { type: "rangeDateInput", ...t };
+  return { type: "ITEMS", itemType: "RANGE_DATE_INPUT", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function Se(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "RANGE_DATE_PICKER", items: [{ key: e, def: (a) => ({
+      type: "rangeDatePicker",
+      ...r(a)
+    }) }], tags: n ?? [] };
+  }
+  const s = { type: "rangeDatePicker", ...t };
+  return { type: "ITEMS", itemType: "RANGE_DATE_PICKER", items: [{ key: e, def: s }], tags: n ?? [] };
+}
+function Ae(e, t, n, s) {
+  if (typeof n == "function") {
+    const l = n;
+    return { type: "ITEMS", itemType: "CUSTOM_INPUT", items: [{ key: t, def: (u) => ({
+      customType: e,
+      ...l(u)
+    }) }], tags: s ?? [] };
+  }
+  const i = { customType: e, ...n };
+  return { type: "ITEMS", itemType: "CUSTOM_INPUT", items: [{ key: t, def: i }], tags: s ?? [] };
+}
+class ke {
+  /**
+   * Deep merges two objects, with right taking precedence over left when properties conflict.
+   * Arrays are replaced, not merged.
+   * @param left - The base object
+   * @param right - The object whose properties take precedence
+   * @returns A new merged object
+   */
+  deepMerge(t, n) {
+    if (n == null)
+      return t;
+    if (t == null || typeof t != "object" || typeof n != "object" || Array.isArray(t) || Array.isArray(n))
+      return n;
+    const s = { ...t };
+    for (const i in n)
+      Object.prototype.hasOwnProperty.call(n, i) && (typeof n[i] == "object" && !Array.isArray(n[i]) && n[i] !== null && typeof t[i] == "object" && !Array.isArray(t[i]) && t[i] !== null ? s[i] = this.deepMerge(t[i], n[i]) : s[i] = n[i]);
+    return s;
+  }
+}
+const G = new ke();
+function K(e, t) {
+  return {
+    items: [e],
+    type: "ITEMS",
+    itemType: h.ACTIONS,
+    tags: t ?? []
+  };
+}
+const V = (e) => {
+  const t = {
+    uid: "#submit",
+    label: "Submit"
+  }, n = e != null ? G.deepMerge(t, e) : t;
+  return K(n);
+};
+function _e(e, t, n) {
+  if (typeof t == "function") {
+    const r = t;
+    return { type: "ITEMS", itemType: "CUSTOM_ACTION", items: [
+      (o) => ({ customType: e, ...r(o) })
+    ], tags: n ?? [] };
+  }
+  return { type: "ITEMS", itemType: "CUSTOM_ACTION", items: [{ customType: e, ...t }], tags: n ?? [] };
+}
+const H = (e, t) => ({
+  type: "ITEMS",
+  itemType: h.DISPLAYS,
+  items: [{ render: e }],
+  tags: t ?? []
+});
+function Ie(e, t) {
+  return { type: "ITEMS", itemType: "ALERTS", items: [e], tags: t ?? [] };
+}
+function Ee(e, t, n) {
+  if (typeof t == "function") {
+    const o = t;
+    return { type: "ITEMS", itemType: "CUSTOM_DISPLAY", items: [
+      (u) => ({ customType: e, ...o(u) })
+    ], tags: n ?? [] };
+  }
+  const { uid: s, ...i } = t ?? {};
+  return { type: "ITEMS", itemType: "CUSTOM_DISPLAY", items: [{
+    customType: e,
+    ...s != null ? { uid: s } : {},
+    props: Object.keys(i).length > 0 ? i : void 0
+  }], tags: n ?? [] };
+}
+const L = (e, t, n) => ({
+  type: "ITEMS",
+  itemType: h.LAYOUTS,
+  items: [{ def: { widgetName: "flex", ...t ?? {} }, children: e }],
+  tags: n ?? []
+}), Ue = (e, t, n) => L(e, { direction: "row", ...t ?? {} }, n), De = (e, t, n) => L(e, { direction: "column", ...t ?? {} }, n), B = (e, t, n) => ({
+  type: "ITEMS",
+  itemType: h.LAYOUTS,
+  items: [
+    {
+      def: {
+        widgetName: "grid",
+        direction: "row",
+        autoFit: !0,
+        ...t ?? {}
+      },
+      children: e
+    }
+  ],
+  tags: n ?? []
+}), Pe = (e, t, n) => B(e, { direction: "row", ...t ?? {} }, n), Ce = (e, t, n) => B(e, { direction: "column", ...t ?? {} }, n);
+function x(e) {
+  return e.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function ve(e, t, n) {
+  const s = e.map((l) => ({
+    label: l.label,
+    uid: l.uid ?? x(l.label)
+  })), i = e.map((l) => ({
+    type: "ITEMS",
+    itemType: h.LAYOUTS,
+    items: [
+      {
+        def: { uid: l.uid ?? x(l.label), direction: "column", widgetName: "flex" },
+        children: l.children
+      }
+    ],
+    tags: []
+  }));
+  return {
+    type: "ITEMS",
+    itemType: "TABS",
+    items: [{ def: {
+      tabs: s,
+      ...t
+    }, children: i }],
+    tags: n ?? []
+  };
+}
+function F(e) {
+  return e.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function we(e, t, n) {
+  const s = e.map((l) => ({
+    label: l.label,
+    uid: l.uid ?? F(l.label)
+  })), i = e.map((l) => ({
+    type: "ITEMS",
+    itemType: h.LAYOUTS,
+    items: [
+      {
+        def: { uid: l.uid ?? F(l.label), direction: "column", widgetName: "flex" },
+        children: l.children
+      }
+    ],
+    tags: []
+  }));
+  return {
+    type: "ITEMS",
+    itemType: "ACCORDION",
+    items: [{ def: {
+      sections: s,
+      ...t
+    }, children: i }],
+    tags: n ?? []
+  };
+}
+function Me(e, t, n, s) {
+  if (typeof n == "function") {
+    const l = n;
+    return { type: "ITEMS", itemType: "CUSTOM_LAYOUT", items: [{ def: (u) => ({
+      customType: e,
+      ...l(u)
+    }), children: t }], tags: s ?? [] };
+  }
+  return { type: "ITEMS", itemType: "CUSTOM_LAYOUT", items: [{ def: { customType: e, ...n }, children: t }], tags: s ?? [] };
+}
+function Le(e, t, n) {
+  const { template: s, ...i } = t;
+  return {
+    type: "ITEMS",
+    itemType: "REPEATER",
+    items: [{ key: e, def: i, children: s }],
+    tags: n ?? []
+  };
+}
+function X(e) {
+  return function(t, n = () => !0) {
+    return {
+      kind: "leaf",
+      selectorType: e,
+      matcher: n,
+      config: t
+    };
+  };
+}
+const D = /* @__PURE__ */ new Map();
+function Z(e, t) {
+  if (D.has(e))
+    throw new Error(`Item type "${e}" is already registered.`);
+  D.set(e, t);
+}
+function I(e) {
+  const t = D.get(e);
+  if (!t)
+    throw new Error(
+      `No handler registered for item type "${e}". Did you forget to import the registration module?`
+    );
+  return t;
+}
+function q(e) {
+  return D.has(e);
+}
+function p(e) {
+  const t = (o) => {
+    if (!e.sensibleDefaults)
+      return {};
+    let a = { ...e.sensibleDefaults.base };
+    for (const u of o) {
+      const c = u.config;
+      for (const y of e.sensibleDefaults.fields) {
+        const d = y;
+        c[d] != null && (a = { ...a, [d]: c[d] });
+      }
+    }
+    return a;
+  }, n = (o, a) => e.sensibleDefaults ? e.sensibleDefaults.apply(o, a) : o, s = (o) => {
+    switch (e.entryShape) {
+      case "bare":
+        return { baseDef: o };
+      case "keyed": {
+        const a = o;
+        return { baseDef: a.def, path: a.key };
+      }
+      case "compound": {
+        const a = o;
+        return { baseDef: a.def, children: a.children };
+      }
+    }
+  }, i = {
+    rollUpSensibleDefaults: t,
+    applySensibleDefaults: n,
+    mapToWidget: e.mapToWidget,
+    parseEntry: s,
+    ...e.afterMerge ? { afterMerge: e.afterMerge } : {},
+    ...e.buildCustomWidget ? { buildCustomWidget: e.buildCustomWidget } : {},
+    ...e.getChildren ? { getChildren: e.getChildren } : {}
+  };
+  Z(e.itemType, i);
+  const r = X(e.itemType);
+  return { gsl: r, gslByUid: (o, a) => r(a, ((u) => u.uid === o)) };
+}
+function m(e) {
+  const {
+    uid: t,
+    path: n,
+    label: s,
+    disabled: i,
+    readonly: r,
+    defaultValue: l,
+    tags: o,
+    type: a,
+    size: u,
+    onLoad: c,
+    onChange: y,
+    onFilter: d,
+    on: T,
+    states: E,
+    include: U,
+    exclude: R,
+    validator: N,
+    ...k
+  } = e;
+  return k;
+}
+function f(e, t) {
+  return typeof e == "function" ? e : { type: t, ...e ?? {} };
+}
+function Be(e) {
+  return e ? e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (t) => t.toUpperCase()) : "";
+}
+function g(e, t) {
+  return e.label != null || t.suppressAutomaticLabels || !e.path ? e : { ...e, label: Be(e.path) };
+}
+function A(e, t) {
+  return e.placeholder != null || t.suppressAutomaticPlaceholders || !e.path ? e : { ...e, placeholder: e.path };
+}
+function Oe(e) {
+  switch (e.type) {
+    case "text":
+      return Ne(e);
+    case "number":
+      return We(e);
+    case "boolean":
+      return Re(e);
+    default:
+      throw new Error(`Unsupported field type "${e.type}"`);
+  }
+}
+function Re(e) {
+  const t = m(e);
+  return {
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "toggle",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "boolean") } : {},
+    props: t
+  };
+}
+function Ne(e) {
+  const t = m(e);
+  return {
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "textinput",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    props: {
+      placeholder: t.placeholder ?? "",
+      ...t
+    },
+    validator: f(e.validator, "string")
+  };
+}
+function We(e) {
+  const t = m(e);
+  return {
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "number",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    props: {
+      placeholder: t.placeholder ?? "",
+      ...t
+    },
+    validator: f(e.validator, "number")
+  };
+}
+const { gsl: P, gslByUid: xe } = p({
+  itemType: "INPUTS",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: {
+      suppressAutomaticLabels: !1,
+      suppressAutomaticPlaceholders: !1
+    },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => {
+      let n = g(e, t);
+      return n = A(n, t), n;
+    }
+  },
+  mapToWidget: Oe
+}), Fe = (e) => P(e, (t) => t.type === "text"), $e = (e) => P(e, (t) => t.type === "number"), je = (e) => P(e, (t) => t.type === "boolean"), { gsl: Ye, gslByUid: ze } = p({
+  itemType: "SELECT",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1, suppressAutomaticPlaceholders: !1 },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "select",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: e.validator } : {},
+    props: m(e)
+  })
+}), { gsl: Ge, gslByUid: Ke } = p({
+  itemType: "DROPDOWN",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: {
+      suppressAutomaticLabels: !1,
+      suppressAutomaticPlaceholders: !1
+    },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "dropdown",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: e.validator } : {},
+    props: m(e)
+  })
+}), { gsl: Ve, gslByUid: He } = p({
+  itemType: "RADIOGROUP",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "radiogroup",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: e.validator } : {},
+    props: m(e)
+  })
+}), { gsl: Xe, gslByUid: Ze } = p({
+  itemType: "CHECKBOX",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "checkbox",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "boolean") } : {},
+    props: m(e)
+  })
+}), { gsl: qe, gslByUid: Qe } = p({
+  itemType: "TEXTAREA",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1, suppressAutomaticPlaceholders: !1 },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "textarea",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: Je, gslByUid: et } = p({
+  itemType: "PASSWORD",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1, suppressAutomaticPlaceholders: !1 },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "password",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: tt, gslByUid: nt } = p({
+  itemType: "CURRENCY",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1, suppressAutomaticPlaceholders: !1 },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "currency",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "number") } : {},
+    props: m(e)
+  })
+}), { gsl: st, gslByUid: it } = p({
+  itemType: "MARKDOWN",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1, suppressAutomaticPlaceholders: !1 },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "markdown",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: rt, gslByUid: lt } = p({
+  itemType: "LIST",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "list",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: e.validator } : {},
+    props: m(e)
+  })
+}), { gsl: at, gslByUid: ot } = p({
+  itemType: "CALENDAR",
+  entryShape: "bare",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "calendar",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: ut, gslByUid: ct } = p({
+  itemType: "DATE_INPUT",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "dateInput",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: pt, gslByUid: dt } = p({
+  itemType: "DATE_PICKER",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: {
+      suppressAutomaticLabels: !1,
+      suppressAutomaticPlaceholders: !1
+    },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "datePicker",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "string") } : {},
+    props: m(e)
+  })
+}), { gsl: yt, gslByUid: mt } = p({
+  itemType: "RANGE_CALENDAR",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "rangeCalendar",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "array") } : {},
+    props: m(e)
+  })
+}), { gsl: gt, gslByUid: bt } = p({
+  itemType: "RANGE_DATE_INPUT",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: { suppressAutomaticLabels: !1 },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "rangeDateInput",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "array") } : {},
+    props: m(e)
+  })
+}), { gsl: ft, gslByUid: ht } = p({
+  itemType: "RANGE_DATE_PICKER",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: {
+      suppressAutomaticLabels: !1,
+      suppressAutomaticPlaceholders: !1
+    },
+    fields: ["suppressAutomaticLabels", "suppressAutomaticPlaceholders"],
+    apply: (e, t) => A(g(e, t), t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "rangeDatePicker",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "array") } : {},
+    props: m(e)
+  })
+});
+function Tt(e) {
+  const t = {};
+  return e.addLabel != null && (t.addLabel = e.addLabel), e.removeLabel != null && (t.removeLabel = e.removeLabel), e.limit != null && (t.limit = e.limit), e.title != null && (t.title = e.title), e.addButtonIcon != null && (t.addButtonIcon = e.addButtonIcon), e.removeButtonIcon != null && (t.removeButtonIcon = e.removeButtonIcon), t;
+}
+function St(e) {
+  return {
+    uid: e.uid ?? "",
+    kind: "input",
+    type: "repeater",
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.validator != null ? { validator: f(e.validator, "array") } : {},
+    props: {
+      ...Tt(e),
+      template: { kind: "layout", type: "flex", children: [], props: { direction: "column" } }
+    }
+  };
+}
+function M(e, t) {
+  for (const n of e) {
+    if (typeof n == "function") continue;
+    const s = n;
+    typeof s.path == "string" && s.path && (s.path = t + s.path), "children" in s && Array.isArray(s.children) && M(s.children, t);
+    const i = s.props;
+    i?.template?.children && Array.isArray(i.template.children) && M(i.template.children, t);
+  }
+}
+function At(e, t) {
+  const n = t.walkChildren(t.children ?? []), s = e.kind === "static" ? e.def.path ?? "" : e.fn({})?.path ?? "";
+  s && M(n, s + ".items.");
+  const i = {
+    kind: "layout",
+    type: "flex",
+    uid: "",
+    children: n,
+    props: { direction: "column" }
+  };
+  if (e.kind === "static") {
+    const l = t.mapStaticDef(e.def, "REPEATER");
+    return {
+      ...l,
+      props: { ...l.props, template: i }
+    };
+  }
+  const r = e.fn;
+  return ((l) => {
+    const o = r(l), a = t.mapStaticDef(o, "REPEATER");
     return {
-      states: e.states,
+      ...a,
+      props: { ...a.props, template: i }
+    };
+  });
+}
+function kt(e) {
+  return {
+    baseDef: e.def,
+    path: e.key,
+    children: e.children
+  };
+}
+function _t(e) {
+  return e.children;
+}
+const It = {
+  parseEntry: kt,
+  rollUpSensibleDefaults: () => ({}),
+  applySensibleDefaults: (e) => e,
+  mapToWidget: St,
+  buildCustomWidget: At,
+  getChildren: _t
+};
+Z("REPEATER", It);
+const Q = X("REPEATER"), Et = (e, t) => Q(t, ((n) => n.uid === e)), J = {
+  onLoad: "load",
+  onChange: "change",
+  onFilter: "filter",
+  onBlur: "blur"
+}, Ut = Object.keys(J);
+class Dt {
+  // ── Action-specific: onClick + submit ─────────────────────────
+  extractOnClickFromMergeResult(t, n, s, i) {
+    if (t.kind === "dynamic") {
+      const o = t.fn;
+      return { kind: "dynamic", fn: (u) => {
+        const c = o(u);
+        return this.wireOnClick(c, n, s, i);
+      } };
+    }
+    const r = t.def;
+    return { kind: "static", def: this.wireOnClick(r, n, s, i) };
+  }
+  countSubmitButtons(t) {
+    let n = 0;
+    for (const s of t) {
+      if (s.type !== "ITEMS") continue;
+      const i = I(s.itemType);
+      for (const r of s.items) {
+        const l = i.getChildren?.(r);
+        if (l && (n += this.countSubmitButtons(l)), s.itemType === h.ACTIONS) {
+          if (typeof r == "function") continue;
+          const o = r;
+          (o.uid === "#submit" || o.onClick === "submit") && n++;
+        }
+      }
+    }
+    return n;
+  }
+  wireOnClick(t, n, s, i) {
+    const r = t.uid === "#submit" || t.onClick === "submit", l = r ? "#submit" : i.next(), o = r ? "submit" : l, a = t.onClick, c = (typeof a == "function" ? a : void 0) ?? (r ? s.onSubmit : void 0);
+    if (c) {
+      n.set(o, (T) => c(T.data));
+      const { onClick: y, ...d } = t;
+      return { ...d, uid: l, on: { click: o } };
+    }
+    if (r) {
+      const { onClick: y, ...d } = t;
+      return { ...d, uid: l, on: { click: "submit" } };
+    }
+    if (typeof a == "string") {
+      const { onClick: y, ...d } = t;
+      return { ...d, uid: l, on: { click: a } };
+    }
+    return { ...t, uid: l };
+  }
+  // ── Universal: onLoad, onChange, onFilter ──────────────────────
+  wireInputLayoutEvents(t, n, s) {
+    if (t.kind === "dynamic") {
+      const r = t.fn;
+      return { kind: "dynamic", fn: (o) => {
+        const a = r(o);
+        return this.wireEventProperties(a, n, s);
+      } };
+    }
+    return { kind: "static", def: this.wireEventProperties(t.def, n, s) };
+  }
+  wireEventProperties(t, n, s) {
+    const i = { ...t.on || {} };
+    let r = !1;
+    const l = { ...t };
+    for (const o of Ut) {
+      const a = t[o];
+      if (a == null) continue;
+      const u = J[o];
+      if (typeof a == "function") {
+        const c = s.next();
+        n.set(c, a), i[u] = c, r = !0;
+      } else typeof a == "string" && (i[u] = a, r = !0);
+      delete l[o];
+    }
+    return r && (l.on = i), l;
+  }
+}
+const C = new Dt();
+function Pt(e) {
+  const {
+    uid: t,
+    label: n,
+    disabled: s,
+    on: i,
+    onClick: r,
+    data: l,
+    type: o,
+    tags: a,
+    size: u,
+    include: c,
+    exclude: y,
+    states: d,
+    ...T
+  } = e;
+  return {
+    uid: t ?? "",
+    kind: "action",
+    type: "button",
+    disabled: s,
+    label: n,
+    ...i != null ? { on: i } : {},
+    props: T
+  };
+}
+const { gsl: Ct, gslByUid: vt } = p({
+  itemType: "ACTIONS",
+  entryShape: "bare",
+  mapToWidget: Pt,
+  afterMerge: (e, t) => C.extractOnClickFromMergeResult(
+    e,
+    t.eventRegistry,
+    t.formConfig,
+    t.eventIdGenerator
+  )
+});
+function wt(e) {
+  const {
+    uid: t,
+    widgetName: n,
+    tags: s,
+    size: i,
+    onChange: r,
+    include: l,
+    exclude: o,
+    ...a
+  } = e, { on: u, ...c } = a;
+  return {
+    uid: t ?? "",
+    kind: "layout",
+    type: n ?? "flex",
+    props: {
+      direction: c.direction ?? "column",
+      ...c
+    },
+    children: []
+  };
+}
+function Mt(e, t) {
+  const n = t.walkChildren(t.children ?? []);
+  if (e.kind === "static")
+    return { ...t.mapStaticDef(e.def, "LAYOUTS"), children: n };
+  const s = e.fn;
+  return ((i) => {
+    const r = s(i);
+    return { ...t.mapStaticDef(r, "LAYOUTS"), children: n };
+  });
+}
+function Lt(e) {
+  return e.children;
+}
+const { gsl: Bt, gslByUid: Ot } = p({
+  itemType: "LAYOUTS",
+  entryShape: "compound",
+  mapToWidget: wt,
+  buildCustomWidget: Mt,
+  getChildren: Lt
+});
+function Rt(e) {
+  return {
+    uid: "",
+    kind: "display",
+    type: "renderer",
+    props: { render: e.render }
+  };
+}
+function Nt(e, t) {
+  if (e.kind === "static") {
+    const s = e.def;
+    return ((i) => ({
+      uid: "",
+      kind: "display",
+      type: "renderer",
+      ...s.include != null ? { include: s.include } : {},
+      ...s.exclude != null ? { exclude: s.exclude } : {},
+      props: { render: s.render(i ?? {}) }
+    }));
+  }
+  const n = e.fn;
+  return ((s) => {
+    const i = n(s);
+    return {
+      uid: "",
+      kind: "display",
+      type: "renderer",
+      ...i.include != null ? { include: i.include } : {},
+      ...i.exclude != null ? { exclude: i.exclude } : {},
+      props: { render: i.render(s ?? {}) }
+    };
+  });
+}
+const { gsl: Wt, gslByUid: xt } = p({
+  itemType: "DISPLAYS",
+  entryShape: "bare",
+  mapToWidget: Rt,
+  buildCustomWidget: Nt
+}), { gsl: Ft, gslByUid: $t } = p({
+  itemType: "ALERTS",
+  entryShape: "bare",
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "display",
+    type: "alert",
+    props: {
+      text: e.text,
+      ...e.level != null ? { level: e.level } : {}
+    }
+  })
+});
+function jt(e) {
+  return {
+    uid: e.uid ?? "",
+    kind: "layout",
+    type: "tabs",
+    props: {
+      tabs: e.tabs,
+      renderMode: e.renderMode ?? "all",
+      ...e.defaultOpen != null ? { defaultOpen: e.defaultOpen } : {}
+    },
+    children: []
+  };
+}
+function Yt(e, t) {
+  const n = t.walkChildren(t.children ?? []);
+  if (e.kind === "static")
+    return { ...t.mapStaticDef(e.def, "TABS"), children: n };
+  const s = e.fn;
+  return ((i) => {
+    const r = s(i);
+    return { ...t.mapStaticDef(r, "TABS"), children: n };
+  });
+}
+function zt(e) {
+  return e.children;
+}
+const { gsl: Gt, gslByUid: Kt } = p({
+  itemType: "TABS",
+  entryShape: "compound",
+  mapToWidget: jt,
+  buildCustomWidget: Yt,
+  getChildren: zt
+});
+function Vt(e) {
+  return {
+    uid: e.uid ?? "",
+    kind: "layout",
+    type: "accordion",
+    props: {
+      sections: e.sections,
+      renderMode: e.renderMode ?? "all",
+      ...e.singleOpen != null ? { singleOpen: e.singleOpen } : {},
+      ...e.defaultOpen != null ? { defaultOpen: e.defaultOpen } : {}
+    },
+    children: []
+  };
+}
+function Ht(e, t) {
+  const n = t.walkChildren(t.children ?? []);
+  if (e.kind === "static")
+    return { ...t.mapStaticDef(e.def, "ACCORDION"), children: n };
+  const s = e.fn;
+  return ((i) => {
+    const r = s(i);
+    return { ...t.mapStaticDef(r, "ACCORDION"), children: n };
+  });
+}
+function Xt(e) {
+  return e.children;
+}
+const { gsl: Zt, gslByUid: qt } = p({
+  itemType: "ACCORDION",
+  entryShape: "compound",
+  mapToWidget: Vt,
+  buildCustomWidget: Ht,
+  getChildren: Xt
+}), { gsl: Qt, gslByUid: Jt } = p({
+  itemType: "CUSTOM_INPUT",
+  entryShape: "keyed",
+  sensibleDefaults: {
+    base: {
+      suppressAutomaticLabels: !1
+    },
+    fields: ["suppressAutomaticLabels"],
+    apply: (e, t) => g(e, t)
+  },
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "input",
+    type: e.customType,
+    path: e.path ?? "",
+    ...e.label != null ? { label: e.label } : {},
+    ...e.disabled != null ? { disabled: e.disabled } : {},
+    ...e.readonly != null ? { readonly: e.readonly } : {},
+    ...e.defaultValue != null ? { defaultValue: e.defaultValue } : {},
+    ...e.validator != null ? { validator: e.validator } : {},
+    props: e.props ?? {}
+  })
+}), { gsl: en, gslByUid: tn } = p({
+  itemType: "CUSTOM_ACTION",
+  entryShape: "bare",
+  mapToWidget: (e) => {
+    const {
+      uid: t,
+      label: n,
+      disabled: s,
+      on: i,
+      onClick: r,
+      data: l,
+      customType: o,
+      tags: a,
+      size: u,
+      include: c,
+      exclude: y,
+      states: d,
+      props: T,
+      ...E
+    } = e;
+    return {
+      uid: t ?? "",
+      kind: "action",
+      type: e.customType,
+      label: n,
+      disabled: s,
+      ...i != null ? { on: i } : {},
+      props: { ...T, ...E }
+    };
+  },
+  afterMerge: (e, t) => C.extractOnClickFromMergeResult(
+    e,
+    t.eventRegistry,
+    t.formConfig,
+    t.eventIdGenerator
+  )
+}), { gsl: nn, gslByUid: sn } = p({
+  itemType: "CUSTOM_DISPLAY",
+  entryShape: "bare",
+  mapToWidget: (e) => ({
+    uid: e.uid ?? "",
+    kind: "display",
+    type: e.customType,
+    props: e.props ?? {}
+  })
+});
+function rn(e) {
+  return {
+    uid: e.uid ?? "",
+    kind: "layout",
+    type: e.customType,
+    props: e.props ?? {},
+    children: []
+  };
+}
+function ln(e, t) {
+  const n = t.walkChildren(t.children ?? []);
+  if (e.kind === "static")
+    return { ...t.mapStaticDef(e.def, "CUSTOM_LAYOUT"), children: n };
+  const s = e.fn;
+  return ((i) => {
+    const r = s(i);
+    return { ...t.mapStaticDef(r, "CUSTOM_LAYOUT"), children: n };
+  });
+}
+function an(e) {
+  return e.children;
+}
+const { gsl: on, gslByUid: un } = p({
+  itemType: "CUSTOM_LAYOUT",
+  entryShape: "compound",
+  mapToWidget: rn,
+  buildCustomWidget: ln,
+  getChildren: an
+});
+class _ {
+  constructor(t) {
+    this.conditions = t;
+  }
+  static root() {
+    return new _([]);
+  }
+  // ─── Scope methods (chain-extending, immutable) ───
+  tag(t) {
+    return new _([...this.conditions, { kind: "tagsAnd", tags: [t] }]);
+  }
+  state(t) {
+    return new _([...this.conditions, { kind: "state", name: t }]);
+  }
+  tagsAnd(t) {
+    return new _([...this.conditions, { kind: "tagsAnd", tags: t }]);
+  }
+  tagsOr(t) {
+    return new _([...this.conditions, { kind: "tagsOr", tags: t }]);
+  }
+  apply(t) {
+    if (this.conditions.length === 0) return t;
+    const n = this.conditions.find(
+      (r) => r.kind === "state"
+    ), s = this.conditions.filter(
+      (r) => r.kind !== "state"
+    ), i = t.matcher;
+    return {
+      ...t,
+      matcher: (r) => {
+        if (!i(r)) return !1;
+        for (const l of s) {
+          const o = r.tags ?? [];
+          if (l.kind === "tagsAnd") {
+            for (const a of l.tags)
+              if (!o.includes(a)) return !1;
+          } else {
+            if (l.tags.length === 0) continue;
+            if (!l.tags.some((a) => o.includes(a))) return !1;
+          }
+        }
+        return !0;
+      },
+      ...n ? { targetState: n.name } : {}
+    };
+  }
+  // ─── Type selectors — inputs ───
+  inputs(t) {
+    return this.apply(P(t));
+  }
+  inputByUid(t, n) {
+    return this.apply(xe(t, n));
+  }
+  textInputs(t) {
+    return this.apply(Fe(t));
+  }
+  numberInputs(t) {
+    return this.apply($e(t));
+  }
+  booleanInputs(t) {
+    return this.apply(je(t));
+  }
+  selects(t) {
+    return this.apply(Ye(t));
+  }
+  selectByUid(t, n) {
+    return this.apply(ze(t, n));
+  }
+  dropdowns(t) {
+    return this.apply(Ge(t));
+  }
+  dropdownByUid(t, n) {
+    return this.apply(Ke(t, n));
+  }
+  radiogroups(t) {
+    return this.apply(Ve(t));
+  }
+  radiogroupByUid(t, n) {
+    return this.apply(He(t, n));
+  }
+  checkboxes(t) {
+    return this.apply(Xe(t));
+  }
+  checkboxByUid(t, n) {
+    return this.apply(Ze(t, n));
+  }
+  textareas(t) {
+    return this.apply(qe(t));
+  }
+  textareaByUid(t, n) {
+    return this.apply(Qe(t, n));
+  }
+  passwords(t) {
+    return this.apply(Je(t));
+  }
+  passwordByUid(t, n) {
+    return this.apply(et(t, n));
+  }
+  currencies(t) {
+    return this.apply(tt(t));
+  }
+  currencyByUid(t, n) {
+    return this.apply(nt(t, n));
+  }
+  markdowns(t) {
+    return this.apply(st(t));
+  }
+  markdownByUid(t, n) {
+    return this.apply(it(t, n));
+  }
+  lists(t) {
+    return this.apply(rt(t));
+  }
+  listByUid(t, n) {
+    return this.apply(lt(t, n));
+  }
+  calendars(t) {
+    return this.apply(at(t));
+  }
+  calendarByUid(t, n) {
+    return this.apply(ot(t, n));
+  }
+  dateInputs(t) {
+    return this.apply(ut(t));
+  }
+  dateInputByUid(t, n) {
+    return this.apply(ct(t, n));
+  }
+  datePickers(t) {
+    return this.apply(pt(t));
+  }
+  datePickerByUid(t, n) {
+    return this.apply(dt(t, n));
+  }
+  rangeCalendars(t) {
+    return this.apply(yt(t));
+  }
+  rangeCalendarByUid(t, n) {
+    return this.apply(mt(t, n));
+  }
+  rangeDateInputs(t) {
+    return this.apply(gt(t));
+  }
+  rangeDateInputByUid(t, n) {
+    return this.apply(bt(t, n));
+  }
+  rangeDatePickers(t) {
+    return this.apply(ft(t));
+  }
+  rangeDatePickerByUid(t, n) {
+    return this.apply(ht(t, n));
+  }
+  repeaters(t) {
+    return this.apply(Q(t));
+  }
+  repeaterByUid(t, n) {
+    return this.apply(Et(t, n));
+  }
+  // ─── Type selectors — actions, displays, layouts ───
+  actions(t) {
+    return this.apply(Ct(t));
+  }
+  actionByUid(t, n) {
+    return this.apply(vt(t, n));
+  }
+  layouts(t) {
+    return this.apply(Bt(t));
+  }
+  layoutByUid(t, n) {
+    return this.apply(Ot(t, n));
+  }
+  displays(t) {
+    return this.apply(Wt(t));
+  }
+  displayByUid(t, n) {
+    return this.apply(xt(t, n));
+  }
+  alerts(t) {
+    return this.apply(Ft(t));
+  }
+  alertByUid(t, n) {
+    return this.apply($t(t, n));
+  }
+  tabs(t) {
+    return this.apply(Gt(t));
+  }
+  tabsByUid(t, n) {
+    return this.apply(Kt(t, n));
+  }
+  accordions(t) {
+    return this.apply(Zt(t));
+  }
+  accordionByUid(t, n) {
+    return this.apply(qt(t, n));
+  }
+  // ─── Type selectors — custom kinds ───
+  customInputs(t) {
+    return this.apply(Qt(t));
+  }
+  customInputByUid(t, n) {
+    return this.apply(Jt(t, n));
+  }
+  customActions(t) {
+    return this.apply(en(t));
+  }
+  customActionByUid(t, n) {
+    return this.apply(tn(t, n));
+  }
+  customDisplays(t) {
+    return this.apply(nn(t));
+  }
+  customDisplayByUid(t, n) {
+    return this.apply(sn(t, n));
+  }
+  customLayouts(t) {
+    return this.apply(on(t));
+  }
+  customLayoutByUid(t, n) {
+    return this.apply(un(t, n));
+  }
+}
+const Rn = {
+  inputs: {
+    textInput: se,
+    numberInput: ie,
+    booleanInput: re,
+    select: le,
+    dropdown: ae,
+    radiogroup: oe,
+    checkbox: ue,
+    textarea: ce,
+    password: pe,
+    currency: de,
+    markdown: ye,
+    list: me,
+    calendar: ge,
+    dateInput: be,
+    datePicker: fe,
+    rangeCalendar: he,
+    rangeDateInput: Te,
+    rangeDatePicker: Se,
+    repeater: Le,
+    custom: Ae
+  },
+  actions: {
+    button: K,
+    submitButton: V,
+    custom: _e
+  },
+  displays: {
+    display: H,
+    alert: Ie,
+    custom: Ee
+  },
+  layouts: {
+    flex: L,
+    horizontalFlex: Ue,
+    verticalFlex: De,
+    grid: B,
+    horizontalGrid: Pe,
+    verticalGrid: Ce,
+    tabs: ve,
+    accordion: we,
+    custom: Me
+  },
+  selectors: _.root()
+};
+function Nn(e, ...t) {
+  return t.map((n) => ({
+    ...n,
+    targetState: e
+  }));
+}
+function Wn(e, ...t) {
+  return {
+    kind: "aggregated",
+    matcher: (n) => n.tags?.includes(e) ?? !1,
+    children: t
+  };
+}
+const ee = {
+  INPUTS: /* @__PURE__ */ new Set([
+    "INPUTS",
+    "TEXTAREA",
+    "PASSWORD",
+    "SELECT",
+    "DROPDOWN",
+    "RADIOGROUP",
+    "CHECKBOX",
+    "CALENDAR",
+    "DATE_INPUT",
+    "DATE_PICKER",
+    "RANGE_CALENDAR",
+    "RANGE_DATE_INPUT",
+    "RANGE_DATE_PICKER",
+    "CURRENCY",
+    "MARKDOWN",
+    "LIST",
+    "CUSTOM_INPUT",
+    "REPEATER"
+  ]),
+  ACTIONS: /* @__PURE__ */ new Set(["ACTIONS", "CUSTOM_ACTION"]),
+  DISPLAYS: /* @__PURE__ */ new Set(["DISPLAYS", "ALERTS", "CUSTOM_DISPLAY"]),
+  LAYOUTS: /* @__PURE__ */ new Set(["LAYOUTS", "TABS", "ACCORDION", "CUSTOM_LAYOUT"])
+};
+function cn(e, t) {
+  const n = ee[e];
+  return n ? n.has(t) : e === t;
+}
+class pn {
+  resolve(t, n) {
+    const s = [];
+    for (const r of n)
+      r.kind === "aggregated" ? this.collectFromAggregated(r, t, s) : this.collectFromLeaf(r, t, s);
+    const i = this.rollUpSensibleDefaults(s);
+    return {
+      leafSelectors: s,
+      sensibleDefaults: i
+    };
+  }
+  collectFromAggregated(t, n, s) {
+    if (t.matcher(n))
+      for (const i of t.children)
+        this.collectFromLeaf(i, n, s);
+  }
+  collectFromLeaf(t, n, s) {
+    cn(t.selectorType, n.itemType ?? "") && t.matcher(n) && s.push(t);
+  }
+  rollUpSensibleDefaults(t) {
+    const n = /* @__PURE__ */ new Map(), s = (r, l) => {
+      const o = n.get(r) ?? [];
+      o.push(l), n.set(r, o);
+    };
+    for (const r of t) {
+      const l = ee[r.selectorType];
+      if (l)
+        for (const o of l) s(o, r);
+      else
+        s(r.selectorType, r);
+    }
+    const i = {};
+    for (const [r, l] of n)
+      q(r) && (i[r] = I(r).rollUpSensibleDefaults(l));
+    return i;
+  }
+}
+const dn = new pn();
+class yn {
+  constructor(t) {
+    this.objectUtils = t;
+  }
+  merge(t, n, s) {
+    let i = {}, r = null;
+    typeof t == "function" && (r = t);
+    const l = this.collectDecorators(s);
+    for (const u of l) {
+      if (r != null) {
+        r = this.composeRuntimeFunctions(r, u);
+        continue;
+      }
+      if (typeof u == "function") {
+        const c = u({
+          ...i,
+          ...typeof t == "function" ? {} : t
+        });
+        if (typeof c == "function") {
+          r = this.createPromotedFunction(
+            i,
+            t,
+            c,
+            n,
+            s
+          );
+          continue;
+        }
+        i = this.objectUtils.deepMerge(i, c);
+      } else
+        i = this.objectUtils.deepMerge(i, u);
+    }
+    if (r != null)
+      return {
+        kind: "dynamic",
+        fn: this.wrapWithSensibleDefaults(r, i, n, s)
+      };
+    const o = this.objectUtils.deepMerge(t, i);
+    return { kind: "static", def: this.applySensibleDefaults({ ...o }, n, s) };
+  }
+  // ── Collect all decorators in priority order ──
+  collectDecorators(t) {
+    const n = [];
+    for (const s of t.leafSelectors) {
+      const i = s.config;
+      i.override != null && n.push(i.override);
+    }
+    return n;
+  }
+  // ── Apply sensible defaults via registry ──
+  applySensibleDefaults(t, n, s) {
+    if (!q(n)) return t;
+    const i = s.sensibleDefaults[n] ?? {};
+    return I(n).applySensibleDefaults(t, i);
+  }
+  // ── Create promoted FunctionWidget ──
+  createPromotedFunction(t, n, s, i, r) {
+    return (l) => {
+      const o = s(l);
+      let a = this.objectUtils.deepMerge(t, o);
+      return a = this.objectUtils.deepMerge(a, n), this.applySensibleDefaults(a, i, r);
+    };
+  }
+  // ── Wrap runtime function with accumulated static decorators and sensible defaults ──
+  wrapWithSensibleDefaults(t, n, s, i) {
+    return (r) => {
+      let l = t(r);
+      return Object.keys(n).length > 0 && (l = this.objectUtils.deepMerge(n, l)), this.applySensibleDefaults(l, s, i);
+    };
+  }
+  // ── Compose two runtime functions ──
+  composeRuntimeFunctions(t, n) {
+    return typeof n == "function" ? (s) => {
+      const i = t(s), r = n(i);
+      return typeof r == "function" ? r(s) : this.objectUtils.deepMerge(r, i);
+    } : (s) => {
+      const i = t(s);
+      return this.objectUtils.deepMerge(i, n);
+    };
+  }
+}
+const mn = new yn(G);
+class gn {
+  mapToWidget(t, n) {
+    if (t.kind === "dynamic") {
+      const s = t.fn;
+      return ((i) => {
+        const r = s(i);
+        return this.mapStaticDef(r, n);
+      });
+    }
+    return this.mapStaticDef(t.def, n);
+  }
+  mapStaticDef(t, n) {
+    const s = I(n).mapToWidget(t);
+    return this.applyBaseWidgetFields(s, t);
+  }
+  /**
+   * Injects BaseWidget-level fields that all widget types share.
+   * Centralized here so individual mappers don't need to repeat the pattern.
+   */
+  applyBaseWidgetFields(t, n) {
+    return n.size != null && (t.size = n.size), n.defaultValue != null && t.kind === "input" && (t.defaultValue = n.defaultValue), n.on != null && (t.on = n.on), n.include != null && (t.include = n.include), n.exclude != null && (t.exclude = n.exclude), t;
+  }
+}
+const bn = new gn();
+class fn {
+  /**
+   * Ensures the output is always a uniform GslSelector[] of aggregated selectors.
+   *
+   * Callers can pass flat leaf selectors (single styling rules) or pre-grouped
+   * aggregated selectors. This method separates them into two buckets, then wraps
+   * any bare leaves into a catch-all aggregated selector so downstream code only
+   * deals with one shape.
+   */
+  normalizeSelectors(t) {
+    const n = Array.isArray(t) ? t : [t], s = [], i = [];
+    for (const r of n)
+      r.kind === "leaf" ? i.push(r) : s.push(r);
+    return i.length > 0 && s.unshift({
+      kind: "aggregated",
+      matcher: () => !0,
+      children: i
+    }), s;
+  }
+  extractFormConfig() {
+    return {
+      suppressAutomaticStack: !1,
+      suppressAutomaticSubmit: !1,
+      onSubmit: (t) => console.log("Form submitted:", t)
+    };
+  }
+}
+const hn = new fn();
+function Tn() {
+  let e = 0;
+  return { next: () => `event_${e++}` };
+}
+class Sn {
+  constructor(t, n, s, i, r) {
+    this.resolver = t, this.merger = n, this.mapper = s, this.eventWiring = i, this.stateExpansion = r;
+  }
+  walkAndMap(t, n, s) {
+    const i = /* @__PURE__ */ new Map(), r = Tn(), l = { value: 0 }, o = /* @__PURE__ */ new Set();
+    return { widgets: this.walkItems(
+      t,
+      n,
+      i,
+      s,
+      r,
+      l,
+      o
+    ), eventRegistry: i };
+  }
+  walkItems(t, n, s, i, r, l, o) {
+    return t.flatMap((a) => {
+      if (a.type !== "ITEMS")
+        throw new Error("Unexpected gui shortcut type");
+      return a.items.map((u) => this.processItem(
+        u,
+        a.itemType,
+        a.tags,
+        n,
+        s,
+        i,
+        r,
+        l,
+        o
+      ));
+    });
+  }
+  processItem(t, n, s, i, r, l, o, a, u) {
+    const c = n, y = I(n), d = y.parseEntry(t), T = this.buildBaseDef(d), E = this.buildDecoratorForMatching(T, c, s), U = this.resolver.resolve(E, i), R = U.leafSelectors.filter((b) => b.targetState != null), N = {
+      leafSelectors: U.leafSelectors.filter((b) => b.targetState == null),
+      sensibleDefaults: U.sensibleDefaults
+    };
+    let k = this.merger.merge(T, c, N);
+    y.afterMerge && (k = y.afterMerge(k, {
+      eventRegistry: r,
+      formConfig: l,
+      eventIdGenerator: o
+    })), k = this.eventWiring.wireInputLayoutEvents(
+      k,
+      r,
+      o
+    );
+    const { cleanedResult: W, stateData: v } = this.stateExpansion.extractFromMergeResult(
+      k,
+      R
+    );
+    let S;
+    if (y.buildCustomWidget) {
+      const b = this.buildCustomWidgetContext(
+        d.children,
+        i,
+        r,
+        l,
+        o,
+        a,
+        u
+      );
+      S = this.buildCustomWidget(y, W, b);
+    } else
+      S = this.mapper.mapToWidget(W, c);
+    if (typeof S != "function") {
+      const b = S;
+      b.uid || (b.path && !u.has(b.path) ? (b.uid = b.path, u.add(b.path)) : b.uid = `dx_${a.value++}`);
+    }
+    if (this.stateExpansion.hasStateData(v))
+      if (typeof S == "function") {
+        const b = S;
+        S = ((te) => {
+          const ne = b(te);
+          return this.stateExpansion.applyToWidget(
+            ne,
+            v,
+            r,
+            o
+          );
+        });
+      } else
+        S = this.stateExpansion.applyToWidget(
+          S,
+          v,
+          r,
+          o
+        );
+    return S;
+  }
+  buildCustomWidgetContext(t, n, s, i, r, l, o) {
+    return {
+      children: t,
+      mapStaticDef: (a, u) => this.mapper.mapStaticDef(a, u),
+      walkChildren: (a) => this.walkItems(
+        a,
+        n,
+        s,
+        i,
+        r,
+        l,
+        o
+      )
+    };
+  }
+  buildCustomWidget(t, n, s) {
+    return t.buildCustomWidget(n, s);
+  }
+  /**
+   * Resolves the base definition from a parsed entry, injecting the path for keyed entries.
+   * For runtime (function) providers, wraps them to inject the path at evaluation time.
+   */
+  buildBaseDef(t) {
+    const n = t.baseDef;
+    return typeof n == "function" ? (s) => {
+      const r = n(s ?? {});
+      return t.path != null ? { ...r, path: t.path } : r;
+    } : t.path != null ? { ...n, path: t.path } : n;
+  }
+  buildDecoratorForMatching(t, n, s) {
+    if (typeof t == "function")
+      return { itemType: n, tags: [...s] };
+    const i = [...s, ..."tags" in t && t.tags ? t.tags : []], r = "uid" in t ? t.uid : void 0, l = "type" in t ? t.type : void 0;
+    return { itemType: n, tags: i, uid: r, type: l };
+  }
+}
+const An = {
+  input: /* @__PURE__ */ new Set(["disabled", "readonly", "label", "validator", "size"]),
+  action: /* @__PURE__ */ new Set(["disabled", "label", "size"]),
+  layout: /* @__PURE__ */ new Set(["size"]),
+  display: /* @__PURE__ */ new Set([])
+}, $ = {
+  onChange: "change",
+  onLoad: "load",
+  onFilter: "filter",
+  onClick: "click"
+};
+class kn {
+  /**
+   * Extracts `states` from a merge result, combining with state-targeted
+   * GSL leaf selectors from `_gslStates`.
+   *
+   * Returns a cleaned merge result (no states) and accumulated state data.
+   */
+  extractFromMergeResult(t, n) {
+    const s = {};
+    for (const o of n) {
+      const a = o.targetState, u = o.config, c = u.override && typeof u.override != "function" ? u.override : u;
+      s[a] = {
+        ...s[a] || {},
+        ...c
+      };
+    }
+    if (t.kind === "dynamic") {
+      const o = t.fn;
+      return {
+        cleanedResult: { kind: "dynamic", fn: (u) => {
+          const c = o(u), { states: y, ...d } = c;
+          return d;
+        } },
+        stateData: { stateOverrides: s }
+      };
+    }
+    const { states: i, ...r } = t.def, l = {};
+    for (const [o, a] of Object.entries(s))
+      l[o] = { ...a };
+    if (i)
+      for (const [o, a] of Object.entries(
+        i
+      ))
+        l[o] = { ...l[o] || {}, ...a };
+    return {
+      cleanedResult: { kind: "static", def: r },
+      stateData: { stateOverrides: l }
+    };
+  }
+  /**
+   * Applies state overrides to a core widget. Each override produces:
+   * - `visible: true/false` → `include: { in }` / `exclude: { from }`
+   * - Core suffixable props → `'prop.stateName': value` at widget root
+   * - Event handlers → `on: { 'eventType.stateName': eventId }` with registry wiring
+   * - Custom props → `props: { 'prop.stateName': value }`
+   */
+  applyToWidget(t, n, s, i) {
+    const { stateOverrides: r } = n;
+    if (Object.keys(r).length === 0)
+      return t;
+    const l = { ...t }, o = t.kind, a = An[o] || /* @__PURE__ */ new Set();
+    t.props && (l.props = { ...t.props }), t.on && (l.on = { ...t.on });
+    for (const [u, c] of Object.entries(r))
+      for (const [y, d] of Object.entries(c))
+        y === "visible" ? this.applyVisibility(l, u, d) : $[y] ? this.applyStateEvent(l, u, y, d, s, i) : a.has(y) ? l[`${y}.${u}`] = d : (l.props || (l.props = {}), l.props[`${y}.${u}`] = d);
+    return l;
+  }
+  hasStateData(t) {
+    return Object.keys(t.stateOverrides).length > 0;
+  }
+  // ── Visibility helpers ──
+  applyVisibility(t, n, s) {
+    if (s) {
+      const i = t.include?.in || [];
+      t.include = { ...t.include || {}, in: [...i, n] };
+    } else {
+      const i = t.exclude?.from || [];
+      t.exclude = { ...t.exclude || {}, from: [...i, n] };
+    }
+  }
+  // ── State-suffixed event helpers ──
+  applyStateEvent(t, n, s, i, r, l) {
+    const o = $[s];
+    if (t.on || (t.on = {}), typeof i == "function") {
+      const a = l.next();
+      r.set(a, i), t.on[`${o}.${n}`] = a;
+    } else typeof i == "string" && (t.on[`${o}.${n}`] = i);
+  }
+}
+const _n = new kn();
+class In {
+  constructor(t, n, s) {
+    this.selectorNormalizer = t, this.eventWiring = n, this.walker = s;
+  }
+  processDxFacade(t, n = [], s) {
+    const { defs: i, gslSelectors: r, formConfig: l } = this.prepareForm(
+      t,
+      n,
+      s
+    ), { widgets: o, eventRegistry: a } = this.walker.walkAndMap(
+      i,
+      r,
+      l
+    ), u = o[0];
+    return this.buildResult({ form: u }, a, l);
+  }
+  /**
+   * Normalizes raw form definitions and applies form-level defaults.
+   *
+   * Steps:
+   *  1. Normalize definitions — ensure a flat array; convert bare functions to display widgets.
+   *  2. Normalize selectors — convert mixed leaf/aggregated selectors into a uniform
+   *     aggregated shape, and extract form-level config (see {@link FormConfig}).
+   *  3. Auto-submit — unless suppressed, append a submit button if none was declared.
+   *     Throws if more than one submit button is found.
+   *  4. Auto-stack — unless suppressed, wrap all definitions in a synthetic root
+   *     flex column layout so the form renders as a single vertical container.
+   */
+  prepareForm(t, n, s) {
+    const r = (Array.isArray(t) ? [...t] : [t]).map(
+      (u) => typeof u == "function" ? H(u) : u
+    ), l = this.selectorNormalizer.normalizeSelectors(n), o = {
+      ...this.selectorNormalizer.extractFormConfig(),
+      ...s
+    }, a = this.eventWiring.countSubmitButtons(r);
+    if (a > 1)
+      throw new Error(
+        `Only one submit button is allowed per form, but ${a} were found. A button is a submit button if it has uid: '#submit' or onClick: 'submit'.`
+      );
+    if (!o.suppressAutomaticSubmit && a === 0 && r.push(V()), !o.suppressAutomaticStack) {
+      const u = {
+        def: { uid: "#root", direction: "column", widgetName: "flex" },
+        children: r
+      };
+      return {
+        defs: [{ type: "ITEMS", itemType: h.LAYOUTS, items: [u], tags: [] }],
+        gslSelectors: l,
+        formConfig: o
+      };
+    }
+    return { defs: r, gslSelectors: l, formConfig: o };
+  }
+  /**
+   * Converts DX `$`-separated state names to core's `:`-separated names.
+   * E.g. `{ register$adult: 'expr' }` → `{ 'register:adult': 'expr' }`.
+   */
+  convertStateNames(t) {
+    const n = {};
+    for (const [s, i] of Object.entries(t))
+      n[s.replace(/\$/g, ":")] = i;
+    return n;
+  }
+  buildResult(t, n, s) {
+    s.states && Object.keys(s.states).length > 0 && (t = {
+      ...t,
+      states: this.convertStateNames(s.states)
+    });
+    const i = { form: t };
+    return n.size > 0 && (i.events = (r) => {
+      const l = n.get(r.name);
+      if (l) {
+        const o = (u) => {
+          if (u && typeof u == "object" && "path" in u && !("type" in u)) {
+            const { path: c, ...y } = u;
+            for (const [d, T] of Object.entries(y))
+              r.callback({
+                type: "OVERRIDE_WIDGET_PROP",
+                payload: { path: c, prop: d, value: T }
+              });
+          } else
+            r.callback(u);
+        }, a = {
+          ...r,
+          callback: o,
+          update: o
+        };
+        l(a);
+      }
+    }), s.dependencies && (i.dependencies = s.dependencies), s.widgetLoaders && (i.widgetLoaders = s.widgetLoaders), s.validateOn && (i.validateOn = s.validateOn), s.itemRenderers && (i.itemRenderers = s.itemRenderers), i;
+  }
+}
+const En = new Sn(
+  dn,
+  mn,
+  bn,
+  C,
+  _n
+), Un = new In(hn, C, En);
+function Dn(e) {
+  return typeof e == "function" ? !0 : Array.isArray(e) ? e.length === 0 || e.every(j) : j(e);
+}
+function j(e) {
+  if (typeof e == "function") return !0;
+  if (e === null || typeof e != "object") return !1;
+  const t = e;
+  return t.type === "ITEMS" && typeof t.itemType == "string";
+}
+const Y = Object.freeze({}), Pn = Object.freeze({}), z = /* @__PURE__ */ new WeakMap();
+function w(e, t) {
+  return e == null ? t : typeof e == "object" ? e : {};
+}
+function xn(e, t, n) {
+  if (!Dn(e))
+    return { formDef: e };
+  const s = w(e, Y), i = w(t, Y), r = w(n, Pn);
+  let l = z.get(s);
+  l || (l = /* @__PURE__ */ new WeakMap(), z.set(s, l));
+  let o = l.get(i);
+  o || (o = /* @__PURE__ */ new WeakMap(), l.set(i, o));
+  const a = o.get(r);
+  if (a) return a;
+  const u = Un.processDxFacade(
+    e,
+    t,
+    n
+  ), c = {
+    formDef: u.form,
+    formEvent: u.events,
+    dependencies: u.dependencies,
+    widgetLoaders: u.widgetLoaders,
+    validateOn: u.validateOn,
+    itemRenderers: u.itemRenderers
+  };
+  return o.set(r, c), c;
+}
+class Cn {
+  create(t) {
+    return {
+      states: t.states,
       form: {
         uid: "gui-root-uid",
         type: "flex",
         kind: "layout",
-        children: e.form
+        children: t.form
       }
     };
   }
 }
-function s() {
-  return new a();
+function Fn() {
+  return new Cn();
 }
-const r = [
-  "calendar",
-  "checkbox",
-  "currency",
-  "dateInput",
-  "datePicker",
-  "dropdown",
-  "list",
-  "number",
-  "password",
-  "radiogroup",
-  "rangeCalendar",
-  "repeater",
-  "select",
-  "textarea",
-  "textinput",
-  "toggle"
-], l = ["accordion", "flex", "tabs"], u = ["alert", "renderer"], o = ["button"], p = [
-  ...r,
-  ...l,
-  ...u,
-  ...o
-], i = {
+const $n = (e) => e !== null && typeof e == "object" && Object.prototype.hasOwnProperty.call(e, "label") && Object.prototype.hasOwnProperty.call(e, "value");
+function jn(e, t) {
+  if (e != null && typeof e == "object" && "__rid" in e)
+    return e.__rid;
+  const n = t();
+  return Object.defineProperty(e, "__rid", {
+    value: n,
+    enumerable: !1,
+    configurable: !1
+  }), n;
+}
+function vn(e) {
+  return typeof e == "object" && e !== null && "$ref" in e && typeof e.$ref == "string" && Object.keys(e).length === 1;
+}
+async function wn(e, t) {
+  const n = new URL(e, t).href, s = await fetch(n);
+  if (!s.ok) throw new Error(`Failed to load form chunk ${n}: ${s.status}`);
+  const { $schema: i, ...r } = await s.json();
+  return O(r, n);
+}
+async function O(e, t) {
+  if (vn(e)) return wn(e.$ref, t);
+  const n = e;
+  if (Array.isArray(n.children)) {
+    const s = await Promise.all(n.children.map((i) => O(i, t)));
+    return { ...n, children: s };
+  }
+  return e;
+}
+async function Yn(e, t) {
+  const n = await Promise.all(
+    e.form.map((s) => O(s, t))
+  );
+  return { ...e, form: n };
+}
+const zn = {
   //
   // Input widgets
   //
   textinput: ({
-    config: t,
-    props: e,
+    config: e,
+    props: t,
     validator: n
   }) => ({
     uid: "",
     kind: "input",
     type: "textinput",
     // The `props` key only exists in the returned object when `props` is actually provided
-    ...e && { props: e },
+    ...t && { props: t },
     ...n && { validator: n },
-    ...t
+    ...e
   }),
   password: ({
-    config: t,
-    props: e,
+    config: e,
+    props: t,
     validator: n
   }) => ({
     uid: "",
     kind: "input",
     type: "password",
     // The `props` key only exists in the returned object when `props` is actually provided
-    ...e && { props: e },
+    ...t && { props: t },
     ...n && { validator: n },
-    ...t
+    ...e
   }),
   numberinput: ({
-    config: t,
-    props: e,
+    config: e,
+    props: t,
     validator: n
   }) => ({
     uid: "",
     kind: "input",
     type: "numberinput",
-    ...e && { props: e },
+    ...t && { props: t },
     ...n && { validator: n },
-    ...t
+    ...e
   }),
   checkbox: ({
-    config: t,
-    props: e,
+    config: e,
+    props: t,
     validator: n
   }) => ({
     uid: "",
     kind: "input",
     type: "checkbox",
-    ...e && { props: e },
+    ...t && { props: t },
     ...n && { validator: n },
-    ...t
+    ...e
   }),
   select: ({
-    config: t,
-    props: e,
+    config: e,
+    props: t,
     validator: n
   }) => ({
     uid: "",
     kind: "input",
     type: "select",
-    ...e && { props: e },
+    ...t && { props: t },
     ...n && { validator: n },
-    ...t
+    ...e
   }),
   //
   // Layout widgets
   //
-  flex: (t, e) => ({
+  flex: (e, t) => ({
     uid: "",
     kind: "layout",
     type: "flex",
-    ...e && { props: e },
-    ...t
+    ...t && { props: t },
+    ...e
   }),
-  tabs: (t, e) => ({
+  grid: (e, t) => ({
+    uid: "",
+    kind: "layout",
+    type: "grid",
+    ...t && { props: t },
+    ...e
+  }),
+  tabs: (e, t) => ({
     uid: "",
     kind: "layout",
     type: "tabs",
-    ...e && { props: e },
-    ...t
+    ...t && { props: t },
+    ...e
   }),
   //
   // Display widgets
   //
-  alert: (t, e) => ({
+  alert: (e, t) => ({
     uid: "",
     kind: "display",
     type: "alert",
-    ...e && { props: e },
-    ...t
-  })
-}, c = (t) => t !== null && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "label") && Object.prototype.hasOwnProperty.call(t, "value");
-function d(t) {
-  return c(t) ? t : { label: t, value: t };
-}
-const b = (t) => ({
-  string: (e, n) => i.textinput({ config: { path: n } }),
-  enum: (e, n) => i.select({
-    config: { path: n },
-    props: { options: e.enum?.map(d) ?? [] },
-    validator: t.stringValidator()
+    ...t && { props: t },
+    ...e
   }),
-  boolean: (e, n) => i.checkbox({ config: { path: n }, validator: t.booleanValidator() }),
-  number: (e, n) => i.numberinput({ config: { path: n }, validator: t.numberValidator() }),
-  integer: (e, n) => i.numberinput({ config: { path: n }, validator: t.integerValidator() }),
-  object: (e, n) => i.flex({ children: n }),
-  // one or the other must be valid .
-  // - remove data when tabs change.
-  // - don't generate all tabs initially.
-  oneOf: (e, n) => i.tabs(
-    { children: n }
-    /* TODO: , props: {logic: 'XOR'} as TabsProps*/
-  ),
-  // one or more must be valid.
-  // - don't remove data when tabs change.
-  // - generate all tabs initially, there might be a defaultValue to populate initial values.
-  anyOf: (e, n) => i.tabs(
-    { children: n }
-    /* TODO: , props: {logic: 'OR'} as TabsProps*/
-  ),
-  fallback: (e) => i.alert(
-    {},
-    {
-      text: `❌ Unsupported Json Schema field ${JSON.stringify(e)}`,
-      level: "error"
-    }
-  )
-});
+  markdownText: (e, t) => ({
+    uid: "",
+    kind: "display",
+    type: "markdownText",
+    ...t && { props: t },
+    ...e
+  })
+}, Mn = [
+  "calendar",
+  "checkbox",
+  "currency",
+  "dateInput",
+  "datePicker",
+  "dropdown",
+  "list",
+  "markdown",
+  "number",
+  "password",
+  "radiogroup",
+  "rangeCalendar",
+  "rangeDateInput",
+  "rangeDatePicker",
+  "repeater",
+  "select",
+  "textarea",
+  "textinput",
+  "toggle"
+], Ln = ["accordion", "flex", "grid", "tabs"], Bn = ["alert", "markdownText", "renderer"], On = ["button"], Gn = [
+  ...Mn,
+  ...Ln,
+  ...Bn,
+  ...On
+];
 export {
-  i as Vanilla,
-  o as actionWidgets,
-  u as displayWidgets,
-  s as golemForm,
-  r as inputWidgets,
-  c as isOption,
-  l as layoutWidgets,
-  b as vanillaSchemaToFieldMap,
-  p as vanillaWidgets
+  zn as GolemWidgets,
+  qt as _gslAccordionByUid,
+  Zt as _gslAccordions,
+  vt as _gslActionByUid,
+  Ct as _gslActions,
+  $t as _gslAlertByUid,
+  Ft as _gslAlerts,
+  je as _gslBooleanInputs,
+  ot as _gslCalendarByUid,
+  at as _gslCalendars,
+  Ze as _gslCheckboxByUid,
+  Xe as _gslCheckboxes,
+  tt as _gslCurrencies,
+  nt as _gslCurrencyByUid,
+  tn as _gslCustomActionByUid,
+  en as _gslCustomActions,
+  sn as _gslCustomDisplayByUid,
+  nn as _gslCustomDisplays,
+  Jt as _gslCustomInputByUid,
+  Qt as _gslCustomInputs,
+  un as _gslCustomLayoutByUid,
+  on as _gslCustomLayouts,
+  ct as _gslDateInputByUid,
+  ut as _gslDateInputs,
+  dt as _gslDatePickerByUid,
+  pt as _gslDatePickers,
+  xt as _gslDisplayByUid,
+  Wt as _gslDisplays,
+  Ke as _gslDropdownByUid,
+  Ge as _gslDropdowns,
+  xe as _gslInputByUid,
+  P as _gslInputs,
+  Ot as _gslLayoutByUid,
+  Bt as _gslLayouts,
+  lt as _gslListByUid,
+  rt as _gslLists,
+  it as _gslMarkdownByUid,
+  st as _gslMarkdowns,
+  $e as _gslNumberInputs,
+  et as _gslPasswordByUid,
+  Je as _gslPasswords,
+  He as _gslRadiogroupByUid,
+  Ve as _gslRadiogroups,
+  mt as _gslRangeCalendarByUid,
+  yt as _gslRangeCalendars,
+  bt as _gslRangeDateInputByUid,
+  gt as _gslRangeDateInputs,
+  ht as _gslRangeDatePickerByUid,
+  ft as _gslRangeDatePickers,
+  Et as _gslRepeaterByUid,
+  Q as _gslRepeaters,
+  ze as _gslSelectByUid,
+  Ye as _gslSelects,
+  Nn as _gslStates,
+  Gt as _gslTabs,
+  Kt as _gslTabsByUid,
+  Wn as _gslTag,
+  Fe as _gslTextInputs,
+  Qe as _gslTextareaByUid,
+  qe as _gslTextareas,
+  we as _guiAccordion,
+  Ie as _guiAlert,
+  re as _guiBooleanInput,
+  K as _guiButton,
+  ge as _guiCalendar,
+  ue as _guiCheckbox,
+  de as _guiCurrency,
+  _e as _guiCustomAction,
+  Ee as _guiCustomDisplay,
+  Ae as _guiCustomInput,
+  Me as _guiCustomLayout,
+  be as _guiDateInput,
+  fe as _guiDatePicker,
+  H as _guiDisplay,
+  ae as _guiDropdown,
+  L as _guiFlex,
+  B as _guiGrid,
+  Ue as _guiHorizontalFlex,
+  Pe as _guiHorizontalGrid,
+  me as _guiList,
+  ye as _guiMarkdown,
+  ie as _guiNumberInput,
+  pe as _guiPassword,
+  oe as _guiRadiogroup,
+  he as _guiRangeCalendar,
+  Te as _guiRangeDateInput,
+  Se as _guiRangeDatePicker,
+  Le as _guiRepeater,
+  le as _guiSelect,
+  V as _guiSubmitButton,
+  ve as _guiTabs,
+  se as _guiTextInput,
+  ce as _guiTextarea,
+  De as _guiVerticalFlex,
+  Ce as _guiVerticalGrid,
+  On as actionWidgets,
+  X as createGslSelector,
+  p as defineShortcutType,
+  Bn as displayWidgets,
+  m as extractWidgetProps,
+  Un as formDefs,
+  jn as getItemKey,
+  Fn as golemForm,
+  Gn as golemWidgets,
+  Rn as gui,
+  Mn as inputWidgets,
+  Dn as isDxDefinitions,
+  $n as isOption,
+  Ln as layoutWidgets,
+  g as processAutoLabel,
+  A as processAutoPlaceholder,
+  Yn as resolveChunkRefs,
+  xn as resolveFormInput
 };