@als-tp/als-react-ts-ui 0.3.1 → 0.5.0

package/dist/als-react-ts-ui384.js

@@ -0,0 +1,183 @@
+import { flip as H, offset as I, size as J, hide as K, computePosition as N, shift as Q, limitShift as T } from "./als-react-ts-ui394.js";
+import { autoUpdate as ae, platform as de } from "./als-react-ts-ui394.js";
+import * as r from "react";
+import { useLayoutEffect as X } from "react";
+import * as Y from "react-dom";
+var Z = typeof document < "u", b = function() {
+}, R = Z ? X : b;
+function w(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, f, c;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (f = n; f-- !== 0; )
+        if (!w(e[f], t[f]))
+          return !1;
+      return !0;
+    }
+    if (c = Object.keys(e), n = c.length, n !== Object.keys(t).length)
+      return !1;
+    for (f = n; f-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, c[f]))
+        return !1;
+    for (f = n; f-- !== 0; ) {
+      const p = c[f];
+      if (!(p === "_owner" && e.$$typeof) && !w(e[p], t[p]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function L(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function z(e, t) {
+  const n = L(e);
+  return Math.round(t * n) / n;
+}
+function k(e) {
+  const t = r.useRef(e);
+  return R(() => {
+    t.current = e;
+  }), t;
+}
+function ne(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: f = [],
+    platform: c,
+    elements: {
+      reference: p,
+      floating: A
+    } = {},
+    transform: D = !0,
+    whileElementsMounted: E,
+    open: x
+  } = e, [s, C] = r.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [M, q] = r.useState(f);
+  w(M, f) || q(f);
+  const [B, U] = r.useState(null), [V, W] = r.useState(null), _ = r.useCallback((o) => {
+    o !== a.current && (a.current = o, U(o));
+  }, []), v = r.useCallback((o) => {
+    o !== d.current && (d.current = o, W(o));
+  }, []), i = p || B, u = A || V, a = r.useRef(null), d = r.useRef(null), y = r.useRef(s), G = E != null, S = k(E), P = k(c), F = k(x), g = r.useCallback(() => {
+    if (!a.current || !d.current)
+      return;
+    const o = {
+      placement: t,
+      strategy: n,
+      middleware: M
+    };
+    P.current && (o.platform = P.current), N(a.current, d.current, o).then((h) => {
+      const m = {
+        ...h,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: F.current !== !1
+      };
+      $.current && !w(y.current, m) && (y.current = m, Y.flushSync(() => {
+        C(m);
+      }));
+    });
+  }, [M, t, n, P, F]);
+  R(() => {
+    x === !1 && y.current.isPositioned && (y.current.isPositioned = !1, C((o) => ({
+      ...o,
+      isPositioned: !1
+    })));
+  }, [x]);
+  const $ = r.useRef(!1);
+  R(() => ($.current = !0, () => {
+    $.current = !1;
+  }), []), R(() => {
+    if (i && (a.current = i), u && (d.current = u), i && u) {
+      if (S.current)
+        return S.current(i, u, g);
+      g();
+    }
+  }, [i, u, g, S, G]);
+  const O = r.useMemo(() => ({
+    reference: a,
+    floating: d,
+    setReference: _,
+    setFloating: v
+  }), [_, v]), l = r.useMemo(() => ({
+    reference: i,
+    floating: u
+  }), [i, u]), j = r.useMemo(() => {
+    const o = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!l.floating)
+      return o;
+    const h = z(l.floating, s.x), m = z(l.floating, s.y);
+    return D ? {
+      ...o,
+      transform: "translate(" + h + "px, " + m + "px)",
+      ...L(l.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: h,
+      top: m
+    };
+  }, [n, D, l.floating, s.x, s.y]);
+  return r.useMemo(() => ({
+    ...s,
+    update: g,
+    refs: O,
+    elements: l,
+    floatingStyles: j
+  }), [s, g, O, l, j]);
+}
+const re = (e, t) => ({
+  ...I(e),
+  options: [e, t]
+}), oe = (e, t) => ({
+  ...Q(e),
+  options: [e, t]
+}), fe = (e, t) => ({
+  ...T(e),
+  options: [e, t]
+}), se = (e, t) => ({
+  ...H(e),
+  options: [e, t]
+}), ie = (e, t) => ({
+  ...J(e),
+  options: [e, t]
+}), ue = (e, t) => ({
+  ...K(e),
+  options: [e, t]
+});
+export {
+  ae as autoUpdate,
+  N as computePosition,
+  se as flip,
+  ue as hide,
+  fe as limitShift,
+  re as offset,
+  de as platform,
+  oe as shift,
+  ie as size,
+  ne as useFloating
+};

package/dist/als-react-ts-ui385.js

@@ -0,0 +1,38 @@
+import { isElement as s } from "./als-react-ts-ui339.js";
+import { useId as m } from "./als-react-ts-ui325.js";
+import { useRefWithInit as c } from "./als-react-ts-ui240.js";
+import { useIsoLayoutEffect as a } from "./als-react-ts-ui193.js";
+import { useFloatingParentNodeId as u } from "./als-react-ts-ui356.js";
+import { FloatingRootStore as g } from "./als-react-ts-ui386.js";
+import { PopupTriggerMap as p } from "./als-react-ts-ui334.js";
+function O(o) {
+  const {
+    open: r = !1,
+    onOpenChange: i,
+    elements: e = {}
+  } = o, f = m(), l = u() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const n = e.reference;
+    n && !s(n) && console.error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `context.setPositionReference()`", "instead.");
+  }
+  const t = c(() => new g({
+    open: r,
+    onOpenChange: i,
+    referenceElement: e.reference ?? null,
+    floatingElement: e.floating ?? null,
+    triggerElements: e.triggers ?? new p(),
+    floatingId: f,
+    nested: l,
+    noEmit: o.noEmit || !1
+  })).current;
+  return a(() => {
+    const n = {
+      open: r,
+      floatingId: f
+    };
+    e.reference !== void 0 && (n.referenceElement = e.reference, n.domReferenceElement = s(e.reference) ? e.reference : null), e.floating !== void 0 && (n.floatingElement = e.floating), t.update(n);
+  }, [r, f, e.reference, e.floating, t]), t.context.onOpenChange = i, t.context.nested = l, t.context.noEmit = o.noEmit || !1, t;
+}
+export {
+  O as useFloatingRootContext
+};

package/dist/als-react-ts-ui386.js

@@ -0,0 +1,57 @@
+import { createEventEmitter as s } from "./als-react-ts-ui382.js";
+import { ReactStore as f } from "./als-react-ts-ui333.js";
+import { createSelector as o } from "./als-react-ts-ui335.js";
+const a = {
+  open: o((e) => e.open),
+  domReferenceElement: o((e) => e.domReferenceElement),
+  referenceElement: o((e) => e.positionReference ?? e.referenceElement),
+  floatingElement: o((e) => e.floatingElement),
+  floatingId: o((e) => e.floatingId)
+};
+class g extends f {
+  constructor(n) {
+    const {
+      nested: t,
+      noEmit: r,
+      onOpenChange: i,
+      triggerElements: m,
+      ...c
+    } = n;
+    super({
+      ...c,
+      positionReference: c.referenceElement,
+      domReferenceElement: c.referenceElement
+    }, {
+      onOpenChange: i,
+      dataRef: {
+        current: {}
+      },
+      events: s(),
+      nested: t,
+      noEmit: r,
+      triggerElements: m
+    }, a);
+  }
+  /**
+   * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
+   *
+   * @param newOpen The new open state.
+   * @param eventDetails Details about the event that triggered the open state change.
+   */
+  setOpen = (n, t) => {
+    if (this.context.dataRef.current.openEvent = n ? t.event : void 0, !this.context.noEmit) {
+      const r = {
+        open: n,
+        reason: t.reason,
+        nativeEvent: t.event,
+        nested: this.context.nested,
+        triggerElement: t.trigger
+      };
+      this.context.events.emit("openchange", r);
+    }
+    this.context.onOpenChange?.(n, t);
+  };
+}
+export {
+  g as FloatingRootStore
+};

package/dist/als-react-ts-ui387.js

@@ -0,0 +1,78 @@
+import * as i from "react";
+import { getWindow as h, isElement as b, isHTMLElement as M } from "./als-react-ts-ui339.js";
+import { isMac as F, isSafari as D } from "./als-react-ts-ui371.js";
+import { useTimeout as k } from "./als-react-ts-ui195.js";
+import { createChangeEventDetails as R } from "./als-react-ts-ui246.js";
+import { createAttribute as O } from "./als-react-ts-ui376.js";
+import { activeElement as T, contains as w, getTarget as S, isTypeableElement as A, matchesFocusVisible as C, getDocument as x } from "./als-react-ts-ui331.js";
+import { triggerFocus as y, triggerPress as B, escapeKey as K } from "./als-react-ts-ui248.js";
+const g = F && D;
+function z(a, L = {}) {
+  const r = "rootStore" in a ? a.rootStore : a, {
+    events: f,
+    dataRef: E
+  } = r.context, {
+    enabled: o = !0,
+    visibleOnly: p = !0
+  } = L, s = i.useRef(!1), v = k(), m = i.useRef(!0);
+  i.useEffect(() => {
+    const t = r.select("domReferenceElement");
+    if (!o)
+      return;
+    const e = h(t);
+    function u() {
+      !r.select("open") && M(t) && t === T(x(t)) && (s.current = !0);
+    }
+    function c() {
+      m.current = !0;
+    }
+    function n() {
+      m.current = !1;
+    }
+    return e.addEventListener("blur", u), g && (e.addEventListener("keydown", c, !0), e.addEventListener("pointerdown", n, !0)), () => {
+      e.removeEventListener("blur", u), g && (e.removeEventListener("keydown", c, !0), e.removeEventListener("pointerdown", n, !0));
+    };
+  }, [r, o]), i.useEffect(() => {
+    if (!o)
+      return;
+    function t(e) {
+      (e.reason === B || e.reason === K) && (s.current = !0);
+    }
+    return f.on("openchange", t), () => {
+      f.off("openchange", t);
+    };
+  }, [f, o]);
+  const l = i.useMemo(() => ({
+    onMouseLeave() {
+      s.current = !1;
+    },
+    onFocus(t) {
+      if (s.current)
+        return;
+      const e = S(t.nativeEvent);
+      if (p && b(e)) {
+        if (g && !t.relatedTarget) {
+          if (!m.current && !A(e))
+            return;
+        } else if (!C(e))
+          return;
+      }
+      r.setOpen(!0, R(y, t.nativeEvent, t.currentTarget));
+    },
+    onBlur(t) {
+      s.current = !1;
+      const e = t.relatedTarget, u = t.nativeEvent, c = b(e) && e.hasAttribute(O("focus-guard")) && e.getAttribute("data-type") === "outside";
+      v.start(0, () => {
+        const n = r.select("domReferenceElement"), d = T(n ? n.ownerDocument : document);
+        !e && d === n || w(E.current.floatingContext?.refs.floating.current, d) || w(n, d) || c || r.context.triggerElements.hasElement(t.relatedTarget) || r.setOpen(!1, R(y, u));
+      });
+    }
+  }), [E, r, p, v]);
+  return i.useMemo(() => o ? {
+    reference: l,
+    trigger: l
+  } : {}, [o, l]);
+}
+export {
+  z as useFocus
+};

package/dist/als-react-ts-ui388.js

@@ -0,0 +1,32 @@
+import * as e from "react";
+import { useTimeout as l } from "./als-react-ts-ui195.js";
+import { createAttribute as m } from "./als-react-ts-ui376.js";
+import { TYPEABLE_SELECTOR as p } from "./als-react-ts-ui390.js";
+const S = m("safe-polygon"), v = `button,a,[role="button"],select,[tabindex]:not([tabindex="-1"]),${p}`;
+function T(t) {
+  return t ? !!t.closest(v) : !1;
+}
+function E(t) {
+  const o = e.useRef(void 0), s = e.useRef(!1), r = e.useRef(void 0), f = e.useRef(!0), i = e.useRef(!1), a = e.useRef(() => {
+  }), u = e.useRef(!1), c = l(), d = l(), R = e.useRef(void 0);
+  return e.useMemo(() => {
+    const n = t.context.dataRef.current;
+    return n.hoverInteractionState || (n.hoverInteractionState = {
+      pointerTypeRef: o,
+      interactedInsideRef: s,
+      handlerRef: r,
+      blockMouseMoveRef: f,
+      performedPointerEventsMutationRef: i,
+      unbindMouseMoveRef: a,
+      restTimeoutPendingRef: u,
+      openChangeTimeout: c,
+      restTimeout: d,
+      handleCloseOptionsRef: R
+    }), n.hoverInteractionState;
+  }, [t, o, s, r, f, i, a, u, c, d, R]);
+}
+export {
+  T as isInteractiveElement,
+  S as safePolygonIdentifier,
+  E as useHoverInteractionSharedState
+};

package/dist/als-react-ts-ui389.js

@@ -0,0 +1,200 @@
+import * as i from "react";
+import { isElement as ee } from "./als-react-ts-ui339.js";
+import { useTimeout as te } from "./als-react-ts-ui195.js";
+import { useValueAsRef as q } from "./als-react-ts-ui337.js";
+import { useStableCallback as D } from "./als-react-ts-ui192.js";
+import { useIsoLayoutEffect as ne } from "./als-react-ts-ui193.js";
+import { useFloatingTree as ce, useFloatingParentNodeId as fe } from "./als-react-ts-ui356.js";
+import { createChangeEventDetails as h } from "./als-react-ts-ui246.js";
+import { createAttribute as le } from "./als-react-ts-ui376.js";
+import { TYPEABLE_SELECTOR as ae } from "./als-react-ts-ui390.js";
+import { isMouseLikePointerType as K } from "./als-react-ts-ui295.js";
+import { getDocument as X, getTarget as me, contains as z } from "./als-react-ts-ui331.js";
+import { triggerHover as C } from "./als-react-ts-ui248.js";
+const re = le("safe-polygon"), de = `button,[role="button"],select,[tabindex]:not([tabindex="-1"]),${ae}`;
+function Ee(o) {
+  return o ? !!o.closest(de) : !1;
+}
+function G(o, w, n) {
+  if (n && !K(n))
+    return 0;
+  if (typeof o == "number")
+    return o;
+  if (typeof o == "function") {
+    const s = o();
+    return typeof s == "number" ? s : s?.[w];
+  }
+  return o?.[w];
+}
+function J(o) {
+  return typeof o == "function" ? o() : o;
+}
+function xe(o, w = {}) {
+  const n = "rootStore" in o ? o.rootStore : o, s = n.useState("open"), a = n.useState("floatingElement"), b = n.useState("domReferenceElement"), {
+    dataRef: p,
+    events: _
+  } = n.context, {
+    enabled: l = !0,
+    delay: oe = 0,
+    handleClose: se = null,
+    mouseOnly: A = !1,
+    restMs: ue = 0,
+    move: B = !0,
+    triggerElement: Q = null,
+    externalTree: ie
+  } = w, O = ce(ie), U = fe(), v = q(se), x = q(oe), P = q(ue), g = i.useRef(void 0), I = i.useRef(!1), f = te(), F = i.useRef(void 0), m = te(), N = i.useRef(!0), V = i.useRef(!1), W = i.useRef(() => {
+  }), S = i.useRef(!1), H = D(() => {
+    const t = p.current.openEvent?.type;
+    return t?.includes("mouse") && t !== "mousedown";
+  }), y = D(() => I.current ? !0 : p.current.openEvent ? ["click", "mousedown"].includes(p.current.openEvent.type) : !1);
+  i.useEffect(() => {
+    if (!l)
+      return;
+    function t(r) {
+      r.open || (f.clear(), m.clear(), N.current = !0, S.current = !1);
+    }
+    return _.on("openchange", t), () => {
+      _.off("openchange", t);
+    };
+  }, [l, _, f, m]), i.useEffect(() => {
+    if (!l || !v.current || !s)
+      return;
+    function t(u) {
+      y() || H() && n.setOpen(!1, h(C, u, u.currentTarget ?? void 0));
+    }
+    const r = X(a).documentElement;
+    return r.addEventListener("mouseleave", t), () => {
+      r.removeEventListener("mouseleave", t);
+    };
+  }, [a, s, n, l, v, H, y]);
+  const k = i.useCallback((t, r = !0) => {
+    const u = G(x.current, "close", g.current);
+    u && !F.current ? f.start(u, () => n.setOpen(!1, h(C, t))) : r && (f.clear(), n.setOpen(!1, h(C, t)));
+  }, [x, n, f]), R = D(() => {
+    W.current(), F.current = void 0;
+  }), d = D(() => {
+    if (V.current) {
+      const t = X(a).body;
+      t.style.pointerEvents = "", t.removeAttribute(re), V.current = !1;
+    }
+  }), $ = D((t) => {
+    const r = me(t);
+    if (!Ee(r)) {
+      I.current = !1;
+      return;
+    }
+    I.current = !0;
+  });
+  i.useEffect(() => {
+    if (!l)
+      return;
+    function t(e) {
+      if (f.clear(), N.current = !1, A && !K(g.current) || J(P.current) > 0 && !G(x.current, "open"))
+        return;
+      const M = G(x.current, "open", g.current), T = e.currentTarget ?? void 0, j = n.select("domReferenceElement"), Y = j && T && !z(j, T);
+      M ? f.start(M, () => {
+        n.select("open") || n.setOpen(!0, h(C, e, T));
+      }) : (!s || Y) && n.setOpen(!0, h(C, e, T));
+    }
+    function r(e) {
+      if (y()) {
+        d();
+        return;
+      }
+      W.current();
+      const M = X(a);
+      m.clear(), S.current = !1;
+      const T = n.context.triggerElements;
+      if (e.relatedTarget && T.hasElement(e.relatedTarget))
+        return;
+      if (v.current && p.current.floatingContext) {
+        s || f.clear(), F.current = v.current({
+          ...p.current.floatingContext,
+          tree: O,
+          x: e.clientX,
+          y: e.clientY,
+          onClose() {
+            d(), R(), y() || k(e, !0);
+          }
+        });
+        const Y = F.current;
+        M.addEventListener("mousemove", Y), W.current = () => {
+          M.removeEventListener("mousemove", Y);
+        };
+        return;
+      }
+      (g.current === "touch" ? !z(a, e.relatedTarget) : !0) && k(e);
+    }
+    function u(e) {
+      if (y() || !p.current.floatingContext)
+        return;
+      const M = n.context.triggerElements;
+      e.relatedTarget && M.hasElement(e.relatedTarget) || v.current?.({
+        ...p.current.floatingContext,
+        tree: O,
+        x: e.clientX,
+        y: e.clientY,
+        onClose() {
+          d(), R(), y() || k(e);
+        }
+      })(e);
+    }
+    function L() {
+      f.clear(), d();
+    }
+    function E(e) {
+      y() || k(e, !1);
+    }
+    const c = Q ?? b;
+    if (ee(c)) {
+      const e = a;
+      return s && c.addEventListener("mouseleave", u), B && c.addEventListener("mousemove", t, {
+        once: !0
+      }), c.addEventListener("mouseenter", t), c.addEventListener("mouseleave", r), e && (e.addEventListener("mouseleave", u), e.addEventListener("mouseenter", L), e.addEventListener("mouseleave", E), e.addEventListener("pointerdown", $, !0)), () => {
+        s && c.removeEventListener("mouseleave", u), B && c.removeEventListener("mousemove", t), c.removeEventListener("mouseenter", t), c.removeEventListener("mouseleave", r), e && (e.removeEventListener("mouseleave", u), e.removeEventListener("mouseenter", L), e.removeEventListener("mouseleave", E), e.removeEventListener("pointerdown", $, !0));
+      };
+    }
+  }, [l, A, B, b, a, Q, n, k, R, d, s, O, x, v, p, y, P, f, m, $]), ne(() => {
+    if (l && s && v.current?.__options?.blockPointerEvents && H()) {
+      V.current = !0;
+      const t = a;
+      if (ee(b) && t) {
+        const r = X(a).body;
+        r.setAttribute(re, "");
+        const u = b, L = O?.nodesRef.current.find((E) => E.id === U)?.context?.elements.floating;
+        return L && (L.style.pointerEvents = ""), r.style.pointerEvents = "none", u.style.pointerEvents = "auto", t.style.pointerEvents = "auto", () => {
+          r.style.pointerEvents = "", u.style.pointerEvents = "", t.style.pointerEvents = "";
+        };
+      }
+    }
+  }, [l, s, U, O, v, H, b, a]), ne(() => {
+    s || (g.current = void 0, S.current = !1, I.current = !1, R(), d());
+  }, [s, R, d]), i.useEffect(() => () => {
+    R(), f.clear(), m.clear(), I.current = !1;
+  }, [l, b, R, f, m]), i.useEffect(() => d, [d]);
+  const Z = i.useMemo(() => {
+    function t(r) {
+      g.current = r.pointerType;
+    }
+    return {
+      onPointerDown: t,
+      onPointerEnter: t,
+      onMouseMove(r) {
+        const {
+          nativeEvent: u
+        } = r, L = r.currentTarget, E = n.select("domReferenceElement") && !z(n.select("domReferenceElement"), r.target);
+        function c() {
+          !N.current && (!n.select("open") || E) && n.setOpen(!0, h(C, u, L));
+        }
+        A && !K(g.current) || n.select("open") && !E || J(P.current) === 0 || !E && S.current && r.movementX ** 2 + r.movementY ** 2 < 2 || (m.clear(), g.current === "touch" || E ? c() : (S.current = !0, m.start(J(P.current), c)));
+      }
+    };
+  }, [A, n, P, m]);
+  return i.useMemo(() => l ? {
+    reference: Z
+  } : {}, [l, Z]);
+}
+export {
+  G as getDelay,
+  xe as useHover
+};

package/dist/als-react-ts-ui39.js

@@ -0,0 +1,48 @@
+const e = "_root_l6s1z_10", _ = "_item_l6s1z_53", r = "_header_l6s1z_100", t = "_trigger_l6s1z_109", l = "_triggerContent_l6s1z_195", o = "_triggerIcon_l6s1z_201", s = "_chevronSvg_l6s1z_214", a = "_panel_l6s1z_222", n = "_panelContent_l6s1z_255", g = {
+  root: e,
+  "root--default": "_root--default_l6s1z_17",
+  "root--bordered": "_root--bordered_l6s1z_21",
+  "root--separated": "_root--separated_l6s1z_28",
+  "root--minimal": "_root--minimal_l6s1z_32",
+  "root--sm": "_root--sm_l6s1z_37",
+  "root--md": "_root--md_l6s1z_41",
+  "root--lg": "_root--lg_l6s1z_45",
+  item: _,
+  "item--default": "_item--default_l6s1z_60",
+  "item--bordered": "_item--bordered_l6s1z_68",
+  "item--separated": "_item--separated_l6s1z_76",
+  "item--minimal": "_item--minimal_l6s1z_82",
+  header: r,
+  trigger: t,
+  "trigger--default": "_trigger--default_l6s1z_142",
+  "trigger--bordered": "_trigger--bordered_l6s1z_150",
+  "trigger--separated": "_trigger--separated_l6s1z_158",
+  "trigger--minimal": "_trigger--minimal_l6s1z_167",
+  "trigger--sm": "_trigger--sm_l6s1z_179",
+  "trigger--md": "_trigger--md_l6s1z_184",
+  "trigger--lg": "_trigger--lg_l6s1z_189",
+  triggerContent: l,
+  triggerIcon: o,
+  chevronSvg: s,
+  panel: a,
+  "panel--default": "_panel--default_l6s1z_238",
+  "panel--bordered": "_panel--bordered_l6s1z_242",
+  "panel--separated": "_panel--separated_l6s1z_246",
+  "panel--minimal": "_panel--minimal_l6s1z_250",
+  panelContent: n,
+  "panel--sm": "_panel--sm_l6s1z_262",
+  "panel--md": "_panel--md_l6s1z_267",
+  "panel--lg": "_panel--lg_l6s1z_272"
+};
+export {
+  s as chevronSvg,
+  g as default,
+  r as header,
+  _ as item,
+  a as panel,
+  n as panelContent,
+  e as root,
+  t as trigger,
+  l as triggerContent,
+  o as triggerIcon
+};

package/dist/als-react-ts-ui390.js

@@ -0,0 +1,11 @@
+const t = "data-base-ui-focusable", e = "active", o = "selected", n = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])", s = "ArrowLeft", c = "ArrowRight", E = "ArrowUp", a = "ArrowDown";
+export {
+  e as ACTIVE_KEY,
+  a as ARROW_DOWN,
+  s as ARROW_LEFT,
+  c as ARROW_RIGHT,
+  E as ARROW_UP,
+  t as FOCUSABLE_ATTRIBUTE,
+  o as SELECTED_KEY,
+  n as TYPEABLE_SELECTOR
+};