@tempots/beatui 0.95.0 → 1.0.1

package/dist/oneof-branch-detection-J_DYEEcD.js

@@ -0,0 +1,1077 @@
+import { Validation as z, upperCaseFirst as B, humanize as W } from "@tempots/std";
+import { attr as c, prop as _, html as h, computedOf as g, aria as F, on as w } from "@tempots/dom";
+import { g as H, C as J } from "./utils-vUtP6iPG.js";
+import { S as y, L as K } from "./stack-BLMteGTn.js";
+import { d as V, I as x } from "./translations-B1_yyDUK.js";
+import U from "ajv";
+import G from "ajv/dist/2019";
+import X from "ajv/dist/2020";
+import Q from "ajv-formats";
+function M(t) {
+  return t.split("/").slice(1).map((e) => e.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function Y(t) {
+  const e = M(t.instancePath || "");
+  if (t.keyword === "required") {
+    const n = t.params.missingProperty;
+    if (n != null) return [...e, n];
+  }
+  if (t.keyword === "additionalProperties") {
+    const n = t.params.additionalProperty;
+    if (n != null) return [...e, n];
+  }
+  if (t.keyword === "unevaluatedProperties") {
+    const n = t.params.unevaluatedProperty;
+    if (n != null) return [...e, n];
+  }
+  return e.length > 0 ? e : void 0;
+}
+function Z(t) {
+  return t.message ?? `${t.keyword} validation failed`;
+}
+function N(t) {
+  return t.reduce((e, n) => {
+    const r = Y(n);
+    if (r == null) return e;
+    let i = e;
+    for (const o of r) {
+      const s = o;
+      i.dependencies == null && (i.dependencies = {}), i.dependencies[s] == null && (i.dependencies[s] = {}), i = i.dependencies[s];
+    }
+    return i.message = Z(n), e;
+  }, {});
+}
+function Ve(t) {
+  const e = N(t);
+  return z.invalid(e);
+}
+function ee(t) {
+  const e = {
+    keyword: "x:ui",
+    // Accept both string and object shapes for future-proofing
+    schemaType: ["string", "object"],
+    errors: !1,
+    // No-op validation – vendor annotation only
+    validate: () => !0
+  };
+  t.addKeyword(e);
+}
+let A = /* @__PURE__ */ new WeakMap();
+function xe() {
+  A = /* @__PURE__ */ new WeakMap();
+}
+function Me(t) {
+  A.delete(t);
+}
+function Ee() {
+  return {
+    ajvInstances: 0
+    // WeakMap doesn't expose size for privacy/security
+  };
+}
+function te(t, e) {
+  let n = A.get(t);
+  n == null && (n = /* @__PURE__ */ new WeakMap(), A.set(t, n));
+  const r = n.get(e);
+  if (r) return r;
+  const i = t.compile(e);
+  return n.set(e, i), i;
+}
+async function k(t, e, n) {
+  const i = {
+    "2020-12": X,
+    "2019-09": G,
+    "draft-07": U
+  }[t], o = new i({
+    meta: n,
+    strictSchema: !1,
+    // Allow more flexible schema validation for tuple arrays
+    allErrors: !0,
+    removeAdditional: e
+  });
+  switch (t) {
+    case "2020-12":
+      o.opts.defaultMeta = "https://json-schema.org/draft/2020-12/schema";
+      break;
+    case "2019-09":
+      o.opts.defaultMeta = "https://json-schema.org/draft/2019-09/schema";
+      break;
+    case "draft-07":
+      o.opts.defaultMeta = "http://json-schema.org/draft-07/schema#";
+      break;
+  }
+  return Q(o), ee(o), o;
+}
+function ne(t) {
+  return t == null || t.includes("draft/2020-12") ? "2020-12" : t.includes("draft/2019-09") ? "2019-09" : "draft-07";
+}
+function re(t) {
+  const e = t.indexOf("#");
+  return e >= 0 ? t.slice(0, e) : t;
+}
+function $(t, e = !0) {
+  if (Array.isArray(t))
+    return t.map((n) => $(n, !1));
+  if (t != null && typeof t == "object") {
+    const n = t, r = {};
+    for (const [i, o] of Object.entries(n))
+      !e && (i === "$id" || i === "$schema" || i === "$dynamicAnchor") || (r[i] = $(o, !1));
+    return r;
+  }
+  return t;
+}
+function R(t) {
+  const e = /* @__PURE__ */ new Set(), n = (r) => {
+    if (r != null) {
+      if (Array.isArray(r)) {
+        for (const i of r) n(i);
+        return;
+      }
+      if (typeof r == "object") {
+        const i = r, o = i.$ref;
+        typeof o == "string" && o.length > 0 && o[0] !== "#" && e.add(re(o));
+        for (const s of Object.values(i)) n(s);
+      }
+    }
+  };
+  return n(t), [...e];
+}
+function E(t, e) {
+  for (const n of e) {
+    const r = n.$id;
+    if (typeof r == "string" && r.length > 0 && !t.getSchema(r))
+      try {
+        t.addSchema(n);
+      } catch {
+      }
+  }
+}
+async function ie(t, e, n, r) {
+  if (n == null) return null;
+  const i = /* @__PURE__ */ new Set();
+  if (r && r.length > 0)
+    for (const a of r) {
+      const l = a.$id;
+      typeof l == "string" && l.length > 0 && i.add(l);
+    }
+  const o = [], s = 5;
+  for (let a = 0; a < s; a++) {
+    const l = R(e), u = o.flatMap(
+      (p) => R(p)
+    ), f = /* @__PURE__ */ new Set([...l, ...u]), d = [];
+    for (const p of f)
+      if (!i.has(p)) {
+        if (t.getSchema(p)) {
+          i.add(p);
+          continue;
+        }
+        d.push(p);
+      }
+    if (d.length === 0) return null;
+    try {
+      const p = await n(d);
+      if (!Array.isArray(p) || p.length === 0)
+        return null;
+      E(t, p);
+      for (const m of p) {
+        const b = m.$id;
+        typeof b == "string" && b.length > 0 && (i.add(b), o.push(m));
+      }
+    } catch (p) {
+      return `refResolver failed: ${p instanceof Error ? p.message : String(p)}`;
+    }
+  }
+  return "refResolver reached iteration limit while resolving external $refs";
+}
+async function Te(t, e) {
+  try {
+    const n = ne(t.$schema), r = e?.sanitizeAdditional === !1 ? !1 : e?.sanitizeAdditional ?? !1, i = (f) => typeof f == "string" && f.endsWith("#") ? f.slice(0, -1) : f ?? "", o = t.$id, s = i(o);
+    if (s !== "" && (/* @__PURE__ */ new Set([
+      "https://json-schema.org/draft/2020-12/schema",
+      "https://json-schema.org/draft/2019-09/schema",
+      "http://json-schema.org/draft-07/schema"
+    ])).has(s)) {
+      const f = await k(n, r, !1), d = $(
+        t
+      );
+      try {
+        f.addMetaSchema(d);
+      } catch {
+      }
+      const p = f.getSchema(o ?? s) ?? f.compile(d);
+      return { ok: !0, value: { ajv: f, validate: p } };
+    }
+    const l = await k(n, r, !0);
+    if (e?.externalSchemas && e.externalSchemas.length > 0 && E(l, e.externalSchemas), e?.refResolver) {
+      const f = await ie(
+        l,
+        t,
+        e.refResolver,
+        e.externalSchemas
+      );
+      if (f != null)
+        return { ok: !1, error: f };
+    }
+    const u = l.compile(t);
+    return { ok: !0, value: { ajv: l, validate: u } };
+  } catch (n) {
+    return { ok: !1, error: n instanceof Error ? n.message : String(n) };
+  }
+}
+function se(t, e) {
+  if (typeof t == "boolean" || typeof e == "boolean")
+    return e;
+  const n = { ...t };
+  for (const [r, i] of Object.entries(e))
+    r === "required" && Array.isArray(t.required) && Array.isArray(i) ? n.required = [.../* @__PURE__ */ new Set([...t.required, ...i])] : r === "properties" && t.properties && typeof i == "object" && i != null ? n.properties = { ...t.properties, ...i } : n[r] = i;
+  return n;
+}
+function oe(t, e) {
+  if (typeof t == "boolean" || typeof e == "boolean")
+    return t === e;
+  const n = t.type, r = e.type;
+  return !(n != null && r != null && n !== r || n === "string" && r === "string" && (t.minLength != null && e.maxLength != null && t.minLength > e.maxLength || t.maxLength != null && e.minLength != null && t.maxLength < e.minLength) || (n === "number" || n === "integer") && (r === "number" || r === "integer") && (t.minimum != null && e.maximum != null && t.minimum > e.maximum || t.maximum != null && e.minimum != null && t.maximum < e.minimum));
+}
+function ae(t, e, n, r) {
+  if (typeof e == "boolean" || typeof n == "boolean")
+    return {
+      path: r,
+      message: `Property "${t}" has conflicting boolean schema definitions in allOf branches`,
+      conflictingValues: [e, n]
+    };
+  const i = e.type, o = n.type;
+  if (i != null && o != null && i !== o) {
+    const s = Array.isArray(i) ? i : [i], a = Array.isArray(o) ? o : [o];
+    return {
+      path: r,
+      message: `Property "${t}" has conflicting types: ${s.join("|")} vs ${a.join("|")}`,
+      conflictingValues: [e, n]
+    };
+  }
+  if (i === o && i === "string") {
+    const s = [];
+    if (e.minLength != null && n.maxLength != null && e.minLength > n.maxLength && s.push(
+      `minLength ${e.minLength} > maxLength ${n.maxLength}`
+    ), e.maxLength != null && n.minLength != null && e.maxLength < n.minLength && s.push(
+      `maxLength ${e.maxLength} < minLength ${n.minLength}`
+    ), s.length > 0)
+      return {
+        path: r,
+        message: `Property "${t}" has conflicting string constraints: ${s.join(", ")}`,
+        conflictingValues: [e, n]
+      };
+  }
+  if (i === o && (i === "number" || i === "integer")) {
+    const s = [];
+    if (e.minimum != null && n.maximum != null && e.minimum > n.maximum && s.push(
+      `minimum ${e.minimum} > maximum ${n.maximum}`
+    ), e.maximum != null && n.minimum != null && e.maximum < n.minimum && s.push(
+      `maximum ${e.maximum} < minimum ${n.minimum}`
+    ), s.length > 0)
+      return {
+        path: r,
+        message: `Property "${t}" has conflicting numeric constraints: ${s.join(", ")}`,
+        conflictingValues: [e, n]
+      };
+  }
+  return oe(e, n) ? null : {
+    path: r,
+    message: `Property "${t}" has conflicting definitions in allOf branches`,
+    conflictingValues: [e, n]
+  };
+}
+function le(t) {
+  const e = Array.isArray(t) ? t : [t], n = new Set(
+    e.map((r) => r)
+  );
+  return n.has("number") && n.add("integer"), n;
+}
+function ce(t, e, n, r) {
+  for (const [i, o] of Object.entries(e)) {
+    if (t[i] != null && t[i] !== o) {
+      const s = t[i], a = ae(i, s, o, [
+        ...n,
+        "properties",
+        i
+      ]);
+      a != null && r.push(a);
+    }
+    t[i] != null ? t[i] = se(t[i], o) : t[i] = o;
+  }
+}
+function fe(t, e, n, r) {
+  e != null && t.additionalProperties != null && t.additionalProperties !== e && r.push({
+    path: [...n, "additionalProperties"],
+    message: `Conflicting additionalProperties values in allOf: ${t.additionalProperties} vs ${e}`,
+    conflictingValues: [t.additionalProperties, e]
+  });
+}
+function ue(t, e, n, r, i) {
+  e != null && t.maxProperties != null && e > t.maxProperties && i.push({
+    path: [...r, "minProperties"],
+    message: `minProperties ${e} conflicts with existing maxProperties ${t.maxProperties}`,
+    conflictingValues: [e, t.maxProperties]
+  }), n != null && t.minProperties != null && n < t.minProperties && i.push({
+    path: [...r, "maxProperties"],
+    message: `maxProperties ${n} conflicts with existing minProperties ${t.minProperties}`,
+    conflictingValues: [n, t.minProperties]
+  });
+}
+function de(t, e, n) {
+  if (t.length === 0)
+    return;
+  let r = null;
+  for (const o of t)
+    if (r == null)
+      r = new Set(o);
+    else {
+      const s = /* @__PURE__ */ new Set();
+      for (const a of r)
+        o.has(a) && s.add(a);
+      r = s;
+    }
+  const i = Array.from(r ?? []);
+  if (i.length === 0) {
+    const o = t.map((s) => Array.from(s));
+    n.push({
+      path: [...e, "type"],
+      message: "Incompatible types in allOf (no common types)",
+      conflictingValues: o
+    });
+    return;
+  } else return i.length === 1 ? i[0] : i;
+}
+function qe(t, e = []) {
+  const n = [], r = {}, i = [], o = [], s = {};
+  for (const l of t) {
+    l.type != null && i.push(le(l.type)), Array.isArray(l.required) && o.push(...l.required), l.properties != null && ce(
+      s,
+      l.properties,
+      e,
+      n
+    );
+    const {
+      type: u,
+      required: f,
+      properties: d,
+      allOf: p,
+      additionalProperties: m,
+      patternProperties: b,
+      minProperties: v,
+      maxProperties: j,
+      ...D
+    } = l;
+    fe(
+      r,
+      m,
+      e,
+      n
+    ), ue(
+      r,
+      v,
+      j,
+      e,
+      n
+    ), Object.assign(r, D), m != null && (r.additionalProperties = m), b != null && (r.patternProperties = b), v != null && (r.minProperties = v), j != null && (r.maxProperties = j);
+  }
+  const a = de(i, e, n);
+  return a != null && (r.type = a), o.length > 0 && (r.required = [...new Set(o)]), Object.keys(s).length > 0 && (r.properties = s), {
+    mergedSchema: r,
+    conflicts: n
+  };
+}
+class T {
+  schema;
+  definition;
+  horizontal;
+  path;
+  ajv;
+  isPropertyRequired;
+  suppressLabel;
+  schemaConflicts;
+  notViolations;
+  widgetRegistry;
+  /**
+   * Function to set the form's validation status.
+   * Available for custom widgets that need to perform their own validation.
+   */
+  setStatus;
+  /**
+   * Signal containing the entire form's current value.
+   * Useful for cross-field validation or conditional rendering.
+   */
+  formValue;
+  /**
+   * Current validation mode ('eager', 'onTouched', 'onSubmit').
+   * Custom widgets may want to behave differently based on this.
+   */
+  validationMode;
+  /**
+   * Signal indicating whether the form is currently submitting.
+   * Widgets should typically disable during submission.
+   */
+  submitting;
+  constructor(e) {
+    const {
+      schema: n,
+      definition: r,
+      horizontal: i,
+      path: o,
+      ajv: s,
+      isPropertyRequired: a,
+      suppressLabel: l,
+      schemaConflicts: u,
+      notViolations: f,
+      widgetRegistry: d,
+      setStatus: p,
+      formValue: m,
+      validationMode: b,
+      submitting: v
+    } = e;
+    this.schema = n, this.definition = r, this.horizontal = i, this.path = o, this.ajv = s, this.isPropertyRequired = a ?? !1, this.suppressLabel = l ?? !1, this.schemaConflicts = u ?? [], this.notViolations = f ?? [], this.widgetRegistry = d, this.setStatus = p, this.formValue = m, this.validationMode = b, this.submitting = v;
+  }
+  with = (e) => new T({
+    schema: e.schema ?? this.schema,
+    definition: e.definition ?? this.definition,
+    horizontal: e.horizontal ?? this.horizontal,
+    path: e.path ?? this.path,
+    ajv: e.ajv ?? this.ajv,
+    isPropertyRequired: e.isPropertyRequired ?? this.isPropertyRequired,
+    suppressLabel: e.suppressLabel ?? this.suppressLabel,
+    schemaConflicts: e.schemaConflicts ?? this.schemaConflicts,
+    notViolations: e.notViolations ?? this.notViolations,
+    widgetRegistry: e.widgetRegistry ?? this.widgetRegistry,
+    setStatus: e.setStatus ?? this.setStatus,
+    formValue: e.formValue ?? this.formValue,
+    validationMode: e.validationMode ?? this.validationMode,
+    submitting: e.submitting ?? this.submitting
+  });
+  append = (e) => this.with({ path: [...this.path, e] });
+  get isRoot() {
+    return this.path.length === 0;
+  }
+  get name() {
+    const e = this.path[this.path.length - 1];
+    if (typeof e == "string")
+      return e;
+  }
+  get widgetName() {
+    return this.path.map(String).join(".");
+  }
+  get widgetLabel() {
+    const e = this.name;
+    return (typeof this.definition == "object" && this.definition !== null ? this.definition.title : void 0) ?? (e != null ? B(W(e)) : void 0);
+  }
+  hasRequiredProperty = (e) => typeof this.definition == "boolean" ? !1 : this.definition.required != null && this.definition.required.includes(e);
+  get nullable() {
+    return this.definition.nullable ?? !1;
+  }
+  get isNullable() {
+    return this.nullable || this.hasType("null") || this.hasEnumValue(null) || this.hasConstValue(null) || (this.anyOf?.some((e) => e.isNullable) ?? !1) || (this.oneOf?.some((e) => e.isNullable) ?? !1);
+  }
+  /**
+   * Determines if this property is optional (can be absent from parent object).
+   * This is different from nullable - optional means the key can be missing,
+   * while nullable means the value can be explicitly null.
+   */
+  get isOptional() {
+    return !this.isPropertyRequired;
+  }
+  /**
+   * Determines if this property should show a presence toggle.
+   * Optional properties that are not at the root level should have presence toggles,
+   * but primitive values that allow null should use nullable controls instead.
+   */
+  get shouldShowPresenceToggle() {
+    return !(!this.isOptional || this.isRoot || (this.isNullable || this.isOptional) && this.isPrimitive);
+  }
+  /**
+   * Determines if this schema represents a primitive type (string, number, boolean, null).
+   */
+  get isPrimitive() {
+    if (typeof this.definition == "boolean")
+      return !1;
+    const e = this.definition;
+    if (e.const !== void 0 || e.enum !== void 0)
+      return !0;
+    if (e.type) {
+      const n = Array.isArray(e.type) ? e.type : [e.type], r = ["string", "number", "integer", "boolean"];
+      return n.every((i) => r.includes(i));
+    }
+    return !1;
+  }
+  /**
+   * Determines if this property is marked as readOnly.
+   */
+  get isReadOnly() {
+    return typeof this.definition == "boolean" ? !1 : !!this.definition.readOnly;
+  }
+  /**
+   * Determines if this property is marked as writeOnly.
+   */
+  get isWriteOnly() {
+    return typeof this.definition == "boolean" ? !1 : !!this.definition.writeOnly;
+  }
+  /**
+   * Determines if this property is marked as deprecated.
+   */
+  get isDeprecated() {
+    return typeof this.definition == "boolean" ? !1 : !!this.definition.deprecated;
+  }
+  /**
+   * Checks if readOnly should be ignored based on x:ui.ignoreReadOnly.
+   */
+  get shouldIgnoreReadOnly() {
+    if (typeof this.definition == "boolean") return !1;
+    const e = this.definition["x:ui"];
+    return e && typeof e == "object" ? !!e.ignoreReadOnly : !1;
+  }
+  /**
+   * Checks if writeOnly should be shown based on x:ui.showWriteOnly.
+   */
+  get shouldShowWriteOnly() {
+    if (typeof this.definition == "boolean") return !1;
+    const e = this.definition["x:ui"];
+    return e && typeof e == "object" ? !!e.showWriteOnly : !1;
+  }
+  get anyOf() {
+    if (typeof this.definition != "boolean")
+      return Array.isArray(this.definition.anyOf) ? this.definition.anyOf.map((e) => this.with({ definition: e })) : void 0;
+  }
+  get oneOf() {
+    if (typeof this.definition != "boolean")
+      return Array.isArray(this.definition.oneOf) ? this.definition.oneOf.map((e) => this.with({ definition: e })) : void 0;
+  }
+  get allOf() {
+    if (typeof this.definition != "boolean")
+      return Array.isArray(this.definition.allOf) ? this.definition.allOf.map((e) => this.with({ definition: e })) : void 0;
+  }
+  hasType = (e) => this.definition === !0 ? !0 : this.definition === !1 ? !1 : Array.isArray(this.definition.type) ? this.definition.type.includes(e) : this.definition.type === e;
+  hasEnumValue = (e) => typeof this.definition == "boolean" ? !1 : Array.isArray(this.definition.enum) ? this.definition.enum.includes(e) : !1;
+  hasConstValue = (e) => typeof this.definition == "boolean" ? !1 : this.definition.const === e;
+  get description() {
+    if (typeof this.definition != "boolean")
+      return this.definition.description;
+  }
+  get examples() {
+    if (typeof this.definition != "boolean")
+      return this.definition.examples;
+  }
+  get default() {
+    if (typeof this.definition != "boolean")
+      return this.definition.default;
+  }
+}
+let S = /* @__PURE__ */ new WeakMap(), P = /* @__PURE__ */ new WeakMap();
+function he(t, e) {
+  const n = typeof e == "object" && e != null ? e : null;
+  if (n != null) {
+    const s = S.get(n)?.get(t);
+    if (s != null) return s;
+  }
+  let r = t;
+  const i = /* @__PURE__ */ new Set();
+  for (; q(r); ) {
+    const o = r.$ref;
+    if (!o.startsWith("#")) {
+      console.warn(`resolveRef: external $ref not supported here: ${o}`);
+      break;
+    }
+    if (i.has(o)) {
+      console.warn(
+        `resolveRef: cycle detected while resolving in-document $ref chain: ${[...i, o].join(" -> ")}`
+      );
+      break;
+    }
+    i.add(o);
+    const s = I(e, o);
+    if (!O(s)) {
+      console.warn(`resolveRef: could not resolve JSON Pointer ${o}`);
+      break;
+    }
+    const { $ref: a, ...l } = r;
+    r = { ...s, ...l };
+  }
+  if (n != null) {
+    let o = S.get(n);
+    o == null && (o = /* @__PURE__ */ new WeakMap(), S.set(n, o)), o.set(t, r);
+  }
+  return r;
+}
+function q(t) {
+  return O(t) && typeof t.$ref == "string";
+}
+function O(t) {
+  return typeof t == "object" && t != null && !Array.isArray(t);
+}
+function I(t, e) {
+  if (!e.startsWith("#")) return;
+  if (e === "#") return t;
+  if (typeof t != "object" || t == null) return;
+  const n = t;
+  let r = P.get(n);
+  r == null && (r = /* @__PURE__ */ new Map(), P.set(n, r));
+  const i = r.get(e);
+  if (i !== void 0) return i;
+  const o = M(e);
+  let s = t;
+  for (const a of o) {
+    if (!O(s) && !Array.isArray(s)) {
+      r.set(e, void 0);
+      return;
+    }
+    s = s[a];
+  }
+  return r.set(e, s), s;
+}
+function Ie(t, e, n) {
+  let r = t;
+  const i = /* @__PURE__ */ new Set(), o = (s, a) => {
+    const { $ref: l, ...u } = a;
+    return { ...s, ...u };
+  };
+  for (; q(r); ) {
+    const s = r.$ref;
+    if (i.has(s)) {
+      console.warn(
+        `resolveAnyRef: cycle detected while resolving $ref chain: ${[...i, s].join(" -> ")}`
+      );
+      break;
+    }
+    if (i.add(s), s.startsWith("#")) {
+      const d = I(e, s);
+      if (!O(d)) {
+        console.warn(`resolveAnyRef: could not resolve JSON Pointer ${s}`);
+        break;
+      }
+      r = o(d, r);
+      continue;
+    }
+    if (!n) {
+      console.warn(
+        `resolveAnyRef: external $ref without AJV not resolved: ${s}`
+      );
+      break;
+    }
+    const a = s.indexOf("#"), l = a >= 0 ? s.slice(0, a) : s;
+    let u = n.getSchema(s) || n.getSchema(l);
+    if (!u)
+      try {
+        u = n.compile({ $ref: s });
+      } catch {
+      }
+    const f = u?.schema;
+    if (!f || typeof f != "object") {
+      console.warn(`resolveAnyRef: AJV could not provide schema for ${s}`);
+      break;
+    }
+    r = o(f, r);
+  }
+  return r;
+}
+function De(t) {
+  if (typeof t.definition == "boolean") return;
+  const e = H(t.definition);
+  if (typeof e != "object") return;
+  const n = {};
+  return typeof e.format == "string" && ["fieldset", "tabs", "accordion", "group", "grid"].includes(e.format) && (n.format = e.format), Array.isArray(e.order) && (n.order = e.order.filter(
+    (r) => typeof r == "string"
+  )), e.groups && typeof e.groups == "object" && (n.groups = e.groups), (typeof e.cols == "number" || e.cols && typeof e.cols == "object") && (n.cols = e.cols), Object.keys(n).length > 0 ? n : void 0;
+}
+function pe({
+  title: t,
+  children: e
+}) {
+  return h.fieldset(
+    c.class("bc-fieldset"),
+    t ? h.legend(c.class("bc-fieldset__legend"), t) : null,
+    h.div(
+      c.class("bc-fieldset__content"),
+      y(c.class("bc-stack--gap-1"), ...e)
+    )
+  );
+}
+function me({
+  title: t,
+  children: e
+}) {
+  return J(
+    { variant: "outlined", size: "md" },
+    y(
+      c.class("bc-stack--gap-1"),
+      t ? K(t) : null,
+      ...e
+    )
+  );
+}
+function ye({
+  cols: t = 1,
+  children: e
+}) {
+  const n = typeof t == "number" ? `bc-schema-grid bc-schema-grid--cols-${t}` : g(t)((r) => {
+    if (typeof r == "number")
+      return `bc-schema-grid bc-schema-grid--cols-${r}`;
+    if (r && typeof r == "object") {
+      const i = ["bc-schema-grid"];
+      return r.sm && i.push(`bc-schema-grid--cols-sm-${r.sm}`), r.md && i.push(`bc-schema-grid--cols-md-${r.md}`), r.lg && i.push(`bc-schema-grid--cols-lg-${r.lg}`), r.xl && i.push(`bc-schema-grid--cols-xl-${r.xl}`), r["2xl"] && i.push(`bc-schema-grid--cols-2xl-${r["2xl"]}`), i.join(" ");
+    }
+    return "bc-schema-grid bc-schema-grid--cols-1";
+  });
+  return h.div(
+    c.class(n),
+    c.class("bc-schema-grid--gap-4"),
+    ...e
+  );
+}
+function be({
+  groups: t,
+  children: e
+}) {
+  if (!t || Object.keys(t).length === 0)
+    return ge({ title: V.properties, children: e });
+  const n = _(Object.keys(t)[0]), r = Object.entries(t);
+  return h.div(
+    c.class("bc-tabs"),
+    // Tab headers
+    h.div(
+      c.class("bc-tabs__header"),
+      c.role("tablist"),
+      ...r.map(
+        ([i], o) => h.button(
+          c.type("button"),
+          c.class("bc-tabs__tab"),
+          c.class(
+            g(n)(
+              (s) => s === i ? "bc-tabs__tab--active" : ""
+            )
+          ),
+          c.role("tab"),
+          c.tabindex(
+            n.map((s) => s === i ? 0 : -1)
+          ),
+          w.click(() => n.set(i)),
+          w.keydown((s) => {
+            switch (s.key) {
+              case "ArrowLeft":
+                s.preventDefault();
+                const a = o > 0 ? o - 1 : r.length - 1;
+                n.set(r[a][0]);
+                break;
+              case "ArrowRight":
+                s.preventDefault();
+                const l = o < r.length - 1 ? o + 1 : 0;
+                n.set(r[l][0]);
+                break;
+              case "Home":
+                s.preventDefault(), n.set(r[0][0]);
+                break;
+              case "End":
+                s.preventDefault(), n.set(r[r.length - 1][0]);
+                break;
+            }
+          }),
+          i
+        )
+      )
+    ),
+    // Tab content
+    h.div(
+      c.class("bc-tabs__content"),
+      ...r.map(
+        ([i, o]) => h.div(
+          c.class("bc-tabs__panel"),
+          c.class(
+            g(n)(
+              (s) => s === i ? "bc-tabs__panel--active" : "bc-tabs__panel--hidden"
+            )
+          ),
+          c.role("tabpanel"),
+          y(
+            c.class("bc-stack--gap-1"),
+            ...e.filter((s, a) => o.length === 0 || a < o.length)
+          )
+        )
+      )
+    )
+  );
+}
+function ge({
+  title: t,
+  children: e
+}) {
+  return h.div(
+    c.class("bc-tabs"),
+    h.div(
+      c.class("bc-tabs__header"),
+      h.div(c.class("bc-tabs__tab bc-tabs__tab--active"), t)
+    ),
+    h.div(
+      c.class("bc-tabs__content"),
+      h.div(
+        c.class("bc-tabs__panel bc-tabs__panel--active"),
+        y(c.class("bc-stack--gap-1"), ...e)
+      )
+    )
+  );
+}
+function ve({
+  groups: t,
+  children: e
+}) {
+  if (!t || Object.keys(t).length === 0)
+    return we({
+      title: V.properties,
+      children: e
+    });
+  const n = Object.entries(t), r = _(new Set([n[0]?.[0]].filter(Boolean)));
+  return h.div(
+    c.class("bc-accordion"),
+    ...n.map(([i, o]) => {
+      const s = g(r)(
+        (a) => a.has(i)
+      );
+      return h.div(
+        c.class("bc-accordion__item"),
+        h.button(
+          c.type("button"),
+          c.class("bc-accordion__header"),
+          F.expanded(s),
+          w.click(() => {
+            const a = r.value, l = new Set(a);
+            l.has(i) ? l.delete(i) : l.add(i), r.set(l);
+          }),
+          w.keydown((a) => {
+            if (a.key === "Enter" || a.key === " ") {
+              a.preventDefault();
+              const l = r.value, u = new Set(l);
+              u.has(i) ? u.delete(i) : u.add(i), r.set(u);
+            }
+          }),
+          h.span(i),
+          x({
+            icon: g(s)(
+              (a) => a ? "chevron-up" : "chevron-down"
+            ),
+            size: "sm"
+          })
+        ),
+        h.div(
+          c.class("bc-accordion__content"),
+          c.class(
+            g(s)(
+              (a) => a ? "bc-accordion__content--open" : "bc-accordion__content--closed"
+            )
+          ),
+          y(
+            c.class("bc-stack--gap-1"),
+            ...e.filter((a, l) => o.length === 0 || l < o.length)
+          )
+        )
+      );
+    })
+  );
+}
+function we({
+  title: t,
+  children: e
+}) {
+  const n = _(!0);
+  return h.div(
+    c.class("bc-accordion"),
+    h.div(
+      c.class("bc-accordion__item"),
+      h.button(
+        c.type("button"),
+        c.class("bc-accordion__header"),
+        w.click(() => n.set(!n.value)),
+        h.span(t),
+        x({
+          icon: g(n)(
+            (r) => r ? "chevron-up" : "chevron-down"
+          ),
+          size: "sm"
+        })
+      ),
+      h.div(
+        c.class("bc-accordion__content"),
+        c.class(
+          g(n)(
+            (r) => r ? "bc-accordion__content--open" : "bc-accordion__content--closed"
+          )
+        ),
+        y(c.class("bc-stack--gap-1"), ...e)
+      )
+    )
+  );
+}
+function C(t, e, n) {
+  const r = /* @__PURE__ */ new Map();
+  n.forEach((s, a) => {
+    t[a] && r.set(s, t[a]);
+  });
+  let i = t;
+  if (e.order && e.order.length > 0) {
+    const s = /* @__PURE__ */ new Map(), a = [];
+    e.order.forEach((l) => {
+      const u = r.get(l);
+      u && s.set(l, u);
+    }), n.forEach((l, u) => {
+      !e.order.includes(l) && t[u] && a.push(t[u]);
+    }), i = [...Array.from(s.values()), ...a];
+  }
+  let o;
+  if (e.groups && Object.keys(e.groups).length > 0) {
+    o = {};
+    const s = /* @__PURE__ */ new Set();
+    Object.entries(e.groups).forEach(([l, u]) => {
+      o[l] = [], u.forEach((f) => {
+        const d = r.get(f);
+        d && (o[l].push(d), s.add(d));
+      });
+    });
+    const a = i.filter(
+      (l) => !s.has(l)
+    );
+    a.length > 0 && (o.Other = a);
+  }
+  return { orderedChildren: i, groupedChildren: o };
+}
+function ze(t, e, n, r = []) {
+  if (!t || !t.format) {
+    if (t?.order) {
+      const { orderedChildren: a } = C(
+        n,
+        t,
+        r
+      );
+      return y(c.class("bc-stack--gap-1"), ...a);
+    }
+    return y(c.class("bc-stack--gap-1"), ...n);
+  }
+  const i = e.widgetLabel || e.name, { orderedChildren: o, groupedChildren: s } = C(
+    n,
+    t,
+    r
+  );
+  switch (t.format) {
+    case "fieldset":
+      return pe({ title: i, children: o });
+    case "group":
+      return me({ title: i, children: o });
+    case "grid":
+      return ye({ cols: t.cols, children: o });
+    case "tabs":
+      return be({
+        groups: s || t.groups,
+        children: s ? Object.values(s).flat() : o
+      });
+    case "accordion":
+      return ve({
+        groups: s || t.groups,
+        children: s ? Object.values(s).flat() : o
+      });
+    default:
+      return y(c.class("bc-stack--gap-1"), ...o);
+  }
+}
+function Ae(t, e, n) {
+  const i = t.definition.oneOf;
+  if (!Array.isArray(i) || i.length === 0)
+    return {
+      matchingBranch: -1,
+      validBranches: [],
+      isAmbiguous: !1,
+      hasNoMatch: !0
+    };
+  const o = i.map((f) => {
+    if (typeof f == "object" && f != null && "$ref" in f) {
+      const d = f.$ref;
+      if (typeof d == "string" && d.startsWith("#"))
+        return he(f, t.schema);
+    }
+    return f;
+  }), s = [];
+  for (let f = 0; f < o.length; f++) {
+    const d = o[f];
+    if (typeof d == "boolean") {
+      d === !0 && s.push(f);
+      continue;
+    }
+    if (n)
+      try {
+        te(n, d)(e) && s.push(f);
+      } catch (p) {
+        console.warn(`Failed to compile oneOf branch ${f}:`, p), L(d, e) && s.push(f);
+      }
+    else
+      L(d, e) && s.push(f);
+  }
+  const a = s.length > 1, l = s.length === 0;
+  return {
+    matchingBranch: s.length === 1 ? s[0] : -1,
+    validBranches: s,
+    isAmbiguous: a,
+    hasNoMatch: l
+  };
+}
+function L(t, e) {
+  if ("const" in t)
+    return t.const === e;
+  if (Array.isArray(t.enum))
+    return t.enum.includes(e);
+  if (t.type != null) {
+    const n = Array.isArray(t.type) ? t.type : [t.type], r = Oe(e);
+    if (r === "unknown" || !n.includes(r))
+      return !1;
+  }
+  if (t.properties && typeof e == "object" && e != null) {
+    const n = e;
+    for (const [r, i] of Object.entries(t.properties))
+      if (typeof i == "object" && i != null && "const" in i && n[r] !== i.const)
+        return !1;
+  }
+  return !0;
+}
+function Oe(t) {
+  return t === null ? "null" : Array.isArray(t) ? "array" : typeof t == "object" ? "object" : typeof t == "string" ? "string" : typeof t == "number" ? Number.isInteger(t) ? "integer" : "number" : typeof t == "boolean" ? "boolean" : "unknown";
+}
+function Be(t, e, n = `Option ${e + 1}`) {
+  if (typeof t == "boolean")
+    return t ? "Any Value" : "No Value";
+  if (t.title)
+    return t.title;
+  if (t.properties) {
+    for (const [r, i] of Object.entries(t.properties))
+      if (typeof i == "object" && i != null && "const" in i) {
+        const o = i.const;
+        if (typeof o == "string")
+          return `${r}: ${o}`;
+      }
+  }
+  return "const" in t && typeof t.const == "string" ? t.const : t.type ? (Array.isArray(t.type) ? t.type : [t.type]).join(" | ") : n;
+}
+function We(t, e, n) {
+  const r = Ae(t, e, n);
+  return r.matchingBranch !== -1 ? r.matchingBranch : -1;
+}
+export {
+  T as S,
+  ze as a,
+  he as b,
+  te as c,
+  Ae as d,
+  Be as e,
+  We as f,
+  De as g,
+  Ve as h,
+  Te as i,
+  N as j,
+  Z as k,
+  Y as l,
+  qe as m,
+  xe as n,
+  Me as o,
+  Ee as p,
+  M as q,
+  Ie as r
+};