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

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

@@ -0,0 +1,101 @@
+import * as a from "react";
+import { useControlled as B } from "./als-react-ts-ui282.js";
+import { useStableCallback as I } from "./als-react-ts-ui192.js";
+import { useBaseUiId as S } from "./als-react-ts-ui249.js";
+import { useRenderElement as T } from "./als-react-ts-ui189.js";
+import { CheckboxGroupContext as U } from "./als-react-ts-ui436.js";
+import { useFieldRootContext as Y } from "./als-react-ts-ui398.js";
+import { useLabelableContext as j } from "./als-react-ts-ui399.js";
+import { fieldValidityMapping as q } from "./als-react-ts-ui409.js";
+import { useField as H } from "./als-react-ts-ui403.js";
+import { PARENT_CHECKBOX as K } from "./als-react-ts-ui127.js";
+import { useCheckboxGroupParent as L } from "./als-react-ts-ui437.js";
+import { useFormContext as X } from "./als-react-ts-ui402.js";
+import { useValueChanged as z } from "./als-react-ts-ui406.js";
+import { areArraysEqual as J } from "./als-react-ts-ui438.js";
+import { jsx as Q } from "react/jsx-runtime";
+import { EMPTY_ARRAY as h } from "./als-react-ts-ui303.js";
+const W = /* @__PURE__ */ a.forwardRef(function(m, g) {
+  const {
+    allValues: s,
+    className: $,
+    defaultValue: n,
+    disabled: R = !1,
+    id: v,
+    onValueChange: d,
+    render: ee,
+    value: c,
+    ...k
+  } = m, {
+    disabled: y,
+    name: l,
+    state: p,
+    validation: o,
+    setFilled: A,
+    setDirty: E,
+    shouldValidateOnChange: P,
+    validityData: f
+  } = Y(), {
+    labelId: G,
+    getDescriptionProps: N
+  } = j(), {
+    clearErrors: M
+  } = X(), i = y || R, [t, D] = B({
+    controlled: c,
+    default: n,
+    name: "CheckboxGroup",
+    state: "value"
+  }), b = I((e, x) => {
+    d?.(e, x), !x.isCanceled && D(e);
+  }), C = L({
+    allValues: s,
+    value: c,
+    onValueChange: d
+  }), F = S(v), u = a.useRef(null), V = a.useCallback((e) => {
+    u.current == null && e != null && !e.hasAttribute(K) && (u.current = e);
+  }, []);
+  H({
+    enabled: !!l,
+    id: F,
+    commit: o.commit,
+    value: t,
+    controlRef: u,
+    name: l,
+    getValue: () => t
+  });
+  const r = t ?? h;
+  z(r, () => {
+    l && M(l);
+    const e = Array.isArray(f.initialValue) ? f.initialValue : h;
+    A(r.length > 0), E(!J(r, e)), P() ? o.commit(r) : o.commit(r, !0);
+  });
+  const O = a.useMemo(() => ({
+    ...p,
+    disabled: i
+  }), [p, i]), _ = a.useMemo(() => ({
+    allValues: s,
+    value: t,
+    defaultValue: n,
+    setValue: b,
+    parent: C,
+    disabled: i,
+    validation: o,
+    registerControlRef: V
+  }), [s, t, n, b, C, i, o, V]), w = T("div", m, {
+    state: O,
+    ref: g,
+    props: [{
+      role: "group",
+      "aria-labelledby": G
+    }, N, k],
+    stateAttributesMapping: q
+  });
+  return /* @__PURE__ */ Q(U.Provider, {
+    value: _,
+    children: w
+  });
+});
+process.env.NODE_ENV !== "production" && (W.displayName = "CheckboxGroup");
+export {
+  W as CheckboxGroup
+};

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

@@ -0,0 +1,35 @@
+const o = "_trigger_d816n_2", r = "_backdrop_d816n_9", t = "_positioner_d816n_17", _ = "_popup_d816n_23", n = "_arrow_d816n_49", e = "_item_d816n_59", c = "_separator_d816n_89", d = "_group_d816n_96", a = "_groupLabel_d816n_100", i = "_radioGroup_d816n_110", p = "_radioItem_d816n_114", s = "_radioItemIndicator_d816n_139", u = "_checkboxItem_d816n_152", g = "_checkboxItemIndicator_d816n_177", m = "_submenuTrigger_d816n_191", I = {
+  trigger: o,
+  backdrop: r,
+  positioner: t,
+  popup: _,
+  arrow: n,
+  item: e,
+  separator: c,
+  group: d,
+  groupLabel: a,
+  radioGroup: i,
+  radioItem: p,
+  radioItemIndicator: s,
+  checkboxItem: u,
+  checkboxItemIndicator: g,
+  submenuTrigger: m
+};
+export {
+  n as arrow,
+  r as backdrop,
+  u as checkboxItem,
+  g as checkboxItemIndicator,
+  I as default,
+  d as group,
+  a as groupLabel,
+  e as item,
+  _ as popup,
+  t as positioner,
+  i as radioGroup,
+  p as radioItem,
+  s as radioItemIndicator,
+  c as separator,
+  m as submenuTrigger,
+  o as trigger
+};

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

