@wrdagency/blockout 1.0.13 → 1.0.17

package/dist/combobox-popover-DcwyOnhG.js

@@ -0,0 +1,650 @@
+import { u as Xe } from "./5JTVDSTH-DcfjjEya.js";
+import { a as Ye } from "./WMYDSCNQ-D4CU76mX.js";
+import { a as me, C as Ze, b as ye, c as et, d as tt, e as Ee, u as ot, f as nt } from "./S43UC3DV-CiBKpqp8.js";
+import { I as rt, S as st, V as D, T as te, U as G, a1 as lt, x as ut, a7 as at, m as B, o as E, W as Ie, f as ne, c as re, a as se, _ as le, i as ue, a8 as it, a9 as ct, y as Oe, aa as ce, ab as dt, e as U, B as ft, b as de, j as R, G as mt, q as we, n as Ae, a0 as vt, a4 as ke, $ as pt, K as bt, s as Ct, O as St, P as gt, k as xt, l as _e, ac as ht, r as Ot, C as Pt } from "./LMDWO4NN-CIZvvtic.js";
+import { h as fe } from "./PFRGBC2K-B9ko--FF.js";
+import { m as Vt, p as yt, t as Et, c as It, s as X, e as J, g as wt, b as At, d as oe, u as kt, a as _t } from "./YV4JVR4I-w1-dnslS.js";
+import { createContext as Le, useRef as j, useState as Te, useEffect as Y, useMemo as Lt, useCallback as Tt, useContext as Kt } from "react";
+import { e as Dt, C as Rt } from "./P7GR5CS5-5PtDURPc.js";
+import { c as Ft, a as Bt } from "./O2PQ2652-D2GSkoLq.js";
+import { c as Mt, d as Ht, b as Nt } from "./4CMBR7SL-ChJnawVl.js";
+import { jsx as Z } from "react/jsx-runtime";
+import { u as $t } from "./UQQRIHDV-BBkcyl82.js";
+import { u as Ut } from "./6VRAQV3D-DK_p41oq.js";
+import { c as jt, u as qt } from "./G7GW6PWC-A0eDeXMt.js";
+import { i as Wt } from "./KFH4SEIX-BFT9WmYk.js";
+var wo = Le(null), Ao = Le(
+  null
+), ae = rt(
+  [Rt],
+  [Dt]
+), zt = ae.useContext, ko = ae.useProviderContext, _o = ae.ContextProvider, Lo = ae.ScopedContextProvider, Gt = ut() && at();
+function Jt(o = {}) {
+  var r = o, {
+    tag: n
+  } = r, e = st(r, [
+    "tag"
+  ]);
+  const c = Vt(e.store, yt(n, ["value", "rtl"]));
+  Et(e, c);
+  const v = n == null ? void 0 : n.getState(), u = c == null ? void 0 : c.getState(), T = D(
+    e.activeId,
+    u == null ? void 0 : u.activeId,
+    e.defaultActiveId,
+    null
+  ), P = Mt(te(G({}, e), {
+    activeId: T,
+    includesBaseElement: D(
+      e.includesBaseElement,
+      u == null ? void 0 : u.includesBaseElement,
+      !0
+    ),
+    orientation: D(
+      e.orientation,
+      u == null ? void 0 : u.orientation,
+      "vertical"
+    ),
+    focusLoop: D(e.focusLoop, u == null ? void 0 : u.focusLoop, !0),
+    focusWrap: D(e.focusWrap, u == null ? void 0 : u.focusWrap, !0),
+    virtualFocus: D(
+      e.virtualFocus,
+      u == null ? void 0 : u.virtualFocus,
+      !0
+    )
+  })), p = Ft(te(G({}, e), {
+    placement: D(
+      e.placement,
+      u == null ? void 0 : u.placement,
+      "bottom-start"
+    )
+  })), K = D(
+    e.value,
+    u == null ? void 0 : u.value,
+    e.defaultValue,
+    ""
+  ), V = D(
+    e.selectedValue,
+    u == null ? void 0 : u.selectedValue,
+    v == null ? void 0 : v.values,
+    e.defaultSelectedValue,
+    ""
+  ), f = Array.isArray(V), _ = te(G(G({}, P.getState()), p.getState()), {
+    value: K,
+    selectedValue: V,
+    resetValueOnSelect: D(
+      e.resetValueOnSelect,
+      u == null ? void 0 : u.resetValueOnSelect,
+      f
+    ),
+    resetValueOnHide: D(
+      e.resetValueOnHide,
+      u == null ? void 0 : u.resetValueOnHide,
+      f && !n
+    ),
+    activeValue: u == null ? void 0 : u.activeValue
+  }), s = It(_, P, p, c);
+  return Gt && X(
+    s,
+    () => J(s, ["virtualFocus"], () => {
+      s.setState("virtualFocus", !1);
+    })
+  ), X(s, () => {
+    if (n)
+      return lt(
+        J(s, ["selectedValue"], (a) => {
+          Array.isArray(a.selectedValue) && n.setValues(a.selectedValue);
+        }),
+        J(n, ["values"], (a) => {
+          s.setState("selectedValue", a.values);
+        })
+      );
+  }), X(
+    s,
+    () => J(s, ["resetValueOnHide", "mounted"], (a) => {
+      a.resetValueOnHide && (a.mounted || s.setState("value", K));
+    })
+  ), X(
+    s,
+    () => J(s, ["open"], (a) => {
+      a.open || (s.setState("activeId", T), s.setState("moves", 0));
+    })
+  ), X(
+    s,
+    () => J(s, ["moves", "activeId"], (a, S) => {
+      a.moves === S.moves && s.setState("activeValue", void 0);
+    })
+  ), X(
+    s,
+    () => wt(s, ["moves", "renderedItems"], (a, S) => {
+      if (a.moves === S.moves) return;
+      const { activeId: d } = s.getState(), m = P.item(d);
+      s.setState("activeValue", m == null ? void 0 : m.value);
+    })
+  ), te(G(G(G({}, p), P), s), {
+    tag: n,
+    setValue: (a) => s.setState("value", a),
+    resetValue: () => s.setState("value", _.value),
+    setSelectedValue: (a) => s.setState("selectedValue", a)
+  });
+}
+function Qt(o) {
+  const r = zt();
+  return o = B(E({}, o), {
+    tag: o.tag !== void 0 ? o.tag : r
+  }), Ht(o);
+}
+function Xt(o, r, n) {
+  return Ie(r, [n.tag]), oe(o, n, "value", "setValue"), oe(o, n, "selectedValue", "setSelectedValue"), oe(o, n, "resetValueOnHide"), oe(o, n, "resetValueOnSelect"), Object.assign(
+    Nt(
+      Bt(o, r, n),
+      r,
+      n
+    ),
+    { tag: n.tag }
+  );
+}
+function Yt(o = {}) {
+  o = Qt(o);
+  const [r, n] = At(Jt, o);
+  return Xt(r, n, o);
+}
+var Zt = "input";
+function Pe(o, r, n) {
+  if (!n) return !1;
+  const e = o.find((c) => !c.disabled && c.value);
+  return (e == null ? void 0 : e.value) === r;
+}
+function Ve(o, r) {
+  return !r || o == null ? !1 : (o = bt(o), r.length > o.length && r.toLowerCase().indexOf(o.toLowerCase()) === 0);
+}
+function eo(o) {
+  return o.type === "input";
+}
+function to(o) {
+  return o === "inline" || o === "list" || o === "both" || o === "none";
+}
+function oo(o) {
+  const r = o.find((n) => {
+    var e;
+    return n.disabled ? !1 : ((e = n.element) == null ? void 0 : e.getAttribute("role")) !== "tab";
+  });
+  return r == null ? void 0 : r.id;
+}
+var no = re(
+  function(r) {
+    var n = r, {
+      store: e,
+      focusable: c = !0,
+      autoSelect: v = !1,
+      getAutoSelectId: u,
+      setValueOnChange: T,
+      showMinLength: P = 0,
+      showOnChange: p,
+      showOnMouseDown: K,
+      showOnClick: V = K,
+      showOnKeyDown: f,
+      showOnKeyPress: _ = f,
+      blurActiveItemOnClick: s,
+      setValueOnClick: a = !0,
+      moveOnKeyPress: S = !0,
+      autoComplete: d = "list"
+    } = n, m = le(n, [
+      "store",
+      "focusable",
+      "autoSelect",
+      "getAutoSelectId",
+      "setValueOnChange",
+      "showMinLength",
+      "showOnChange",
+      "showOnMouseDown",
+      "showOnClick",
+      "showOnKeyDown",
+      "showOnKeyPress",
+      "blurActiveItemOnClick",
+      "setValueOnClick",
+      "moveOnKeyPress",
+      "autoComplete"
+    ]);
+    const k = me();
+    e = e || k, ue(
+      e,
+      process.env.NODE_ENV !== "production" && "Combobox must receive a `store` prop or be wrapped in a ComboboxProvider component."
+    );
+    const I = j(null), [M, w] = it(), x = j(!1), H = j(!1), A = e.useState(
+      (t) => t.virtualFocus && v
+    ), y = d === "inline" || d === "both", [q, Q] = Te(y);
+    ct(() => {
+      y && Q(!0);
+    }, [y]);
+    const l = e.useState("value"), g = j();
+    Y(() => J(e, ["selectedValue", "activeId"], (t, i) => {
+      g.current = i.selectedValue;
+    }), []);
+    const h = e.useState((t) => {
+      var i;
+      if (y && q && !(t.activeValue && Array.isArray(t.selectedValue) && (t.selectedValue.includes(t.activeValue) || (i = g.current) != null && i.includes(t.activeValue))))
+        return t.activeValue;
+    }), W = e.useState("renderedItems"), N = e.useState("open"), $ = e.useState("contentElement"), ee = Lt(() => {
+      if (!y || !q) return l;
+      if (Pe(
+        W,
+        h,
+        A
+      )) {
+        if (Ve(l, h)) {
+          const i = (h == null ? void 0 : h.slice(l.length)) || "";
+          return l + i;
+        }
+        return l;
+      }
+      return h || l;
+    }, [y, q, W, h, A, l]);
+    Y(() => {
+      const t = I.current;
+      if (!t) return;
+      const i = () => Q(!0);
+      return t.addEventListener("combobox-item-move", i), () => {
+        t.removeEventListener("combobox-item-move", i);
+      };
+    }, []), Y(() => {
+      if (!y || !q || !h || !Pe(
+        W,
+        h,
+        A
+      ) || !Ve(l, h)) return;
+      let i = dt;
+      return queueMicrotask(() => {
+        const b = I.current;
+        if (!b) return;
+        const { start: C, end: L } = Oe(b), F = l.length, O = h.length;
+        ce(b, F, O), i = () => {
+          if (!fe(b)) return;
+          const { start: z, end: Qe } = Oe(b);
+          z === F && Qe === O && ce(b, C, L);
+        };
+      }), () => i();
+    }, [
+      M,
+      y,
+      q,
+      h,
+      W,
+      A,
+      l
+    ]);
+    const De = j(null), ve = U(u), pe = j(null);
+    Y(() => {
+      if (!N || !$) return;
+      const t = ft($);
+      if (!t) return;
+      De.current = t;
+      const i = () => {
+        x.current = !1;
+      }, b = () => {
+        if (!e || !x.current) return;
+        const { activeId: L } = e.getState();
+        L !== null && L !== pe.current && (x.current = !1);
+      }, C = { passive: !0, capture: !0 };
+      return t.addEventListener("wheel", i, C), t.addEventListener("touchmove", i, C), t.addEventListener("scroll", b, C), () => {
+        t.removeEventListener("wheel", i, !0), t.removeEventListener("touchmove", i, !0), t.removeEventListener("scroll", b, !0);
+      };
+    }, [N, $, e]), de(() => {
+      l && (H.current || (x.current = !0));
+    }, [l]), de(() => {
+      A !== "always" && N || (x.current = N);
+    }, [A, N]);
+    const be = e.useState("resetValueOnSelect");
+    Ie(() => {
+      var t, i;
+      const b = x.current;
+      if (!e || !N || !b && !be) return;
+      const { baseElement: C, contentElement: L, activeId: F } = e.getState();
+      if (!(C && !fe(C))) {
+        if (L != null && L.hasAttribute("data-placing")) {
+          const O = new MutationObserver(w);
+          return O.observe(L, { attributeFilter: ["data-placing"] }), () => O.disconnect();
+        }
+        if (A && b) {
+          const O = ve(W), z = O !== void 0 ? O : (t = oo(W)) != null ? t : e.first();
+          pe.current = z, e.move(z ?? null);
+        } else {
+          const O = (i = e.item(F || e.first())) == null ? void 0 : i.element;
+          O && "scrollIntoView" in O && O.scrollIntoView({ block: "nearest", inline: "nearest" });
+        }
+      }
+    }, [
+      e,
+      N,
+      M,
+      l,
+      A,
+      be,
+      ve,
+      W
+    ]), Y(() => {
+      if (!y) return;
+      const t = I.current;
+      if (!t) return;
+      const i = [t, $].filter(
+        (C) => !!C
+      ), b = (C) => {
+        i.every((L) => pt(C, L)) && (e == null || e.setValue(ee));
+      };
+      for (const C of i)
+        C.addEventListener("focusout", b);
+      return () => {
+        for (const C of i)
+          C.removeEventListener("focusout", b);
+      };
+    }, [y, $, e, ee]);
+    const ie = (t) => t.currentTarget.value.length >= P, Ce = m.onChange, Re = R(p ?? ie), Fe = R(
+      // If the combobox is combined with tags, the value will be set by the tag
+      // input component.
+      T ?? !e.tag
+    ), Be = U((t) => {
+      if (Ce == null || Ce(t), t.defaultPrevented || !e) return;
+      const i = t.currentTarget, { value: b, selectionStart: C, selectionEnd: L } = i, F = t.nativeEvent;
+      if (x.current = !0, eo(F) && (F.isComposing && (x.current = !1, H.current = !0), y)) {
+        const O = F.inputType === "insertText" || F.inputType === "insertCompositionText", z = C === b.length;
+        Q(O && z);
+      }
+      if (Fe(t)) {
+        const O = b === e.getState().value;
+        e.setValue(b), queueMicrotask(() => {
+          ce(i, C, L);
+        }), y && A && O && w();
+      }
+      Re(t) && e.show(), (!A || !x.current) && e.setActiveId(null);
+    }), Se = m.onCompositionEnd, Me = U((t) => {
+      x.current = !0, H.current = !1, Se == null || Se(t), !t.defaultPrevented && A && w();
+    }), ge = m.onMouseDown, He = R(
+      s ?? (() => !!(e != null && e.getState().includesBaseElement))
+    ), Ne = R(a), $e = R(V ?? ie), Ue = U((t) => {
+      ge == null || ge(t), !t.defaultPrevented && (t.button || t.ctrlKey || e && (He(t) && e.setActiveId(null), Ne(t) && e.setValue(ee), $e(t) && mt(t.currentTarget, "mouseup", e.show)));
+    }), xe = m.onKeyDown, je = R(_ ?? ie), qe = U((t) => {
+      if (xe == null || xe(t), t.repeat || (x.current = !1), t.defaultPrevented || t.ctrlKey || t.altKey || t.shiftKey || t.metaKey || !e) return;
+      const { open: i } = e.getState();
+      i || (t.key === "ArrowUp" || t.key === "ArrowDown") && je(t) && (t.preventDefault(), e.show());
+    }), he = m.onBlur, We = U((t) => {
+      x.current = !1, he == null || he(t), t.defaultPrevented;
+    }), ze = we(m.id), Ge = to(d) ? d : void 0, Je = e.useState((t) => t.activeId === null);
+    return m = B(E({
+      id: ze,
+      role: "combobox",
+      "aria-autocomplete": Ge,
+      "aria-haspopup": vt($, "listbox"),
+      "aria-expanded": N,
+      "aria-controls": $ == null ? void 0 : $.id,
+      "data-active-item": Je || void 0,
+      value: ee
+    }, m), {
+      ref: Ae(I, m.ref),
+      onChange: Be,
+      onCompositionEnd: Me,
+      onMouseDown: Ue,
+      onKeyDown: qe,
+      onBlur: We
+    }), m = Xe(B(E({
+      store: e,
+      focusable: c
+    }, m), {
+      // Enable inline autocomplete when the user moves from the combobox input
+      // to an item.
+      moveOnKeyPress: (t) => ke(S, t) ? !1 : (y && Q(!0), !0)
+    })), m = Ye(E({ store: e }, m)), E({ autoComplete: "off" }, m);
+  }
+), To = ne(function(r) {
+  const n = no(r);
+  return se(Zt, n);
+});
+function Ko(o = {}) {
+  const r = Yt(o);
+  return /* @__PURE__ */ Z(Ze, { value: r, children: o.children });
+}
+var ro = "div";
+function so(o, r) {
+  if (r != null)
+    return o == null ? !1 : Array.isArray(o) ? o.includes(r) : o === r;
+}
+function lo(o) {
+  var r;
+  return (r = {
+    menu: "menuitem",
+    listbox: "option",
+    tree: "treeitem"
+  }[o]) != null ? r : "option";
+}
+var uo = re(
+  function(r) {
+    var n = r, {
+      store: e,
+      value: c,
+      hideOnClick: v,
+      setValueOnClick: u,
+      selectValueOnClick: T = !0,
+      resetValueOnSelect: P,
+      focusOnHover: p = !1,
+      moveOnKeyPress: K = !0,
+      getItem: V
+    } = n, f = le(n, [
+      "store",
+      "value",
+      "hideOnClick",
+      "setValueOnClick",
+      "selectValueOnClick",
+      "resetValueOnSelect",
+      "focusOnHover",
+      "moveOnKeyPress",
+      "getItem"
+    ]), _;
+    const s = ye();
+    e = e || s, ue(
+      e,
+      process.env.NODE_ENV !== "production" && "ComboboxItem must be wrapped in a ComboboxList or ComboboxPopover component."
+    );
+    const { resetValueOnSelectState: a, multiSelectable: S, selected: d } = kt(e, {
+      resetValueOnSelectState: "resetValueOnSelect",
+      multiSelectable(l) {
+        return Array.isArray(l.selectedValue);
+      },
+      selected(l) {
+        return so(l.selectedValue, c);
+      }
+    }), m = Tt(
+      (l) => {
+        const g = B(E({}, l), { value: c });
+        return V ? V(g) : g;
+      },
+      [c, V]
+    );
+    u = u ?? !S, v = v ?? (c != null && !S);
+    const k = f.onClick, I = R(u), M = R(T), w = R(
+      (_ = P ?? a) != null ? _ : S
+    ), x = R(v), H = U((l) => {
+      k == null || k(l), !l.defaultPrevented && (St(l) || gt(l) || (c != null && (M(l) && (w(l) && (e == null || e.resetValue()), e == null || e.setSelectedValue((g) => Array.isArray(g) ? g.includes(c) ? g.filter((h) => h !== c) : [...g, c] : c)), I(l) && (e == null || e.setValue(c))), x(l) && (e == null || e.hide())));
+    }), A = f.onKeyDown, y = U((l) => {
+      if (A == null || A(l), l.defaultPrevented) return;
+      const g = e == null ? void 0 : e.getState().baseElement;
+      if (!g || fe(g)) return;
+      (l.key.length === 1 || l.key === "Backspace" || l.key === "Delete") && (queueMicrotask(() => g.focus()), xt(g) && (e == null || e.setValue(g.value)));
+    });
+    S && d != null && (f = E({
+      "aria-selected": d
+    }, f)), f = _e(
+      f,
+      (l) => /* @__PURE__ */ Z(et.Provider, { value: c, children: /* @__PURE__ */ Z(tt.Provider, { value: d ?? !1, children: l }) }),
+      [c, d]
+    );
+    const q = Kt(Ee);
+    f = B(E({
+      role: lo(q),
+      children: c
+    }, f), {
+      onClick: H,
+      onKeyDown: y
+    });
+    const Q = R(K);
+    return f = Ut(B(E({
+      store: e
+    }, f), {
+      getItem: m,
+      // Dispatch a custom event on the combobox input when moving to an item
+      // with the keyboard so the Combobox component can enable inline
+      // autocompletion.
+      moveOnKeyPress: (l) => {
+        if (!Q(l)) return !1;
+        const g = new Event("combobox-item-move"), h = e == null ? void 0 : e.getState().baseElement;
+        return h == null || h.dispatchEvent(g), !0;
+      }
+    })), f = $t(E({ store: e, focusOnHover: p }, f)), f;
+  }
+), Do = Ct(
+  ne(function(r) {
+    const n = uo(r);
+    return se(ro, n);
+  })
+), ao = "div", Ke = re(
+  function(r) {
+    var n = r, { store: e, alwaysVisible: c } = n, v = le(n, ["store", "alwaysVisible"]);
+    const u = ye(!0), T = ot();
+    e = e || T;
+    const P = !!e && e === u;
+    ue(
+      e,
+      process.env.NODE_ENV !== "production" && "ComboboxList must receive a `store` prop or be wrapped in a ComboboxProvider component."
+    );
+    const p = j(null), K = we(v.id), V = e.useState("mounted"), f = Wt(V, v.hidden, c), _ = f ? B(E({}, v.style), { display: "none" }) : v.style, s = e.useState(
+      (w) => Array.isArray(w.selectedValue)
+    ), a = ht(p, "role", v.role), d = (a === "listbox" || a === "tree" || a === "grid") && s || void 0, [m, k] = Te(!1), I = e.useState("contentElement");
+    de(() => {
+      if (!V) return;
+      const w = p.current;
+      if (!w || I !== w) return;
+      const x = () => {
+        k(!!w.querySelector("[role='listbox']"));
+      }, H = new MutationObserver(x);
+      return H.observe(w, {
+        subtree: !0,
+        childList: !0,
+        attributeFilter: ["role"]
+      }), x(), () => H.disconnect();
+    }, [V, I]), m || (v = E({
+      role: "listbox",
+      "aria-multiselectable": d
+    }, v)), v = _e(
+      v,
+      (w) => /* @__PURE__ */ Z(nt, { value: e, children: /* @__PURE__ */ Z(Ee.Provider, { value: a, children: w }) }),
+      [e, a]
+    );
+    const M = K && (!u || !P) ? e.setContentElement : null;
+    return v = B(E({
+      id: K,
+      hidden: f
+    }, v), {
+      ref: Ae(M, p, v.ref),
+      style: _
+    }), Ot(v);
+  }
+), Ro = ne(function(r) {
+  const n = Ke(r);
+  return se(ao, n);
+}), io = "div";
+function co(o, ...r) {
+  if (!o) return !1;
+  if ("id" in o) {
+    const n = r.filter(Boolean).map((e) => `[aria-controls~="${e}"]`).join(", ");
+    return n ? o.matches(n) : !1;
+  }
+  return !1;
+}
+var fo = re(
+  function(r) {
+    var n = r, {
+      store: e,
+      modal: c,
+      tabIndex: v,
+      alwaysVisible: u,
+      autoFocusOnHide: T = !0,
+      hideOnInteractOutside: P = !0
+    } = n, p = le(n, [
+      "store",
+      "modal",
+      "tabIndex",
+      "alwaysVisible",
+      "autoFocusOnHide",
+      "hideOnInteractOutside"
+    ]);
+    const K = me();
+    e = e || K, ue(
+      e,
+      process.env.NODE_ENV !== "production" && "ComboboxPopover must receive a `store` prop or be wrapped in a ComboboxProvider component."
+    );
+    const V = e.useState("baseElement"), f = j(!1), _ = _t(
+      e.tag,
+      (s) => s == null ? void 0 : s.renderedItems.length
+    );
+    return p = Ke(E({ store: e, alwaysVisible: u }, p)), p = qt(B(E({
+      store: e,
+      modal: c,
+      alwaysVisible: u,
+      backdrop: !1,
+      autoFocusOnShow: !1,
+      finalFocus: V,
+      preserveTabOrderAnchor: null,
+      unstable_treeSnapshotKey: _
+    }, p), {
+      // When the combobox popover is modal, we make sure to include the
+      // combobox input and all the combobox controls (cancel, disclosure) in
+      // the list of persistent elements so they make part of the modal context,
+      // allowing users to tab through them.
+      getPersistentElements() {
+        var s;
+        const a = ((s = p.getPersistentElements) == null ? void 0 : s.call(p)) || [];
+        if (!c || !e) return a;
+        const { contentElement: S, baseElement: d } = e.getState();
+        if (!d) return a;
+        const m = Pt(d), k = [];
+        if (S != null && S.id && k.push(`[aria-controls~="${S.id}"]`), d != null && d.id && k.push(`[aria-controls~="${d.id}"]`), !k.length) return [...a, d];
+        const I = k.join(","), M = m.querySelectorAll(I);
+        return [...a, ...M];
+      },
+      // The combobox popover should focus on the combobox input when it hides,
+      // unless the event was triggered by a click outside the popover, in which
+      // case the input shouldn't be re-focused.
+      autoFocusOnHide(s) {
+        return ke(T, s) ? !1 : f.current ? (f.current = !1, !1) : !0;
+      },
+      // Make sure we don't hide the popover when the user interacts with the
+      // combobox cancel or the combobox disclosure buttons. They will have the
+      // aria-controls attribute pointing to either the combobox input or the
+      // combobox popover elements.
+      hideOnInteractOutside(s) {
+        var a, S;
+        const d = e == null ? void 0 : e.getState(), m = (a = d == null ? void 0 : d.contentElement) == null ? void 0 : a.id, k = (S = d == null ? void 0 : d.baseElement) == null ? void 0 : S.id;
+        if (co(s.target, m, k)) return !1;
+        const I = typeof P == "function" ? P(s) : P;
+        return I && (f.current = s.type === "click"), I;
+      }
+    })), p;
+  }
+), Fo = jt(
+  ne(function(r) {
+    const n = fo(r);
+    return se(io, n);
+  }),
+  me
+);
+export {
+  Ko as C,
+  wo as T,
+  To as a,
+  Fo as b,
+  Ro as c,
+  Do as d,
+  Ao as e,
+  ko as f,
+  Lo as g,
+  _o as h,
+  Yt as i,
+  zt as u
+};

package/dist/components/avatar/index.d.ts

@@ -1,10 +1,12 @@
-import { FC } from 'react';
+import { FC, HTMLAttributeAnchorTarget } from 'react';
 interface AvatarProps {
     className?: string;
     image?: string;
     name?: string;
-    size?: "small" | "normal" | "large";
+    size?: "x-small" | "small" | "medium" | "large" | "x-large";
     withName?: boolean;
+    href?: string;
+    target?: HTMLAttributeAnchorTarget;
 }
 export declare const Avatar: FC<AvatarProps>;
 export {};