@stachelock/ui 0.6.2 → 0.6.4

package/dist/inputs/AddressInput.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/inputs/AddressInput.js

@@ -0,0 +1,639 @@
+import { defineComponent as me, inject as ye, onMounted as pe, ref as S, reactive as ve, computed as T, watch as be, createElementBlock as A, openBlock as p, createVNode as m, unref as g, withCtx as k, createElementVNode as y, createCommentVNode as L, normalizeClass as w, createBlock as U, Fragment as he, renderList as xe, toDisplayString as R, resolveDynamicComponent as ke, createTextVNode as Z } from "vue";
+import { Combobox as we, ComboboxInput as Ce, ComboboxButton as Ie, TransitionRoot as H, ComboboxOptions as Se, ComboboxOption as Ae } from "@headlessui/vue";
+import { LockClosedIcon as ze, MagnifyingGlassIcon as Ke, CheckIcon as Ge, ChevronDownIcon as Me, ChevronUpIcon as Te } from "@heroicons/vue/20/solid";
+import { ClockIcon as W, ExclamationCircleIcon as Ue, CheckCircleIcon as $e } from "@heroicons/vue/24/outline";
+import { useField as Ee } from "vee-validate";
+import { debounce as Q } from "lodash-es";
+import Oe from "../forms/FormFieldWrapper.js";
+import z from "./TextInput.js";
+import { g as Pe } from "../id-DafBB_QF.js";
+import { Loader as Le } from "@googlemaps/js-api-loader";
+import { _ as Re } from "../_plugin-vue_export-helper-CHgC5LLL.js";
+let v = null, M = null, $ = null, K = null, N = !1;
+const G = /* @__PURE__ */ new Map(), Ne = 1e3, Fe = 1e3 * 60 * 60 * 24;
+function Be(e) {
+  v = e, N = !1, K = null, $ = null, M = null;
+}
+function De() {
+  return v !== null && !!v.apiKey;
+}
+async function F() {
+  if (!N) {
+    if (K)
+      return K;
+    if (!v?.apiKey)
+      throw new Error(
+        '[Geocoding] API key not configured. Call configureGeocoding({ apiKey: "..." }) first, or configure via StachelockUI plugin with googleMaps.apiKey option.'
+      );
+    return K = (async () => {
+      try {
+        await new Le({
+          apiKey: v.apiKey,
+          version: v.version || "weekly",
+          id: "__stachelockGoogleMapsScriptId",
+          libraries: v.libraries || ["places", "maps", "geometry"]
+        }).load(), $ = await google.maps.importLibrary("places"), M = new google.maps.Geocoder(), N = !0;
+      } catch (e) {
+        throw K = null, console.error("[Geocoding] Error loading Google Maps API:", e), e;
+      }
+    })(), K;
+  }
+}
+function X(e) {
+  return e.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function J(e) {
+  return typeof e == "string" ? `str:${X(e)}` : `pid:${e.placeId}`;
+}
+function Y(e) {
+  const o = G.get(e);
+  return o ? Date.now() - o.ts > Fe ? (G.delete(e), null) : o.result : null;
+}
+function q(e, o) {
+  try {
+    if (G.size >= Ne) {
+      const c = G.keys().next().value;
+      c && G.delete(c);
+    }
+    G.set(e, { result: o, ts: Date.now() });
+  } catch {
+  }
+}
+function ee(e, o = 15, c = "200x200") {
+  if (!v?.apiKey) return "";
+  const i = v.staticMapsApiKey || v.apiKey, r = "https://maps.googleapis.com/maps/api/staticmap", d = new URLSearchParams({
+    center: `${e.lat},${e.lng}`,
+    zoom: o.toString(),
+    size: c,
+    key: i,
+    markers: `color:red|${e.lat},${e.lng}`
+  });
+  return `${r}?${d.toString()}`;
+}
+async function Ve(e) {
+  if (!e?.trim())
+    return {
+      status: "INVALID_INPUT",
+      message: "No placeId provided for geocoding."
+    };
+  await F();
+  const o = J({ placeId: e }), c = Y(o);
+  return c || new Promise((i) => {
+    if (!M) {
+      i({
+        status: "ERROR",
+        message: "Geocoder service not initialized."
+      });
+      return;
+    }
+    M.geocode({ placeId: e }, (r, d) => {
+      if (d === google.maps.GeocoderStatus.OK && r && r.length > 0) {
+        const u = r[0], n = u.geometry ? {
+          lat: u.geometry.location.lat(),
+          lng: u.geometry.location.lng()
+        } : void 0, h = {
+          status: "OK",
+          message: "Found address",
+          address_components: u.address_components || [],
+          location: n,
+          formatted_address: u.formatted_address || "",
+          thumbnailUrl: n ? ee(n) : void 0
+        };
+        q(o, h), i(h);
+      } else
+        i({
+          status: d.toString(),
+          message: `Unable to geocode place: ${d}`
+        });
+    });
+  });
+}
+function _e(e) {
+  const o = X(e);
+  if (o.length < 10) return !1;
+  const c = /\d/.test(o), i = o.includes(","), r = /\b([A-Z]{2})\b/i.test(e), d = /\b\d{5}(?:-\d{4})?\b/.test(o);
+  return (i || r || d) && c;
+}
+async function je(e) {
+  if (!e?.trim())
+    return {
+      status: "INVALID_INPUT",
+      message: "No address provided for geocoding."
+    };
+  if (!_e(e))
+    return {
+      status: "INVALID_INPUT",
+      message: "Insufficient address information for geocoding."
+    };
+  await F();
+  const o = J(e), c = Y(o);
+  return c || new Promise((i) => {
+    if (!M) {
+      i({
+        status: "ERROR",
+        message: "Geocoder service not initialized."
+      });
+      return;
+    }
+    M.geocode({ address: e }, (r, d) => {
+      if (d === google.maps.GeocoderStatus.OK && r && r.length > 0) {
+        const u = r[0], n = u.geometry ? {
+          lat: u.geometry.location.lat(),
+          lng: u.geometry.location.lng()
+        } : void 0, h = {
+          status: "OK",
+          message: "Found address",
+          address_components: u.address_components || [],
+          location: n,
+          formatted_address: u.formatted_address || "",
+          thumbnailUrl: n ? ee(n) : void 0
+        };
+        q(o, h), i(h);
+      } else
+        i({
+          status: d.toString(),
+          message: `Unable to geocode address: ${d}`
+        });
+    });
+  });
+}
+async function Ze(e, o) {
+  if (!e?.trim())
+    return [];
+  if (await F(), !$)
+    return console.warn("[Geocoding] Places library not initialized"), [];
+  try {
+    const { AutocompleteSuggestion: c } = $, i = {
+      input: e,
+      ...o?.includedPrimaryTypes && { includedPrimaryTypes: o.includedPrimaryTypes },
+      ...o?.includedRegionCodes && { includedRegionCodes: o.includedRegionCodes }
+    }, { suggestions: r } = await c.fetchAutocompleteSuggestions(i);
+    return r.filter(
+      (u) => u.placePrediction !== null
+    ).map((u) => {
+      const n = u.placePrediction;
+      return {
+        placeId: n.placeId,
+        description: n.text.toString(),
+        mainText: n.mainText?.toString() || n.text.toString(),
+        secondaryText: n.secondaryText?.toString() || "",
+        types: n.types || []
+      };
+    });
+  } catch (c) {
+    return console.error("[Geocoding] Error fetching autocomplete suggestions:", c), [];
+  }
+}
+function He(e) {
+  const o = {
+    street: "",
+    city: "",
+    state: "",
+    zipcode: "",
+    country: ""
+  };
+  if (!e?.address_components)
+    return o;
+  let c = "", i = "";
+  for (const r of e.address_components) {
+    const d = r.types;
+    d.includes("street_number") ? c = r.long_name : d.includes("route") ? i = r.long_name : d.includes("locality") ? o.city = r.long_name : d.includes("administrative_area_level_1") ? o.state = r.short_name : d.includes("postal_code") ? o.zipcode = r.long_name : d.includes("country") && (o.country = r.short_name);
+  }
+  return o.street = [c, i].filter(Boolean).join(" "), o;
+}
+function We(e) {
+  return [
+    e.street,
+    e.city,
+    e.state && e.zipcode ? `${e.state} ${e.zipcode}` : e.state || e.zipcode,
+    e.country
+  ].filter(Boolean).join(", ");
+}
+const Qe = { class: "sl-address-input" }, Xe = { class: "sl-space-y-3" }, Je = { class: "sl-relative" }, Ye = { class: "sl-flex sl-flex-col" }, qe = {
+  key: 0,
+  class: "sl-flex sl-items-center sl-justify-between"
+}, et = { class: "sl-flex sl-items-center sl-gap-2" }, tt = { class: "sl-grid sl-grid-cols-1 sm:sl-grid-cols-2 sl-gap-3 sl-p-3 sl-bg-gray-50 dark:sl-bg-slate-800/50 sl-rounded-lg sl-border sl-border-gray-200 dark:sl-border-slate-700" }, st = { class: "sm:sl-col-span-2" }, lt = /* @__PURE__ */ me({
+  __name: "AddressInput",
+  props: {
+    name: {},
+    modelValue: {},
+    label: { default: "" },
+    placeholder: { default: "Search for an address..." },
+    disabled: { type: Boolean, default: !1 },
+    rules: {},
+    showSuggestionCount: { type: Boolean, default: !1 },
+    allowManualEntry: { type: Boolean, default: !0 },
+    successMessage: { default: "" },
+    tertiaryLabel: { default: "" },
+    validateOnMount: { type: Boolean, default: !1 }
+  },
+  emits: ["update:modelValue", "blur", "focus"],
+  setup(e, { expose: o, emit: c }) {
+    const i = e, r = c, d = Pe(i.name || "address-input"), u = ye("googleMaps", void 0);
+    pe(() => {
+      u?.apiKey && !De() && Be({
+        apiKey: u.apiKey,
+        version: u.version,
+        libraries: u.libraries
+      });
+    });
+    const { value: n, errorMessage: h, meta: E, handleChange: O, setTouched: te } = Ee(
+      () => i.name,
+      i.rules,
+      {
+        validateOnMount: i.validateOnMount,
+        initialValue: i.modelValue
+      }
+    ), b = S([]), P = S(null), B = S(""), C = S(!1), D = S(!1), f = S("unverified"), s = ve({
+      street: "",
+      suite: "",
+      city: "",
+      state: "",
+      zipcode: "",
+      country: ""
+    }), V = T(() => !!(n.value?.formattedAddress || n.value?.street)), se = T(() => i.showSuggestionCount && b.value.length > 0 ? `${b.value.length} suggestions` : i.tertiaryLabel), _ = T(() => {
+      switch (f.value) {
+        case "verified":
+          return "sl-text-green-600 dark:sl-text-green-400";
+        case "error":
+          return "sl-text-red-600 dark:sl-text-red-400";
+        case "pending":
+          return "sl-text-yellow-600 dark:sl-text-yellow-400";
+        default:
+          return "sl-text-gray-500 dark:sl-text-slate-400";
+      }
+    }), le = T(() => {
+      switch (f.value) {
+        case "verified":
+          return "Verified";
+        case "error":
+          return "Not verified";
+        case "pending":
+          return "Verifying...";
+        default:
+          return "Unverified";
+      }
+    }), ae = T(() => {
+      switch (f.value) {
+        case "verified":
+          return $e;
+        case "error":
+          return Ue;
+        case "pending":
+          return W;
+        default:
+          return W;
+      }
+    }), oe = Q(async (l) => {
+      if (!l || l.length < 3) {
+        b.value = [];
+        return;
+      }
+      D.value = !0;
+      try {
+        const t = await Ze(l);
+        b.value = t;
+      } catch (t) {
+        console.error("[AddressInput] Error fetching suggestions:", t), b.value = [];
+      } finally {
+        D.value = !1;
+      }
+    }, 300);
+    function re(l) {
+      const t = l.target;
+      B.value = t.value, oe(t.value);
+    }
+    function ne(l) {
+      return l ? l.description : n.value?.formattedAddress ? n.value.formattedAddress : "";
+    }
+    async function ie(l) {
+      if (l) {
+        f.value = "pending", b.value = [];
+        try {
+          const t = await Ve(l.placeId);
+          if (t.status === "OK") {
+            f.value = "verified";
+            const a = He(t);
+            s.street = a.street, s.city = a.city, s.state = a.state, s.zipcode = a.zipcode, s.country = a.country;
+            const x = {
+              formattedAddress: t.formatted_address,
+              street: a.street,
+              suite: s.suite,
+              city: a.city,
+              state: a.state,
+              zipcode: a.zipcode,
+              country: a.country,
+              geocode: t,
+              placeId: l.placeId
+            };
+            n.value = x, O(x), r("update:modelValue", x), C.value = !0;
+          } else
+            f.value = "error", console.warn("[AddressInput] Geocoding failed:", t.message);
+        } catch (t) {
+          f.value = "error", console.error("[AddressInput] Geocoding error:", t);
+        }
+      }
+    }
+    const de = ["street", "city", "state", "zipcode", "country"], ce = Q(async () => {
+      const l = We(s);
+      if (!l || l.length < 10) {
+        f.value = "unverified";
+        return;
+      }
+      f.value = "pending";
+      try {
+        const t = await je(l);
+        if (t.status === "OK") {
+          f.value = "verified";
+          const a = {
+            formattedAddress: t.formatted_address,
+            street: s.street,
+            suite: s.suite,
+            city: s.city,
+            state: s.state,
+            zipcode: s.zipcode,
+            country: s.country,
+            geocode: t,
+            placeId: void 0
+            // Clear placeId since we re-geocoded
+          };
+          n.value = a, O(a), r("update:modelValue", a);
+        } else
+          f.value = "unverified";
+      } catch (t) {
+        f.value = "error", console.error("[AddressInput] Re-geocoding error:", t);
+      }
+    }, 600);
+    function I(l) {
+      const t = {
+        ...n.value,
+        street: s.street,
+        suite: s.suite,
+        city: s.city,
+        state: s.state,
+        zipcode: s.zipcode,
+        country: s.country
+      };
+      de.includes(l) && (f.value = "unverified", t.geocode = void 0, ce()), n.value = t, O(t), r("update:modelValue", t);
+    }
+    function ue(l) {
+      r("focus", l);
+    }
+    function fe(l) {
+      te(!0), r("blur", l);
+    }
+    be(
+      () => i.modelValue,
+      (l) => {
+        l && (l.geocode?.status === "OK" ? f.value = "verified" : l.geocode?.status === "ERROR" && (f.value = "error"), l !== n.value && (n.value = l, l.street !== void 0 && (s.street = l.street), l.suite !== void 0 && (s.suite = l.suite), l.city !== void 0 && (s.city = l.city), l.state !== void 0 && (s.state = l.state), l.zipcode !== void 0 && (s.zipcode = l.zipcode), l.country !== void 0 && (s.country = l.country)));
+      },
+      { immediate: !0, deep: !0 }
+    );
+    function ge() {
+      n.value = void 0, P.value = null, B.value = "", b.value = [], C.value = !1, f.value = "unverified", s.street = "", s.suite = "", s.city = "", s.state = "", s.zipcode = "", s.country = "";
+    }
+    return o({
+      resetInput: ge,
+      geocodeStatus: f,
+      meta: E,
+      errorMessage: h
+    }), (l, t) => (p(), A("div", Qe, [
+      m(Oe, {
+        id: g(d),
+        name: e.name,
+        label: e.label,
+        "tertiary-label": se.value,
+        "error-message": g(h),
+        "success-message": e.successMessage,
+        "is-valid": g(E).valid,
+        "is-touched": g(E).touched,
+        disabled: e.disabled
+      }, {
+        default: k(() => [
+          y("div", Xe, [
+            m(g(we), {
+              modelValue: P.value,
+              "onUpdate:modelValue": [
+                t[0] || (t[0] = (a) => P.value = a),
+                ie
+              ],
+              disabled: e.disabled,
+              nullable: ""
+            }, {
+              default: k(() => [
+                y("div", Je, [
+                  m(g(Ce), {
+                    id: g(d),
+                    "display-value": ne,
+                    placeholder: e.placeholder || "Search for an address...",
+                    disabled: e.disabled,
+                    class: w([
+                      "sl-block sl-w-full sl-rounded-lg sl-border sl-py-2.5 sl-pl-3 sl-pr-10 sl-text-sm focus:sl-outline-none",
+                      e.disabled ? "sl-border-gray-200 dark:sl-border-slate-700 sl-bg-gray-50 dark:sl-bg-slate-800 sl-text-gray-500 dark:sl-text-slate-400 sl-cursor-not-allowed" : "sl-border-gray-300 dark:sl-border-slate-600 sl-bg-white dark:sl-bg-slate-900 sl-text-gray-900 dark:sl-text-slate-100 placeholder:sl-text-gray-400 dark:placeholder:sl-text-slate-500 focus:sl-border-stachelock-500 focus:sl-ring-2 focus:sl-ring-stachelock-500"
+                    ]),
+                    onChange: re,
+                    onFocus: ue,
+                    onBlur: fe
+                  }, null, 8, ["id", "placeholder", "disabled", "class"]),
+                  m(g(Ie), { class: "sl-absolute sl-inset-y-0 sl-right-0 sl-flex sl-items-center sl-pr-2" }, {
+                    default: k(() => [
+                      e.disabled ? (p(), U(g(ze), {
+                        key: 0,
+                        class: "sl-h-5 sl-w-5 sl-text-gray-400 dark:sl-text-slate-500",
+                        "aria-hidden": "true"
+                      })) : (p(), U(g(Ke), {
+                        key: 1,
+                        class: "sl-h-5 sl-w-5 sl-text-gray-400 dark:sl-text-slate-400",
+                        "aria-hidden": "true"
+                      }))
+                    ]),
+                    _: 1
+                  }),
+                  m(g(H), {
+                    leave: "sl-transition sl-ease-in sl-duration-100",
+                    "leave-from": "sl-opacity-100",
+                    "leave-to": "sl-opacity-0"
+                  }, {
+                    default: k(() => [
+                      b.value.length > 0 ? (p(), U(g(Se), {
+                        key: 0,
+                        class: "sl-absolute sl-z-50 sl-mt-1 sl-max-h-60 sl-w-full sl-overflow-auto sl-rounded-md sl-bg-white dark:sl-bg-slate-800 sl-py-1 sl-text-base sl-shadow-lg dark:sl-shadow-slate-900/50 sl-ring-1 sl-ring-black sl-ring-opacity-5 dark:sl-ring-slate-700 focus:sl-outline-none sm:sl-text-sm"
+                      }, {
+                        default: k(() => [
+                          (p(!0), A(he, null, xe(b.value, (a) => (p(), U(g(Ae), {
+                            key: a.placeId,
+                            value: a,
+                            as: "template"
+                          }, {
+                            default: k(({ active: x, selected: j }) => [
+                              y("li", {
+                                class: w([
+                                  "sl-relative sl-cursor-pointer sl-select-none sl-py-2 sl-pl-10 sl-pr-4",
+                                  x ? "sl-bg-stachelock-600 sl-text-white" : "sl-text-gray-900 dark:sl-text-slate-200"
+                                ])
+                              }, [
+                                y("div", Ye, [
+                                  y("span", {
+                                    class: w(["sl-block sl-truncate", j ? "sl-font-medium" : "sl-font-normal"])
+                                  }, R(a.mainText), 3),
+                                  y("span", {
+                                    class: w(["sl-text-xs", x ? "sl-text-stachelock-100" : "sl-text-gray-500 dark:sl-text-slate-400"])
+                                  }, R(a.secondaryText), 3)
+                                ]),
+                                j ? (p(), A("span", {
+                                  key: 0,
+                                  class: w([
+                                    "sl-absolute sl-inset-y-0 sl-left-0 sl-flex sl-items-center sl-pl-3",
+                                    x ? "sl-text-white" : "sl-text-stachelock-600 dark:sl-text-stachelock-400"
+                                  ])
+                                }, [
+                                  m(g(Ge), {
+                                    class: "sl-h-5 sl-w-5",
+                                    "aria-hidden": "true"
+                                  })
+                                ], 2)) : L("", !0)
+                              ], 2)
+                            ]),
+                            _: 2
+                          }, 1032, ["value"]))), 128))
+                        ]),
+                        _: 1
+                      })) : L("", !0)
+                    ]),
+                    _: 1
+                  })
+                ])
+              ]),
+              _: 1
+            }, 8, ["modelValue", "disabled"]),
+            V.value && !e.disabled ? (p(), A("div", qe, [
+              y("div", et, [
+                y("span", {
+                  class: w(["sl-text-xs sl-uppercase sl-font-medium", _.value])
+                }, R(le.value), 3),
+                (p(), U(ke(ae.value), {
+                  class: w(["sl-h-4 sl-w-4", _.value])
+                }, null, 8, ["class"]))
+              ]),
+              C.value ? (p(), A("button", {
+                key: 1,
+                type: "button",
+                onClick: t[2] || (t[2] = (a) => C.value = !1),
+                class: "sl-text-xs sl-text-gray-500 dark:sl-text-slate-400 hover:sl-underline sl-flex sl-items-center sl-gap-1"
+              }, [
+                t[10] || (t[10] = Z(" Collapse ", -1)),
+                m(g(Te), { class: "sl-h-3 sl-w-3" })
+              ])) : (p(), A("button", {
+                key: 0,
+                type: "button",
+                onClick: t[1] || (t[1] = (a) => C.value = !0),
+                class: "sl-text-xs sl-text-stachelock-600 dark:sl-text-stachelock-400 hover:sl-underline sl-flex sl-items-center sl-gap-1"
+              }, [
+                t[9] || (t[9] = Z(" Edit address ", -1)),
+                m(g(Me), { class: "sl-h-3 sl-w-3" })
+              ]))
+            ])) : L("", !0),
+            m(g(H), {
+              show: C.value && V.value && !e.disabled,
+              enter: "sl-transition sl-ease-out sl-duration-200",
+              "enter-from": "sl-opacity-0 sl-transform sl--translate-y-2",
+              "enter-to": "sl-opacity-100 sl-transform sl-translate-y-0",
+              leave: "sl-transition sl-ease-in sl-duration-150",
+              "leave-from": "sl-opacity-100 sl-transform sl-translate-y-0",
+              "leave-to": "sl-opacity-0 sl-transform sl--translate-y-2"
+            }, {
+              default: k(() => [
+                y("div", tt, [
+                  y("div", st, [
+                    m(z, {
+                      name: `${e.name}_street`,
+                      label: "Street Address",
+                      value: s.street,
+                      disabled: e.disabled,
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[3] || (t[3] = (a) => {
+                        s.street = a, I("street");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ]),
+                  y("div", null, [
+                    m(z, {
+                      name: `${e.name}_suite`,
+                      label: "Suite / Apt",
+                      value: s.suite,
+                      disabled: e.disabled,
+                      placeholder: "Optional",
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[4] || (t[4] = (a) => {
+                        s.suite = a, I("suite");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ]),
+                  y("div", null, [
+                    m(z, {
+                      name: `${e.name}_city`,
+                      label: "City",
+                      value: s.city,
+                      disabled: e.disabled,
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[5] || (t[5] = (a) => {
+                        s.city = a, I("city");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ]),
+                  y("div", null, [
+                    m(z, {
+                      name: `${e.name}_state`,
+                      label: "State",
+                      value: s.state,
+                      disabled: e.disabled,
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[6] || (t[6] = (a) => {
+                        s.state = a, I("state");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ]),
+                  y("div", null, [
+                    m(z, {
+                      name: `${e.name}_zipcode`,
+                      label: "ZIP Code",
+                      value: s.zipcode,
+                      disabled: e.disabled,
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[7] || (t[7] = (a) => {
+                        s.zipcode = a, I("zipcode");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ]),
+                  y("div", null, [
+                    m(z, {
+                      name: `${e.name}_country`,
+                      label: "Country",
+                      value: s.country,
+                      disabled: e.disabled,
+                      "show-valid-check": !1,
+                      "colorful-validation": !1,
+                      "onUpdate:value": t[8] || (t[8] = (a) => {
+                        s.country = a, I("country");
+                      })
+                    }, null, 8, ["name", "value", "disabled"])
+                  ])
+                ])
+              ]),
+              _: 1
+            }, 8, ["show"])
+          ])
+        ]),
+        _: 1
+      }, 8, ["id", "name", "label", "tertiary-label", "error-message", "success-message", "is-valid", "is-touched", "disabled"])
+    ]));
+  }
+}), yt = /* @__PURE__ */ Re(lt, [["__scopeId", "data-v-d65320d7"]]);
+export {
+  yt as default
+};

package/dist/inputs/ImageDropzoneInput.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/inputs/ImageDropzoneInput.js

@@ -0,0 +1,4 @@
+import { _ as f } from "../ImageDropzoneInput.vue_vue_type_script_setup_true_lang-7JWDfxD2.js";
+export {
+  f as default
+};

package/dist/src/components/avatars/AvatarIcon.d.ts

@@ -0,0 +1,18 @@
+import { FunctionalComponent, HTMLAttributes, VNodeProps } from 'vue';
+export type RoundedType = 'square' | 'rounded' | 'rounded-md' | 'rounded-lg' | 'rounded-full';
+type __VLS_Props = {
+    /** Size of the avatar (Tailwind scale) */
+    size: number;
+    /** Background color class or CSS color */
+    color: string;
+    /** Fallback initials */
+    initials: string;
+    /** Vue component to render as icon */
+    iconComponent?: FunctionalComponent<HTMLAttributes & VNodeProps>;
+    /** Corner rounding style */
+    rounded?: RoundedType;
+    /** Additional classes for the icon */
+    classes?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSpanElement>;
+export default _default;