@@ -0,0 +1,40 @@
+import * as e from "react";
+import { useId as a } from "./als-react-ts-ui325.js";
+import { ContextMenuRootContext as d } from "./als-react-ts-ui464.js";
+import { MenuRootContext as p } from "./als-react-ts-ui465.js";
+import { jsx as o } from "react/jsx-runtime";
+import { MenuRoot as x } from "./als-react-ts-ui198.js";
+function P(r) {
+  const [t, u] = e.useState({
+    getBoundingClientRect() {
+      return DOMRect.fromRect({
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      });
+    }
+  }), i = e.useRef(null), s = e.useRef(null), c = e.useRef(null), f = e.useRef(null), l = e.useRef(!0), R = e.useRef(null), n = a(), m = e.useMemo(() => ({
+    anchor: t,
+    setAnchor: u,
+    actionsRef: c,
+    backdropRef: i,
+    internalBackdropRef: s,
+    positionerRef: f,
+    allowMouseUpTriggerRef: l,
+    initialCursorPointRef: R,
+    rootId: n
+  }), [t, n]);
+  return /* @__PURE__ */ o(d.Provider, {
+    value: m,
+    children: /* @__PURE__ */ o(p.Provider, {
+      value: void 0,
+      children: /* @__PURE__ */ o(x, {
+        ...r
+      })
+    })
+  });
+}
+export {
+  P as ContextMenuRoot
+};

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

@@ -0,0 +1,112 @@
+import * as c from "react";
+import { ownerDocument as x } from "./als-react-ts-ui372.js";
+import { useTimeout as C } from "./als-react-ts-ui195.js";
+import { useContextMenuRootContext as k } from "./als-react-ts-ui464.js";
+import { useMenuRootContext as A } from "./als-react-ts-ui465.js";
+import { useRenderElement as _ } from "./als-react-ts-ui189.js";
+import { createChangeEventDetails as O } from "./als-react-ts-ui246.js";
+import { pressableTriggerOpenStateMapping as B } from "./als-react-ts-ui244.js";
+import { findRootOwnerId as I } from "./als-react-ts-ui466.js";
+import { getTarget as v, contains as l } from "./als-react-ts-ui331.js";
+import { stopEvent as W } from "./als-react-ts-ui295.js";
+import { cancelOpen as G, triggerPress as V } from "./als-react-ts-ui248.js";
+const w = 500, j = /* @__PURE__ */ c.forwardRef(function(m, D) {
+  const {
+    render: z,
+    className: F,
+    ...P
+  } = m, {
+    setAnchor: S,
+    actionsRef: p,
+    internalBackdropRef: h,
+    backdropRef: d,
+    positionerRef: b,
+    allowMouseUpTriggerRef: f,
+    initialCursorPointRef: L,
+    rootId: g
+  } = k(!1), {
+    store: y
+  } = A(!1), R = y.useState("open"), s = c.useRef(null), o = c.useRef(null), i = C(), T = C(), a = c.useRef(!1);
+  function M(e, t, n) {
+    const r = n.type.startsWith("touch");
+    L.current = {
+      x: e,
+      y: t
+    }, S({
+      getBoundingClientRect() {
+        return DOMRect.fromRect({
+          width: r ? 10 : 0,
+          height: r ? 10 : 0,
+          x: e,
+          y: t
+        });
+      }
+    }), a.current = !1, p.current?.setOpen(!0, O(V, n)), T.start(w, () => {
+      a.current = !0;
+    });
+  }
+  function N(e) {
+    f.current = !0, W(e), M(e.clientX, e.clientY, e.nativeEvent), x(s.current).addEventListener("mouseup", (n) => {
+      if (f.current = !1, !a.current)
+        return;
+      T.clear(), a.current = !1;
+      const r = v(n);
+      l(b.current, r) || g && r && I(r) === g || p.current?.setOpen(!1, O(G, n));
+    }, {
+      once: !0
+    });
+  }
+  function Y(e) {
+    if (f.current = !1, e.touches.length === 1) {
+      e.stopPropagation();
+      const t = e.touches[0];
+      o.current = {
+        x: t.clientX,
+        y: t.clientY
+      }, i.start(w, () => {
+        o.current && M(o.current.x, o.current.y, e.nativeEvent);
+      });
+    }
+  }
+  function U(e) {
+    if (i.isStarted() && o.current && e.touches.length === 1) {
+      const t = e.touches[0], n = 10, r = Math.abs(t.clientX - o.current.x), u = Math.abs(t.clientY - o.current.y);
+      (r > n || u > n) && i.clear();
+    }
+  }
+  function E() {
+    i.clear(), o.current = null;
+  }
+  c.useEffect(() => {
+    function e(n) {
+      const u = v(n);
+      (l(s.current, u) || l(h.current, u) || l(d.current, u)) && n.preventDefault();
+    }
+    const t = x(s.current);
+    return t.addEventListener("contextmenu", e), () => {
+      t.removeEventListener("contextmenu", e);
+    };
+  }, [d, h]);
+  const X = c.useMemo(() => ({
+    open: R
+  }), [R]);
+  return _("div", m, {
+    state: X,
+    ref: [s, D],
+    props: [{
+      onContextMenu: N,
+      onTouchStart: Y,
+      onTouchMove: U,
+      onTouchEnd: E,
+      onTouchCancel: E,
+      style: {
+        WebkitTouchCallout: "none"
+      }
+    }, P],
+    stateAttributesMapping: B
+  });
+});
+process.env.NODE_ENV !== "production" && (j.displayName = "ContextMenuTrigger");
+export {
+  j as ContextMenuTrigger
+};

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

