@overmap-ai/forms 1.0.0

package/dist/forms.js

@@ -0,0 +1,1786 @@
+var Et = Object.defineProperty;
+var zt = (o, i, e) => i in o ? Et(o, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[i] = e;
+var p = (o, i, e) => (zt(o, typeof i != "symbol" ? i + "" : i, e), e);
+import { jsx as r, jsxs as b, Fragment as ot } from "react/jsx-runtime";
+import { Flex as v, Text as k, useSeverityColor as pe, Checkbox as Lt, CheckCircledIcon as Pt, TextField as oe, FontFamilyIcon as At, CalendarIcon as Dt, InputIcon as kt, TextArea as Mt, RowsIcon as Ot, Select as st, Box as ge, IconButton as ce, PlusIcon as Se, Badge as _e, Cross1Icon as Vt, ListBulletIcon as _t, DropdownMenuIcon as $t, MultiSelect as Rt, CheckboxIcon as qt, Card as Ee, Heading as ze, Button as G, ButtonList as Le, divButtonProps as Nt, StarFilledIcon as Bt, StarIcon as Wt, QuestionMarkCircledIcon as jt, PersonIcon as Ht, Tooltip as Ut, Avatar as Gt, Separator as Kt, Dialog as Yt, Pencil1Icon as Qt, TrashIcon as Xt, DragHandleDots2Icon as Jt, DropdownMenu as Zt, DotsVerticalIcon as ei, useAlertDialog as ti, Em as ii, Strong as Ze, useToast as ni, Tabs as Q } from "@overmap-ai/blocks";
+import { useField as We, useFormikContext as ae, useFormik as je, FormikProvider as He } from "formik";
+import ri, { useMemo as T, memo as z, useCallback as E, useState as de, useEffect as Pe, forwardRef as me, useReducer as oi } from "react";
+import { DragDropContext as lt, Droppable as Ue, Draggable as Ge } from "@hello-pangea/dnd";
+import { slugify as at, useAppSelector as $, selectFormRevision as ct, useSDK as si, selectFilteredUserForms as li, selectUserFormMapping as ai, selectOrganization as dt, selectUser as Ke, selectNumberOfUserForms as ci, selectCurrentUser as ut, classNames as ft, isToday as di, getLocalDateString as ui, selectLatestFormRevision as fi, useFileSrc as hi, selectSubmissionsForForm as pi } from "@overmap-ai/core";
+import se from "lodash.get";
+import Ye from "lodash.set";
+class ht {
+  constructor(i) {
+    p(this, "type");
+    p(this, "identifier");
+    p(this, "description");
+    const { description: e = null, identifier: t, type: n } = i;
+    this.identifier = t, this.description = e, this.type = n;
+  }
+  getId() {
+    return this.identifier;
+  }
+  static deserialize(i) {
+    throw new Error(`${this.name} must implement deserialize.`);
+  }
+  _serialize() {
+    if (!this.identifier)
+      throw new Error("Field identifier must be set before serializing.");
+    return {
+      type: this.type,
+      identifier: this.identifier,
+      description: this.description
+    };
+  }
+}
+class R extends ht {
+  constructor(e) {
+    const { label: t, required: n, fieldValidators: s = [], formValidators: a = [], ...l } = e;
+    super(l);
+    p(this, "required");
+    p(this, "formValidators");
+    p(this, "fieldValidators");
+    p(this, "label");
+    this.label = t, this.required = n, this.fieldValidators = s, this.formValidators = a;
+  }
+  static getFieldCreationSchema() {
+    return [];
+  }
+  isBlank(e) {
+    return e == null || e === "";
+  }
+  getError(e, t) {
+    if (this.required && this.isBlank(e))
+      return "This field is required.";
+    for (const n of this.getFieldValidators()) {
+      const s = n(e);
+      if (s)
+        return s;
+    }
+    if (t)
+      for (const n of this.getFormValidators()) {
+        const s = n(e, t);
+        if (s)
+          return s;
+      }
+  }
+  // TODO: We can probably combine _serialize and serialize.
+  _serialize() {
+    return {
+      ...super._serialize(),
+      label: this.label,
+      required: this.required
+    };
+  }
+  getFieldValidators() {
+    return [...this.fieldValidators];
+  }
+  getFormValidators() {
+    return [...this.formValidators];
+  }
+}
+p(R, "fieldTypeName"), p(R, "fieldTypeDescription");
+const mi = "_description_17zed_1", Ae = {
+  description: mi
+}, W = (o) => {
+  const { label: i, children: e, severity: t, inputId: n, labelId: s, flexProps: a } = o;
+  return /* @__PURE__ */ r(v, { direction: "column", gap: "1", asChild: !0, ...a, children: /* @__PURE__ */ b("label", { htmlFor: n, children: [
+    /* @__PURE__ */ r(k, { severity: t, id: s, children: i }),
+    e
+  ] }) });
+}, j = (o) => {
+  const { helpText: i, children: e, severity: t } = o;
+  return /* @__PURE__ */ b(v, { direction: "column", gap: "1", children: [
+    e,
+    /* @__PURE__ */ r(v, { direction: "column", children: /* @__PURE__ */ r(k, { size: "1", severity: t, className: Ae.description, children: i }) })
+  ] });
+}, H = (o) => {
+  const { id: i, field: e, formId: t, ...n } = o, [s, a, l] = We(e.getId()), { touched: c } = a, f = a.error ?? e.description, u = a.error ? "danger" : void 0, d = i ?? `${t}-${e.getId()}-input`, h = `${d}-label`, m = e.required ? `${e.label} *` : e.label, g = T(() => ({
+    ...s,
+    onChange: (w) => {
+      l.setValue(w.target.value, !1).then(), c && l.setError(e.getError(w.target.value));
+    },
+    onBlur: (w) => {
+      l.setTouched(!0, !1).then(), l.setError(e.getError(w.target.value));
+    }
+  }), [e, s, l, c]);
+  return [
+    {
+      helpText: f,
+      severity: u,
+      inputId: d,
+      labelId: h,
+      label: m,
+      fieldProps: g,
+      helpers: l,
+      field: e
+    },
+    { ...n, "aria-labelledby": h }
+  ];
+}, gi = [!0, "true"], bi = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, field: a, label: l, fieldProps: c, helpers: f }, u] = H(i), d = pe(n), { setValue: h, setTouched: m, setError: g } = f, y = gi.includes(c.value), I = E(
+    (w) => {
+      if (w === "indeterminate")
+        throw new Error("indeterminate CheckedState value is not supported");
+      h(w, !1).then(), m(!0, !1).then(), g(a.getError(w));
+    },
+    [h, m, g, a]
+  );
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(
+    W,
+    {
+      severity: n,
+      inputId: e,
+      labelId: t,
+      label: l,
+      flexProps: { direction: "row-reverse", justify: "end", align: "center", gap: "2" },
+      children: /* @__PURE__ */ r(
+        Lt,
+        {
+          ...u,
+          ...c,
+          id: e,
+          color: d,
+          value: y.toString(),
+          checked: y,
+          onCheckedChange: I,
+          onChange: void 0,
+          onBlur: void 0
+        }
+      )
+    }
+  ) });
+}), X = class X extends R {
+  constructor(i) {
+    super({ ...i, type: "boolean" });
+  }
+  // if a BooleanField is required, `false` is considered blank
+  isBlank(i) {
+    return this.required && !i;
+  }
+  serialize() {
+    return super._serialize();
+  }
+  static deserialize(i) {
+    if (i.type !== "boolean")
+      throw new Error("Type mismatch.");
+    return new X(i);
+  }
+  getInput(i) {
+    return /* @__PURE__ */ r(bi, { ...i, field: this });
+  }
+};
+p(X, "fieldTypeName", "Checkbox"), p(X, "fieldTypeDescription", "Perfect for both optional and required yes/no questions."), p(X, "Icon", Pt);
+let le = X;
+const yi = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l, field: c }, f] = H(i), u = pe(n);
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(
+    oe.Input,
+    {
+      ...f,
+      ...l,
+      type: "number",
+      id: e,
+      min: c.minimum,
+      max: c.maximum,
+      step: c.integers ? 1 : 0.1,
+      color: u
+    }
+  ) }) });
+}), q = class q extends R {
+  constructor(e) {
+    const {
+      minimum: t = Number.MIN_SAFE_INTEGER,
+      maximum: n = Number.MAX_SAFE_INTEGER,
+      integers: s = !1,
+      ...a
+    } = e;
+    super({ ...a, type: "number" });
+    p(this, "minimum");
+    p(this, "maximum");
+    p(this, "integers");
+    this.minimum = t, this.maximum = n, this.integers = s;
+  }
+  static getFieldCreationSchema() {
+    return [
+      new q({
+        label: "Minimum",
+        description: "Minimum value",
+        integers: !0,
+        required: !1,
+        identifier: "minimum",
+        formValidators: [this._validateMin]
+      }),
+      new q({
+        label: "Maximum",
+        description: "Maximum value",
+        integers: !0,
+        required: !1,
+        identifier: "maximum",
+        formValidators: [this._validateMax]
+      }),
+      new le({
+        label: "Integers",
+        description: "Whole numbers only",
+        required: !1,
+        identifier: "integers"
+      })
+    ];
+  }
+  getFieldValidators() {
+    const e = super.getFieldValidators(), t = this.minimum, n = this.maximum;
+    return typeof t == "number" && e.push((s) => {
+      if (typeof s == "number" && s < t)
+        return `Must be at least ${this.minimum}.`;
+    }), typeof n == "number" && e.push((s) => {
+      if (typeof s == "number" && s > n)
+        return `Must be at most ${this.maximum}.`;
+    }), this.integers && e.push((s) => {
+      if (typeof s == "number" && !Number.isInteger(s))
+        return "Must be a whole number.";
+    }), e;
+  }
+  serialize() {
+    return {
+      ...super._serialize(),
+      minimum: this.minimum,
+      maximum: this.maximum,
+      integers: this.integers
+    };
+  }
+  static deserialize(e) {
+    if (e.type !== "number")
+      throw new Error("Type mismatch.");
+    return new q(e);
+  }
+  getInput(e) {
+    return /* @__PURE__ */ r(yi, { field: this, ...e });
+  }
+};
+p(q, "fieldTypeName", "Number"), p(q, "fieldTypeDescription", "Allows specifying a number within a given range."), p(q, "Icon", At), p(q, "_validateMin", (e, t) => typeof t.maximum == "number" && typeof e == "number" && t.maximum < e ? "Minimum cannot be greater than minimum." : null), p(q, "_validateMax", (e, t) => typeof t.minimum == "number" && typeof e == "number" && t.minimum > e ? "Maximum cannot be less than minimum." : null);
+let ue = q;
+const vi = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, field: l, fieldProps: c, helpers: f }, u] = H(i), d = pe(n), { setValue: h, setError: m } = f, g = c.value ? c.value.split("T")[0] : "", y = E(
+    (I) => {
+      const w = new Date(I.target.value).toISOString();
+      h(w, !1).then(), m(l.getError(w));
+    },
+    [l, m, h]
+  );
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(
+    oe.Input,
+    {
+      ...u,
+      ...c,
+      type: "date",
+      id: e,
+      color: d,
+      value: g,
+      onChange: y
+    }
+  ) }) });
+}), J = class J extends R {
+  constructor(i) {
+    super({ ...i, type: "date" });
+  }
+  serialize() {
+    return super._serialize();
+  }
+  static deserialize(i) {
+    if (i.type !== "date")
+      throw new Error("Type mismatch.");
+    return new J(i);
+  }
+  getInput(i) {
+    return /* @__PURE__ */ r(vi, { field: this, ...i });
+  }
+};
+p(J, "fieldTypeName", "Date"), p(J, "fieldTypeDescription", "Allows specifying a date."), p(J, "Icon", Dt);
+let $e = J;
+class be extends R {
+  constructor(e) {
+    const { minLength: t, maxLength: n = 5e3, ...s } = e;
+    super(s);
+    p(this, "minLength");
+    p(this, "maxLength");
+    this.minLength = t ? Math.max(t, 0) : void 0, this.maxLength = n ? Math.max(n, 0) : 5e3;
+  }
+  static getFieldCreationSchema() {
+    return [
+      // min, max
+      new ue({
+        label: "Minimum length",
+        description: "Minimum number of characters",
+        required: !1,
+        identifier: "minimum_length",
+        minimum: 0,
+        maximum: 100,
+        formValidators: [this._validateMin],
+        integers: !0
+      }),
+      new ue({
+        label: "Maximum length",
+        description: "Maximum number of characters",
+        required: !1,
+        identifier: "maximum_length",
+        minimum: 1,
+        maximum: 5e3,
+        // TODO: depends on short vs long text
+        formValidators: [this._validateMax],
+        // TODO: default: 500 (see: "Short text fields can hold up to 500 characters on a single line.")
+        integers: !0
+      })
+    ];
+  }
+  getFieldValidators() {
+    const e = super.getFieldValidators();
+    return this.minLength && e.push((t) => {
+      if (this.minLength && (!t || t.length < this.minLength))
+        return !this.required && !t ? null : `Minimum ${this.minLength} character(s).`;
+    }), this.maxLength && e.push((t) => {
+      if (typeof t == "string" && this.maxLength && t.length > this.maxLength)
+        return `Maximum ${this.maxLength} character(s).`;
+    }), e;
+  }
+  _serialize() {
+    if (!this.identifier)
+      throw new Error("Field identifier must be set before serializing.");
+    return {
+      ...super._serialize(),
+      minimum_length: this.minLength,
+      maximum_length: this.maxLength
+    };
+  }
+}
+/**
+ * This function validates that the value given for "minimum length" (when creating a new field) is less than or
+ * equal to the value given for "maximum length".
+ */
+p(be, "_validateMin", (e, t) => typeof t.maximum_length == "number" && typeof e == "number" && t.maximum_length < e ? "Minimum cannot be greater than maximum." : null), /**
+ * This function validates that the value given for "maximum length" (when creating a new field) is greater than or
+ * equal to the value given for "minimum length".
+ */
+p(be, "_validateMax", (e, t) => {
+  if (typeof e != "number")
+    return null;
+  const { minimum_length: n } = t;
+  return typeof n != "number" ? null : n > e ? "Maximum cannot be less than minimum." : null;
+});
+const wi = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l, field: c }, f] = H(i), u = pe(n);
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(oe.Input, { ...f, ...l, type: c.inputType, id: e, color: u }) }) });
+}), Z = class Z extends be {
+  constructor(e) {
+    const { inputType: t = "text", ...n } = e, s = e.maxLength ? Math.min(500, e.maxLength) : 500, a = e.minLength ? Math.min(e.minLength, s) : void 0;
+    super({ ...n, maxLength: s, minLength: a, type: "string" });
+    p(this, "inputType");
+    this.inputType = t;
+  }
+  serialize() {
+    return { ...super._serialize(), input_type: this.inputType };
+  }
+  static deserialize(e) {
+    if (e.type !== "string")
+      throw new Error("Type mismatch.");
+    const { maximum_length: t, minimum_length: n, input_type: s, ...a } = e;
+    return new Z({ ...a, maxLength: t, minLength: n, inputType: s });
+  }
+  getInput(e) {
+    return /* @__PURE__ */ r(wi, { field: this, ...e });
+  }
+};
+p(Z, "fieldTypeName", "Short Text"), p(Z, "fieldTypeDescription", "Short text fields can hold up to 500 characters on a single line."), p(Z, "Icon", kt);
+let fe = Z;
+const Ii = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l }, c] = H(i);
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(Mt, { ...c, ...l, resize: "vertical", id: e, severity: n }) }) });
+}), ee = class ee extends be {
+  constructor(i) {
+    const e = i.maxLength ? Math.min(5e3, i.maxLength) : 5e3, t = i.minLength ? Math.min(i.minLength, e) : void 0;
+    super({ ...i, maxLength: e, minLength: t, type: "text" });
+  }
+  serialize() {
+    return super._serialize();
+  }
+  static deserialize(i) {
+    if (i.type !== "text")
+      throw new Error("Type mismatch.");
+    const { maximum_length: e, minimum_length: t, ...n } = i;
+    return new ee({ ...n, maxLength: e, minLength: t });
+  }
+  getInput(i) {
+    return /* @__PURE__ */ r(Ii, { field: this, ...i });
+  }
+};
+p(ee, "fieldTypeName", "Paragraph"), p(ee, "fieldTypeDescription", "Paragraph fields can hold up to 5000 characters and can have multiple lines."), p(ee, "Icon", Ot);
+let he = ee;
+const xi = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l, field: c, helpers: f }, u] = H(i), { setValue: d, setTouched: h, setError: m } = f, g = T(
+    () => c.options.map((I) => ({ value: I.value, itemContent: I.label })),
+    [c.options]
+  ), y = E(
+    (I) => {
+      d(I, !1).then(), h(!0, !1).then(), m(c.getError(I));
+    },
+    [h, d, m, c]
+  );
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(
+    st,
+    {
+      items: g,
+      ...l,
+      onValueChange: y,
+      placeholder: "Select one...",
+      id: e,
+      severity: n,
+      ...u
+    }
+  ) }) });
+}), ye = (o = "", i = []) => ({
+  type: "section",
+  fields: i,
+  identifier: o,
+  label: null,
+  condition: null,
+  conditional: !1
+}), Ci = (o) => {
+  if (!o)
+    return;
+  const i = o.fields;
+  let e = [];
+  const t = [];
+  for (const n of i)
+    n.type === "section" ? (e.length > 0 && (t.push(ye(`AUTO_section-${i.indexOf(n)}`, e)), e = []), t.push(n)) : e.push(n);
+  return e.length > 0 && t.push(ye("AUTO_section-last", e)), { ...o, fields: t };
+};
+function Re(o, i, e) {
+  const t = Array.from(o), [n] = t.splice(i, 1);
+  if (!n)
+    throw new Error("Could not find field to reorder.");
+  return t.splice(e, 0, n), t;
+}
+function Ti(o, i, e) {
+  const t = Array.from(o);
+  return t[i] = e, t;
+}
+function pt(o, i, e) {
+  const t = Array.from(o ?? []);
+  return t.splice(i, 0, e), t;
+}
+function ve(o, i) {
+  const e = Array.from(o);
+  return e.splice(i, 1), e;
+}
+const Fi = (o, i) => typeof o == "string" && o.length > 0 ? o : at(i), mt = (o, i) => {
+  if (!i)
+    return null;
+  for (const e of o)
+    if (e.type === "section") {
+      const t = mt(e.fields, i);
+      if (t)
+        return t;
+    } else if (e.identifier === i)
+      return e;
+  return null;
+}, qe = (o, i) => o.filter((e, t) => t < i).flatMap((e) => e.fields), Si = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l, field: c, helpers: f }, u] = H(i), d = pe(n), h = T(() => Array.isArray(l.value) ? l.value : [], [l.value]), { setValue: m, setTouched: g, setError: y } = f, I = `${e}-droppable`, { disabled: w } = u, [x, P] = de(""), [A, L] = de(""), O = A || s, B = A ? "red" : d, V = E(
+    (S) => {
+      m(S, !1).then(), g(!0, !1).then(), y(c.getError(S));
+    },
+    [m, g, y, c]
+  ), F = E(
+    (S) => {
+      h.findIndex((_) => _.value === S.target.value.trim()) >= 0 ? L("All options must be unique") : S.target.value ? L("") : L("Option cannot be empty"), P(S.target.value);
+    },
+    [P, h]
+  ), C = E(() => {
+    if (A)
+      return;
+    if (!x.trim())
+      return L("Option cannot be empty");
+    const S = x.trim();
+    V([...h, { value: S, label: S }]), P("");
+  }, [x, A, V, h]), M = E(
+    (S) => {
+      S.key === "Enter" && (S.preventDefault(), C());
+    },
+    [C]
+  ), D = E(
+    (S) => {
+      V(ve(h, S));
+    },
+    [h, V]
+  ), N = E(
+    (S) => {
+      if (!S.destination)
+        return;
+      const _ = S.source.index, U = S.destination.index;
+      V(Re(h, _, U));
+    },
+    [V, h]
+  );
+  return /* @__PURE__ */ r(lt, { onDragEnd: N, children: /* @__PURE__ */ b(v, { direction: "column", gap: "2", children: [
+    /* @__PURE__ */ r(j, { helpText: O, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: (!w || h.length === 0) && /* @__PURE__ */ b(v, { gap: "2", children: [
+      /* @__PURE__ */ r(ge, { grow: "1", children: /* @__PURE__ */ r(
+        oe.Input,
+        {
+          placeholder: "Press enter to add a new option",
+          ...u,
+          ...l,
+          value: x,
+          onChange: F,
+          onKeyDown: M,
+          id: e,
+          color: B,
+          onBlur: void 0
+        }
+      ) }),
+      /* @__PURE__ */ r(
+        ce,
+        {
+          type: "button",
+          "aria-label": "Add option",
+          disabled: !!A || w,
+          onClick: C,
+          children: /* @__PURE__ */ r(Se, {})
+        }
+      )
+    ] }) }) }),
+    /* @__PURE__ */ r(Ue, { droppableId: I, children: (S) => /* @__PURE__ */ b(v, { ...S.droppableProps, ref: S.innerRef, direction: "column", children: [
+      h.map((_, U) => /* @__PURE__ */ r(
+        Ge,
+        {
+          draggableId: `${_.value}-draggable`,
+          index: U,
+          isDragDisabled: w,
+          children: ({ draggableProps: Y, dragHandleProps: Me, innerRef: St }) => /* @__PURE__ */ r(
+            v,
+            {
+              ...Me,
+              ...Y,
+              ref: St,
+              gap: "2",
+              align: "center",
+              justify: "between",
+              mb: "1",
+              asChild: !0,
+              children: /* @__PURE__ */ b(_e, { color: "gray", size: "2", children: [
+                /* @__PURE__ */ r("span", { children: _.label }),
+                /* @__PURE__ */ r(
+                  ce,
+                  {
+                    size: "small",
+                    variant: "ghost",
+                    type: "button",
+                    "aria-label": "Delete option",
+                    severity: "info",
+                    disabled: w,
+                    onClick: () => D(U),
+                    children: /* @__PURE__ */ r(Vt, {})
+                  }
+                )
+              ] })
+            }
+          )
+        },
+        _.value
+      )),
+      S.placeholder
+    ] }) })
+  ] }) });
+}), te = class te extends R {
+  constructor(e) {
+    const { minimum_length: t, maximum_length: n, ...s } = e;
+    super({ ...s, type: "multi-string" });
+    p(this, "minLength");
+    p(this, "maxLength");
+    this.minLength = t ?? 0, this.maxLength = n ?? 1 / 0;
+  }
+  getInput(e) {
+    return /* @__PURE__ */ r(Si, { field: this, ...e });
+  }
+  serialize() {
+    return { ...super._serialize(), minimum_length: this.minLength, maximum_length: this.maxLength };
+  }
+  isBlank(e) {
+    return super.isBlank(e) || e.length === 0;
+  }
+  getFieldValidators() {
+    const e = super.getFieldValidators();
+    return e.push((t) => {
+      if (Array.isArray(t) && t.length < this.minLength)
+        return `Must have at least ${this.minLength} options.`;
+    }), e.push((t) => {
+      if (Array.isArray(t) && t.length > this.maxLength)
+        return `Must have at most ${this.maxLength} options.`;
+    }), e;
+  }
+  static deserialize(e) {
+    if (e.type !== "multi-string")
+      throw new Error("Type mismatch.");
+    return new te(e);
+  }
+};
+p(te, "fieldTypeName", "Multi-string"), p(te, "fieldTypeDescription", "Allows the user to provide multiple unique strings."), p(te, "Icon", _t);
+let we = te;
+class gt extends R {
+  constructor(e) {
+    super(e);
+    p(this, "options");
+    const t = /* @__PURE__ */ new Set();
+    this.options = e.options.map((n) => (typeof n == "string" && (n = { label: n, value: n }), t.add(n.label), n)), t.size !== e.options.length && console.error(
+      `${e.options.length - t.size} duplicate identifiers found in options. This may cause unexpected behavior. Options:`,
+      e.options
+    );
+  }
+  _serialize() {
+    return {
+      ...super._serialize(),
+      options: this.options
+    };
+  }
+  static getFieldCreationSchema() {
+    return [
+      new we({
+        label: "Options",
+        description: "List possible options for the user to select from.",
+        required: !0,
+        identifier: "options",
+        minimum_length: 2,
+        maximum_length: 20
+      })
+    ];
+  }
+}
+const ie = class ie extends gt {
+  constructor(i) {
+    super({ ...i, type: "select" });
+  }
+  serialize() {
+    return super._serialize();
+  }
+  static deserialize(i) {
+    if (i.type !== "select")
+      throw new Error("Type mismatch.");
+    return new ie(i);
+  }
+  getInput(i) {
+    return /* @__PURE__ */ r(xi, { field: this, ...i });
+  }
+};
+p(ie, "fieldTypeName", "Dropdown"), p(ie, "fieldTypeDescription", "Allows the user to select a single option from a list of options."), p(ie, "Icon", $t);
+let Ie = ie;
+const Ei = z(function(i) {
+  const [{ inputId: e, labelId: t, severity: n, helpText: s, label: a, fieldProps: l, field: c, helpers: f }, u] = H(i), { setValue: d, setTouched: h, setError: m } = f, g = T(() => Array.isArray(l.value) ? l.value : [], [l.value]), y = E(
+    (I) => {
+      d(I, !1).then(), h(!0, !1).then(), m(c.getError(I));
+    },
+    [h, d, m, c]
+  );
+  return /* @__PURE__ */ r(j, { helpText: s, severity: n, children: /* @__PURE__ */ r(W, { severity: n, inputId: e, labelId: t, label: a, children: /* @__PURE__ */ r(
+    Rt,
+    {
+      value: g,
+      onValueChange: y,
+      options: c.options,
+      name: l.name,
+      placeholder: "Select one or more...",
+      id: e,
+      severity: n,
+      ...u
+    }
+  ) }) });
+}), ne = class ne extends gt {
+  constructor(i) {
+    super({ ...i, type: "multi-select" });
+  }
+  isBlank(i) {
+    return super.isBlank(i) || i.length === 0;
+  }
+  serialize() {
+    return super._serialize();
+  }
+  static deserialize(i) {
+    if (i.type !== "multi-select")
+      throw new Error("Type mismatch.");
+    return new ne(i);
+  }
+  getInput(i) {
+    return /* @__PURE__ */ r(Ei, { field: this, ...i });
+  }
+};
+p(ne, "fieldTypeName", "Multi-select"), p(ne, "fieldTypeDescription", "Allows the user to select a multiple options from a list of options."), p(ne, "Icon", qt);
+let Ne = ne;
+const zi = z(function({ field: i, ...e }) {
+  const [{ value: t }] = We(i.options.clonedFieldIdentifier), n = T(() => {
+    const s = i.options.getFieldToClone(t);
+    return s ? De(s) : null;
+  }, [i.options, t]);
+  return Ce(n, e);
+});
+class xe extends R {
+  constructor(e, t) {
+    super({ ...e, type: "custom" });
+    p(this, "Component");
+    // identifier of the field whose value is the label of the field to re-render
+    p(this, "options");
+    this.options = e, this.Component = t;
+  }
+  serialize() {
+    throw new Error("Serializing only supported for public input types.");
+  }
+  getInput(e) {
+    const t = this.Component;
+    return /* @__PURE__ */ r(t, { field: this, ...e });
+  }
+}
+p(xe, "fieldTypeName", "Custom"), p(xe, "fieldTypeDescription", "Allows re-rendering of field already in the form");
+class Li extends xe {
+  constructor(i) {
+    super(i, zi);
+  }
+}
+const Pi = z(function(i) {
+  const { field: e, ...t } = i, { label: n, description: s, fields: a, condition: l } = e, { values: c, setFieldValue: f } = ae(), u = l != null && l.identifier ? se(c, l.identifier) : void 0, d = T(() => vt(l, u), [l, u]);
+  Pe(() => {
+    if (!d)
+      for (const m of a)
+        f(m.getId(), "").then();
+  }, [d, a, f]);
+  const h = wt(a, t);
+  return d ? n ? /* @__PURE__ */ r(Ee, { children: /* @__PURE__ */ b(v, { direction: "column", gap: "3", children: [
+    /* @__PURE__ */ b(v, { direction: "column", children: [
+      /* @__PURE__ */ r(ze, { as: "h3", size: "3", children: n }),
+      /* @__PURE__ */ r(k, { className: Ae.description, children: s })
+    ] }),
+    h
+  ] }) }) : h : null;
+}), re = class re extends ht {
+  constructor(e) {
+    const { label: t = null, fields: n, condition: s = null, conditional: a, ...l } = e;
+    super({ ...l, type: "section" });
+    p(this, "label");
+    p(this, "fields");
+    p(this, "condition");
+    this.fields = n, this.condition = s, this.label = t, a === !1 && (this.condition = null);
+  }
+  static getFieldCreationSchema(e) {
+    return e.length === 0 ? [] : [
+      new le({
+        label: "Conditional",
+        description: "Conditionally show or hide this section.",
+        identifier: "conditional",
+        required: !1
+      }),
+      // Declare a section that will hold options for the condition (if any).
+      new re({
+        label: "Conditional settings",
+        identifier: "conditional-settings",
+        // This section will only be rendered if the above "Conditional" field is checked.
+        condition: {
+          identifier: "conditional",
+          value: !0
+        },
+        // These are the options of the condition.
+        fields: [
+          // Declare a select field that will be used to select the field against which we will check the
+          // condition. This must be selected before the next field is rendered.
+          new Ie({
+            label: "Field",
+            description: "The field to use for the condition.",
+            // The options (for the field against which we will check the condition) are all the labels of
+            // the fields in the previous section(s) (or fields declared before with no section) that
+            // support conditions. We pass in both the label and the identifier of each supported field. The
+            // identifier becomes the value of the option.
+            options: e.map((t) => t.label ? {
+              label: t.label,
+              value: t.identifier
+            } : null).filter((t) => !!t),
+            identifier: "condition.identifier",
+            required: !0
+          }),
+          // Declare a custom field that will be used to input a value for the condition. The value of the
+          // conditional field selected in the previous step must be equal to the value the user inputs into
+          // this field for the section to be rendered.
+          new Li({
+            label: "Value",
+            identifier: "condition.value",
+            required: !0,
+            clonedFieldIdentifier: "condition.identifier",
+            getFieldToClone(t) {
+              if (!t)
+                return null;
+              const n = e.find((s) => s.identifier === t);
+              return n ? {
+                ...n,
+                // Override some options to make it make sense in the context and to make it work with the framework.
+                label: "Value",
+                identifier: "condition.value",
+                description: "The value to compare against.",
+                required: n.type !== "boolean"
+              } : (console.error("Could not find field with identifier", t), null);
+            }
+          })
+        ]
+      })
+    ];
+  }
+  static deserialize(e) {
+    var n;
+    if (e.type !== "section")
+      throw new Error("Invalid type");
+    const t = ((n = e.fields) == null ? void 0 : n.map(bt)) ?? [];
+    return new re({ ...e, fields: t });
+  }
+  conditional() {
+    return this.condition !== null;
+  }
+  serialize() {
+    return {
+      ...super._serialize(),
+      label: this.label,
+      condition: this.condition,
+      conditional: this.conditional(),
+      fields: this.fields.map((e) => e.serialize())
+    };
+  }
+  getErrors(e) {
+    const t = {};
+    for (const n of this.fields) {
+      const s = n.getId(), a = n.getError(se(e, s), e);
+      a && Ye(t, n.getId(), a);
+    }
+    return t;
+  }
+  getInput(e) {
+    return /* @__PURE__ */ r(Pi, { field: this, ...e });
+  }
+};
+p(re, "fieldTypeName", "Section"), p(re, "fieldTypeDescription", "Sections can be useful for grouping fields together. They can also be conditionally shown or hidden.");
+let K = re;
+const Qe = {
+  date: $e,
+  number: ue,
+  boolean: le,
+  select: Ie,
+  string: fe,
+  text: he,
+  custom: xe,
+  // TODO: Underscore
+  "multi-string": we,
+  "multi-select": Ne
+}, bt = (o) => {
+  const i = o.type;
+  return Qe[i].deserialize(o);
+}, De = (o) => o.type === "section" ? K.deserialize(o) : bt(o);
+function yt(o, i = {}) {
+  const { readonly: e = !1 } = i;
+  return {
+    title: o.title,
+    description: o.description,
+    fields: o.fields.map((t) => De(t)),
+    meta: { readonly: e }
+  };
+}
+function vt(o, i) {
+  if (!o)
+    return !0;
+  const e = Array.isArray(i) ? i.map((n) => typeof n == "string" ? n : n.value) : i, t = Array.isArray(o.value) ? o.value.map((n) => typeof n == "string" ? n : n.value) : o.value;
+  if (Array.isArray(t) && Array.isArray(e)) {
+    for (const n of t)
+      if (!e.includes(n))
+        return !1;
+    return !0;
+  }
+  return t === i;
+}
+const Ce = (o, i) => T(() => !i || !o ? null : o.getInput(i), [o, i]), wt = (o, i) => {
+  const e = T(() => o.map((t) => /* @__PURE__ */ r("div", { children: t.getInput(i) }, t.getId())), [o, i]);
+  return /* @__PURE__ */ r(v, { direction: "column", gap: "2", children: e });
+}, Te = (o) => Object.keys(o).length > 0, It = async (o, i) => {
+  const e = {};
+  for (const t of o.fields)
+    if (t instanceof K) {
+      if (t.condition) {
+        const { identifier: n } = t.condition;
+        if (!vt(t.condition, se(i, n)))
+          continue;
+      }
+      Object.assign(e, t.getErrors(i));
+    } else {
+      if (!(t instanceof R))
+        throw new Error("Invalid field type");
+      const n = t.getId(), s = t.getError(se(i, n), i);
+      s && Ye(e, n, s);
+    }
+  if (Te(e))
+    return e;
+}, Ai = [null, void 0], Xe = (o, i) => o.reduce((e, t) => t instanceof K ? { ...e, ...Xe(t.fields, i) } : (Ai.includes(se(e, t.getId())) && Ye(e, t.getId(), ""), e), i), Di = () => {
+  throw new Error("onSubmit must be provided if form is not readonly.");
+}, Je = z(
+  me((o, i) => {
+    const {
+      schema: e,
+      values: t = {},
+      onSubmit: n = Di,
+      submitText: s = "Submit",
+      cancelText: a,
+      onCancel: l,
+      onDirty: c,
+      // if the title isn't provided, hide it by default
+      hideTitle: f = !e.title,
+      hideDescription: u,
+      className: d
+    } = o, { readonly: h } = e.meta, m = T(() => crypto.randomUUID(), []), g = je({
+      initialValues: Xe(e.fields, t),
+      onSubmit: n,
+      validate: (P) => It(e, P),
+      // only validate the entire form on submit
+      validateOnBlur: !1,
+      validateOnChange: !1
+    }), { dirty: y } = g, I = T(
+      () => typeof e.title == "string" ? /* @__PURE__ */ r(ze, { children: e.title }) : e.title,
+      [e.title]
+    ), w = T(
+      () => typeof e.description == "string" ? /* @__PURE__ */ r(k, { className: Ae.description, children: e.description }) : e.description,
+      [e.description]
+    ), x = wt(e.fields, { formId: m, disabled: h });
+    return Pe(() => {
+      y && c && c();
+    }, [y, c]), /* @__PURE__ */ r(He, { value: g, children: /* @__PURE__ */ r(v, { ref: i, direction: "column", gap: "2", className: d, asChild: !0, children: /* @__PURE__ */ b("form", { id: m, onSubmit: g.handleSubmit, children: [
+      !f && /* @__PURE__ */ r(Ee, { children: /* @__PURE__ */ b(v, { direction: "column", gap: "1", children: [
+        I,
+        !u && w
+      ] }) }),
+      x,
+      !h && /* @__PURE__ */ b(v, { justify: "end", gap: "2", children: [
+        a && /* @__PURE__ */ r(G, { type: "button", variant: "soft", onClick: l, children: a }),
+        /* @__PURE__ */ r(G, { type: "submit", disabled: !g.isValid, children: s })
+      ] })
+    ] }) }) });
+  })
+), fn = z(
+  me((o, i) => {
+    const { submission: e, showFormDescription: t = !1, showFormTitle: n = !0 } = o, s = $(ct(e.form_revision));
+    if (!s)
+      throw new Error(
+        `Could not find revision ${e.form_revision} for submission ${e.offline_id}.`
+      );
+    const a = T(() => yt(s, { readonly: !0 }), [s]);
+    return /* @__PURE__ */ r(
+      Je,
+      {
+        ref: i,
+        schema: a,
+        values: e.values,
+        hideDescription: !t,
+        hideTitle: !n
+      }
+    );
+  })
+), ki = "_favoriteIcon_1bixi_1", Mi = "_regularIcon_1bixi_9", et = {
+  favoriteIcon: ki,
+  regularIcon: Mi
+}, Oe = "organization:", Ve = "user:", hn = z(
+  me((o, i) => {
+    const { maxResults: e = 20, ...t } = o, [n, s] = de(""), [a, l] = de(""), { sdk: c } = si(), f = T(() => {
+      const x = { maxResults: e, searchTerm: n };
+      return a && (a.startsWith(Oe) ? x.owner_organization = parseInt(a.slice(Oe.length)) : a.startsWith(Ve) && (x.owner_user = parseInt(a.slice(Ve.length)))), x;
+    }, [n, e, a]), u = $(li(f)) ?? [], d = $(ai), h = E(
+      (x) => {
+        x.favorite ? c.userForms.unfavorite(x.offline_id).then() : c.userForms.favorite(x.offline_id).then();
+      },
+      [c]
+    ), m = T(() => {
+      const x = c.store.getState(), P = {};
+      for (const A of Object.values(d)) {
+        const L = dt(A.owner_organization || -1)(x);
+        L && (P[`${Oe}${L.id}`] = L.name);
+        const O = Ke(A.owner_user || -1)(x);
+        O && (P[`${Ve}${O.id}`] = O.username);
+      }
+      return Object.entries(P).map(([A, L]) => ({ itemContent: L, value: A }));
+    }, [d, c.store]), g = E((x) => {
+      s(x.currentTarget.value);
+    }, []), I = ($(ci) || 0) - u.length, w = u.length == e && I > 0 ? `Only the first ${e} results are shown (${I} hidden)` : I > 0 && `${I} hidden forms`;
+    return /* @__PURE__ */ b(v, { ref: i, direction: "column", gap: "2", children: [
+      /* @__PURE__ */ b(v, { gap: "2", grow: "1", children: [
+        /* @__PURE__ */ r(ge, { grow: "1", asChild: !0, children: /* @__PURE__ */ r(oe.Root, { size: "3", children: /* @__PURE__ */ r(oe.Input, { placeholder: "Filter", value: n, onChange: g }) }) }),
+        /* @__PURE__ */ r(
+          st,
+          {
+            items: m,
+            value: a,
+            onValueChange: l,
+            placeholder: "Owner",
+            size: "large"
+          }
+        )
+      ] }),
+      u.length > 0 && /* @__PURE__ */ r(Le.Root, { children: u.map((x) => /* @__PURE__ */ r(
+        Oi,
+        {
+          ...t,
+          form: x,
+          handleToggleFavorite: () => h(x)
+        },
+        x.offline_id
+      )) }),
+      /* @__PURE__ */ r(ge, { px: "3", children: /* @__PURE__ */ r(k, { size: "2", severity: "info", children: w }) })
+    ] });
+  })
+), Oi = (o) => {
+  var h;
+  const { form: i, onSelectForm: e, isFavoriteEditable: t, handleToggleFavorite: n } = o, s = (h = $(dt(i.owner_organization || -1))) == null ? void 0 : h.name, a = $(Ke(i.owner_user || -1)), l = $(ut).id, c = !!a && a.id === l, f = s ?? (c ? "You" : a == null ? void 0 : a.username) ?? "Unknown", u = E(
+    (m) => {
+      m.stopPropagation(), n();
+    },
+    [n]
+  ), d = /* @__PURE__ */ r(Le.Item, { onClick: () => e(i), asChild: !0, children: /* @__PURE__ */ b(v, { justify: "between", gap: "2", py: "2", px: "3", ...Nt, children: [
+    /* @__PURE__ */ b(v, { grow: "1", align: "center", gap: "2", children: [
+      /* @__PURE__ */ r(
+        ce,
+        {
+          className: ft(i.favorite ? et.favoriteIcon : et.regularIcon),
+          variant: "ghost",
+          onClick: u,
+          "aria-label": i.favorite ? "Favorite form" : "Standard form",
+          disabled: !t,
+          children: i.favorite ? /* @__PURE__ */ r(Bt, {}) : /* @__PURE__ */ r(Wt, {})
+        }
+      ),
+      /* @__PURE__ */ r(k, { noWrap: !0, children: i.latestRevision.title }),
+      i.latestRevision.description && /* @__PURE__ */ r(jt, {})
+    ] }),
+    f && /* @__PURE__ */ b(v, { align: "center", gap: "2", children: [
+      /* @__PURE__ */ r(Ht, {}),
+      " ",
+      f
+    ] })
+  ] }) });
+  return i.latestRevision.description ? /* @__PURE__ */ r(Ut, { content: i.latestRevision.description, children: d }, i.offline_id) : d;
+}, Vi = "_submissionsContainer_9iirt_1", _i = "_stopHorizontalOverflow_9iirt_6", xt = {
+  submissionsContainer: Vi,
+  stopHorizontalOverflow: _i
+}, $i = z(function(i) {
+  var x;
+  const { submission: e, onSubmissionClick: t, compact: n, labelType: s, rowDecorator: a } = i, l = $(ut), c = $(Ke("created_by" in e ? e.created_by : l.id)), f = Be(e), u = di(f) ? f.toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  }) : ui(f), d = $(ct(e.form_revision));
+  if (!d)
+    throw new Error(`Could not find revision ${e.form_revision} for submission ${e.offline_id}.`);
+  const h = (x = $(fi(d.form))) == null ? void 0 : x.revision, m = hi({
+    file: (c == null ? void 0 : c.profile.file) ?? null,
+    fileSha1: (c == null ? void 0 : c.profile.file_sha1) ?? null
+  }), g = (c == null ? void 0 : c.username.charAt(0).toUpperCase()) ?? "?", y = d.revision === h, I = ri.useCallback(() => {
+    t && t({ submission: e });
+  }, [e, t]), w = /* @__PURE__ */ r(Le.Item, { onClick: I, asChild: !0, children: /* @__PURE__ */ b(v, { grow: "1", width: "100%", p: "2", gap: "2", justify: "between", children: [
+    /* @__PURE__ */ b(v, { gap: "2", align: "center", className: xt.stopHorizontalOverflow, children: [
+      /* @__PURE__ */ r(Gt, { src: m, size: "1", fallback: g }),
+      /* @__PURE__ */ r(k, { size: "2", noWrap: !0, children: s === "creator" ? (c || l).username : d.title })
+    ] }),
+    /* @__PURE__ */ b(v, { gap: "2", align: "center", children: [
+      !n && (d.revision ? /* @__PURE__ */ r(_e, { variant: "soft", severity: y ? "primary" : "info", children: n ? d.revision.toString() : `Revision #${d.revision}` }) : !!h && /* @__PURE__ */ r(_e, { children: "Original" })),
+      /* @__PURE__ */ r(k, { size: "2", noWrap: !0, children: u })
+    ] })
+  ] }) });
+  return a ? a(e, w) : w;
+}), Be = (o) => {
+  const i = "created_at" in o ? o.created_at : o.submitted_at;
+  return new Date(i);
+}, pn = z(function(i) {
+  const {
+    formId: e,
+    submissions: t,
+    compact: n = !1,
+    className: s,
+    after: a,
+    variant: l = "outline",
+    ...c
+  } = i;
+  if (!!e == !!t)
+    throw new Error("Either formId or submissions must be provided, but not both.");
+  const f = $(
+    t ? () => t : pi(e)
+  ), u = T(
+    () => f == null ? void 0 : f.sort((d, h) => Be(h).getTime() - Be(d).getTime()),
+    [f]
+  );
+  return /* @__PURE__ */ r(
+    Le.Root,
+    {
+      className: ft(xt.submissionsContainer, s),
+      size: "small",
+      variant: l,
+      before: !n && /* @__PURE__ */ b(k, { severity: "info", children: [
+        "There are ",
+        ((f == null ? void 0 : f.length) || 0).toString(),
+        " submissions of this form."
+      ] }),
+      after: a,
+      children: u == null ? void 0 : u.map((d, h) => /* @__PURE__ */ r(
+        $i,
+        {
+          submission: d,
+          compact: n,
+          ...c
+        },
+        h
+      ))
+    }
+  );
+}), mn = z(function(i) {
+  const { name: e, render: t } = i, { submitForm: n } = ae(), [s, a, l] = We(e);
+  return T(() => {
+    const c = (f) => l.setValue(f, !1);
+    return t({
+      value: s.value,
+      setValue: c,
+      patchValue: n
+    });
+  }, [n, l, s.value, t]);
+}), gn = z(
+  me((o, i) => {
+    const { children: e, schema: t, values: n, onPatch: s, onError: a, ...l } = o, c = T(() => Xe(t.fields, n), [t.fields, n]), f = E(
+      (g) => {
+        const y = {};
+        for (const I in g) {
+          const w = g[I];
+          w !== c[I] && w !== void 0 && (y[I] = w);
+        }
+        Te(y) && s(y);
+      },
+      [c, s]
+    ), u = E(
+      async (g) => {
+        const y = await It(t, g);
+        return y && a(y), y;
+      },
+      [t, a]
+    ), d = je({
+      initialValues: c,
+      onSubmit: f,
+      validate: u,
+      // only validate the entire form on submit
+      validateOnBlur: !1,
+      validateOnChange: !1
+    }), { errors: h, resetForm: m } = d;
+    return Pe(() => {
+      Te(h) && m({ values: c, errors: {} });
+    }, [h, c, m]), /* @__PURE__ */ r(He, { value: d, children: /* @__PURE__ */ r("form", { ...l, ref: i, onSubmit: d.handleSubmit, children: e }) });
+  })
+), Ct = {
+  ...Qe,
+  section: K
+}, Ri = z(function(i) {
+  const { field: e, setFieldType: t } = i, n = e.fieldTypeName, s = e.fieldTypeDescription, a = e.Icon;
+  return /* @__PURE__ */ b(v, { gap: "4", align: "center", children: [
+    /* @__PURE__ */ r(G, { type: "button", variant: "surface", onClick: t, style: { width: "135px" }, children: /* @__PURE__ */ b(v, { gap: "3", align: "center", grow: "1", children: [
+      /* @__PURE__ */ r(a, {}),
+      n
+    ] }) }),
+    /* @__PURE__ */ r(k, { children: s })
+  ] });
+}), Tt = [
+  ["string", "text"],
+  ["select", "multi-select"],
+  ["boolean", "date", "number", "multi-string"]
+], qi = Tt.length - 1, Ni = z(function(i) {
+  const { setFieldType: e } = i;
+  return /* @__PURE__ */ r(v, { direction: "column", gap: "3", children: Tt.map((t, n) => /* @__PURE__ */ b(v, { direction: "column", gap: "3", children: [
+    /* @__PURE__ */ r(v, { direction: "column", gap: "2", children: t.map((s) => /* @__PURE__ */ r(
+      Ri,
+      {
+        field: Qe[s],
+        setFieldType: () => e(s)
+      },
+      s
+    )) }),
+    n < qi && /* @__PURE__ */ r(Kt, { size: "4" })
+  ] }, n)) });
+}), Bi = (o) => (i) => {
+  if (!i || typeof i != "string")
+    return;
+  const e = at(i);
+  if (o.includes(e))
+    return "This name is already taken.";
+}, Wi = (o, i) => {
+  const e = [
+    new fe({
+      label: "Label",
+      required: !0,
+      maxLength: 100,
+      identifier: "label",
+      fieldValidators: [Bi(o)]
+    }),
+    new he({
+      label: "Description",
+      required: !1,
+      maxLength: 1e3,
+      identifier: "description"
+    })
+  ];
+  return i === "section" ? e : [
+    ...e,
+    new le({ label: "Required", description: null, required: !1, identifier: "required" })
+  ];
+}, ji = z(function(i) {
+  const { fieldType: e, handleCancel: t, handleCreateField: n, defaultField: s, conditionalSourceFields: a } = i, l = Ct[e], c = ae(), f = T(() => {
+    const u = c.values.fields.flatMap(
+      (h) => h.type === "section" ? [...h.fields.map((m) => m.identifier), h.identifier] : h.identifier
+    ).filter((h) => h !== (s == null ? void 0 : s.identifier));
+    let d = Wi(u, e);
+    if (l === K) {
+      if (a === void 0)
+        throw new Error("Conditional source fields must be provided when changing sections.");
+      d = d.concat(l.getFieldCreationSchema(a));
+    } else {
+      if (!(l.prototype instanceof R))
+        throw new Error(`Field must be an instance of BaseField. Got ${l}.`);
+      d = [...d, ...l.getFieldCreationSchema()];
+    }
+    return {
+      fields: d,
+      meta: { readonly: !1 },
+      // using the dialog title as the form title
+      title: null
+    };
+  }, [c.values.fields, e, l, s == null ? void 0 : s.identifier, a]);
+  return /* @__PURE__ */ r(
+    Je,
+    {
+      schema: f,
+      values: s,
+      onSubmit: n,
+      cancelText: s ? void 0 : "Back",
+      onCancel: t
+    }
+  );
+}), Fe = z(function(i) {
+  const { parentPath: e, index: t, children: n, initial: s, editing: a, conditionalSourceFields: l } = i, [c, f] = de(), u = (s == null ? void 0 : s.type) ?? c, d = u ? Ct[u].fieldTypeName : void 0, { setFieldValue: h, values: m } = ae();
+  if (a && !s)
+    throw new Error("Initial field must be provided if editing is true.");
+  const g = !u && !a && !s, y = g ? "Choose a field type" : `${d} settings`, I = g ? "Select a field type to add to this section." : (d == null ? void 0 : d.toLowerCase()) === "section" ? "Customize your section" : `Customize your ${d == null ? void 0 : d.toLowerCase()} field.`, w = E(() => f(void 0), []), x = E((L) => {
+    f(void 0), L();
+  }, []), P = E(
+    (L, O) => {
+      const { label: B } = L;
+      if (!u)
+        throw new Error("Field type must be selected before creating a field.");
+      if (!B || typeof B != "string")
+        throw new Error("Label must be provided before creating a field.");
+      const V = De({
+        type: u,
+        ...L,
+        identifier: Fi(L.identifier, B)
+      }).serialize(), F = se(m, e);
+      if (F === void 0)
+        throw new Error("Parent path must point to an existing field.");
+      let C;
+      if (!Array.isArray(F))
+        throw new Error("Parent path must point to an array.");
+      a ? C = Ti(F, t, V) : C = pt(F, t, V), h(e, C).then(), O();
+    },
+    [a, u, m, e, h, t]
+  ), A = E(
+    (L) => g ? /* @__PURE__ */ r(Ni, { setFieldType: f }) : /* @__PURE__ */ r(
+      ji,
+      {
+        conditionalSourceFields: l,
+        handleCancel: w,
+        handleCreateField: (O) => P(O, L),
+        fieldType: u,
+        defaultField: s
+      }
+    ),
+    [l, w, P, s, g, u]
+  );
+  return /* @__PURE__ */ r(Yt, { onCloseInterrupt: x, title: y, description: I, content: A, children: n });
+}), tt = ({ children: o }) => /* @__PURE__ */ r(ot, { children: o }), it = (o, i) => ({
+  initial: o ? i : "none",
+  sm: o ? "none" : i
+}), Ft = z(function(i) {
+  const { remove: e, dragHandleProps: t, editProps: n, insertAfterProps: s } = i, a = T(
+    () => [
+      {
+        Wrapper: Fe,
+        wrapperProps: n,
+        Icon: Qt,
+        text: "Edit"
+      },
+      {
+        Icon: Xt,
+        buttonProps: {
+          onClick: e
+        },
+        text: "Delete"
+      },
+      {
+        Wrapper: Fe,
+        wrapperProps: s,
+        Icon: Se,
+        text: "Add after"
+      },
+      {
+        // Wrapping icon in a div so that the asChild turns the button into a div
+        // so that the drag handle props are not applied to the icon
+        // Note: b/c the <button> does not handle the space-press event correctly
+        Icon: (l) => /* @__PURE__ */ r("div", { ...l, children: /* @__PURE__ */ r(Jt, {}) }),
+        text: "Reorder",
+        disableOnMobile: !0,
+        buttonProps: { ...t, asChild: !0 }
+      }
+    ],
+    [t, n, s, e]
+  );
+  return /* @__PURE__ */ b(ot, { children: [
+    /* @__PURE__ */ r(v, { gap: "4", display: it(!1, "flex"), children: a.map((l) => {
+      const c = l.Wrapper ?? tt;
+      return /* @__PURE__ */ r(c, { ...l.wrapperProps, children: /* @__PURE__ */ r(ce, { type: "button", variant: "ghost", "aria-label": l.text, ...l.buttonProps, children: /* @__PURE__ */ r(l.Icon, {}) }) }, l.text);
+    }) }),
+    /* @__PURE__ */ r(ge, { display: it(!0, "block"), children: /* @__PURE__ */ r(
+      Zt,
+      {
+        trigger: /* @__PURE__ */ r(ce, { variant: "ghost", "aria-label": "Actions menu", children: /* @__PURE__ */ r(ei, {}) }),
+        closeOnSelect: !1,
+        items: a.map((l) => {
+          var f;
+          if (l.disableOnMobile)
+            return null;
+          const c = l.Wrapper ?? tt;
+          return {
+            ...l.buttonProps,
+            onSelect: (f = l.buttonProps) == null ? void 0 : f.onClick,
+            content: /* @__PURE__ */ r(c, { ...l.wrapperProps, children: /* @__PURE__ */ b(v, { gap: "2", align: "center", children: [
+              /* @__PURE__ */ r(l.Icon, {}),
+              l.text
+            ] }) })
+          };
+        }).filter((l) => l !== null)
+      }
+    ) })
+  ] });
+}), ke = "form-builder", Hi = z(function(i) {
+  const { field: e, index: t, sectionIndex: n, remove: s } = i, a = T(() => De(e), [e]), l = Ce(a, { formId: ke, disabled: !0 }), c = T(
+    () => ({
+      index: t,
+      parentPath: `fields.${n}.fields`,
+      initial: e,
+      editing: !0
+    }),
+    [e, t, n]
+  ), f = T(
+    () => ({
+      parentPath: `fields.${n}.fields`,
+      index: t + 1,
+      initial: void 0
+    }),
+    [t, n]
+  );
+  return /* @__PURE__ */ r(Ge, { draggableId: e.identifier, index: t, children: (u) => /* @__PURE__ */ r(
+    Ee,
+    {
+      ref: u.innerRef,
+      ...u.draggableProps,
+      ...u.dragHandleProps,
+      mb: "4",
+      children: /* @__PURE__ */ b(v, { gap: "4", justify: "between", align: "center", children: [
+        l,
+        /* @__PURE__ */ r(
+          Ft,
+          {
+            remove: s,
+            editProps: c,
+            insertAfterProps: f,
+            dragHandleProps: u.dragHandleProps
+          }
+        )
+      ] })
+    }
+  ) });
+}), Ui = z(function(i) {
+  var P, A, L, O, B, V;
+  const { field: e, index: t, dropState: n } = i, s = (P = n[e.identifier]) == null ? void 0 : P.disabled, { setFieldValue: a, values: l } = ae(), c = ti(), f = E(
+    (F, C) => {
+      for (const M of F) {
+        const D = C.indexOf(M);
+        a(`fields.${D}.condition`, null).then(), a(`fields.${D}.conditional`, !1).then();
+      }
+    },
+    [a]
+  ), u = E(
+    (F) => {
+      var D;
+      const C = e.fields[F];
+      if (!C)
+        throw new Error("Could not find field to remove.");
+      const M = [];
+      for (const N of l.fields)
+        ((D = N.condition) == null ? void 0 : D.identifier) === C.identifier && M.push(N);
+      return {
+        removing: C,
+        affectedSections: M,
+        action: () => a(`fields.${t}.fields`, ve(e.fields, F))
+      };
+    },
+    [e.fields, l.fields, a, t]
+  ), d = E(
+    (F) => {
+      const { affectedSections: C, action: M, removing: D } = u(F), N = () => {
+        M().then(), f(C, l.fields);
+      };
+      if (C.length > 0) {
+        const S = C.map((_) => _.label).join(", ");
+        return c({
+          title: "Remove condition?",
+          description: `${D.label} is being used as a condition, deleting it will remove the condition from the ${S} section(s).`,
+          severity: "danger",
+          actionText: "Remove",
+          onAction: N
+        });
+      }
+      N();
+    },
+    [u, f, l.fields, c]
+  ), h = E(() => {
+    const C = e.fields.map((Y, Me) => u(Me)).flatMap((Y) => Y.affectedSections), M = C.length ? "Remove fields and conditions?" : "Remove fields?", D = e.fields.length, N = C.map((Y) => Y.label).join(", "), S = C.length ? `Deleting this section will remove the ${D} field(s) it contains and will remove the conditions from following sections: ${N}` : `Deleting this section will remove the ${D} field(s) it contains.`, _ = ve(l.fields, t), U = () => a("fields", _);
+    if (C.length > 0)
+      return c({
+        title: M,
+        description: S,
+        severity: "danger",
+        actionText: "Remove",
+        onAction: () => {
+          U().then(() => {
+            f(C, _);
+          });
+        }
+      });
+    U().then();
+  }, [
+    e.fields,
+    l.fields,
+    t,
+    u,
+    a,
+    c,
+    f
+  ]), m = T(
+    () => ({
+      index: t,
+      parentPath: "fields",
+      initial: e,
+      editing: !0,
+      conditionalSourceFields: qe(l.fields, t)
+    }),
+    [e, t, l.fields]
+  ), g = T(
+    () => ({
+      index: t + 1,
+      parentPath: "fields",
+      initial: ye(),
+      conditionalSourceFields: qe(l.fields, t + 1)
+    }),
+    [t, l.fields]
+  ), y = T(
+    () => ({
+      parentPath: `fields.${t}.fields`,
+      index: e.fields.length,
+      initial: void 0
+    }),
+    [e.fields.length, t]
+  ), I = T(
+    () => {
+      var F, C;
+      return (C = mt(l.fields, (F = e.condition) == null ? void 0 : F.identifier)) == null ? void 0 : C.label;
+    },
+    [(A = e.condition) == null ? void 0 : A.identifier, l.fields]
+  ), w = Array.isArray((L = e.condition) == null ? void 0 : L.value) ? "contains all of" : "equals", x = Array.isArray((O = e.condition) == null ? void 0 : O.value) ? (B = e.condition) == null ? void 0 : B.value.map((F) => typeof F == "string" ? F : F.label).join(", ") : (V = e.condition) == null ? void 0 : V.value.toString();
+  return /* @__PURE__ */ r(Ge, { draggableId: e.identifier, index: t, children: (F) => /* @__PURE__ */ r(
+    Ee,
+    {
+      ref: F.innerRef,
+      ...F.draggableProps,
+      ...F.dragHandleProps,
+      mb: "4",
+      children: /* @__PURE__ */ b(v, { gap: "3", justify: "between", align: "center", children: [
+        /* @__PURE__ */ b(v, { direction: "column", gap: "2", grow: "1", children: [
+          /* @__PURE__ */ b(v, { direction: "column", children: [
+            /* @__PURE__ */ r(ze, { as: "h3", size: "3", children: e.label }),
+            /* @__PURE__ */ r(k, { className: Ae.description, children: e.description })
+          ] }),
+          e.condition && /* @__PURE__ */ r(k, { size: "1", children: /* @__PURE__ */ b(ii, { children: [
+            "Display only if ",
+            /* @__PURE__ */ r(Ze, { children: I }),
+            " ",
+            w,
+            " ",
+            /* @__PURE__ */ r(Ze, { children: x })
+          ] }) }),
+          /* @__PURE__ */ r(Ue, { droppableId: e.identifier, type: "SECTION", isDropDisabled: s, children: (C) => /* @__PURE__ */ b(
+            v,
+            {
+              ref: C.innerRef,
+              ...C.droppableProps,
+              direction: "column",
+              gap: "0",
+              children: [
+                e.fields.map((M, D) => /* @__PURE__ */ r(
+                  Hi,
+                  {
+                    field: M,
+                    index: D,
+                    sectionIndex: t,
+                    remove: () => d(D)
+                  },
+                  M.identifier
+                )),
+                C.placeholder,
+                /* @__PURE__ */ r(Fe, { ...y, children: /* @__PURE__ */ b(G, { type: "button", variant: "outline", children: [
+                  /* @__PURE__ */ r(Se, {}),
+                  " Add a field"
+                ] }) })
+              ]
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ r(
+          Ft,
+          {
+            remove: h,
+            insertAfterProps: g,
+            dragHandleProps: F.dragHandleProps,
+            editProps: m
+          }
+        )
+      ] })
+    }
+  ) });
+}), Gi = (o, i) => {
+  var t;
+  const e = { ...o };
+  switch (i.type) {
+    case "release":
+      for (const n in e)
+        e[n].disabled = !1;
+      return e;
+    case "hold":
+      for (const n in e)
+        (t = e[n]) != null && t.conditionFields.has(i.fieldId) && (e[n].disabled = !0);
+      return e;
+    case "update":
+      return i.state;
+  }
+}, Ki = (o, i) => {
+  if (i)
+    for (let e = 0; e < o.length; e++) {
+      const t = o[e];
+      if (t) {
+        for (const n of t.fields)
+          if (n.identifier === i)
+            return e;
+      }
+    }
+}, nt = (o) => {
+  var e, t, n;
+  const i = {};
+  for (let s = 0; s < o.length; s++) {
+    const a = o[s];
+    if (!a)
+      throw new Error("Field is undefined.");
+    const l = s > 0 ? (e = i[o[s - 1].identifier]) == null ? void 0 : e.conditionFields : void 0, c = new Set(l);
+    (t = a.condition) != null && t.identifier && c.add(a.condition.identifier), i[a.identifier] = {
+      disabled: !1,
+      conditionFields: c,
+      conditionIndex: Ki(o, (n = a.condition) == null ? void 0 : n.identifier),
+      index: s,
+      label: a.label
+    };
+  }
+  return i;
+}, rt = (o, i) => {
+  for (const [e, t] of Object.entries(o))
+    if (t.identifier === i)
+      return [t, e];
+}, Yi = z(function() {
+  const { values: i, setFieldValue: e } = ae(), [t, n] = oi(Gi, i.fields, nt), { showInfo: s } = ni();
+  Pe(() => {
+    n({ type: "update", state: nt(i.fields) });
+  }, [n, i.fields]);
+  const a = E((f) => {
+    f.type === "SECTION" && n({ type: "hold", fieldId: f.draggableId });
+  }, []), l = E(
+    (f) => {
+      const { source: u, destination: d, type: h, reason: m, draggableId: g } = f;
+      if (n({ type: "release" }), !d || m === "CANCEL")
+        return;
+      if (h === "ROOT") {
+        const P = t[g];
+        if (!P)
+          throw new Error("Could not find section context.");
+        let A = typeof P.conditionIndex < "u" ? (
+          // cannot move a section with a condition before the condition's field
+          Math.max(P.conditionIndex + 1, d.index)
+        ) : d.index;
+        for (const L of Object.values(t))
+          L.conditionIndex === u.index && (A = Math.min(A, L.index - 1));
+        return A != d.index && s({
+          title: "Reordered sections",
+          description: "Sections with conditions must be below the fields they reference."
+        }), e("fields", Re(i.fields, u.index, A));
+      }
+      if (h !== "SECTION")
+        throw new Error("Unexpected droppable type.");
+      const [y, I] = rt(i.fields, u.droppableId) ?? [], [w, x] = rt(i.fields, d.droppableId) ?? [];
+      if (!(y != null && y.fields) || !w)
+        throw new Error("Could not find section with fields.");
+      if (y.identifier === w.identifier)
+        e(
+          `fields.${I}.fields`,
+          Re(y.fields, u.index, d.index)
+        ).then();
+      else {
+        const P = y.fields[u.index];
+        if (!P)
+          throw new Error("Could not find field to reorder.");
+        e(`fields.${I}.fields`, ve(y.fields, u.index)).then(), e(
+          `fields.${x}.fields`,
+          pt(w.fields, d.index, P)
+        ).then();
+      }
+    },
+    [i.fields, e, t, s]
+  ), c = T(
+    () => ({
+      index: i.fields.length,
+      parentPath: "fields",
+      initial: ye(),
+      conditionalSourceFields: qe(i.fields, i.fields.length)
+    }),
+    [i.fields]
+  );
+  return /* @__PURE__ */ r(lt, { onDragStart: a, onDragEnd: l, children: /* @__PURE__ */ r(Ue, { droppableId: "droppable", type: "ROOT", children: (f) => /* @__PURE__ */ b(
+    v,
+    {
+      ref: f.innerRef,
+      ...f.droppableProps,
+      direction: "column",
+      gap: "0",
+      children: [
+        i.fields.map((u, d) => /* @__PURE__ */ r(
+          Ui,
+          {
+            field: u,
+            index: d,
+            dropState: t
+          },
+          u.label
+        )),
+        f.placeholder,
+        /* @__PURE__ */ r(Fe, { ...c, children: /* @__PURE__ */ b(G, { type: "button", variant: "outline", children: [
+          /* @__PURE__ */ r(Se, {}),
+          " Add a section"
+        ] }) })
+      ]
+    }
+  ) }) });
+}), Qi = {
+  title: "",
+  description: "",
+  fields: []
+}, Xi = new fe({
+  label: "Title",
+  minLength: 0,
+  maxLength: 100,
+  required: !0,
+  identifier: "title"
+}), Ji = { formId: ke, placeholder: "Give your form a title." }, Zi = new he({
+  label: "Description",
+  minLength: 0,
+  maxLength: 1e3,
+  required: !1,
+  identifier: "description"
+}), en = { formId: ke, placeholder: "Explain the purpose of this form." }, tn = () => {
+  alert("This is a form preview, your data will not be saved.");
+}, bn = z(
+  me((o, i) => {
+    const { onCancel: e, onSave: t, revision: n } = o, s = n ? "Edit form" : "Create a new form", { heading: a = s } = o, l = E((m) => {
+      const g = {};
+      if (m.title || (g.title = "Title is required."), (!m.fields || m.fields.length === 0) && (g.fields = "At least one field is required."), Te(g))
+        return g;
+    }, []), c = je({
+      initialValues: Ci(n) ?? Qi,
+      validate: l,
+      onSubmit: (m) => t(m),
+      // only validate the entire for on submit
+      validateOnChange: !1,
+      validateOnBlur: !1
+    }), f = T(() => yt(c.values), [c.values]), u = Ce(Xi, Ji), d = Ce(Zi, en), h = T(
+      () => typeof a == "object" ? a : /* @__PURE__ */ r(ze, { children: a }),
+      [a]
+    );
+    return /* @__PURE__ */ r(Q.Root, { ref: i, defaultValue: "edit", children: /* @__PURE__ */ b(v, { direction: "column", gap: "2", children: [
+      /* @__PURE__ */ b(Q.List, { children: [
+        /* @__PURE__ */ r(Q.Trigger, { value: "edit", children: "Edit" }),
+        /* @__PURE__ */ r(Q.Trigger, { value: "preview", children: "Preview" })
+      ] }),
+      /* @__PURE__ */ b(Q.Content, { value: "edit", children: [
+        h,
+        /* @__PURE__ */ b(k, { children: [
+          "Add a new form field by clicking a + button. Specify options for each field, then drag and drop to rearrange them. You can see what a submitted form might look like in the",
+          " ",
+          /* @__PURE__ */ r("em", { children: "Preview" }),
+          " tab, but",
+          " ",
+          /* @__PURE__ */ r("strong", { children: "field values entered on this page will not be saved." })
+        ] }),
+        /* @__PURE__ */ r(v, { asChild: !0, direction: "column", gap: "2", mt: "3", children: /* @__PURE__ */ b("form", { id: ke, onSubmit: c.handleSubmit, children: [
+          /* @__PURE__ */ b(He, { value: c, children: [
+            u,
+            d,
+            /* @__PURE__ */ r(Yi, {}),
+            /* @__PURE__ */ r(k, { severity: "danger", size: "1", children: typeof c.errors.fields == "string" && c.errors.fields })
+          ] }),
+          /* @__PURE__ */ b(v, { justify: "end", gap: "2", children: [
+            /* @__PURE__ */ r(G, { type: "button", variant: "soft", onClick: e, children: "Cancel" }),
+            /* @__PURE__ */ r(G, { type: "submit", disabled: !c.isValid, children: "Save" })
+          ] })
+        ] }) })
+      ] }),
+      /* @__PURE__ */ r(Q.Content, { value: "preview", children: /* @__PURE__ */ r(Je, { schema: f, onSubmit: tn }) })
+    ] }) });
+  })
+);
+export {
+  le as BooleanField,
+  bi as BooleanInput,
+  $e as DateField,
+  vi as DateInput,
+  K as FieldSection,
+  hn as FormBrowser,
+  bn as FormBuilder,
+  Je as FormRenderer,
+  pn as FormSubmissionBrowser,
+  fn as FormSubmissionViewer,
+  Ne as MultiSelectField,
+  Ei as MultiSelectInput,
+  we as MultiStringField,
+  Si as MultiStringInput,
+  ue as NumberField,
+  yi as NumberInput,
+  mn as PatchField,
+  gn as PatchFormProvider,
+  Ie as SelectField,
+  xi as SelectInput,
+  fe as StringField,
+  wi as StringInput,
+  he as TextField,
+  Ii as TextInput,
+  De as deserialize,
+  bt as deserializeField,
+  yt as formRevisionToSchema,
+  vt as isConditionMet,
+  Ce as useFieldInput,
+  wt as useFieldInputs
+};