@uva-glass/component-library 1.38.0 → 1.40.0

package/dist/components/IconButton/IconButton.stories.js

@@ -1,5 +1,5 @@
 import { jsx as o } from "react/jsx-runtime";
-import { f as a } from "../../index-CPfft0rG.js";
+import { f as a } from "../../index-0Faxlks_.js";
 import { IconButton as e } from "./IconButton.js";
 import { Icon as l } from "../Icon/Icon.js";
 const m = {

package/dist/components/InputField/InputField.stories.js

@@ -1,6 +1,6 @@
 import { jsx as e } from "react/jsx-runtime";
 import { useState as d, useRef as g } from "react";
-import { f as i } from "../../index-CPfft0rG.js";
+import { f as i } from "../../index-0Faxlks_.js";
 import { InputField as l } from "./InputField.js";
 import { Container as u } from "../storyComponents/Container/Container.js";
 import { Icon as f } from "../Icon/Icon.js";
@@ -9,7 +9,7 @@ import "../OverlayCloseButton/OverlayCloseButton.js";
 import "../GridRow/GridRow.js";
 import "../IconButton/IconButton.js";
 import "../Input/Input.js";
-import "../../MultiSelect-Drcfmp0z.js";
+import "../../MultiSelect-Blc_VDxu.js";
 import "../SelectListbox/SelectListbox.js";
 import "../SelectListbox/SelectProvider.js";
 const C = (t) => {

package/dist/components/MenuButton/MenuButton.d.ts

@@ -0,0 +1,13 @@
+import { PressEvent } from 'react-aria';
+import { AriaButtonProps } from '@react-aria/button';
+import { IconProps } from 'components/Icon';
+import { RefObject } from 'react';
+import { UIButtonVariant } from 'types/UserInterface';
+
+export interface MenuButtonProps extends AriaButtonProps<'button'> {
+    buttonRef: RefObject<HTMLButtonElement>;
+    variant: UIButtonVariant;
+    iconName?: IconProps['name'];
+    onClick?: (event: PressEvent) => void;
+}
+export declare function MenuButton({ buttonRef, variant, iconName, children, ...restProps }: MenuButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MenuButton/MenuButton.js

@@ -0,0 +1,621 @@
+import { jsxs as $e, jsx as Te } from "react/jsx-runtime";
+import { g as le, k as he, l as me, m as V, n as Ee, o as Ke, p as I, d as xe, f as ue, b as w, q as Se, a as F, r as ke, s as ee, c as z, $ as we, e as Oe, j as Ce } from "../../focusSafely-b94Glb9J.js";
+import { c as ce } from "../../clsx-OuTLNxxd.js";
+import fe, { useRef as J, useCallback as L, useEffect as Q, useState as _e, useMemo as Me, useContext as de } from "react";
+import { s as te } from "../../Button.module-DfLXeuUK.js";
+import { Icon as De } from "../Icon/Icon.js";
+function D(...t) {
+  let r = {
+    ...t[0]
+  };
+  for (let a = 1; a < t.length; a++) {
+    let i = t[a];
+    for (let o in i) {
+      let c = r[o], u = i[o];
+      typeof c == "function" && typeof u == "function" && // This is a lot faster than a regex.
+      o[0] === "o" && o[1] === "n" && o.charCodeAt(2) >= /* 'A' */
+      65 && o.charCodeAt(2) <= /* 'Z' */
+      90 ? r[o] = le(c, u) : (o === "className" || o === "UNSAFE_className") && typeof c == "string" && typeof u == "string" ? r[o] = ce(c, u) : o === "id" && c && u ? r.id = he(c, u) : r[o] = u !== void 0 ? u : c;
+    }
+  }
+  return r;
+}
+function U(t, r, a = !0) {
+  var i, o;
+  let { metaKey: c, ctrlKey: u, altKey: p, shiftKey: d } = r;
+  me() && (!((o = window.event) === null || o === void 0 || (i = o.type) === null || i === void 0) && i.startsWith("key")) && t.target === "_blank" && (V() ? c = !0 : u = !0);
+  let y = Ee() && V() && !Ke() ? new KeyboardEvent("keydown", {
+    keyIdentifier: "Enter",
+    metaKey: c,
+    ctrlKey: u,
+    altKey: p,
+    shiftKey: d
+  }) : new MouseEvent("click", {
+    metaKey: c,
+    ctrlKey: u,
+    altKey: p,
+    shiftKey: d,
+    bubbles: !0,
+    cancelable: !0
+  });
+  U.isOpening = a, I(t), t.dispatchEvent(y), U.isOpening = !1;
+}
+U.isOpening = !1;
+function Fe() {
+  let t = J(/* @__PURE__ */ new Map()), r = L((o, c, u, p) => {
+    let d = p != null && p.once ? (...y) => {
+      t.current.delete(u), u(...y);
+    } : u;
+    t.current.set(u, {
+      type: c,
+      eventTarget: o,
+      fn: d,
+      options: p
+    }), o.addEventListener(c, u, p);
+  }, []), a = L((o, c, u, p) => {
+    var d;
+    let y = ((d = t.current.get(u)) === null || d === void 0 ? void 0 : d.fn) || u;
+    o.removeEventListener(c, y, p), t.current.delete(u);
+  }, []), i = L(() => {
+    t.current.forEach((o, c) => {
+      a(o.eventTarget, o.type, c, o.options);
+    });
+  }, [
+    a
+  ]);
+  return Q(() => i, [
+    i
+  ]), {
+    addGlobalListener: r,
+    removeGlobalListener: a,
+    removeAllGlobalListeners: i
+  };
+}
+function pe(t, r) {
+  xe(() => {
+    if (t && t.ref && r)
+      return t.ref.current = r.current, () => {
+        t.ref && (t.ref.current = null);
+      };
+  });
+}
+let M = "default", q = "", H = /* @__PURE__ */ new WeakMap();
+function re(t) {
+  if (ue()) {
+    if (M === "default") {
+      const r = w(t);
+      q = r.documentElement.style.webkitUserSelect, r.documentElement.style.webkitUserSelect = "none";
+    }
+    M = "disabled";
+  } else (t instanceof HTMLElement || t instanceof SVGElement) && (H.set(t, t.style.userSelect), t.style.userSelect = "none");
+}
+function X(t) {
+  if (ue()) {
+    if (M !== "disabled") return;
+    M = "restoring", setTimeout(() => {
+      Se(() => {
+        if (M === "restoring") {
+          const r = w(t);
+          r.documentElement.style.webkitUserSelect === "none" && (r.documentElement.style.webkitUserSelect = q || ""), q = "", M = "default";
+        }
+      });
+    }, 300);
+  } else if ((t instanceof HTMLElement || t instanceof SVGElement) && t && H.has(t)) {
+    let r = H.get(t);
+    t.style.userSelect === "none" && (t.style.userSelect = r), t.getAttribute("style") === "" && t.removeAttribute("style"), H.delete(t);
+  }
+}
+const ge = fe.createContext({
+  register: () => {
+  }
+});
+ge.displayName = "PressResponderContext";
+function Ie(t, r) {
+  return r.get ? r.get.call(t) : r.value;
+}
+function ve(t, r, a) {
+  if (!r.has(t)) throw new TypeError("attempted to " + a + " private field on non-instance");
+  return r.get(t);
+}
+function Le(t, r) {
+  var a = ve(t, r, "get");
+  return Ie(t, a);
+}
+function Ue(t, r) {
+  if (r.has(t))
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function Ae(t, r, a) {
+  Ue(t, r), r.set(t, a);
+}
+function Ye(t, r, a) {
+  if (r.set) r.set.call(t, a);
+  else {
+    if (!r.writable)
+      throw new TypeError("attempted to set read only private field");
+    r.value = a;
+  }
+}
+function ne(t, r, a) {
+  var i = ve(t, r, "set");
+  return Ye(t, i, a), a;
+}
+function Xe(t) {
+  let r = de(ge);
+  if (r) {
+    let { register: a, ...i } = r;
+    t = D(i, t), a();
+  }
+  return pe(r, t.ref), t;
+}
+var G = /* @__PURE__ */ new WeakMap();
+class B {
+  continuePropagation() {
+    ne(this, G, !1);
+  }
+  get shouldStopPropagation() {
+    return Le(this, G);
+  }
+  constructor(r, a, i, o) {
+    Ae(this, G, {
+      writable: !0,
+      value: void 0
+    }), ne(this, G, !0);
+    var c;
+    let u = (c = o == null ? void 0 : o.target) !== null && c !== void 0 ? c : i.currentTarget;
+    const p = u == null ? void 0 : u.getBoundingClientRect();
+    let d, y = 0, b, O = null;
+    i.clientX != null && i.clientY != null && (b = i.clientX, O = i.clientY), p && (b != null && O != null ? (d = b - p.left, y = O - p.top) : (d = p.width / 2, y = p.height / 2)), this.type = r, this.pointerType = a, this.target = i.currentTarget, this.shiftKey = i.shiftKey, this.metaKey = i.metaKey, this.ctrlKey = i.ctrlKey, this.altKey = i.altKey, this.x = d, this.y = y;
+  }
+}
+const ae = Symbol("linkClicked");
+function Pe(t) {
+  let {
+    onPress: r,
+    onPressChange: a,
+    onPressStart: i,
+    onPressEnd: o,
+    onPressUp: c,
+    isDisabled: u,
+    isPressed: p,
+    preventFocusOnPress: d,
+    shouldCancelOnPointerExit: y,
+    allowTextSelectionOnPress: b,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ref: O,
+    ...R
+  } = Xe(t), [N, A] = _e(!1), m = J({
+    isPressed: !1,
+    ignoreEmulatedMouseEvents: !1,
+    ignoreClickAfterPress: !1,
+    didFirePressStart: !1,
+    isTriggeringEvent: !1,
+    activePointerId: null,
+    target: null,
+    isOverTarget: !1,
+    pointerType: null
+  }), { addGlobalListener: $, removeAllGlobalListeners: x } = Fe(), T = F((e, f) => {
+    let h = m.current;
+    if (u || h.didFirePressStart) return !1;
+    let l = !0;
+    if (h.isTriggeringEvent = !0, i) {
+      let g = new B("pressstart", f, e);
+      i(g), l = g.shouldStopPropagation;
+    }
+    return a && a(!0), h.isTriggeringEvent = !1, h.didFirePressStart = !0, A(!0), l;
+  }), P = F((e, f, h = !0) => {
+    let l = m.current;
+    if (!l.didFirePressStart) return !1;
+    l.ignoreClickAfterPress = !0, l.didFirePressStart = !1, l.isTriggeringEvent = !0;
+    let g = !0;
+    if (o) {
+      let n = new B("pressend", f, e);
+      o(n), g = n.shouldStopPropagation;
+    }
+    if (a && a(!1), A(!1), r && h && !u) {
+      let n = new B("press", f, e);
+      r(n), g && (g = n.shouldStopPropagation);
+    }
+    return l.isTriggeringEvent = !1, g;
+  }), S = F((e, f) => {
+    let h = m.current;
+    if (u) return !1;
+    if (c) {
+      h.isTriggeringEvent = !0;
+      let l = new B("pressup", f, e);
+      return c(l), h.isTriggeringEvent = !1, l.shouldStopPropagation;
+    }
+    return !0;
+  }), E = F((e) => {
+    let f = m.current;
+    f.isPressed && f.target && (f.isOverTarget && f.pointerType != null && P(K(f.target, e), f.pointerType, !1), f.isPressed = !1, f.isOverTarget = !1, f.activePointerId = null, f.pointerType = null, x(), b || X(f.target));
+  }), Y = F((e) => {
+    y && E(e);
+  }), be = Me(() => {
+    let e = m.current, f = {
+      onKeyDown(l) {
+        if (j(l.nativeEvent, l.currentTarget) && l.currentTarget.contains(l.target)) {
+          var g;
+          ie(l.target, l.key) && l.preventDefault();
+          let n = !0;
+          if (!e.isPressed && !l.repeat) {
+            e.target = l.currentTarget, e.isPressed = !0, n = T(l, "keyboard");
+            let s = l.currentTarget, v = (C) => {
+              j(C, s) && !C.repeat && s.contains(C.target) && e.target && S(K(e.target, C), "keyboard");
+            };
+            $(w(l.currentTarget), "keyup", le(v, h), !0);
+          }
+          n && l.stopPropagation(), l.metaKey && V() && ((g = e.metaKeyEvents) === null || g === void 0 || g.set(l.key, l.nativeEvent));
+        } else l.key === "Meta" && (e.metaKeyEvents = /* @__PURE__ */ new Map());
+      },
+      onClick(l) {
+        if (!(l && !l.currentTarget.contains(l.target)) && l && l.button === 0 && !e.isTriggeringEvent && !U.isOpening) {
+          let g = !0;
+          if (u && l.preventDefault(), !e.ignoreClickAfterPress && !e.ignoreEmulatedMouseEvents && !e.isPressed && (e.pointerType === "virtual" || ee(l.nativeEvent))) {
+            !u && !d && I(l.currentTarget);
+            let n = T(l, "virtual"), s = S(l, "virtual"), v = P(l, "virtual");
+            g = n && s && v;
+          }
+          e.ignoreEmulatedMouseEvents = !1, e.ignoreClickAfterPress = !1, g && l.stopPropagation();
+        }
+      }
+    }, h = (l) => {
+      var g;
+      if (e.isPressed && e.target && j(l, e.target)) {
+        var n;
+        ie(l.target, l.key) && l.preventDefault();
+        let v = l.target;
+        P(K(e.target, l), "keyboard", e.target.contains(v)), x(), l.key !== "Enter" && Z(e.target) && e.target.contains(v) && !l[ae] && (l[ae] = !0, U(e.target, l, !1)), e.isPressed = !1, (n = e.metaKeyEvents) === null || n === void 0 || n.delete(l.key);
+      } else if (l.key === "Meta" && (!((g = e.metaKeyEvents) === null || g === void 0) && g.size)) {
+        var s;
+        let v = e.metaKeyEvents;
+        e.metaKeyEvents = void 0;
+        for (let C of v.values()) (s = e.target) === null || s === void 0 || s.dispatchEvent(new KeyboardEvent("keyup", C));
+      }
+    };
+    if (typeof PointerEvent < "u") {
+      f.onPointerDown = (s) => {
+        if (s.button !== 0 || !s.currentTarget.contains(s.target)) return;
+        if (ke(s.nativeEvent)) {
+          e.pointerType = "virtual";
+          return;
+        }
+        W(s.currentTarget) && s.preventDefault(), e.pointerType = s.pointerType;
+        let v = !0;
+        e.isPressed || (e.isPressed = !0, e.isOverTarget = !0, e.activePointerId = s.pointerId, e.target = s.currentTarget, !u && !d && I(s.currentTarget), b || re(e.target), v = T(s, e.pointerType), $(w(s.currentTarget), "pointermove", l, !1), $(w(s.currentTarget), "pointerup", g, !1), $(w(s.currentTarget), "pointercancel", n, !1)), v && s.stopPropagation();
+      }, f.onMouseDown = (s) => {
+        s.currentTarget.contains(s.target) && s.button === 0 && (W(s.currentTarget) && s.preventDefault(), s.stopPropagation());
+      }, f.onPointerUp = (s) => {
+        !s.currentTarget.contains(s.target) || e.pointerType === "virtual" || s.button === 0 && _(s, s.currentTarget) && S(s, e.pointerType || s.pointerType);
+      };
+      let l = (s) => {
+        s.pointerId === e.activePointerId && (e.target && _(s, e.target) ? !e.isOverTarget && e.pointerType != null && (e.isOverTarget = !0, T(K(e.target, s), e.pointerType)) : e.target && e.isOverTarget && e.pointerType != null && (e.isOverTarget = !1, P(K(e.target, s), e.pointerType, !1), Y(s)));
+      }, g = (s) => {
+        s.pointerId === e.activePointerId && e.isPressed && s.button === 0 && e.target && (_(s, e.target) && e.pointerType != null ? P(K(e.target, s), e.pointerType) : e.isOverTarget && e.pointerType != null && P(K(e.target, s), e.pointerType, !1), e.isPressed = !1, e.isOverTarget = !1, e.activePointerId = null, e.pointerType = null, x(), b || X(e.target));
+      }, n = (s) => {
+        E(s);
+      };
+      f.onDragStart = (s) => {
+        s.currentTarget.contains(s.target) && E(s);
+      };
+    } else {
+      f.onMouseDown = (n) => {
+        if (n.button !== 0 || !n.currentTarget.contains(n.target)) return;
+        if (W(n.currentTarget) && n.preventDefault(), e.ignoreEmulatedMouseEvents) {
+          n.stopPropagation();
+          return;
+        }
+        e.isPressed = !0, e.isOverTarget = !0, e.target = n.currentTarget, e.pointerType = ee(n.nativeEvent) ? "virtual" : "mouse", !u && !d && I(n.currentTarget), T(n, e.pointerType) && n.stopPropagation(), $(w(n.currentTarget), "mouseup", l, !1);
+      }, f.onMouseEnter = (n) => {
+        if (!n.currentTarget.contains(n.target)) return;
+        let s = !0;
+        e.isPressed && !e.ignoreEmulatedMouseEvents && e.pointerType != null && (e.isOverTarget = !0, s = T(n, e.pointerType)), s && n.stopPropagation();
+      }, f.onMouseLeave = (n) => {
+        if (!n.currentTarget.contains(n.target)) return;
+        let s = !0;
+        e.isPressed && !e.ignoreEmulatedMouseEvents && e.pointerType != null && (e.isOverTarget = !1, s = P(n, e.pointerType, !1), Y(n)), s && n.stopPropagation();
+      }, f.onMouseUp = (n) => {
+        n.currentTarget.contains(n.target) && !e.ignoreEmulatedMouseEvents && n.button === 0 && S(n, e.pointerType || "mouse");
+      };
+      let l = (n) => {
+        if (n.button === 0) {
+          if (e.isPressed = !1, x(), e.ignoreEmulatedMouseEvents) {
+            e.ignoreEmulatedMouseEvents = !1;
+            return;
+          }
+          e.target && _(n, e.target) && e.pointerType != null ? P(K(e.target, n), e.pointerType) : e.target && e.isOverTarget && e.pointerType != null && P(K(e.target, n), e.pointerType, !1), e.isOverTarget = !1;
+        }
+      };
+      f.onTouchStart = (n) => {
+        if (!n.currentTarget.contains(n.target)) return;
+        let s = Ge(n.nativeEvent);
+        if (!s) return;
+        e.activePointerId = s.identifier, e.ignoreEmulatedMouseEvents = !0, e.isOverTarget = !0, e.isPressed = !0, e.target = n.currentTarget, e.pointerType = "touch", !u && !d && I(n.currentTarget), b || re(e.target), T(k(e.target, n), e.pointerType) && n.stopPropagation(), $(z(n.currentTarget), "scroll", g, !0);
+      }, f.onTouchMove = (n) => {
+        if (!n.currentTarget.contains(n.target)) return;
+        if (!e.isPressed) {
+          n.stopPropagation();
+          return;
+        }
+        let s = se(n.nativeEvent, e.activePointerId), v = !0;
+        s && _(s, n.currentTarget) ? !e.isOverTarget && e.pointerType != null && (e.isOverTarget = !0, v = T(k(e.target, n), e.pointerType)) : e.isOverTarget && e.pointerType != null && (e.isOverTarget = !1, v = P(k(e.target, n), e.pointerType, !1), Y(k(e.target, n))), v && n.stopPropagation();
+      }, f.onTouchEnd = (n) => {
+        if (!n.currentTarget.contains(n.target)) return;
+        if (!e.isPressed) {
+          n.stopPropagation();
+          return;
+        }
+        let s = se(n.nativeEvent, e.activePointerId), v = !0;
+        s && _(s, n.currentTarget) && e.pointerType != null ? (S(k(e.target, n), e.pointerType), v = P(k(e.target, n), e.pointerType)) : e.isOverTarget && e.pointerType != null && (v = P(k(e.target, n), e.pointerType, !1)), v && n.stopPropagation(), e.isPressed = !1, e.activePointerId = null, e.isOverTarget = !1, e.ignoreEmulatedMouseEvents = !0, e.target && !b && X(e.target), x();
+      }, f.onTouchCancel = (n) => {
+        n.currentTarget.contains(n.target) && (n.stopPropagation(), e.isPressed && E(k(e.target, n)));
+      };
+      let g = (n) => {
+        e.isPressed && n.target.contains(e.target) && E({
+          currentTarget: e.target,
+          shiftKey: !1,
+          ctrlKey: !1,
+          metaKey: !1,
+          altKey: !1
+        });
+      };
+      f.onDragStart = (n) => {
+        n.currentTarget.contains(n.target) && E(n);
+      };
+    }
+    return f;
+  }, [
+    $,
+    u,
+    d,
+    x,
+    b,
+    E,
+    Y,
+    P,
+    T,
+    S
+  ]);
+  return Q(() => () => {
+    var e;
+    b || X((e = m.current.target) !== null && e !== void 0 ? e : void 0);
+  }, [
+    b
+  ]), {
+    isPressed: p || N,
+    pressProps: D(R, be)
+  };
+}
+function Z(t) {
+  return t.tagName === "A" && t.hasAttribute("href");
+}
+function j(t, r) {
+  const { key: a, code: i } = t, o = r, c = o.getAttribute("role");
+  return (a === "Enter" || a === " " || a === "Spacebar" || i === "Space") && !(o instanceof z(o).HTMLInputElement && !ye(o, a) || o instanceof z(o).HTMLTextAreaElement || o.isContentEditable) && // Links should only trigger with Enter key
+  !((c === "link" || !c && Z(o)) && a !== "Enter");
+}
+function Ge(t) {
+  const { targetTouches: r } = t;
+  return r.length > 0 ? r[0] : null;
+}
+function se(t, r) {
+  const a = t.changedTouches;
+  for (let i = 0; i < a.length; i++) {
+    const o = a[i];
+    if (o.identifier === r) return o;
+  }
+  return null;
+}
+function k(t, r) {
+  let a = 0, i = 0;
+  return r.targetTouches && r.targetTouches.length === 1 && (a = r.targetTouches[0].clientX, i = r.targetTouches[0].clientY), {
+    currentTarget: t,
+    shiftKey: r.shiftKey,
+    ctrlKey: r.ctrlKey,
+    metaKey: r.metaKey,
+    altKey: r.altKey,
+    clientX: a,
+    clientY: i
+  };
+}
+function K(t, r) {
+  let a = r.clientX, i = r.clientY;
+  return {
+    currentTarget: t,
+    shiftKey: r.shiftKey,
+    ctrlKey: r.ctrlKey,
+    metaKey: r.metaKey,
+    altKey: r.altKey,
+    clientX: a,
+    clientY: i
+  };
+}
+function Be(t) {
+  let r = 0, a = 0;
+  return t.width !== void 0 ? r = t.width / 2 : t.radiusX !== void 0 && (r = t.radiusX), t.height !== void 0 ? a = t.height / 2 : t.radiusY !== void 0 && (a = t.radiusY), {
+    top: t.clientY - a,
+    right: t.clientX + r,
+    bottom: t.clientY + a,
+    left: t.clientX - r
+  };
+}
+function He(t, r) {
+  return !(t.left > r.right || r.left > t.right || t.top > r.bottom || r.top > t.bottom);
+}
+function _(t, r) {
+  let a = r.getBoundingClientRect(), i = Be(t);
+  return He(a, i);
+}
+function W(t) {
+  return !(t instanceof HTMLElement) || !t.hasAttribute("draggable");
+}
+function ie(t, r) {
+  return t instanceof HTMLInputElement ? !ye(t, r) : t instanceof HTMLButtonElement ? t.type !== "submit" && t.type !== "reset" : !Z(t);
+}
+const Re = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function ye(t, r) {
+  return t.type === "checkbox" || t.type === "radio" ? r === " " : Re.has(t.type);
+}
+function Ne(t) {
+  let { isDisabled: r, onFocus: a, onBlur: i, onFocusChange: o } = t;
+  const c = L((d) => {
+    if (d.target === d.currentTarget)
+      return i && i(d), o && o(!1), !0;
+  }, [
+    i,
+    o
+  ]), u = we(c), p = L((d) => {
+    const y = w(d.target);
+    d.target === d.currentTarget && y.activeElement === d.target && (a && a(d), o && o(!0), u(d));
+  }, [
+    o,
+    a,
+    u
+  ]);
+  return {
+    focusProps: {
+      onFocus: !r && (a || o || i) ? p : void 0,
+      onBlur: !r && (i || o) ? c : void 0
+    }
+  };
+}
+function oe(t) {
+  if (!t) return;
+  let r = !0;
+  return (a) => {
+    let i = {
+      ...a,
+      preventDefault() {
+        a.preventDefault();
+      },
+      isDefaultPrevented() {
+        return a.isDefaultPrevented();
+      },
+      stopPropagation() {
+        console.error("stopPropagation is now the default behavior for events in React Spectrum. You can use continuePropagation() to revert this behavior.");
+      },
+      continuePropagation() {
+        r = !1;
+      }
+    };
+    t(i), r && a.stopPropagation();
+  };
+}
+function je(t) {
+  return {
+    keyboardProps: t.isDisabled ? {} : {
+      onKeyDown: oe(t.onKeyDown),
+      onKeyUp: oe(t.onKeyUp)
+    }
+  };
+}
+let We = /* @__PURE__ */ fe.createContext(null);
+function Ve(t) {
+  let r = de(We) || {};
+  pe(r, t);
+  let { ref: a, ...i } = r;
+  return i;
+}
+function ze(t, r) {
+  let { focusProps: a } = Ne(t), { keyboardProps: i } = je(t), o = D(a, i), c = Ve(r), u = t.isDisabled ? {} : c, p = J(t.autoFocus);
+  return Q(() => {
+    p.current && r.current && Oe(r.current), p.current = !1;
+  }, [
+    r
+  ]), {
+    focusableProps: D({
+      ...o,
+      tabIndex: t.excludeFromTabOrder && !t.isDisabled ? -1 : void 0
+    }, u)
+  };
+}
+function qe(t, r) {
+  let {
+    elementType: a = "button",
+    isDisabled: i,
+    onPress: o,
+    onPressStart: c,
+    onPressEnd: u,
+    onPressUp: p,
+    onPressChange: d,
+    preventFocusOnPress: y,
+    allowFocusWhenDisabled: b,
+    // @ts-ignore
+    onClick: O,
+    href: R,
+    target: N,
+    rel: A,
+    type: m = "button"
+  } = t, $;
+  a === "button" ? $ = {
+    type: m,
+    disabled: i
+  } : $ = {
+    role: "button",
+    tabIndex: i ? void 0 : 0,
+    href: a === "a" && i ? void 0 : R,
+    target: a === "a" ? N : void 0,
+    type: a === "input" ? m : void 0,
+    disabled: a === "input" ? i : void 0,
+    "aria-disabled": !i || a === "input" ? void 0 : i,
+    rel: a === "a" ? A : void 0
+  };
+  let { pressProps: x, isPressed: T } = Pe({
+    onPressStart: c,
+    onPressEnd: u,
+    onPressChange: d,
+    onPress: o,
+    onPressUp: p,
+    isDisabled: i,
+    preventFocusOnPress: y,
+    ref: r
+  }), { focusableProps: P } = ze(t, r);
+  b && (P.tabIndex = i ? -1 : P.tabIndex);
+  let S = D(P, x, Ce(t, {
+    labelable: !0
+  }));
+  return {
+    isPressed: T,
+    buttonProps: D($, S, {
+      "aria-haspopup": t["aria-haspopup"],
+      "aria-expanded": t["aria-expanded"],
+      "aria-controls": t["aria-controls"],
+      "aria-pressed": t["aria-pressed"],
+      onClick: (E) => {
+        O && (O(E), console.warn("onClick is deprecated, please use onPress"));
+      }
+    })
+  };
+}
+function nt({ buttonRef: t, variant: r, iconName: a, children: i, ...o }) {
+  const { buttonProps: c } = qe(o, t), { pressProps: u } = Pe({
+    onPress: (p) => typeof o.onClick == "function" && o.onClick(p)
+  });
+  return /* @__PURE__ */ $e(
+    "button",
+    {
+      ...c,
+      ...u,
+      ref: t,
+      className: ce(te.button, te[`button--${r}`]),
+      children: [
+        i,
+        a && /* @__PURE__ */ Te(De, { name: a })
+      ]
+    }
+  );
+}
+export {
+  nt as MenuButton
+};
+//# sourceMappingURL=MenuButton.js.map