@@ -0,0 +1,16 @@
+import { ALSFormRow as o, ALSFormGroup as r, ALSFormActions as m, ALSFormDescription as t, ALSFormError as A, ALSFormTextarea as F, ALSFormControl as L, ALSFormLabel as e, ALSFormField as S, ALSFormRoot as i } from "./als-react-ts-ui71.js";
+const a = {
+  Root: i,
+  Field: S,
+  Label: e,
+  Control: L,
+  Textarea: F,
+  Error: A,
+  Description: t,
+  Actions: m,
+  Group: r,
+  Row: o
+};
+export {
+  a as ALSForm
+};

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

@@ -0,0 +1,40 @@
+import * as a from "react";
+import { useMenuRootContext as m } from "./als-react-ts-ui465.js";
+import { useRenderElement as d } from "./als-react-ts-ui189.js";
+import { popupStateMapping as f } from "./als-react-ts-ui244.js";
+import { transitionStatusMapping as l } from "./als-react-ts-ui245.js";
+import { useContextMenuRootContext as M } from "./als-react-ts-ui464.js";
+import { triggerHover as S } from "./als-react-ts-ui248.js";
+const R = {
+  ...f,
+  ...l
+}, g = /* @__PURE__ */ a.forwardRef(function(e, o) {
+  const {
+    className: x,
+    render: C,
+    ...p
+  } = e, {
+    store: t
+  } = m(), n = t.useState("open"), i = t.useState("mounted"), s = t.useState("transitionStatus"), u = t.useState("lastOpenChangeReason"), r = M(), c = a.useMemo(() => ({
+    open: n,
+    transitionStatus: s
+  }), [n, s]);
+  return d("div", e, {
+    ref: r?.backdropRef ? [o, r.backdropRef] : o,
+    state: c,
+    stateAttributesMapping: R,
+    props: [{
+      role: "presentation",
+      hidden: !i,
+      style: {
+        pointerEvents: u === S ? "none" : void 0,
+        userSelect: "none",
+        WebkitUserSelect: "none"
+      }
+    }, p]
+  });
+});
+process.env.NODE_ENV !== "production" && (g.displayName = "MenuBackdrop");
+export {
+  g as MenuBackdrop
+};

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

