@golemui/gui-shared 0.17.0 → 1.0.0-rc.0

package/internals.js

@@ -1,15 +1,726 @@
-import { aa as f } from "./resolveFormInput-DoBisQ5Q.js";
-function o(e, n) {
-  if (e != null && typeof e == "object" && "__rid" in e)
-    return e.__rid;
-  const r = n();
-  return Object.defineProperty(e, "__rid", {
-    value: r,
+import { aF as I, aG as h, ah as C, aH as M, aI as B } from "./register-BCL1xvhN.js";
+import { X as ye, W as _e, L as he, K as me, R as Se, Q as be, d as De, x as Te, w as Ae, l as Oe, k as Ue, q as Ie, r as Re, a0 as Ee, $ as xe, a2 as ke, a1 as ve, Z as we, Y as Ce, a4 as Me, a3 as Be, z as Le, y as Pe, B as je, A as Fe, P as Ne, O as We, h as ze, g as Ge, a as Ke, _ as $e, N as Ve, M as Ye, v as He, u as Xe, t as qe, T as Je, S as Qe, s as Ze, c as et, p as tt, o as st, j as at, i as nt, D as rt, C as ot, F as it, E as lt, H as ct, G as ut, J as pt, I as dt, f as ft, e as gt, U as yt, V as _t, aJ as ht, aK as mt, b as St, n as bt, m as Dt, a6 as Tt, ag as At, aC as Ot, aj as Ut, as as It, ay as Rt, av as Et, ai as xt, ae as kt, ak as vt, a5 as wt, ar as Ct, aq as Mt, aA as Bt, ad as Lt, aa as Pt, ac as jt, a9 as Ft, at as Nt, au as Wt, af as zt, aD as Gt, aw as Kt, az as $t, ap as Vt, ao as Yt, an as Ht, am as Xt, aB as qt, a7 as Jt, al as Qt, aE as Zt, ax as es, ab as ts, a8 as ss, aL as as, aM as ns, aN as rs, aO as os, aP as is } from "./register-BCL1xvhN.js";
+import "@golemui/core";
+import "@golemui/gui-validators";
+function ie(i, ...e) {
+  return e.map((t) => ({
+    ...t,
+    targetState: i
+  }));
+}
+function le(i, ...e) {
+  return {
+    kind: "aggregated",
+    matcher: (t) => t.tags?.includes(i) ?? !1,
+    children: e
+  };
+}
+const R = {
+  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",
+    "TAGS"
+  ]),
+  ACTIONS: /* @__PURE__ */ new Set(["ACTIONS", "CUSTOM_ACTION"]),
+  DISPLAYS: /* @__PURE__ */ new Set(["DISPLAYS", "ALERTS", "MARKDOWN_TEXTS", "CUSTOM_DISPLAY"]),
+  LAYOUTS: /* @__PURE__ */ new Set(["LAYOUTS", "TABS", "ACCORDION", "CUSTOM_LAYOUT"])
+};
+function L(i, e) {
+  const t = R[i];
+  return t ? t.has(e) : i === e;
+}
+class P {
+  resolve(e, t) {
+    const a = [];
+    for (const n of t)
+      n.kind === "aggregated" ? this.collectFromAggregated(n, e, a) : this.collectFromLeaf(n, e, a);
+    const s = this.rollUpSensibleDefaults(a);
+    return {
+      leafSelectors: a,
+      sensibleDefaults: s
+    };
+  }
+  collectFromAggregated(e, t, a) {
+    if (e.matcher(t))
+      for (const s of e.children)
+        this.collectFromLeaf(s, t, a);
+  }
+  collectFromLeaf(e, t, a) {
+    L(e.selectorType, t.itemType ?? "") && e.matcher(t) && a.push(e);
+  }
+  rollUpSensibleDefaults(e) {
+    const t = /* @__PURE__ */ new Map(), a = (n, r) => {
+      const o = t.get(n) ?? [];
+      o.push(r), t.set(n, o);
+    };
+    for (const n of e) {
+      const r = R[n.selectorType];
+      if (r)
+        for (const o of r) a(o, n);
+      else
+        a(n.selectorType, n);
+    }
+    const s = {};
+    for (const [n, r] of t)
+      I(n) && (s[n] = h(n).rollUpSensibleDefaults(r));
+    return s;
+  }
+}
+const j = new P();
+class F {
+  /**
+   * 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(e, t) {
+    if (t == null)
+      return e;
+    if (e == null || typeof e != "object" || typeof t != "object" || Array.isArray(e) || Array.isArray(t))
+      return t;
+    const a = { ...e };
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (typeof t[s] == "object" && !Array.isArray(t[s]) && t[s] !== null && typeof e[s] == "object" && !Array.isArray(e[s]) && e[s] !== null ? a[s] = this.deepMerge(e[s], t[s]) : a[s] = t[s]);
+    return a;
+  }
+}
+const N = new F();
+class W {
+  constructor(e) {
+    this.objectUtils = e;
+  }
+  merge(e, t, a) {
+    let s = {}, n = null;
+    typeof e == "function" && (n = e);
+    const r = this.collectDecorators(a);
+    for (const c of r) {
+      if (n != null) {
+        n = this.composeRuntimeFunctions(n, c);
+        continue;
+      }
+      if (typeof c == "function") {
+        const u = c({
+          ...s,
+          ...typeof e == "function" ? {} : e
+        });
+        if (typeof u == "function") {
+          n = this.createPromotedFunction(
+            s,
+            e,
+            u,
+            t,
+            a
+          );
+          continue;
+        }
+        s = this.objectUtils.deepMerge(s, u);
+      } else
+        s = this.objectUtils.deepMerge(s, c);
+    }
+    if (n != null)
+      return {
+        kind: "dynamic",
+        fn: this.wrapWithSensibleDefaults(n, s, t, a)
+      };
+    const o = this.objectUtils.deepMerge(e, s);
+    return { kind: "static", def: this.applySensibleDefaults({ ...o }, t, a) };
+  }
+  // ── Collect all decorators in priority order ──
+  collectDecorators(e) {
+    const t = [];
+    for (const a of e.leafSelectors) {
+      const s = a.config;
+      s.override != null && t.push(s.override);
+    }
+    return t;
+  }
+  // ── Apply sensible defaults via registry ──
+  applySensibleDefaults(e, t, a) {
+    if (!I(t)) return e;
+    const s = a.sensibleDefaults[t] ?? {};
+    return h(t).applySensibleDefaults(e, s);
+  }
+  // ── Create promoted FunctionWidget ──
+  createPromotedFunction(e, t, a, s, n) {
+    return (r) => {
+      const o = a(r);
+      let l = this.objectUtils.deepMerge(e, o);
+      return l = this.objectUtils.deepMerge(l, t), this.applySensibleDefaults(l, s, n);
+    };
+  }
+  // ── Wrap runtime function with accumulated static decorators and sensible defaults ──
+  wrapWithSensibleDefaults(e, t, a, s) {
+    return (n) => {
+      let r = e(n);
+      return Object.keys(t).length > 0 && (r = this.objectUtils.deepMerge(t, r)), this.applySensibleDefaults(r, a, s);
+    };
+  }
+  // ── Compose two runtime functions ──
+  composeRuntimeFunctions(e, t) {
+    return typeof t == "function" ? (a) => {
+      const s = e(a), n = t(s);
+      return typeof n == "function" ? n(a) : this.objectUtils.deepMerge(n, s);
+    } : (a) => {
+      const s = e(a);
+      return this.objectUtils.deepMerge(s, t);
+    };
+  }
+}
+const z = new W(N);
+class G {
+  mapToWidget(e, t) {
+    if (e.kind === "dynamic") {
+      const a = e.fn;
+      return ((s) => {
+        const n = a(s);
+        return this.mapStaticDef(n, t);
+      });
+    }
+    return this.mapStaticDef(e.def, t);
+  }
+  mapStaticDef(e, t) {
+    const a = h(t).mapToWidget(e);
+    return this.applyBaseWidgetFields(a, e);
+  }
+  /**
+   * Injects BaseWidget-level fields that all widget types share.
+   * Centralized here so individual mappers don't need to repeat the pattern.
+   */
+  applyBaseWidgetFields(e, t) {
+    return t.size != null && (e.size = t.size), t.defaultValue != null && e.kind === "input" && (e.defaultValue = t.defaultValue), t.on != null && (e.on = t.on), t.include != null && (e.include = t.include), t.exclude != null && (e.exclude = t.exclude), e;
+  }
+}
+const K = new G();
+class $ {
+  /**
+   * 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(e) {
+    const t = Array.isArray(e) ? e : [e], a = [], s = [];
+    for (const n of t)
+      n.kind === "leaf" ? s.push(n) : a.push(n);
+    return s.length > 0 && a.unshift({
+      kind: "aggregated",
+      matcher: () => !0,
+      children: s
+    }), a;
+  }
+  extractFormConfig() {
+    return {
+      suppressAutomaticStack: !1
+    };
+  }
+}
+const V = new $(), Y = {
+  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([])
+}, T = {
+  onChange: "change",
+  onLoad: "load",
+  onFilter: "filter",
+  onClick: "click"
+};
+class H {
+  /**
+   * 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(e, t) {
+    const a = {};
+    for (const o of t) {
+      const l = o.targetState, c = o.config, u = c.override && typeof c.override != "function" ? c.override : c;
+      a[l] = {
+        ...a[l] || {},
+        ...u
+      };
+    }
+    if (e.kind === "dynamic") {
+      const o = e.fn;
+      return {
+        cleanedResult: { kind: "dynamic", fn: (c) => {
+          const u = o(c), { states: p, ...f } = u;
+          return f;
+        } },
+        stateData: { stateOverrides: a }
+      };
+    }
+    const { states: s, ...n } = e.def, r = {};
+    for (const [o, l] of Object.entries(a))
+      r[o] = { ...l };
+    if (s)
+      for (const [o, l] of Object.entries(
+        s
+      ))
+        r[o] = { ...r[o] || {}, ...l };
+    return {
+      cleanedResult: { kind: "static", def: n },
+      stateData: { stateOverrides: r }
+    };
+  }
+  /**
+   * 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(e, t, a, s) {
+    const { stateOverrides: n } = t;
+    if (Object.keys(n).length === 0)
+      return e;
+    const r = { ...e }, o = e.kind, l = Y[o] || /* @__PURE__ */ new Set();
+    e.props && (r.props = { ...e.props }), e.on && (r.on = { ...e.on });
+    for (const [c, u] of Object.entries(n))
+      for (const [p, f] of Object.entries(u))
+        p === "visible" ? this.applyVisibility(r, c, f) : T[p] ? this.applyStateEvent(r, c, p, f, a, s) : l.has(p) ? r[`${p}.${c}`] = f : (r.props || (r.props = {}), r.props[`${p}.${c}`] = f);
+    return r;
+  }
+  hasStateData(e) {
+    return Object.keys(e.stateOverrides).length > 0;
+  }
+  // ── Visibility helpers ──
+  applyVisibility(e, t, a) {
+    if (a) {
+      const s = e.include?.in || [];
+      e.include = { ...e.include || {}, in: [...s, t] };
+    } else {
+      const s = e.exclude?.from || [];
+      e.exclude = { ...e.exclude || {}, from: [...s, t] };
+    }
+  }
+  // ── State-suffixed event helpers ──
+  applyStateEvent(e, t, a, s, n, r) {
+    const o = T[a];
+    if (e.on || (e.on = {}), typeof s == "function") {
+      const l = r.next();
+      n.set(l, s), e.on[`${o}.${t}`] = l;
+    } else typeof s == "string" && (e.on[`${o}.${t}`] = s);
+  }
+}
+const X = new H();
+function q() {
+  let i = 0;
+  return { next: () => `event_${i++}` };
+}
+class J {
+  constructor(e, t, a, s, n) {
+    this.resolver = e, this.merger = t, this.mapper = a, this.eventWiring = s, this.stateExpansion = n;
+  }
+  walkAndMap(e, t, a) {
+    const s = /* @__PURE__ */ new Map(), n = q(), r = { value: 0 }, o = /* @__PURE__ */ new Set();
+    return { widgets: this.walkItems(
+      e,
+      t,
+      s,
+      a,
+      n,
+      r,
+      o
+    ), eventRegistry: s };
+  }
+  walkItems(e, t, a, s, n, r, o) {
+    return e.flatMap((l) => {
+      if (l.type !== "ITEMS")
+        throw new Error("Unexpected gui shortcut type");
+      return l.items.map((c) => this.processItem(
+        c,
+        l.itemType,
+        l.tags,
+        t,
+        a,
+        s,
+        n,
+        r,
+        o
+      ));
+    });
+  }
+  processItem(e, t, a, s, n, r, o, l, c) {
+    const u = t, p = h(t), f = p.parseEntry(e), _ = this.buildBaseDef(f), E = this.buildDecoratorForMatching(_, u, a), m = this.resolver.resolve(E, s), x = m.leafSelectors.filter((d) => d.targetState != null), k = {
+      leafSelectors: m.leafSelectors.filter((d) => d.targetState == null),
+      sensibleDefaults: m.sensibleDefaults
+    };
+    let y = this.merger.merge(_, u, k);
+    p.afterMerge && (y = p.afterMerge(y, {
+      eventRegistry: n,
+      formConfig: r,
+      eventIdGenerator: o
+    })), y = this.eventWiring.wireInputLayoutEvents(
+      y,
+      n,
+      o
+    );
+    const { cleanedResult: D, stateData: S } = this.stateExpansion.extractFromMergeResult(
+      y,
+      x
+    );
+    let g;
+    if (p.buildCustomWidget) {
+      const d = this.buildCustomWidgetContext(
+        f.children,
+        s,
+        n,
+        r,
+        o,
+        l,
+        c
+      );
+      g = this.buildCustomWidget(p, D, d);
+    } else
+      g = this.mapper.mapToWidget(D, u);
+    if (typeof g != "function") {
+      const d = g;
+      d.uid || (d.path && !c.has(d.path) ? (d.uid = d.path, c.add(d.path)) : d.uid = `dx_${l.value++}`);
+    }
+    if (this.stateExpansion.hasStateData(S))
+      if (typeof g == "function") {
+        const d = g;
+        g = ((v) => {
+          const w = d(v);
+          return this.stateExpansion.applyToWidget(
+            w,
+            S,
+            n,
+            o
+          );
+        });
+      } else
+        g = this.stateExpansion.applyToWidget(
+          g,
+          S,
+          n,
+          o
+        );
+    return g;
+  }
+  buildCustomWidgetContext(e, t, a, s, n, r, o) {
+    return {
+      children: e,
+      mapStaticDef: (l, c) => this.mapper.mapStaticDef(l, c),
+      walkChildren: (l) => this.walkItems(
+        l,
+        t,
+        a,
+        s,
+        n,
+        r,
+        o
+      )
+    };
+  }
+  buildCustomWidget(e, t, a) {
+    return e.buildCustomWidget(t, a);
+  }
+  /**
+   * 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(e) {
+    const t = e.baseDef;
+    return typeof t == "function" ? (a) => {
+      const n = t(a ?? {});
+      return e.path != null ? { ...n, path: e.path } : n;
+    } : e.path != null ? { ...t, path: e.path } : t;
+  }
+  buildDecoratorForMatching(e, t, a) {
+    if (typeof e == "function")
+      return { itemType: t, tags: [...a] };
+    const s = [...a, ..."tags" in e && e.tags ? e.tags : []], n = "uid" in e ? e.uid : void 0, r = "type" in e ? e.type : void 0;
+    return { itemType: t, tags: s, uid: n, type: r };
+  }
+}
+class Q {
+  constructor(e, t) {
+    this.selectorNormalizer = e, this.walker = t;
+  }
+  processDxFacade(e, t = [], a) {
+    const { defs: s, gslSelectors: n, formConfig: r } = this.prepareForm(
+      e,
+      t,
+      a
+    ), { widgets: o, eventRegistry: l } = this.walker.walkAndMap(
+      s,
+      n,
+      r
+    ), c = o[0];
+    return this.buildResult({ form: c }, l, r);
+  }
+  /**
+   * 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-stack — unless suppressed, wrap all definitions in a synthetic root
+   *     flex column layout so the form renders as a single vertical container.
+   */
+  prepareForm(e, t, a) {
+    const n = (Array.isArray(e) ? [...e] : [e]).map(
+      (l) => typeof l == "function" ? C(l) : l
+    ), r = this.selectorNormalizer.normalizeSelectors(t), o = {
+      ...this.selectorNormalizer.extractFormConfig(),
+      ...a
+    };
+    if (!o.suppressAutomaticStack) {
+      const l = {
+        def: { uid: "#root", direction: "column", widgetName: "flex" },
+        children: n
+      };
+      return {
+        defs: [{ type: "ITEMS", itemType: M.LAYOUTS, items: [l], tags: [] }],
+        gslSelectors: r,
+        formConfig: o
+      };
+    }
+    return { defs: n, gslSelectors: r, formConfig: o };
+  }
+  /**
+   * Converts DX `$`-separated state names to core's `:`-separated names.
+   * E.g. `{ register$adult: 'expr' }` → `{ 'register:adult': 'expr' }`.
+   */
+  convertStateNames(e) {
+    const t = {};
+    for (const [a, s] of Object.entries(e))
+      t[a.replace(/\$/g, ":")] = s;
+    return t;
+  }
+  buildResult(e, t, a) {
+    a.states && Object.keys(a.states).length > 0 && (e = {
+      ...e,
+      states: this.convertStateNames(a.states)
+    });
+    const s = { form: e };
+    return t.size > 0 && (s.events = (n) => {
+      const r = t.get(n.name);
+      if (r) {
+        const o = (c) => {
+          if (c && typeof c == "object" && "path" in c && !("type" in c)) {
+            const { path: u, ...p } = c;
+            for (const [f, _] of Object.entries(p))
+              n.callback({
+                type: "OVERRIDE_WIDGET_PROP",
+                payload: { path: u, prop: f, value: _ }
+              });
+          } else
+            n.callback(c);
+        }, l = {
+          ...n,
+          callback: o,
+          update: o
+        };
+        r(l);
+      }
+    }), a.dependencies && (s.dependencies = a.dependencies), a.widgetLoaders && (s.widgetLoaders = a.widgetLoaders), a.validateOn && (s.validateOn = a.validateOn), a.itemRenderers && (s.itemRenderers = a.itemRenderers), s;
+  }
+}
+const Z = new J(
+  j,
+  z,
+  K,
+  B,
+  X
+), ee = new Q(V, Z);
+function te(i) {
+  return typeof i == "function" ? !0 : Array.isArray(i) ? i.length === 0 || i.every(A) : A(i);
+}
+function A(i) {
+  if (typeof i == "function") return !0;
+  if (i === null || typeof i != "object") return !1;
+  const e = i;
+  return e.type === "ITEMS" && typeof e.itemType == "string";
+}
+const O = Object.freeze({}), se = Object.freeze({}), U = /* @__PURE__ */ new WeakMap();
+function b(i, e) {
+  return i == null ? e : typeof i == "object" ? i : {};
+}
+function ce(i, e, t) {
+  if (!te(i))
+    return { formDef: i };
+  const a = b(i, O), s = b(e, O), n = b(t, se);
+  let r = U.get(a);
+  r || (r = /* @__PURE__ */ new WeakMap(), U.set(a, r));
+  let o = r.get(s);
+  o || (o = /* @__PURE__ */ new WeakMap(), r.set(s, o));
+  const l = o.get(n);
+  if (l) return l;
+  const c = ee.processDxFacade(
+    i,
+    e,
+    t
+  ), u = {
+    formDef: c.form,
+    formEvent: c.events,
+    dependencies: c.dependencies,
+    widgetLoaders: c.widgetLoaders,
+    validateOn: c.validateOn,
+    itemRenderers: c.itemRenderers
+  };
+  return o.set(n, u), u;
+}
+class ae {
+  create(e) {
+    return {
+      states: e.states,
+      form: {
+        uid: "gui-root-uid",
+        type: "flex",
+        kind: "layout",
+        children: e.form
+      }
+    };
+  }
+}
+function ue() {
+  return new ae();
+}
+const pe = (i) => i !== null && typeof i == "object" && Object.prototype.hasOwnProperty.call(i, "label") && Object.prototype.hasOwnProperty.call(i, "value");
+function de(i, e) {
+  if (i != null && typeof i == "object" && "__rid" in i)
+    return i.__rid;
+  const t = e();
+  return Object.defineProperty(i, "__rid", {
+    value: t,
     enumerable: !1,
     configurable: !1
-  }), r;
+  }), t;
 }
 export {
-  o as getItemKey,
-  f as resolveFormInput
+  ye as _gslAccordionByUid,
+  _e as _gslAccordions,
+  he as _gslActionByUid,
+  me as _gslActions,
+  Se as _gslAlertByUid,
+  be as _gslAlerts,
+  De as _gslBooleanInputs,
+  Te as _gslCalendarByUid,
+  Ae as _gslCalendars,
+  Oe as _gslCheckboxByUid,
+  Ue as _gslCheckboxes,
+  Ie as _gslCurrencies,
+  Re as _gslCurrencyByUid,
+  Ee as _gslCustomActionByUid,
+  xe as _gslCustomActions,
+  ke as _gslCustomDisplayByUid,
+  ve as _gslCustomDisplays,
+  we as _gslCustomInputByUid,
+  Ce as _gslCustomInputs,
+  Me as _gslCustomLayoutByUid,
+  Be as _gslCustomLayouts,
+  Le as _gslDateInputByUid,
+  Pe as _gslDateInputs,
+  je as _gslDatePickerByUid,
+  Fe as _gslDatePickers,
+  Ne as _gslDisplayByUid,
+  We as _gslDisplays,
+  ze as _gslDropdownByUid,
+  Ge as _gslDropdowns,
+  Ke as _gslInputByUid,
+  $e as _gslInputs,
+  Ve as _gslLayoutByUid,
+  Ye as _gslLayouts,
+  He as _gslListByUid,
+  Xe as _gslLists,
+  qe as _gslMarkdownByUid,
+  Je as _gslMarkdownTextByUid,
+  Qe as _gslMarkdownTexts,
+  Ze as _gslMarkdowns,
+  et as _gslNumberInputs,
+  tt as _gslPasswordByUid,
+  st as _gslPasswords,
+  at as _gslRadiogroupByUid,
+  nt as _gslRadiogroups,
+  rt as _gslRangeCalendarByUid,
+  ot as _gslRangeCalendars,
+  it as _gslRangeDateInputByUid,
+  lt as _gslRangeDateInputs,
+  ct as _gslRangeDatePickerByUid,
+  ut as _gslRangeDatePickers,
+  pt as _gslRepeaterByUid,
+  dt as _gslRepeaters,
+  ft as _gslSelectByUid,
+  gt as _gslSelects,
+  ie as _gslStates,
+  yt as _gslTabs,
+  _t as _gslTabsByUid,
+  le as _gslTag,
+  ht as _gslTags,
+  mt as _gslTagsByUid,
+  St as _gslTextInputs,
+  bt as _gslTextareaByUid,
+  Dt as _gslTextareas,
+  Tt as _guiAccordion,
+  At as _guiAlert,
+  Ot as _guiBooleanInput,
+  Ut as _guiButton,
+  It as _guiCalendar,
+  Rt as _guiCheckbox,
+  Et as _guiCurrency,
+  xt as _guiCustomAction,
+  kt as _guiCustomDisplay,
+  vt as _guiCustomInput,
+  wt as _guiCustomLayout,
+  Ct as _guiDateInput,
+  Mt as _guiDatePicker,
+  C as _guiDisplay,
+  Bt as _guiDropdown,
+  Lt as _guiFlex,
+  Pt as _guiGrid,
+  jt as _guiHorizontalFlex,
+  Ft as _guiHorizontalGrid,
+  Nt as _guiList,
+  Wt as _guiMarkdown,
+  zt as _guiMarkdownText,
+  Gt as _guiNumberInput,
+  Kt as _guiPassword,
+  $t as _guiRadiogroup,
+  Vt as _guiRangeCalendar,
+  Yt as _guiRangeDateInput,
+  Ht as _guiRangeDatePicker,
+  Xt as _guiRepeater,
+  qt as _guiSelect,
+  Jt as _guiTabs,
+  Qt as _guiTags,
+  Zt as _guiTextInput,
+  es as _guiTextarea,
+  ts as _guiVerticalFlex,
+  ss as _guiVerticalGrid,
+  as as createGslSelector,
+  ns as defineShortcutType,
+  rs as extractWidgetProps,
+  ee as formDefs,
+  de as getItemKey,
+  ue as golemForm,
+  te as isDxDefinitions,
+  pe as isOption,
+  os as processAutoLabel,
+  is as processAutoPlaceholder,
+  ce as resolveFormInput
 };