@@ -0,0 +1,145 @@
+import * as d from "react";
+import { inertValue as Q } from "./als-react-ts-ui256.js";
+import { MenuPositionerContext as X } from "./als-react-ts-ui468.js";
+import { useMenuRootContext as Y } from "./als-react-ts-ui465.js";
+import { useAnchorPositioning as Z } from "./als-react-ts-ui364.js";
+import { useRenderElement as $ } from "./als-react-ts-ui189.js";
+import { popupStateMapping as ee } from "./als-react-ts-ui244.js";
+import { CompositeList as te } from "./als-react-ts-ui284.js";
+import { InternalBackdrop as ne } from "./als-react-ts-ui257.js";
+import { useMenuPortalContext as oe } from "./als-react-ts-ui467.js";
+import { DROPDOWN_COLLISION_AVOIDANCE as re } from "./als-react-ts-ui260.js";
+import { useContextMenuRootContext as se } from "./als-react-ts-ui464.js";
+import { createChangeEventDetails as x } from "./als-react-ts-ui246.js";
+import { jsxs as ie, jsx as I } from "react/jsx-runtime";
+import { FloatingNode as ae } from "./als-react-ts-ui356.js";
+import { triggerHover as de, siblingOpen as g } from "./als-react-ts-ui248.js";
+const le = /* @__PURE__ */ d.forwardRef(function(c, C) {
+  const {
+    anchor: v,
+    positionMethod: M = "absolute",
+    className: ce,
+    render: pe,
+    side: y,
+    align: E,
+    sideOffset: b = 0,
+    alignOffset: w = 0,
+    collisionBoundary: A = "clipping-ancestors",
+    collisionPadding: k = 5,
+    arrowPadding: D = 5,
+    sticky: H = !1,
+    disableAnchorTracking: T = !1,
+    collisionAvoidance: B = re,
+    ...L
+  } = c, {
+    store: e
+  } = Y(), V = oe(), U = se(!0), n = e.useState("parent"), _ = e.useState("floatingRootContext"), s = e.useState("floatingTreeRoot"), p = e.useState("mounted"), i = e.useState("open"), j = e.useState("modal"), u = e.useState("activeTriggerElement"), F = e.useState("lastOpenChangeReason"), a = e.useState("floatingNodeId"), O = e.useState("floatingParentNodeId");
+  let P = v, S = b, N = w, m = E;
+  n.type === "context-menu" && (P = v ?? n.context?.anchor, m = m ?? "start", !y && m !== "center" && (N = c.alignOffset ?? 2, S = c.sideOffset ?? -5));
+  let l = y, f = m;
+  n.type === "menu" ? (l = l ?? "inline-end", f = f ?? "start") : n.type === "menubar" && (l = l ?? "bottom", f = f ?? "start");
+  const R = n.type === "context-menu", t = Z({
+    anchor: P,
+    floatingRootContext: _,
+    positionMethod: U ? "fixed" : M,
+    mounted: p,
+    side: l,
+    sideOffset: S,
+    align: f,
+    alignOffset: N,
+    arrowPadding: R ? 0 : D,
+    collisionBoundary: A,
+    collisionPadding: k,
+    sticky: H,
+    nodeId: a,
+    keepMounted: V,
+    disableAnchorTracking: T,
+    collisionAvoidance: B,
+    shiftCrossAxis: R,
+    externalTree: s
+  }), W = d.useMemo(() => {
+    const r = {};
+    return i || (r.pointerEvents = "none"), {
+      role: "presentation",
+      hidden: !p,
+      style: {
+        ...t.positionerStyles,
+        ...r
+      }
+    };
+  }, [i, p, t.positionerStyles]);
+  d.useEffect(() => {
+    function r(o) {
+      o.open ? (o.parentNodeId === a && e.set("hoverEnabled", !1), o.nodeId !== a && o.parentNodeId === e.select("floatingParentNodeId") && e.setOpen(!1, x(g))) : o.parentNodeId === a && o.reason !== g && e.set("hoverEnabled", !0);
+    }
+    return s.events.on("menuopenchange", r), () => {
+      s.events.off("menuopenchange", r);
+    };
+  }, [e, s.events, a]), d.useEffect(() => {
+    if (e.select("floatingParentNodeId") == null)
+      return;
+    function r(o) {
+      if (o.open || o.nodeId !== e.select("floatingParentNodeId"))
+        return;
+      const K = o.reason ?? g;
+      e.setOpen(!1, x(K));
+    }
+    return s.events.on("menuopenchange", r), () => {
+      s.events.off("menuopenchange", r);
+    };
+  }, [s.events, e]), d.useEffect(() => {
+    function r(o) {
+      !i || o.nodeId !== e.select("floatingParentNodeId") || o.target && u && u !== o.target && e.setOpen(!1, x(g));
+    }
+    return s.events.on("itemhover", r), () => {
+      s.events.off("itemhover", r);
+    };
+  }, [s.events, i, u, e]), d.useEffect(() => {
+    const r = {
+      open: i,
+      nodeId: a,
+      parentNodeId: O,
+      reason: e.select("lastOpenChangeReason")
+    };
+    s.events.emit("menuopenchange", r);
+  }, [s.events, i, e, a, O]);
+  const q = d.useMemo(() => ({
+    open: i,
+    side: t.side,
+    align: t.align,
+    anchorHidden: t.anchorHidden,
+    nested: n.type === "menu"
+  }), [i, t.side, t.align, t.anchorHidden, n.type]), z = d.useMemo(() => ({
+    side: t.side,
+    align: t.align,
+    arrowRef: t.arrowRef,
+    arrowUncentered: t.arrowUncentered,
+    arrowStyles: t.arrowStyles,
+    nodeId: t.context.nodeId
+  }), [t.side, t.align, t.arrowRef, t.arrowUncentered, t.arrowStyles, t.context.nodeId]), G = $("div", c, {
+    state: q,
+    stateAttributesMapping: ee,
+    ref: [C, e.useStateSetter("positionerElement")],
+    props: [W, L]
+  }), J = p && n.type !== "menu" && (n.type !== "menubar" && j && F !== de || n.type === "menubar" && n.context.modal);
+  let h = null;
+  return n.type === "menubar" ? h = n.context.contentElement : n.type === void 0 && (h = u), /* @__PURE__ */ ie(X.Provider, {
+    value: z,
+    children: [J && /* @__PURE__ */ I(ne, {
+      ref: n.type === "context-menu" || n.type === "nested-context-menu" ? n.context.internalBackdropRef : null,
+      inert: Q(!i),
+      cutout: h
+    }), /* @__PURE__ */ I(ae, {
+      id: a,
+      children: /* @__PURE__ */ I(te, {
+        elementsRef: e.context.itemDomElements,
+        labelsRef: e.context.itemLabels,
+        children: G
+      })
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (le.displayName = "MenuPositioner");
+export {
+  le as MenuPositioner
+};

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

@@ -0,0 +1,87 @@
+import * as a from "react";
+import { useMenuRootContext as O } from "./als-react-ts-ui465.js";
+import { useMenuPositionerContext as D } from "./als-react-ts-ui468.js";
+import { useRenderElement as I } from "./als-react-ts-ui189.js";
+import { popupStateMapping as N } from "./als-react-ts-ui244.js";
+import { transitionStatusMapping as w } from "./als-react-ts-ui245.js";
+import { useOpenChangeComplete as G } from "./als-react-ts-ui253.js";
+import { createChangeEventDetails as K } from "./als-react-ts-ui246.js";
+import { useToolbarRootContext as _ } from "./als-react-ts-ui368.js";
+import { COMPOSITE_KEYS as j } from "./als-react-ts-ui254.js";
+import { getDisabledMountTransitionStyles as k } from "./als-react-ts-ui366.js";
+import { jsx as A } from "react/jsx-runtime";
+import { useHoverFloatingInteraction as H } from "./als-react-ts-ui369.js";
+import { FloatingFocusManager as V } from "./als-react-ts-ui255.js";
+import { outsidePress as Y } from "./als-react-ts-ui248.js";
+const q = {
+  ...N,
+  ...w
+}, z = /* @__PURE__ */ a.forwardRef(function(u, g) {
+  const {
+    render: J,
+    className: L,
+    finalFocus: i,
+    ...S
+  } = u, {
+    store: e
+  } = O(), {
+    side: p,
+    align: c
+  } = D(), y = _(!0) != null, n = e.useState("open"), r = e.useState("transitionStatus"), b = e.useState("popupProps"), x = e.useState("mounted"), m = e.useState("instantType"), C = e.useState("activeTriggerElement"), t = e.useState("parent"), E = e.useState("lastOpenChangeReason"), R = e.useState("rootId"), l = e.useState("floatingRootContext"), s = e.useState("floatingTreeRoot"), F = e.useState("closeDelay"), T = e.useState("activeTriggerElement");
+  G({
+    open: n,
+    ref: e.context.popupRef,
+    onComplete() {
+      n && e.context.onOpenChangeComplete?.(!0);
+    }
+  }), a.useEffect(() => {
+    function o(d) {
+      e.setOpen(!1, K(d.reason, d.domEvent));
+    }
+    return s.events.on("close", o), () => {
+      s.events.off("close", o);
+    };
+  }, [s.events, e]);
+  const v = e.useState("hoverEnabled"), M = e.useState("disabled");
+  H(l, {
+    enabled: v && !M && t.type !== "context-menu" && t.type !== "menubar",
+    closeDelay: F
+  });
+  const h = a.useMemo(() => ({
+    transitionStatus: r,
+    side: p,
+    align: c,
+    open: n,
+    nested: t.type === "menu",
+    instant: m
+  }), [r, p, c, n, t.type, m]), P = I("div", u, {
+    state: h,
+    ref: [g, e.context.popupRef],
+    stateAttributesMapping: q,
+    props: [b, {
+      onKeyDown(o) {
+        y && j.has(o.key) && o.stopPropagation();
+      }
+    }, k(r), S, {
+      "data-rootownerid": R
+    }]
+  });
+  let f = t.type === void 0 || t.type === "context-menu";
+  return (C || t.type === "menubar" && E !== Y) && (f = !0), /* @__PURE__ */ A(V, {
+    context: l,
+    modal: !1,
+    disabled: !x,
+    returnFocus: i === void 0 ? f : i,
+    initialFocus: t.type !== "menu",
+    restoreFocus: !0,
+    externalTree: t.type !== "menubar" ? s : void 0,
+    previousFocusableElement: T,
+    nextFocusableElement: t.type === void 0 ? e.context.triggerFocusTargetRef : void 0,
+    beforeContentFocusGuardRef: t.type === void 0 ? e.context.beforeContentFocusGuardRef : void 0,
+    children: P
+  });
+});
+process.env.NODE_ENV !== "production" && (z.displayName = "MenuPopup");
+export {
+  z as MenuPopup
+};

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

@@ -0,0 +1,39 @@
+import * as s from "react";
+import { useMenuPositionerContext as d } from "./als-react-ts-ui468.js";
+import { useMenuRootContext as f } from "./als-react-ts-ui465.js";
+import { useRenderElement as M } from "./als-react-ts-ui189.js";
+import { popupStateMapping as l } from "./als-react-ts-ui244.js";
+const w = /* @__PURE__ */ s.forwardRef(function(e, a) {
+  const {
+    className: A,
+    render: N,
+    ...i
+  } = e, {
+    store: p
+  } = f(), {
+    arrowRef: u,
+    side: r,
+    align: t,
+    arrowUncentered: o,
+    arrowStyles: m
+  } = d(), n = p.useState("open"), c = s.useMemo(() => ({
+    open: n,
+    side: r,
+    align: t,
+    uncentered: o
+  }), [n, r, t, o]);
+  return M("div", e, {
+    ref: [u, a],
+    stateAttributesMapping: l,
+    state: c,
+    props: {
+      style: m,
+      "aria-hidden": !0,
+      ...i
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (w.displayName = "MenuArrow");
+export {
+  w as MenuArrow
+};

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

@@ -0,0 +1,47 @@
+import * as i from "react";
+import { useMenuItem as P, REGULAR_ITEM as x } from "./als-react-ts-ui470.js";
+import { useMenuRootContext as C } from "./als-react-ts-ui465.js";
+import { useRenderElement as E } from "./als-react-ts-ui189.js";
+import { useBaseUiId as v } from "./als-react-ts-ui249.js";
+import { useCompositeListItem as N } from "./als-react-ts-ui290.js";
+import { useMenuPositionerContext as g } from "./als-react-ts-ui468.js";
+const h = /* @__PURE__ */ i.forwardRef(function(s, n) {
+  const {
+    render: A,
+    className: B,
+    id: m,
+    label: u,
+    nativeButton: a = !1,
+    disabled: e = !1,
+    closeOnClick: d = !0,
+    ...c
+  } = s, r = N({
+    label: u
+  }), p = g(!0), f = v(m), {
+    store: t
+  } = C(), o = t.useState("isActive", r.index), l = t.useState("itemProps"), {
+    getItemProps: I,
+    itemRef: M
+  } = P({
+    closeOnClick: d,
+    disabled: e,
+    highlighted: o,
+    id: f,
+    store: t,
+    nativeButton: a,
+    nodeId: p?.nodeId,
+    itemMetadata: x
+  }), R = i.useMemo(() => ({
+    disabled: e,
+    highlighted: o
+  }), [e, o]);
+  return E("div", s, {
+    state: R,
+    props: [l, c, I],
+    ref: [M, n, r.ref]
+  });
+});
+process.env.NODE_ENV !== "production" && (h.displayName = "MenuItem");
+export {
+  h as MenuItem
+};